Solução do Exercício 1:

#!/usr/bin/env python3
# Script de Backup de Configurações

import paramiko
import time
import datetime
import argparse
import sys
import os

def get_args():
    """Processa os argumentos da linha de comando."""
    parser = argparse.ArgumentParser(description='Script de backup de configuração Cisco.')
    parser.add_argument('-H', '--hostname', required=True, help='Hostname ou IP do dispositivo')
    parser.add_argument('-u', '--username', required=True, help='Nome de usuário')
    parser.add_argument('-p', '--password', required=True, help='Senha')
    parser.add_argument('-d', '--directory', default='.', help='Diretório para salvar o backup')
    return parser.parse_args()

def connect_ssh(hostname, username, password, port=22):
    """Estabelece uma conexão SSH com um dispositivo."""
    try:
        # Criando o cliente SSH
        ssh_client = paramiko.SSHClient()
        
        # Configurando para aceitar chaves de host desconhecidas
        ssh_client.set_missing_host_key_policy(paramiko.AutoAddPolicy())
        
        # Estabelecendo a conexão
        print(f"Conectando a {hostname}...")
        ssh_client.connect(
            hostname=hostname,
            port=port,
            username=username,
            password=password,
            look_for_keys=False,
            allow_agent=False
        )
        print(f"Conectado com sucesso a {hostname}")
        
        return ssh_client
    except paramiko.AuthenticationException:
        print(f"Falha na autenticação para {hostname}")
        return None
    except paramiko.SSHException as e:
        print(f"Erro SSH para {hostname}: {str(e)}")
        return None
    except Exception as e:
        print(f"Erro ao conectar a {hostname}: {str(e)}")
        return None

def get_device_hostname(ssh_client):
    """Obtém o hostname configurado no dispositivo."""
    try:
        # Invocando um shell
        shell = ssh_client.invoke_shell()
        
        # Enviando o comando
        shell.send("show running-config | include hostname\n")
        
        # Aguardando a resposta
        time.sleep(2)
        
        # Lendo a saída
        output = shell.recv(65535).decode("utf-8")
        
        # Extraindo o hostname
        for line in output.splitlines():
            if "hostname" in line:
                parts = line.split()
                if len(parts) >= 2:
                    return parts[1]
        
        return "unknown"
    except Exception as e:
        print(f"Erro ao obter hostname: {str(e)}")
        return "unknown"

def get_running_config(ssh_client):
    """Obtém a configuração em execução do dispositivo."""
    try:
        # Invocando um shell
        shell = ssh_client.invoke_shell()
        
        # Enviando o comando
        print("Executando 'show running-config'...")
        shell.send("terminal length 0\n")  # Desativa paginação
        time.sleep(1)
        shell.send("show running-config\n")
        
        # Aguardando a resposta (configurações podem ser grandes)
        time.sleep(10)
        
        # Lendo a saída
        output = shell.recv(65535).decode("utf-8")
        return output
    except Exception as e:
        print(f"Erro ao obter configuração: {str(e)}")
        return None

def save_config_to_file(config, hostname, directory):
    """Salva a configuração em um arquivo com timestamp."""
    try:
        # Criando o timestamp
        timestamp = datetime.datetime.now().strftime("%Y%m%d_%H%M%S")
        
        # Criando o nome do arquivo
        filename = f"{hostname}_{timestamp}.cfg"
        filepath = os.path.join(directory, filename)
        
        # Salvando a configuração
        with open(filepath, 'w') as f:
            f.write(config)
        
        print(f"Configuração salva em: {filepath}")
        return filepath
    except Exception as e:
        print(f"Erro ao salvar configuração: {str(e)}")
        return None

def main():
    """Função principal."""
    # Obtendo argumentos
    args = get_args()
    
    # Verificando se o diretório existe
    if not os.path.exists(args.directory):
        try:
            os.makedirs(args.directory)
            print(f"Diretório criado: {args.directory}")
        except Exception as e:
            print(f"Erro ao criar diretório: {str(e)}")
            sys.exit(1)
    
    # Estabelecendo a conexão
    ssh_client = connect_ssh(
        hostname=args.hostname,
        username=args.username,
        password=args.password
    )
    
    if not ssh_client:
        print("Não foi possível estabelecer conexão SSH. Saindo.")
        sys.exit(1)
    
    try:
        # Obtendo o hostname configurado
        device_hostname = get_device_hostname(ssh_client)
        print(f"Hostname do dispositivo: {device_hostname}")
        
        # Obtendo a configuração
        config = get_running_config(ssh_client)
        if not config:
            print("Não foi possível obter a configuração. Saindo.")
            ssh_client.close()
            sys.exit(1)
        
        # Salvando a configuração
        save_config_to_file(config, device_hostname, args.directory)
        
    finally:
        # Fechando a conexão
        ssh_client.close()
        print("Conexão fechada.")

