Instale todos os pacotes essenciais de uma vez no Debian e Ubuntu com Bash e Ansible

Depois de uma instalação limpa do Debian, há normalmente vários packages que instalo sempre. Em vez de instalá-los um por um manualmente, eu os mantenho em um script Bash simples e instalo tudo com um único command.

Para mim, essa é uma solução leve e efficiente para instalação básica de pacotes. Não há necessidade de usar nenhuma plataforma de automação só para instalar uma lista de packages.

Então, basicamente, é isto o que faço depois de instalar o Debian:

• Executo um script Bash simples de pós-iinstalação;
• Instalo todos os packages necessários.

Meu script é bem minimalista e contém dois tipos de packages:

• Ferramentas básicas, úteis em praticamente qualquer desktop;
• Pacotes pessoais de desktop, que eu quero especficamente.

Se a configuração depois crescer além da instalação de pacotes e passar a incluir configuração do sistema, então eu vou para o Ansible.

Observe que este guia é especficamente um guia de pós-iinstalação focado em pacotes, e não um guia completo/geral de pós-instalação do Debian ou do Ubuntu. Se você quer um guia completo de pós-instalação essencial, veja os links abaixo:

• Debian Server Setup: Essential Post-Installation Steps
• DebPostInstall: Debian And Ubuntu Server Post Install Script
• An Automated Way To Install Essential Applications On Ubuntu

1. Crie um script Bash simples de pós-instalação para Debian / Ubuntu

É conveniente manter todos os scripts em um único diretório. Então vou criar um diretório de scripts:

mkdir -p ~/scripts

Crie o script:

nano ~/scripts/install-deb-essential-packages.sh

Adicione:

#!/usr/bin/env bash
set -euo pipefail
PACKAGES=(
# Basic tools
git
curl
wget
ca-certificates
unzip
build-essential
# Personal desktop packages
firmware-cirrus
papirus-icon-theme
timeshift
gnome-shell-extension-manager
vim
gnome-shell-extension-dashtodock
gnome-themes-extra
flatpak
gnome-software-plugin-flatpak
steam-installer
)
echo "Updating package lists..."
sudo apt update
echo "Installing packages..."
sudo apt install -y "${PACKAGES[@]}"
echo "Done."

Note que alguns packages estão disponíveis apenas para uma plataforma específica. Então talvez você precise editar este script e adicionar ou remover packages de acordo com a sua distribuição Linux. Depois de adicionar todos os pacotes essenciais a instalar, salve o script e feche-o.

Torne-o executável:

chmod +x ~/scripts/install-deb-essential-packages.sh

Os comandos de instalação usam sudo e, portanto, exigem privilégios administrativos na máquina. Execute o script para instalar todos os pacotes essenciais de uma vez no seu sistema Debian/Ubuntu:

~/scripts/install-deb-essential-packages.sh

Você pode usar o mesmo script em outros sistemas baseados em Debian, como Ubuntu e derivados do Ubuntu, como Linux Mint, Pop!_OS, ElementaryOS e Zorin OS.

Como já foi dito, alguns packages podem estar disponíveis apenas para uma edição específica. Apenas make questão de garantir que os packages do script estejam disponíveis para a sua distribuição Linux. Você pode verificar a disponibilidade dos pacotes como descrito no link abaixo:

• How To Check Package Availability In Debian and Ubuntu Repositories

2. Por que esses pacotes básicos?

O primeiro grupo é intencionalmente pequeno.

git

Útil para clonar repositórios e gerenciar arquivos de configuração.

git clone ...

curl

Uma ferramenta de linha de command de propósito geral para transferir dados por protocolos de rede. Muitas instruções de instalação e scripts a utilizam.

wget

Outro downloader de linha de command útil.

ca-certificates

Fornece certificados de CA confiáveis usados por softwares para conexões HTTPS/TLS.

unzip

Útil porque softwares e projetos baixados frequentemente vêm como arquivos .zip.

build-essential

Fornece o conjunto básico padrão de ferramentas de compilação, incluindo ferramentas como gcc e make. O Debian o identifica especficamente como o pacote-chave para um ambiente básico de compilação.

build-essential não é estritamente necessário para todo usuário de desktop. Se eu sei que não vou compilar software, posso removê-lo. Ele está incluído aqui porque é uma base útil para uma máquina pessoal voltada ao desenvolvimento.

3. Por que usar um array Bash?

Em vez de executar manualmente:

sudo apt install git
sudo apt install curl
sudo apt install wget
sudo apt install unzip

