Aula 24: Automação Cisco — EEM, Python e Ansible para redes

Bem-vindo à vigésima quarta aula do curso Cisco IOS — Do Zero ao Avançado. Chegamos a um dos momentos mais estratégicos para qualquer profissional de redes e infraestrutura: dominar a Automação Cisco. Depois de percorrer desde os fundamentos da CLI, VLANs, roteamento, protocolos de redundância, segurança e troubleshooting, nesta aula vamos elevar o patamar da operação. A automação deixou de ser um diferencial e passou a ser pré-requisito em ambientes que gerenciam dezenas, centenas ou milhares de dispositivos. O objetivo é substituir tarefas manuais repetitivas por processos orquestrados, consistentes e auditáveis, reduzindo erros humanos e aumentando a disponibilidade da rede. Em nossos projetos na JRT Technology Solutions, nossos especialistas utilizam diariamente os pilares que você vai aprender aqui — EEM, Python e Ansible — para implantar mudanças em grande escala com segurança e previsibilidade.

Ao longo desta aula, você vai compreender como funciona o Embedded Event Manager (EEM), um motor de automação embarcado no próprio Cisco IOS/IOS-XE que permite reagir a eventos de sistema sem depender de ferramentas externas. Vai aprender a escrever applets EEM diretamente pela CLI para executar ações como backup automático, envio de syslog e acionamento de comandos em resposta a falhas ou agendamentos. Em seguida, mergulharemos no mundo da programação com Python, usando a biblioteca Netmiko — amplamente adotada pela comunidade de engenheiros de rede — para conectar-se a equipamentos Cisco via SSH, coletar informações e aplicar configurações de forma programática.

Por fim, chegaremos ao Ansible, a ferramenta de automação e gerenciamento de configuração mais popular do mercado, que dispensa a instalação de agentes nos dispositivos. Você vai criar um ambiente completo de automação em estações Linux, escrever inventários, playbooks e executar tarefas idempotentes em múltiplos switches simultaneamente. O foco prático desta aula é total: cada comando, arquivo e saída esperada será demonstrado passo a passo, sem resumos enganosos ou lacunas que comprometam a reprodutibilidade do laboratório.

Ao final desta lição, você será capaz de: configurar applets EEM para reagir a eventos de syslog e timers; preparar uma estação de automação com Python e Ansible em distribuições Linux como Ubuntu/Debian e CentOS/RHEL/Rocky; escrever scripts Python com Netmiko para coletar dados e aplicar VLANs; construir playbooks Ansible com módulos nativos para IOS; executar backups automáticos de configuração em lote; e solucionar os erros mais comuns do processo. Se você acompanhar toda a execução, terá um laboratório funcional que pode ser usado como base para projetos reais de Automação Cisco.

O que você vai aprender nesta aula

Compreender a arquitetura de Automação Cisco com EEM, Python e Ansible, e quando utilizar cada abordagem;
Instalar e configurar Python 3, pip, virtualenv, Ansible, Netmiko e Paramiko em Ubuntu/Debian e CentOS/RHEL/Rocky Linux;
Criar applets EEM no IOS para responder a eventos de syslog, timers cron e ações de CLI;
Escrever scripts Python com Netmiko para conexão SSH, coleta de informações e aplicação de configurações;
Construir inventário e playbooks Ansible com os módulos ios_command, ios_config e ios_facts;
Automatizar o backup de running-config e o deploy de VLANs em múltiplos switches Cisco;
Verificar a instalação, testar a comunicação com os dispositivos e diagnosticar erros frequentes;
Adotar boas práticas de segurança e versionamento em ambientes de automação de rede.

Pré-requisitos e Ambiente

Antes de iniciar esta aula, você deve ter concluído as lições anteriores do curso, especialmente aquelas que tratam de acesso gerencial via SSH, configuração de VLANs, roteamento básico e fundamentos de CLI do IOS. É essencial que você tenha acesso a pelo menos um equipamento Cisco IOS ou IOS-XE, físico ou emulado. Em nossos laboratórios na JRT Technology Solutions, utilizamos plataformas como Cisco Modeling Labs (CML), EVE-NG e GNS3, todas compatíveis com as práticas desta aula. Para reproduzir os exemplos sem lacunas, recomendamos um ambiente com três switches virtuais, como Catalyst 9300 ou IOSvL2, com endereços IP de gerência na faixa 192.168.1.0/24.

