FastAPI

• python
• framework Backend moderno, rápido y orientado a la productividad.
• Basado en tipado estático, async/await y validación automática con Pydantic.
• Cumple con el estándar ASGI, lo que permite alta concurrencia y rendimiento.
• Ideal para construir APIs REST, microservicios o backends para aplicaciones modernas.

Recursos y documentación

• Tutorial - User Guide - FastAPI
• GitHub - Full Stack FastAPI Template
• Crea una Aplicación con FastAPI para Python - Kinsta®

• [04. Documentación automática

  Curso de Introducción a FastAPI 2024 - YouTube](https://youtu.be/5gwCOje67Js)

Características clave

• Desarrollo rápido gracias a autocompletado y tipado en los editores.
• Validación automática de datos con Pydantic.
• Documentación interactiva automática con Swagger y Redoc.
• Compatible con ASGI, permitiendo servidores concurrentes de alto rendimiento.
• Integración sencilla con bases de datos, autenticación JWT, middlewares y CORS.
• Escalable: adecuado para microservicios o arquitecturas complejas.

Servidores ASGI compatibles

• Uvicorn — rápido, basado en asyncio.
• Starlette — framework ligero sobre el que se construye FastAPI.

Validación y modelos de datos

• Welcome to Pydantic - Pydantic
• Pydantic permite:
  • Validar entradas y salidas.
  • Definir esquemas con tipado estricto.
  • Generar documentación a partir de los modelos.

Ejemplo básico con Pydantic

from pydantic import BaseModel

class Item(BaseModel):
	name: str
	price: float
	in_stock: bool = True

`

Creación de una API básica

Ejemplo de servidor FastAPI

from fastapi import FastAPI
from pydantic import BaseModel

app = FastAPI()

class Item(BaseModel):
	name: str
	price: float
	in_stock: bool = True

@app.get("/")
def read_root():
	return {"message": "Bienvenido a FastAPI"}

@app.post("/items/")
def create_item(item: Item):
	return {"item": item}

• Ejecutar con Uvicorn:

uvicorn main:app --reload

• Documentación generada automáticamente:

  • Swagger UI: http://127.0.0.1:8000/docs
  • ReDoc: http://127.0.0.1:8000/redoc

Mejores prácticas

• Organizar la app por módulos (routers, models, services).
• Usar dependencias con Depends para inyección de lógica común.
• Añadir middleware para logs, seguridad y control de errores.
• Definir variables de entorno con python-dotenv o pydantic-settings.
• Implementar tests con pytest y httpx.

Extensiones y ecosistema

• Autenticación: fastapi-users, JWT o OAuth2.
• Bases de datos: SQLModel, SQLAlchemy, Tortoise ORM.
• Tareas asíncronas: Celery, RQ, o BackgroundTasks.
• Integración con frontend: ideal con Blazor, React, Vue o Svelte.
• Despliegue: Docker, Kubernetes, Azure, AWS Lambda.

Plantillas y ejemplos completos

• FastAPI Full Stack Template (FastAPI + React + PostgreSQL)
• fastapi-best-practices
• fastapi-realworld-example-app

Temas relacionados

• ASGI
• Swagger
• Pydantic
• Python AsyncIO
• Backend
• Microservicios

FastAPI (temas avanzados adicionales)

WebSockets y comunicación en tiempo real

• FastAPI soporta WebSockets nativamente.
• Útil para chat, notificaciones, dashboards en tiempo real o juegos online.
• Ejemplo básico:

from fastapi import FastAPI, WebSocket

app = FastAPI()

@app.websocket("/ws")
async def websocket_endpoint(websocket: WebSocket):
	await websocket.accept()
	while True:
		data = await websocket.receive_text()
		await websocket.send_text(f"Recibido: {data}")

`

Background Tasks

• Permite ejecutar tareas en segundo plano sin bloquear la respuesta al cliente.
• Ideal para enviar correos, procesar archivos o actualizar registros en BD.

from fastapi import BackgroundTasks, FastAPI

app = FastAPI()

def write_log(message: str):
	with open("log.txt", "a") as f:
		f.write(message + "\n")

@app.post("/send/")
async def send_message(background_tasks: BackgroundTasks, message: str):
	background_tasks.add_task(write_log, message)
	return {"status": "Mensaje encolado"}

Eventos de startup y shutdown

• Permite inicializar recursos al arrancar la app (DB, cache) y cerrarlos correctamente al detenerse.

@app.on_event("startup")
async def startup_event():
	print("Aplicación iniciada, recursos cargados")

@app.on_event("shutdown")
async def shutdown_event():
	print("Aplicación cerrada, recursos liberados")

Dependencias avanzadas

• Las dependencias (Depends) pueden ser jerárquicas y reutilizables.
• Ejemplo: autenticación con roles, conexión a BD o configuración de servicios.

from fastapi import Depends, HTTPException, status

def get_token_header(token: str):
	if token != "secreto":
		raise HTTPException(status_code=status.HTTP_403_FORBIDDEN, detail="Token inválido")
	return token

@app.get("/protected/")
def protected_route(token: str = Depends(get_token_header)):
	return {"message": "Acceso permitido"}

Versionado de API

• Organizar rutas por versión es crucial para mantener compatibilidad con clientes existentes.
• Ejemplo de estructura de rutas: /v1/items/, /v2/items/.

Respuestas y manejo de errores avanzados

• FastAPI permite definir respuestas personalizadas con códigos HTTP, headers y modelos de respuesta.
• Ejemplo:

from fastapi import Response

@app.get("/custom/")
def custom_response():
	content = {"message": "Respuesta personalizada"}
	return Response(content=str(content), media_type="application/json", status_code=202)

Seguridad avanzada

• Autenticación: OAuth2, JWT, API keys.
• Autorización: control de roles y permisos.
• Protección CORS y HTTPS para producción.
• Ejemplo JWT: se puede combinar con dependencias para validar tokens.

Integración con ORMs y bases de datos

• SQLAlchemy, Tortoise ORM, SQLModel, MongoDB (con Motor).
• Soporta operaciones síncronas y asíncronas.
• Uso de sessions y transacciones con context managers.

Testing avanzado

• TestClient permite pruebas de endpoints sin necesidad de levantar un servidor.
• Compatible con pytest para pruebas unitarias e integración.

from fastapi.testclient import TestClient

client = TestClient(app)

def test_read_root():
	response = client.get("/")
	assert response.status_code == 200
	assert response.json() == {"message": "Bienvenido a FastAPI"}

Optimización y performance

• Middleware para caching, compresión y logging.
• Uso eficiente de async/await para operaciones I/O intensivas.
• Integración con herramientas de profiling (PyInstrument, cProfile) para detectar cuellos de botella.

Despliegue avanzado

• Docker: contenerizar la app para entornos de producción.
• Gunicorn + Uvicorn workers para manejo de múltiples procesos.
• Orquestación con Kubernetes, despliegue en AWS, Azure, GCP.
• Monitoreo con Prometheus, Grafana y logs centralizados.

Observabilidad y métricas

• Middleware personalizado para medir tiempos de respuesta y errores.
• Integración con OpenTelemetry para tracing distribuido.
• Métricas de endpoints expuestas para dashboards en tiempo real.

Integración con Machine Learning

• FastAPI permite exponer modelos ML como APIs.
• Serialización de entrada/salida con Pydantic.
• Uso combinado con librerías como TensorFlow, PyTorch o scikit-learn.

Plantillas y ejemplos de proyectos

• APIs REST completas con autenticación, roles y testing.
• Integración con frontend React/Vue/Svelte para apps full-stack.
• Microservicios ligeros y modulares con comunicación interna usando HTTP o WebSockets.

FastAPI (temas avanzados adicionales)

WebSockets y comunicación en tiempo real

• FastAPI soporta WebSockets nativamente.
• Útil para chat, notificaciones, dashboards en tiempo real o juegos online.
• Ejemplo básico:

from fastapi import FastAPI, WebSocket

app = FastAPI()

@app.websocket("/ws")
async def websocket_endpoint(websocket: WebSocket):
	await websocket.accept()
	while True:
		data = await websocket.receive_text()
		await websocket.send_text(f"Recibido: {data}")

`

Background Tasks

• Permite ejecutar tareas en segundo plano sin bloquear la respuesta al cliente.
• Ideal para enviar correos, procesar archivos o actualizar registros en BD.

from fastapi import BackgroundTasks, FastAPI

app = FastAPI()

def write_log(message: str):
	with open("log.txt", "a") as f:
		f.write(message + "\n")

@app.post("/send/")
async def send_message(background_tasks: BackgroundTasks, message: str):
	background_tasks.add_task(write_log, message)
	return {"status": "Mensaje encolado"}

Eventos de startup y shutdown

• Permite inicializar recursos al arrancar la app (DB, cache) y cerrarlos correctamente al detenerse.

@app.on_event("startup")
async def startup_event():
	print("Aplicación iniciada, recursos cargados")

@app.on_event("shutdown")
async def shutdown_event():
	print("Aplicación cerrada, recursos liberados")

Dependencias avanzadas

• Las dependencias (Depends) pueden ser jerárquicas y reutilizables.
• Ejemplo: autenticación con roles, conexión a BD o configuración de servicios.

from fastapi import Depends, HTTPException, status

def get_token_header(token: str):
	if token != "secreto":
		raise HTTPException(status_code=status.HTTP_403_FORBIDDEN, detail="Token inválido")
	return token

@app.get("/protected/")
def protected_route(token: str = Depends(get_token_header)):
	return {"message": "Acceso permitido"}

Versionado de API

• Organizar rutas por versión es crucial para mantener compatibilidad con clientes existentes.
• Ejemplo de estructura de rutas: /v1/items/, /v2/items/.

Respuestas y manejo de errores avanzados

• FastAPI permite definir respuestas personalizadas con códigos HTTP, headers y modelos de respuesta.
• Ejemplo:

from fastapi import Response

@app.get("/custom/")
def custom_response():
	content = {"message": "Respuesta personalizada"}
	return Response(content=str(content), media_type="application/json", status_code=202)

Seguridad avanzada

• Autenticación: OAuth2, JWT, API keys.
• Autorización: control de roles y permisos.
• Protección CORS y HTTPS para producción.
• Ejemplo JWT: se puede combinar con dependencias para validar tokens.

Integración con ORMs y bases de datos

• SQLAlchemy, Tortoise ORM, SQLModel, MongoDB (con Motor).
• Soporta operaciones síncronas y asíncronas.
• Uso de sessions y transacciones con context managers.

Testing avanzado

• TestClient permite pruebas de endpoints sin necesidad de levantar un servidor.
• Compatible con pytest para pruebas unitarias e integración.

from fastapi.testclient import TestClient

client = TestClient(app)

def test_read_root():
	response = client.get("/")
	assert response.status_code == 200
	assert response.json() == {"message": "Bienvenido a FastAPI"}

Optimización y performance

• Middleware para caching, compresión y logging.
• Uso eficiente de async/await para operaciones I/O intensivas.
• Integración con herramientas de profiling (PyInstrument, cProfile) para detectar cuellos de botella.

Despliegue avanzado

• Docker: contenerizar la app para entornos de producción.
• Gunicorn + Uvicorn workers para manejo de múltiples procesos.
• Orquestación con Kubernetes, despliegue en AWS, Azure, GCP.
• Monitoreo con Prometheus, Grafana y logs centralizados.

Observabilidad y métricas

• Middleware personalizado para medir tiempos de respuesta y errores.
• Integración con OpenTelemetry para tracing distribuido.
• Métricas de endpoints expuestas para dashboards en tiempo real.

Integración con Machine Learning

• FastAPI permite exponer modelos ML como APIs.
• Serialización de entrada/salida con Pydantic.
• Uso combinado con librerías como TensorFlow, PyTorch o scikit-learn.

Plantillas y ejemplos de proyectos

• APIs REST completas con autenticación, roles y testing.
• Integración con frontend React/Vue/Svelte para apps full-stack.
• Microservicios ligeros y modulares con comunicación interna usando HTTP o WebSockets.

FastAPI Cheatsheet

Conceptos Clave

• Framework Backend moderno, rápido y asíncrono.
• Basado en Python 3.7+, Pydantic y ASGI.
• Genera documentación automática: Swagger (/docs) y Redoc (/redoc).
• Compatible con async/await, WebSockets y BackgroundTasks.
• Ideal para APIs REST, microservicios y apps full-stack.

Instalación

pip install fastapi uvicorn

`

• Para desarrollo con autoreload:

uvicorn main:app --reload

Estructura básica

from fastapi import FastAPI
from pydantic import BaseModel

app = FastAPI()

class Item(BaseModel):
	name: str
	price: float
	in_stock: bool = True

@app.get("/")
def read_root():
	return {"message": "Bienvenido a FastAPI"}

@app.post("/items/")
def create_item(item: Item):
	return {"item": item}

Rutas y métodos HTTP

• @app.get("/ruta") → GET
• @app.post("/ruta") → POST
• @app.put("/ruta") → PUT
• @app.delete("/ruta") → DELETE
• @app.patch("/ruta") → PATCH

Path parameters

@app.get("/items/{item_id}")
def read_item(item_id: int):
	return {"item_id": item_id}

Query parameters

@app.get("/search/")
def search(q: str = None, limit: int = 10):
	return {"q": q, "limit": limit}

Modelos y validación (Pydantic)

from pydantic import BaseModel, Field

class User(BaseModel):
	name: str = Field(..., example="Alice")
	age: int = Field(..., gt=0)
	email: str

Responses y status codes

from fastapi import Response, status

@app.get("/custom/")
def custom_response():
	return Response(content='{"msg":"OK"}', media_type="application/json", status_code=status.HTTP_202_ACCEPTED)

Dependencias (DI)

from fastapi import Depends, HTTPException, status

def verify_token(token: str):
	if token != "secreto":
		raise HTTPException(status_code=status.HTTP_403_FORBIDDEN, detail="Token inválido")
	return token

@app.get("/secure/")
def secure_route(token: str = Depends(verify_token)):
	return {"message": "Acceso permitido"}

Background tasks

from fastapi import BackgroundTasks

def write_log(msg: str):
	with open("log.txt", "a") as f:
		f.write(msg + "\n")

@app.post("/send/")
def send_message(background_tasks: BackgroundTasks, message: str):
	background_tasks.add_task(write_log, message)
	return {"status": "Mensaje encolado"}

WebSockets

from fastapi import WebSocket

@app.websocket("/ws")
async def websocket_endpoint(ws: WebSocket):
	await ws.accept()
	while True:
		data = await ws.receive_text()
		await ws.send_text(f"Recibido: {data}")

Eventos de la aplicación

@app.on_event("startup")
async def startup_event():
	print("App iniciada")

@app.on_event("shutdown")
async def shutdown_event():
	print("App cerrada")

Seguridad

• Autenticación: OAuth2, JWT, API Keys.
• Autorización: roles y scopes.
• Protección CORS y HTTPS en producción.

Testing

from fastapi.testclient import TestClient

client = TestClient(app)

def test_root():
	response = client.get("/")
	assert response.status_code == 200
	assert response.json() == {"message": "Bienvenido a FastAPI"}

ORMs y Bases de Datos

• SQLAlchemy, Tortoise ORM, SQLModel, MongoDB.
• Compatible con operaciones síncronas y asíncronas.
• Uso de sessions y context managers recomendados.

Buenas prácticas

• Versionar API: /v1/items/, /v2/items/.
• Mantener lógica fuera de endpoints.
• Usar response_model para validar salidas.
• Manejo centralizado de errores (HTTPException).
• Configuración con variables de entorno y pydantic-settings.
• Logging, métricas y monitoreo.

Despliegue

• Docker + Uvicorn/Gunicorn para producción.
• Escalar con Kubernetes o servicios en la nube (AWS, Azure, GCP).
• Monitoreo con Prometheus, Grafana, logs centralizados.

Plantillas y recursos

• FastAPI Full Stack Template
• Documentación oficial FastAPI
• Tutorial FastAPI - Kinsta
• YouTube: Documentación automática FastAPI

Notas rápidas

• Docs automáticos: /docs → Swagger, /redoc → Redoc.
• Tipado y validación automática gracias a Pydantic.
• Soporta async/await y tareas en background.
• WebSockets nativos y comunicación en tiempo real.
• Escalable y listo para producción con ASGI (Uvicorn/Starlette).