Atualizando pacotes Linux para desenvolvedores C#

Como o gerenciamento de pacotes do Linux difere do Windows

[0:00 - 0:38] Tim começa abordando um obstáculo comum para desenvolvedores que vêm do Windows. No Windows, cada aplicativo normalmente gerencia suas próprias atualizações. O Visual Studio verifica se há atualizações independentemente do Edge, que por sua vez atualiza separadamente dos drivers da sua impressora. Não existe um sistema único que rastreie tudo o que está instalado em sua máquina.

O Linux adota uma abordagem centralizada. Um gerenciador de pacotes como o apt (Advanced Package Tool) rastreia todos os softwares instalados a partir dos repositórios oficiais. Ao executar uma atualização, o apt consulta os repositórios em busca de todos os pacotes instalados de uma só vez. Atualizações de navegadores, correções de bibliotecas, atualizações de SDKs e correções de segurança chegam através do mesmo canal.

Para desenvolvedores C#, isso tem implicações reais. Seu ambiente de execução .NET , as bibliotecas OpenSSL das quais suas chamadas HTTPS dependem e as dependências de nível de sistema com as quais seus aplicativos se vinculam são todas gerenciadas por este sistema. Se você está começando a usar C# em uma plataforma que não seja Windows , saber como o gerenciador de pacotes funciona evita que você tenha que lidar com falhas de compilação misteriosas mais tarde. Um único apt upgrade mantém toda a pilha alinhada, algo que você precisaria coordenar em vários atualizadores separados no Windows.

Interface gráfica do usuário: Gerenciador de atualizações

[0:38 - 1:34] Para desenvolvedores que preferem um fluxo de trabalho visual, Tim primeiro explica o Gerenciador de Atualizações. O Linux Mint inclui um que funciona de forma semelhante ao Windows Update. Um pequeno ícone no canto inferior direito da barra de tarefas abre o aplicativo, e você verá exatamente o que será atualizado: Microsoft Edge, Firefox, curl, libssh e muito mais. Cada entrada exibe a versão atual, a nova versão e o tamanho do download.

Todos os pacotes são selecionados por padrão, mas você pode desmarcar itens se quiser ignorar uma atualização específica. Isso é útil se uma versão específica de uma ferramenta for necessária para o seu projeto e você não quiser que ela mude no meio do sprint.

Você clica em "Instalar atualizações", digita sua senha quando solicitado e aguarda a conclusão do processo. A solicitação de senha existe porque a modificação de pacotes do sistema é uma ação administrativa, que abordaremos na próxima seção.

Uma das coisas que a interface gráfica faz bem: classifica as atualizações por nível de risco e é mais conservadora em relação a alterações que possam afetar a estabilidade do sistema. Para um desenvolvedor iniciante em Linux que simplesmente deseja manter seu ambiente saudável sem se preocupar com os detalhes, o Gerenciador de Atualizações é uma excelente opção padrão.

Entendendo o sudo

[1:34 - 1:51] Antes de passar para o terminal, Tim dedica um momento para explicar sudo, já que aparece em todas as operações de pacotes da linha de comando. Vale a pena entender o que ele faz antes de começar a digitar. A maioria das contas de usuário do Windows são contas de administrador por padrão, o que lhes dá acesso total para instalar, remover e modificar o software do sistema. O Linux adota a abordagem oposta: sua conta é executada com permissões limitadas e você só obtém privilégios de administrador quando necessário.

Ao adicionar o prefixo sudo a um comando, será solicitada uma senha para verificar sua identidade. Após a autenticação, esse comando é executado com privilégios de root e, em seguida, as permissões retornam ao normal. O gerenciamento de pacotes (instalação, remoção ou atualização de software) é uma operação em nível de sistema que pode afetar todos os aplicativos na máquina, portanto, o prefixo explícito sudo garante que você não modifique acidentalmente pacotes do sistema quando sua intenção era fazer outra coisa.

Se você já usou o Windows, pense nisso como algo semelhante a executar o Visual Studio como administrador, exceto que, no Linux, você eleva comandos individuais em vez de aplicativos inteiros. É um modelo mais direcionado.

A linha de comando: apt update

[1:51 - 2:28] Com sudo coberto, Tim se move para o terminal. Trabalhar dessa forma proporciona um controle mais preciso sobre o processo de atualização, e ele demonstra três comandos em sequência. Entender o que cada um faz é importante porque, como ele destaca, a nomenclatura é enganosa.

O primeiro comando é:

sudo apt update

sudo apt update