Eu mantenho uma única lista:

PACKAGES=(
git
curl
wget
unzip
)

Depois instalo tudo com:

sudo apt install -y "${PACKAGES[@]}"

Isso é:

• Mais rápido
• Mais fácil de manter
• Fácil de modificar
• Fácil de reutilizar depois de reinstalar o Debian

Adicionar um pacote é tão simples quanto adicionar outra linha:

PACKAGES=(
git
curl
wget
neovim
)

4. Por que set -euo pipefail?

Como você deve ter notado, o script começa com:

set -euo pipefail

Isso torna o script mais seguro.

Em particular, -e faz o script parar quando um command falha, em vez de continuar cegamente.

Para um pequeno script pessoal de configuração, esse é um bom padrão.

5. Mantenha os pacotes pessoais separados

À medida que a lista cresce, pode ser útil distinguir entre ferramentas de -propósito geral e coisas especficíficas da minha configuração.

Por exemplo:

PACKAGES=(
# Basic tools
git
curl
wget
ca-certificates
unzip
build-essential
# Desktop
firmware-cirrus
papirus-icon-theme
gnome-shell-extension-manager
gnome-shell-extension-dashtodock
gnome-themes-extra
# Applications
timeshift
flatpak
gnome-software-plugin-flatpak
steam-installer
# Editor
vim
)

Isso torna o script mais fácil de entender depois.

6. Quando eu uso o Ansible?

Alguns de vocês devem se perguntar por que não usar apenas plataformas de automação como o Ansible e pronto. Eu não uso Ansible só para uma lista de pacotes. O Ansible se torna útil quando começo a fazer coisas como:

• Instalar packages
• Configurar o Git
• Criar arquivos de configuração
• Configurar o Vim
• Habilitar serviços
• Configurar o GNOME
• Aplicar configurações do sistema

Ou quando quero a mesma configuração em várias máquinas.

Para simples instalação de pacotes, uso Bash. Para configuração de sistema repetível, vou de Ansible.

7. Instale o Ansible

O Ansible é uma ferramenta de automação de TI de linha de command, de código aberto, escrita em Python. Ele pode configurar sistemas, implantar software e orquestrar fluxos de trabalho avançados para dar suporte à implantação de aplicações, a atualizações de sistema e muito mais.

Ele é conhecido por ser "agentless", ou seja, gerencia máquinas remotas por protocolos de conexão padrão sem instalar software persistente nelas.

Como funciona

Você escreve instruções legíveis por humanos em YAML (chamadas "playbooks") que declaram o estado desejado dos seus servidores. O Ansible se conecta via SSH (para Linux/Unix) ou WinRM (para Windows), verifica o estado atual e só make mudanças se for necessário para corresponder às suas instruções. Nenhum agente ou daemon extra é necessário nos nós gerenciados.

Pontos principais

• Arquitetura sem agente: Diferente de ferramentas que exigem um agente persistente em cada servidor, o Ansible usa o seu daemon SSH já existente (ou WinRM para Windows) como transporte. Isso reduz a sobrecarga de manutenção e elimina a necessidade de gerenciar atualizações ou compatibilidade de software de agente.
• Idempotência: Este é um princípio central. Os módulos do Ansible são projetados para serem idempotentes quando possível, ou seja, só fazem mudanças em um sistema quando o estado desejado ainda não foi alcançado. Executar o mesmo playbook várias vezes produz o mesmo resultado. Observação: alguns módulos (como command e shell) não têm esse comportamento nativamente e exigem aplicação manual.
• Simplicidade via YAML: Os playbooks são escritos em YAML, uma linguagem legível por humanos. Isso significa que seu código de automação muitas vezes se lê como documentação, tornando-o acessível até para quem não é programador dedicado.
• Modelo push: Você executa o Ansible de um "nó de controle" central, e ele envia as mudanças de configuração para os "nós gerenciados" via SSH (ou WinRM para Windows).

Um fato interessante sobre o Ansible

Embora o Ansible seja famoso por ser "agentless", ele na verdade usa um agente minúsculo e efêmero — mas apenas temporariamente. Para cada tarefa, o Ansible se conecta aos nós gerenciados e envia pequenos programas, chamados módulos Ansible, para eles.

Esses programas são escritos para serem modelos de recursos do estado desejado do sistema. O Ansible então executa esses módulos (via SSH por padrão) e os remove quando finished. Isso deixa o servidor exatamente como estava antes da automação, sem nenhum software Ansible persistente instalado.

