De ULBwiki

Apt

Introdução

O APT, ou Advanced Packaging Tool, surgiu a partir da necessidade de ter em mãos uma ferramenta prática e rápida de se instalar pacotes, além de gerenciar suas dependências automaticamente e cuidar dos seus arquivos de configuração nas atualizações. O Debian, pioneiro com o dpkg e os pacotes .deb, que em seguida a Red Hat criou o famoso sistema rpm, saiu novamente na frente com o APT, hoje portado para outras distribuições também, e algumas funções desse poderoso gerenciador serão conhecidas a seguir.

A leitura desse "guia básico" do APT é essencial para o entendimento dos tutoriais dessa wiki e de outras páginas que encontrará pela web. Com ele você entenderá o mínimo dos comandos para gerenciar os programas no seu Ubuntu.

Adicionando Pacotes

Abra um terminal através do menu Aplicações > Acessórios > Terminal. Conheça as funções do apt-get com o comando:

$ man apt-get

Em seguida aparecerá o manual do apt-get, com suas opções para instalação, remoção e outras funções. Instale um pacote:

$ sudo apt-get install nome-do-pacote

onde <nome-do-pacote> deve ser substituído pelo programa que deseja. Em seguida todas as dependências para a instalação do pacote serão instaladas e, por último, o pacote solicitado para instalação. Para reinstalar um pacote:

$ sudo apt-get install nome-do-pacote --reinstall

Removendo Pacotes

Remover pacotes é tão simples quanto instalá-los. Para remover um pacote, basta usar

$ sudo apt-get remove nome-do-pacote

e o pacote selecionado e todos os pacotes que têm como dependência o pacote a ser removido serão removidos também. Ao remover um pacote, seus arquivos de configuração são mantidos no sistema e, para removê-los, basta adicionar a opção --purge ao comando:

$ sudo apt-get remove nome-do-pacote --purge

Busca - apt-cache

Para efetuar busca de pacotes pelo terminal, usamos o apt-cache. O apt-cache, como o próprio nome sugere, é um manipular do cache de pacotes do APT. Ele não altera o estado do sistema, apenas realiza busca de pacotes e gera resultados de acordo com a opção utilizada. Para conhecer melhor o apt-cache, use:

$ man apt-cache

Para buscar um pacote que contenha a palavra palavra no nome do pacote ou em sua descrição, usa-se:

$ apt-cache search palavra

Mais palavras podem ser usadas na pesquisa, separadas por espaço. Para procurar por palavra apenas no nome do pacote, adicione a opção --names-only ao comando:

$ apt-cache search palavra --names-only

Para mostrar as informações de um determinado pacote:

$ apt-cache showpkg pacote

E uma lista com informações do pacote será gerada. Como na busca, você pode colocar mais pacotes no mesmo comando, separando por espaço.

Uma busca que acho bem interessante é a de dependências para um determinado pacote. Você pode listar as dependências de um ou mais pacotes usando o depends:

$ apt-cache depends pacote(s)

Atualizações do Sistema

Atualizar o sistema usando o APT é bem simples. Primeiro é necessário atualizar os arquivos de índice dos pacotes a partir de suas fontes. Essas fontes, ou repositórios, são especificadas no arquivo /etc/apt/sources.list. Para saber como adicionar novos, repositórios, leia o Guia para iniciantes da comunidade. Para atualizar os arquivos de índice:

$ sudo apt-get update

Agora você tem as novas listas de pacotes e, para atualizar o sistema, basta rodar:

$ sudo apt-get upgrade

Limpe o cache do APT

O APT faz um cache dos programas que você instalou, é útil se você quiser fazer várias instalações e instalar os mesmos programas sem baixar tudo de novo, mas com o tempo se torna um espaço ocupado inutilmente, para limpar o cache basta digitar em um terminal o seguinte comando:

$ apt-get clean.

Há também uma opção caso você não queira limpar todo o cache, apagando apenas os arquivos que não podem mais ser baixados (arquivos obsoletos), mantendo os pacotes baixados recentemente:

