Concepto clave

Desplegar una API de FastAPI en un entorno simulado es como probar un prototipo de coche en un circuito cerrado antes de llevarlo a la carretera. Te permite validar que todos los componentes funcionan juntos correctamente, identificar problemas de integración y asegurar que la aplicación se comporta como se espera en condiciones controladas que imitan el entorno de producción.

En el desarrollo backend profesional, el despliegue en entornos simulados (staging, testing, development) es una fase crítica del ciclo de vida del software. No se trata solo de hacer que el código corra en otro servidor, sino de verificar la escalabilidad, seguridad, y resiliencia del sistema completo. Piensa en esto como el ensayo general de una obra de teatro: todos los actores (servicios, bases de datos, cachés) deben coordinarse perfectamente antes del estreno.

Este proceso incluye configurar infraestructura similar a producción (contenedores Docker, balanceadores de carga, bases de datos replicadas), ejecutar pruebas de integración y carga, y validar que las políticas de seguridad (CORS, autenticación, rate limiting) se aplican correctamente. Un despliegue exitoso en simulación reduce drásticamente los riesgos cuando la aplicación pasa a producción real.

Cómo funciona en la práctica

Vamos a desplegar nuestra API de gestión de contenidos en un entorno simulado usando Docker Compose. Este enfoque nos permite emular una arquitectura de microservicios donde cada componente (FastAPI, PostgreSQL, Redis) corre en su propio contenedor, comunicándose a través de una red virtual.

Paso 1: Preparar el Dockerfile para nuestra aplicación FastAPI. Creamos un archivo que define cómo construir la imagen de nuestra API, incluyendo dependencias, variables de entorno y el comando de inicio.

Paso 2: Configurar docker-compose.yml para orquestar los servicios. Definiremos tres servicios: la app FastAPI, la base de datos PostgreSQL para almacenar contenido, y Redis para caché de sesiones y rate limiting.

Paso 3: Ejecutar el entorno con docker-compose up y validar que todos los servicios estén corriendo y comunicándose. Usaremos herramientas como docker-compose logs para monitorear y curl o Postman para probar los endpoints.

Paso 4: Realizar pruebas de validación. Esto incluye verificar que la API responde correctamente, que la base de datos persiste datos entre reinicios, y que las características de seguridad (como JWT authentication) funcionan en el entorno simulado.

Codigo en accion

Primero, creamos el Dockerfile para nuestra aplicación FastAPI. Este es el "antes" donde solo tenemos el código local, y el "después" donde lo empaquetamos para despliegue.

# Dockerfile para API de Gestión de Contenidos
FROM python:3.11-slim

WORKDIR /app

# Copiar requirements e instalar dependencias
COPY requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt

# Copiar el código de la aplicación
COPY . .

# Exponer el puerto que usa FastAPI (por defecto 8000)
EXPOSE 8000

# Comando para ejecutar la aplicación con Uvicorn
CMD ["uvicorn", "main:app", "--host", "0.0.0.0", "--port", "8000", "--reload"]

Ahora, configuramos docker-compose.yml para orquestar los servicios. Este archivo define cómo interactúan los contenedores.

# docker-compose.yml
version: '3.8'

services:
  api:
    build: .
    container_name: fastapi_content_api
    ports:
      - "8000:8000"
    environment:
      - DATABASE_URL=postgresql://user:password@db:5432/contentdb
      - REDIS_URL=redis://redis:6379
      - SECRET_KEY=tu_clave_secreta_aqui
    depends_on:
      - db
      - redis
    networks:
      - app-network

  db:
    image: postgres:15
    container_name: postgres_db
    environment:
      POSTGRES_USER: user
      POSTGRES_PASSWORD: password
      POSTGRES_DB: contentdb
    volumes:
      - postgres_data:/var/lib/postgresql/data
    networks:
      - app-network

  redis:
    image: redis:7-alpine
    container_name: redis_cache
    networks:
      - app-network

networks:
  app-network:
    driver: bridge

volumes:
  postgres_data:

Errores comunes

