Guía Docker: Dockerizando una aplicación Python Django

Docker es un proyecto de código abierto que proporciona una plataforma abierta para que desarrolladores y administradores de sistemas construyan, empaqueten y ejecuten aplicaciones en cualquier lugar como un contenedor ligero. Docker automatiza el despliegue de aplicaciones dentro de contenedores de software.

Django es un marco de aplicación web escrito en python que sigue la arquitectura MVC (Modelo-Vista-Controlador). Está disponible de forma gratuita y se publica bajo una licencia de código abierto. Es rápido y está diseñado para ayudar a los desarrolladores a poner su aplicación en línea lo más rápidamente posible.

En este tutorial, te mostraré paso a paso cómo crear una imagen docker para un proyecto de aplicación Django existente en Ubuntu 16.04. Aprenderemos a dockerizar una aplicación python Django, y luego desplegaremos la aplicación como un contenedor en el entorno docker utilizando un script docker-compose.

Para desplegar nuestra aplicación python Django, necesitamos imágenes docker adicionales. Necesitamos una imagen docker nginx para el servidor web y una imagen PostgreSQL para la base de datos.

¿Qué vamos a hacer?

1. Instalar Docker-ce
2. Instalar Docker-compose
3. Configurar el entorno del proyecto
4. Construir y ejecutar
5. Probar

Paso 1 – Instalar Docker-ce

En este tutorial, instalaremos docker-ce community edition desde el repositorio de docker. Instalaremos docker-ce community edition y docker-compose que soportan la versión 3 del archivo compose.

Antes de instalar docker-ce, instala las dependencias de docker necesarias utilizando el comando apt.

sudo apt install -y \
    apt-transport-https \
    ca-certificates \
    curl \
    software-properties-common

Ahora añade la clave de docker y el repositorio ejecutando los comandos siguientes.

curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo apt-key add -
sudo add-apt-repository \
   "deb [arch=amd64] https://download.docker.com/linux/ubuntu \
   $(lsb_release -cs) \
   stable"

Actualiza el repositorio e instala docker-ce.

sudo apt update
sudo apt install -y docker-ce

Una vez completada la instalación, inicia el servicio docker y habilítalo para que se lance cada vez que se inicie el sistema.

systemctl start docker
systemctl enable docker

A continuación, añadiremos un nuevo usuario llamado ‘omar’ y lo añadiremos al grupo docker.

useradd -m -s /bin/bash omar
usermod -a -G docker omar

Inicia sesión como el usuario omar y ejecuta el comando docker como se muestra a continuación.

su - omar
docker run hello-world

Asegúrate de que recibes el mensaje de bienvenida de Docker

La instalación de Docker-ce se ha completado.

Paso 2 – Instalar Docker-compose

En este tutorial, utilizaremos el último soporte de docker-compose para la versión 3 del archivo compose. Instalaremos docker-compose manualmente.

Descarga la última versión de docker-compose utilizando el comando curl al directorio ‘/usr/local/bin’ y hazlo ejecutable utilizando chmod.

Ejecuta los siguientes comandos.

sudo curl -L https://github.com/docker/compose/releases/download/1.21.0/docker-compose-$(uname -s)-$(uname -m) -o /usr/local/bin/docker-compose
sudo chmod +x /usr/local/bin/docker-compose

Ahora comprueba la versión de docker-compose.

docker-compose version

Y asegúrate de que tienes la última versión de docker-compose 1.21.

La última versión de docker-compose que soporta la versión 3 del archivo compose ha sido instalada.

Paso 3 – Configurar el entorno del proyecto

En este paso, configuraremos el entorno del proyecto python Django. Crearemos un nuevo directorio ‘guide01’ y lo convertiremos en el directorio principal para los archivos de nuestro proyecto, como el Dockerfile, el proyecto Django, el archivo de configuración de nginx, etc.

Inicia sesión con el usuario ‘omar’.

su - omar

Crea un nuevo directorio ‘guide01’ y entra en él.

mkdir -p guide01
cd guide01/

Ahora, dentro del directorio ‘guide01’, crea nuevos directorios ‘project’ y ‘config’.

mkdir project/ config/

Nota:

• Directorio ‘project’: Todos los archivos de nuestro proyecto python Django se colocarán en ese directorio.
• Directorio ‘config’: Directorio para los archivos de configuración del proyecto, incluyendo el archivo de configuración de nginx, el archivo de requisitos de python pip, etc.

Crea un nuevo archivo requirements.txt

A continuación, crea un nuevo archivo ‘requirements.txt’ dentro del directorio ‘config’ utilizando el comando vim.

vim config/requirements.txt

Pega la configuración de abajo.

Django==2.0.4  
 gunicorn==19.7.0  
 psycopg2==2.7.4

Guarda y sal.

Crea el archivo de host virtual Nginx django.conf

Dentro del directorio config, crea el directorio de configuración ‘nginx’ y añade el archivo de configuración del host virtual django.conf.

mkdir -p config/nginx/
vim config/nginx/django.conf

Pega allí la siguiente configuración.

upstream web {
   ip_hash;
   server web:8000;
 }
 
 # portal
 server {
   location / {
         proxy_pass http://web/;
     }
   listen 8000;
   server_name localhost;
 
   location /static {    
     autoindex on;    
     alias /src/static/;    
   }
 }