Para instalar o Ansible no Debian / Ubuntu, execute:

sudo apt update
sudo apt install ansible

Verifique a versão:

ansible --version

Saída de exemplo:

ansible [core 2.16.3]
config file = None
configured module search path = ['/home/ostechnix/.ansible/plugins/modules', '/usr/share/ansible/plugins/modules']
ansible python module location = /usr/lib/python3/dist-packages/ansible
ansible collection location = /home/ostechnix/.ansible/collections:/usr/share/ansible/collections
executable location = /usr/bin/ansible
python version = 3.12.3 (main, Apr 10 2024, 05:33:47) [GCC 13.2.0] (/usr/bin/python3)
jinja version = 3.1.2
libyaml = True

8. Crie um projeto Ansible

Para um desktop pessoal:

mkdir -p ~/ansible/debian-desktop
cd ~/ansible/debian-desktop

Inicialize o Git:

git init

Estrutura inicial:

debian-desktop/
├── inventory.ini
└── site.yml

9. Crie o inventário

Crie o arquivo inventory.ini:

inventory.ini

Adicione:

[desktop]
localhost ansible_connection=local

Isso diz ao Ansible para gerenciar meu computador atual localmente.

Teste com command:

ansible -i inventory.ini desktop -m ping

Saída de exemplo:

localhost | SUCCESS => {
"ansible_facts": {
"discovered_interpreter_python": "/usr/bin/python3"
},
"changed": false,
"ping": "pong"
}

10. Crie o playbook

Crie o arquivo site.yml:

nano site.yml

Adicione as seguintes linhas:

---
- name: Configure my Debian desktop
hosts: desktop
become: true
tasks:
- name: Update apt cache
ansible.builtin.apt:
update_cache: true
- name: Install desktop packages
ansible.builtin.apt:
name:
- git
- curl
- wget
- ca-certificates
- unzip
- build-essential
- firmware-cirrus
- papirus-icon-theme
- timeshift
- gnome-shell-extension-manager
- vim
- gnome-shell-extension-dashtodock
- gnome-themes-extra
- flatpak
- gnome-software-plugin-flatpak
- steam-installer
state: present

Novamente, adicione no playbook acima os packages que a sua plataforma suporta. Salve e feche o arquivo.

Execute o playbook:

ansible-playbook -i inventory.ini site.yml --ask-become-pass

Saída de exemplo:

BECOME password:
PLAY [Configure my Debian desktop] ********************************************************************************************************************************************************************************************************
TASK [Gathering Facts] ********************************************************************************************************************************************************************************************************************
ok: [localhost]
TASK [Update apt cache] *******************************************************************************************************************************************************************************************************************
changed: [localhost]
TASK [Install desktop packages] ***********************************************************************************************************************************************************************************************************
changed: [localhost]
PLAY RECAP ********************************************************************************************************************************************************************************************************************************
localhost : ok=3 changed=2 unreachable=0 failed=0 skipped=0 rescued=0 ignored=0

11. Diferença entre script Bash e Ansible

O Bash geralmente diz: Execute estes commands.

O Ansible geralmente diz: Faça a máquina ficar assim.

Por exemplo:

- name: Install Vim
ansible.builtin.apt:
name: vim
state: present

Se o Vim não estiver instalado, o Ansible instrui o sistema a instalá-lo. Se o Vim já estiver instalado, ele simplesmente diz não faça nada.

Isso se chama idempotência.

12. Adicionando configuração

Depois que a instalação de pacotes funciona, o Ansible também pode gerenciar configuração.

Por exemplo:

- name: Create Vim configuration
ansible.builtin.copy:
content: |
set number
set relativenumber
syntax on
dest: "{{ ansible_facts.user_dir }}/.vimrc"
mode: "0644"

Agora o Ansible não está apenas instalando software. Ele está configurando a máquina.

13. Divida as coisas quando o playbook ficar grande

Não se preocupe com roles do Ansible imediatamente.

Se o site.yml ficar grande demais, você pode dividir as tarefas em arquivos separados:

debian-desktop/
├── inventory.ini
├── site.yml
├── packages.yml
├── git.yml
└── desktop.yml

O site.yml é o playbook principal. Ele importa e executa as tarefas dos outros arquivos:

---
- name: Configure my Debian desktop
hosts: desktop
become: true
tasks:
- ansible.builtin.import_tasks: packages.yml
- ansible.builtin.import_tasks: git.yml
- ansible.builtin.import_tasks: desktop.yml

Os arquivos individuais têm propósitos específicos:

