Simplepkg: gerenciamento de instalações e pacotes ------------------------------------------------- Autor: Silvio Rhatto Licença: GPL O simplepkg é um sistema de gerenciamento de sistemas slackware que roda sobre o pkgtool. Ele é composto por vários scripts que desempenham funções de administração e desenvolvimento de sistemas do tipo Slackware, procurando fechar um circuito de produção, envolvendo a construção, a instalação de pacotes e até mesmo a instalação do sistema de forma automatizada. Do lado do desenvolvedor/a, ele ajuda na criação de SlackBuilds e construção de pacotes. Do lado do administrador/a, ele possibilita a instalação automatizada de sistemas, instalação de pacotes e a criação de "templates" de instalação -- que contém todos os arquivos de configuração, informações de permissões e scripts de pós-instalação de uma dada máquina ou jaula. Documentação ------------ A documentação mais atualizada do simplepkg está em http://slack.sarava.org/simplepkg. Descrição --------- Todas as distribuições de GNU/Linux já tem algum sistema de empacotamento amadurecido. A questão agora é a praticidade de instalar e controlar o que está instalado, tanto pacotes como arquivos de configuração de uma máquina, além da facilidade na criação de pacotes. Imagine por exemplo se você precisa manter uma lista de pacotes de 200 máquinas slackware, sendo que algumas são usadas como desktop, outras como servidores web, alguma sendo o servidor de email e assim por diante. Imagine agora que você perca o disco de algumas dessas máquinas ou que precise cotidianamente reinstalar ou atualizar um sistema. Usar o cd de instalação do slackware e configurar na mão toda a vez que der um pau faria com que você ficasse louco/a e desperdiçasse muito tempo, além do que sempre ocorre de esquecermos algum detalhe ou pacote durante a configuração do sistema. Manter um backup completo de cada máquina, por outro lado, pode ser muito custoso se o número delas for muito grande. O simplepkg permite que você mantenha um template para cada grupo de máquinas e com apenas um comando instalar o template numa partição. Além do template, você precisa configurar o simplepkg para obter pacotes de um repositório local ou remoto. Gerenciar instalações e pacotes não é tudo o que o simplepkg faz. Ele pode ser usado até na criação de jaula e vservers, podendo manter toda a configuração das máquinas num repositório Subversion. O simplepkg funciona não apenas com o Slackware mas com qualquer port (oficial ou não) que siga minimamente os padrões oficiais. Arquitetura ----------- O simplepkg é um conjunto de scripts escritos com a filosofia KISS (Keep It Simple, Stupid) em mente. Ele é um sistema muito simples, composto pelos seguintes comandos: - mkjail: constrói uma jaula/instalação de slackware numa pasta - templatepkg: criar ou adiciona pacotes a um template - lspkg: lista pacotes instalados - jail-update: inverso do jail-commit - jail-commit: atualiza o template - rebuildpkg: reconstrói um pacote a partir de sua entrada no /var/log/packages - simplaret: obtém pacotes de repositórios locais ou remotos - createpkg: baixa, compila e empacota software de acordo com scripts presentes num repositório - repos: cria e mantém repositórios - mkbuild: cria scripts de construção de pacotes Instalando o simplepkg ---------------------- Para baixar o pacote do simplepkg, vá em http://slack.sarava.org/packages/noarch/. Depois, basta usar o comando installpkg simplepkg-VERSAO-noarch-BUILD.tgz Usando o simplepkg ------------------ As três principais aplicações desse conjunto são: - Gerenciamento de pacotes - Criação e manutenção de jaulas - Criação de pacotes O gerencamento de pacotes é feito através do simplaret, e por ser algo bem específico está detalhado no artigo correspondente. As seções a seguir mostrarão como o simplepkg pode ser utilizado para criar e manter jaulas, assim como também criar pacotes. Criando templates de instalação ------------------------------- Originalmente, o simplepkg foi desenvolvido para ajudar na automatização de instalações de sistemas slackware. Para isso, ele trabalha com templates -- listas com pacotes instalados, scripts e arquivos de configuração -- permitindo criar perfis de instalação que podem ser então usados para instalar o sistema numa outra partição ou criar um chroot. A construção de um template é feita através do programa templatepkg. Para criar um template de nome "meu-slackware" contendo a lista de pacotes atualmente instalados no seu sistema, digite templatepkg -c meu-slackware A opção -c (ou --create) criará a pasta /etc/simplepkg/templates/meu-slackware, que conterá os seguintes componentes: - /etc/simplepkg/templates/meu-slackware/meu-slackware.template: lista de pacotes - /etc/simplepkg/templates/meu-slackware/meu-slackware.d: cópia de arquivos de configuração - /etc/simplepkg/templates/meu-slackware/meu-slackware.s: scripts de pós-instalação Esses três componentes são suficientes para armazenar todas as características de uma instalação de slackware: a lista de pacotes controla o software instalado (a partir do conteúdo da pasta /var/log/packages), a cópia dos arquivos de configuração controla as personalizações feitas para o uso dos aplicativos e os scripts de pós-instalação cuidam de qualquer rotina que precisa ser realizada exatamente após a instalação do sistema. Se você quiser criar um template a partir de uma instalação de slackware presente numa outra partição do sistema que não seja a raíz, basta usar um comando do tipo templatepkg -c meu-slackware /mnt/slackware onde /mnt/slackware é o local onde o sistema alternativo está instalado. Após criado, o template possuirá apenas a lista de pacotes contendo o nome dos aplicativos instalados no seu sistema. Para adicionar um arquivo de configuração, basta dar um comando como templatepkg -a meu-slackware /etc/hosts Isso adicionará o arquivo /etc/hosts no template "meu-slackware". Além de salvar o arquivo e copiá-lo automaticamente quando você instalar seu sistema, o simplepkg ainda pode tomar conta de qualquer alteração que o /etc/hosts sofrer no sistema, seja mudança no conteúdo do arquivo, dono ou permissão. Se você ainda estiver armazenando seus templates num repositório svn (o que veremos a seguir), o simplepkg pode ainda manter um histórico completo das alterações do arquivo. ATENÇÂO: evite ao máximo deixar arquivos contendo senhas ou chaves privadas num template. O lugar mais adequado para deixar esse tipo de coisa é num backup seguro. Criando jaulas e replicando instalações --------------------------------------- Uma vez que um template foi criado com uma lista de pacotes e opcionalmente com arquivos de configuração e scripts de pós-instalação (que serão detalhados a seguir), você pode replicar sua instalação de slackware utilizando o comando mkjail jaula meu-slackware Isso cria uma nova árvore do slackware em /vserver/jaula contendo todos os pacotes e arquivos de configuração do template "meu-slackware". A instalação dos pacotes será feita pelo aplicativo simplaret, que deve estar configurado corretamente e cuja configuração padrão deve funcionar para a maioria dos casos. Se você quiser instalar essa jaula em outro local que não seja a pasta /vservers (esse local padrão pode ser mudado pelo arquivo de configuração do simplepkg), basta usar um comando do tipo ROOT=/mnt mkjail hda2 meu-slackware O comando acima faz exatamente o que você está pensando: replica sua instalação slackware em /mnt/hda2, dispensando totalmente o programa de instalação do slackware! Caso nenhum template for especificado, o mkjail utiliza o template /etc/simplepkg/default. O simplepkg já vem com alguns templates padrões, presentes em /etc/simplepkg/defaults/template. Scripts de pós-instalação ------------------------- templatepkg -b nome-do-script.sh Listando o conteúdo de um template ---------------------------------- templatepkg -l Removendo arquivos de um template --------------------------------- templatepkg -d Apagando um template -------------------- templatepkg -r Atualizando um template ----------------------- jail-commit Para atualizar apenas a lista de pacotes de um template, use templatepkg -u meu-template Editando manualmente a lista de pacotes --------------------------------------- templatepkg -e nome-do-template Restaurando arquivos de configuração numa jaula ----------------------------------------------- jail-update Armazenando as configurações no repositório Subversion ------------------------------------------------------ svnadmin create /var/svn/simplepkg --fs-type fsfs templatepkg -e file:///var/svn/simplepkg jail-commit jail-commit --all templatepkg -s Atualização de jaulas --------------------- Existe ainda uma facilidade para que a obtenção e aplicação de atualizações seja feita de forma única, através do arquivo /etc/simplepkg/jailist. Esse arquivo serve, além de outros propósitos descritos na documentação do simplepkg, para que o simplaret saiba de antemão quais são as instalações de sistema do tipo Slackware presentes numa máquina, além da instalação principal na raíz do sistema. Veja a documentação do simplaret para mais detalhes. Arquiteturas e versões diferentes --------------------------------- O simplepkg foi idealizado para permitir que um mesmo template possa ser usado para criar jaulas de arquiteturas e versões diferentes de sistemas padrão slackware. A atualização desses sistemas também é unificada. Essa possibilidade só é permitida se você usa o simplaret e não o swaret como ferramenta de obtenção de pacotes. Por exemplo, para criar uma instalação de slackware 10.1 (assumindo que suas definições de repositórios do /etc/simplepkg/repos.conf contenham locais com slack 10.1), basta usar o comando VERSION=10.1 mkjail minha-jaula template-servidor Arquiteturas diferentes também podem ser usadas. Se você está num sistema x86_64 e quer instalar um slack 10.2 numa partição, experimente ARCH=i386 VERSION=10.2 ROOT=/mnt mkjail hda2 meu-slackware Note que os templates independem de arquitetura e versão, já que eles só contém nomes de pacotes, arquivos de configuração e scripts. Por isso, o templatepkg, o metapkg, o lspkg e o jail-update funcionam normalmente. Para atualizar suas jaulas, o jail-upgrade checa antes qual a versão e arquitetura de cada uma de suas jaulas através do /etc/slackware-version correspondente e a partir disso aplica os patches da arquitetura e versão da mesma, usando para isso o simplaret (veja a documentação própria). Desse modo, mesmo que você tenha jaulas de versões e arquiteturas diversas, usar o comando "jail-upgrade" faz a atualização sem problemas, desde que seus patches estejam organizados por arquitetura e versão, conforme é detalhado na documentação do simplaret, em http://slack.sarava.org/node/16. Criando um pacote de um template -------------------------------- templatepkg -p nome-do-template Aplicativos auxiliares: rebuildpkg, createpkg, lspkg e repos ------------------------------------------------------------ O simplepkg acompanha ainda um aplicativo auxiliar que ajuda a recuperar pacotes instalados cujo tgz original foi perdido. O comando rebuildpkg reconstrói um pacote a partir de uma entrada no /var/log/packages. O comando rebuildpkg coreutils reconstrói um pacote do coreutils usando os arquivos e as metainformações listadas no arquivo do /var/log/packages/ correspondente ao coreutils. Se você quiser construir seus próprios pacotes baseados nos slackbuilds disponíveis em http://slack.sarava.org/slackbuilds, basta utilizar o createpkg: createpkg nome-do-pacote Parâmetros de configuração -------------------------- /etc/simplepkg/simplepkg.conf Fonte ----- Se você quiser obter diretamente o código-fonte do simplepkg, baixe-o do repositório: svn checkout svn://slack.sarava.org/simplepkg