Uma suposição comum é que este comando atualiza pacotes. Não. apt update atualiza o índice de pacotes, um catálogo local de software disponível. Com o tempo, esse catálogo fica desatualizado à medida que os mantenedores lançam novas versões; portanto, executar este comando baixa a versão mais recente dos servidores do repositório. Não será necessário fazer nenhuma alteração de software em sua máquina. Trata-se apenas de uma etapa para coleta de informações.

Após a execução, o apt informa quantos pacotes possuem versões mais recentes disponíveis. Você pode consultar a lista completa antes de confirmar qualquer alteração:

apt list --upgradeable

apt list --upgradeable

Isso fornece uma visão linha por linha de cada pacote com uma versão mais recente disponível, incluindo os números de versão atual e da nova versão. Se você estiver trabalhando com .NET nesta máquina, é aqui que você poderá encontrar atualizações do SDK, patches de tempo de execução ou alterações nas bibliotecas das quais seu aplicativo depende. Entender quais versões do .NET estão instaladas em sua máquina ajuda a decidir se uma determinada atualização é segura ou se precisa ser testada primeiro.

A linha de comando: apt upgrade

[3:01 - 3:40] Assim que o índice é atualizado, Tim passa para o segundo comando — aquele que realmente instala as versões mais recentes:

sudo apt upgrade

sudo apt upgrade

Preste atenção à nomenclatura: update obtém as informações mais recentes, upgrade é o que altera os pacotes. Essa divisão em duas etapas é intencional. Isso separa a etapa de "verificar o que está disponível" da etapa de "aplicar alterações", dando a você tempo para revisar, pesquisar ou fazer um backup antes que qualquer alteração seja feita.

Nos bastidores, o upgrade segue regras rígidas sobre o que fará e o que não fará. Ele baixa e instala versões mais recentes de pacotes já presentes no seu sistema, mas nunca removerá um pacote existente nem instalará um novo que não estivesse presente anteriormente. Quando uma versão mais recente precisa de uma dependência que não está instalada, upgrade retém esse pacote em vez de baixar a nova dependência automaticamente.

A vantagem é a previsibilidade. Manter sua infraestrutura .NET atualizada é importante, mas fazer isso de forma controlada também é. O sistema apresenta um resumo das alterações que serão feitas e pede sua confirmação antes de prosseguir, para que nada aconteça sem sua permissão explícita.

Linha de comando: apt full-upgrade

[3:40 - 4:19] Com as atualizações de segurança aplicadas, Tim apresenta o terceiro comando para lidar com tudo o que upgrade foi deliberadamente omitido:

sudo apt full-upgrade

sudo apt full-upgrade

full-upgrade trata dos casos que upgrade evita deliberadamente. Se uma atualização de pacote exigir a instalação de novas dependências ou a remoção de pacotes conflitantes, full-upgrade fará isso. Aqui são aplicadas atualizações do kernel, alterações importantes nas bibliotecas do sistema e correções no nível do sistema operacional.

Executar isso como uma etapa separada proporciona uma abordagem em camadas. Se algo der errado durante a resolução de dependências complexas, você já terá aplicado as atualizações mais simples e só precisará solucionar os problemas mais complexos.

Para equipes que gerenciam um pipeline de compilação de aplicativos C# no Linux, esse fluxo de trabalho em etapas é especialmente relevante. Em um ambiente CI/CD automatizado , você pode optar por executar apenas apt upgrade para garantir a estabilidade, reservando full-upgrade para janelas de manutenção programadas, onde você pode verificar se tudo ainda compila e passa após alterações mais profundas no sistema.

Por que a contagem de pacotes difere?

[2:28 - 3:01] Algo que costuma confundir as pessoas: o Gerenciador de Atualizações pode mostrar 23 atualizações, enquanto a linha de comando relata 79 pacotes. Não se tratam de conjuntos diferentes de atualizações; É o mesmo sistema, contabilizado de forma diferente.

A interface gráfica do usuário agrupa pacotes relacionados em unidades lógicas. Uma única "atualização do Firefox" no Gerenciador de Atualizações pode, na verdade, consistir no binário do Firefox, seu pacote de localização, bibliotecas compartilhadas das quais ele depende e um pacote de configuração, cada um rastreado como um pacote separado pelo apt. Assim, o que o Gerenciador de Atualizações apresenta como uma única atualização, o apt lista como quatro ou cinco atualizações de pacotes individuais.

Uma vez que você saiba disso, a discrepância deixa de ser intrigante. Alguém poderia dizer "Eu tinha 100 pacotes para atualizar" para o mesmo conjunto de alterações que o seu Gerenciador de Atualizações mostra como 30 atualizações.

