ULC Lab · implementação reproduzível

Laboratório: Orquestração de Provisionamento e Configuração de Servidores Linux com Ansible

Você vai automatizar o provisionamento e a configuração de dois servidores Linux virtuais usando Ansible, incluindo instalação de pacotes, criação de usuários e aplicação de hardening básico. O laboratório pode ser executado em cerca de 2 horas.

Ligado ao treinamento Automação e orquestração de data center com Ansible: do zero à governança avançada

ULC-LAB-DATA-0002 · Status de validaçãoNão validado pela Upnetix: roteiro derivado da documentação oficial, para você executar e validar

Duração estimada: 120 min
Passos: 11
Validações: 5
Versões da documentação consultada: Ansible 2.15 · OpenSSH a versão estável atual · Python 3.8 ou superior

Objetivo

O objetivo é demonstrar como o Ansible pode ser usado para padronizar e automatizar tarefas de configuração em múltiplos servidores, reduzindo erros humanos e acelerando o tempo de entrega. Você aprenderá a criar um inventário, escrever playbooks, aplicar configurações idempotentes e validar o resultado. No final, terá uma base pronta para expandir a automação em ambientes de data center, como os operados pela Upnetix.

Topologia

O ambiente terá uma máquina controladora (Ansible) conectada via SSH a dois servidores Linux (SRV1 e SRV2), todos na mesma rede privada (exemplo: 192.168.56.0/24). O acesso SSH será feito com chave pública/privada. O Ansible aplicará configurações idênticas nos dois servidores.


           +-------------------+
           |  Controladora     |
           |  (Ansible)        |
           |  192.168.56.10    |
           +---------+---------+
                     |
         +-----------+-----------+
         |                       |
+--------+--------+     +--------+--------+
|   SRV1 (Linux)  |     |   SRV2 (Linux)  |
| 192.168.56.21   |     | 192.168.56.22   |
+-----------------+     +-----------------+

Equipamentos e software

Item	Requisito, licença ou versão
Controladora (VM ou física)	1 vCPU, 1GB RAM, 1 porta de rede, Ubuntu 20.04 ou superior
Servidor 1 (VM)	1 vCPU, 512MB RAM, 1 porta de rede, Ubuntu 20.04 ou superior
Servidor 2 (VM)	1 vCPU, 512MB RAM, 1 porta de rede, Ubuntu 20.04 ou superior
Ansible	GNU GPLv3 · 2.15
OpenSSH	BSD · a versão estável atual
Python	PSF License · 3.8 ou superior

Roteiro

Preparar as máquinas virtuais
Crie três VMs: uma para a controladora (Ansible) e duas para os servidores. Todas devem estar na mesma rede privada. Isso reflete um cenário real de automação em data center.
O que você deve ver: As três VMs estão acessíveis via ping entre si.
Instalar o Ansible na controladora
O Ansible será a ferramenta de orquestração. Instale-o na controladora.
```
sudo apt update && sudo apt install -y ansible
```
O que você deve ver: O comando 'ansible --version' retorna a versão instalada.
Configurar acesso SSH sem senha
O Ansible exige SSH sem senha para automação. Gere um par de chaves na controladora e copie a chave pública para os dois servidores.
```
ssh-keygen -t ed25519 -C "ansible-lab" -N ""
ssh-copy-id user@192.168.56.21
ssh-copy-id user@192.168.56.22
```
O que você deve ver: Conexão SSH da controladora para os servidores sem pedir senha.
Testar conectividade SSH
Antes de automatizar, garanta que o SSH está funcionando.
```
ssh user@192.168.56.21 'hostname'
ssh user@192.168.56.22 'hostname'
```
O que você deve ver: Os nomes dos hosts dos servidores são exibidos.
Criar o inventário do Ansible
O inventário define quais máquinas o Ansible vai gerenciar. Crie um arquivo chamado 'hosts' na controladora.
```
cat > ~/hosts <<EOF
[srv_linux]
192.168.56.21 ansible_user=user
192.168.56.22 ansible_user=user
EOF
```
O que você deve ver: Arquivo 'hosts' criado com os IPs dos servidores.
Testar o inventário com Ansible
Valide se o Ansible consegue se conectar aos servidores.
```
ansible -i ~/hosts srv_linux -m ping
```
O que você deve ver: Resposta 'pong' dos dois servidores.

Criar o playbook de configuração

O playbook define as tarefas automatizadas. Crie um arquivo 'setup.yml' com as ações desejadas: instalar 'htop', criar usuário 'operador', e aplicar hardening mínimo (desabilitar root login via SSH).

