El Proyecto | Sobre nosotros | Contribuir | Donaciones | Licencia

HOME

Docker es una herramienta poderosa que permite a los desarrolladores crear, desplegar y ejecutar aplicaciones en contenedores. Los contenedores son ligeros y portátiles, lo que facilita la gestión de dependencias y la replicación de entornos de desarrollo y producción. En esta sección, aprenderemos cómo usar Docker para contenerizar una aplicación Django.

¿Qué es Docker?

Docker es una plataforma que permite empaquetar una aplicación y sus dependencias en un contenedor. Esto asegura que la aplicación se ejecute de manera consistente en cualquier entorno.

Ventajas de usar Docker:

Consistencia: Asegura que la aplicación se ejecute de la misma manera en diferentes entornos.
Portabilidad: Los contenedores pueden ejecutarse en cualquier sistema que tenga Docker instalado.
Aislamiento: Cada contenedor tiene su propio entorno, lo que evita conflictos de dependencias.
Escalabilidad: Facilita la escalabilidad horizontal de las aplicaciones.

Configuración del Entorno

Prerrequisitos:

Tener Docker instalado en tu sistema. Puedes descargarlo desde aquí.

Archivos necesarios:

Dockerfile: Define la imagen de Docker para tu aplicación.
docker-compose.yml: Facilita la gestión de múltiples contenedores.

Creando el Dockerfile

El Dockerfile es un script que contiene una serie de instrucciones para construir una imagen de Docker.

# Usar una imagen base oficial de Python
FROM python:3.9-slim

# Establecer el directorio de trabajo en el contenedor
WORKDIR /app

# Copiar los archivos de requerimientos
COPY requirements.txt .

# Instalar las dependencias
RUN pip install --no-cache-dir -r requirements.txt

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

# Exponer el puerto en el que la aplicación correrá
EXPOSE 8000

# Comando para correr la aplicación
CMD ["python", "manage.py", "runserver", "0.0.0.0:8000"]

Explicación del Dockerfile:

FROM python:3.9-slim: Usa una imagen base de Python 3.9.
WORKDIR /app: Establece el directorio de trabajo dentro del contenedor.
COPY requirements.txt .: Copia el archivo de requerimientos al contenedor.
RUN pip install --no-cache-dir -r requirements.txt: Instala las dependencias.
COPY . .: Copia el resto del código de la aplicación al contenedor.
EXPOSE 8000: Expone el puerto 8000 para acceder a la aplicación.
CMD ["python", "manage.py", "runserver", "0.0.0.0:8000"]: Comando para iniciar la aplicación.

Creando el archivo docker-compose.yml

docker-compose es una herramienta para definir y ejecutar aplicaciones Docker con múltiples contenedores.

version: '3.8'

services:
  web:
    build: .
    command: python manage.py runserver 0.0.0.0:8000
    volumes:
      - .:/app
    ports:
      - "8000:8000"
    depends_on:
      - db

  db:
    image: postgres:13
    environment:
      POSTGRES_DB: mydatabase
      POSTGRES_USER: myuser
      POSTGRES_PASSWORD: mypassword
    volumes:
      - postgres_data:/var/lib/postgresql/data/

volumes:
  postgres_data:

Explicación del docker-compose.yml:

version: '3.8': Versión de docker-compose.
services: Define los servicios que componen la aplicación.
- web: Servicio para la aplicación Django.
  - build: .: Construye la imagen usando el Dockerfile en el directorio actual.
  - command: Comando para iniciar el servidor Django.
  - volumes: Monta el directorio actual en el contenedor.
  - ports: Mapea el puerto 8000 del contenedor al puerto 8000 del host.
  - depends_on: Define la dependencia del servicio db.
- db: Servicio para la base de datos PostgreSQL.
  - image: Usa la imagen oficial de PostgreSQL.
  - environment: Variables de entorno para configurar la base de datos.
  - volumes: Monta un volumen para persistir los datos de la base de datos.
volumes: Define los volúmenes para persistencia de datos.

Construyendo y Ejecutando los Contenedores

Paso 1: Construir la imagen de Docker

docker-compose build

Paso 2: Iniciar los contenedores

docker-compose up

Paso 3: Acceder a la aplicación

Abre tu navegador y navega a http://localhost:8000 para ver tu aplicación Django en funcionamiento.

Ejercicio Práctico

Ejercicio:

Crea un nuevo proyecto Django.
Configura un Dockerfile y un docker-compose.yml para contenerizar tu aplicación.
Asegúrate de que tu aplicación se conecte a una base de datos PostgreSQL en un contenedor separado.
Ejecuta los contenedores y verifica que tu aplicación funcione correctamente.

Solución:

Crear un nuevo proyecto Django:

django-admin startproject myproject
cd myproject

Crear el archivo requirements.txt:

Django>=3.2,<4.0
psycopg2-binary>=2.8

Crear el Dockerfile y el docker-compose.yml como se muestra en las secciones anteriores.
Construir y ejecutar los contenedores:

docker-compose build
docker-compose up

Verificar la aplicación en http://localhost:8000.

Conclusión

En esta sección, hemos aprendido cómo usar Docker para contenerizar una aplicación Django. Hemos visto cómo crear un Dockerfile y un docker-compose.yml para definir y ejecutar contenedores. Esta configuración no solo facilita la gestión de dependencias y entornos, sino que también mejora la portabilidad y escalabilidad de nuestras aplicaciones Django.

Próximos Pasos:

En la siguiente sección, exploraremos las mejores prácticas de seguridad para aplicaciones Django, asegurando que nuestras aplicaciones sean robustas y seguras en producción.

Usando Docker con Django