Além dos dispositivos de rede, você precisará de uma estação Linux que atuará como controladora de automação. Nesta aula, demonstraremos os procedimentos em duas famílias: Ubuntu 22.04/Debian 12 e Rocky Linux 9/RHEL 9/CentOS Stream. A escolha da distribuição é indiferente para o resultado final, mas é importante que o sistema tenha Python 3 instalado, acesso à internet para instalação de pacotes e conectividade IP com os switches via porta 22/TCP (SSH). Os dispositivos Cisco deverão estar com SSH habilitado, usuário com privilégio nível 15 e senha de enable configurada.

Para fins didáticos, utilizaremos as seguintes credenciais de laboratório: usuário cisco, senha cisco e segredo de enable cisco. Os switches terão os nomes SW1, SW2 e SW3, com IPs 192.168.1.11, 192.168.1.12 e 192.168.1.13, respectivamente. Se o seu ambiente usar credenciais diferentes, ajuste os arquivos de inventário e scripts conforme necessário. O importante é que você entenda cada parâmetro e consiga adaptar a configuração sem copiar às cegas.

Por fim, esteja preparado para trabalhar com terminal e editor de texto no Linux. Utilizaremos o nano ou vim para criar os arquivos de configuração. Caso não tenha familiaridade, recomendamos praticar os comandos de edição antes de prosseguir. Todos os arquivos serão apresentados com conteúdo completo e comentado, de modo que você possa copiar e colar diretamente, respeitando a indentação, que é obrigatória em YAML e Python.

Fundamentos da Automação Cisco: EEM, Python e Ansible

A Automação Cisco não é uma tecnologia única, mas um conjunto de ferramentas e abordagens que atendem a necessidades distintas. O primeiro pilar, Embedded Event Manager (EEM), é um recurso nativo do IOS/IOS-XE que monitora eventos internos do sistema e executa ações programadas quando condições específicas são detectadas. O EEM não requer servidor externo, agente ou software adicional — tudo roda dentro do próprio dispositivo. Ele é ideal para automações on-box, como reagir a uma interface que caiu, a uma mensagem de syslog crítica ou a um agendamento cron. A configuração pode ser feita por meio de applets, que são políticas simples definidas na CLI, ou por scripts Tcl mais avançados.

O segundo pilar é o Python, a linguagem de programação mais utilizada no ecossistema de redes e segurança. Com Python, você pode escrever scripts para se conectar a dispositivos via SSH, executar comandos, coletar saídas e aplicar configurações. A biblioteca Netmiko abstrai boa parte da complexidade da conexão SSH, lidando com prompts, paginação e modo enable de forma simples. O Python é ideal quando você precisa de flexibilidade total: lógica condicional, integração com APIs, tratamento de erros e manipulação de dados estruturados.

O terceiro pilar é o Ansible, uma ferramenta de automação declarativa e agente-less. Diferente do Python puro, no Ansible você descreve o estado desejado da rede em arquivos YAML chamados playbooks. O Ansible usa módulos específicos para Cisco, como ios_config, ios_command e ios_facts, e conecta-se aos dispositivos via SSH usando o network_cli. A grande vantagem é a idempotência: executar o mesmo playbook várias vezes não gera alterações desnecessárias, pois o Ansible verifica o estado atual antes de aplicar mudanças. Além disso, o Ansible escala naturalmente, permitindo executar tarefas em dezenas ou centenas de dispositivos em paralelo.

A combinação dessas três abordagens cobre praticamente todos os cenários de automação de rede. O EEM resolve o imediato dentro do equipamento; o Python oferece liberdade criativa e integração; o Ansible entrega orquestração escalável e padronizada. Em nossos projetos na JRT Technology Solutions, costumamos utilizar Ansible para o gerenciamento diário da configuração, Python para integrações específicas com sistemas de terceiros e EEM para respostas locais a falhas, como reinício automático de interfaces ou acionamento de traps SNMP. Agora, vamos transformar essa teoria em prática.

Passo a Passo — Instalando o Ambiente de Automação no Ubuntu/Debian

Nesta seção, prepararemos a estação Linux com Ubuntu 22.04 ou Debian 12 para funcionar como controladora de automação. O objetivo é instalar o Python 3, o gerenciador de pacotes pip, a ferramenta de virtualização venv, o Ansible e as bibliotecas Netmiko e Paramiko. Utilizaremos um ambiente virtual Python para isolar as dependências do projeto, evitando conflitos com pacotes do sistema. Siga os comandos na ordem exata apresentada.