Guarda y sal.

Crea el Dockerfile

Crea un nuevo ‘Dockerfile’ dentro del directorio ‘guide01’.

Ejecuta el siguiente comando.

vim Dockerfile

Ahora pega el script Dockerfile de abajo.

FROM python:3.5-alpine
 ENV PYTHONUNBUFFERED 1  
 
 RUN apk update && \
     apk add --virtual build-deps gcc python-dev musl-dev && \
     apk add postgresql-dev bash
 
 RUN mkdir /config  
 ADD /config/requirements.txt /config/  
 RUN pip install -r /config/requirements.txt
 RUN mkdir /src
 WORKDIR /src

Guarda y sal.

Nota:

Queremos construir las imágenes Docker para nuestro proyecto Django basado en Alpine Linux, el tamaño más pequeño de Linux. Nuestro proyecto Django se ejecutará en Alpine Linux con python 3.5 instalado encima y añadiremos el paquete postgresql-dev para el soporte de la base de datos PostgreSQL. Y luego instalaremos todos los paquetes python listados en el archivo ‘requirements.txt’ usando el comando pip de python, y crearemos un nuevo ‘/src’ para nuestro proyecto.

Crear el script Docker-compose

Crea el archivo ‘docker-compose.yml’ en el directorio ‘guide01’ utilizando el comandovim que aparece a continuación.

vim docker-compose.yml

Pega allí la siguiente configuración.

version: '3'
 services:
   db:
     image: postgres:10.3-alpine
     container_name: postgres01
   nginx:
     image: nginx:1.13-alpine
     container_name: nginx01
     ports:
       - "8000:8000"
     volumes:
       - ./project:/src
       - ./config/nginx:/etc/nginx/conf.d
     depends_on:
       - web
   web:
     build: .
     container_name: django01
     command: bash -c "python manage.py makemigrations && python manage.py migrate && python manage.py collectstatic --noinput && gunicorn hello_django.wsgi -b 0.0.0.0:8000"
     depends_on:
       - db
     volumes:
       - ./project:/src
     expose:
       - "8000"
     restart: always

Guarda y sal.

Nota:

Con este script del archivo docker-compose, crearemos tres servicios. Crearemos el servicio de base de datos llamado ‘db’ utilizando el alpine Linux de PostgreSQL, crearemos el servicio ‘nginx’ utilizando de nuevo el alpine Linux de Nginx, y crearemos nuestro contenedor python Django utilizando las imágenes docker personalizadas generadas a partir de nuestro Dockerfile.

Configurar el proyecto Django

Copia los archivos de tu proyecto Django al directorio ‘project’.

cd ~/django
cp -r * ~/guide01/project/

Ve al directorio ‘project’ y edita la configuración de la aplicación ‘settings.py’.

cd ~/guide01/project/
vim hello_django/settings.py

Nota:

Vamos a desplegar una aplicación Django sencilla llamada ‘hello_django’.

En la línea ‘ALLOW_HOSTS’, añade el nombre del servicio ‘web’.

ALLOW_HOSTS = ['web']

Ahora cambia la configuración de la base de datos. Utilizaremos la base de datos PostgreSQL que se ejecuta como un servicio llamado ‘db’ con usuario y contraseña por defecto.

DATABASES = {  
     'default': {
         'ENGINE': 'django.db.backends.postgresql_psycopg2',
         'NAME': 'postgres',
         'USER': 'postgres',
         'HOST': 'db',
         'PORT': 5432,
     }
 }

Y para el directorio de configuración ‘STATIC_ROOT’, añade esta línea al final de la línea del archivo.

STATIC_ROOT = os.path.join(BASE_DIR, 'static/')

Guarda y sal.

Ahora estamos listos para construir y ejecutar el proyecto Django bajo el contenedor docker.

Paso 4 – Construir y ejecutar la imagen Docker

En este paso, queremos construir una imagen Docker para nuestro proyecto Django utilizando la configuración en el directorio ‘guide01’.

Ve al directorio ‘guide01’.

cd ~/guide01/

Ahora construye las imágenes Docker utilizando el comando docker-compose.

docker-compose build

Inicia todos los servicios dentro del script docker-compose.

docker-compose up -d

Espera unos minutos a que Docker construya nuestra imagen Python y descargue las imágenes docker nginx y postgresql.

Y cuando se haya completado, comprueba el contenedor en ejecución y enumera las imágenes Docker en el sistema utilizando los siguientes comandos.

docker-compose ps
docker-compose images

Y ahora obtendrás tres contenedores en ejecución y la lista de imágenes Docker en el sistema como se muestra a continuación.

Nuestra aplicación Python Django se está ejecutando ahora dentro del contenedor Docker, y se han creado las imágenes Docker para nuestro servicio.

Paso 5 – Prueba

Abre tu navegador web y escribe la dirección del servidor con el puerto 8000, el mío eshttp://ovh01:8000/

Ahora obtendrás la página de inicio de Django por defecto.

A continuación, prueba la página de administración añadiendo la ruta ‘/admin’ en la URL.

http://ovh01:8000/admin/

Y verás la página de inicio de sesión del administrador de Django.

La aplicación Django Python en Docker se ha completado con éxito.

Referencia

• https://docs.docker.com/