FastAPI: cómo crear APIs rápidamente.

En el mundo actual en el que vivimos, donde el tiempo de implementación y de puesta en producción cada vez es menor, necesitamos herramientas que nos permitan crear de forma rápida y eficiente nuestras ideas. Uno de los factores que, bajo mi punto de vista, ha ayudado mucho en la utilización de este framework es la magnífica documentación que tiene. Es útil incluso para conocer sobre el tipado en Python, muy detallada y fácil de consultar.

El framework que no quería escribir Sebastián Ramírez

Su creador, Sebastián Ramírez, pasó años evitando crear un nuevo framework. Su filosofía era simple: buscar la herramienta que mejor resolviera un problema y usarla, contribuyendo a ella si fuera necesario. Trabajaba creando APIs y, a pesar de probar distintos frameworks en distintos lenguajes de programación, siempre encontraba problemas: configuraciones poco intuitivas, plugins en cascada con combinaciones frágiles, falta de validaciones claras…

En ese momento aparecen las anotaciones de tipo (type hints) en Python 3.6 e, inspirado en cómo Pydantic usaba esta información para generar serializadores y en otras herramientas como el autocompletado de DRF, decide empezar con FastAPI.

Su objetivo principal era que los equipos de desarrollo obtuvieran el mejor código posible al usar FastAPI de la manera más sencilla, con beneficios como autocompletado y errores en línea.

¿Qué es FastAPI?

FastAPI es, en esencia, un micro-framework de desarrollo web moderno y de alto rendimiento para construir APIs en Python. Su filosofía se centra en la "experiencia del equipo de desarrollo", buscando que sea lo más intuitivo y eficiente posible. Como resultado, FastAPI ha crecido exponencialmente, posicionándose como el tercer framework web de Python (detrás de Flask y Django) y, sin duda, uno de los más populares actualmente.

La clave de su diseño es la simplicidad a través de la estandarización basada en estándares abiertos como OpenAPI y JSON Schema, y explota al máximo las anotaciones de tipo de Python y Pydantic. La promesa es clara: "cuanto más código FastAPI se escribe, menos código de API hay que escribir". Así te puedes concentrar en la lógica de negocio y dejar que el framework se encargue de la validación de datos, la serialización y la documentación.

Un enfoque modular y abierto

Aunque no se mencionan explícitamente los principios SOLID, FastAPI encarna sus ideas a través de su diseño modular, su preferencia por la integración externa y la estandarización. Sebastián evita integrar funcionalidades innecesarias directamente en el core del framework. En lugar de crear plugins o componentes específicos de FastAPI para cada necesidad, la filosofía es documentar cómo usar herramientas de terceros (como librerías de autenticación o bases de datos) de manera que se integren fluidamente con el framework.

Por ejemplo, FastAPI es agnóstico a la base de datos: no viene con un ORM propio, lo que permite usarlo con cualquier base de datos SQL o NoSQL. Aunque Sebastián creó SQLModel para facilitar la interacción con bases de datos SQL de manera compatible con FastAPI y Pydantic, FastAPI no depende de SQLModel. Esto permite que cada componente mantenga su independencia y propósito claro, facilitando el mantenimiento y la flexibilidad. Si una parte puede ser independiente, es mejor mantenerla así.

¡Escribe menos, consigue más!

Una de las mayores ventajas de FastAPI es la rapidez con la que puedes tener una API funcional. Te permite concentrarte en la lógica de negocio, no en la infraestructura.

Veamos un ejemplo de lo fácil que es empezar:

from fastapi import FastAPI # 1. Importamos la clase principal FastAPI

app = FastAPI() # 2. Creamos una instancia de FastAPI, nuestra aplicación

@app.get("/") # 3. Definimos una ruta GET en la raíz de nuestra API
def read_root(): # 4. Función que se ejecutará cuando se acceda a esta ruta
    # 5. Devolvemos un diccionario de Python. FastAPI lo convierte automáticamente a JSON.
    return {"mensaje": "¡Hola, mundo de FastAPI!"}

@app.get("/items/{item_id}") # 6. Ruta con un parámetro de ruta: item_id
def read_item(item_id: int, q: str | None = None):
    """
item_id se espera como entero, 'q' como string opcional
     FastAPI automáticamente valida los tipos y detecta si es parámetro de ruta o de consulta (query)
    """
    return {"item_id": item_id, "q": q}

¿Qué conseguimos con este poco código?

• Simplicidad: una API completa con solo unas pocas líneas.
• Decoradores intuitivos: @app.get() asocia la función a una ruta HTTP GET.
• Conversión automática a JSON: los diccionarios Python se serializan automáticamente.
• Validación y extracción de parámetros: FastAPI automáticamente detecta item_id como un parámetro de ruta y q como un parámetro de consulta (query parameter) gracias a las anotaciones de tipo. Si el tipo no coincide, FastAPI devolverá un error.

La magia de la validación de datos

