Docker es una plataforma abierta para construir, enviar y ejecutar aplicaciones distribuidas. Brinda a los programadores, equipos de desarrollo e ingenieros de operaciones de la caja de herramientas comunes que necesitan para aprovechar la naturaleza distribuida y en red de las aplicaciones modernas.

La contenedorización ofrece varias ventajas, como un aprovisionamiento más rápido o entornos aislados y fáciles de recrear.

Si no sabe qué es la contenedorización, puede pensar en ella como una forma simplificada de virtualización. O mejor aún, puede buscar una descripción detallada, que no es el propósito de esta publicación.

Pasos para «Dockerizar» con Django

Para empezar, me gustaría contarles que me interesé en «Dockerizar» mis aplicaciones de Django para mejorar mis canalizaciones de implementación.

Si bien la documentación en Docker es muy buena, sus ejemplos son demasiado generales para mí, así que decidí investigar un poco sobre cómo hacerlo.

En esta publicación, tengo la intención de dar un paseo por «Dockerizando Django» y exponer un puerto desarrollado uwsgi , que se puede usar para la producción a diferencia del servidor de desarrollo de Django.

Explicaré la mayoría de los pasos, sin embargo, recomiendo leer el tutorial de docker sobre imágenes . Asumo que tiene Docker instalado y funcionando.

Paso 1. Proporcionar un Dockerfile en la raíz del proyecto

En la raíz de nuestro proyecto Django (misma carpeta que manage.py) tendremos alguna estructura:

• carpeta de requisitos, que contiene los requisitos de Python que debe instalar pip.
• require.apt, que contiene los requisitos del sistema.
• my_project.ini, que se utiliza para mantener las configuraciones de uwsgi.

Este le dice a Docker cómo construir la imagen. Mi Dockerfile, por ejemplo, se ve así:

DESDE ubuntu:14.04 
EJECUTAR configuración regional-gen en_US.UTF-8 
ENV LANG es_US.UTF-8 
ENV IDIOMA es_US:es 
ENV PYTHONBUFFED 1 

AÑADIR ./requisitos /requisitos 
AGREGAR ./install_os_dependencies.sh /install_os_dependencies.sh 
AGREGAR ./requisitos. apt /requisitos.apt 
AÑADIR ./mi_proyecto.ini /mi_proyecto.ini 

EJECUTAR 

./install_os_dependencies.sh instalar EJECUTAR pip3 install -r "requisitos/requisitos.txt" 

EJECUTAR groupadd -r agregar && useradd -r -g 
agregar agregar AGREGAR . /aplicación 
EJECUTAR chown -R django /aplicación 
EJECUTAR chgrp -R django /aplicación 
WORKDIR /aplicación

EXPONER 8000 

CMD sudo -u django uwsgi mi_proyecto.ini --maestro

Esto construirá nuestra imagen usando como base ubuntu de dockerhub .

Puede cambiar esto cambiando la primera línea, siempre que obtenga los requisitos para su otra imagen:

DESDE ubuntu:14.04

CleanNecesita generar los entornos locales para evitar algunos problemas con Python y Unicode. Eso puede no ser necesario con otras imágenes.

EJECUTAR configuración regional-gen en_US.UTF-8 
ENV LANG es_US.UTF-8 
ENV IDIOMA es_US:es 
ENV PYTHONBUFFED 1

Paso 2. Agregar los archivos necesarios para construir muestra imagen:

A continuación, una línea de código para agregar los archivos necesarios en la construcción de nuestra imagen:

AÑADIR ./requisitos /requisitos 
AGREGAR ./install_os_dependencies.sh /install_os_dependencies.sh 
AGREGAR ./requisitos.apt /requisitos.apt 
AÑADIR ./mi_proyecto.ini /mi_proyecto.ini
    
install_os_dependencies.sh es un script bash que instalará los requisitos del sistema, que se enumeran en require.apt. Se inicia con:

EJECUTAR ./install_os_dependencies.sh instalar

Puede encontrar este script en el repositorio de cookies de PyDanny .

Ahora bien, como estoy usando Python3 para este proyecto, mis requisitos.apt deben reflejar que:

##dependencias de compilación básicas de varias aplicaciones de Django para Ubuntu 14.04 
Instalación del metapaquete #build-essential: make, gcc, g++, 
construir-esencial 
#requerido para traducir obtener 
texto 
python3-dev 
python3-pip 

