O que so Eventos Enviados pelo Servidor HTTP (SSE)?

Server-Sent Events (SSE) um padro que permite que um servidor envie dados para uma pgina web ou cliente por meio de uma nica conexo HTTP de longa durao. Ao contrrio das requisies web tradicionais, onde o cliente deve solicitar explicitamente os dados, o SSE permite um fluxo unidirecional de informaes. Uma vez estabelecida a conexo, o servidor pode enviar atualizaes sempre que novos dados estiverem disponveis, sem interveno adicional do cliente.

Definio: Server-Sent Events (SSE) uma tecnologia onde um navegador recebe atualizaes automticas de um servidor via uma conexo HTTP. Faz parte da especificao HTML5 e projetado para ser uma alternativa mais simples aos WebSockets para comunicao servidor-para-cliente.

A Diferena Fundamental: HTTP Simples vs. SSE

Para entender o valor do SSE, essencial compar-lo com o modelo padro de requisio-resposta HTTP que governa a maioria das interaes web.

Em um cenrio de HTTP simples, se um cliente precisa saber quando um arquivo foi atualizado em um servidor, ele deve fazer polling repetidamente no servidor ou esperar por uma ao especfica do usurio. Isso leva a trfego de rede desnecessrio e maior latncia. O SSE resolve isso mantendo o canal de comunicao aberto, permitindo que o servidor "envie" a atualizao no momento em que ela ocorre.

Como o SSE Funciona: Por Trs dos Panos

O SSE opera sobre HTTP padro e usa um tipo MIME especfico: text/event-stream. O processo comea com uma requisio HTTP GET padro do cliente, incluindo um cabealho indicando que ele deseja aceitar um fluxo de eventos.

1. Handshake: O cliente envia uma requisio com o cabealho Accept: text/event-stream.

2. Resposta: O servidor responde com Content-Type: text/event-stream e mantm a conexo aberta.

3. Transmisso de Dados: O servidor envia dados em um formato de texto especfico, geralmente prefixado com data:. Por exemplo:

   event: update
   data: {"status": "processing", "progress": 45}
   
   event: result
   data: {"message": "Task completed successfully"}
   

4. Reconexo Automtica: Uma das caractersticas mais poderosas do SSE seu suporte integrado para reconexo. Se a conexo for perdida, o cliente (geralmente o navegador) tentar automaticamente se reconectar aps um curto atraso.

SSE no Contexto dos Servidores MCP

O Model Context Protocol (MCP) um padro aberto que permite que modelos de IA interajam com ferramentas externas e fontes de dados. O MCP suporta mltiplos mecanismos de transporte, sendo o SSE a escolha principal para implementaes de servidor remoto baseadas na web (frequentemente referidas como "Streamable HTTP").

Por que o MCP Usa SSE

Servidores MCP frequentemente precisam fornecer feedback em tempo real para agentes de IA, como transmitir a sada de uma ferramenta de longa execuo ou fornecer atualizaes de status durante a recuperao de dados complexos. O SSE ideal para isso por vrias razes:

• Streaming em Tempo Real: Modelos de IA geram texto e dados incrementalmente. O SSE permite que os servidores MCP transmitam esses resultados de volta ao cliente medida que so produzidos, em vez de esperar que todo o processo termine.

• Compatibilidade com Firewall e Proxy: Como o SSE apenas HTTP padro, ele atravessa facilmente firewalls, proxies e balanceadores de carga que poderiam bloquear protocolos no padronizados como WebSockets.

• Simplicidade e Eficincia: Para muitas tarefas orientadas por IA, a comunicao principalmente do servidor (a ferramenta/fonte de dados) para o cliente (o agente de IA). O SSE fornece a capacidade de tempo real necessria sem a complexidade de gerenciar conexes WebSocket full-duplex.

A Arquitetura de Transporte MCP

Em uma implementao MCP SSE, a comunicao estruturada para lidar com a natureza unidirecional do SSE, mantendo a capacidade do cliente de enviar comandos:

1. O Endpoint SSE (GET): O cliente estabelece uma conexo de longa durao para receber mensagens, eventos e sadas de ferramentas do servidor MCP.

2. O Endpoint de Comando (POST): Quando o cliente precisa enviar uma requisio ao servidor (por exemplo, "executar esta ferramenta"), ele envia uma requisio HTTP POST padro. O servidor ento processa a requisio e envia os resultados de volta atravs do fluxo SSE estabelecido.

Casos de Uso para SSE no MCP

A integrao de SSE e MCP permite uma variedade de casos de uso poderosos no ecossistema de IA:

1. Monitoramento de Logs ao Vivo: Um agente de IA pode se conectar a um servidor MCP que monitora logs do servidor. Usando SSE, o agente recebe um fluxo ao vivo de entradas de log, permitindo detectar e reagir a erros em tempo real.

2. Visualizao Dinmica de Dados: Quando um agente de IA realiza anlise de dados via uma ferramenta MCP, o servidor pode usar SSE para enviar atualizaes incrementais para um painel, mostrando o progresso da anlise ou grficos intermedirios.

3. Fluxos de Trabalho Colaborativos de IA: Mltiplos agentes podem se inscrever no mesmo fluxo SSE de um servidor MCP, permitindo que eles permaneam sincronizados sobre o estado de uma tarefa compartilhada ou fonte de dados.

No entanto, entrar no mundo async pode ser confuso. O que uma corrotina? Eu preciso mesmo do asyncio? E, a pergunta mais crtica de todas: o que acontece se eu misturar cdigo sncrono e assncrono?

O Bsico: Funes Sncronas vs. Assncronas

• Funo Sncrona (normal): Quando voc a chama, ela executa do incio ao fim sem interrupo. Se ela precisa esperar por algo (como uma resposta de rede), todo o seu programa para e espera junto. como um telefonema: voc fica na linha at a conversa acabar.

• Funo Assncrona (Corrotina): uma funo que pode ser pausada e retomada. Quando ela encontra uma operao de espera (marcada com await), ela diz ao Python: "Ei, isso vai demorar. Pode ir fazendo outra coisa enquanto eu espero". como enviar uma mensagem de texto: voc envia e pode fazer outras coisas at a resposta chegar.

As Peas do Quebra-Cabea Async

Para o async funcionar, precisamos de trs componentes principais:

1. Corrotinas (async def): So as funes "pausveis". Voc as define com async def.

2. await: A palavra-chave que de fato pausa a corrotina e devolve o controle, dizendo "estou esperando por este resultado". Voc s pode usar await dentro de uma async def.

3. O Event Loop: o maestro que orquestra tudo. Ele mantm uma lista de tarefas e executa uma de cada vez. Quando uma tarefa pausada com await, o event loop imediatamente pega a prxima tarefa da lista e a executa. Ele o corao do asyncio.

Eu Preciso do asyncio?

Sim e no.

• No, voc no precisa importar e interagir com todas as partes complexas do asyncio o tempo todo.

• Sim, voc precisa de algo para rodar o event loop e gerenciar as corrotinas. O asyncio a biblioteca padro do Python para isso.

Na prtica, seu uso do asyncio pode ser to simples quanto:

• asyncio.run(main()): O ponto de entrada que inicia o event loop e executa sua corrotina principal main.

• asyncio.gather(*tasks): Uma forma de executar uma lista de corrotinas concorrentemente e esperar que todas terminem.

Voc no precisa construir o event loop manualmente; o asyncio cuida da parte difcil para voc.

O Pecado Capital: Chamar Cdigo Bloqueante em uma Corrotina

Esta a regra mais importante da programao assncrona: nunca, jamais, chame uma funo sncrona e bloqueante dentro de uma corrotina.

Funes bloqueantes so aquelas que fazem o programa esperar, como:

• time.sleep(5)

• requests.get(url)

• Uma chamada de uma biblioteca de rede que no async, como netmiko.ConnectHandler(...)

O que acontece quando voc faz isso?

Voc congela o chef de cozinha. A funo bloqueante toma controle total do processo e no o devolve at que ela termine. O event loop fica paralisado, incapaz de trocar de tarefa. Todas as outras corrotinas que estavam prontas para rodar ficam esperando, famintas. Todo o benefcio da concorrncia perdido.

sequenceDiagram
    participant EventLoop
    participant CorrotinaA
    participant CorrotinaB
    participant FuncaoSincrona

    EventLoop->>CorrotinaA: Executar
    CorrotinaA->>FuncaoSincrona: Chamar time.sleep(5)
    Note over EventLoop,FuncaoSincrona: O EVENT LOOP EST BLOQUEADO!
    Note over CorrotinaB: Esperando para executar...
    FuncaoSincrona-->>CorrotinaA: Retorna aps 5s
    CorrotinaA-->>EventLoop: Finaliza
    EventLoop->>CorrotinaB: Finalmente executa

No diagrama acima, a CorrotinaB s pde executar depois que a FuncaoSincrona (o time.sleep(5)) liberou o processo, 5 segundos depois. A concorrncia foi destruda.

A Soluo: asyncio.to_thread()

Ento, como usamos bibliotecas sncronas e bloqueantes (como a netmiko, que essencial para muitos de ns) em um cdigo async?

A resposta delegar o trabalho bloqueante para um thread separado, liberando o event loop para continuar seu trabalho. Desde o Python 3.9, o asyncio tornou isso incrivelmente fcil com asyncio.to_thread().

asyncio.to_thread(func, *args) pega uma funo sncrona func e seus argumentos *args, a executa em um thread separado e retorna um objeto "aguardvel" (awaitable). O event loop pode "esperar" por esse objeto sem ser bloqueado.

Caso Prtico: Netmiko (Sncrono) + HTTPX (Assncrono)

Vamos criar um script que, concorrentemente, busca a configurao de um roteador usando netmiko e busca dados de uma API usando httpx.

O jeito ERRADO (bloqueante):

import asyncio
import httpx
from netmiko import ConnectHandler

async def get_config_bloqueante(device): # RUIM!
    print('Iniciando conexo Netmiko...')
    with ConnectHandler(**device) as conn:
        output = conn.send_command('show run')
    print('Conexo Netmiko finalizada.')
    return output

async def get_api_data():
    print('Iniciando chamada de API...')
    async with httpx.AsyncClient() as client:
        await client.get('https://httpbin.org/delay/2') # Simula espera de 2s
    print('Chamada de API finalizada.')

async def main():
    # ... (definio do dispositivo) ...
    await asyncio.gather(
        get_config_bloqueante(device), # Esta chamada ir bloquear tudo!
        get_api_data()
    )

# Se a conexo Netmiko levar 5s, a chamada de API s comear depois disso.

O jeito CERTO (com to_thread):

import asyncio
import httpx
from netmiko import ConnectHandler

# Funo sncrona e bloqueante, como deve ser
def get_config_sincrono(device):
    print('Iniciando conexo Netmiko em um thread...')
    with ConnectHandler(**device) as conn:
        output = conn.send_command('show run')
    print('Conexo Netmiko finalizada.')
    return output

async def get_api_data():
    print('Iniciando chamada de API...')
    async with httpx.AsyncClient() as client:
        await client.get('https://httpbin.org/delay/2')
    print('Chamada de API finalizada.')

async def main():
    device = {
    # dados do router
    }

    # Delega a funo bloqueante para um thread separado
    netmiko_task = asyncio.to_thread(get_config_sincrono, device)
    api_task = get_api_data()

    await asyncio.gather(netmiko_task, api_task)

asyncio.run(main())

Nesta verso, enquanto get_config_sincrono est rodando em seu prprio thread, o event loop est livre para executar get_api_data concorrentemente. As duas tarefas progridem ao mesmo tempo.

Concluso

Entender async entender a arte de no esperar. Para automao de redes, onde o tempo de espera o maior inimigo, isso transformador.

Lembre-se das regras de ouro:

1. Use async/await para tarefas I/O-bound: Interaes com rede (APIs, SSH) so o caso de uso perfeito.

2. Nunca bloqueie o Event Loop: Uma nica chamada sncrona bloqueante em uma corrotina destri toda a vantagem do async.

3. Use asyncio.to_thread(): a sua ponte segura para integrar bibliotecas sncronas e legadas em um mundo assncrono moderno.

Ao dominar esses conceitos, voc estar equipado para escrever automaes de rede drasticamente mais rpidas, eficientes e escalveis.

Referncias:

1. RealPython - Async IO in Python: A Complete Walkthrough

2. Documentao Oficial do asyncio

3. Documentao do asyncio.to_thread

nesse cenrio que surge o HTTPX, uma biblioteca de cliente HTTP de nova gerao para Python. O HTTPX oferece uma API amplamente compatvel, o que torna a migrao quase indolor, mas adiciona superpoderes que so cruciais para a automao de redes moderna: suporte nativo a async/await e HTTP/2

Vamos focar nas vantagens do httpx e mostrar por que ele deve se tornar a sua nova ferramenta padro para interagir com APIs de rede.

Requests vs. HTTPX: Uma Comparao Direta

Vantagem 1: Programao Assncrona (async/await)

A maior limitao do requests que ele sncrono. Quando voc faz uma requisio, seu cdigo para e espera a resposta do servidor antes de continuar. Em automao de redes, isso um gargalo fatal. Imagine precisar consultar a API de 100 switches para obter o status de suas interfaces. Com requests, voc faria isso em srie:

sequenceDiagram
    participant Script
    participant Switch1
    participant Switch2
    participant Switch100

    Script->>Switch1: GET /api/interfaces
    Note right of Script: Espera...
    Switch1-->>Script: Resposta
    Script->>Switch2: GET /api/interfaces
    Note right of Script: Espera...
    Switch2-->>Script: Resposta
    Note over Script: ...continua sequencialmente...
    Script->>Switch100: GET /api/interfaces
    Note right of Script: Espera...
    Switch100-->>Script: Resposta

Se cada requisio levar 1 segundo, o processo todo levar 100 segundos. A maior parte desse tempo gasta esperando a rede e o servidor (I/O-bound).

O HTTPX com async resolve isso. Ele permite que voc dispare todas as 100 requisies de uma vez e espere pelas respostas concorrentemente. Enquanto uma requisio est esperando pela rede, o programa pode trabalhar em outra.

sequenceDiagram
    participant Script
    participant Switch1
    participant Switch2
    participant Switch100

    Script->>Switch1: GET /api/interfaces
    Script->>Switch2: GET /api/interfaces
    Script->>Switch100: GET /api/interfaces
    Note right of Script: Dispara todas as requisies

    Switch1-->>Script: Resposta
    Switch2-->>Script: Resposta
    Switch100-->>Script: Resposta
    Note right of Script: Processa as respostas  medida que chegam

Com async, o tempo total ser prximo ao da requisio mais longa, talvez pouco mais de 1 segundo, em vez de 100 segundos. Uma melhoria de performance de quase 100x.

Caso Prtico: Consultando Mltiplos Dispositivos no NetBox