Atualize a lista de pacotes e instale os pacotes básicos do sistema, incluindo o Python 3, o pip, o suporte a ambientes virtuais, o git e o sshpass, que será útil em testes de conectividade.
Crie um diretório de trabalho chamado automacao-cisco e entre nele. Dentro dele, crie o ambiente virtual venv usando o módulo venv do Python.
Ative o ambiente virtual com o comando source venv/bin/activate. O prompt do terminal deve mudar para indicar que o ambiente está ativo.
Atualize o pip para a versão mais recente e instale o ansible-core, o netmiko e o paramiko usando o pip.
Confirme as versões instaladas com ansible –version e python3 –version.

# Atualiza os repositórios e instala pacotes básicos
sudo apt update
sudo apt install -y python3 python3-pip python3-venv git sshpass

# Cria o diretório do projeto e o ambiente virtual
mkdir ~/automacao-cisco
cd ~/automacao-cisco
python3 -m venv venv

# Ativa o ambiente virtual
source venv/bin/activate

# Atualiza o pip e instala as dependências de automação
pip install --upgrade pip
pip install "ansible-core>=2.15" netmiko paramiko

# Verifica as versões instaladas
python3 --version
ansible --version

Collecting ansible-core>=2.15
  Downloading ansible_core-2.15.9-py3-none-any.whl (2.2 MB)
Collecting netmiko
  Downloading netmiko-4.3.0-py3-none-any.whl (223 kB)
Collecting paramiko
  Downloading paramiko-3.4.0-py3-none-any.whl (224 kB)
...
Successfully installed ansible-core-2.15.9 netmiko-4.3.0 paramiko-3.4.0
Python 3.10.12
ansible [core 2.15.9]
  config file = None
  configured module search path = ['/home/usuario/.ansible/plugins/modules', '/usr/share/ansible/plugins/modules']
  ansible python module location = /home/usuario/automacao-cisco/venv/lib/python3.10/site-packages/ansible
  ansible collection location = /home/usuario/.ansible/collections:/usr/share/ansible/collections
  executable location = /home/usuario/automacao-cisco/venv/bin/ansible
  python version = 3.10.12 (main, Nov 20 2023, 15:14:05) [GCC 11.4.0]

Explicando cada comando: sudo apt update atualiza o índice de pacotes; sudo apt install -y python3 python3-pip python3-venv git sshpass instala o Python, o pip, o módulo venv, o git e o sshpass, com a flag -y para confirmar automaticamente. O mkdir ~/automacao-cisco cria a pasta do projeto; cd ~/automacao-cisco entra nela. O comando python3 -m venv venv cria um ambiente virtual isolado chamado venv. Ao rodar source venv/bin/activate, as próximas instalações com pip ficarão restritas a esse ambiente, sem afetar o sistema. O pip install –upgrade pip atualiza o gerenciador; pip install “ansible-core>=2.15” netmiko paramiko instala o Ansible Core (mínimo 2.15), o Netmiko e o Paramiko. A saída mostra o sucesso da instalação e as versões do Python e do Ansible.

Com o ambiente virtual ativo, você pode testar a conectividade com os switches usando o Python e a biblioteca Paramiko no próximo passo. Lembre-se de que, sempre que abrir um novo terminal, será necessário reativar o ambiente com source venv/bin/activate. Para sair do ambiente, use o comando deactivate. Agora, veremos o mesmo procedimento para distribuições da família Red Hat.

Passo a Passo — Instalando o Ambiente no CentOS/RHEL/Rocky Linux

Se a sua controladora utiliza Rocky Linux 9, RHEL 9 ou CentOS Stream, o processo é semelhante, mas com o gerenciador de pacotes dnf e a necessidade de habilitar o repositório EPEL para instalar o Ansible a partir dos repositórios oficiais da distribuição. A instalação via dnf do ansible-core garante que o pacote seja mantido pelo gerenciador do sistema, o que é recomendado em ambientes corporativos. Alternativamente, você pode instalar tudo com pip dentro de um venv, exatamente como no Ubuntu. Aqui, demonstraremos a abordagem nativa com dnf para o Ansible Core e pip para Netmiko e Paramiko.

Atualize os pacotes do sistema com dnf update. Em seguida, instale as dependências de desenvolvimento, incluindo python3-devel, openssl-devel, git e sshpass.
Instale o repositório EPEL, que fornece pacotes adicionais para RHEL e derivados, e em seguida instale o pacote ansible-core.
Crie e ative o ambiente virtual Python da mesma forma que no Ubuntu.
Instale o Netmiko e o Paramiko com pip dentro do ambiente virtual.
Verifique as versões com ansible –version e python3 –version.

