Script de pós-instalação do Linux: como automatizar seu sistema após a formatação

Sim sempre Reinstale ou formate seu Linux. Você está perdendo uma tarde inteira tentando configurar o sistema "exatamente do jeito que você gosta" — precisa automatizar isso agora. Um bom script de pós-instalação permite que você, com um único comando, Atualize seu sistema, instale seus programas principais e aplique as configurações de segurança. e até mesmo ajustar com precisão o ambiente de desktop e os arquivos de configuração sem precisar executar comando por comando.

A ideia é muito simples: prepare um ou mais scripts Bash reutilizáveis Salve este arquivo em um pendrive USB inicializável com inicialização múltipla, no seu repositório de configuração ou em um disco rígido externo e execute-o imediatamente após instalar sua distribuição. A partir daí, o sistema funcionará no piloto automático e você só precisará monitorar erros graves. Vejamos como fazer isso em diferentes situações: desde uma instalação limpa típica do Ubuntu até cenários mais avançados com várias distribuições, incluindo ferramentas de instalação automatizadas.

O que é um script de pós-instalação no Linux e para que serve?

Um script de pós-instalação nada mais é do que um arquivo de texto executável Com comandos Bash que executam sequencialmente tudo o que você faria manualmente logo após instalar o Linux. Em vez de digitar "sudo apt install isso", "sudo apt install aquilo", ajustar o firewall, instalar snaps, etc., você escreve o comando uma vez e o reutiliza quantas vezes quiser.

Esse tipo de script geralmente é responsável por tarefas típicas de configuraçãoAtualize a distribuição, instale programas básicos (navegador, pacote de escritório, ferramentas de segurança, multimídia), ative e configure o firewall, ajuste alguns comportamentos do ambiente gráfico (por exemplo, o dock do GNOME) e, se desejar, execute outros scripts que carreguem seus arquivos de configuração, configurações do Vim, seu terminal ou qualquer outra coisa que você use diariamente.

Crie um script Bash básico para pós-instalação.

Vamos começar pela abordagem mais direta: um script Bash em sua casa que você pode copiar e colar em qualquer nova instalação. Isso é útil para quem troca de distribuição constantemente, para quem reinstala a mesma distribuição com frequência ou para ter um script reproduzível ao criar sistemas para outras pessoas.

Atualize o sistema de acordo com a distribuição.

Uma das primeiras coisas que todos fazem após instalar o Linux é pacotes de atualizaçãoEssa etapa também deve estar no seu script, mas é importante lembrar que cada distribuição usa um método diferente. um gerenciador de pacotes diferenteNormalmente, seu script é projetado para uma família específica (por exemplo, Debian/Ubuntu) e, se você trabalha com várias, deve ter um script diferente para cada caso.

Para distribuições do estilo Debian, Ubuntu e derivadosA sequência típica poderia ser:

sudo apt update && sudo apt -y upgrade

Em outras distribuições, as coisas são diferentes. Por exemplo, em CentOS e Red Hat “gostam” tem sido tradicionalmente usado yum:

sudo yum update

Apareceu em versões mais recentes do Fedora. DNF como uma evolução do yum, com uma sintaxe muito semelhante. Assim, para Fedora Você pode usar:

sudo dnf update

No caso de openSUSEO sistema de pacotes é normalmente gerenciado com Zíper e a atualização geral é feita com:

sudo zypper update

No mundo Arch Linux, Manjaro, Antergos, KaOS e outros baseados em Pac-Man, o equivalente seria:

sudo pacman -Syu

Se você também usa ferramentas externas como o yaourt (atualmente substituído pelo yay e outros auxiliares do AUR), em alguns ambientes a configuração era algo assim:

yaourt -Syua

Outros gostam Gentoo ou Slackware Eles possuem seus próprios gerenciadores e comandos de atualização. Nesse caso, seu script será adaptado ao que você utiliza (emerge, slapt-get, etc.), mas a ideia é sempre a mesma: Mantenha o banco de dados do sistema atualizado. Assim que a pós-instalação começar.

Organize a instalação do programa por categoria

Assim que o sistema for atualizado, é hora de Instale todo o software necessário.Para evitar que o script se torne caótico, é uma boa ideia classificar os pacotes em grupos lógicos e manter os comentários claros. Um esboço típico poderia ter categorias como estas:

UtilidadesFerramentas de sistema, compressores, monitores, etc.
InternetNavegadores, clientes de e-mail, mensagens.
JogosSteam, Lutris, jogos nativos, etc.
DE / MesasAmbientes gráficos e plugins.
MultimediaReprodutores de vídeo e áudio, editores de imagem.
ProdutividadePacotes de escritório, aplicativos para anotações, gerenciadores de tarefas.
desenvolvimentocompiladores, IDEs, ferramentas de depuração.

