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

Instalar Docker-ce

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 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 implementar nuestra aplicación 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"

Instalar Docker-ce

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

Iniciar ventana acoplable

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.

Comprobar la instalación de Docker

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

Paso 2: instalar Docker-compose

En este tutorial, 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.

Instalar Docker-compose

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 el entorno del proyecto

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.

Configurar proyecto Django

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

Ejecutar imagen acoplable

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.

Use docker-compose para construir la imagen

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.

comando doke-compose ps

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.

P√°gina de inicio predeterminada del proyecto 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.

administración de Django

La aplicación Dockerizing Python Django se completó con éxito.

Deja una respuesta

Tu dirección de correo electrónico no será publicada. Los campos obligatorios están marcados con *