$ sudo apt-get autoclean

Gerenciador de Pacotes Synaptic

O Synaptic é um aplicativo para administração de pacotes em modo gráfico. Resumindo, ele é uma interface gráfica para o APT. Ele oferece as mesmas funcionalidades do apt-get, usado pela linha de comandos.

Para abrir o Synaptic, basta ir no menu Sistema > Administração > Gerenciador de Pacotes Synaptic e encontrará uma janela como a figura a seguir:

Funcionalidades

Instalar, remover, fazer upgrade e downgrade de um ou muitos pacotes;

Atualizar todo seu sistema;

Procurar pacotes pelo nome, descrições ou outros atributos;

Selecionar pacotes por status, seção, nome, ou filtro personalizado;

Visualizar toda a documentação relacionada a um pacote;

Forçar a instalação de um determinado pacote e outros recursos.

Administração de Repositórios

Ao instalar programas no seu Ubuntu, seja direto pelo APT ou pelo Synaptic, eles são baixados de algum lugar, correto? Agora a pergunta: de onde esses pacotes são baixados?

Os repositórios de onde seus programas são instalados ficam gravados no arquivo /etc/apt/sources.list. Esse arquivo contém a lista de servidores usados como fonte de pacotes, bem como CD/DVD ou pasta local usados como repositórios.

Para editar esse arquivo você precisa de privilégios de superusuário. ATENÇÃO!!! Somente edite esse arquivo se você sabe o que está fazendo e adicione apenas fontes confiáveis. Fontes de terceiros podem ser um grande risco para seu sistema, podendo causar conflitos de pacotes e quebrar seu sistema. Para abrir o arquivo para edição:

$ sudo gedit /etc/apt/sources.list

ou, se estiver usando a versão Server:

$ sudo vi /etc/apt/sources.list

O arquivo contém linhas iniciadas com deb indicam o endereço de um servidor usado como fonte de pacotes. A linha que inicia com deb-src é usada como repositório de códigos-fonte. Note que pode-se indicar um endereço da web, CD ou pasta local, apenas direcionando para o local correto:

deb http://endereco-web/
deb cdrom:[descrição do CD]/
deb file:///pasta-local/

Você pode também administrar seus repositórios pelo Synaptic ou pelo Canais de Software. No Guia para iniciantes você pode encontrar mais informações sobre como adicionar repositórios.

Criando passo-a-passo um pacote DEB

Fonte

A finalidade de um pacote deb é realizar tarefas como: instalação de aplicativos, instalação de ferramentas, codecs, plugins, fazer configurações, etc.

Veja como é simples criar um pacote deb seguindo este exemplo passo-a-passo:

Passo 1 - Definir exatamente o objetivo do pacote é uma das etapas mais importante de todo processo. Para este simples exemplo será criado um pacote deb, que irá automaticamente colocar um arquivo chamado script-raf, dentro diretório /usr/lib/cups/filter.

Passo 2 - Para dar início a criação de um pacote precisamos criar um diretório base onde toda a estrutura do pacote será montada, lembrando-se que é aconselhável que o nome deste diretório seja sugestivo em relação à funcionalidade do pacote. Para este exemplo o diretório base será chamado de "pacteste", e este será criado dentro do diretório /tmp.

Comando necessário:

Criando o diretório pacteste:

$ sudo mkdir /tmp/pacteste

Passo 3 - Após criar o diretório pacteste, vamos criar dentro dele o diretório principal do pacote, que obrigatoriamente deverá ser chamado de DEBIAN (o nome do diretório deverá ser escrito em maiúsculo). Este é o diretório que conterá os arquivos de controle do pacote.

Comandos necessários:

Criando o diretório principal chamado DEBIAN:

$ sudo mkdir /tmp/pacteste/DEBIAN

Entendendo o arquivo de controle (control)