FastAPI utiliza Pydantic y las anotaciones de tipos estándar de Python para la validación y serialización de datos, lo que es una de sus características más poderosas.

from fastapi import FastAPI
from pydantic import BaseModel
from typing import List

app = FastAPI()

# 1. Definimos un modelo de datos con Pydantic. Esto nos permite estructurar el JSON esperado.
class Food(BaseModel):
    name: str # El nombre de la comida, requerido (no tiene valor por defecto)
    ingredients: List[str] # Una lista de strings para los ingredientes
    price: float = 0.0 # El precio, opcional (valor por defecto 0.0)

@app.post("/foods/") # 2. Usamos POST para recibir datos en el cuerpo de la solicitud
def create_food(food: Food) -> Food: # 3. FastAPI espera un cuerpo JSON que coincida con nuestro modelo 'Food'
    # 4. Si el JSON entrante no cumple con el modelo 'Food', FastAPI lo rechazará automáticamente
    return food

Beneficios de esta aproximación

• Validación automática. Si los datos que recibe la API no coinciden con la definición del modelo Food, FastAPI automáticamente devolverá un error detallado, indicando exactamente dónde está el problema.
• Autocompletado y detección de errores en el editor. Gracias a las anotaciones de tipo, tu editor de código (VS Code, PyCharm...) sabe el tipo de cada variable y atributo, ofreciéndote autocompletado en todas partes y detectando errores antes de que ejecutes el código.
• Serialización automática. FastAPI convierte los datos entre Python y JSON de forma bidireccional.
• Validación adicional. Puedes añadir reglas más complejas usando pydantic.Field o fastapi.Query, fastapi.Path, fastapi.Body… entre otros métodos.

La documentación automática e interactiva

Una de las características más aclamadas de FastAPI es su capacidad para generar documentación interactiva de forma automática sin que tengas que escribir una sola línea adicional de código para ello. Accediendo a la ruta /docs (Swagger UI) o /redoc de tu API, obtendrás interfaces que:

• Muestran todos tus endpoints y sus métodos HTTP.
• Describen los tipos de datos esperados para cada parámetro y cuerpo de mensaje.
• Permiten probar tus APIs en vivo directamente desde el navegador, enviando solicitudes y viendo las respuestas.

Esto es posible porque FastAPI está construido sobre estándares abiertos como OpenAPI y JSON Schema. Esto es una decisión crucial, ya que elimina la necesidad de escribir y mantener documentación externa que fácilmente puede quedar desactualizada. La documentación siempre está sincronizada con tu código.

La comunidad y el futuro de FastAPI

La comunidad de FastAPI es conocida por ser muy amigable y acogedora, manteniendo un espíritu de ayuda mutua. Si deseas contribuir, hay varias formas de hacerlo, incluso si estás empezando:

1. Ayudar a otros usuarios en GitHub Discussions

Esta es una de las formas más valiosas de contribuir, ya que consume mucho tiempo del mantenedor. Incluso han creado la sección "FastAPI Experts" para reconocer a quienes ayudan constantemente.

2. Traducir la documentación.

La documentación de FastAPI está en constante expansión y se busca que esté disponible en más idiomas. Contribuir con traducciones o revisar las existentes es muy útil y un excelente modo de aprender el framework a fondo.

3. Mejorar la documentación

Corregir errores gramaticales o mejorar las explicaciones de conceptos son contribuciones valiosas, especialmente para los nuevos usuarios.

Recientemente, el desarrollo de FastAPI fue patrocinado por Sequoia OS fellowship, gracias a lo cual han iniciado una empresa FastAPICloud para facilitar el despliegue de aplicaciones basadas en FastAPI, siguiendo las premisas del framework. Su objetivo es que con un solo comando (fastapi deploy), la plataforma se encargará del autoscaling, HTTPS y toda la complejidad de la infraestructura, liberando al equipo de desarrollo para que se enfoque solo en la lógica de negocio.

Conclusión: un framework que nos cuida

FastAPI es más que un framework; es una herramienta que simplifica la vida del equipo de desarrollo al automatizar tareas tediosas como la validación de datos y la generación de documentación. Te impulsa a escribir mejor Python al aprovechar los tipos, y te protege de errores comunes antes de que lleguen a producción. Su filosofía de "Developer Experience First" es evidente en cada detalle.

Si estás buscando una solución robusta, rápida y amigable para tus proyectos de API en Python. Su futuro parece prometedor por el apoyo del sector y la reciente creación de una empresa que permita seguir impulsando el desarrollo del framework.

Referencias

• Pybites Podcast, Sebastián Ramírez
• Entrevista a Sebastián Ramírez, Platzi
• Open Source con FastAPI's @tiangolo, GitHub
• Modern Python through FastAPI and friends - Sebastián Ramírez, Python Chile
• Charla FastAPI + OpenSource con Sebastián Ramírez, FIUBA - Ingeniería del Software 2