No script, você pode adicionar comentários a essas seções, facilitando a localização de cada bloco. Algo como isto:

# Utilidades # Desarrollo # Internet # Juegos # DE's y WM's # Multimedia # Productividad

Abaixo de cada bloco comentado, você adiciona os comandos de instalação apropriados para sua distribuição. Em um sistema baseado em Arch LinuxVocê poderia ter algo assim:

sudo pacman -S chromium sudo pacman -S steam sudo pacman -S gnome-shell gnome-extra

O objetivo é que, ao executar o script, todos os... aplicativos que você costuma usarSe em algum momento você quiser alterar sua seleção (adicionar ou remover um programa), basta modificar a lista de pacotes nessa categoria e pronto.

Execute o script e siga as melhores práticas.

Depois de escrever e salvar seu roteiro install.shA partir do terminal, basta navegar até a pasta onde o programa está localizado e executá-lo. Uma prática comum é combinar a mudança de diretório com a execução do programa:

cd /ruta/del/script && ./install.sh

Outra opção muito simples para usuários do Ubuntu ou Debian é invocar o bash diretamente Sobre o arquivo:

bash nombre-script.sh

Para evitar ter que esperar por confirmações, muitos comandos de instalação usam o parâmetro -y (ou equivalente) que aceite a pergunta "Deseja continuar?" por padrão. Dessa forma, o script pode a ser executado do início ao fim sem intervençãoO que é conveniente quando você o inicia logo após instalar o sistema e o deixa executando atualizações, instalações e limpeza enquanto você faz outra coisa.

Exemplo prático de um script pós-instalação no Ubuntu

Em um cenário típico com Ubuntu 22.04 LTS ou posteriorFaz sentido criar um script que combine APT e Snap, pois alguns aplicativos estão disponíveis apenas como snaps. Um exemplo de fluxo de trabalho poderia ser: atualizar, instalar pacotes padrão, limpar o sistema, instalar snaps importantes, ativar o firewall e aplicar alguns ajustes na área de trabalho.

Um esqueleto simples desse tipo de script poderia conter blocos como este:

#!/bin/bash

# Atualizar a lista de pacotes
sudo apt update

# Instale as atualizações disponíveis sem perguntar
sudo apt -y upgrade

Remova as embalagens que não são mais necessárias e faça a limpeza.
sudo apt -y autoremove
sudo apt limpeza automática

# Instale aplicativos comuns via APT
sudo apt -y install vlc gimp clamav chkrootkit lynis

# Instale aplicativos comuns como o Snap
sudo snap install chromium brave

# Ativar UFW (firewall do kernel Linux)
sudo ufw enable

# Ajustar o comportamento do dock do GNOME
gsettings set org.gnome.shell.extensions.dash-to-dock click-action 'minimize'

Com algo tão compacto que você está cobrindo Atualizações, limpeza, software base, segurança e um pequeno ajuste de usabilidade.Claro, você pode estender este script ao seu gosto: adicionar instalação de ferramentas de desenvolvimento, configuração de backup, scripts que baixam seus arquivos de configuração do Git, etc.

Utilize ferramentas avançadas: Ansible, Chef e similares.

Se você trabalha com várias máquinas ou precisa replicar seu ambiente em servidores, laptops e desktops, chega um ponto em que um simples script Bash se torna insuficiente. É aí que ferramentas como Ansible, Chef e empresas do setor, que permitem descrever o estado desejado de um sistema (pacotes instalados, arquivos de configuração, serviços ativos) e aplicá-lo de forma reproduzível.

Alguns usuários que estão cansados de sempre fazer a mesma configuração pós-instalação no Ubuntu recorrem a esses sistemas de gerenciamento de configuração ou projetos pré-fabricados. pós-instalação específicaUm exemplo prático é um repositório dedicado à automatização da pós-instalação no Ubuntu, onde scripts Bash são combinados com definições de pacotes, temas, fontes e outras preferências.

Mesmo assim, para muitos casos de uso em computadores desktop, a solução mais prática continua sendo... Script Bash sem dependências externasespecialmente se você procura algo fácil de transportar em um pen drive ou que possa ser copiado para uma máquina recém-instalada sem a necessidade de configurar infraestrutura adicional.

Automação diretamente do instalador: scripts %post e Kickstart

No mundo das distribuições de tipos Red Hat, CentOS, Rocky e derivados, é muito comum usar Kickstart Para instalações não supervisionadas. Uma seção pode ser definida dentro de um arquivo Kickstart. %post que é executado automaticamente após a conclusão da instalação do sistema básico.

A ideia é que, se você tiver definido o configuração de rede No próprio Kickstart, ao acessar a seção de pós-instalação, a rede já estará configurada e funcionando. Lá, você pode inserir qualquer comando que desejar automatizar: instalar pacotes adicionais, ajustar configurações, baixar scripts, alterar mensagens do sistema, etc.

