Ferramentas

Um gestor de pacotes é uma ferramenta que instala, atualiza e remove software - juntamente com tudo aquilo de que esse software depende - indo buscá-lo a um repositório. Em vez de descarregar ficheiros à mão, descompactá-los nos lugares certos e torcer para não ter esquecido nenhuma peça, pede ao gestor o que quer e ele faz o trabalho: localiza o pacote, traz os outros pacotes de que precisa, coloca-os onde devem ficar e regista o que instalou. É esse registo que lhe permite depois atualizar ou remover de forma limpa a mesma coisa.

O problema que resolve: as dependências

Os gestores de pacotes existem porque quase nenhum software funciona sozinho. Um programa costuma depender de bibliotecas, e essas bibliotecas dependem de outras bibliotecas, formando uma cadeia chamada dependências transitivas. Resolver isto à mão é lento e propenso a erros: é preciso encontrar cada dependência, escolher uma versão compatível, instalá-la na ordem certa e repetir todo o processo em cada máquina. Um gestor de pacotes faz isto automaticamente, e é por isso que se tornou uma parte padrão de quase todos os sistemas operativos e linguagens de programação.

Gestores de pacotes do sistema operativo

O primeiro grande tipo é o gestor de pacotes do sistema operativo, que instala software e bibliotecas de sistema para toda a máquina. No Debian e Ubuntu é o apt, no Fedora e Red Hat é o dnf, no macOS muitos programadores usam o Homebrew (o comando brew), e no Windows há o winget. Estas ferramentas vão buscar a repositórios cuidados de pacotes construídos para esse sistema, gerem as dependências entre eles e mantêm o software atualizado com um único comando.

• Instala, atualiza e remove software e as suas dependências
• Gestores de sistema: apt, dnf, Homebrew, winget
• Gestores de linguagem: npm, pip, cargo, Composer
• Resolução de versões + lockfiles tornam as instalações reproduzíveis
• Faça commit do lockfile e audite vulnerabilidades

Gestores de pacotes de linguagem e projeto

O segundo grande tipo é o gestor de linguagem ou de projeto, que instala as bibliotecas de que um projeto específico precisa em vez de software para toda a máquina. O npm faz isto para JavaScript e Node.js, o pip para Python, o cargo para Rust e o Composer para PHP. Leem um ficheiro de manifesto no seu projeto que lista as dependências, depois descarregam-nas de um registo central para o projeto para que o seu código as possa usar, mantendo cada projeto isolado dos outros.

Repositórios, registos e resolução de versões

Para fazer o seu trabalho, um gestor de pacotes comunica com um repositório ou registo - um catálogo central dos pacotes publicados e das suas versões. Quando pede um pacote, muitas vezes indica não uma versão exata mas um intervalo, através de uma convenção como o versionamento semântico (semver), onde números como 2.4.1 sinalizam a dimensão de uma alteração. O gestor executa então a resolução de versões: determina um conjunto de versões que satisfaz todos os requisitos ao mesmo tempo, incluindo todas as dependências transitivas, para que nada entre em conflito.

Lockfiles e instalações reproduzíveis

Como um intervalo de versões pode resolver-se em diferentes versões exatas ao longo do tempo, a maioria dos gestores de pacotes modernos escreve um lockfile. Um lockfile regista a versão precisa de cada pacote realmente instalado, de modo que a pessoa seguinte - ou o servidor de build - que instale o projeto obtenha exatamente o mesmo conjunto, e não apenas um compatível. É isto que torna as instalações reproduzíveis: o manifesto diz o que quer em termos gerais, e o lockfile fixa o que obteve.

Boas práticas

Algumas boas práticas decorrem diretamente do modo como estas ferramentas funcionam. Faça commit do lockfile no controlo de versões para que toda a gente e cada ambiente instalem um conjunto de dependências idêntico, o que elimina toda uma classe de surpresas do tipo funciona-na-minha-máquina. Execute o comando de auditoria do gestor (muitos, incluindo o npm e as ferramentas baseadas em pip, oferecem um) para verificar as suas dependências face a bases de dados de vulnerabilidades conhecidas, e atualize de forma deliberada em vez de deixar versões antigas por corrigir.

Armadilhas a vigiar

As armadilhas também vale a pena conhecer. Deixar dependências não fixadas - aceitar qualquer versão que por acaso seja a mais recente - significa que duas instalações podem diferir em silêncio, de modo que uma build que funcionava ontem pode partir-se hoje sem qualquer alteração da sua parte. E como está a puxar código de um registo público, os gestores de pacotes são um alvo para ataques à cadeia de fornecimento, onde um pacote malicioso ou raptado é publicado sob um nome de aparência familiar. Rever o que adiciona, vigiar os nomes typosquattados e manter as auditorias a correr são as defesas do dia a dia.

No conjunto, um gestor de pacotes é uma das ferramentas mais úteis que um programador tem: transforma o emaranhado de encontrar, versionar e instalar software em alguns comandos, e o seu lockfile torna o resultado repetível entre máquinas. Aprenda o que o seu sistema operativo e a sua linguagem usam, faça commit do seu lockfile, audite as suas dependências, e instalar software passa a ser um passo de rotina e fiável em vez de uma fonte de surpresas.