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 Python Django 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.
¿Qué haremos?
- Instalar Docker-ce
- Instalar Docker-compose
- Configurar el entorno del proyecto
- Crear y ejecutar
- 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 composició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) \
estable"
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 inicie el sistema.
systemctl iniciar ventana acoplable
systemctl habilitar ventana acoplable
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 ejecutar hola-mundo
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
En este tutorial, utilizaremos la última compatibilidad con docker-compose para la versión 3 del archivo de redacció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 comprueba la versión de docker-compose.
versión docker-compose
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 la versión 3 del archivo de composición.
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 Dockerfile, proyecto Django, 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 guía01
cd guía01/
Ahora dentro del directorio 'guide01', cree nuevos directorios 'project' y 'config'.
mkdir proyecto/configuración/
- Directorio 'proyecto':Todos nuestros archivos de proyecto de 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.
Crea 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í.
web ascendente {
ip_hash;
servidor web:8000;
}
# portal
servidor {
ubicación / {
proxy_pass http://web/;
}
listen 8000;
server_name localhost;
ubicación /static {
autoindex activado;
alias /src/static/;
}
} Guardar y salir.
Crea el Dockerfile
Cree un nuevo 'Dockerfile' dentro del directorio 'guide01'.
Ejecute el siguiente comando.
vim Dockerfile
Ahora pegue el script de Dockerfile a continuación.
&&\apk agregar postgresql-dev bash
EJECUTAR mkdir /config
AGREGAR /config/requirements.txt /config/
EJECUTAR pip install -r /config/requirements. txt
EJECUTAR mkdir /src
WORKDIR /src
Guardar y salir.
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 secuencia de comandos de Docker-compose
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í.
versión:'3'
servicios:
db:
imagen:postgres:10.3-alpine
container_name:postgres01
nginx:
imagen:nginx:1.13-alpine
nombre_contenedor:nginx01
puertos:
- "8000:8000"
volúmenes:
- ./project:/src
- ./config/nginx:/etc/nginx/conf.d
depende_de:
- web
web:
compilación:.
nombre_contenedor:django01
comando:bash -c "python manage.py makemigrations &&python manage.py migrar &&python manage.py collectstatic --noinput &&gunicorn hello_django.wsgi -b 0.0.0.0:8000"
depende_de:
- db
volúmenes:
- ./proyecto:/src
exposición:
- "8000"
reiniciar:siempre
Guardar y salir.
Con este script de archivo docker-compose, crearemos tres servicios. Cree el servicio de base de datos llamado 'db' usando PostgreSQL alpine Linux, cree el servicio 'nginx' usando Nginx alpine Linux nuevamente y cree nuestro contenedor python Django usando las imágenes de docker personalizadas generadas desde nuestro Dockerfile.
Configurar proyecto Django
Copie los archivos de su proyecto Django en el directorio 'proyecto'.
cd ~/django
cp -r * ~/guide01/proyecto/
Vaya al directorio 'proyecto' y edite la configuración de la aplicación 'settings.py'.
cd ~/guide01/project/
vim hello_django/settings.py
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 el usuario y la contraseña predeterminados.
BASES DE DATOS ={
'predeterminado':{
'MOTOR':'django.db.backends.postgresql_psycopg2',
'NOMBRE':'postgres',
' USUARIO':'postgres',
'HOST':'db',
'PUERTO':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:compilar y ejecutar 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 crea las imágenes de la ventana acoplable con el comando docker-compose.
compilación docker-compose
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
imágenes docker-compose
Y ahora obtendrá tres contenedores ejecutándose 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 aplicación Dockerizing Python Django se completó con éxito.