# Atualiza o sistema e instala dependências de desenvolvimento
sudo dnf update -y
sudo dnf install -y python3 python3-pip python3-devel openssl-devel git sshpass

# Habilita o repositório EPEL e instala o Ansible Core
sudo dnf install -y epel-release
sudo dnf install -y ansible-core

# Cria e ativa o ambiente virtual
mkdir ~/automacao-cisco
cd ~/automacao-cisco
python3 -m venv venv
source venv/bin/activate

# Instala Netmiko e Paramiko com pip
pip install --upgrade pip
pip install netmiko paramiko

# Verifica as versões
python3 --version
ansible --version

Last metadata expiration check: 0:02:15 ago on Sun 13 Sep 2026 09:22:41 AM -03.
Dependencies resolved.
================================================================================
 Package                Architecture   Version              Repository     Size
================================================================================
 ansible-core           x86_64         1:2.14.2-7.el9      appstream      2.2 M
 epel-release           noarch         9-5.el9             extras         18 k
...
Complete!
Python 3.9.18
ansible [core 2.14.2]
  config file = None
  configured module search path = ['/home/usuario/.ansible/plugins/modules', '/usr/share/ansible/plugins/modules']
  ansible python module location = /usr/lib/python3.9/site-packages/ansible
  executable location = /usr/bin/ansible
  python version = 3.9.18 (main, Jun  1 2023, 17:24:21) [GCC 11.3.1 20221121 (Red Hat 11.3.1-4)]

Aqui, o ponto de atenção é o gerenciador dnf. O comando sudo dnf update -y atualiza todos os pacotes; sudo dnf install -y python3 python3-pip python3-devel openssl-devel git sshpass instala o Python, o pip, os cabeçalhos de desenvolvimento do Python, o OpenSSL, o git e o sshpass. A flag -y confirma automaticamente. O repositório EPEL é habilitado com sudo dnf install -y epel-release, e o pacote ansible-core é instalado via dnf. Em seguida, criamos o ambiente virtual e instalamos o Netmiko e o Paramiko com pip, isolando as bibliotecas Python do sistema. A saída mostra a instalação concluída e as versões do Python e Ansible.

Vale destacar que o Ansible instalado via dnf no Rocky/RHEL fica disponível no PATH do sistema, mesmo antes de ativar o venv. Para evitar conflitos, recomendamos ativar o venv antes de executar scripts Python que dependam do Netmiko. Em ambos os sistemas, o ambiente está pronto para receber os arquivos de inventário e playbooks que criaremos a seguir.

Configuração Detalhada — Inventário e Playbooks Ansible para Cisco IOS

Com o Ansible instalado, precisamos definir três arquivos essenciais: o ansible.cfg com parâmetros globais, o hosts.cfg (inventário) com os dispositivos e suas variáveis de conexão, e os playbooks que descrevem as tarefas. O ansible.cfg indica onde está o inventário, desabilita a checagem de chave SSH (para laboratório), desativa a coleta automática de fatos e define tempos de timeout. O hosts.cfg organiza os switches no grupo switches e define as variáveis de conexão comuns: usuário, senha, tipo de rede, método de conexão e credenciais de enable.

Os playbooks utilizam módulos nativos da collection cisco.ios, que já está embutida no Ansible Core. O módulo ios_command executa comandos de show e retorna a saída; o ios_config aplica configurações de forma idempotente; e o ios_facts coleta informações do dispositivo. Antes de escrever os playbooks, crie os arquivos de configuração exatamente como mostrado abaixo.

# Arquivo ansible.cfg — parâmetros globais do Ansible
[defaults]
inventory = ./hosts.cfg
host_key_checking = False
retry_files_enabled = False
gathering = explicit
interpreter_python = auto_silent

[persistent_connection]
connect_timeout = 30
command_timeout = 60

# Arquivo hosts.cfg — inventário de dispositivos Cisco
[switches]
SW1 ansible_host=192.168.1.11
SW2 ansible_host=192.168.1.12
SW3 ansible_host=192.168.1.13

[switches:vars]
ansible_user=cisco
ansible_password=cisco
ansible_network_os=ios
ansible_connection=network_cli
ansible_become=yes
ansible_become_method=enable
ansible_become_password=cisco