Passo 4 - O arquivo de controle chamado "control" é de extrema importância para cada pacote deb, pois este traz informações como: nome do pacote, versão do pacote, nome do mantenedor, dependências relacionadas, descrições sobre a finalidade, entre muitas outras características.

Devido à grande importância deste arquivo, vou descrever rapidamente abaixo alguns dos campos que você poderá encontrar ao abrí-lo.

Package: (Obrigatório) - Este campo descreve o nome do pacote binário. O nome do pacote deve ser composto somente por letras minúsculas (a-z), dígitos (0-9), sinais de mais (+) e menos (-), e pontos (.). Deve ser formado por pelo menos dois caracteres e deve começar com um caráter alfanumérico.

Source: Especifica o nome do pacote fonte, mas este campo pode ser omitido de um arquivo de controle do pacote quando o pacote da fonte tem o mesmo nome e versão que o pacote binário.

Version: (Obrigatório) - Neste campo você obrigatoriamente deverá inserir a versão do pacote o qual você esta criando.

Section: (Recomendado) - Este campo especifica uma área de aplicação em que o pacote foi classificado.

Architecture: (Obrigatório) - Especifica a lista arquitetura(s) para a qual, o pacote é destinado. Exemplo de arquiteturas:

i386 ia64 alpha amd64 armeb arm hppa m32r m68k mips mipsel powerpc ppc64 s390 
s390x sh3 sh3eb sh4 sh4eb sparc darwin-i386 darwin-ia64 darwin-alpha darwin-amd64
darwin-armeb darwin-arm darwin-hppa darwin-m32r darwin-m68k darwin-mips
darwin-mipsel darwin-powerpc darwin-ppc64 darwin-s390 darwin-s390x 
darwin-sh3 darwin-sh3eb darwin-sh4 darwin-sh4eb darwin-sparc freebsd-i386
freebsd-ia64 freebsd-alpha freebsd-amd64 freebsd-armeb freebsd-arm freebsd-hppa 
freebsd-m32r freebsd-m68k freebsd-mips freebsd-mipsel freebsd-powerpc 
freebsd-ppc64 freebsd-s390 freebsd-s390x freebsd-sh3 freebsd-sh3eb freebsd-sh4 
freebsd-sh4eb freebsd-sparc kfreebsd-i386 kfreebsd-ia64 kfreebsd-alpha kfreebsd-amd64 
kfreebsd-armeb kfreebsd-arm kfreebsd-hppa kfreebsd-m32r kfreebsd-m68k kfreebsd-mips 
kfreebsd-mipsel kfreebsd-powerpc kfreebsd-ppc64 kfreebsd-s390 kfreebsd-s390x 
kfreebsd-sh3 kfreebsd-sh3eb kfreebsd-sh4 kfreebsd-sh4eb kfreebsd-sparc knetbsd-i386 
knetbsd-ia64 knetbsd-alpha knetbsd-amd64 knetbsd-armeb knetbsd-arm knetbsd-hppa 
knetbsd-m32r knetbsd-m68k knetbsd-mips knetbsd-mipsel knetbsd-powerpc knetbsd-ppc64 
knetbsd-s390 knetbsd-s390x knetbsd-sh3 knetbsd-sh3eb knetbsd-sh4 knetbsd-sh4eb 
knetbsd-sparc netbsd-i386 netbsd-ia64 netbsd-alpha netbsd-amd64 netbsd-armeb 
netbsd-arm netbsd-hppa netbsd-m32r netbsd-m68k netbsd-mips netbsd-mipsel 
netbsd-powerpc netbsd-ppc64 netbsd-s390 netbsd-s390x netbsd-sh3 netbsd-sh3eb 
netbsd-sh4 netbsd-sh4eb netbsd-sparc openbsd-i386 openbsd-ia64 openbsd-alpha 
openbsd-amd64 openbsd-armeb openbsd-arm openbsd-hppa openbsd-m32r openbsd-m68k 
openbsd-mips openbsd-mipsel openbsd-powerpc openbsd-ppc64 openbsd-s390 openbsd-s390x 
openbsd-sh3 openbsd-sh3eb openbsd-sh4 openbsd-sh4eb openbsd-sparc hurd-i386 hurd-ia64 
hurd-alpha hurd-amd64 hurd-armeb hurd-arm hurd-hppa hurd-m32r hurd-m68k hurd-mips 
hurd-mipsel hurd-powerpc hurd-ppc64 hurd-s390 hurd-s390x hurd-sh3 hurd-sh3eb 
hurd-sh4 hurd-sh4eb hurd-sparc