if __name__ == "__main__":
    main()

Solução do Exercício 2:

#!/usr/bin/env python3
# Inventário de Rede com NAPALM

from napalm import get_network_driver
import json
import argparse
import sys
import os
from datetime import datetime

def get_args():
    """Processa os argumentos da linha de comando."""
    parser = argparse.ArgumentParser(description='Script de inventário de rede com NAPALM.')
    parser.add_argument('-d', '--device_type', required=True, choices=['ios', 'iosxr', 'nxos', 'junos', 'eos'],
                        help='Tipo de dispositivo (ios, iosxr, nxos, junos, eos)')
    parser.add_argument('-H', '--hostname', required=True, help='Hostname ou IP do dispositivo')
    parser.add_argument('-u', '--username', required=True, help='Nome de usuário')
    parser.add_argument('-p', '--password', required=True, help='Senha')
    parser.add_argument('-P', '--port', type=int, default=22, help='Porta SSH (padrão: 22)')
    parser.add_argument('-o', '--output_dir', default='.', help='Diretório para salvar o relatório')
    return parser.parse_args()

def connect_napalm(device_type, hostname, username, password, port=22):
    """Estabelece uma conexão NAPALM com um dispositivo."""
    try:
        # Obtendo o driver apropriado para o tipo de dispositivo
        driver = get_network_driver(device_type)
        
        # Criando o objeto de dispositivo
        optional_args = {'port': port}
        
        device = driver(
            hostname=hostname,
            username=username,
            password=password,
            optional_args=optional_args
        )
        
        # Abrindo a conexão
        print(f"Conectando a {hostname} usando NAPALM ({device_type})...")
        device.open()
        print(f"Conectado com sucesso a {hostname}")
        
        return device
    except Exception as e:
        print(f"Erro ao conectar a {hostname}: {str(e)}")
        return None

def collect_device_info(device):
    """Coleta informações do dispositivo usando NAPALM."""
    inventory = {}
    
    try:
        # Coletando informações básicas
        print("Coletando informações básicas...")
        inventory['facts'] = device.get_facts()
        
        # Coletando informações das interfaces
        print("Coletando informações das interfaces...")
        inventory['interfaces'] = device.get_interfaces()
        inventory['interfaces_counters'] = device.get_interfaces_counters()
        
        # Coletando informações de IP
        print("Coletando informações de IP...")
        inventory['interfaces_ip'] = device.get_interfaces_ip()
        
        # Coletando tabela ARP
        print("Coletando tabela ARP...")
        inventory['arp_table'] = device.get_arp_table()
        
        # Coletando tabela MAC
        print("Coletando tabela MAC...")
        try:
            inventory['mac_address_table'] = device.get_mac_address_table()
        except NotImplementedError:
            print("Aviso: get_mac_address_table não implementado para este dispositivo.")
            inventory['mac_address_table'] = []
        
        # Coletando informações de LLDP
        print("Coletando informações de LLDP...")
        try:
            inventory['lldp_neighbors'] = device.get_lldp_neighbors()
            inventory['lldp_neighbors_detail'] = device.get_lldp_neighbors_detail()
        except NotImplementedError:
            print("Aviso: LLDP getters não implementados para este dispositivo.")
            inventory['lldp_neighbors'] = {}
            inventory['lldp_neighbors_detail'] = {}
        
        # Adicionando metadados
        inventory['metadata'] = {
            'collected_at': datetime.now().isoformat(),
            'device_type': device.platform,
            'hostname': inventory['facts'].get('hostname', 'unknown')
        }
        
        return inventory
    except Exception as e:
        print(f"Erro ao coletar informações: {str(e)}")
        return None

def save_inventory_to_json(inventory, output_dir):
    """Salva o inventário em um arquivo JSON."""
    try:
        # Criando o nome do arquivo
        hostname = inventory['facts'].get('hostname', 'unknown')
        timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
        filename = f"{hostname}_inventory_{timestamp}.json"
        filepath = os.path.join(output_dir, filename)
        
        # Salvando o inventário
        with open(filepath, 'w') as f:
            json.dump(inventory, f, indent=4)
        
        print(f"Inventário salvo em: {filepath}")
        return filepath
    except Exception as e:
        print(f"Erro ao salvar inventário: {str(e)}")
        return None

