Você tem 50 switches para atualizar. A senha do admin precisa mudar em todos. Fazer via CLI, um por um, leva o dia inteiro. Com Python, leva 3 minutos e você não precisa digitar uma senha sequer.
Isso é automação de redes. Não é desenvolvimento de software. É engenharia de redes usando uma ferramenta a mais.
Por que Python e não Ansible ou Terraform
Ansible, Terraform e outras ferramentas de IaC fazem automação de redes. Python não substitui nenhuma delas. Mas Python é o ponto de entrada porque:
- O CCNA v1.1 cobra Python explicitamente no domínio de automação
- Netmiko, NAPALM e Nornir — as três bibliotecas padrão de automação Cisco — são Python
- Scripts Python são mais fáceis de debugar e adaptar do que playbooks YAML quando algo quebra em produção
- Você entende o que está acontecendo linha por linha
A Cisco Press lançou em abril de 2026 um livro inteiro dedicado a Netmiko, NAPALM e Nornir para engenheiros de redes. Esse combo virou o padrão de fato no mercado.
O que você precisa saber de Python antes de começar
Não precisa muito. Os scripts de automação de redes usam estruturas simples:
# Variáveis
ip = "192.168.1.1"
usuario = "admin"
# Listas
dispositivos = ["192.168.1.1", "192.168.1.2", "192.168.1.3"]
# Dicionários
roteador = {
"host": "192.168.1.1",
"username": "admin",
"password": "cisco123",
"device_type": "cisco_ios"
}
# Loop
for ip in dispositivos:
print(f"Conectando em {ip}")
# Função
def conectar(host, usuario, senha):
# lógica aqui
pass
Se você entende isso, está pronto para escrever os primeiros scripts de automação.
Netmiko: SSH em múltiplos dispositivos com Python
Netmiko é a biblioteca mais usada para conectar em dispositivos de rede via SSH. Suporta Cisco IOS, IOS-XE, NX-OS, Arista, Juniper, Fortinet e mais de 50 plataformas.
Instalação:
pip install netmiko
Conectar em um roteador e rodar um comando:
from netmiko import ConnectHandler
roteador = {
"device_type": "cisco_ios",
"host": "192.168.1.1",
"username": "admin",
"password": "cisco123",
}
conexao = ConnectHandler(**roteador)
output = conexao.send_command("show ip interface brief")
print(output)
conexao.disconnect()
Output no terminal:
Interface IP-Address OK? Method Status Protocol
GigabitEthernet0/0 192.168.1.1 YES NVRAM up up
GigabitEthernet0/1 10.0.0.1 YES NVRAM up up
Enviar comandos de configuração:
from netmiko import ConnectHandler
roteador = {
"device_type": "cisco_ios",
"host": "192.168.1.1",
"username": "admin",
"password": "cisco123",
}
comandos = [
"interface loopback0",
"ip address 1.1.1.1 255.255.255.255",
"description Gerenciamento",
"no shutdown"
]
conexao = ConnectHandler(**roteador)
output = conexao.send_config_set(comandos)
conexao.save_config()
print(output)
conexao.disconnect()
send_config_set() entra no modo de configuração, envia os comandos em sequência, e sai. save_config() executa write memory automaticamente.
O script que muda senha em 50 dispositivos de uma vez
Esse é o caso de uso que justifica aprender Python para redes. Lista de IPs num arquivo, uma credencial nova, script roda em paralelo.
from netmiko import ConnectHandler
# Lista de dispositivos
dispositivos = [
{"device_type": "cisco_ios", "host": "10.0.0.1", "username": "admin", "password": "senha_antiga"},
{"device_type": "cisco_ios", "host": "10.0.0.2", "username": "admin", "password": "senha_antiga"},
{"device_type": "cisco_ios", "host": "10.0.0.3", "username": "admin", "password": "senha_antiga"},
]
nova_senha = "NovaSenha@2026"
for dispositivo in dispositivos:
try:
conexao = ConnectHandler(**dispositivo)
conexao.send_config_set([
f"username admin secret {nova_senha}",
"line vty 0 4",
"login local"
])
conexao.save_config()
conexao.disconnect()
print(f"✓ {dispositivo['host']} atualizado")
except Exception as e:
print(f"✗ {dispositivo['host']} - erro: {e}")
Com 3 dispositivos na lista o script roda em segundos. Com 50, em minutos. Sem erro de digitação, sem esquecer algum, com log de sucesso e falha para cada host.
NAPALM: coletar dados de forma padronizada
NAPALM (Network Automation and Programmability Abstraction Layer with Multivendor support) resolve um problema específico: o output do show varia por fabricante e por plataforma. NAPALM abstrai isso e devolve dicionários Python estruturados, independente se é Cisco IOS, Arista EOS ou Junos.
pip install napalm
import napalm
driver = napalm.get_network_driver("ios")
device = driver(
hostname="192.168.1.1",
username="admin",
password="cisco123"
)
device.open()
# Dados de interfaces em formato estruturado
interfaces = device.get_interfaces()
for nome, dados in interfaces.items():
print(f"{nome}: UP={dados['is_up']} | Speed={dados['speed']}Mbps")
# Tabela ARP
arp = device.get_arp_table()
for entrada in arp:
print(f"IP: {entrada['ip']} | MAC: {entrada['mac']}")
device.close()
Output estruturado, sem precisar fazer parsing de texto. Você recebe Python dict, itera, exporta para CSV, envia por API. Muito mais útil do que scrape de show commands.
Nornir: rodar tudo em paralelo em centenas de dispositivos
Netmiko e NAPALM são ótimos para um dispositivo por vez. Nornir é o orquestrador que usa os dois em paralelo, com inventário em YAML e execução simultânea em threads.
pip install nornir nornir-netmiko nornir-utils
Arquivo de inventário hosts.yaml:
SW-CORE-01:
hostname: 10.0.0.1
groups:
- cisco_ios
SW-ACESSO-01:
hostname: 10.0.0.2
groups:
- cisco_ios
Script que roda show version em todos os dispositivos ao mesmo tempo:
from nornir import InitNornir
from nornir_netmiko import netmiko_send_command
from nornir_utils.plugins.functions import print_result
nr = InitNornir(config_file="config.yaml")
resultado = nr.run(
task=netmiko_send_command,
command_string="show version"
)
print_result(resultado)
Enquanto Netmiko conecta em um dispositivo por vez, Nornir conecta em todos simultaneamente. Com 100 dispositivos, o tempo de execução é o mesmo de um. A diferença em produção é enorme.
O que o CCNA cobra de Python
O domínio 6 (Automation and Programmability) representa 10% da prova. Os conceitos cobrados:
- O que é automação e por que ela existe
- REST API: verbos HTTP (GET, POST, PUT, DELETE), JSON como formato de dados
- Diferença entre gerenciamento tradicional (CLI por CLI) e controller-based (Cisco DNA Center, Meraki)
- Configuração via API vs via CLI
A prova não pede para você escrever um script Netmiko. Ela pede que você reconheça o que uma API REST faz, o que é um payload JSON, e por que automação reduz erro humano.
# Exemplo de chamada REST API que a Cisco usa em questões de prova
import requests
url = "https://192.168.1.1/api/v1/devices"
headers = {"Content-Type": "application/json"}
auth = ("admin", "cisco123")
response = requests.get(url, headers=headers, auth=auth, verify=False)
print(response.json())
▌ Note que: saber ler um bloco de Python como esse e identificar que é uma chamada GET a uma API REST com autenticação básica é o nível que a prova cobra. Não precisa escrever do zero.
Python para redes não é aprender a programar. É aprender a automatizar o que você já faz no CLI. A curva de entrada é menor do que parece, e o ganho de tempo em produção é imediato.