cat > ~/setup.yml <<EOF
---
- hosts: srv_linux
  become: yes
  tasks:
    - name: Instalar htop
      apt:
        name: htop
        state: present
        update_cache: yes
    - name: Criar usuário operador
      user:
        name: operador
        shell: /bin/bash
        state: present
    - name: Desabilitar login root via SSH
      lineinfile:
        path: /etc/ssh/sshd_config
        regexp: '^PermitRootLogin'
        line: 'PermitRootLogin no'
      notify: Reiniciar SSH
  handlers:
    - name: Reiniciar SSH
      service:
        name: ssh
        state: restarted
EOF

O que você deve ver: Arquivo 'setup.yml' criado.

Executar o playbook
Aplique as configurações nos dois servidores.
```
ansible-playbook -i ~/hosts setup.yml
```
O que você deve ver: Saída detalhada mostrando cada tarefa como 'ok' ou 'changed'.
Validar instalação do htop
Verifique se o pacote 'htop' foi instalado nos servidores.
```
ansible -i ~/hosts srv_linux -a 'htop --version'
```
O que você deve ver: Versão do htop exibida nos dois servidores.
Validar criação do usuário operador
Confirme se o usuário 'operador' existe.
```
ansible -i ~/hosts srv_linux -a 'id operador'
```
O que você deve ver: Informações do usuário 'operador' exibidas.
Validar hardening SSH
Cheque se o root login está desabilitado.
```
ansible -i ~/hosts srv_linux -a 'grep ^PermitRootLogin /etc/ssh/sshd_config'
```
O que você deve ver: Linha 'PermitRootLogin no' nos dois servidores.

Como saber que funcionou

Teste	Comando	Critério
Conectividade Ansible	`ansible -i ~/hosts srv_linux -m ping`	Ambos respondem 'pong'.
Instalação do htop	`ansible -i ~/hosts srv_linux -a 'htop --version'`	Versão do htop exibida.
Usuário operador criado	`ansible -i ~/hosts srv_linux -a 'id operador'`	Saída com UID e grupos do usuário.
Root login desabilitado	`ansible -i ~/hosts srv_linux -a 'grep ^PermitRootLogin /etc/ssh/sshd_config'`	'PermitRootLogin no' presente.
SSH sem senha	`ssh user@192.168.56.21`	Acesso sem senha.

Troubleshooting

Sintoma	Causa provável	Correção
Falha no ping do Ansible	Chave SSH não copiada corretamente ou usuário incorreto no inventário	Rever o passo de ssh-copy-id e o arquivo de inventário.
Erro 'become' ao rodar playbook	Usuário sem permissão sudo	Adicione o usuário ao grupo sudo nos servidores.
Pacote não instalado	Cache do apt desatualizado ou repositório offline	Verifique conectividade e rode 'sudo apt update' manualmente.
Root ainda acessa via SSH	Handler de reinício do SSH não executou	Reinicie o serviço SSH manualmente.
Usuário operador não criado	Erro de sintaxe no playbook	Consulte a documentação do módulo user do Ansible.

Segurança e hardening

Use chaves SSH protegidas por senha sempre que possível
Desabilite o login root via SSH em todos os servidores
Garanta que apenas usuários autorizados tenham acesso sudo
Limite o acesso ao inventário e aos playbooks a pessoas confiáveis
Mantenha o Ansible e dependências atualizados

Checklist final

Controladora e servidores acessíveis via SSH
Inventário Ansible criado e funcional
Playbook executado sem erros
Pacote htop instalado em ambos os servidores
Usuário operador criado em ambos os servidores
Login root via SSH desabilitado

Referências

Documentação oficial do Ansible · Ansible (Red Hat) (docs.ansible.com)
Repositório oficial do Ansible AWX · GitHub (repositório oficial do projeto) (github.com)
Documentação do módulo user do Ansible · Ansible (Red Hat) (docs.ansible.com)
Documentação do módulo apt do Ansible · Ansible (Red Hat) (docs.ansible.com)

Verificação editorial

Publicado: 09/09/2026
Última revisão: 09/09/2026
Versão do conteúdo: 1.0
Referências: 4 oficiais
Revisão técnica: redação e revisão por IA, URLs conferidas na publicação
Status: Atual

Encontrou um erro? Escreva para comercial@upnetix.com.br com o endereço da página. A revisão semestral por IA nunca altera comandos ou configurações sem passar pela fila de revisão.