def main():
    """Função principal."""
    # Obtendo argumentos
    args = get_args()
    
    # Verificando se o diretório de saída existe
    if not os.path.exists(args.output_dir):
        try:
            os.makedirs(args.output_dir)
            print(f"Diretório criado: {args.output_dir}")
        except Exception as e:
            print(f"Erro ao criar diretório: {str(e)}")
            sys.exit(1)
    
    # Estabelecendo a conexão
    device = connect_napalm(
        device_type=args.device_type,
        hostname=args.hostname,
        username=args.username,
        password=args.password,
        port=args.port
    )
    
    if not device:
        print("Não foi possível estabelecer conexão NAPALM. Saindo.")
        sys.exit(1)
    
    try:
        # Coletando informações
        inventory = collect_device_info(device)
        if not inventory:
            print("Não foi possível coletar informações. Saindo.")
            device.close()
            sys.exit(1)
        
        # Salvando o inventário
        save_inventory_to_json(inventory, args.output_dir)
        
    finally:
        # Fechando a conexão
        device.close()
        print("Conexão fechada.")

if __name__ == "__main__":
    main()

Solução do Exercício 3:

#!/usr/bin/env python3
# Validação de Configuração com NAPALM

from napalm import get_network_driver
import json
import argparse
import sys
import os
from datetime import datetime

def get_args():
    """Processa os argumentos da linha de comando."""
    parser = argparse.ArgumentParser(description='Script de validação de configuração com NAPALM.')
    parser.add_argument('-d', '--device_type', required=True, choices=['ios', 'iosxr', 'nxos', 'junos', 'eos'],
                        help='Tipo de dispositivo (ios, iosxr, nxos, junos, eos)')
    parser.add_argument('-H', '--hostname', required=True, help='Hostname ou IP do dispositivo')
    parser.add_argument('-u', '--username', required=True, help='Nome de usuário')
    parser.add_argument('-p', '--password', required=True, help='Senha')
    parser.add_argument('-P', '--port', type=int, default=22, help='Porta SSH (padrão: 22)')
    parser.add_argument('-v', '--validation_file', required=True, help='Arquivo JSON de validação')
    parser.add_argument('-o', '--output_dir', default='.', help='Diretório para salvar o relatório')
    return parser.parse_args()

def connect_napalm(device_type, hostname, username, password, port=22):
    """Estabelece uma conexão NAPALM com um dispositivo."""
    try:
        # Obtendo o driver apropriado para o tipo de dispositivo
        driver = get_network_driver(device_type)
        
        # Criando o objeto de dispositivo
        optional_args = {'port': port}
        
        device = driver(
            hostname=hostname,
            username=username,
            password=password,
            optional_args=optional_args
        )
        
        # Abrindo a conexão
        print(f"Conectando a {hostname} usando NAPALM ({device_type})...")
        device.open()
        print(f"Conectado com sucesso a {hostname}")
        
        return device
    except Exception as e:
        print(f"Erro ao conectar a {hostname}: {str(e)}")
        return None

def load_validation_file(validation_file):
    """Carrega o arquivo de validação JSON."""
    try:
        with open(validation_file, 'r') as f:
            validation_data = json.load(f)
        
        print(f"Arquivo de validação carregado: {validation_file}")
        return validation_data
    except FileNotFoundError:
        print(f"Erro: Arquivo de validação não encontrado: {validation_file}")
        return None
    except json.JSONDecodeError as e:
        print(f"Erro: Arquivo de validação contém JSON inválido: {str(e)}")
        return None
    except Exception as e:
        print(f"Erro ao carregar arquivo de validação: {str(e)}")
        return None

def validate_device(device, validation_data):
    """Valida o dispositivo contra o estado desejado."""
    try:
        print("Executando validação...")
        result = device.compliance_report(validation_data)
        
        # Exibindo resumo dos resultados
        if result.get('complies', False):
            print("Validação bem-sucedida! O dispositivo está em conformidade.")
        else:
            print("Validação falhou! O dispositivo não está em conformidade.")
            
            # Contando falhas
            failure_count = 0
            for getter, getter_result in result.items():
                if getter != 'complies' and isinstance(getter_result, dict) and not getter_result.get('complies', True):
                    failure_count += 1
            
            print(f"Total de falhas: {failure_count}")
        
        return result
    except Exception as e:
        print(f"Erro ao validar dispositivo: {str(e)}")
        return None