Flatpak: um gerenciador de pacotes separado

[5:56 - 6:41] Há um detalhe que é fácil de passar despercebido: o Linux pode ter vários gerenciadores de pacotes instalados, e o apt só reconhece os pacotes que ele gerencia. O Flatpak é uma dessas alternativas; trata-se de um sistema baseado em sandbox que empacota aplicativos com suas próprias dependências, isolando-os do restante do sistema.

Se você instalou softwares através do Flatpak, executar apt upgrade não afetará esses aplicativos. Você precisa atualizá-los separadamente:

flatpak list
flatpak update

flatpak list
flatpak update

O comando flatpak list mostra tudo o que foi instalado via Flatpak, e o comando flatpak update atualiza esses pacotes para suas versões mais recentes. É uma boa prática verificar regularmente, especialmente se você instalou IDEs, ferramentas de banco de dados ou aplicativos de comunicação por meio dele.

No Linux, o software pode ser instalado através do apt, Flatpak, Snap ou até mesmo manualmente. Cada um possui seu próprio mecanismo de atualização, portanto, uma rotina de atualização completa deve levar em consideração todos eles. Se você está acostumado com cada aplicativo tendo seu próprio atualizador, a principal diferença aqui é que você precisa saber qual gerenciador de pacotes é responsável por qual software e executar o comando de atualização correto para cada um.

Qual método você deve usar?

[4:19 - 5:32] A opinião de Tim é que ambas as abordagens são válidas e a escolha certa depende do seu fluxo de trabalho. Se você se sente mais confortável com uma interface visual, o Gerenciador de Atualizações realiza as mesmas atualizações que o apt, através de uma interface de apontar e clicar. Você não precisa memorizar comandos nem se preocupar em executar os passos na ordem errada. Dito isso, existe um bom motivo para se familiarizar com a linha de comando: a automação. Você pode criar um script shell simples que execute toda a sequência de atualização e agendá-lo para ser executado semanalmente usando o cron. Um script de três linhas que mantém seu sistema atualizado sem que você precise se preocupar com isso é o tipo de pequeno investimento que se multiplica ao longo do tempo.

Além da automação, a linha de comando permite aplicar seletivamente determinados níveis de atualização, dependendo do contexto, ou direcionar a saída para outras ferramentas para análise. Essas opções não estão disponíveis através da interface gráfica do usuário.

Auditoria dos pacotes instalados

[7:16 - 7:54] Há também um efeito colateral útil do processo de atualização: revisar sua lista de atualizações também serve como uma auditoria do que está instalado em seu sistema. Quando você vir um pacote na fila de atualizações, vale a pena perguntar se você ainda precisa dele.

Você pode ver o Firefox na lista de atualizações mesmo que use o Edge como dispositivo principal, ou vice-versa. Manter dois navegadores instalados para testes de compatibilidade entre navegadores em aplicações web faz sentido, mas o princípio mais amplo é que a lista de atualizações expõe toda a infraestrutura do seu ambiente de desenvolvimento. Ferramentas obsoletas de um projeto anterior, bibliotecas de desenvolvimento que foram incluídas como dependências e nunca removidas, pacotes que você esqueceu que instalou há seis meses: tudo isso aparece aqui.

Esse tipo de organização e limpeza compensa mais do que você imagina. Um ambiente de desenvolvimento limpo é mais fácil de replicar entre os membros da equipe, mais simples de conteinerizar e menos propenso a gerar bugs do tipo "funciona apenas na minha máquina". Se o seu servidor Linux tiver pacotes instalados que o seu Dockerfile não inclui, você pode estar dependendo de algo que não existirá em produção. Familiarizar-se com a implantação de aplicativos C# no Docker torna essa conexão entre seus pacotes locais e seu ambiente de produção muito mais concreta.

Conclusão

[7:54 - 8:25] Como Tim demonstra, todo o processo — seja pelo Gerenciador de Atualizações ou pela linha de comando — leva no máximo alguns minutos e protege você do acúmulo de dívida técnica no nível do sistema operacional. Transformar isso em um hábito semanal, em vez de uma tarefa ocasional, mantém suas ferramentas de desenvolvimento, dependências de tempo de execução e bibliotecas do sistema alinhadas, e esse alinhamento é o que torna o desenvolvimento multiplataforma em C# confiável, em vez de frustrante.

Para um passo a passo completo, confira o vídeo de Tim Corey em seu canal do YouTube.