ULC Lab · implementação reproduzível

Laboratório: Automação de atualização segura de roteadores Linux com Ansible

Você vai automatizar a atualização de pacotes críticos e a configuração de firewall em dois roteadores Linux simulados, usando Ansible em uma VM de controle. Em cerca de 2 horas, terá uma bancada funcional para testar automação e resposta rápida a vulnerabilidades.

Ligado ao treinamento Segurança e automação em ISPs com Ansible do zero à resposta orquestrada

ULC-LAB-ISPS-0004 · 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: 12
Validações: 5
Versões da documentação consultada: Ansible 2.15 · Ubuntu Server 22.04 LTS · iptables a versão estável atual

Objetivo

Demonstrar como orquestrar, via Ansible, a atualização de sistemas e aplicação de regras de firewall em roteadores Linux, simulando um cenário real de ISP. O laboratório ensina a criar um playbook seguro, validar resultados e corrigir problemas comuns, usando apenas software livre.

Topologia

Três VMs em uma rede virtual privada: uma VM 'ansible-controller' (192.168.56.10), duas VMs 'router1' (192.168.56.11) e 'router2' (192.168.56.12). O controlador acessa os roteadores via SSH. Os roteadores simulam CPEs ou equipamentos de borda.


+------------------+
| ansible-controller|
| 192.168.56.10     |
+--------+---------+
         |
   +-----+-----+
   |           |
+--+--+     +--+--+
|router1|   |router2|
|.11   |   |.12   |
+------+   +------+

Equipamentos e software

Item	Requisito, licença ou versão
VM ansible-controller	1 vCPU, 1GB RAM, Ubuntu Server 22.04 ou superior, acesso SSH às outras VMs
VM router1	1 vCPU, 512MB RAM, Ubuntu Server 22.04 ou superior, SSH habilitado
VM router2	1 vCPU, 512MB RAM, Ubuntu Server 22.04 ou superior, SSH habilitado
Ansible	GPLv3 · 2.15
Ubuntu Server	GPLv2 · 22.04 LTS
iptables	GPLv2 · a versão estável atual

Roteiro

Preparar as VMs
Crie três VMs na sua máquina local ou em um hypervisor. Configure as redes para que todas se enxerguem na faixa 192.168.56.0/24. Garanta que as VMs 'router1' e 'router2' tenham SSH ativo.
O que você deve ver: As VMs respondem a ping entre si e aceitam conexões SSH.
Instalar o Ansible no controlador
No 'ansible-controller', instale o Ansible. Ele será o orquestrador das automações.
```
sudo apt update && sudo apt install -y ansible
```
O que você deve ver: Comando 'ansible --version' retorna a versão instalada.
Configurar acesso SSH sem senha
Gere uma chave SSH no controlador e distribua para 'router1' e 'router2'. Isso permite automação sem intervenção manual.
```
ssh-keygen -t ed25519 -N '' -f ~/.ssh/id_ed25519
ssh-copy-id user@192.168.56.11
ssh-copy-id user@192.168.56.12
```
O que você deve ver: Login por SSH do controlador para os roteadores sem pedir senha.
Criar o inventário do Ansible
Defina os hosts gerenciados em um arquivo de inventário. Isso organiza os alvos da automação.
```
echo '[routers]
router1 ansible_host=192.168.56.11 ansible_user=user
router2 ansible_host=192.168.56.12 ansible_user=user' > ~/routers.ini
```
O que você deve ver: Arquivo routers.ini criado com as entradas dos roteadores.
Testar conectividade Ansible
Verifique se o Ansible consegue acessar os roteadores via ping do módulo.
```
ansible -i ~/routers.ini routers -m ping
```
O que você deve ver: Saída 'SUCCESS' para ambos os roteadores.
Criar playbook para atualização de pacotes
Automatize a atualização dos pacotes críticos (por exemplo, openssh-server e iptables) nos roteadores.
```
nano ~/update_and_harden.yml
```
O que você deve ver: Arquivo editado com o conteúdo do playbook.

Escrever o playbook de atualização e hardening

