Instalação e inventário

Introdução

Neste laboratório, você dará os primeiros passos no mundo do Ansible, uma poderosa ferramenta de automação de código aberto.

Imagine que você precise gerenciar 100 servidores. Fazer login em cada um deles para instalar software ou alterar configurações seria trabalhoso e sujeito a erros. O Ansible permite gerenciar esses servidores, chamados de nós gerenciados, a partir de um único nó de controle, sem instalar agentes nos destinos.

Esse design sem agentes é um dos principais motivos pelos quais o Ansible se tornou popular entre as equipes de operações. Ele reduz a quantidade de software adicional que você precisa manter em cada host e aproveita ferramentas nas quais os administradores já confiam, especialmente o SSH.

O Ansible funciona da seguinte forma:

Conecta-se aos servidores usando SSH (a mesma ferramenta usada para fazer login remotamente).
Lê instruções de arquivos de texto simples (escritos em YAML).
Envia pequenos programas (módulos) aos servidores para executar o trabalho.

Esse modelo sem agentes é um dos motivos pelos quais o Ansible se tornou popular. Ele aproveita ferramentas que os administradores de Linux já conhecem, especialmente SSH e configurações baseadas em texto.

Neste laboratório, você atuará tanto como gerenciador quanto como gerenciado. Você instalará o Ansible no seu ambiente e o configurará para gerenciar a si próprio (localhost). Essa é uma ótima maneira de aprender os conceitos básicos com segurança.

Você aprenderá a:

Instalar o Ansible usando o gerenciador de pacotes.
Configurar chaves SSH para que o Ansible possa fazer login sem senha.
Criar um arquivo de inventário para listar os computadores que você deseja gerenciar.
Testar a conexão usando o módulo ping.

Instalar o Ansible

O primeiro passo é instalar o software Ansible na sua máquina. Como estamos usando o Ubuntu, podemos usar o gerenciador de pacotes apt, que funciona como uma “loja de aplicativos” para ferramentas de linha de comando do Linux.

Embora o script de configuração já tenha executado uma atualização, é uma boa prática garantir que a lista de pacotes esteja atualizada:

sudo apt update

Agora, instale o Ansible executando:

sudo apt install ansible -y

Entendendo o comando:

sudo: Executa o comando com privilégios de administrador (root).
apt install: Informa ao gerenciador de pacotes que ele deve instalar um programa.
ansible: Nome do pacote que queremos instalar.
-y: Responde automaticamente “sim” a qualquer solicitação de confirmação, como “Deseja continuar?”.

Quando a instalação terminar, confirme que ela foi concluída verificando a versão:

ansible --version

Você deverá ver uma saída começando com ansible [core 2.x.x]. Isso confirma que o Ansible está instalado e pronto para uso.

Gerar chaves SSH

O Ansible usa SSH (Secure Shell) para se comunicar com os servidores. Essa é a forma padrão de acessar servidores Linux remotamente.

Por isso, o inventário é tão importante. O Ansible precisa de uma lista clara das máquinas existentes, de como elas estão agrupadas e de como acessá-las. Na prática, o inventário funciona como a agenda de endereços do seu sistema de automação.

Por padrão, o SSH exige uma senha. No entanto, para ferramentas de automação como o Ansible, digitar uma senha sempre que ele se conecta a um servidor é inviável. Em vez disso, usamos chaves SSH.

Pense nas chaves SSH como uma fechadura e uma chave:

Chave pública (a fechadura): você a coloca em qualquer servidor que deseja acessar.
Chave privada (a chave): você a mantém protegida no computador de controle.

Quando o Ansible se conecta, o servidor verifica se a sua “chave” corresponde à sua “fechadura”. Se corresponder, você entra sem precisar fornecer uma senha.

Gere um par de chaves executando:

ssh-keygen -t rsa -b 2048 -N "" -f ~/.ssh/id_rsa

Entendendo o comando:

ssh-keygen: Ferramenta usada para gerar chaves.
-t rsa: Cria uma chave do tipo RSA (padrão).
-b 2048: Define o tamanho da chave como 2048 bits (suficientemente seguro).
-N "": Define uma frase secreta vazia. Isso é essencial: significa “não me peça uma senha para usar esta chave”, permitindo que o Ansible seja executado de forma totalmente automática.
-f ~/.ssh/id_rsa: Salva a chave no local padrão.

Verifique se os arquivos foram criados:

ls -l ~/.ssh/

Você deverá ver id_rsa (sua chave privada secreta) e id_rsa.pub (sua chave pública).

Autorizar sua chave