Vamos buscar os detalhes de 3 dispositivos diferentes no NetBox, primeiro com requests e depois com httpx.

Com requests (Sequencial):

import requests
import time

NETBOX_URL = "https://demo.netbox.dev/api"
DEVICE_IDS = [1, 2, 3]

def fetch_devices_sync():
    start_time = time.time()
    for device_id in DEVICE_IDS:
        response = requests.get(f"{NETBOX_URL}/dcim/devices/{device_id}/")
        print(f"Dispositivo {device_id}: {response.json()["name"]}")
    duration = time.time() - start_time
    print(f"\nVerso sncrona levou: {duration:.2f} segundos")

fetch_devices_sync()

Com httpx (Concorrente):

import httpx
import asyncio
import time

NETBOX_URL = "https://demo.netbox.dev/api"
DEVICE_IDS = [1, 2, 3]

async def fetch_device(client, device_id):
    response = await client.get(f"{NETBOX_URL}/dcim/devices/{device_id}/")
    print(f"Dispositivo {device_id}: {response.json()["name"]}")

async def fetch_devices_async():
    start_time = time.time()
    async with httpx.AsyncClient() as client:
        tasks = [fetch_device(client, device_id) for device_id in DEVICE_IDS]
        await asyncio.gather(*tasks)
    duration = time.time() - start_time
    print(f"\nVerso assncrona levou: {duration:.2f} segundos")

asyncio.run(fetch_devices_async())

Embora para 3 dispositivos a diferena possa ser pequena, para 100 ou 1000, a verso assncrona ser ordens de magnitude mais rpida.

Vantagem 2: Suporte a HTTP/2

O HTTP/2 uma reviso majoritria do protocolo HTTP que traz melhorias significativas de performance, especialmente o multiplexing. Com HTTP/1.1, se voc precisa de 5 recursos de um mesmo servidor, o navegador (ou seu cliente HTTP) abre mltiplas conexes TCP, o que custoso. Com HTTP/2, todas essas requisies podem ser enviadas concorrentemente sobre uma nica conexo TCP

Para APIs modernas que so servidas sobre HTTP/2 (como muitas APIs gRPC-web e de provedores de nuvem), usar um cliente que suporte o protocolo pode reduzir a latncia e o consumo de recursos.

Com httpx, habilitar HTTP/2 trivial:

import httpx

# O cliente tentar negociar HTTP/2 com o servidor
with httpx.Client(http2=True) as client:
    response = client.get("https://http2.pro/api/v1")
    print(response.http_version)
    # Output: "HTTP/2"

A biblioteca requests no possui suporte nativo a HTTP/2.

Migrando de requests para httpx: Um Cheatsheet

A beleza do httpx que sua API sncrona um substituto quase direto para o requests. A migrao incrivelmente fcil.

Passo 1: Migrao Sncrona

Na maioria dos casos, voc pode simplesmente substituir import requests por import httpx e seu cdigo continuar funcionando.

Passo 2: Adotando o Async (Onde faz sentido)

Para as partes do seu cdigo que fazem mltiplas chamadas de API, refatore-as para usar async def, httpx.AsyncClient, e asyncio.gather para obter os ganhos de performance.

Concluso: Por que o HTTPX o Futuro para NetDevOps

O requests uma biblioteca fantstica e serviu comunidade Python por muitos anos. Ela no est "morta" e ainda perfeitamente adequada para scripts simples e sequenciais. No entanto, a automao de redes moderna inerentemente concorrente. Precisamos interagir com dezenas, centenas ou milhares de dispositivos e APIs o mais rpido possvel.

O HTTPX no apenas uma alternativa; a evoluo natural. Ele nos d:

• Performance: A capacidade de executar operaes de I/O em paralelo com async.

• Eficincia: Suporte a HTTP/2 para interaes mais rpidas com APIs modernas.

• Flexibilidade: Uma nica biblioteca que pode operar tanto de forma sncrona quanto assncrona.

• Familiaridade: Uma API que se sente em casa para qualquer um que j usou requests.

Para qualquer novo projeto de automao de redes que envolva interao com APIs, o httpx deveria ser sua escolha padro. Comece usando sua API sncrona para uma transio fcil e, em seguida, adote o async nas partes do seu cdigo que mais se beneficiaro da concorrncia. Sua automao agradecer pela velocidade.

Referncias:

1. HTTPX Official Documentation

2. MDN Web Docs - HTTP/2

3. ScrapingAnt - Requests vs. HTTPX - A Detailed Comparison

Bora dar uma olhada!

O Que o Operador Walrus e a problemtica

Em essncia, o operador walrus combina duas aes em uma: atribuir um valor a uma varivel e retornar esse mesmo valor para ser usado imediatamente.

O Problema: Muitas vezes, precisamos obter um valor, checar se ele vlido e, se for, us-lo. Isso geralmente resulta em cdigo repetitivo ou menos legvel.

A Soluo (:=): Ele elimina essa redundncia, tornando o cdigo mais conciso e direto ao ponto.

Exemplos: Antes e Depois

Exemplo 1: Parsing de Sada de Comandos

Um dos usos mais comuns na automao de redes executar um comando, procurar por um padro com expresses regulares (regex) e, se encontrar, usar o valor encontrado.

Cenrio: Encontrar todas as interfaces que esto administrativamente desativadas (administratively down) na sada de um show interface.

Sem o Operador Walrus 🙁

import re

# Simulao da sada de um comando
show_interface_output = """
GigabitEthernet1 is up, line protocol is up
GigabitEthernet2 is administratively down, line protocol is down
TenGigabitEthernet3/1 is up, line protocol is up
GigabitEthernet4 is administratively down, line protocol is down
"""

down_interfaces = []
for line in show_interface_output.splitlines():
    # Procuramos pelo padro
    match = re.search(r"^(.*) is administratively down", line)
    # Checamos se o padro foi encontrado
    if match:
        # Se sim, usamos o valor capturado
        interface_name = match.group(1)
        down_interfaces.append(interface_name)

print(f"Interfaces desativadas: {down_interfaces}")
# Sada: Interfaces desativadas: [\"GigabitEthernet2\", \"GigabitEthernet4\"]

Com o Operador Walrus 🙂

import re

show_interface_output = """mesma do exemplo anterior"""

down_interfaces = []
for line in show_interface_output.splitlines():
    # 1. Procuramos, atribumos e checamos TUDO EM UMA LINHA
    if match := re.search(r"^(.*) is administratively down", line):
        # 2. Se o padro foi encontrado, a varivel \"match\" j est pronta para uso
        down_interfaces.append(match.group(1))

print(f"Interfaces desativadas: {down_interfaces}")
# Sada: Interfaces desativadas: [\"GigabitEthernet2\", \"GigabitEthernet4\"]

A verificao e a atribuio acontecem no mesmo lugar, reduzindo a complexidade visual.

Exemplo 2: Loops Interativos (Cliente Ollama)

O operador walrus brilha em loops while onde voc precisa obter uma entrada do usurio e verificar se ela atende a uma condio de sada.

Cenrio: Criar um loop simples que l a entrada do usurio, envia para uma funo (simulando o cliente Ollama) e para quando o usurio digita "sair".

Sem o Operador Walrus 🙁

def processar_prompt(prompt):
    print(f"🤖 Processando: {prompt}")
    # Aqui iria a chamada real para o cliente Ollama
    # client.chat(model="llama3", messages=[...])

# Precisamos ler a entrada uma vez fora do loop
prompt = input("Voc: ")

#  Checamos a condio
while prompt.lower() != "sair":
    processar_prompt(prompt)
    # 3. E precisamos ler a entrada novamente dentro do loop
    prompt = input("Voc: ")

print("At logo!")

Com o Operador Walrus 🙂

def processar_prompt(prompt):
    print(f"🤖 Processando: {prompt}")

# 1. Lemos, atribumos e checamos TUDO NA CONDIO DO WHILE
while (prompt := input("Voc: ")).lower() != "sair":
    processar_prompt(prompt)

print("At logo!")

1. Elimina a Duplicao: No precisamos mais da linha prompt = input("Voc: ") em dois lugares diferentes.

2. Lgica Centralizada: A lgica de controle do loop (obter entrada e verificar a condio de parada) est toda concentrada na declarao while, tornando o cdigo mais fcil de entender.

Quando Usar e Quando Evitar

Regra: Se o operador walrus torna seu cdigo mais limpo e fcil de entender, use-o. Se ele o torna mais crptico, prefira a forma tradicional.

O bsico (add, commit, push, pull) resolve 90% dos casos. Mas os outros 10% so onde os problemas crticos acontecem. Dominar os comandos a seguir o que diferencia um usurio iniciante de um expert.

git stash: Salvando seu Trabalho Temporariamente

Cenrio: Voc est no meio da configurao de uma nova poltica de BGP (feature/bgp-policy), mas um incidente urgente acontece e voc precisa verificar o estado de uma configurao no branch main imediatamente. Seu trabalho est incompleto e voc no quer fazer um commit "WIP" (Work in Progress).

O git stash salva suas modificaes no commitadas em uma "pilha" temporria e limpa seu diretrio de trabalho, deixando-o no estado do ltimo commit (HEAD).

graph TD
    A[Diretrio de Trabalho com Mudanas] -- git stash --> B(Pilha de Stash);
    B -- git stash pop --> C[Diretrio de Trabalho Restaurado];

Cheatsheet do stash:

Exemplo de fluxo:

# Voc est no branch 'feature/bgp-policy' com trabalho no salvo
git status # Mostra arquivos modificados

# Salva o trabalho para atender a uma emergncia
git stash

# Muda para o branch principal para investigar
git checkout main
# ... faz a investigao ...

# Volta para seu branch de feature
git checkout feature/bgp-policy

# Restaura seu trabalho no salvo
git stash pop

git status # Seus arquivos modificados esto de volta!

git revert vs git reset: A Batalha pela Histria do Git

Ambos os comandos desfazem mudanas, mas de maneiras fundamentalmente diferentes. A escolha errada aqui pode causar grandes problemas para sua equipe.

Visualizando git revert:

Imagine que o commit C introduziu um bug em produo.

gitGraph
    commit id: "A"
    commit id: "B"
    commit id: "C" type: HIGHLIGHT
    commit id: "D"
    commit id: "C'" type: REVERSE msg: "Revert feat: Adiciona bug"

O git revert C cria um novo commit C' que desfaz as mudanas de C. O histrico preservado e a mudana transparente para todos.

Visualizando git reset:

Agora, imagine que C e D so commits ruins que voc fez localmente e ainda no compartilhou.

gitGraph
    commit id: "A"
    commit id: "B"
    commit id: "C"
    commit id: "D"

Executar git reset --hard B mover o HEAD do main de volta para B, e os commits C e D sero perdidos (ou, mais precisamente, se tornaro rfos, aguardando para serem limpos pelo garbage collector do Git).

gitGraph
    commit id: "A"
    commit id: "B"

Regra de ouro: Se o commit est no repositrio remoto (GitHub/GitLab), use git revert. Se o commit s existe na sua mquina local, git reset uma opo.

git rebase: Reescrevendo a Histria para um Futuro Mais Limpo

Cenrio: Voc criou seu branch feature/nova-firewall-policy a partir do main. Enquanto voc trabalhava, outros engenheiros mesclaram vrias outras mudanas no main. Seu branch de feature agora est desatualizado, e um git merge main criaria um "merge commit" que polui o histrico.

O git rebase resolve isso. Ele pega todos os commits do seu branch e os reaplica "em cima" do estado mais recente do branch alvo (main).

graph TD
    subgraph "Antes do Rebase"
        A((A)) --> B((B)) --> C((C<br>main))
        B --> D((D)) --> E((E<br>feature))
    end
    subgraph "Depois de 'git rebase main'"
        A2((A)) --> B2((B)) --> C2((C<br>main)) --> D2((D')) --> E2((E'<br>feature))
    end
    style C fill:#f9f,stroke:#333
    style E fill:#f9f,stroke:#333
    style C2 fill:#f9f,stroke:#333
    style E2 fill:#f9f,stroke:#333

Fluxo de trabalho com rebase:

# No seu branch de feature
git checkout feature/nova-firewall-policy

# Busca as ltimas mudanas do remoto
git fetch origin

# Rebase do seu branch em cima do 'main' mais recente
git rebase origin/main

# Agora seu branch est atualizado e pronto para um merge limpo (fast-forward)

Aviso: Assim como o reset, o rebase reescreve o histrico (os hashes dos commits D e E mudam para D' e E'). Nunca faa rebase de um branch que compartilhado e usado por mltiplos desenvolvedores (como o main). seguro para seus prprios branches de feature antes de abrir um PR.

git reflog e git bisect: As Ferramentas do Detetive

• git reflog (Reference Log): Seu salva-vidas. O Git mantm um registro de quase tudo que voc faz (commits, resets, checkouts). Se voc usou git reset e acha que perdeu um commit para sempre, o git reflog mostrar o hash daquele commit perdido, e voc pode recuper-lo com git checkout <hash> ou git cherry-pick <hash>. a sua rede de segurana pessoal.

• git bisect: O caador de bugs. Se voc sabe que um bug foi introduzido em algum momento nos ltimos 100 commits, mas no sabe onde, o git bisect automatiza a busca. Voc informa um commit "bom" (onde o bug no existia) e um commit "ruim" (onde o bug existe). O Git ento faz uma busca binria, fazendo checkout de commits no meio do caminho e perguntando a voc se o bug est presente. Em poucos passos, ele aponta o commit exato que introduziu a regresso. Isso incrvel para encontrar qual mudana de configurao quebrou a conectividade.

Adotar o Git como a fonte de versionamento para a configurao da sua rede transforma a maneira como voc opera. Mudanas deixam de ser comandos ad-hoc digitados em uma sesso SSH meia-noite e passam a ser commits rastreveis, revisveis e, o mais importante, reversveis. O Git no apenas um sistema de backup; a base para uma operao de rede moderna, habilitando prticas como reviso por pares (code review), testes automatizados (CI/CD) e auditoria.

Este guia um cheatsheet focado nos comandos que mais utilizo no Git e que vez ou outra preciso de um refresh.

Por que Git para Redes? O Modelo de IaC

Infraestrutura como Cdigo (IaC) a prtica de gerenciar e provisionar infraestrutura atravs de arquivos de definio legveis por mquina, em vez de configurao manual. O Git o pilar que sustenta essa prtica.

Git Cheatsheet Bsico para o Dia a Dia

Estes so os comandos que voc usar 90% do tempo. Mantenha esta lista por perto.

O Workflow de Feature Branch: Um Padro para NetDevOps

Nunca, jamais, faa commit diretamente no branch main (ou master). O branch main deve sempre refletir o estado desejado da sua produo. Todas as mudanas devem seguir o Feature Branch Workflow.