No arquivo, insira o seguinte conteúdo:

  - hosts: routers
    become: yes
    tasks:
      - name: Atualizar cache do apt
        apt:
          update_cache: yes
      - name: Atualizar openssh-server e iptables
        apt:
          name:
            - openssh-server
            - iptables
          state: latest
      - name: Aplicar regras básicas de firewall
        ansible.builtin.shell: |
          iptables -F
          iptables -A INPUT -p tcp --dport 22 -j ACCEPT
          iptables -A INPUT -m conntrack --ctstate ESTABLISHED,RELATED -j ACCEPT
          iptables -A INPUT -j DROP
        args:
          warn: false

O que você deve ver: Playbook salvo corretamente.

Executar o playbook
Rode o playbook para aplicar as atualizações e regras de firewall.
```
ansible-playbook -i ~/routers.ini ~/update_and_harden.yml
```
O que você deve ver: Saída indicando sucesso das tarefas em ambos os roteadores.
Validar atualização dos pacotes
Verifique se os pacotes realmente foram atualizados.
```
ansible -i ~/routers.ini routers -a 'dpkg -l | grep openssh-server'
```
O que você deve ver: Saída mostrando a versão instalada do openssh-server.
Validar regras de firewall
Confirme se as regras de iptables estão ativas nos roteadores.
```
ansible -i ~/routers.ini routers -a 'sudo iptables -L -n'
```
O que você deve ver: A porta 22 aparece como ACCEPT, demais INPUT como DROP.
Testar acesso SSH e bloqueio de outras portas
Tente conectar via SSH (deve funcionar) e via outra porta (deve ser bloqueado).
```
nc -vz 192.168.56.11 22
nc -vz 192.168.56.11 80
```
O que você deve ver: Conexão na porta 22 aceita, porta 80 recusada.
Reverter firewall (opcional, para troubleshooting)
Se necessário, limpe as regras para restaurar conectividade total.
```
ansible -i ~/routers.ini routers -a 'sudo iptables -F'
```
O que você deve ver: Todas as regras removidas, INPUT liberado.

Como saber que funcionou

Teste	Comando	Critério
Verificar resposta ao ping Ansible	`ansible -i ~/routers.ini routers -m ping`	Ambos os roteadores respondem SUCCESS
Checar atualização do openssh-server	`ansible -i ~/routers.ini routers -a 'dpkg -l \| grep openssh-server'`	Versão listada é a mais recente disponível
Confirmar regra de firewall para SSH	`ansible -i ~/routers.ini routers -a 'sudo iptables -L -n'`	INPUT para porta 22 está como ACCEPT
Testar bloqueio de porta não autorizada	`nc -vz 192.168.56.11 80`	Conexão recusada ou timeout
SSH permanece acessível	`ssh user@192.168.56.11`	Login sem senha, acesso ao shell

Troubleshooting

Sintoma	Causa provável	Correção
Ansible falha no ping	Chave SSH não copiada ou usuário incorreto	Verifique usuário e repita ssh-copy-id
Playbook trava em atualização	Lock do apt ou falta de permissões	Garanta que não há outro apt rodando e use become: yes
SSH cai após aplicar firewall	Regra de iptables bloqueando SSH	Acesse via console e limpe as regras: iptables -F
Pacote não atualiza	Repositório desatualizado	Rode apt update manualmente e tente novamente
Conexão recusada em todas as portas	Firewall bloqueando tudo	Revise as regras aplicadas e ajuste o playbook

Segurança e hardening

Use chaves SSH protegidas por senha sempre que possível
Limite o acesso SSH apenas ao controlador
Revise as regras de firewall antes de aplicar em produção
Nunca rode playbooks de firewall sem console de emergência
Mantenha o Ansible atualizado para evitar vulnerabilidades

Checklist final

Inventário Ansible criado e funcional
Playbook executado sem erros
Pacotes atualizados nos roteadores
Firewall ativo e SSH acessível
Portas não autorizadas bloqueadas

Referências

Ansible User Guide · Ansible (Red Hat) (docs.ansible.com)
Ansible apt module · 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: 2 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.