def save_validation_report(report, hostname, output_dir):
    """Salva o relatório de validação em um arquivo JSON."""
    try:
        # Criando o nome do arquivo
        timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
        filename = f"{hostname}_validation_{timestamp}.json"
        filepath = os.path.join(output_dir, filename)
        
        # Adicionando metadados ao relatório
        report_with_metadata = {
            'metadata': {
                'hostname': hostname,
                'timestamp': datetime.now().isoformat(),
                'overall_compliance': report.get('complies', False)
            },
            'report': report
        }
        
        # Salvando o relatório
        with open(filepath, 'w') as f:
            json.dump(report_with_metadata, f, indent=4)
        
        print(f"Relatório de validação salvo em: {filepath}")
        return filepath
    except Exception as e:
        print(f"Erro ao salvar relatório: {str(e)}")
        return None

def main():
    """Função principal."""
    # Obtendo argumentos
    args = get_args()
    
    # Verificando se o diretório de saída existe
    if not os.path.exists(args.output_dir):
        try:
            os.makedirs(args.output_dir)
            print(f"Diretório criado: {args.output_dir}")
        except Exception as e:
            print(f"Erro ao criar diretório: {str(e)}")
            sys.exit(1)
    
    # Carregando o arquivo de validação
    validation_data = load_validation_file(args.validation_file)
    if not validation_data:
        print("Não foi possível carregar o arquivo de validação. Saindo.")
        sys.exit(1)
    
    # Estabelecendo a conexão
    device = connect_napalm(
        device_type=args.device_type,
        hostname=args.hostname,
        username=args.username,
        password=args.password,
        port=args.port
    )
    
    if not device:
        print("Não foi possível estabelecer conexão NAPALM. Saindo.")
        sys.exit(1)
    
    try:
        # Executando a validação
        validation_report = validate_device(device, validation_data)
        if validation_report is None:
            print("Não foi possível executar a validação. Saindo.")
            device.close()
            sys.exit(1)
        
        # Salvando o relatório
        save_validation_report(validation_report, args.hostname, args.output_dir)
        
    finally:
        # Fechando a conexão
        device.close()
        print("Conexão fechada.")

if __name__ == "__main__":
    main()

Exemplo de arquivo de validação (validation.json):

{
    "get_facts": {
        "os_version": "15.4",
        "hostname": "Router1",
        "model": "CSR1000V"
    },
    "get_interfaces": {
        "GigabitEthernet1": {
            "is_up": true,
            "is_enabled": true
        },
        "Loopback0": {
            "is_up": true,
            "description": "Management Interface"
        }
    },
    "get_interfaces_ip": {
        "GigabitEthernet1": {
            "ipv4": {
                "192.168.1.1": {
                    "prefix_length": 24
                }
            }
        },
        "Loopback0": {
            "ipv4": {
                "1.1.1.1": {
                    "prefix_length": 32
                }
            }
        }
    }
}

Respostas do Quiz:

1. Benefícios da automação de redes: Eficiência, consistência, redução de erros humanos, escalabilidade, documentação automática e resposta rápida a incidentes.
2. Protocolo para dispositivos antigos: SSH é o mais adequado para automação em dispositivos Cisco mais antigos, pois é amplamente suportado em todas as versões do IOS.
3. Diferença entre NETCONF e RESTCONF: NETCONF usa SSH e XML, enquanto RESTCONF usa HTTP/HTTPS e JSON/XML. RESTCONF é geralmente considerado mais simples e mais familiar para desenvolvedores web.
4. Biblioteca SSH base: Paramiko é a implementação de SSH em Python usada como base para outras bibliotecas como Netmiko.
5. Vantagem do NAPALM: A principal vantagem do NAPALM é a abstração multi-vendor, que fornece uma interface unificada para interagir com dispositivos de diferentes fabricantes.
6. Operações de configuração do NAPALM: Merge (mesclagem), replace (substituição) e compare (comparação).
7. Getters no NAPALM: São métodos padronizados para obter informações dos dispositivos, como get_facts(), get_interfaces(), get_arp_table(), etc.
8. Método de validação do NAPALM: O método compliance_report() é usado para validar o estado atual de um dispositivo contra um estado desejado.
9. Importância de ssh_client.close(): Para liberar recursos do sistema, garantir que todos os dados sejam enviados e evitar que o arquivo fique bloqueado para outros processos.
10. Limitação do Paramiko: Paramiko é uma biblioteca de baixo nível que não possui tratamento específico para diferentes tipos de dispositivos de rede, não oferece recursos como detecção de prompt ou tratamento de paginação, e requer mais código para tarefas comuns.