sequenceDiagram
    participant Dev as Engenheiro
    participant Local as Repositrio Local
    participant Remote as Repositrio Remoto (GitHub)
    participant CI_CD as Pipeline CI/CD

    Dev->>Local: git checkout main
    Dev->>Local: git pull origin main
    Dev->>Local: git checkout -b feature/nova-vlan
    Note over Dev,Local: Trabalha na nova feature
    Dev->>Local: git add .
    Dev->>Local: git commit -m "feat: Adiciona VLAN 100"
    Dev->>Remote: git push origin feature/nova-vlan
    Dev->>Remote: Abre Pull Request (PR)
    Remote->>CI_CD: Dispara pipeline de CI (testes)
    CI_CD-->>Remote: Testes passaram
    Note over Remote: Outro engenheiro revisa e aprova o PR
    Remote->>Local: Engenheiro mescla o PR no branch 'main'
    Remote->>CI_CD: Dispara pipeline de CD (deploy)
    CI_CD-->>Remote: Deploy concludo com sucesso

Cenrio: Voc precisa adicionar uma nova VLAN de voz (VLAN 100) em todos os switches de acesso.

Passo a Passo do Workflow:

1. Sincronize seu Repositrio Local: Antes de comear, garanta que seu branch main local est atualizado com o remoto.

    git checkout main
    git pull origin main
   

2. Crie um Novo Branch para sua Mudana: O nome do branch deve ser descritivo.

    git checkout -b feature/add-voice-vlan-100
   

3. Faa as Mudanas Necessrias: Modifique os arquivos de configurao, templates Jinja2, ou variveis do inventrio Ansible para adicionar a VLAN 100.

    # Exemplo: editando um arquivo de variveis
    # vim group_vars/access_switches.yml
   

4. Teste suas Mudanas Localmente: Use ferramentas como ansible-lint, pytest, ou um laboratrio virtual (EVE-NG, GNS3) para validar que sua mudana funciona como esperado e no quebra nada.

5. Faa o Commit das suas Mudanas: Adicione os arquivos modificados e faa o commit com uma mensagem clara, seguindo um padro como o Conventional Commits.

    git add group_vars/access_switches.yml
    git commit -m "feat: Adiciona VLAN 100 para o servio de voz"
   

6. Envie seu Branch para o Repositrio Remoto:

    git push origin feature/add-voice-vlan-100
   

7. Abra um Pull Request (PR) ou Merge Request (MR): Na interface do seu provedor Git (GitHub, GitLab, Bitbucket), abra um PR do seu branch (feature/add-voice-vlan-100) para o branch main.

   • Descreva o propsito da mudana.

   • Associe o PR a um ticket do Jira ou outra ferramenta de gerenciamento.

8. Reviso por Pares (Code Review) e CI:

   • Outro membro da equipe revisa suas mudanas, sugere melhorias e, finalmente, aprova.

   • Um pipeline de CI disparado automaticamente, rodando testes (pytest, ansible-lint) contra o seu branch para uma validao final.

9. Merge: Aps a aprovao e o sucesso do pipeline de CI, o PR mesclado no branch main.

10. Deploy (Opcional, mas recomendado - GitOps): O merge no main pode disparar um pipeline de CD (Continuous Deployment) que executa um playbook Ansible em produo, aplicando a mudana na rede real.

11. Limpeza: Aps o merge, voc pode deletar o branch local e remoto.

    git checkout main
    git branch -d feature/add-voice-vlan-100
    git push origin --delete feature/add-voice-vlan-100
    

Comandos Avanados teis (Quando as Coisas do Errado)

Referncias:

1. Atlassian Git Tutorial

2. Conventional Commits Specification

3. Git Flow vs. GitHub Flow

Desenvolvido pela Astral, o uv um gerenciador de pacotes e projetos Python escrito em Rust. Ele foi projetado para ser um substituto completo e veloz para os fluxos de trabalho de pip, pip-tools, pipx e virtualenv. A promessa uma performance de 10 a 100 vezes mais rpida que as ferramentas tradicionais

Por que usar o uv?

Antes de entrarmos nos comandos, vale a pena entender os benefcios:

• Velocidade Extrema: Graas ao Rust e a um resolvedor de dependncias avanado, o uv instala e atualiza pacotes em uma frao do tempo do pip.

• Tudo em Um: Ele unifica as funcionalidades de vrias ferramentas em um nico executvel. Chega de instalar virtualenv, pip-tools e outros pacotes separadamente.

• Cache Inteligente: O uv utiliza um cache global de pacotes, evitando downloads repetidos entre diferentes projetos.

• Compatibilidade: um substituto direto do pip, o que significa que voc pode us-lo com seus arquivos requirements.txt existentes sem nenhuma modificao.

Instalao

A instalao do uv simples e no requer uma instalao prvia de Python.

Aps a instalao, verifique se tudo ocorreu bem com o comando:

uv --version

Guia de Comandos do uv

Vamos detalhar os comandos mais importantes para o seu fluxo de trabalho.

Ambientes Virtuais

O uv gerencia ambientes virtuais de forma nativa.

Uso:

# Cria o ambiente
uv venv

# Ativa o ambiente (Linux/macOS)
source .venv/bin/activate

# Ativa o ambiente (Windows)
.venv\Scripts\activate

Gerenciamento de Pacotes

Esta a principal funcionalidade do uv. Os comandos so intuitivos e substituem diretamente o pip

Basicamente, se voce sabia trabalhar com o pip, nao tera dificuldades aqui.

Exemplo para Automao de Redes:

# Instala as bibliotecas essenciais para automao
uv pip install netmiko napalm nornir

# Verifica os pacotes instalados
uv pip list

Sincronizao de Dependncias (Estilo pip-tools)

Para projetos mais robustos, uma boa prtica fixar as verses das dependncias para garantir a reprodutibilidade. O uv simplifica isso.

Executando Comandos e Ferramentas

O uv tambm substitui o pipx, permitindo executar ferramentas de linha de comando sem poluir seu ambiente global.

Exemplo Prtico com uvx:

Imagine que voc quer formatar seu cdigo com o black sem instal-lo no seu projeto.

# Formata todos os arquivos .py no diretrio atual
uvx black .

O uv baixar o black em um ambiente temporrio, o executar e depois o descartar. Simples assim!

Caso de Uso: Projeto de Automao de Rede

Vamos simular o incio de um novo projeto para automatizar a coleta de fatos de dispositivos de rede usando nornir.

1. Crie o diretrio do projeto e inicialize o ambiente:

    mkdir projeto-nornir
    cd projeto-nornir
    uv venv
    source .venv/bin/activate
   

2. Instale as dependncias:

   O nornir precisa de plugins para se conectar aos dispositivos. Vamos instalar o nornir e o plugin para netmiko.

    uv pip install nornir nornir-netmiko
   

   A instalao ser notavelmente mais rpida do que com o pip.

3. Crie seu script de automao (coleta_fatos.py):

    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")
   
    result = nr.run(task=netmiko_send_command, command_string="show version")
   
    print_result(result)
   

4. Execute o script com uv run:

    uv run python coleta_fatos.py
   

5. Gere o arquivo de requerimentos para compartilhar o projeto:

    uv pip freeze > requirements.txt
   

Agora, qualquer colega de equipe pode recriar seu ambiente de forma rpida e determinstica com uv venv e uv pip install -r requirements.txt.

Concluso

O uv uma melhoria na qualidade de vida para desenvolvedores Python ao unificar vrias funcionalidades em uma nica interface. Ele simplifica o fluxo de trabalho, reduz a complexidade e acelera o ciclo de desenvolvimento.

Para quem trabalha com automao de redes, onde a agilidade para testar scripts e gerenciar dependncias fundamental, adotar o uv um passo natural.

Referncias:

1. Astral, uv - Documentao Oficial

Uma pesquisa rpida me levou a algumas opes interessantes:

SchemaSpy

Ferramenta open source baseada em Java que analisa os metadados do banco de dados e gera diagramas interativos em HTML, alm de relatrios detalhados.

Ideal para: Gerar automaticamente relatrios e diagramas completos a partir de um banco de dados existente.

DBeaver

Ferramenta universal de gerenciamento de bancos de dados, compatvel com diversos sistemas (MySQL, PostgreSQL, Oracle, etc.). Permite gerar diagramas de esquemas a partir de um banco existente.

Ideal para: Administrar mltiplos sistemas de banco e visualizar esquemas complexos.

DbSchema

Ferramenta universal de banco de dados que pode realizar engenharia reversa p criar um diagrama visual, alm de permitir desenhar esquemas e export-los como SQL.

Ideal para: Usurios que precisam de uma representao visual e tambm da funcionalidade de exportao em SQL.

SchemaSpy

Documentacao

Fiz uma nova instalao do NetBox via Docker e baixei o SchemaSpy a partir do repositrio Docker Hub junto com suas dependncias.

Criando o diretrio de sada

mkdir schemaspy
cd schemaspy

Criando o arquivo de configurao do banco de dados

As informaes do banco de dados do NetBox esto no arquivo /env/postgres.env:

POSTGRES_DB=netbox
POSTGRES_PASSWORD=FAKE_PASSWORD
POSTGRES_USER=netbox

Para entender os valores que podemos definir no arquivo de configurao, consulte

Crie um arquivo chamado postgresdb.properties com o seguinte contedo:

# Tipo de banco de dados. Execute com -dbhelp para mais detalhes
schemaspy.t=pgsql11
# Propriedades do banco: host, porta, nome, usurio e senha
schemaspy.host=postgres
schemaspy.port=5432
schemaspy.db=netbox
schemaspy.u=netbox
schemaspy.p=FAKE_PASSWORD

Executando

A documentao lista todas as opes necessrias.
Basta informar o caminho de sada, as credenciais do banco e o formato desejado.
O comando abaixo executa o container e gera o relatrio da estrutura do banco:

docker run \
    -v "$PWD/output:/output" \
    --network netbox-docker_default \
    -v "./postgresdb.properties:/schemaspy.properties" \
    schemaspy/schemaspy:latest

Sada

O SchemaSpy gera um relatrio navegvel em HTML dentro do diretrio output, repleto de informaes interessantes sobre o banco de dados.

Ao acessar a aba Relationships, voc ver um diagrama das tabelas e seus relacionamentos exatamente o que eu estava procurando!

Resultado

O SchemaSpy gera dois diagramas:

• Um compacto

• E outro amplo, localizado em /diagrams/summary

A verso do NetBox utilizada neste teste foi NetBox Community v4.1.6.

Reviso

Os diagramas so bem detalhados, mas h muitas intersees de setas, o que pode dificultar a leitura.
Como o arquivo exportado em HTML, no possvel arrastar ou reorganizar as tabelas.

Abaixo est um exemplo da tabela dcim_device. possvel perceber que, com o aumento de relacionamentos, o diagrama se torna mais denso:

O SchemaSpy uma ferramenta extremamente til para quem deseja compreender a estrutura de bancos de dados complexos como o do NetBox.

Se voc trabalha com infraestrutura de TI, provavelmente j ouviu o termo "automao de redes" (ou network automation). Longe de ser apenas mais um buzzword, a automao de redes representa uma mudana fundamental na forma como projetamos, gerenciamos e operamos as redes. Para o profissional de redes no Brasil, entender e dominar essa disciplina no mais um diferencial, mas uma necessidade para se manter relevante e competitivo no mercado.

A Realidade da Gesto de Redes Tradicional

Vamos ser honestos: a maneira como gerenciamos redes por dcadas est se tornando insustentvel. O mtodo tradicional, baseado em acesso manual via CLI para configurar roteadores, switches e firewalls, um de cada vez, apresenta desafios significativos:

• Erros Humanos: Uma simples digitao errada pode causar uma interrupo de servio ou uma falha de segurana. (E convenhamos que fazer uma change na madrugada aumenta nossas chances)

• Lentido: Implementar uma mudana em dezenas ou centenas de dispositivos manualmente um processo lento, tedioso e que no escala.

• Inconsistncia: Garantir que todos os dispositivos tenham uma configurao padronizada quase impossvel manualmente, levando a uma "deriva de configurao"

• Falta de Visibilidade: Obter uma viso completa do estado da rede muitas vezes requer a execuo de mltiplos comandos em diversos equipamentos, consolidando os dados manualmente.

"A complexidade das redes modernas, impulsionada pela nuvem, virtualizao e IoT, tornou a gesto manual uma barreira para a agilidade dos negcios."

O que Automao de Redes, Afinal?

A automao de redes a prtica de usar software para automatizar o processo de configurao, gerenciamento, teste, implantao e operao de dispositivos de rede. Em vez de um engenheiro se conectar manualmente a um switch para configurar uma VLAN, ele escreve um script ou usa uma ferramenta que faz isso por ele de forma programtica.

Isso possvel atravs de APIs, que permitem que softwares conversem com os equipamentos de rede e de ferramentas de automao que orquestram essas interaes em larga escala.

Por que a Automao de Redes Importante?

A automao no sobre substituir engenheiros de rede, mas sim sobre potencializ-los. Ao automatizar tarefas repetitivas e de baixo valor, os engenheiros podem focar em atividades mais estratgicas, como o design da arquitetura da rede, planejamento de capacidade e inovao.

Principais Benefcios:

1. Agilidade e Velocidade: Implemente mudanas e novos servios em minutos, no em semanas. A automao permite que a infraestrutura de rede acompanhe a velocidade do desenvolvimento de software e das necessidades do negcio.

2. Reduo de Erros: Scripts e ferramentas executam tarefas de forma consistente e previsvel, eliminando os erros humanos que so a principal causa de interrupes de servio [2].

3. Padronizao e Conformidade: Garanta que todos os dispositivos sigam uma configurao padro (golden configuration), facilitando a gesto e auditorias de segurana.

4. Escalabilidade: Gerenciar 1.000 dispositivos se torna to simples quanto gerenciar 10. A automao permite que as equipes de rede gerenciem ambientes muito maiores e mais complexos com os mesmos recursos.

5. Valorizao Profissional: Profissionais com habilidades em automao de redes so mais valorizados no mercado, com salrios significativamente maiores e acesso a melhores oportunidades de carreira.

Ferramentas Essenciais para Comear

O universo da automao de redes vasto, mas algumas ferramentas se destacam como fundamentais para quem est comeando:

• Ansible: Uma ferramenta de automao de TI extremamente popular por sua simplicidade. Usa arquivos YAML, que so fceis de ler e escrever e no requer a instalao de agentes nos dispositivos de rede.

• Python: A linguagem de programao de fato para automao de redes. Sintaxe simples e um ecossistema de bibliotecas amplo a tornam uma escolha popular.

• Netmiko e Scrapli: Bibliotecas Python que simplificam a conexo via SSH com dispositivos de rede, permitindo enviar comandos e extrair informaes de forma estruturada.

