Si estás buscando una forma eficiente y escalable de desplegar tus aplicaciones web, FastAPI y Docker Compose forman una combinación perfecta. En esta guía, te mostraré cómo configurar y desplegar una aplicación FastAPI utilizando Docker Compose, explicando cada paso con ejemplos prácticos y consejos que he acumulado tras trabajar con estas tecnologías en proyectos reales.
¿Qué es FastAPI?
FastAPI es un moderno framework de Python para construir APIs rápidas, seguras y fáciles de mantener. Se centra en la simplicidad y el rendimiento, ofreciendo:
- Validación automática de datos.
- Documentación interactiva automática (Swagger UI).
- Excelente rendimiento, comparable a frameworks como NodeJS o Go.
En mi experiencia, FastAPI es ideal cuando buscas rapidez en desarrollo sin sacrificar robustez y escalabilidad.
¿Qué es Docker Compose?
Docker Compose es una herramienta que permite definir y ejecutar aplicaciones multicontenedor en Docker mediante un archivo YAML llamado docker-compose.yml. Te ayuda a orquestar y controlar múltiples servicios (como bases de datos, caches y el backend) desde un solo lugar.
He usado Docker Compose para simplificar entornos de desarrollo y producción, especialmente cuando la aplicación interactúa con varias dependencias externas, facilitando levantar y detener todo el stack con comandos simples.
Ventajas de usar FastAPI con Docker Compose
Combinar FastAPI con Docker Compose aporta:
- Entornos reproducibles: tu app y sus dependencias quedan encapsuladas y versionadas.
- Fácil escalabilidad: añadir más instancias o servicios es simple.
- Aislamiento: no hay conflictos locales ni dependencias sueltas.
- Facilidad de mantenimiento: actualizar o cambiar componentes sin afectar otros servicios.
Personalmente, migrar mis proyectos a esta arquitectura redujo significativamente problemas en despliegues y mejoró la colaboración entre equipos.
Cómo crear el Dockerfile para una app FastAPI
Para dockerizar nuestra aplicación FastAPI, debemos crear un Dockerfile que defina cómo construir la imagen de la app.
Ejemplo básico y funcional:
# Usa una imagen oficial de Python ligera
FROM python:3.11-slim
# Establece el directorio de trabajo dentro del contenedor
WORKDIR /app
# Copia el archivo de requerimientos y lo instala
COPY requirements.txt .
RUN pip install –no-cache-dir -r requirements.txt
# Copia todo el código fuente
COPY . .
# Expone el puerto en que la app escuchará
EXPOSE 8000
# Comando para arrancar la aplicación
CMD [«uvicorn», «main:app», «–host», «0.0.0.0», «–port», «8000»]
Un par de consejos clave para optimizar:
- Utiliza imágenes ligeras (
python:3.11-slim). - Copia primero
requirements.txtpara aprovechar cache de Docker y acelerar nuevas compilaciones. - Expón el puerto 8000, que es por defecto en FastAPI.
En mi último proyecto, este enfoque mínimo me permitió modificar el backend y levantar un entorno local en segundos, mejorando la productividad.
Cómo crear el archivo docker-compose.yml para arrancar FastAPI y base de datos
Una aplicación real suele depender de bases de datos u otros servicios. Aquí te muestro un ejemplo docker-compose.yml que levanta FastAPI junto con PostgreSQL:
version: «3.9»
services:
web:
build: .
ports:
– «8000:8000»
volumes:
– .:/app
environment:
– DATABASE_URL=postgresql://user:password@db:5432/mydatabase
depends_on:
– db
db:
image: postgres:15-alpine
environment:
POSTGRES_USER: user
POSTGRES_PASSWORD: password
POSTGRES_DB: mydatabase
volumes:
– pgdata:/var/lib/postgresql/data
volumes:
pgdata:
Este archivo realiza:
- Construye la imagen
weba partir del Dockerfile local. - Mapea el puerto 8000 para acceso externo.
- Usa un volumen local para que los cambios en código se reflejen al instante.
- Declara dependencia del servicio
db(PostgreSQL). - Define variables de entorno para la conexión a base de datos.
Con esta estructura, Docker Compose orquesta los dos servicios permitiendo un flujo de desarrollo fluido y un despliegue replicable. En mis casos, gestionar las variables de entorno en .env también aporta flexibilidad y seguridad.
Comandos para levantar, parar y escalar servicios con Docker Compose
Docker Compose facilita el manejo del entorno con comandos sencillos:
- Levantar servicios:
docker-compose up -d
- Ver logs en tiempo real:
docker-compose logs -f
- Parar y remover servicios:
docker-compose down - Escalar servicios (por ejemplo, 3 instancias del backend):
docker-compose up -d –scale web=3
Estos comandos son básicos pero cruciales para administrar tu entorno. En práctica, escalando tu backend y desacoplando servicios aumenta la resiliencia y capacidad de tu app.
Tips y buenas prácticas para optimización, seguridad y mantenimiento FastAPI con Docker Compose
¿Quieres profundizar y dominar estas herramientas para transformar tu carrera profesional? Descubre el Bootcamp Aprender a Programar desde Cero de KeepCoding, donde te guiarán desde cero para convertirte en un experto desarrollador backend con FastAPI, Docker, y más.
FastAPI con Docker Compose usa variables de entorno gestiona configuraciones con archivos .env y env_file para no hardcodear credenciales.
- Persistencia: Usa volúmenes Docker para las bases de datos y archivos que deban conservarse.
- Multistage builds: Optimiza imágenes Docker para producción reduciendo tamaño y tiempos.
- Seguridad: No incluyas credenciales en imágenes ni repositorios; usa Docker Secrets o servicios de gestión de secretos.
- Monitoreo y logging: Integra herramientas para revisar salud de contenedores y logs.
- Versiona tu configuración: Utiliza control de versiones para tus Dockerfile y archivos compose.
FastAPI con Docker Compose Implementar estas prácticas me ha permitido entregar servicios confiables y seguros, esenciales en entornos productivos. Puedes consultar la documentación oficial de FastAPI y explorar más materiales formativos en KeepCoding para avanzar con confianza en tus proyectos backend.