No configurar variables de entorno correctamente: En producción simulada, olvidar definir variables como DATABASE_URL o SECRET_KEY puede causar fallos de conexión o vulnerabilidades. Siempre usa archivos .env o variables en docker-compose, y valida que estén accesibles en la aplicación.
Ignorar la persistencia de datos: Si no usas volúmenes Docker para bases de datos, los datos se pierden al reiniciar contenedores. Esto simula mal un entorno real donde la data debe sobrevivir reinicios. Configura volúmenes como en el ejemplo de PostgreSQL arriba.
No probar la comunicación entre servicios: Asumir que los contenedores se conectan automáticamente puede llevar a timeouts. Valida con comandos como docker-compose exec api ping db o implementa health checks en tu código.
Usar el modo debug en simulación: Ejecutar con --reload en Uvicorn es útil para desarrollo, pero en simulación deberías deshabilitarlo para emular mejor el rendimiento de producción. Ajusta el CMD en Dockerfile según el entorno.
Olvidar límites de recursos: En entornos simulados, no configurar límites de CPU/memoria para contenedores puede enmascarar problemas de escalabilidad. Usa deploy.resources en docker-compose para simular restricciones reales.

Checklist de dominio

La aplicación FastAPI se ejecuta correctamente en un contenedor Docker, respondiendo en el puerto configurado.
Los servicios de base de datos y caché (PostgreSQL, Redis) están desplegados y accesibles desde la aplicación.
Las variables de entorno están configuradas y se usan en el código para conexiones y configuraciones sensibles.
Se han realizado pruebas de integración que validan al menos 3 endpoints críticos (ej: crear contenido, autenticar usuario, listar contenidos).
Los datos persisten entre reinicios de contenedores, verificando que los volúmenes Docker funcionan.
La API maneja errores de forma consistente (ej: devuelve códigos HTTP apropiados para recursos no encontrados o errores de servidor).
Se ha simulado un escenario de carga básica (ej: 10-20 requests concurrentes) para identificar cuellos de botella.

Despliega y Valida la API en un Entorno Dockerizado Simulado

En este ejercicio, desplegarás la API de gestión de contenidos en un entorno simulado usando Docker Compose y validarás su funcionamiento completo.

Prepara tu proyecto: Asegúrate de tener un proyecto FastAPI con al menos dos endpoints (ej: GET /contents y POST /contents). Incluye un archivo requirements.txt con fastapi, uvicorn, sqlalchemy, psycopg2-binary, y redis.
Crea los archivos de configuración: Usa los ejemplos de código proporcionados en la lección para crear Dockerfile y docker-compose.yml en la raíz de tu proyecto. Ajusta las variables de entorno según tu configuración.
Construye y ejecuta los contenedores: En la terminal, navega a tu directorio del proyecto y ejecuta docker-compose up --build. Espera a que todos los servicios estén corriendo (ver logs para confirmar).
Valida la conectividad: Usa curl http://localhost:8000/docs o abre un navegador en esa URL para verificar que la API de FastAPI está activa y sirviendo la documentación interactiva.
Prueba endpoints críticos: Ejecuta al menos tres pruebas:
- POST a /contents con un JSON válido para crear un nuevo contenido.
- GET a /contents para listar los contenidos creados.
- Una prueba de error (ej: GET a un contenido inexistente) para verificar manejo de errores.
Verifica persistencia: Detén los contenedores con docker-compose down y luego reinícialos con docker-compose up. Confirma que los datos creados en el paso anterior aún están accesibles.
Documenta los resultados: Crea un breve informe con capturas de pantalla o salidas de terminal que muestren cada paso exitoso y cualquier problema encontrado.

Pistas

Si la API no se levanta, revisa los logs con 'docker-compose logs api' para ver errores de importación o configuración.
Para probar la conexión a PostgreSQL desde el contenedor de la API, usa 'docker-compose exec api python -c "import psycopg2; psycopg2.connect('postgresql://user:password@db:5432/contentdb')"'.
Si los datos no persisten, asegúrate de que el volumen 'postgres_data' esté definido en docker-compose.yml y no se esté usando :ro (solo lectura).

Evalua tu comprension

Completa el quiz interactivo de arriba para ganar XP.

Desplegar y Validar el Proyecto en un Entorno Simulado