• packages.yml - contém tarefas para instalar e gerenciar pacotes APT.
• git.yml - contém tarefas para configurar o Git.
• desktop.yml - contém tarefas para configurar o GNOME e outras configurações de desktop.

Por exemplo, packages.yml pode conter:

---
- name: Install required packages
ansible.builtin.apt:
name:
- git
- curl
- wget
- vim
- flatpak
state: present

Isso mantém o site.yml pequeno e make a configuração mais fácil de entender e manter.

14. Eventualmente, use roles do Ansible para configurações complexas

Se o projeto ficar muito maior, você pode introduzir roles do Ansible.

A estrutura pode eventualmente ficar assim:

debian-desktop/
├── inventory.ini
├── site.yml
└── roles/
├── packages/
├── git/
├── vim/
└── gnome/

Cada role agrupa todas as tarefas, arquivos, templates, variáveis e configuração relacionadas a uma área específica.

Por exemplo:

• packages - gerencia os packages instalados.
• git - gerencia a configuração do Git.
• vim - gerencia a configuração do Vim.
• gnome - gerencia o GNOME e a configuração do desktop.

Não comece com roles. Para uma máquina pessoal, comece com um único site.yml. Se ele ficar grande, divida-o em arquivos como packages.yml, git.yml e desktop.yml. Só introduza roles quando o projeto tiver crescido o suficiente para que eles tragam um benefício real.

15. Comandos úteis do Ansible

Teste o Ansible:

ansible -i inventory.ini desktop -m ping

Execute o playbook:

ansible-playbook -i inventory.ini site.yml --ask-become-pass

Simulação (dry run):

ansible-playbook -i inventory.ini site.yml --check --ask-become-pass

Mais saída:

ansible-playbook -i inventory.ini site.yml --ask-become-pass -v

16. Mantenha a configuração no Git

Para o script Bash:

cd ~/scripts
git init

Para o projeto Ansible:

cd ~/ansible/debian-desktop
git init

Com o tempo, o projeto Ansible pode se tornar a descrição canônica da configuração do meu desktop.

17. E quanto ao Fedora ou a distribuições baseadas em RHEL?

A estrutura Bash do script pode ser reutilizada no Fedora e em outras distribuições baseadas em RHEL, mas você não deve assumir que simplesmente trocar apt por dnf é suficiente.

No Debian:

sudo apt update
sudo apt install -y "${PACKAGES[@]}"

Em sistemas Fedora/RHEL, a instalação de pacotes geralmente usa:

sudo dnf install -y "${PACKAGES[@]}"

No entanto, os nomes dos pacotes podem diferir entre distribuições.

Por exemplo:

Debian              Fedora/RHEL
-------             ----------
git                 git
curl                curl
wget                wget
ca-certificates     ca-certificates
unzip               unzip
build-essential     gcc gcc-c++ make

Alguns packages podem ter nomes completamente diferentes, podem ser fornecidos por repositórios diferentes ou podem não existir da mesma forma.

Portanto, para uma configuração pessoal, geralmente é mais limpo manter scripts separados:

install-debian-essential-packages.sh
install-fedora-essential-packages.sh

O script do Debian pode usar:

sudo apt update
sudo apt install -y "${PACKAGES[@]}"

enquanto o script do Fedora pode usar:

sudo dnf install -y "${PACKAGES[@]}"

com uma lista de pacotes especficífica do Fedora.

Por que não make um único script para tudo?

É possível detectar a distribuição:

if command -v apt >/dev/null 2>&1; then
sudo apt update
sudo apt install -y "${PACKAGES[@]}"
elif command -v dnf >/dev/null 2>&1; then
sudo dnf install -y "${PACKAGES[@]}"
else
echo "Unsupported package manager."
exit 1
fi

Mas isso fica mais complicado quando os nomes dos pacotes diferem.

Para uma configuração pessoal simples, scripts separados são mais fáceis de entender e manter.

Se a configuração eventualmente precisar dar suporte a várias distribuições e ficar muito mais complicada, esse é um bom momento para considerar o Ansible.

18. Conclusão

Como você pode ver, podemos usar um script Bash simples de pós-iinstalação para evitar instalar manualmente os mesmos packages um por um. Se você quiser automatizar e reproduzir a configuração de todo o sistema, então pode usar o Ansible.

Não introduza o Ansible até que o problema seja grande o suficiente para precisar dele.

Não complique as coisas. Comece simples. Automatize o que se torna repetitivo. Introduza o Ansible quando for a configuração que precisa ser gerenciada.