Como um exemplo simples, poderíamos alterar o Mensagem do Dia (MOTD) do sistema recém-instalado, colocando-o na seção %post algo equivalente a:

%post echo "Bienvenido a tu nuevo servidor" > /etc/motd %end

Essa abordagem de incorporar um script pós-instalação no instalador é Muito poderoso para implantações em larga escala.Como todo o processo é 100% automático: a instalação inicia, as partições e os pacotes básicos são aplicados, os scripts pós-instalação são executados e o sistema está pronto para uso.

Limitações na replicação de instalações entre distribuições heterogêneas

Ao tentar usar um único mecanismo genérico de pós-instalação para distribuições muito diferentesÉ aí que começam os problemas. Nem todos gerenciam atualizações, dependências e correções da mesma maneira, nem oferecem as mesmas versões de software em seus repositórios.

Devemos distinguir, por um lado, uma escrita que apenas enumera pacotes para instalar e permite que o gerenciador de dependências da distribuição resolva as dependências (como o apt-get ou ferramentas como zypper, dnf, urpmi), e, por outro lado, um sistema que também pretende lidar com correções de segurança, versões anteriores e novas versões. de programas que a distribuição original nem sequer fornece.

Em uma distribuição como DebianCom milhares de pacotes e um vasto ecossistema, o instalador e ferramentas como o apt gerenciam as dependências de software mantidas pela própria distribuição. Em outras distribuições, especialmente as comerciais, a filosofia é diferente: elas fornecem o conjunto de pacotes e patches que escolheram suportar e, além disso, você entra em um mundo onde... A resolução de dependências e atualizações não é garantida..

Um exemplo ilustrativo: em um SuSE 8.2 Antigamente, se você quisesse atualizar o PostgreSQL com o apt para uma versão mais recente do que a versão original da distribuição, perceberia que o apt primeiro solicitava a versão incluída nos CDs oficiais. Você precisava acessar o YaST, selecionar o pacote original para instalação a partir do CD correspondente e somente então o apt aceitaria a atualização adicional de seus repositórios. Esse tipo de peculiaridade dificultava a manutenção de um ambiente estável. uma única ferramenta que funciona sem intervenção em todos os casos..

Métodos rápidos para identificar o tipo de arquivo no Windows e no Linux

Scripts pós-instalação em ambientes personalizados e LFS

No extremo oposto das distribuições pré-configuradas, encontram-se os ambientes que você mesmo cria. seu sistema Linux do zero, no estilo do Linux From Scratch (LFS). Aqui, a pós-instalação não é mais uma lista de pacotes, mas se torna um uma série muito longa de passos guiados: compilação de ferramentas, criação de partições, montagem de sistemas de arquivos, ajustes na cadeia de ferramentas, configuração de serviços básicos, etc.

Seguir um guia detalhado do LFS ou uma abordagem mais didática ajudará você a entender o sistema desde as camadas mais baixas: compiladores, linkers, bibliotecas C, shell, utilitários básicos, até o kernel e a inicialização com o GRUB. Esse processo pode ser demorado. vários dias (entre 3 e 5, facilmente)Requer paciência e um certo nível de conhecimento em administração Unix, mas em troca oferece uma Controle total sobre o que será instalado. e como o sistema é montado.

Em um caso real, usando Debian como sistema hospedeiro dentro de uma máquina virtual em VirtualBoxO processo começa com a criação de uma máquina virtual com um disco de, por exemplo, 30 GB, a instalação do Debian 10 como base e o ajuste fino dos repositórios em /etc/apt/sources.list para poder acessar os pacotes de compilação (build-essential, linux-headers-amd64etc.) e depois instale o Adições do VBoxLinux Para ter integração completa com o host.

Assim que o sistema base estiver confortável de usar (tela cheia, dependências de compilação resolvidas), um segunda unidade de disco virtualEste segundo disco, também de tamanho fixo, será onde o novo sistema Linux personalizado será instalado. Este segundo disco está particionado a partir do Debian (por exemplo). /dev/sdb) com ferramentas como se separaramUma tabela de partições do tipo msdos é definida e partições primárias e lógicas (raiz, swap, /home) são criadas seguindo um esquema semelhante ao do primeiro disco.

Essas partições são então formatadas com os sistemas de arquivos apropriados e seus conteúdos são obtidos. UUID com utilidades como blkid e as entradas são adicionadas a /etc/fstab do sistema host para montá-los em pontos como /mnt/lfs, /mnt/lfs/home e para habilitar o trocarA partir daí, a estrutura básica é construída, e diretórios como $LFS/sources y $LFS/toolsuma longa lista de pacotes é baixada com wget usando um arquivo wget-list e um usuário dedicado é criado, por exemplo. lfs, com seu .bash_profile y .bashrc adaptado ao ambiente de compilação.

