Introducción

Cuando construyes una aplicación web generada por IA en tu portátil, funciona porque Python está instalado, las dependencias están en el lugar correcto y las variables de entorno están configuradas de forma precisa. Mueve esa aplicación a un servidor, a la máquina de un compañero o a una plataforma cloud, y de repente nada funciona. Docker resuelve esto empaquetando tu aplicación junto con todo lo que necesita en una sola unidad portable llamada contenedor.

En esta lección, escribirás un Dockerfile para una aplicación web Python típica, lo construirás en una imagen y usarás Docker Compose para ejecutar la aplicación junto con cualquier servicio del que dependa (como una base de datos o Redis). El enfoque es práctico: al final, deberías poder containerizar una pequeña aplicación web generada por IA con confianza.

Escribiendo tu primer Dockerfile

Un Dockerfile es un archivo de texto con instrucciones que Docker lee para ensamblar una imagen. Piensa en él como una receta: cada línea añade una capa. Para una aplicación web generada por IA, la configuración más común es una aplicación FastAPI o Flask servida por Uvicorn.

Aquí tienes un Dockerfile mínimo para una aplicación web Python:

FROM python:3.11-slim
WORKDIR /app
COPY requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt
COPY . .
EXPOSE 8000
CMD ["uvicorn", "main:app", "--host", "0.0.0.0", "--port", "8000"]

Analicemos cada línea. `FROM python:3.11-slim` parte de una imagen oficial y ligera de Python. `WORKDIR /app` establece el directorio de trabajo dentro del contenedor para que los comandos posteriores se ejecuten allí. `COPY requirements.txt .` copia primero solo el archivo de dependencias, lo que permite a Docker cachear el paso de `pip install` y saltarlo cuando solo cambia tu código. `COPY . .` copia luego el código fuente. `EXPOSE 8000` documenta el puerto en el que escucha la aplicación. `CMD` define el comando que se ejecuta cuando arranca el contenedor.

Un error común es copiar todo antes de instalar las dependencias. Eso obliga a Docker a reconstruir la capa pesada de `pip install` cada vez que modificas un solo archivo Python. El orden importa para la velocidad.

Construyendo y ejecutando la imagen

Una vez que existe el Dockerfile, dos comandos lo convierten en un contenedor en ejecución. Primero, construye la imagen y etiquétala con un nombre:

docker build -t my-ai-app:1.0 .

El `.` indica a Docker dónde encontrar el Dockerfile (directorio actual). El flag `-t` asigna un nombre y una etiqueta de versión, lo que facilita referenciar la imagen más tarde. Luego ejecútala:

docker run -p 8000:8000 my-ai-app:1.0

El flag `-p 8000:8000` mapea el puerto 8000 de tu host al puerto 8000 dentro del contenedor. Sin él, la aplicación se ejecuta pero no puedes acceder a ella desde tu navegador. Visita `http://localhost:8000` y deberías ver tu aplicación respondiendo.

Para verificar que la imagen se construyó correctamente, lista todas las imágenes:

docker images

Para ver los contenedores en ejecución, usa `docker ps`. Añade `-a` para incluir los detenidos.

Usando Docker Compose para aplicaciones multi-servicio

La mayoría de aplicaciones web de IA no se ejecutan solas. Normalmente necesitan una base de datos (PostgreSQL), una caché (Redis), o ambas. Gestionar cada una con comandos `docker run` separados se vuelve complicado rápido. Docker Compose te permite declarar todos los servicios en un archivo YAML y arrancarlos juntos.

Crea un archivo llamado `docker-compose.yml`:

services:
  web:
    build: .
    ports:
      - "8000:8000"
    environment:
      - DATABASE_URL=postgresql://user:pass@db:5432/mydb
    depends_on:
      - db
  db:
    image: postgres:16
    environment:
      - POSTGRES_USER=user
      - POSTGRES_PASSWORD=pass
      - POSTGRES_DB=mydb
    volumes:
      - pgdata:/var/lib/postgresql/data
volumes:
  pgdata:

Observa cómo el servicio `web` referencia a `db` por nombre de host. Docker Compose crea una red privada donde los servicios se alcanzan entre sí por el nombre del servicio. La directiva `depends_on` indica a Docker que arranque la base de datos antes que la aplicación web. El volumen con nombre `pgdata` mantiene los datos de la base de datos a salvo incluso si el contenedor se elimina.

Para levantar todo:

docker compose up --build

Añade `-d` para ejecutarlo en segundo plano. Para detener y eliminar los contenedores:

docker compose down

Errores comunes y cómo evitarlos

Olvidar el archivo `.dockerignore` es un descuido frecuente. Crea uno junto a tu Dockerfile:

echo -e "__pycache__\n.git\n.env\n*.pyc" > .dockerignore

Sin él, tu imagen arrastra archivos innecesarios, ralentiza las construcciones y corre el riesgo de filtrar secretos como archivos `.env` que contienen claves de API.

Otro escollo es hardcodear secretos dentro de la imagen. Nunca pongas claves de API o contraseñas de bases de datos directamente en el Dockerfile. Usa variables de entorno o monta archivos de secretos en tiempo de ejecución.

Por último, ejecutar contenedores como root por defecto es un riesgo de seguridad para producción. Añade un usuario no root a tu Dockerfile cuando estés listo para desplegar en serio.

Resumen

Un Dockerfile describe cómo empaquetar tu aplicación en una imagen. Docker Compose orquesta múltiples contenedores juntos a través de un único archivo YAML. Para una aplicación web generada por IA, el flujo de trabajo típico es: escribe un Dockerfile que copie las dependencias primero, construye una imagen con `docker build`, ejecútala con `docker run -p`, y extiende a Compose cuando añadas servicios como bases de datos. Dominar estos cuatro comandos y una estructura YAML te lleva el 90 por ciento del camino hacia una aplicación containerizada lista para cualquier plataforma cloud.