• Git: Um sistema de controle de verso essencial para gerenciar seus scripts e playbooks. Tratar sua configurao de rede como cdigo (Infrastructure as Code) um dos pilares da automao.

Como Comear sua Jornada em Automao de Redes?

A transio para a automao pode parecer intimidante, mas pode ser feita de forma gradual.

1. Comece com a Mentalidade Certa: Entenda que automao uma jornada, no um destino. Comece pequeno, automatizando tarefas simples que voc realiza repetidamente.

2. Aprenda os Fundamentos: Invista tempo para aprender os conceitos bsicos de Python e os princpios de funcionamento do Ansible. No preciso ser um desenvolvedor, mas crucial entender a lgica da programao.

3. Pratique em Laboratrios: Crie um ambiente de laboratrio para testar seus scripts sem arriscar a rede de produo.

4. Busque Conhecimento Estruturado: Cursos especializados podem acelerar drasticamente sua curva de aprendizado. Eles fornecem um caminho claro, exemplos prticos e o suporte de instrutores experientes.

Concluso: O Futuro da Engenharia de Redes Automatizado

A automao de redes no mais uma opo, mas uma evoluo natural da profisso de engenheiro de redes. Abraar essa mudana significa se tornar um profissional mais eficiente, estratgico e valorizado. As empresas no Brasil esto cada vez mais buscando talentos que possam construir e gerenciar redes modernas, geis e seguras.

Se voc est pronto para dar o prximo passo na sua carreira e se tornar um protagonista nesta transformao, a AutoNetOps est aqui para te ajudar. Somos a primeira comunidade do Brasil 100% focada em automao de redes, com cursos prticos e mentoria para te guiar nesta jornada.

Explore nossos cursos de Ansible, Python e Netmiko e comece a automatizar hoje mesmo!

Se voc trabalha com automao de redes em Python, provvel que tenha usado o mtodo dict.get() muitas vezes. Ele extremamente til para evitar excees do tipo KeyError ao acessar configuraes de dispositivos ou dados de rede:

network_config = {"ip": "192.168.1.1"}
port = network_config.get("port", 80)  # defaults 80 se "port" estiver faltando

Simples, n? Sem erros, sem travamentos, apenas um valor padro.

Mas aqui est o problema: embora o dict.get() seja prtico, ele frequentemente superutilizado e, em alguns casos, no a maneira mais clara ou legvel de lidar com chaves ausentes em configuraes de rede.

Neste artigo, vou mostrar abordagens mais limpas e Pythonicas que tornam seu cdigo mais seguro, legvel e fcil de manter.

Por que o dict.get() Nem Sempre a Melhor Escolha

O dict.get() parece inofensivo primeira vista, mas vamos analisar as desvantagens no contexto de automao de redes:

Lgica*: Quando o valor default dinmico (como uma porta padro calculada ou um endereo de gateway), a linha pode ficar poluda ou repetitiva.*

Flexibilidade limitada*: Muitas vezes voc precisa retornar um valor padro e tambm armazen-lo no dicionrio para uso futuro o* dict.get() no faz isso automaticamente.

Imagine que voc est lidando com configuraes de um roteador:

mtu = device.get("mtu", 1500)

Se voc precisar armazenar esse valor padro de volta no dicionrio device, pode acabar escrevendo:

if "mtu" not in device:
    device["mtu"] = 1500
mtu = device["mtu"]

Isso verboso e propenso a erros. O Python oferece uma ferramenta melhor para esses casos.

Conhea o setdefault() A Alternativa Mais Limpa

Em vez de usar get() e atribuies manuais, o mtodo setdefault() perfeito para automao de redes:

mtu = device.setdefault("mtu", 1500)

O que isso faz:

Se "mtu" existe no dicionrio, retorna seu valor.

Se no existe, insere o valor padro (1500) no dicionrio e o retorna.

Simples, conciso e explcito.

Vamos comparar:

# Using get()
mtu = device.get("mtu", 1500)
if "mtu" not in device:
    device["mtu"] = 1500

# Using setdefault()
mtu = device.setdefault("mtu", 1500)

A verso com setdefault() mais curta, clara e garante que o dicionrio seja atualizado com o valor padro.

Quando Preferir o setdefault() ao invs do get()

Use o setdefault() quando:

Voc precisa buscar e inicializar um valor de configurao ausente, como portas, IPs ou MTUs.

Voc trabalha com dicionrios aninhados (como configuraes de VLANs ou interfaces).

Voc quer reduzir cdigo repetitivo e manter a clareza em scripts de automao.

Por exemplo, ao processar configuraes de interfaces de rede:

interfaces = ["eth0", "eth1", "eth0", "eth2", "eth1"]

interface_status = {}
for interface in interfaces:
    interface_status.setdefault(interface, {"status": "down", "vlans": []})["vlans"].append(10)

print(interface_status)
# {
# 'eth0': {'status': 'down', 'vlans': [10, 10]},
# 'eth1': {'status': 'down', 'vlans': [10, 10]},
# 'eth2': {'status': 'down', 'vlans': [10]}
#}

Sem o setdefault(), voc precisaria verificar a existncia de cada chave antes de atualizar, adicionando linhas desnecessrias.

Uma Abordagem Ainda Mais Limpa: O defaultdict

O mdulo collections do Python oferece o defaultdict, que ideal para automao de redes:

from collections import defaultdict

interface_status = defaultdict(lambda: {"status": "down", "vlans": []})
for interface in interfaces:
    interface_status[interface]["vlans"].append(10)

print(dict(interface_status))
#{
# 'eth0': {'status': 'down', 'vlans': [10, 10]},
# 'eth1': {'status': 'down', 'vlans': [10, 10]},
# 'eth2': {'status': 'down', 'vlans': [10]}
}

Por que o defaultdict muitas vezes supera tanto o get() quanto o setdefault():

Inicializa chaves ausentes automaticamente.

Mantm seu cdigo mnimo.

Deixa a inteno cristalina: Quero um dicionrio que padro para configuraes de interface.

Pense nele como um dicionrio mais inteligente que elimina verificaes repetitivas.

Comparando as Trs Abordagens

Vamos resumir com uma tabela de referncia rpida:

dict.get(key, default): Retorna um valor com segurana ou um padro.

Use quando no precisa armazenar o padro de volta no dicionrio.

dict.setdefault(key, default): Retorna um valor se presente; caso contrrio, define e retorna o padro.

Use quando precisa buscar e inicializar.

collections.defaultdict: Inicializa padres automaticamente para chaves ausentes.

Use quando trabalha com colees de configuraes ou quando chaves ausentes so frequentes.

Exemplo do Mundo Real: Gerenciamento de Configuraes de Rede

Imagine que voc est construindo um script para gerenciar configuraes de rede:

device = {"hostname": "router1"}

mtu = device.get("mtu", 1500)  #  Funciona, mas nao atualiza o device

Mais tarde, algum inspeciona device e no v "mtu". Confuso, n?

Em vez disso:

mtu = device.setdefault("mtu", 1500)
# device = {"hostname": "router1", "mtu": 1500}

Ou, se voc tem mltiplos padres:

from collections import defaultdict

device = defaultdict(lambda: "N/A")
device.update({"hostname": "router1"})

print(device["mtu"])  # N/A

Agora seu dicionrio lida com chaves ausentes de forma elegante, e seu cdigo mais previsvel.

O Custo Oculto de Usar get() Demais

Depender muito do get() pode introduzir bugs sutis em scripts de automao:

Voc pode esquecer de atualizar o dicionrio com os padres.

Seu cdigo pode esconder o fato de que algumas configuraes esto faltando.

Futuros mantenedores (ou o futuro voc) podem se perguntar por que alguns padres no foram persistidos.

Sim, o get() tem seu lugar. Mas, muitas vezes, o setdefault() ou o defaultdict comunicam sua inteno de forma mais clara e cdigo que comunica inteno sempre mais limpo.

Concluso: Escreva Cdigo que seu Futuro Eu Agradecer

O Python nos oferece vrias ferramentas para lidar com chaves de dicionrio ausentes em automao de redes. Embora o dict.get() seja conveniente, nem sempre a melhor escolha a longo prazo.

Use o get() quando precisar apenas de um fallback rpido e somente leitura.

Use o setdefault() quando quiser buscar e inicializar em uma nica operao.

Adote o defaultdict quando lidar com colees de configuraes e chaves ausentes frequentes.

Cdigo mais limpo no apenas sobre menos linhas. sobre clareza, manutenibilidade e expresso de inteno. Na prxima vez que voc instintivamente alcanar o get(), pare por um momento e pergunte a si mesmo: Existe uma maneira mais limpa?

O Jinja2 uma poderosa biblioteca de templates para Python, amplamente utilizada para manipular dados diretamente em templates. Seus filtros embutidos permitem transformar e formatar dados de maneira eficiente. Este guia explora os filtros mais usados, com explicaes detalhadas, exemplos prticos e casos de uso reais, ajudando voc a aplicar o Jinja2 em projetos de automao, gerao de relatrios ou configuraes de rede.

Agrupando Dados com o Filtro batch

Propsito

O filtro batch divide uma sequncia em sublistas (ou "lotes") com um nmero fixo de elementos. ideal para organizar dados em grupos para exibio ou processamento em blocos.

Sintaxe

batch(value, linecount, fill_with=None)

• value: Sequncia a ser agrupada.

• linecount: Nmero mximo de elementos por grupo.

• fill_with (opcional): Valor para preencher grupos incompletos.

Caso de Uso

Organizar endereos IP em grupos para exibio em interfaces de usurio ou para processamento em lotes, como em scripts de automao de rede.

Exemplo 1: Agrupando Endereos IP

{% for grupo in sflow_boxes|batch(2) %}  
Grupo Sflow {{ loop.index }}: {{ grupo | join(", ") }}  
{% endfor %}

Dados:

sflow_boxes:  
  - 10.180.0.1  
  - 10.180.0.2  
  - 10.180.0.3  
  - 10.180.0.4  
  - 10.180.0.5

Resultado:

Grupo Sflow 1: 10.180.0.1, 10.180.0.2  
Grupo Sflow 2: 10.180.0.3, 10.180.0.4  
Grupo Sflow 3: 10.180.0.5

Exemplo 2: Preenchendo Grupos Incompletos

{% for grupo in sflow_boxes|batch(3, fill_with='N/A') %}  
Grupo Sflow {{ loop.index }}: {{ grupo | join(", ") }}  
{% endfor %}

Resultado:

Grupo Sflow 1: 10.180.0.1, 10.180.0.2, 10.180.0.3  
Grupo Sflow 2: 10.180.0.4, 10.180.0.5, N/A

Definindo Valores Padro com o Filtro default

Propsito

O filtro default retorna um valor padro quando a varivel est indefinida ou avaliada como falsa (como None, 0, False ou string vazia). til para evitar erros em templates com dados ausentes.

Sintaxe

default(value, default_value='', boolean=False)

• value: Varivel a ser verificada.

• default_value: Valor retornado se value for indefinido ou falso.

• boolean (opcional): Se True, considera valores falsos como indefinidos.

Caso de Uso

Atribuir uma VLAN padro a interfaces de rede quando nenhuma VLAN especificada.

Exemplo

{% for intf in interfaces %}  
interface {{ intf.name }}  
  switchport mode access  
  switchport access vlan {{ intf.vlan | default('10') }}  
{% endfor %}

Dados:

interfaces:  
  - name: Ethernet1  
    vlan: 50  
  - name: Ethernet2  
  - name: Ethernet3  
    vlan: 60

Resultado:

interface Ethernet1  
  switchport mode access  
  switchport access vlan 50  
interface Ethernet2  
  switchport mode access  
  switchport access vlan 10  
interface Ethernet3  
  switchport mode access  
  switchport access vlan 60

Ordenando Dicionrios com o Filtro dictsort

Propsito

O filtro dictsort ordena dicionrios por chave ou valor, em ordem crescente ou decrescente, permitindo organizar dados no ordenados por padro no Python.

Sintaxe

dictsort(value, case_sensitive=False, by='key', reverse=False)

• value: Dicionrio a ser ordenado.

• case_sensitive: Se True, diferencia maisculas de minsculas.

• by: Ordenar por 'key' (padro) ou 'value'.

• reverse: Se True, ordena em ordem decrescente.

Caso de Uso

Organizar prefixos de rede por nome ou pares BGP por prioridade.

Exemplo 1: Ordenando por Chave

{% for pl_name, pl_lines in prefix_lists | dictsort %}  
ip prefix-list {{ pl_name }}  
  {{ pl_lines | join('\n  ') }}  
{% endfor %}

Dados:

prefix_lists:  
  pl-ntt-out:  
    - permit 10.0.0.0/23  
  pl-zayo-out:  
    - permit 10.0.1.0/24  
  pl-cogent-out:  
    - permit 10.0.0.0/24

Resultado:

ip prefix-list pl-cogent-out  
  permit 10.0.0.0/24  
ip prefix-list pl-ntt-out  
  permit 10.0.0.0/23  
ip prefix-list pl-zayo-out  
  permit 10.0.1.0/24

Exemplo 2: Ordenando por Valor (Prioridade)

Pares BGP por prioridade:  
{% for peer, priority in peer_priority | dictsort(by='value', reverse=true) %}  
  Par: {{ peer }}; Prioridade: {{ priority }}  
{% endfor %}

Dados:

peer_priority:  
  ntt: 200  
  zayo: 300  
  cogent: 100

Resultado:

Pares BGP por prioridade:  
  Par: zayo; Prioridade: 300  
  Par: ntt; Prioridade: 200  
  Par: cogent; Prioridade: 100

Convertendo para Nmeros com os Filtros float e int

Filtro float

Propsito

Converte um valor em nmero de ponto flutuante, til para operaes numricas ou comparaes com strings numricas.

Sintaxe

float(value, default=0.0)

• value: Valor a ser convertido.

• default: Valor retornado se a converso falhar.

Caso de Uso

Comparar verses de software representadas como strings.

Exemplo

{% if eos_ver | float >= 4.22 %}  
Verso EOS {{ eos_ver }}: nova sintaxe de comando.  
{% else %}  
Verso EOS {{ eos_ver }}: sintaxe de comando antiga.  
{% endif %}

Dados:

eos_ver: "4.10"

Resultado:

Verso EOS 4.10: sintaxe de comando antiga.

Filtro int

Propsito

Converte um valor em nmero inteiro, com suporte para diferentes bases numricas (como hexadecimal).

Sintaxe

int(value, default=0, base=10)

• value: Valor a ser convertido.

• default: Valor retornado se a converso falhar.

• base: Base numrica do valor (ex.: 16 para hexadecimal).

Caso de Uso

Converter um Ethertype hexadecimal para decimal.

Exemplo

