Guía de Docker: Dockerización de la aplicación Python Django

Docker es un proyecto de código abierto que proporciona una plataforma abierta para desarrolladores y administradores de sistemas para crear, empaquetar y ejecutar aplicaciones en cualquier lugar como un contenedor ligero. Docker automatiza la implementación de aplicaciones dentro de contenedores de software.

Django es un marco de aplicación web escrito en python que sigue la arquitectura MVC (Model-View-Controller). 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ápido posible.

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

Para dockerizar aplicacion python Django, necesitamos imágenes acoplables adicionales. Necesitamos una imagen acoplable de nginx para el servidor web y una imagen de PostgreSQL para la base de datos.

¿Lo que haremos?

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

Paso 1 – Instalar Docker-ce

En este tutorial, instalaremos la edición comunitaria de docker-ce desde el repositorio de docker. Instalaremos la edición comunitaria docker-ce y docker-compose que admiten la versión 3 del archivo de redacción.

Antes de instalar docker-ce, instale las dependencias de docker necesarias con el comando apt.

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

Ahora agregue la clave de la ventana acoplable y el repositorio ejecutando los comandos a continuación.

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"

Actualice el repositorio e instale docker-ce.

sudo apt update
sudo apt install -y docker-ce

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

systemctl start docker
systemctl enable docker

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

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

Inicie sesión como usuario omar y ejecute el comando docker como se muestra a continuación.

su - omar
docker run hello-world

Asegúrese de recibir el mensaje de saludo mundial de Docker.

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

Paso 2: instalar Docker-compose

Usaremos la compatibilidad más reciente de docker-compose para la versión 3 del archivo de composición. Instalaremos docker-compose manualmente.

Descargue la última versión de docker-compose usando el comando curl en el directorio ‘/usr/local/bin’ y hágalo ejecutable usando chmod.

Ejecute los comandos a continuación.

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 verifique la versión de docker-compose.

docker-compose version

Y asegúrese de obtener la última versión de docker-compose 1.21.

Se ha instalado la última versión de docker-compose que admite el archivo de composición versión 3.

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 nuestros archivos de proyecto, como un Dockerfile, un proyecto Django, un archivo de configuración nginx, etc.

Inicie sesión con el usuario ‘omar’.

su - omar

Cree un nuevo directorio ‘guide01’ y vaya al directorio.

mkdir -p guide01
cd guide01/

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

mkdir project/ config/

Nota:

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

Crear un nuevo archivo requirements.txt

Luego, cree un nuevo archivo ‘requirements.txt’ dentro del directorio ‘config’ usando el comando vim.

vim config/requirements.txt

Pegue la configuración a continuación.

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

Guardar y Salir.

Cree el archivo de host virtual Nginx django.conf

En el directorio de configuración, cree el directorio de configuración ‘nginx’ y agregue el archivo de configuración de host virtual django.conf.

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

Pegue la siguiente configuración allí.

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/;
}
}

Guardar y Salir.

Crear el Dockerfile

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

Ejecute el siguiente comando.

vim Dockerfile

Ahora pegue el script Dockerfile a continuación.

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

Guardar y Salir.

Nota:

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

Crear script de composición de Docker

Cree el archivo ‘docker-compose.yml’ en el directorio ‘guide01’ usando el comando vim a continuación.

vim docker-compose.yml

Pegue la siguiente configuración allí.

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

Guardar y Salir.

Nota:

Con este script de archivo docker-compose, crearemos tres servicios. Cree el servicio de base de datos denominado ‘db’ con PostgreSQL alpine Linux, cree el servicio ‘nginx’ con Nginx alpine Linux nuevamente y cree nuestro contenedor python Django con las imágenes de Docker personalizadas generadas a partir de nuestro Dockerfile.

Configurar proyecto Django

Copie los archivos de su proyecto Django en el directorio ‘proyecto’.

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

Vaya al directorio ‘proyecto’ y edite la configuración de la aplicación ‘settings.py’.

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

Nota:

Implementaremos una aplicación Django simple llamada aplicación ‘hello_django’.

En la línea ‘ALLOW_HOSTS’, agregue el nombre del servicio ‘web’.

ALLOW_HOSTS = ['web']

Ahora cambie la configuración de la base de datos. Usaremos la base de datos PostgreSQL que se ejecuta como un servicio llamado ‘db’ con usuario y contraseña predeterminados.

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’, agregue esta línea al final de la línea del archivo.

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

Guardar y Salir.

Ahora estamos listos para compilar y ejecutar el proyecto Django en el contenedor acoplable.

Paso 4: cree y ejecute la imagen de Docker

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

Vaya al directorio ‘guide01’.

cd ~/guide01/

Ahora cree las imágenes de la ventana acoplable con el comando docker-compose.

docker-compose build

Inicie todos los servicios dentro del script docker-compose.

docker-compose up -d

Espere unos minutos para que Docker cree nuestra imagen de Python y descargue las imágenes de docker de nginx y postgresql.

Y cuando esté completo, verifique el contenedor en ejecución y enumere las imágenes de la ventana acoplable en el sistema usando los siguientes comandos.

docker-compose ps
docker-compose images

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

Nuestra aplicación Python Django ahora se ejecuta dentro del contenedor acoplable y se han creado imágenes acoplables para nuestro servicio.

Paso 5 – Prueba

Abra su navegador web y escriba la dirección del servidor con el puerto 8000, el mío es: http://ovh01:8000/

Ahora obtendrá la página de inicio predeterminada de Django.

A continuación, pruebe la página de administración agregando la ruta ‘/admin’ en la URL.

http://ovh01:8000/admin/

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

La dockerización de la aplicación Python Django se ha completado con éxito.