Python para Automação de Redes e Administração de Servidores
Neste post, vamos explorar como usar Python para automação de redes e servidores, com exemplos práticos, bibliotecas recomendadas e estratégias para aumentar produtividade, segurança e confiabilidade.
1. Por que usar Python para automação de infraestrutura
Simplicidade e legibilidade: scripts claros e fáceis de manter.
Bibliotecas ricas: suporte a protocolos de rede, SSH, SNMP, REST APIs e serviços em nuvem.
Integração com sistemas existentes: Linux, Windows, roteadores, switches, firewalls.
Escalabilidade: scripts pequenos podem evoluir para pipelines completos de automação.
Comunidade ativa: vasta documentação e exemplos para casos de uso de TI.
2. Automatizando tarefas de servidores
2.1 Execução remota via SSH
Python permite gerenciar servidores remotamente usando SSH.
Biblioteca paramiko:
import paramiko
ssh = paramiko.SSHClient()
ssh.set_missing_host_key_policy(paramiko.AutoAddPolicy())
ssh.connect("192.168.1.10", username="admin", password="senha")
stdin, stdout, stderr = ssh.exec_command("uptime")
print(stdout.read().decode())
ssh.close()
Aplicações práticas:
Monitorar uptime de servidores
Executar scripts de manutenção
Deploy de aplicações
Boa prática: utilizar chaves SSH ao invés de senhas para segurança.
2.2 Automatizando comandos do sistema
Biblioteca subprocess:
import subprocess
# Reiniciar serviço nginx
subprocess.run(["systemctl", "restart", "nginx"])
# Listar processos ativos
result = subprocess.run(["ps", "aux"], capture_output=True, text=True)
print(result.stdout)
Vantagens:
Executa comandos nativos do SO
Permite capturar saídas e erros
Ideal para scripts híbridos Python + shell
2.3 Gerenciamento de usuários e permissões
Python pode interagir com usuarios do sistema e permissões de arquivos.
import os
import pwd
# Listar usuários do sistema
for user in pwd.getpwall():
print(user.pw_name)
# Criar diretório e definir permissões
os.makedirs("/tmp/teste", exist_ok=True)
os.chmod("/tmp/teste", 0o755)
3. Automação de redes
3.1 Monitoramento de dispositivos
Biblioteca netmiko: simplifica SSH para dispositivos de rede (Cisco, Juniper, HP, Arista).
from netmiko import ConnectHandler
device = {
"device_type": "cisco_ios",
"host": "192.168.1.1",
"username": "admin",
"password": "senha"
}
connection = ConnectHandler(**device)
output = connection.send_command("show ip interface brief")
print(output)
connection.disconnect()
Aplicações práticas:
Verificar status de interfaces
Coletar informações de roteamento
Atualizar configurações em massa
3.2 Automação com SNMP
Biblioteca pysnmp: permite consultar dispositivos via SNMP.
from pysnmp.hlapi import *
iterator = getCmd(
SnmpEngine(),
CommunityData('public', mpModel=0),
UdpTransportTarget(('192.168.1.1', 161)),
ContextData(),
ObjectType(ObjectIdentity('1.3.6.1.2.1.1.5.0')) # sysName
)
errorIndication, errorStatus, errorIndex, varBinds = next(iterator)
if errorIndication:
print(errorIndication)
else:
for varBind in varBinds:
print(varBind)
Aplicações práticas:
Monitoramento de tráfego, interfaces e status de dispositivos
Integração com dashboards de rede
Alertas automáticos em caso de falha
3.3 Trabalhando com APIs de dispositivos
Muitos dispositivos modernos expõem APIs REST:
import requests
url = "https://switch.local/api/v1/interfaces"
headers = {"Authorization": "Bearer SEU_TOKEN"}
response = requests.get(url, headers=headers)
interfaces = response.json()
for intf in interfaces:
print(intf["name"], intf["status"])
Vantagens:
Configuração programática sem SSH
Permite integração com sistemas de gerenciamento centralizados
Ideal para automação de larga escala
4. Automatizando tarefas comuns de TI
4.1 Backup automatizado
import shutil
import datetime
source = "/var/www/html"
destination = f"/backup/html_{datetime.date.today()}.tar.gz"
shutil.make_archive(destination.replace(".tar.gz", ""), 'gztar', source)
print("Backup concluído!")
4.2 Deploy de aplicações
import subprocess
# Atualiza código do repositório Git
subprocess.run(["git", "pull", "origin", "main"])
# Reinicia serviço
subprocess.run(["systemctl", "restart", "meu_app"])
4.3 Monitoramento de logs
import time
log_file = "/var/log/nginx/access.log"
with open(log_file) as f:
f.seek(0, 2) # Vai para o fim do arquivo
while True:
line = f.readline()
if not line:
time.sleep(1)
continue
print("Nova linha:", line.strip())
5. Bibliotecas essenciais para automação
| Biblioteca | Uso |
|---|---|
paramiko | SSH e execução remota |
netmiko | Automação de dispositivos de rede |
pysnmp | Consultas SNMP |
requests | Interação com APIs REST |
subprocess | Execução de comandos nativos do sistema |
psutil | Monitoramento de CPU, memória, processos |
fabric | Execução de tarefas em múltiplos servidores |
ansible | Integração com automação de configuração |
6. Boas práticas para scripts de automação
Segurança primeiro: evite senhas em texto plano, use chaves SSH ou variáveis de ambiente.
Logging detalhado: registre ações e resultados, especialmente em produção.
Validação de erros: trate falhas de conexão, permissões e tempo limite.
Idempotência: scripts devem poder ser executados várias vezes sem efeitos colaterais indesejados.
Modularidade: divida tarefas em funções e classes reutilizáveis.
Versionamento: mantenha scripts sob controle de versão (Git) para auditoria e rollback.
7. Exemplo de projeto completo de automação
Objetivo: monitorar servidores, coletar métricas, reiniciar serviços críticos e enviar alertas.
Estrutura sugerida:
automation/
├── servers.yaml # Configuração de servidores
├── monitor.py # Script de monitoramento
├── deploy.py # Deploy de aplicações
├── backup.py # Backup automatizado
├── logs/ # Armazenamento de logs
└── utils.py # Funções auxiliares (SSH, API, etc.)
Fluxo completo:
Ler configuração de servidores (
servers.yaml)Conectar via SSH ou API
Coletar métricas de CPU, memória e serviços
Executar ações corretivas (reiniciar serviços, liberar espaço)
Gerar logs e alertas por e-mail ou Slack
8. Conclusão
Python é uma ferramenta indispensável para automação de redes e administração de servidores, permitindo:
Executar tarefas repetitivas de forma confiável
Monitorar e gerenciar múltiplos servidores e dispositivos
Integrar diferentes tecnologias e APIs
Reduzir erros humanos e aumentar produtividade
Ao combinar bibliotecas poderosas, boas práticas de segurança e organização, é possível criar pipelines de automação robustos e escaláveis, transformando a administração de TI em processos programáticos e eficientes.
Comentários
Postar um comentário