Ethertype LLDP  
  Hex: {{ lldp_ethertype }}  
  Dec: {{ lldp_ethertype | int(base=16) }}

Dados:

lldp_ethertype: 88CC

Resultado:

Ethertype LLDP  
  Hex: 88CC  
  Dec: 35020

Agrupando por Atributo com o Filtro groupby

Propsito

Agrupa objetos de uma sequncia com base em um atributo, ideal para relatrios ou organizao de dados.

Sintaxe

groupby(value, attribute)

• value: Sequncia de objetos.

• attribute: Atributo para agrupamento (suporta notao de ponto, ex.: interface.vlan).

Caso de Uso

Agrupar interfaces de rede por VLAN.

Exemplo

{% for vid, members in interfaces | groupby('vlan') %}  
Interfaces na VLAN {{ vid }}: {{ members | map(attribute='name') | join(", ") }}  
{% endfor %}

Dados:

interfaces:  
  - name: Ethernet1  
    vlan: 50  
  - name: Ethernet2  
    vlan: 50  
  - name: Ethernet3  
    vlan: 60

Resultado:

Interfaces na VLAN 50: Ethernet1, Ethernet2  
Interfaces na VLAN 60: Ethernet3

Concatenando Listas com o Filtro join

Propsito

Une elementos de uma sequncia em uma nica string, com um delimitador especificado.

Sintaxe

join(value, d='', attribute=None)

• value: Sequncia a ser unida.

• d: Delimitador (padro: string vazia).

• attribute: Atributo a ser extrado, se os elementos forem objetos.

Caso de Uso

Exibir servidores de nomes em uma nica linha.

Exemplo

ip name-server {{ name_servers | join(" ") }}

Dados:

name_servers:  
  - 1.1.1.1  
  - 8.8.8.8  
  - 9.9.9.9

Resultado:

ip name-server 1.1.1.1 8.8.8.8 9.9.9.9

Transformando Dados com o Filtro map

Propsito

Aplica um filtro ou extrai um atributo de todos os elementos de uma sequncia.

Sintaxe

map(*args, **kwargs)

• *args: Nome de um filtro (ex.: "lower") ou atributo a extrair (ex.: attribute='name').

Caso de Uso 1: Normalizando Nomes

Dispositivos:  
{{ devices | map('lower') | join('\n') }}

Dados:

devices:  
  - Core-rtr-warsaw-01  
  - DIST-Rtr-Prague-01

Resultado:

Dispositivos:  
core-rtr-warsaw-01  
dist-rtr-prague-01

Caso de Uso 2: Extraindo Atributos

Interfaces:  
{{ interfaces | map(attribute='name') | join('\n') }}

Dados:

interfaces:  
  - name: Ethernet1  
    mode: switched  
  - name: Ethernet2  
    mode: routed

Resultado:

Interfaces:  
Ethernet1  
Ethernet2

Filtrando Dados com os Filtros select e reject

Filtro select

Propsito

Mantm elementos de uma sequncia que passam em um teste Jinja2.

Sintaxe

select(*args, **kwargs)

• *args: Nome do teste (ex.: "gt").

• **kwargs: Argumentos adicionais para o teste.

Caso de Uso

Listar apenas nmeros de AS BGP privados (>64495).

Exemplo

AS BGP privados:  
{% for as_no in as_numbers | select('gt', 64495) %}  
{{ as_no }}  
{% endfor %}

Dados:

as_numbers:  
  - 1794  
  - 65203  
  - 65099

Resultado:

AS BGP privados:  
65203  
65099

Filtro reject

Propsito

Remove elementos de uma sequncia que passam em um teste Jinja2.

Caso de Uso

Listar apenas nmeros de AS BGP pblicos (64495).

Exemplo

AS BGP pblicos:  
{% for as_no in as_numbers | reject('gt', 64495) %}  
{{ as_no }}  
{% endfor %}

Resultado:

AS BGP pblicos:  
1794

Filtrando Atributos com o Filtro rejectattr

Propsito

Remove objetos de uma sequncia cujo atributo passa em um teste especfico.

Sintaxe

rejectattr(*args, **kwargs)

• *args: Atributo e nome do teste (ex.: "mode", "eq").

• **kwargs: Argumentos adicionais.

Caso de Uso

Listar apenas interfaces roteadas, excluindo as no modo "switched".

Exemplo

Interfaces roteadas:  
{% for intf in interfaces | rejectattr('mode', 'eq', 'switched') %}  
{{ intf.name }}  
{% endfor %}

Dados:

interfaces:  
  - name: Ethernet1  
    mode: switched  
  - name: Ethernet2  
    mode: routed

Resultado:

Interfaces roteadas:  
Ethernet2

Convertendo para JSON com o Filtro tojson

Propsito

Converte uma estrutura de dados Python em uma string JSON, til para APIs ou depurao.

Sintaxe

tojson(value, indent=None)

• value: Estrutura de dados a ser convertida.

• indent: Nmero de espaos para indentao.

Caso de Uso

Gerar uma representao JSON de interfaces para uma API.

Exemplo

{{ interfaces | tojson(indent=2) }}

Dados:

interfaces:  
  - name: Ethernet1  
    vlan: 50  
  - name: Ethernet2  
    vlan: 60

Resultado:

[
  {
    "name": "Ethernet1",
    "vlan": 50
  },
  {
    "name": "Ethernet2",
    "vlan": 60
  }
]

Extraindo Valores nicos com o Filtro unique

Propsito

Retorna valores nicos de uma coleo, frequentemente usado com map para extrair atributos distintos.

Sintaxe

unique(value, case_sensitive=False, attribute=None)

• value: Coleo de dados.

• case_sensitive: Se True, diferencia maisculas de minsculas.

• attribute: Atributo para extrair valores nicos.

Caso de Uso

Listar VLANs de acesso nicas em uso.

Exemplo

VLANs em uso: {{ interfaces | map(attribute='vlan') | unique | join(", ") }}

Dados:

interfaces:  
  - name: Ethernet1  
    vlan: 50  
  - name: Ethernet2  
    vlan: 50  
  - name: Ethernet3  
    vlan: 60

Resultado:

VLANs em uso: 50, 60

Referncias

• Documentao Oficial do Jinja

• Primer on Jinja Templating - Real Python

• Best Practices for Jinja Templating - GeeksforGeeks

• Mastering Jinja2 Templating for DataOps - DataOps.live

• Python Jinja Templating: Use Cases and Examples - Medium

A metodologia gil uma abordagem flexvel para o desenvolvimento de software que valoriza a adaptao s mudanas, colaborao e entrega rpida de resultados. Ela surgiu com o Manifesto gil, um documento que define quatro valores principais:

1. Indivduos e interaes acima de processos e ferramentas.

2. Software funcionando acima de documentao extensiva.

3. Colaborao com o cliente acima de negociaes contratuais.

4. Resposta s mudanas acima de seguir um plano rgido.

Explicao simplificada:
Imagine que voc est construindo uma casa. Em vez de planejar cada detalhe no incio e s mostrar o resultado final, a metodologia gil permite que voc mostre ao cliente uma parte funcional da casa a cada poucas semanas, ajustando o projeto conforme o feedback. Isso garante que o produto final atenda s necessidades reais.

Princpios do Manifesto gil

O Manifesto gil tambm lista 12 princpios que orientam como colocar esses valores em prtica:

1. Foco no cliente: Satisfazer o cliente com entregas contnuas e valiosas.

2. Adaptao s mudanas: Aceitar alteraes nos requisitos, mesmo no final do projeto.

3. Entregas frequentes: Entregar software funcional regularmente, preferencialmente a cada 2 a 4 semanas.

4. Colaborao: Desenvolvedores e clientes devem trabalhar juntos diariamente.

5. Equipes motivadas: Criar um ambiente que motive a equipe, dando confiana e autonomia.

6. Comunicao direta: Preferir conversas presenciais ou videochamadas para alinhar ideias.

7. Software funcional: A principal medida de progresso o software que realmente funciona.

8. Ritmo sustentvel: Promover um ritmo de trabalho que a equipe possa manter indefinidamente.

9. Ambiente gil: Criar uma cultura que facilite mudanas rpidas e eficientes.

10. Simplicidade: Fazer apenas o necessrio, evitando trabalho desnecessrio.

11. Equipes auto-organizveis: Permitir que as equipes decidam como realizar o trabalho.

12. Melhoria contnua: Refletir regularmente sobre como melhorar processos e resultados.

Exemplo prtico:
Uma equipe est desenvolvendo um aplicativo de delivery. Em vez de criar todo o app de uma vez, ela entrega primeiro a funcionalidade de busca de restaurantes. O cliente testa, d feedback, e a equipe ajusta antes de desenvolver o sistema de pedidos.

graph TD
    A[Planejamento] --> B[Desenvolvimento]
    B --> C[Testes]
    C --> D[Entrega ao Cliente]
    D --> E[Feedback]
    E --> A
    style A fill:#f9f,stroke:#333,stroke-width:2px
    style B fill:#bbf,stroke:#333,stroke-width:2px
    style C fill:#bfb,stroke:#333,stroke-width:2px
    style D fill:#fbf,stroke:#333,stroke-width:2px
    style E fill:#ffb,stroke:#333,stroke-width:2px

Scrum: Uma Implementao do gil

O Scrum uma das formas mais populares de aplicar a metodologia gil. Ele organiza o trabalho em equipes pequenas (geralmente de 5 a 10 pessoas) que trabalham em ciclos curtos chamados sprints.

Componentes do Scrum

1. Histrias de Usurio: So pequenas tarefas que descrevem uma funcionalidade do ponto de vista do usurio. Exemplo: "Como cliente, quero buscar restaurantes por tipo de comida para escolher onde pedir."

2. Backlog: Uma lista priorizada de todas as funcionalidades (histrias de usurio) que o projeto precisa. O Product Owner (representante do cliente) decide a ordem de prioridade.

3. Sprints: Ciclos curtos onde a equipe desenvolve, testa e entrega uma ou mais histrias de usurio. No final de cada sprint, o software deve estar funcional.

4. Reunies Dirias (Daily): Reunies rpidas (menos de 15 minutos) onde cada membro da equipe responde:

   • O que fiz ontem?

   • O que vou fazer hoje?

   • H algum obstculo?

5. Reviso do Sprint: No final do sprint, a equipe apresenta o software ao cliente para feedback.

6. Retrospectiva: A equipe reflete sobre o que funcionou bem e o que pode melhorar no prximo sprint.

Exemplo prtico:
A equipe de desenvolvimento do app de delivery planeja um sprint de 2 semanas para criar a funcionalidade de busca de restaurantes. Durante o sprint, eles se renem diariamente para alinhar o progresso. No final, mostram a funcionalidade ao cliente, que sugere adicionar filtros por preo. A equipe ajusta o backlog para incluir essa mudana no prximo sprint.

graph TD
    A[Backlog] -->|Planejamento do Sprint| B[Sprint 2-4 semanas]
    B --> C[Desenvolvimento]
    C --> D[Testes]
    D --> E[Reviso do Sprint]
    E --> F[Entrega do Incremento]
    F --> G[Retrospectiva]
    G -->|Feedback| A
    style A fill:#f9f,stroke:#333,stroke-width:2px
    style B fill:#bbf,stroke:#333,stroke-width:2px
    style C fill:#bfb,stroke:#333,stroke-width:2px
    style D fill:#fbf,stroke:#333,stroke-width:2px
    style E fill:#ffb,stroke:#333,stroke-width:2px
    style F fill:#bff,stroke:#333,stroke-width:2px
    style G fill:#fbf,stroke:#333,stroke-width:2px

Lean: Foco em Valor e Eficincia

A metodologia Lean foca em minimizar desperdcios enquanto maximiza o valor entregue ao cliente. Ela frequentemente usada junto com o gil ou Scrum.

Princpios do Lean

1. Eliminar desperdcios: Qualquer coisa que no agrega valor ao cliente considerada desperdcio. Os sete tipos de desperdcio so:

   • Trabalho incompleto (cdigo parcialmente desenvolvido)

   • Processos extras (reunies desnecessrias)

   • Funcionalidades extras (adicionar recursos que o cliente no pediu)

   • Troca de tarefas (multitarefa que reduz a produtividade)

   • Espera (aguardar aprovao ou recursos)

   • Movimentao (deslocamentos desnecessrios entre ferramentas ou equipes)

   • Defeitos (erros que exigem retrabalho)

2. Amplificar o aprendizado: Sprints curtos permitem que a equipe aprenda rapidamente com feedback do cliente, ajustando o produto para entregar mais valor.

3. Decidir o mais tarde possvel: Evitar decises prematuras permite maior flexibilidade. Exemplo: No escolher uma tecnologia especfica at entender todas as necessidades do projeto.

4. Entregar o mais rpido possvel: Entregas rpidas geram feedback imediato, reduzem desperdcios e garantem que o cliente receba o que precisa agora.

5. Otimizar o todo: Cada membro da equipe deve entender o impacto de suas decises no projeto como um todo, evitando solues que beneficiem apenas uma parte.

Exemplo prtico:
No desenvolvimento do app de delivery, a equipe Lean percebe que adicionar um recurso de inteligncia artificial para recomendaes de restaurantes no foi solicitado pelo cliente. Eles removem essa ideia do backlog para evitar desperdcio de tempo e recursos.

graph TD
    A[Identificar Valor] --> B[Mapear Fluxo de Valor]
    B --> C[Eliminar Desperdcios]
    C --> D[Entrega Rpida]
    D --> E[Feedback do Cliente]
    E --> F[Melhoria Contnua]
    F --> A
    style A fill:#f9f,stroke:#333,stroke-width:2px
    style B fill:#bbf,stroke:#333,stroke-width:2px
    style C fill:#bfb,stroke:#333,stroke-width:2px
    style D fill:#fbf,stroke:#333,stroke-width:2px
    style E fill:#ffb,stroke:#333,stroke-width:2px
    style F fill:#bff,stroke:#333,stroke-width:2px

Explicao do diagrama:
O Lean comea identificando o que valioso para o cliente, mapeia o processo para eliminar desperdcios, entrega rapidamente, coleta feedback e melhora continuamente.

Metodologia Cascata (Waterfall)

A metodologia Cascata uma abordagem tradicional e linear, onde cada fase do projeto deve ser concluda antes de iniciar a prxima. No h como voltar s fases anteriores, exceto em casos excepcionais (como erros encontrados nos testes).

Fases da Metodologia Cascata

1. Requisitos: Define o que o software deve fazer, documentado em um documento de requisitos. Exemplo: "O app deve permitir pedidos de comida online."

2. Anlise: Analisa o sistema para criar modelos e lgica que sero usados no desenvolvimento.

3. Design do Programa: Define detalhes tcnicos, como linguagem de programao, banco de dados e arquitetura.

4. Codificao: Escreve o cdigo-fonte do software.