Depends: Campo onde são declaradas todas as dependências necessárias para se fazer à instalação do pacote. O pacote não será configurado a menos que todos os pacotes alistados neste campo sejam configurados corretamente.

Installed-Size: Descreve a quantidade total de espaço em disco requerida para instalar o pacote nomeado. O espaço em disco é representado em kilobytes como número decimal simples.

Maintainer: (Obrigatório) - Contém o nome e/ou email do mantenedor do pacote.

Description: (Obrigatório) - Contém a descrição do pacote.

Criando um arquivo de controle (control)

Passo 5 - Neste passo vamos utilizar um editor de texto qualquer (ex: vi ,mcedit, kedit, etc) para criar o arquivo control referente ao exemplo.

Comandos necessários:

$ sudo gedit /tmp/pacteste/DEBIAN/control

Após aberto no editor de texto gedit, vou criar as seguintes linhas no arquivo control:

Package: pacote-raf
Priority: optional
Version: 0.1
Architecture: i386
Maintainer: Rafael Brianezi da Silva
Depends:
Description: Este é um pacote gerado com o intuito de elucidar a criação de um pacote deb.

Criando a estrutura de diretórios do pacote

Passo 6 - Depois de criado o diretório DEBIAN e o arquivo de controle necessário, podemos agora começar a criar dentro do diretório base (pacteste) a estrutura de diretório exatamente igual à que desejamos após a instalação do pacote.

Opaaa...!!!, Neste ponto podem surgir algumas dúvidas, mas basta entender a idéia principal que tudo ficará claro, veja:

Conforme mencionado no passo 1, o objetivo deste pacote ao ser instalado é colocar o arquivo script-raf, dentro do diretório /usr/lib/cups/filter.

Como devo proceder?

A resposta é simples, basta criar esta estrutura de diretório (/usr/lib/cups/filter) dentro do diretório base e colocar o arquivo desejado no local onde ele deverá ser copiado após a instalação.

Lembrando que o diretório base "representa" o diretório raiz (/) do sistema.

Na prática eu entraria no diretório base e criaria o diretório usr, dentro de usr eu criaria o lib, dentro de lib o cups, dentro cups o diretório filter, e finalmente dentro de filter eu colocaria o arquivo script-raf.

Ou simplesmente, entre no diretório base e digite o seguinte comando:

$ sudo mkdir -p usr/lib/cups/filter

OBS: Note que na frente do usr não tem o /.

No momento da instalação do pacote ele fará automaticamente a seguinte verificação partindo da raiz (/) do sistema:

Tem diretório usr na raiz (/)?

   * Se sim, então entre no diretório usr;
   * Senão, crie o diretório usr e entre; 

Dentro de usr, tem o diretório lib?

   * Se sim, então entre no diretório lib;
   * Senão, crie o diretório lib e entre; 

Dentro de lib, tem o diretório cups?

   * Se sim, então entre no diretório cups;
   * Senão, crie o diretório cups e entre; 

Dentro de cups, tem o diretório filter?

   * Se sim, então entre no diretório filter;
   * Senão, crie o diretório filter e entre; 

Dentro do diretório filter, tem o arquivo script-raf?

   * Se sim, sobrescreva o arquivo;
   * Senão, copie o arquivo script-raf para este diretório. 

Criando o pacote DEB

Passo 7 - Após ter criado toda a estrutura indicada no passo anterior, finalmente podemos aplicar ao diretório raiz (pacteste), o comando necessário para que, a partir deste diretório, seja gerado o pacote deb que é o nosso objetivo principal.

