Curso 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.

Arquitectura de FastAPI

FastAPI se apoya en dos dependencias principales: Starlette aporta el servidor web ASGI, el enrutamiento y el soporte para WebSockets; Pydantic v2 aporta la validación y serialización de datos con anotaciones de tipo. Sobre ellos, FastAPI añade el sistema de dependencias, la generación automática de documentación OpenAPI 3.1 y las utilidades de seguridad.

flowchart TB
    subgraph cliente[Cliente HTTP]
        Browser[Navegador / curl / Postman]
    end
    subgraph servidor[Proceso ASGI]
        Uvicorn[Uvicorn / Hypercorn]
        subgraph fastapi_app[FastAPI application]
            Starlette[Starlette: routing, middleware, WebSockets]
            Pydantic[Pydantic v2: validación y serialización]
            DI[Sistema de dependencias]
            OpenAPI[OpenAPI 3.1 autogenerado]
        end
    end
    subgraph infra[Infraestructura]
        DB[(PostgreSQL / SQLite)]
        Redis[(Redis / broker)]
    end
    Browser -->|HTTP/1.1, HTTP/2, WS| Uvicorn
    Uvicorn --> Starlette
    Starlette --> DI
    DI --> Pydantic
    DI --> DB
    DI --> Redis
    Starlette --> OpenAPI

¿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, EmailStr, Field

app = FastAPI()

class Usuario(BaseModel):
    nombre: str = Field(min_length=1, max_length=80)
    edad: int = Field(ge=0, le=130)
    email: EmailStr

@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 typing import Annotated
from fastapi import FastAPI, Depends
from sqlalchemy.ext.asyncio import AsyncSession
from database import get_db

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

DbSession = Annotated[AsyncSession, Depends(get_db)]

@app.get("/productos/{producto_id}")
async def obtener_producto(producto_id: int, db: DbSession):
    # Lógica de consulta asíncrona a la 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 válida según los tipos especificados, generando errores descriptivos cuando los datos no cumplen con los requisitos.

from typing import Annotated
from fastapi import FastAPI, Query

app = FastAPI()

@app.get("/productos/")
async def listar_productos(
    categoria: Annotated[str | None, Query(max_length=40)] = None,
    precio_min: Annotated[float, Query(ge=0)] = 0,
    precio_max: Annotated[float, Query(le=10000)] = 1000,
    limite: Annotated[int, Query(le=100)] = 10,
):
    # 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 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 String
from sqlalchemy.orm import DeclarativeBase, Mapped, mapped_column
from pydantic import BaseModel, ConfigDict

class Base(DeclarativeBase):
    pass

class ProductoModel(Base):
    __tablename__ = "productos"
    id: Mapped[int] = mapped_column(primary_key=True)
    nombre: Mapped[str] = mapped_column(String(120))
    precio: Mapped[float]

class ProductoSchema(BaseModel):
    model_config = ConfigDict(from_attributes=True)

    id: int
    nombre: str
    precio: float

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.

import asyncio
from contextlib import asynccontextmanager
from fastapi import BackgroundTasks, FastAPI

@asynccontextmanager
async def lifespan(app: FastAPI):
    # Ciclo de arranque: pool de conexiones, caches, consumidores, etc.
    app.state.ready = True
    yield
    # Ciclo de cierre: liberar recursos
    app.state.ready = False

app = FastAPI(lifespan=lifespan)

async def procesar_archivo(nombre_archivo: str) -> None:
    # Simulación de procesamiento pesado no bloqueante
    await asyncio.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 typing import Annotated
from fastapi import APIRouter, Depends
from sqlalchemy.ext.asyncio import AsyncSession
from database import get_db
from auth import get_current_user

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

DbSession = Annotated[AsyncSession, Depends(get_db)]
CurrentUser = Annotated[dict, Depends(get_current_user)]

@router.get("/productos/")
async def listar_productos(db: DbSession, usuario: CurrentUser):
    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.