Agora que você tem uma chave, precisa colocar a chave pública no servidor que deseja gerenciar. Neste laboratório, estamos gerenciando o localhost (a mesma máquina em que você está).

Esta etapa mostra a separação entre a autenticação e a lógica de automação. Antes que o Ansible possa automatizar qualquer tarefa, ele precisa de uma forma confiável e não interativa de autenticar-se no destino.

Você precisa adicionar o conteúdo de id_rsa.pub a um arquivo chamado authorized_keys, localizado na pasta .ssh.

Normalmente, você usaria um comando como ssh-copy-id. No entanto, esse comando geralmente solicita uma senha primeiro, para confirmar sua identidade. Como estamos em um ambiente de laboratório sem senha, copiaremos a chave manualmente.

Execute este comando para acrescentar sua chave pública à lista de chaves autorizadas:

cat ~/.ssh/id_rsa.pub >> ~/.ssh/authorized_keys

Entendendo o comando:

cat ...: Lê sua chave pública.
>>: Acrescenta a saída ao final do arquivo de destino, em vez de sobrescrevê-lo.
.../authorized_keys: Este é o arquivo que o SSH verifica para saber quem tem permissão para fazer login.

Agora, defina as permissões corretas para que o SSH confie no arquivo:

chmod 600 ~/.ssh/authorized_keys

Vamos testar. Tente fazer SSH na sua própria máquina:

ssh localhost "echo Hello from SSH"

Se aparecer a pergunta “Are you sure you want to continue connecting?”, digite yes e pressione Enter.

Você deverá ver “Hello from SSH” impresso imediatamente, sem que uma senha seja solicitada. Isso significa que o Ansible também poderá se conectar sem senha.

Criar um arquivo de inventário

O Ansible precisa de uma lista dos servidores que deve gerenciar. Essa lista é chamada de inventário.

O inventário pode ser um arquivo de texto simples. Criaremos um diretório de projeto e um arquivo de inventário chamado hosts.ini.

Crie um arquivo vazio chamado hosts.ini:

touch hosts.ini

Neste momento, o Ansible ainda não conhece nenhum servidor. Nós os adicionaremos na próxima etapa.

Adicionar um host ao inventário

Agora, edite o arquivo hosts.ini para adicionar nosso servidor. Os inventários do Ansible geralmente usam o formato INI, que tem esta aparência:

[group_name]
server_address

Agrupar servidores, como [webservers] ou [databases], permite executar comandos de uma só vez em todos os servidores daquele tipo.

Vamos adicionar localhost a um grupo chamado [webservers]. Execute este comando para gravar o conteúdo no arquivo:

echo -e "[webservers]\nlocalhost" > hosts.ini

Entendendo o comando:

echo -e: Imprime texto e permite caracteres especiais, como \n (nova linha).
"[webservers]\nlocalhost": Texto que queremos gravar. [webservers] fica na primeira linha e localhost, na segunda.
> hosts.ini: Sobrescreve o arquivo com esse conteúdo.

Verifique o conteúdo do arquivo:

cat hosts.ini

A saída deve ser exatamente esta:

[webservers]
localhost

Testar a conectividade

Chegou o momento da verdade. Vamos pedir ao Ansible que se conecte a todos os servidores do nosso inventário e verifique se eles estão disponíveis.

Usaremos o comando ansible (para executar tarefas avulsas) com o módulo ping.

Execute este comando:

ansible all -m ping -i hosts.ini

Entendendo o comando:

all: Corresponde a todos os hosts do seu inventário.
-m ping: Informa ao Ansible que ele deve usar o módulo chamado ping.
- Observação: este módulo é diferente do comando de rede ping. O ping do Ansible realmente faz login no servidor, verifica se o Python está disponível e retorna "pong". Isso comprova que sua configuração está funcionando.
-i hosts.ini: Informa ao Ansible que ele deve usar o arquivo de inventário que acabamos de criar, em vez do padrão do sistema.

Você deverá ver uma mensagem verde "SUCCESS":

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

Se você vir "ping": "pong", parabéns! Você configurou o Ansible com sucesso para gerenciar seu servidor.

Resumo

Neste laboratório, você criou a base para a automação com Ansible. Você aprendeu:

Instalação: Preparar o Ansible no seu sistema.
Configuração de chaves SSH: Criar “chaves” para que o Ansible possa fazer login com segurança e sem senhas.
Inventário: Criar uma lista (hosts.ini) dos servidores a serem gerenciados.
Verificação de conectividade: Usar o módulo ping para confirmar que tudo está funcionando.

Estas etapas — instalar, acessar, criar o inventário e testar — são as primeiras tarefas de qualquer projeto Ansible, seja para gerenciar um servidor ou mil.