Sintaxe do comando:

$ dpkg-deb -b <caminho absoluto do diretório base> <local onde o pacote deve ser gerado>

Comando para gerar o pacote do exemplo:

$ dpkg-deb -b /tmp/pacteste /tmp

O resultado deste comando será um arquivo chamado pacote-raf_0.1_i386.deb dentro do diretório /tmp.

Para testar se o pacote realmente funciona, basta utilizar o seguinte comando:

Sintaxe do comando:

$ dpkg -i <nome do pacote>

Uma outra dica interessante é você pegar um pacote já criado, desmontá-lo e analisar como a estrutura foi criada. Para isso veja os seguinte comandos:

Comando para extrair o conteúdo de um pacote deb para dentro de um diretório:

$ dpkg-deb -x <nome_do_Pacote.deb> /tmp/pacote

Comando para extrair o arquivo de controle de um pacote deb:

$ dpkg-deb -e <nome_do_pacote.deb> /tmp/pacote/DEBIAN

Apt-build

[Fonte]

A ferramenta

O propósito do apt-build é facilitar o processo de instalação de softwares a partir da compilação. Quando você tem o código fonte de um programa em mãos, a instalação do mesmo geralmente é feita através do processo de compilação, para isso, é necessário pegar o código fonte do programa em questão, descompactar, entrar na pasta com os arquivos descompactados e, geralmente usar os famosos comandos:

./configure && make && make install

O legal da compilação é que o GCC (O compilador de programas do mundo GNU/Linux) compila os programas adaptando-se ao hardware do seu computador, processador, memória, etc.. tornando o programa muito mais leve e otimizado do que se ele tivesse apenas sido copiado para o seu HD. Isso realmente é uma grande vantagem, tanto que em servidores, ferramentas de missão crítica como um Web Server, ou um DNS ou um servidor de arquivos ou proxy DEVEM ser compiladas, garantindo melhor performance e evitando travamentos indesejados além do alto consumo de memória. Mas, como nem tudo nesse mundo são rosas, o processo de compilação é demorado (claro) além de ser chato por que nem todas as distribuições para usuários finais trazem as bibliotecas necessárias para uma compilação sem traumas e o resultado é que sempre acabamos nos afundando internet abaixo para resolvermos problemas de dependência, versão de bibliotecas e outros problemas, o que nos faz perder um tempo bem grande para instalarmos o programa.

Por causa desses inconvenientes, cada distribuição bola a sua forma de gerenciar pacotes e programas, sem a necessidade de compilação e com passos simples para o usuário. O Debian e seus derivados, por exemplo contam com o poderoso apt-get, uma ferramenta de instalação tão simples e tão estável que até mesmo o mais perdido dos usuários consegue usá-lo através das suas várias interfaces gráficas.

O propósito do apt-buid é compilar programas a partir do código fonte, porém com a mesma facilidade que o apt-get faz para instalar e gerenciar programas. Quando executado, o apt-build checa pelo programa e levanta todas as dependências que esse aplicativo vai precisar. Então ele baixa tudo, compila as dependências, compila o programa solicitado, limpa o lixo que por ventura sobrar e, com tudo compiladinho, ele cria os arquivos .deb, joga tudo no diretório de pacotes do computador e instala pelo dpkg, fazendo então uma instalação simples e controlada de pacotes, mas que foram compilados para o seu nível de hardware. Tudo muito simples e fácil, com todas as vantagens do apt-get.

Instalando o apt-build

Para instalar o apt-buid, basta usar o bom e velho apt-get com o comando:

apt-get install apt-build

Após instalado, algumas perguntas serão feitas. Primeiro, ele vai instalar o courier e vai pedir informações sobre e-mail para enviar mensagens ao administrador em alguns momentos. Nessa fase, você pode responder tudo bonitinho ou aceitar o padrão para tudo, não é obrigatório que esse passo funcione certinho.

