Por qué elegí FastAPI para mis APIs en Python
3 min de lectura
Tabla de contenidos
## Mi camino hacia FastAPI
Después de años trabajando con Django REST Framework y Flask, decidí probar FastAPI para un nuevo proyecto. Lo que comenzó como un experimento se convirtió en mi elección predeterminada para cualquier API en Python.
## Las razones de mi elección
### 1. Rendimiento excepcional
FastAPI está construido sobre **Starlette** para la parte web y **Pydantic** para la validación de datos. Esta combinación lo convierte en uno de los frameworks más rápidos disponibles:
- Comparable en rendimiento a Node.js y Go
- Soporte nativo para programación asíncrona
- Ideal para aplicaciones de alto tráfico
```python
from fastapi import FastAPI
import asyncio
app = FastAPI()
@app.get("/usuarios/{usuario_id}")
async def obtener_usuario(usuario_id: int):
# Operaciones asíncronas sin bloquear
usuario = await obtener_usuario_db(usuario_id)
return usuario
```
### 2. Documentación automática
Una de las características que más valoro es la generación automática de documentación interactiva:
- **Swagger UI** disponible en `/docs`
- **ReDoc** disponible en `/redoc`
- Siempre actualizada con tu código
Esto elimina la necesidad de mantener documentación separada y facilita enormemente la colaboración con equipos frontend.
### 3. Validación de datos con Pydantic
Pydantic hace que la validación sea elegante y type-safe:
```python
from pydantic import BaseModel, EmailStr
from typing import Optional
from datetime import datetime
class UsuarioCrear(BaseModel):
nombre: str
email: EmailStr
edad: int
biografia: Optional[str] = None
class UsuarioRespuesta(BaseModel):
id: int
nombre: str
email: str
creado_en: datetime
class Config:
from_attributes = True
```
### 4. Integración perfecta con PostgreSQL
FastAPI se integra maravillosamente con bases de datos, especialmente PostgreSQL a través de SQLAlchemy:
```python
from sqlalchemy import Column, Integer, String, DateTime
from sqlalchemy.ext.declarative import declarative_base
Base = declarative_base()
class Usuario(Base):
__tablename__ = "usuarios"
id = Column(Integer, primary_key=True, index=True)
nombre = Column(String, index=True)
email = Column(String, unique=True, index=True)
creado_en = Column(DateTime, default=datetime.utcnow)
```
## Mi estructura de proyecto típica
Después de varios proyectos, he llegado a esta estructura que me funciona muy bien:
```
backend/
├── app/
│ ├── api/
│ │ ├── endpoints/
│ │ │ ├── usuarios.py
│ │ │ └── productos.py
│ │ └── router.py
│ ├── core/
│ │ ├── config.py
│ │ └── security.py
│ ├── db/
│ │ └── session.py
│ ├── models/
│ ├── schemas/
│ └── main.py
└── docker-compose.yml
```
## Comparación honesta
| Aspecto | FastAPI | Django REST | Flask |
|---------|---------|-------------|-------|
| Rendimiento | Excelente | Bueno | Bueno |
| Curva aprendizaje | Suave | Moderada | Suave |
| Documentación auto | Sí | Parcial | No |
| Validación | Pydantic | Serializers | Manual |
| Async nativo | Sí | Parcial | No |
## ¿Cuándo NO usar FastAPI?
Siendo honesto, FastAPI no es la mejor opción para todo:
- **Aplicaciones monolíticas completas**: Django sigue siendo rey aquí
- **Proyectos legacy**: Si ya tienes Flask/Django funcionando, no migres sin razón
- **Equipos sin experiencia en type hints**: La curva puede ser más pronunciada
## Conclusión
FastAPI ha transformado la forma en que desarrollo APIs. La combinación de rendimiento, documentación automática y una excelente experiencia de desarrollo lo convierten en mi primera opción para nuevos proyectos.
Si estás buscando un framework moderno para tus APIs en Python, te animo a darle una oportunidad. La documentación oficial es excelente y la comunidad está creciendo rápidamente.
**¿Qué framework usas para tus APIs? ¡Me encantaría conocer tu experiencia!**