5. Testes: Identifica e corrige erros. Se forem encontrados problemas graves, pode ser necessrio repetir a fase de codificao.

6. Operaes: Inclui implantao, suporte e manuteno do software.

Exemplo prtico:
No desenvolvimento do app de delivery, a equipe Cascata passa meses definindo todos os requisitos antes de comear a codificar. S depois de terminar o cdigo completo que o cliente v o produto final, o que pode levar a ajustes caros se houver mudanas.

graph TD
    A[Requisitos] --> B[Anlise]
    B --> C[Design]
    C --> D[Codificao]
    D --> E[Testes]
    E --> F[Operaes]
    style A fill:#f9f,stroke:#333,stroke-width:2px
    style B fill:#bbf,stroke:#333,stroke-width:2px
    style C fill:#bfb,stroke:#333,stroke-width:2px
    style D fill:#fbf,stroke:#333,stroke-width:2px
    style E fill:#ffb,stroke:#333,stroke-width:2px
    style F fill:#bff,stroke:#333,stroke-width:2px

Explicao do diagrama:
A Cascata um processo linear. Cada fase concluda antes da prxima, sem possibilidade de voltar, exceto em casos de erros nos testes.

Comparao entre gil, Lean e Cascata

Para facilitar a compreenso, aqui est uma tabela comparativa:

Viso Geral das Ferramentas

As seguintes ferramentas so essenciais para automao de rede, abrangendo SSH, SNMP e protocolos baseados em YANG:

• SSH: Para acesso seguro via linha de comando e operaes NETCONF.

  • NAPALM: Uma biblioteca Python para automao de rede multi-fornecedor.

  • Netmiko: Uma biblioteca Python para automao de dispositivos via SSH.

• SNMP: Para monitoramento e gerenciamento de dispositivos de rede.

  • NET-SNMP: Um conjunto de ferramentas para operaes SNMP.

• YANG-based:

  • Cisco YANG Suite: Uma ferramenta para explorar e testar modelos YANG.

  • GNMIc/Pygnmi: Ferramentas para interaes com o protocolo gNMI.

  • SSH (NETCONF): Para gerenciamento de dispositivos baseado em YANG via NETCONF.

NAPALM

NAPALM simplifica o gerenciamento de dispositivos de rede por meio de uma API unificada. Pode ser usado via CLI ou integrado em scripts Python.

Instalao

Instale o NAPALM usando pip:

pip3 install napalm

Referncia

• NAPALM Documentation

Uso

Execute o NAPALM via CLI para interagir com dispositivos:

napalm --user <username> --password <password> --vendor <driver> <ip_address> call <getter>

Exemplo: get_facts

Obtenha informaes do dispositivo, como hostname, modelo e verso do sistema operacional:

napalm --user admin --password admin --vendor ios 192.168.1.1 call get_facts

Getters:

Resultado:

GNMIc

GNMIc uma ferramenta CLI poderosa para interagir com dispositivos de rede via protocolo gNMI (gRPC Network Management Interface), ideal para telemetria e configurao.

Instalao

Instale o GNMIc usando o script de instalao fornecido:

bash -c "$(curl -sL https://get-gnmic.kmrd.dev)"

Referncia

• GNMIc Documentation

Comandos Comuns

CAPABILITIES

Verifique as capacidades gNMI de um dispositivo:

gnmic -a <ip:port> --username <user> --password <password> --insecure capabilities

Exemplo:

gnmic -a 10.80.255.30:6030 -u admin -p admin --insecure capabilities

GET

Obtenha um instantneo de dados do dispositivo usando um caminho especfico:

gnmic -a <ip:port> --username <user> --password <password> --insecure get --path "/components/component/state/temperature"

SET

Modifique o estado do dispositivo (consulte a Documentao de Set do GNMIc):

gnmic -a <ip:port> --username <user> --password <password> --insecure set --update-path "/interfaces/interface[name=Management1]/config/description" --update-value "Atualizado via gNMI"

SUBSCRIBE

Inscreva-se para receber dados de telemetria em tempo real:

gnmic -a <ip:port> --username <user> --password <password> --insecure subscribe --path "/interfaces/interface[name=Management1]/state/counters"

GNMI Prompt

Inicie uma sesso interativa com credenciais pr-configuradas:

gnmic --insecure --username admin --password admin --address <ip:port> prompt

NET-SNMP

NET-SNMP um conjunto de ferramentas para interagir com dispositivos habilitados para SNMP, permitindo consultas e gerenciamento de estatsticas de rede.

Instalao

Siga o guia oficial para instalao:

• NET-SNMP Tutorial

OIDs Comuns do SNMP

Principais OIDs para estatsticas de interface (MIB-II, RFC 1213):

Consultando Estatsticas de Interface

Consulte dispositivos habilitados para SNMP (por exemplo, IP 192.168.1.1, community string public). Substitua IF_INDEX pelo ndice da interface (descoberto via ifDescr).

Exemplo (SNMPv2c):

snmpget -v2c -c public 192.168.1.1 .1.3.6.1.2.1.2.2.1.10.IF_INDEX .1.3.6.1.2.1.2.2.1.16.IF_INDEX
snmpget -v2c -c public 192.168.1.1 SNMPv2-MIB::sysUpTime.0 # Tempo de atividade do sistema
snmpbulkwalk -v2c -c public 192.168.1.1 .1.0.8802.1.1.2.1.4.1.1.9 # Vizinhos LLDP

Exemplo (SNMPv3):

Obtenha o nome do sistema com SNMPv3:

snmpget -v3 -u USERNAME -a SHA -x AES -l authPriv -A AUTHPASS -X PRIVPASS 192.168.1.1 .1.3.6.1.2.1.1.5.0

Cisco YANG Suite

O Cisco YANG Suite uma ferramenta baseada em navegador para explorar e testar modelos YANG, ideal para operaes NETCONF e RESTCONF.

Instalao

Instale via Docker ou pip. Consulte o repositrio oficial:

• Cisco YANG Suite GitHub

Executando o YANG Suite

Inicie o suite:

yangsuite

Acesse a interface web para explorar modelos YANG e executar operaes.

SSH (NETCONF)

O NETCONF sobre SSH permite o gerenciamento de dispositivos baseado em YANG. til para obter esquemas e realizar operaes.

Iniciando uma Sesso NETCONF

Inicie uma sesso NETCONF (porta padro 830):

ssh -s <username>@<device-ip> -p 830 netconf

Isso abre uma sesso interativa para operaes NETCONF, como obter esquemas YANG ou configurar dispositivos.

Nota: Embora o NETCONF sobre SSH seja suportado, ferramentas como NAPALM ou GNMIc frequentemente oferecem fluxos de trabalho mais eficientes.

The Discovery: Pktmon to the Rescue

Picture this: youre deep in the trenches of troubleshooting, and you realize the system youre working on is bare-bones. No third-party tools, no fancy GUI sniffers. But then, like finding a forgotten tool in the back of a shed, I discovered Pktmon, a built-in packet sniffer introduced in Windows 10. Its not flashyno sleek interface like Wiresharkbut its powerful, lightweight, and, best of all, already there just waiting to be used.

I opened an elevated Command Prompt (because Pktmon demands admin privileges, naturally) and typed pktmon help to get the lay of the land. The help menu was like a treasure map, revealing commands for capturing packets, setting filters, and even converting logs for later analysis. I was ready to dive in.

Step 1: Setting the Stage

First things first, I needed to know what network interfaces were available. I typed:

pktmon comp list

This command listed all the network adapters on the system, each with an ID. For example:

Network Adapters:
Id  MAC Address        Name
--  -----------        ----
9   00-50-56-BD-C1-83  Ethernet Adapter
12  E8-6A-64-44-7B-00  Wi-Fi Adapter

My target was the Ethernet adapter (ID 9). Knowing the interface ID is crucial if you want to focus your capture on a specific NIC to avoid drowning in irrelevant data.

Step 2: Crafting Filters Like a Pro

Pktmons filtering capabilities are where it shines. I needed to zero in on specific trafficsay, HTTP traffic on port 80. To set this up, I added a filter:

pktmon filter add -p 80 -t tcp

This told Pktmon to capture TCP traffic on port 80. Want to capture ICMP pings instead? Easy:

pktmon filter add -t icmp

You can stack up to 32 filters to get granular. For instance, to monitor traffic to a specific IP (like 192.168.1.100):

pktmon filter add -i 192.168.1.100

To check your filters, run:

pktmon filter list

If you mess up, clear them with:

pktmon filter remove

Pro tip: Always set filters before capturing. Unfiltered captures are like trying to find a needle in a haystack of network traffic.

Step 3: Starting the Capture

With filters in place, it was time to start capturing. I wanted to save the packets to a file for later analysis, so I ran:

pktmon start --etw --pkt-size 0 --file-name C:\Temp\traffic.etl --comp 9

Heres what each part does:

• --etw: Enables Event Tracing for Windows, saving packets to an ETL file.

• --pkt-size 0: Captures full packets (default is just the first 128 bytes).

• --file-name C:\Temp\traffic.etl: Specifies the output file.

• --comp 9: Targets the Ethernet adapter (ID 9).

The capture started, silently logging packets in the background. To monitor in real-time (available in Windows 10 version 2004 and later), I couldve added -l real-time, but I wanted a file for deeper analysis.

Step 4: Stopping and Converting

After reproducing the issue (a quick browser refresh to a problematic website), I stopped the capture:

pktmon stop

This saved the data to C:\Temp\traffic.etl. But ETL files arent exactly user-friendly. To make them compatible with Wireshark, I converted the file to PCAPNG format:

pktmon etl2pcap C:\Temp\traffic.etl --out C:\Temp\traffic.pcapng

Now I had a traffic.pcapng file I could transfer to my workstation, where Wireshark was ready to dissect it with all its graphical glory.

Step 5: Analyzing the Results

On my own machine, I opened traffic.pcapng in Wireshark. The HTTP traffic I filtered for was there, clear as day, helping me pinpoint a misconfigured server response causing the slowdown. Pktmons ability to identify packet drops (with reasons like MTU Mismatch or Filtered VLAN) also gave me clues about potential network issues.

Bonus: Real-Time Monitoring

For quick checks, Pktmons real-time mode is a lifesaver. Try:

pktmon start --etw -l real-time -p 0

This displays packets on the command line as theyre captured. Hit Ctrl+C to stop. Its not as pretty as Wireshark, but it gets the job done when youre in a bind.

Why Pktmon Rocks

• No Installation Needed: Its built into Windows 10

• Lightweight: Perfect for servers where installing third-party tools is a no-go.

• Flexible Filters: Filter by IP, port, protocol, MAC, and more.

• Wireshark Compatibility: Convert to PCAPNG for detailed analysis.

Caveats

• No GUI: Its command-line only, so expect to get cozy with CMD or PowerShell.

• Basic Analysis: For deep packet inspection, youll still want Wireshark or similar tools.

• Admin Privileges: You need elevated access to run Pktmon.

The Victory Lap

Back to my story: with Pktmon, I captured the problematic traffic, converted it to PCAPNG, and analyzed it later on my own machine. The issue? An old DNS server that was taking forever to answer. Thanks to Pktmons filters, I isolated the culprit without sifting through gigabytes of data.

It is a nice tool to have on the tool belt. Leaving here for further reference and for those who might also leverage it.

A Descoberta: Pktmon ao Resgate

Em um ambiente limitado, sem ferramentas de terceiros nao autorizadas, sem sniffers com interface grfica sofisticada. Mas ento, como encontrar uma ferramenta esquecida no fundo de um galpo, descobri o Pktmon, um sniffer de pacotes embutido, introduzido no Windows 10. No chamativosem uma interface elegante como o Wiresharkmas suficiente para quebrar o galho, leve e, o melhor de tudo, j est ali, esperando para ser usado.

Abri um Prompt de Comando elevado (porque o Pktmon exige privilgios de administrador, claro) e digitei pktmon help para me orientar. O menu de ajuda era como um mapa do tesouro, revelando comandos para capturar pacotes, configurar filtros e at converter logs para anlise posterior.

Passo 1: Preparando o Terreno

Primeiro, eu precisava saber quais interfaces de rede estavam disponveis. Digitei:

pktmon comp list

Esse comando listou todos os adaptadores de rede do sistema, cada um com um ID. Por exemplo:

Adaptadores de Rede:
Id  Endereo MAC      Nome
--  -----------        ----
9   00-50-56-BD-C1-83  Adaptador Ethernet
12  E8-6A-64-44-7B-00  Adaptador Wi-Fi

Meu alvo era o adaptador Ethernet (ID 9). Saber o ID da interface crucial se voc quer focar a captura em uma NIC especfica para evitar se afogar em dados irrelevantes.

Passo 2: Criando Filtros

As capacidades de filtragem do Pktmon so onde ele brilha. Eu precisava focar em um trfego especficodigamos, trfego HTTP na porta 80. Para configurar isso, adicionei um filtro:

pktmon filter add -p 80 -t tcp

Isso instruiu o Pktmon a capturar trfego TCP na porta 80. Quer capturar pings ICMP em vez disso? Fcil:

pktmon filter add -t icmp

Voc pode empilhar at 32 filtros para ser bem especfico. Por exemplo, para monitorar trfego para um IP especfico (como 192.168.1.100):

pktmon filter add -i 192.168.1.100

Para verificar seus filtros, execute:

pktmon filter list

Se errar, limpe-os com:

pktmon filter remove

Dica de ouro: Sempre configure os filtros antes de capturar. Capturas sem filtro so como procurar uma agulha em um palheiro de trfego de rede.

Passo 3: Iniciando a Captura

Com os filtros configurados, era hora de comear a capturar. Eu queria salvar os pacotes em um arquivo para anlise posterior, ento executei:

pktmon start --etw --pkt-size 0 --file-name C:\Temp\traffic.etl --comp 9

Aqui est o que cada parte faz:

• --etw: Ativa o Event Tracing for Windows, salvando pacotes em um arquivo ETL.

• --pkt-size 0: Captura pacotes completos (o padro apenas os primeiros 128 bytes).

• --file-name C:\Temp\traffic.etl: Especifica o arquivo de sada.

• --comp 9: Foca no adaptador Ethernet (ID 9).

A captura comeou, registrando pacotes silenciosamente em segundo plano. Para monitoramento em tempo real (disponvel no Windows 10 verso 2004 ou posterior), eu poderia ter adicionado -l real-time, mas queria um arquivo para uma anlise mais profunda.

Passo 4: Parando e Convertendo

Depois de reproduzir o problema (uma rpida atualizao no navegador para um site problemtico), parei a captura:

pktmon stop

Isso salvou os dados em C:\Temp\traffic.etl. Mas arquivos ETL no so exatamente amigveis. Para torn-los compatveis com o Wireshark, converti o arquivo para o formato PCAPNG:

pktmon etl2pcap C:\Temp\traffic.etl --out C:\Temp\traffic.pcapng

Agora eu tinha um arquivo traffic.pcapng que podia transferir para minha estao de trabalho, onde o Wireshark estava pronto para dissec-lo com toda sua glria grfica.

Passo 5: Analisando os Resultados

Na minha prpria mquina, abri o traffic.pcapng no Wireshark. O trfego HTTP que filtrei estava l, claro como o dia, me ajudando a identificar uma resposta de servidor mal configurada que causava a lentido. A capacidade do Pktmon de identificar quedas de pacotes (com motivos como MTU Mismatch ou Filtered VLAN) tambm me deu pistas sobre possveis problemas na rede.

Bnus: Monitoramento em Tempo Real

Para verificaes rpidas, o modo em tempo real do Pktmon um salva-vidas. Experimente:

pktmon start --etw -l real-time -p 0

Isso exibe os pacotes na linha de comando enquanto so capturados. Pressione Ctrl+C para parar. No to bonito quanto o Wireshark, mas resolve quando voc est em apuros.

Por que o Pktmon Incrvel

• Sem Instalao Necessria: Est embutido no Windows 10.

• Leve: Perfeito para servidores onde instalar ferramentas de terceiros proibido.

• Filtros Flexveis: Filtre por IP, porta, protocolo, MAC e mais.

• Compatibilidade com Wireshark: Converta para PCAPNG para anlise detalhada.

Cuidados

• Sem Interface Grfica: s linha de comando, ento prepare-se para se familiarizar com CMD ou PowerShell.

• Anlise Bsica: Para inspeo profunda de pacotes, voc ainda vai querer o Wireshark ou ferramentas similares.

• Privilgios de Administrador: Voc precisa de acesso elevado para rodar o Pktmon.

A Volta da Vitria

Voltando minha histria: com o Pktmon, capturei o trfego problemtico, converti para PCAPNG e analisei depois na minha prpria mquina. O problema? Um servidor DNS antigo que demorava uma eternidade para responder. Graas aos filtros do Pktmon, isolei o culpado sem precisar vasculhar gigabytes de dados.

uma ferramenta excelente para ter no cinto de utilidades. Deixo aqui para referncia futura e para quem tambm quiser aproveit-la.

Overview of Tools

The following tools are essential for network automation, covering SSH, SNMP, and YANG-based protocols:

• SSH: For secure command-line access and NETCONF operations.

  • NAPALM: A Python library for multi-vendor network automation.

  • Netmiko

• SNMP: For monitoring and managing network devices.

  • NET-SNMP: A suite of tools for SNMP operations.

• YANG-based:

  • Cisco YANG Suite: A tool for exploring and testing YANG models.

  • GNMIc/Pygnmi: Tools for gNMI protocol interactions.

  • SSH (NETCONF): For YANG-based device management via NETCONF.

NAPALM

NAPALM (Network Automation and Programmability Abstraction Layer with Multivendor support) simplifies network device management through a unified API. It can be used via CLI or integrated into Python scripts.

Installation

Install NAPALM using pip:

pip3 install napalm

Reference

• NAPALM Documentation

Usage

Run NAPALM from the CLI to interact with devices:

napalm --user <username> --password <password> --vendor <driver> <ip_address> call <getter>

Example: get_facts

Retrieve device facts such as hostname, model, and OS version:

napalm --user admin --password admin --vendor ios 192.168.1.1 call get_facts

Example Output:

Result

GNMIc

GNMIc is a powerful CLI tool for interacting with network devices via the gNMI (gRPC Network Management Interface) protocol, ideal for telemetry and configuration.

Installation

Install GNMIc using the provided installation script:

bash -c "$(curl -sL https://get-gnmic.kmrd.dev)"

Reference

• GNMIc Documentation

Common Commands

CAPABILITIES

Check the gNMI capabilities of a device:

gnmic -a <ip:port> --username <user> --password <password> --insecure capabilities

Example:

gnmic -a 10.80.255.30:6030 -u admin -p admin --insecure capabilities

GET

Retrieve a snapshot of device data using a specific path:

gnmic -a <ip:port> --username <user> --password <password> --insecure get --path "/components/component/state/temperature"

SET

Modify device state (refer to GNMIc Set Documentation):

gnmic -a <ip:port> --username <user> --password <password> --insecure set --update-path "/interfaces/interface[name=Management1]/config/description" --update-value "Updated via gNMI"

SUBSCRIBE

Subscribe to real-time telemetry data:

gnmic -a <ip:port> --username <user> --password <password> --insecure subscribe --path "/interfaces/interface[name=Management1]/state/counters"

GNMI Prompt

Start an interactive session with preconfigured credentials:

gnmic --insecure --username admin --password admin --address <ip

NET-SNMP

NET-SNMP is a suite for interacting with SNMP-enabled devices, providing tools to query and manage network statistics.

Installation

Follow the official guide for installation:

• NET-SNMP Tutorial

Common SNMP OIDs

Key OIDs for interface statistics (MIB-II, RFC 1213):

Querying Interface Statistics

Query SNMP-enabled devices (e.g., IP 192.168.1.1, community string public). Replace IF_INDEX with the interface index (discoverable via ifDescr).

Example (SNMPv2c):

snmpget -v2c -c public 192.168.1.1 .1.3.6.1.2.1.2.2.1.10.IF_INDEX .1.3.6.1.2.1.2.2.1.16.IF_INDEX
snmpget -v2c -c public 192.168.1.1 SNMPv2-MIB::sysUpTime.0 # SYS UPTIME
snmpbulkwalk -v2c -c public 192.168.1.1 .1.0.8802.1.1.2.1.4.1.1.9 #LLDP NEIGHORS

Example (SNMPv3):

Retrieve system name with SNMPv3:

snmpget -v3 -u USERNAME -a SHA -x AES -l authPriv -A AUTHPASS -X PRIVPASS 192.168.1.1 .1.3.6.1.2.1.1.5.0

Cisco YANG Suite

YANG Suite is a valuable tool for working with YANG-based models.

Installation

You can install Cisco YANG Suite either via Docker or pip. Check the GitHub Repository for instructions.

Running YANG Suite

Once installed, run the suite using:

yangsuite

Access the web interface to explore YANG models and execute operations.

SSH (NETCONF)

NETCONF over SSH enables YANG-based device management. Its useful for retrieving schemas and performing operations.

Starting a NETCONF Session

Initiate a NETCONF session (default port 830):

ssh -s <username>@<device-ip> -p 830 netconf

This opens an interactive session for NETCONF operations, such as retrieving YANG schemas or configuring devices.

Note: While NETCONF over SSH is supported, tools like NAPALM or GNMIc often provide more efficient workflows.

Conclusion

This cheat sheet consolidates essential tools for network automation, including NAPALM, GNMIc, NET-SNMP, Cisco YANG Suite, and NETCONF over SSH. These tools enable efficient device querying, configuration, and telemetry, streamlining network management tasks. Use this guide as a quick reference to enhance your automation workflows.

As network engineers, we often deal with large datasets like IP addresses or subnets. Efficiently searching through these datasets is critical for automation tasks, such as finding a specific subnet in a network inventory. In this article, well explore two fundamental search algorithmslinear search and binary searchusing Python and subnets from the 10.0.0.0/8 network

Creating the Data

To simulate a network inventory, well create a dataset of /24 subnets from the 10.0.0.0/8 range (e.g., 10.0.0.0, 10.0.1.0, ..., 10.255.255.0). The following Python script generates three files: an ordered list, a reversed list, and a random list of subnets.

"""Generate subnet lists for testing search algorithms"""
import ipaddress
import random

# Generate all /24 subnets from 10.0.0.0/8
subnets = list(ipaddress.ip_network("10.0.0.0/8").subnets(new_prefix=24))
networks = [str(n.network_address) for n in subnets]

# Ordered subnets
with open("ordered_ip.txt", "w") as f:
    f.write("\n".join(networks))

# Reversed subnets
with open("reverse_ip.txt", "w") as f:
    f.write("\n".join(reversed(networks)))

# Random subnets
random.shuffle(networks)
with open("random_ip.txt", "w") as f:
    f.write("\n".join(networks))

This script produces:

• ordered_ip.txt: Subnets in ascending order (10.0.0.0, 10.0.1.0, ...).

• reverse_ip.txt: Subnets in descending order (10.255.255.0, 10.255.254.0, ...).

• random_ip.txt: Subnets in random order.

Each file contains 65,536 subnets (256 256), perfect for testing search performance.

Linear Search: The Straightforward Approach

Linear search is like checking each device in a rack one by one until you find the one youre looking for. It examines every element in a list until it finds a match or reaches the end.

How It Works

Imagine searching for 10.0.5.0 in an ordered list:

Subnets: 10.0.0.0  10.0.1.0  10.0.2.0  10.0.3.0  10.0.4.0  10.0.5.0
Indices:    0         1         2         3         4         5

• Check 10.0.0.0 No match.

• Check 10.0.1.0 No match.

• Continue until 10.0.5.0 is found (6 steps).

Performance:

• Best case: Target is at the start (1 step, (1)).

• Worst case: Target is at the end or absent (n steps, O(n), where n is the list size).

• For 65,536 subnets, the worst case means checking all 65,536 entries!

import sys
import time
from ipaddress import ip_address

# Read subnets and convert to integers for comparison
with open(sys.argv[1], "r") as f:
    data = [str(ip_address(line.strip())) for line in f]

# Get target subnet from user
target = str(ip_address(input("Enter a /24 subnet (e.g., 10.80.40.0): ")))

start_time = time.time()
for prefix in data:
    if prefix == target:
        print(f"Found {ip_address(target)} with linear search")
        break
print(f"Time: {time.time() - start_time:.4f} seconds")

Binary Search: The Efficient Divide-and-Conquer

Binary search is like troubleshooting a network by dividing the problem space in half repeatedly. It requires a sorted list but is significantly faster for large datasets.

How It Works

For the same list, searching for 10.0.5.0:

Subnets: 10.0.0.0  10.0.1.0  10.0.2.0  10.0.3.0  10.0.4.0  10.0.5.0
Indices:    0         1         2         3         4         5

1. Find the midpoint: (0 + 5) // 2 = 2 (10.0.2.0).

2. Compare: 10.0.2.0 < 10.0.5.0, so ignore the left half (indices 02).

3. New list: 10.0.3.0, 10.0.4.0, 10.0.5.0.

4. New midpoint: (3 + 5) // 2 = 4 (10.0.4.0).

5. Compare: 10.0.4.0 < 10.0.5.0, ignore index 4.

6. Check 10.0.5.0 Found in 3 steps!

Performance:

• Best case: Target is at the midpoint (1 step, (1)).

• Worst case: O(log n), where n is the list size. For 65,536 subnets, it takes at most ~16 steps (log(65,536) 16).

• Binary search is exponentially faster than linear search for large datasets.

import sys
import time
from ipaddress import ip_address

def binary_search(arr, target):
    arr = sorted(arr)  # Ensure the list is sorted
    start, end = 0, len(arr) - 1
    while start <= end:
        mid = (start + end) // 2
        if arr[mid] == target:
            return mid
        elif arr[mid] < target:
            start = mid + 1
        else:
            end = mid - 1
    return -1

# Read subnets and convert to integers
with open(sys.argv[1], "r", encoding="utf-8") as f:
    data = [str(ip_address(line.strip())) for line in f]

# Get target subnet
target = str(ip_address(input("Enter a /24 subnet (e.g., 10.80.40.0): ")))

start_time = time.time()
index = binary_search(data, target)
if index != -1:
    print(f"Found {ip_address(target)} with binary search")
else:
    print(f"Subnet {ip_address(target)} not found")
print(f"Time: {time.time() - start_time:.4f} seconds")

Performance Comparison

To illustrate the difference, lets test both algorithms on our subnet datasets. Here are results for searching 10.255.255.0 (worst case for linear search in ordered_ip.txt):

• Linear Search: ~0.008 seconds (65,536 checks).

• Binary Search: ~0.0001 seconds (~16 checks).

For a random subnet like 10.80.40.0 in random_ip.txt:

• Linear Search: ~0.004 seconds (average case).

• Binary Search: ~0.0001 seconds (sorting overhead included).

The chart below visualizes the number of steps required as the dataset size grows:

Practical Application in Network Automation

Imagine youre automating a task to find a specific subnet in a routing table or IPAM system. Linear search works for small lists but becomes impractical for thousands of subnets. Binary search, with its O(log n) efficiency, is ideal for large-scale network data, especially if the data is pre-sorted (common in databases or IPAM tools).

Example Use Case: Youre validating whether a subnet exists in a networks inventory before assigning it to a new VLAN. Binary search ensures quick lookups, minimizing script runtime and improving automation efficiency.

Interactive Challenge

Try this hands-on exercise to see the algorithms in action:

1. Save the subnet generation script as subnets.py and run it to create the three files.

2. Combine the linear and binary search scripts into one file (search_subnets.py):

import sys
import time
from ipaddress import ip_address

def linear_search(arr, target):
    for i, prefix in enumerate(arr):
        if prefix == target:
            return i
    return -1

def binary_search(arr, target):
    arr = sorted(arr)
    start, end = 0, len(arr) - 1
    while start <= end:
        mid = (start + end) // 2
        if arr[mid] == target:
            return mid
        elif arr[mid] < target:
            start = mid + 1
        else:
            end = mid - 1
    return -1

# Read subnets
with open(sys.argv[1], "r", encoding="utf-8") as f:
    data = [str(ip_address(line.strip())) for line in f]

# Get target subnet
target = str(ip_address(input("Enter a /24 subnet (e.g., 10.80.40.0): ")))

# Linear search
start_time = time.time()
index = linear_search(data, target)
print(f"Linear Search: {'Found' if index != -1 else 'Not found'} {ip_address(target)}")
print(f"Time: {time.time() - start_time:.4f} seconds")

# Binary search
start_time = time.time()
index = binary_search(data, target)
print(f"Binary Search: {'Found' if index != -1 else 'Not found'} {ip_address(target)}")
print(f"Time: {time.time() - start_time:.4f} seconds")

Run the script with different files and subnets:

python search_subnets.py ordered_ip.txt

Try searching for 10.0.0.0 (best case), 10.255.255.0 (worst case), and a random subnet like 10.80.40.0.

Challenge: Modify the script to count the number of comparisons each algorithm makes and print them. This will help you see the efficiency gap firsthand!

Gerando os Dados

Para simular um inventrio de rede, criaremos um conjunto de sub-redes /24 no range10.0.0.0/8 (por exemplo, 10.0.0.0, 10.0.1.0, ..., 10.255.255.0). O script Python a seguir gera trs arquivos: uma lista ordenada, uma lista invertida e uma lista aleatria de sub-redes.