Depois de mais alguns pacotinhos configurados então vem a vez do apt-build para valer. Na primeira tela da configuração, ele vai simplesmente perguntar onde os pacotes baixados devem ficar armazenados, você pode escolher o padrão: /var/cache/apt-build/build.

A pergunta seguinte é onde os pacotes vão ficar guardados depois que eles forem compilados. Também pode-se escolher o padrão: /var/cache/apt-build/repository.

O passo seguinte é um dos mais interessantes. Ele vai perguntar qual é o nível de otimização da compilação. Existem 3 níveis: O "Baixo", onde a compilação é rápida, porém mais genérica, quer dizer, o programa compilado tende a ficar mais lento. O "Médio" onde a compilação é mais específica, mais demorada, mas o programa instalado roda bem mais limpo e o "Forte", onde o tempo de compilação é bem maior mas o programa roda muito leve e muito rápido, esse nível é tão extremo que em alguns casos a compilação pode encontrar problemas. Eu estou usando o nível médio em meu computador.

O passo seguinte configura o apt-get para instalar os pacotes criados pelo apt-build, basta aceitar a opção padrão que é Sim e seguir para o passo seguinte. Caso você tenha alguma opçao que queira colocar no GCC, pode-se colocar nesse passo. Caso voce não tenha nada a ser acrescentado (o padrão de quase todo mundo) basta seguir em frente sem colocar nada. De ok e siga para passo seguinte onde a mesma pergunta será feita, mas dessa vez para o make. Basta seguir em frente do mesmo jeito e ir para o próximo passo.

O passo seguinte também exige muita atenção por que ele vai perguntar qual é o seu tipo de processador. É importante que essa pergunta seja muito bem respondida por que a compilação vai ser voltada para se encaixar ao processador escolhido aí. Logo, se um processador diferente do seu computador for escolhido, você poderá ter problemas no futuro ao executar os seus programas instalados.

Depois disso, seu programa estará instalado! Agora é só usar.

Usando

Antes de sair por aí instalando tudo, certifique-se que o seu apt está configurado para baixar códigos fontes, basta ir até o arquivo /etc/apt/sources.list e adicionar um repositório com o tipo definido para deb-src, conforme o exemplo abaixo:

deb http://br.archive.ubuntu.com/ubuntu/ hardy main restricted
 deb-src http://br.archive.ubuntu.com/ubuntu/ hardy main restricted

Após arrumar o seu sources.list não se esqueça do famoso:

apt-get update

Para usar o apt-build, basta rodá-lo de um terminal para instalar o programa que você quiser, como se fosse um apt-get:

apt-build install programa

Ele faz o resto. Tudo simples fácil, e compilado! Todos as demais funções do programa funcionam muito igual ao apt-get, portanto, não vai haver confusões (eu espero!!), seguem aqui algumas, mais simples:

apt-build install --reinstall programa

Reinstala um programa já instalado.

apt-build upgrade

Faz upgrade de todos os pacotes instalados.

apt-build world

Recompila todo o seu sistema (demooooooora)

apt-build source programa

Baixa o código fonte e descompacta, mas não compila nem instala.

apt-build remove programa

Desinstala o programa selecionado

apt-build clean-build

Apaga os pacotes compilados (útil para ganhar espaço no HD)

apt-build clean-sources

Apaga os pacotes fontes (útil para ganhar espaço no HD também) Todos as opções podem ser vistas com um man apt-build. Simples e fácil.

Conclusão

O APT é uma poderosa ferramenta de gerenciamento de pacotes, contando com uma infinidade de funcionalidades. Ter um conhecimento básico sobre ele é fundamental para administrar pacotes no seu sistema. Com esse guia básico do APT você poderá gerenciar os pacotes do seu Ubuntu, acompanhar todos os tutoriais da wiki e entender alguns comandos utilizados neles. Volto a repetir que, para ter informações mais aprofundadas, leia os manuais dos programas, digitando man programa no terminal.