# Playbook backup_configs.yml — backup da running-config
---
- name: Backup das configurações dos switches Cisco
  hosts: switches
  gather_facts: no
  tasks:
    - name: Capturar running-config
      ios_command:
        commands: show running-config
      register: output

    - name: Salvar backup localmente
      copy:
        content: "{{ output.stdout[0] }}"
        dest: "./backups/{{ inventory_hostname }}_running-config_{{ ansible_date_time.date }}.cfg"
      delegate_to: localhost

# Playbook vlan_deploy.yml — deploy de VLANs nos switches
---
- name: Deploy de VLANs nos switches
  hosts: switches
  gather_facts: no
  vars:
    vlans:
      - id: 100
        name: VENDAS
      - id: 200
        name: TI
      - id: 300
        name: VOZ
  tasks:
    - name: Criar VLANs
      ios_config:
        lines:
          - "vlan {{ item.id }}"
          - " name {{ item.name }}"
      loop: "{{ vlans }}"

Vamos detalhar cada arquivo. No ansible.cfg, a diretiva inventory = ./hosts.cfg indica que o inventário está no arquivo local; host_key_checking = False evita a confirmação manual da chave SSH, o que é aceitável em laboratório, mas em produção deve ser substituído por chaves validadas. retry_files_enabled = False evita a criação de arquivos .retry após falhas. gathering = explicit desativa a coleta automática de fatos, pois usaremos módulos específicos. A seção [persistent_connection] define connect_timeout = 30 e command_timeout = 60 para evitar timeout em dispositivos lentos.

No hosts.cfg, cada switch é listado com seu endereço IP. A variável ansible_network_os=ios informa ao Ansible que se trata de um dispositivo Cisco IOS; ansible_connection=network_cli usa a conexão de rede via CLI persistente; ansible_become=yes e ansible_become_method=enable indicam que o Ansible deve entrar no modo privilegiado, usando ansible_become_password para a senha de enable. Os playbooks usam hosts: switches para executar as tarefas em todos os dispositivos do grupo. O bloco vars no playbook de VLANs define uma lista de dicionários com id e name, que é percorrida pelo loop e inserida nas linhas de configuração via Jinja2, gerando comandos como vlan 100 e name VENDAS.

Para executar esses playbooks, crie o diretório backups antes de rodar o backup, pois o módulo copy espera que o destino exista. Em seguida, execute os comandos abaixo no terminal, dentro do diretório ~/automacao-cisco. O primeiro comando testa a comunicação com todos os switches usando o módulo ping; o segundo executa o backup; o terceiro aplica as VLANs.

# Testa a conectividade com todos os switches
ansible -i hosts.cfg switches -m ping

# Executa o backup das configurações
ansible-playbook -i hosts.cfg backup_configs.yml

# Aplica as VLANs em todos os switches
ansible-playbook -i hosts.cfg vlan_deploy.yml

SW1 | SUCCESS => {
    "changed": false,
    "ping": "pong"
}
SW2 | SUCCESS => {
    "changed": false,
    "ping": "pong"
}
SW3 | SUCCESS => {
    "changed": false,
    "ping": "pong"
}
PLAY [Backup das configurações dos switches Cisco] ********************************
TASK [Capturar running-config] ****************************************************
ok: [SW1]
ok: [SW2]
ok: [SW3]
TASK [Salvar backup localmente] ***************************************************
changed: [SW1]
changed: [SW2]
changed: [SW3]
PLAY RECAP ***********************************************************************
SW1             : ok=2    changed=1    unreachable=0    failed=0    skipped=0
SW2             : ok=2    changed=1    unreachable=0    failed=0    skipped=0
SW3             : ok=2    changed=1    unreachable=0    failed=0    skipped=0

O primeiro comando ansible -i hosts.cfg switches -m ping usa o módulo ping para verificar se o Ansible consegue estabelecer a conexão de rede. A saída mostra “ping”: “pong” para cada switch, confirmando que a comunicação é bem-sucedida. O segundo comando executa o playbook de backup: a tarefa Capturar running-config retorna ok, pois não altera nada, e a tarefa Salvar backup localmente retorna changed, indicando que os arquivos foram criados. O terceiro comando aplica as VLANs, e o resumo final PLAY RECAP consolida o resultado de cada host. Agora, veremos como usar

Quer aprender na prática com especialistas?

A JRT Technology Solutions oferece treinamentos e implementação de Cisco IOS para equipes corporativas.

Falar no WhatsApp

Cisco IOS — Do Zero ao Avançado: Automação Cisco — EEM, Python e Ansible para redes