Docker est un projet open source qui fournit une plate-forme ouverte aux développeurs et aux administrateurs système pour créer, empaqueter et exécuter des applications n'importe où en tant que conteneur léger. Docker automatise le déploiement d'applications dans des conteneurs de logiciels.
Django est un framework d'application Web écrit en python qui suit l'architecture MVC (Model-View-Controller). Il est disponible gratuitement et publié sous une licence open source. Il est rapide et conçu pour aider les développeurs à mettre leur application en ligne le plus rapidement possible.
Dans ce tutoriel, je vais vous montrer étape par étape comment créer une image docker pour un projet d'application Django existant dans Ubuntu 16.04. Nous allons apprendre à dockeriser une application python Django, puis à déployer l'application en tant que conteneur dans l'environnement docker à l'aide d'un script docker-compose.
Afin de déployer notre application python Django, nous avons besoin d'images docker supplémentaires. Nous avons besoin d'une image docker nginx pour le serveur Web et d'une image PostgreSQL pour la base de données.
Qu'allons-nous faire ?
- Installer Docker-ce
- Installer Docker-compose
- Configurer l'environnement du projet
- Construire et exécuter
- Test
Étape 1 - Installer Docker-ce
Dans ce didacticiel, nous allons installer docker-ce community edition à partir du référentiel docker. Nous allons installer docker-ce community edition et docker-compose qui prennent en charge la version 3 du fichier de composition.
Avant d'installer docker-ce, installez les dépendances de docker nécessaires à l'aide de la commande apt.
sudo apt install -y \
apt-transport-https \
ca-certificates \
curl \
software-properties-common
Ajoutez maintenant la clé docker et le référentiel en exécutant les commandes ci-dessous.
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"
Mettez à jour le référentiel et installez docker-ce.
sudo apt update
sudo apt install -y docker-ce
Une fois l'installation terminée, démarrez le service docker et activez-le pour qu'il se lance à chaque démarrage du système.
systemctl start docker
systemctl enable docker
Ensuite, nous allons ajouter un nouvel utilisateur nommé "omar" et l'ajouter au groupe docker.
useradd -m -s /bin/bash omar
usermod -a -G docker omar
Connectez-vous en tant qu'utilisateur omar et exécutez la commande docker comme indiqué ci-dessous.
su - omar
docker run hello-world
Assurez-vous de recevoir le message hello-world de Docker.
L'installation de Docker-ce est terminée.
Étape 2 - Installer Docker-compose
Dans ce didacticiel, nous utiliserons la dernière prise en charge de docker-compose pour la version 3 du fichier de composition. Nous installerons docker-compose manuellement.
Téléchargez la dernière version de docker-compose à l'aide de la commande curl dans le répertoire '/usr/local/bin' et rendez-la exécutable à l'aide de chmod.
Exécutez les commandes ci-dessous.
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
Vérifiez maintenant la version de docker-compose.
docker-compose version
Et assurez-vous d'avoir la dernière version de docker-compose 1.21.
La dernière version de docker-compose qui prend en charge la version 3 du fichier de composition a été installée.
Étape 3 - Configurer l'environnement du projet
Dans cette étape, nous allons configurer l'environnement du projet python Django. Nous allons créer un nouveau répertoire 'guide01' et en faire le répertoire principal pour nos fichiers de projet, tels qu'un Dockerfile, un projet Django, un fichier de configuration nginx, etc.
Connectez-vous à l'utilisateur 'omar'.
su - omar
Créez un nouveau répertoire 'guide01' et accédez au répertoire.
mkdir -p guide01
cd guide01/
Maintenant, dans le répertoire 'guide01', créez de nouveaux répertoires 'project' et 'config'.
mkdir project/ config/
Remarque :
- Répertoire 'project' :tous nos fichiers de projet python Django seront placés dans ce répertoire.
- Répertoire 'config' :répertoire pour les fichiers de configuration du projet, y compris le fichier de configuration nginx, le fichier d'exigences python pip, etc.
Créer un nouveau fichier requirements.txt
Ensuite, créez un nouveau fichier 'requirements.txt' dans le répertoire 'config' à l'aide de la commande vim.
vim config/requirements.txt
Collez la configuration ci-dessous.
Django==2.0.4
gunicorn==19.7.0
psycopg2==2.7.4
Enregistrez et quittez.
Créer le fichier d'hôte virtuel Nginx django.conf
Sous le répertoire config, créez le répertoire de configuration 'nginx' et ajoutez le fichier de configuration de l'hôte virtuel django.conf.
mkdir -p config/nginx/
vim config/nginx/django.conf
Collez-y la configuration suivante.
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/;
}
} Enregistrez et quittez.
Créer le Dockerfile
Créez un nouveau 'Dockerfile' dans le répertoire 'guide01'.
Exécutez la commande ci-dessous.
vim Dockerfile
Collez maintenant le script Dockerfile ci-dessous.
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
Enregistrez et quittez.
Remarque :
Nous voulons construire les images Docker pour notre projet Django basé sur Alpine Linux, la plus petite taille de Linux. Notre projet Django exécutera Alpine Linux avec python 3.5 installé dessus et ajoutera le package postgresql-dev pour le support de la base de données PostgreSQL. Ensuite, nous installerons tous les packages python répertoriés dans le fichier "requirements.txt" à l'aide de la commande python pip, et créerons un nouveau "/src" pour notre projet.
Créer un script de composition Docker
Créez le fichier "docker-compose.yml" dans le répertoire "guide01" à l'aide de la commande vim ci-dessous.
vim docker-compose.yml
Collez-y la configuration suivante.
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
Enregistrez et quittez.
Remarque :
Avec ce script de fichier docker-compose, nous allons créer trois services. Créez le service de base de données nommé 'db' à l'aide de PostgreSQL alpine Linux, créez à nouveau le service 'nginx' à l'aide de Nginx alpine Linux et créez notre conteneur python Django à l'aide des images docker personnalisées générées à partir de notre Dockerfile.
Configurer le projet Django
Copiez vos fichiers de projet Django dans le répertoire 'project'.
cd ~/django
cp -r * ~/guide01/project/
Allez dans le répertoire 'project' et modifiez le paramètre d'application 'settings.py'.
cd ~/guide01/project/
vim hello_django/settings.py
Remarque :
Nous allons déployer une application Django simple appelée 'hello_django' app.
Sur la ligne 'ALLOW_HOSTS', ajoutez le nom de service 'web'.
ALLOW_HOSTS = ['web']
Modifiez maintenant les paramètres de la base de données. Nous utiliserons la base de données PostgreSQL qui s'exécute en tant que service nommé "db" avec un utilisateur et un mot de passe par défaut.
DATABASES = {
'default': {
'ENGINE': 'django.db.backends.postgresql_psycopg2',
'NAME': 'postgres',
'USER': 'postgres',
'HOST': 'db',
'PORT': 5432,
}
} Et pour le répertoire de configuration 'STATIC_ROOT', ajoutez cette ligne à la fin de la ligne du fichier.
STATIC_ROOT = os.path.join(BASE_DIR, 'static/')
Enregistrez et quittez.
Nous sommes maintenant prêts à créer et à exécuter le projet Django sous le conteneur docker.
Étape 4 - Créer et exécuter l'image Docker
Dans cette étape, nous souhaitons créer une image Docker pour notre projet Django en utilisant la configuration du répertoire 'guide01'.
Allez dans le répertoire 'guide01'.
cd ~/guide01/
Créez maintenant les images docker à l'aide de la commande docker-compose.
docker-compose build
Démarrez tous les services dans le script docker-compose.
docker-compose up -d
Attendez quelques minutes que Docker construise notre image Python et télécharge les images docker nginx et postgresql.
Et une fois terminé, vérifiez le conteneur en cours d'exécution et répertoriez les images Docker sur le système à l'aide des commandes suivantes.
docker-compose ps
docker-compose images
Et maintenant, vous obtiendrez trois conteneurs en cours d'exécution et une liste d'images Docker sur le système, comme indiqué ci-dessous.
Notre application Python Django s'exécute maintenant dans le conteneur Docker et des images Docker pour notre service ont été créées.
Étape 5 - Tester
Ouvrez votre navigateur Web et saisissez l'adresse du serveur avec le port 8000, la mienne est : http://ovh01:8000/
Vous obtiendrez maintenant la page d'accueil par défaut de Django.
Ensuite, testez la page d'administration en ajoutant le chemin '/admin' sur l'URL.
http://ovh01:8000/admin/
Et vous verrez la page de connexion de l'administrateur Django.
L'application Dockerizing Python Django a été complétée avec succès.