FastAPI é um framework para construir APIs com Python 3.7+. Em automação de redes, FastAPI é ideal para criar APIs que interagem com dispositivos, como roteadores e switches, de forma rápida e escalável.

Recursos

• Documentação Oficial do FastAPI

• Tutorial de APIs REST com FastAPI

Principais Características

• Alta Performance: Suporta chamadas assíncronas por padrão

• Fácil de Usar: Projetado para ser simples, mesmo para iniciantes em Python.

• Documentação Automática: Gera documentação interativa (Swagger UI) para suas APIs.

• Baseado em Padrões: Compatível com OpenAPI e JSON Schema, padrões comuns em APIs de rede.

Por que FastAPI para Automação de Redes?

FastAPI é uma boa escolha porque:

• Permite criar endpoints para consultar ou configurar dispositivos rapidamente.

• Suporta operações assíncronas, úteis para interagir com vários dispositivos ao mesmo tempo.

• Valida dados automaticamente (ex.: configurações de rede em JSON), reduzindo erros.

FastAPI vs. Outros Frameworks

FastAPI se destaca pela performance e pela facilidade de criar APIs robustas

Configuração do Ambiente

Para começar, configure um ambiente virtual Python e instale o FastAPI e o Uvicorn (servidor ASGI).

Instalar FastAPI e Uvicorn

pip install fastapi uvicorn

Verificar a Instalação

Crie um arquivo main.py com uma API simples:

from fastapi import FastAPI

app = FastAPI()

@app.get("/")
def read_root():
    return {"mensagem": "Bem-vindo à AUTONETOPS"}

Execute a aplicação:

uvicorn main:app --reload

Acesse http://localhost:8000

Sua Primeira Aplicação FastAPI

Vamos criar uma API para gerenciar informações de dispositivos de rede, como roteadores ou switches. Este exemplo simula interações com dispositivos, preparando você para integrar com Netmiko ou NAPALM nas próximas lições.

from fastapi import FastAPI
from pydantic import BaseModel

app = FastAPI()

# Modelo para representar um dispositivo de rede
class Device(BaseModel):
    hostname: str
    ip: str
    device_type: str = "cisco_ios"  # Valor padrão

# Endpoint para saudação inicial
@app.get("/")
def read_root():
    return {"mensagem": "API para Automação de Redes"}

# Endpoint para obter informações de um dispositivo por ID
@app.get("/devices/{device_id}")
def read_device(device_id: int, status: str = None):
    return {"device_id": device_id, "status": status}

# Endpoint para criar um novo dispositivo
@app.post("/devices/")
def create_device(device: Device):
    return {"hostname": device.hostname, "ip": device.ip, "device_type": device.device_type}

Explicação do Código

• Operações de Caminho: Usamos @app.get e @app.post para definir endpoints.

• Parâmetros de Caminho: {device_id} é convertido automaticamente para int.

• Parâmetros de Consulta: status é opcional (valor padrão None).

• Modelo Pydantic: A classe Device define e valida dados de entrada (ex.: JSON com hostname e ip).

• Documentação Automática: Acesse http://localhost:8000/docs para testar a API interativamente.

Como Executar

Salve o código em main.py e execute:

uvicorn main:app --reload

Teste os endpoints:

• GET http://localhost:8000/devices/1?status=active → Retorna {"device_id": 1, "status": "active"}.

• POST http://localhost:8000/devices/ com corpo JSON:

  json { "hostname": "r1", "ip": "172.20.20.11", "device_type": "cisco_ios" }

Atividade Prática

1. Explorar a Documentação:

   • Acesse http://localhost:8000/docs e teste os endpoints GET e POST.

   • Envie um POST com um dispositivo inválido (ex.: ip ausente) e observe a validação automática.

2. Criar um Novo Endpoint:

   • Adicione um endpoint GET /devices/ que retorna uma lista fixa de dispositivos. Ex: [{"hostname": "r1", "ip": "172.20.20.11"}]