import ipaddress
import random

# Gera todas as sub-redes /24 de 10.0.0.0/8
subnets = list(ipaddress.ip_network("10.0.0.0/8").subnets(new_prefix=24))
networks = [str(n.network_address) for n in subnets]

# Sub-redes ordenadas
with open("ordered_ip.txt", "w") as f:
    f.write("\n".join(networks))

# Sub-redes invertidas
with open("reverse_ip.txt", "w") as f:
    f.write("\n".join(reversed(networks)))

# Sub-redes aleatrias
random.shuffle(networks)
with open("random_ip.txt", "w") as f:
    f.write("\n".join(networks))

Este script produz:

• ordered_ip.txt: Sub-redes em ordem crescente (10.0.0.0, 10.0.1.0, ...).

• reverse_ip.txt: Sub-redes em ordem decrescente (10.255.255.0, 10.255.254.0, ...).

• random_ip.txt: Sub-redes em ordem aleatria.

Cada arquivo contm 65.536 sub-redes (256 256), ideal para testar o desempenho das buscas.

Linear Search: A Abordagem Direta

O linear search como verificar cada dispositivo em um rack, um a um, at encontrar o que voc procura. Ele examina cada elemento de uma lista at encontrar uma correspondncia ou chegar ao final.

Como Funciona

Imagine procurar pela sub-rede 10.0.5.0 em uma lista ordenada:

Sub-redes: 10.0.0.0  10.0.1.0  10.0.2.0  10.0.3.0  10.0.4.0  10.0.5.0
ndices:      0         1         2         3         4         5

• Verifica 10.0.0.0 Sem correspondncia.

• Verifica 10.0.1.0 Sem correspondncia.

• Continua at encontrar 10.0.5.0 (6 passos).

Desempenho:

• Melhor caso: O alvo est no incio (1 passo, O(1)).

• Pior caso: O alvo est no final ou ausente (n passos, O(n), onde n o tamanho da lista).

• Para 65.536 sub-redes, o pior caso significa verificar todas as 65.536 entradas

Cdigo do Linear Search

import sys
import time
from ipaddress import ip_address

# L as sub-redes e converte para inteiros para comparao
with open(sys.argv[1], "r") as file:
    data = [str(ip_address(line.strip())) for line in file]

# Obtm a sub-rede alvo do usurio
target = str(ip_address(input("Digite uma sub-rede /24 (ex., 10.80.40.0): ")))

start_time = time.time()
for prefix in data:
    if prefix == target:
        print(f"Encontrado {ip_address(target)} com linear search")
        break
print(f"Tempo: {time.time() - start_time:.4f} segundos")

Binary Search: Dividir e Conquistar

O binary search como solucionar um problema de rede dividindo o espao do problema ao meio repetidamente. Ele requer uma lista ordenada, mas significativamente mais rpido para grandes conjuntos de dados.

Como Funciona

Na mesma lista, procurando por 10.0.5.0:

Sub-redes: 10.0.0.0  10.0.1.0  10.0.2.0  10.0.3.0  10.0.4.0  10.0.5.0
ndices:      0         1         2         3         4         5

1. Encontra o ponto mdio: (0 + 5) // 2 = 2 (10.0.2.0).

2. Compara: 10.0.2.0 < 10.0.5.0, ento ignora a metade esquerda (ndices 02).

3. Nova lista: 10.0.3.0, 10.0.4.0, 10.0.5.0.

4. Novo ponto mdio: (3 + 5) // 2 = 4 (10.0.4.0).

5. Compara: 10.0.4.0 < 10.0.5.0, ignora o ndice 4.

6. Verifica 10.0.5.0 Encontrado em 3 passos!

Desempenho:

• Melhor caso: O alvo est no ponto mdio (1 passo, O(1)).

• Pior caso: O(log n), onde n o tamanho da lista. Para 65.536 sub-redes, so necessrios no mximo ~16 passos (log(65.536) 16).

• O binary search exponencialmente mais rpido que o linear search para grandes conjuntos.

Cdigo do Binary Search

import sys
import time
from ipaddress import ip_address

def binary_search(arr, target):
    arr = sorted(arr)  # Garante que a lista est ordenada
    start = 0
    end = len(arr) - 1
    while start <= end:
        mid = (start + end) // 2
        if arr[mid] == target:
            return mid
        elif arr[mid] < target:
            start = mid + 1
        else:
            end = mid - 1
    return -1

# L as sub-redes e converte para inteiros
with open(sys.argv[1], "r") as f:
    data = [str(ip_address(line.strip())) for line in f]

# Obtm a sub-rede alvo
target = str(ip_address(input("Digite uma sub-rede /24 (ex., 10.80.40.0): ")))

start_time = time.time()
index = binary_search(data, target)
if index != -1:
    print(f"Encontrado {ip_address(target)} com binary search")
else:
    print(f"Sub-rede {ip_address(target)} no encontrada")
print(f"Tempo: {time.time() - start_time:.4f} segundos")

Comparao de Desempenho

Para ilustrar a diferena, testamos ambos os algoritmos em nossos conjuntos de sub-redes. Resultados para a busca de 10.255.255.0 (pior caso para linear search em ordered_ip.txt):

• Linear Search: ~0.008 segundos (65.536 verificaes).

• Binary Search: ~0.0001 segundos (~16 verificaes).

Para uma sub-rede aleatria como 10.80.40.0 em random_ip.txt:

• Linear Search: ~0.004 segundos (caso mdio).

• Binary Search: ~0.0001 segundos (incluindo a sobrecarga de ordenao).

O grfico abaixo visualiza o nmero de passos necessrios conforme o tamanho do conjunto de dados aumenta:

Aplicao Prtica em Automao de Redes

Imagine que voc est automatizando uma tarefa para encontrar uma sub-rede especfica em uma tabela de roteamento ou sistema IPAM. O linear search funciona para listas pequenas, mas se torna impraticvel para milhares de sub-redes. O binary search, com sua eficincia O(log n), ideal para dados de rede em grande escala, especialmente se os dados j estiverem ordenados (comum em bancos de dados ou ferramentas IPAM).

Exemplo de Caso de Uso: Voc est validando se uma sub-rede existe no inventrio de uma rede antes de atribu-la a uma nova VLAN. O binary search garante buscas rpidas, minimizando o tempo de execuo do script e melhorando a eficincia da automao.

Desafio Interativo

Experimente este exerccio prtico para ver os algoritmos em ao:

1. Salve o script de gerao de sub-redes como subnets.py e execute-o para criar os trs arquivos.

2. Combine os scripts de linear search e binary search em um nico arquivo

    import sys
    import time
    from ipaddress import ip_address
   
    def linear_search(arr, target):
        for i, prefix in enumerate(arr):
            if prefix == target:
                return i
        return -1
   
    def binary_search(arr, target):
        arr = sorted(arr)
        start, end = 0, len(arr) - 1
        while start <= end:
            mid = (start + end) // 2
            if arr[mid] == target:
                return mid
            elif arr[mid] < target:
                start = mid + 1
            else:
                end = mid - 1
        return -1
   
    # L as sub-redes
    with open(sys.argv[1], "r") as f:
        data = [int(ip_address(line.strip())) for line in f]
   
    # Obtm a sub-rede alvo
    target = int(ip_address(input("Digite uma sub-rede /24 (ex., 10.80.40.0): ")))
   
    # Linear search
    start_time = time.time()
    index = linear_search(data, target)
    print(f"Linear Search: {'Encontrado' if index != -1 else 'No encontrado'} {ip_address(target)}")
    print(f"Tempo: {time.time() - start_time:.4f} segundos")
   
    # Binary search
    start_time = time.time()
    index = binary_search(data, target)
    print(f"Binary Search: {'Encontrado' if index != -1 else 'No encontrado'} {ip_address(target)}")
    print(f"Tempo: {time.time() - start_time:.4f} segundos")
   

3. Execute o script com diferentes arquivos e sub-redes:

    search_subnets.py ordered_ip.txt
   

   Experimente buscar por 10.0.0.0 (melhor caso), 10.255.255.0 (pior caso) e uma sub-rede aleatria como 10.80.40.0.

Desafio: Modifique o script para contar o nmero de comparaes que cada algoritmo faz e imprima-os. Isso ajudar a visualizar a diferena de eficincia diretamente!

JumpHost

Eu frequentemente utilizo o recurso de encaminhamento de tneis SSH para acessar endpoints disponveis a partir de um JumpHost, mas no do meu laptop.

Exemplo de Configurao

ssh -L [local_addr:]local_port:remote_addr:remote_port [user@]sshd_addr

## Exemplos
ssh -L 8443:destino:443 usuario@jumphost
ssh -L 2022:destino:22 usuario@jumphost

Aqui est uma representao visual:

Proxy Reverso

A ideia permitir que uma entidade acessvel por voc se conecte por meio de outra entidade que no consegue estabelecer essa conexo diretamente.

O caso de uso mais comum que vi em outros artigos :

• Expor um servio de desenvolvimento internet pblica para uma demonstrao.

  Alvo

  Pode ser um servidor web em sua empresa ou em sua prpria mquina, por exemplo.

Outro caso de uso que precisei por algum tempo foi:

• Expor um servio pblico a um servidor interno.

Guia Passo a Passo do Meu Caso

H um servidor da empresa que no tem acesso ao GitHub, onde armazeno uma grande quantidade de cdigo.

Minha mquina pessoal de trabalho tem acesso ao GitHub. Posso me conectar ao servidor a partir da minha mquina, mas no posso conectar ao meu computador a partir do servidor devido a regras de firewall que bloqueiam essa conexo (o que impede o uso da tcnica de JumpHost).

Portanto, preciso criar um tnel da minha mquina para o servidor para conceder acesso a algo.

necessrio configurar uma conexo de proxy reverso para que o servidor tenha acesso ao GitHub.

No Servidor Remoto

1. Certifique-se de adicionar as chaves SSH ao GitHub.

2. Carregar Permanentemente a Chave SSH no ssh-agent

nano ~/.bashrc
#### Adicione ao final do arquivo
eval "$(ssh-agent -s)"
ssh-add ~/.ssh/github_private_key

3. Ajustar o Arquivo de Configurao do Git

nano ~/.ssh/config

Host localhost
    Hostname localhost
    Port 8088
    User git

4. Configurar a Origem

No repositrio da sua pasta:

git remote set-url origin git@localhost:usuario/REPONOME.git

5. Criar o Tnel (A partir da Sua Mquina Local)

ssh -R 8088:github.sua_empresa.com:22 servidor

6. Validar o Acesso

ssh -T git@localhost

Referncias

https://www.ssh.com/academy/ssh/tunneling-example

https://docs.github.com/en/authentication/connecting-to-github-with-ssh

• O que causa um loop em uma rede?

Loops so introduzidos em uma rede quando adicionamos redundncia, criando mltiplos caminhos entre dois pontos. Isso pode fazer com que os dados circulem indefinidamente, causando problemas graves, como degradao de desempenho, bloqueios inesperados de portas, interrupes completas da rede e at falhas nos dispositivos.

Quando h um loop, os switches continuam encaminhando pacotes repetidamente at que uma das seguintes situaes ocorra:

• O loop corrigido ao desconectar um dos cabos.

• Os switches travam devido ao excesso de trfego.

• Os quadros Ethernet, que no possuem um campo TTL (Time to Live), continuam circulando indefinidamente.

Esse comportamento tambm afeta o trfego BUM broadcast, unicast desconhecido e multicast.

BPDU

Os switches que utilizam o STP trocam informaes por meio de mensagens especiais chamadas BPDU (Bridge Protocol Data Unit, ou Unidade de Dados de Protocolo de Ponte).

Formao da rvore

O processo de formao da rvore segue estas etapas:

• Eleio do switch raiz: Todas as portas do switch raiz estaro no estado de encaminhamento (forwarding).

• Switches no-raiz: Cada switch no-raiz deve encontrar o caminho mais curto at o switch raiz e eleger uma porta raiz (root port). - Isso acontece atraves do CUSTO

• Outras portas: Todas as portas que recebem BPDUs (indicando a presena de um loop) passam por um processo de eleio para determinar se sero portas de encaminhamento ou bloqueio, eliminando o loop.

Switch Raiz

O switch raiz aquele com o menor identificador de ponte (bridge ID), composto por prioridade + endereo MAC.

Switches No-Raiz

Todos os switches no-raiz devem encontrar o caminho mais curto at o switch raiz. Como isso feito? O STP atribui custos a cada interface com base na sua velocidade. A interface com o menor custo at o switch raiz designada como a porta raiz, que encaminha o trfego.

As demais portas dos switches no-raiz decidem se encaminharo trfego ou sero bloqueadas para evitar loops. Todas as portas que recebem BPDUs passam por esse processo de eleio para determinar seu estado.

Processo de Desempate

Quando o STP precisa tomar uma deciso, ele segue esta ordem de critrios:

1. Menor custo at o switch raiz: Quando um switch recebe mltiplos BPDUs, ele escolhe a interface com o menor custo at o switch raiz como a porta raiz.

   

2. Menor ID de ponte do remetente: Se um switch est conectado a dois outros switches que oferecem o mesmo custo at o switch raiz, ele escolhe a interface conectada ao switch com o menor ID de ponte como a porta raiz.

   

3. Menor ID de porta do remetente: Se um switch possui duas interfaces conectadas ao mesmo switch e o custo at o switch raiz igual, ele escolhe a interface com o menor nmero como a porta raiz.

   

Tabela de Custos de Porta por Velocidade de Interface

Nota: Os custos acima seguem o padro IEEE 802.1D, amplamente implementado em dispositivos de rede. Algumas switches modernas podem suportar velocidades mais altas (como 25 Gbps, 40 Gbps ou 100 Gbps) com o mesmo custo mnimo de 10 Gbps.

O STP atribui custos s portas para determinar o caminho mais eficiente para os dados na rede. Custos menores so preferidos, o que significa que links de maior velocidade so priorizados.

Melhores Prticas para Evitar Loops na Rede

Para garantir a estabilidade da rede e prevenir loops, siga estas recomendaes:

1. Priorize switches centrais no STP: Configure as prioridades do STP para garantir que o switch raiz seja o mais confivel. Isso otimiza os caminhos de dados e bloqueia links redundantes adequadamente.

2. Ative proteo contra loops: Configure a proteo contra loops nas portas dos switches para desativ-las automaticamente quando um loop for detectado.

3. Manuteno regular: Inspecione e substitua cabos defeituosos. Negociaes de link inadequadas podem causar mudanas de prioridade no STP (flapping), resultando em problemas persistentes de conectividade.

Espero que esta reviso rpida do STP tenha sido til! H sempre mais a explorar, mas com essas informaes, voc tem uma base slida para diagnosticar e interpretar resultados de anlises.

At a prxima!