FastAPI

FastAPI es un framework web moderno y de alto rendimiento para construir APIs con Python, basado en las anotaciones de tipo estándar de Python. Desarrollado por Sebastián Ramirez, FastAPI combina la facilidad de uso de frameworks como Flask con el rendimiento de frameworks asíncronos como Starlette, ofreciendo una experiencia de desarrollo excepcional tanto para principiantes como para desarrolladores experimentados.

¿Qué hace especial a FastAPI?

FastAPI se distingue por su arquitectura asíncrona nativa, que permite manejar miles de conexiones concurrentes con un consumo mínimo de recursos. A diferencia de frameworks tradicionales que procesan las peticiones de forma secuencial, FastAPI aprovecha las capacidades asíncronas de Python para ofrecer un rendimiento comparable a frameworks escritos en Go o Node.js.

La validación automática de datos es otra característica fundamental. FastAPI utiliza Pydantic para validar automáticamente los datos de entrada y salida, eliminando la necesidad de escribir código de validación manual. Esto no solo reduce errores, sino que también mejora la productividad del desarrollador significativamente.

from fastapi import FastAPI
from pydantic import BaseModel

app = FastAPI()

class Usuario(BaseModel):
    nombre: str
    edad: int
    email: str

@app.post("/usuarios/")
async def crear_usuario(usuario: Usuario):
    return {"mensaje": f"Usuario {usuario.nombre} creado correctamente"}

Ecosistema y herramientas integradas

FastAPI incluye documentación automática mediante Swagger UI y ReDoc, generada directamente desde el código fuente. Esta documentación interactiva permite a los desarrolladores y consumidores de la API probar endpoints directamente desde el navegador, facilitando tanto el desarrollo como la integración.

El framework se integra perfectamente con el ecosistema Python moderno. Utiliza Starlette como base para el manejo de peticiones HTTP, Pydantic para la validación de datos, y es compatible con herramientas populares como SQLAlchemy para bases de datos, Jinja2 para templates, y bibliotecas de autenticación como OAuth2.

from fastapi import FastAPI, Depends
from sqlalchemy.orm import Session
from database import get_db

app = FastAPI(title="Mi API", version="1.0.0")

@app.get("/productos/{producto_id}")
async def obtener_producto(producto_id: int, db: Session = Depends(get_db)):
    # Lógica de consulta a base de datos
    return {"id": producto_id, "nombre": "Producto ejemplo"}

Desarrollo de APIs REST

FastAPI facilita la creación de APIs REST completas siguiendo las mejores prácticas de la industria. El framework maneja automáticamente la serialización JSON, códigos de estado HTTP, y cabeceras de respuesta, permitiendo al desarrollador concentrarse en la lógica de negocio.

Los path parameters y query parameters se definen de forma intuitiva utilizando las anotaciones de tipo de Python. FastAPI extrae automáticamente estos parámetros de la URL y los valida según los tipos especificados, generando errores descriptivos cuando los datos no cumplen con los requisitos.

from typing import Optional
from fastapi import FastAPI, Query

app = FastAPI()

@app.get("/productos/")
async def listar_productos(
    categoria: Optional[str] = None,
    precio_min: float = Query(0, ge=0),
    precio_max: float = Query(1000, le=10000),
    limite: int = Query(10, le=100)
):
    # Lógica de filtrado y paginación
    return {"productos": [], "total": 0}

Integración con bases de datos

La integración con SQLAlchemy permite crear aplicaciones robustas con persistencia de datos. FastAPI se combina perfectamente con el patrón ORM, facilitando la definición de modelos de datos, relaciones entre tablas, y operaciones CRUD complejas.

Los schemas de Pydantic actúan como una capa de validación entre los modelos de base de datos y las respuestas de la API, asegurando que los datos cumplan con el formato esperado antes de ser enviados al cliente.

from sqlalchemy import Column, Integer, String
from sqlalchemy.ext.declarative import declarative_base
from pydantic import BaseModel

Base = declarative_base()

class ProductoModel(Base):
    __tablename__ = "productos"
    id = Column(Integer, primary_key=True)
    nombre = Column(String, nullable=False)
    precio = Column(Integer, nullable=False)

class ProductoSchema(BaseModel):
    id: int
    nombre: str
    precio: float
    
    class Config:
        orm_mode = True

Programación asíncrona

La programación asíncrona es fundamental en FastAPI. El framework permite definir funciones asíncronas que pueden manejar operaciones de I/O sin bloquear el hilo principal, mejorando significativamente el rendimiento en aplicaciones que realizan consultas a bases de datos, llamadas a APIs externas, o procesan archivos.

Las background tasks permiten ejecutar tareas pesadas en segundo plano sin afectar el tiempo de respuesta de la API. Esto es especialmente útil para operaciones como envío de emails, procesamiento de imágenes, o generación de reportes.

from fastapi import FastAPI, BackgroundTasks

app = FastAPI()

def procesar_archivo(nombre_archivo: str):
    # Simulación de procesamiento pesado
    import time
    time.sleep(10)
    print(f"Archivo {nombre_archivo} procesado")

@app.post("/subir-archivo/")
async def subir_archivo(background_tasks: BackgroundTasks, archivo: str):
    background_tasks.add_task(procesar_archivo, archivo)
    return {"mensaje": "Archivo recibido, procesando en segundo plano"}

Seguridad

FastAPI incluye soporte nativo para OAuth2 y JWT, facilitando la implementación de sistemas de autenticación seguros. El framework maneja automáticamente la validación de tokens, scopes de permisos, y integración con proveedores de identidad externos.

El sistema de dependencias permite crear middleware de seguridad reutilizable que se puede aplicar a endpoints específicos o grupos de rutas, manteniendo el código limpio y organizando las responsabilidades de seguridad de forma clara.

from fastapi import FastAPI, Depends, HTTPException, status
from fastapi.security import HTTPBearer, HTTPAuthorizationCredentials

app = FastAPI()
security = HTTPBearer()

async def verificar_token(credentials: HTTPAuthorizationCredentials = Depends(security)):
    if credentials.credentials != "token-valido":
        raise HTTPException(
            status_code=status.HTTP_401_UNAUTHORIZED,
            detail="Token inválido"
        )
    return credentials.credentials

@app.get("/protegido/")
async def endpoint_protegido(token: str = Depends(verificar_token)):
    return {"mensaje": "Acceso autorizado", "token": token}

Organización

Para aplicaciones grandes, FastAPI ofrece APIRouter que permite organizar endpoints en módulos separados. Esta funcionalidad facilita el mantenimiento del código y permite que equipos de desarrollo trabajen en diferentes partes de la aplicación de forma independiente.

La inyección de dependencias es un patrón fundamental en FastAPI que promueve código testeable y mantenible. Las dependencias pueden ser funciones simples, clases, o incluso otras dependencias, creando un sistema flexible para compartir lógica común entre endpoints.

from fastapi import APIRouter, Depends
from database import get_db
from auth import get_current_user

router = APIRouter(prefix="/api/v1", tags=["productos"])

@router.get("/productos/")
async def listar_productos(
    db: Session = Depends(get_db),
    usuario: dict = Depends(get_current_user)
):
    return {"productos": [], "usuario": usuario["username"]}

FastAPI representa la evolución natural del desarrollo de APIs en Python, combinando las mejores características de frameworks anteriores con las capacidades modernas del lenguaje. Su enfoque en la productividad del desarrollador, el rendimiento, y la calidad del código lo convierte en la elección ideal para proyectos que requieren APIs robustas, escalables y fáciles de mantener.