Introducción a FastAPI

¿Qué es FastAPI y por qué usarlo?

FastAPI es un framework web moderno para crear APIs con Python que se ha convertido en una de las opciones más populares para desarrolladores que buscan construir servicios web eficientes. Fue creado por Sebastián Ramirez y está diseñado específicamente para aprovechar las características más avanzadas de Python.

Qué es un framework web

Antes de profundizar en FastAPI, es importante entender qué es un framework web. Imagina que quieres construir una casa: podrías fabricar cada ladrillo, cada ventana y cada puerta desde cero, pero sería mucho más eficiente usar materiales prefabricados y herramientas especializadas.

Un framework web funciona de manera similar. Proporciona una estructura base y herramientas predefinidas que te permiten crear aplicaciones web sin tener que programar desde cero todas las funcionalidades básicas como el manejo de peticiones HTTP, el enrutamiento de URLs o la gestión de respuestas.

Características principales de FastAPI

FastAPI destaca por varias características que lo hacen especialmente atractivo para desarrolladores:

Facilidad de uso: La sintaxis de FastAPI es intuitiva y similar al Python que ya conoces. No necesitas aprender conceptos complicados para empezar a crear tu primera API.

Documentación automática: Una de las características más impresionantes es que FastAPI genera automáticamente documentación interactiva para tu API. Esto significa que cada vez que creas un endpoint, FastAPI crea una página web donde puedes probar tu API directamente desde el navegador.

Validación automática: FastAPI verifica automáticamente que los datos que recibe tu API sean correctos. Si alguien envía datos incorrectos, el framework responde con un error claro explicando qué está mal.

Basado en estándares: Utiliza estándares web modernos como OpenAPI y JSON Schema, lo que significa que tu API será compatible con muchas herramientas y servicios existentes.

Por qué elegir FastAPI

Existen varios motivos por los que FastAPI se ha vuelto tan popular entre desarrolladores:

Curva de aprendizaje suave: Si ya conoces Python básico, puedes empezar a crear APIs funcionales en cuestión de minutos. La sintaxis es clara y no requiere configuraciones complejas.

Productividad alta: Las características automáticas de FastAPI (documentación, validación, serialización) te permiten concentrarte en la lógica de tu aplicación en lugar de en tareas repetitivas.

Rendimiento excelente: FastAPI está construido sobre tecnologías modernas que lo hacen uno de los frameworks Python más rápidos disponibles.

Comunidad activa: Cuenta con una comunidad creciente de desarrolladores que contribuyen con ejemplos, tutoriales y extensiones.

Casos de uso típicos

FastAPI es especialmente útil para crear:

• APIs REST para aplicaciones web y móviles
• Microservicios que se comunican entre diferentes partes de una aplicación
• Servicios de datos que procesan y entregan información
• Prototipos rápidos para probar ideas de negocio

La versatilidad de FastAPI lo convierte en una excelente opción tanto para proyectos pequeños como para aplicaciones empresariales complejas. Su diseño modular permite empezar con algo simple y expandir la funcionalidad según las necesidades del proyecto.

Primer ejemplo ejecutable

El siguiente código define una API mínima con dos endpoints: uno que devuelve un saludo y otro que recibe un cliente y devuelve una puntuación de riesgo simple. Con este bloque el framework arranca, valida las entradas, serializa la salida a JSON y pública la documentación en /docs.

from fastapi import FastAPI
from pydantic import BaseModel, Field

app = FastAPI(title="Primera API", version="1.0")

class Cliente(BaseModel):
    nombre: str = Field(min_length=1)
    ingresos: float = Field(ge=0)
    deuda: float = Field(ge=0)

@app.get("/")
async def raiz() -> dict:
    return {"mensaje": "API activa"}

@app.post("/riesgo")
async def calcular_riesgo(cliente: Cliente) -> dict:
    ratio = cliente.deuda / max(cliente.ingresos, 1.0)
    nivel = "alto" if ratio > 0.5 else "medio" if ratio > 0.2 else "bajo"
    return {"cliente": cliente.nombre, "ratio": round(ratio, 3), "riesgo": nivel}

Ejecutar el servicio en local:

uvicorn main:app --reload --port 8000

Al navegar a http://localhost:8000/docs aparece la interfaz Swagger donde se puede probar el endpoint /riesgo introduciendo valores y recibir la respuesta sin necesidad de clientes HTTP externos.

Arquitectura interna

FastAPI se apoya en Starlette (capa ASGI, enrutamiento, middleware) y Pydantic v2 (validación, serialización), y añade el sistema de dependencias y la generación automática de OpenAPI 3.1.

flowchart TB
    request[HTTP request] --> asgi["Uvicorn / Hypercorn"]
    asgi --> starlette["Starlette router + middleware"]
    starlette --> validation[Pydantic v2 validation]
    validation --> di[Dependency Injection]
    di --> endpoint[Endpoint async def]
    endpoint --> serializer[Pydantic serializer]
    serializer --> response[JSON response]
    starlette --> docs[OpenAPI 3.1 autogenerado]

Caso B2B: microservicio de predicción de churn

Un equipo de retención de clientes de un operador telco necesita puntuar a diario la probabilidad de abandono de cada cliente. El equipo de datos entrena un modelo scikit-learn, lo serializa con joblib y expone un endpoint FastAPI que integra el CRM. La documentación automática en /docs permite que el equipo de CRM pruebe la API sin instalar Postman, y la validación Pydantic rechaza payloads mal formados antes de llegar al modelo.

from fastapi import FastAPI, HTTPException
from pydantic import BaseModel, Field
import joblib

app = FastAPI(title="Churn scoring")
modelo = joblib.load("modelo_churn.joblib")

class Cliente(BaseModel):
    meses_contrato: int = Field(ge=0)
    gasto_mensual: float = Field(ge=0)
    incidencias_30d: int = Field(ge=0)

@app.post("/churn-score")
async def puntuar(cliente: Cliente) -> dict:
    try:
        proba = modelo.predict_proba([[cliente.meses_contrato,
                                        cliente.gasto_mensual,
                                        cliente.incidencias_30d]])[0][1]
    except Exception as exc:
        raise HTTPException(status_code=500, detail=f"Error inferencia: {exc}")
    return {"probabilidad_abandono": round(float(proba), 4)}

Este patrón (validación Pydantic, carga de modelo en arranque, respuesta tipada) es el esqueleto recurrente de los servicios de inferencia ML en empresa.

En las próximas lecciones veremos cómo instalar FastAPI y crear nuestra primera API funcional, pero por ahora es importante que entiendas que FastAPI es una herramienta que simplifica significativamente el proceso de crear servicios web con Python.