##dependencias compartidas de: 
# #Almohada, pylibmc 
zlib1g-dev 

## Dependencias Postgresql y psycopg2 
libpq-dev 

##Dependencias de almohadas 
libtiff4-dev 
libjpeg8-dev 
libfreetype6-dev 
liblcms1-dev 
libwebp-dev 

##pylibmc 
libmemcached-dev 
libssl-dev 

##extensiones-django 
Graphviz-dev 

##lxml
libxml2-dev 
libxslt-dev

Paso 3. Instalar nuestras dependencias en Python:

En este punto, nuestra imagen ya tiene las dependencias básicas del sistema, instalamos nuestras dependencias de Python:

EJECUTAR pip3 install -r "requisitos/requisitos.txt"

El archivo requirements.txt debe estar en un formato que pip pueda entender .

Para este proyecto, instalaré solo Django y uwsgi, por lo que el archivo es muy corto:

django==1.8.4 
uWSGI==2.0.11.1

Ahora que todos los requisitos están instalados, crearemos un nuevo usuario con permisos más bajos, que usaremos para ejecutar uwsgi:

EJECUTAR groupadd -r agregar && useradd -r -g 
agregar agregar AGREGAR . /aplicación 
EJECUTAR chown -R django /aplicación 
EJECUTAR chgrp -R django /aplicación 
WORKDIR /aplicación

WORKDIR es la forma preferida de Docker para cambiar directorios (no algo así como RUN cd).

Paso 4. Exponer un puerto

Como ya tenemos nuestra aplicación y todos sus requisitos instalados, necesitamos exponer un puerto para hablar con el mundo (8000 en este caso):

EXPONER 8000

En este punto, podremos ejecutar el servidor de desarrollo de nuestro Django y exponerlo, pero eso no sería útil para la producción.

Por tanto, agregaré uwsgi para ejecutar mi aplicación Python.

Paso 5. Definir las configuraciones para uwsgi en my_project.ini

De la siguiente manera: 

[whisky] 
http = :8000 
chdir = /aplicación/ 
env = DJANGO_SETTINGS_MODULE=config.settings 
archivo wsgi = config/wsgi.py 
procesos = 4 
hilos = 2

Con la directiva http, estamos diciendo que sirva http. Es posible que desee utilizar sockets tcp o sockets Unix, lo que resultó un cambio en esa configuración.

Por ahora, solo quiero acceder al servidor desde mi navegador local, por lo que http es suficiente.

chdir le dice a uwsgi dónde está la aplicación.

Para ir terminando establecemos una variable de entorno para seleccionar una de nuestras configuraciones.

Si tiene configuraciones específicas de instancia, puede cambiarlas aquí (local, prueba, producción, etc.).

La última línea en nuestro Dockerfile define qué comando se ejecutará cuando comencemos nuestra imagen

CMD sudo -u django uwsgi mi_proyecto.ini --maestro

Corremos uwsgi como el usuario que creamos.

Paso 6. Verificar nuestra imagen

Como ya hemos terminado de construir nuestro Dockerfile. Es hora de verificar si podemos construir nuestra imagen (no olvide el.):

ventana acoplable construir -t django_app.

Si todo funciona, deberíamos tener algo como esto:

Construido con exito dd40ad889782

Ese es el id de nuestra nueva imagen. Podemos correrla ahora:

ventana acoplable ejecutable -p 8000:8000 -ti dd40ad889782

Finalmente, le decimos a Docker qué puertos queremos reenviar (host: guest) con -p. -ti nos permite detener el contenedor con ctrl + C. Si no nos importa esto, esa bandera puede omitirse.

Suponiendo que su aplicación Django no tenga problemas, debería poder usarla desde http://localhost:8000 .

No se mencionan las bases de datos, porque están más relacionadas con la configuración de Django que con la configuración de Docker . Puede usar sqlite para que funcione.

Si desea inspeccionar las partes internas de su nuevo contenedor, acceda a ellas con:

docker exec -it nombre_raro bash

Donde rare_name es el nombre asignado por Docker a su contenedor.

Si desea verificar sus contenedores en ejecución, puede ejecutar:

ventana acoplable p

Para terminar, quiero agradecer su lectura, espero que con los pasos aquí enunciados pueda iniciar.

Tenga en cuenta que mantuve la mayoría de las cosas al mínimo para evitar una complejidad innecesaria.