O processo continua com um verificador (um script de controle de versão) que verifica se todas as ferramentas necessárias estão presentes (Bash, Binutils, GCC, etc.), em muitos casos instalando tanto o pacote principal quanto sua variante de desenvolvimento (-dev o -desenvolverTambém são criadas ligações simbólicas importantes, como por exemplo, a criação de links simbólicos. /bin/sh Aponte para o Bash, e pacotes como este serão compilados um a um. binutils, gcc, glibc, tcl, expect, dejagnu, m4, ncurses, bison, bzip2, coreutils, diffutils, file, findutils, gawk, gettext, grep, gzip, make, patch, perl, Python, sed, tar, texinfo, xz e muitas outras, em duas rodadas (cadeia de ferramentas temporária e cadeia de ferramentas final dentro do chroot).

O caminho geralmente é limpo. símbolos de depuração Bibliotecas desnecessárias são removidas para economizar espaço, bibliotecas estáticas não essenciais são eliminadas, a cadeia de ferramentas é ajustada para que todas as novas compilações usem as bibliotecas recém-instaladas e o ambiente é configurado. chroot Preparando /dev, /proc, /sys, /run e criando nós como /dev/console y /dev/null.

A árvore de diretórios padrão é construída dentro do chroot (/bin, /sbin, /usr, /var, /etc…), links simbólicos temporários são gerados para programas que ainda não existem e são inicializados / Etc / passwd y / etc / group com um usuário root mínimo, e os arquivos de log são preparados em /var/log Com as permissões corretas. Os seguintes itens também estão configurados: local com ferramentas como locale-gen ou equivalente, o fuso horário é selecionado com tzselect e um link é criado a partir de /etc/localtime para a área escolhida em /usr/share/zoneinfo.

Outro elemento crucial é a configuração de nsswitch.conf para que a resolução de nomes e outros serviços funcionem bem na rede, e o ld.so.conf junto com ldconfig para registrar os caminhos das novas bibliotecas dinâmicas. Em seguida, com a glibc e os compiladores finais, os pacotes principais são recompilados para garantir que tudo esteja vinculado corretamente.

Em paralelo, o acesso à rede está sendo configurado no novo sistema: arquivos estão sendo criados. /etc/sysconfig/ifconfig.eth0 (ou o nome da interface correspondente), o endereço IP, o gateway e a máscara são definidos e o seguinte é gerado: / Etc / resolv.conf com os servidores DNS apropriados e eles são resolvidos. hostname y / Etc / hosts com as informações da máquina.

Os scripts e arquivos de inicialização também são configurados como / etc / inittab, / etc / sysconfig / clock, / etc / sysconfig / console y /etc/sysconfig/rc.siteonde são ajustados detalhes como o nível de execução padrão, o tratamento de logs do sistema, o idioma do console, o mapeamento do teclado e o comportamento do serviço na inicialização.

A experiência com o shell é personalizada. / etc / profile e arquivos do tipo ~ / .bash_profile y ~ / .bashrc, Plus / etc / inputrc para a biblioteca Readline (controlando atalhos de teclado, comportamento do histórico de comandos, etc.). Um / etc / shells com a lista de shells válidos e um / etc / fstab adaptado às novas partições (raiz, home, swap, /boot se existir).

A próxima etapa é compilar o Kernel Linux: a versão escolhida é descompactada (por exemplo, um linux-5.x.y), partindo de um arquivo de configuração base, as opções principais são revisadas, tais como: CONFIG_DEVTMPFS e outros relacionados ao udev e ao hardware da VM, você entra no menu de configuração (make menuconfig) para ajustar o nome de host padrão e vários recursos, e finalmente é compilado (make, make modules_install) e o kernel e seus componentes são instalados em /boot.

A etapa final geralmente consiste em instalar e configurar. GRUB como um carregador de inicialização. Os comandos são executados para gravar o GRUB no MBR do disco correto, gerando um grub.cfg com as entradas para o novo kernel e, se aplicável, para outros sistemas presentes. Neste contexto específico, como a distribuição Debian do host foi usada apenas como uma "estrutura", seu disco virtual é eventualmente removido da máquina, de modo que o disco que estava inicialmente /dev/sdb acontece de ser / Dev / sda e o novo sistema Linux inicia automaticamente.

Quando tudo estiver pronto, serão criados arquivos de identificação, como por exemplo: / etc / lsb-release y / etc / os-release com o nome da nova distribuição (por exemplo, “S4viOS”), um bashrc Agradável para o usuário root e futuros usuários, e uma desmontagem final do sistema de arquivos é realizada antes do grande momento: reiniciar a VM, escolher a entrada correspondente no GRUB e ver... Como inicializar pela primeira vez o sistema Linux que você criou do zero.

MóvilForum