Déploiement Simple d’une Application Django avec Docker,

Gunicorn et Nginx
Abdoul Malik Kondi
5 novembre 2023

Résumé
Cet article vous guidera à travers les étapes du déploiement d’une application web Django en
utilisant Gunicorn comme serveur d’application et Nginx comme serveur web, le tout géré dans
des conteneurs Docker.

1 Introduction
Le déploiement d’une application web, telle que Django, peut sembler complexe au départ, car cela
implique de confier la gestion de l’application à un serveur web comme Nginx ou Apache. Cependant,
une fois que vous prenez les choses en main, vous réaliserez que ce n’est pas sorcier. Dans cet article, je
vais vous montrer comment déployer une application Django avec Gunicorn en utilisant le serveur
web Nginx, le tout encapsulé dans des conteneurs Docker.

2 Prérequis
Avant de commencer, voici ce dont vous aurez besoin :
1. Une application Django que vous souhaitez déployer.
2. Ajoutez Gunicorn à votre fichier requirements.txt pour spécifier la dépendance.
3. Ajoutez la constante CSRF TRUSTED ORIGINS à votre configuration Django pour gérer
les origines de confiance :
CSRF_TRUSTED_ORIGINS = [
"http://127.0.0.1:8080",
"http://localhost:8080"
]

4. Mettez votre application Django sur GitHub (vous pouvez utiliser mon application de gestion
de contacts si vous le souhaitez sur github : https ://github.com/amk-7/gestion contact).
5. Créez le répertoire docker gunicorn nginx.

3 Explications Techniques
Avant de plonger dans les détails du déploiement, il est important de comprendre les composants
clés de notre solution de déploiement.
— Django : Django est un framework web Python puissant et populaire. Il est le moteur de notre
application web.
— Gunicorn : Gunicorn est un serveur d’application WSGI (Web Server Gateway Interface) qui
servira notre application Django. Il gère les connexions entrantes et dirige le trafic vers Django.
— Nginx : Nginx est un serveur web et proxy inverse. Il agit comme point d’entrée pour les
requêtes HTTP, dirige le trafic vers Gunicorn et sert de serveur statique pour les fichiers.

1
 — Docker : Docker est une plateforme de conteneurisation qui nous permet d’isoler notre appli-
cation et ses dépendances dans des conteneurs légers et portables.

4 Créer un fichier Dockerfile pour notre application Django

Pour déployer notre application Django, nous aurons besoin d’un fichier Dockerfile pour construire
une image Docker. Dans le répertoire docker gunicorn nginx, créez un répertoire nommé webapp. Dans
ce répertoire, créez un fichier Dockerfile. Voici le contenu du Dockerfile :
FROM python:3.10-alpine

# Installez les dépendances nécessaires

RUN apk add python3-dev build-base linux-headers pcre-dev git

# Récupérez le projet Django depuis GitHub

RUN git clone https://github.com/votre-utilisateur/votre-projet.git
WORKDIR /votre-projet

# Mettez à jour pip et installez les dépendances Python

RUN pip install --upgrade pip
RUN pip install -r requirements.txt

# Point d’entrée : Exécutez l’application avec Gunicorn

ENTRYPOINT ["gunicorn", "--workers=3", "--bind", "unix:/app/gunicorn.sock", "votre_projet.wsgi:applic

Ce Dockerfile utilise une image Python Alpine, installe les dépendances nécessaires, récupère le
projet Django depuis GitHub, installe les dépendances Python spécifiées dans requirements.txt, puis
configure Gunicorn comme point d’entrée pour l’application.

5 Créer un fichier Dockerfile pour le serveur web Nginx

Nous aurons également besoin d’un fichier Dockerfile pour le serveur web Nginx. Dans le répertoire
docker gunicorn nginx, créez un répertoire nommé nginx. Dans ce répertoire, créez un fichier Dockerfile.
Voici le contenu du Dockerfile :

FROM nginx:latest

# Copiez les fichiers de configuration

COPY nginx.conf /etc/nginx/nginx.conf
COPY conf.d/app.conf /etc/nginx/conf.d/app.conf

# Commande de démarrage de Nginx en mode démon

CMD ["nginx", "-g", "daemon off;"]

2
 Ce Dockerfile utilise l’image Nginx la plus récente, copie les fichiers de configuration nécessaires,
puis démarre Nginx en mode démon.
Créez un fichier nommé nginx.conf dans le repertoir nginx. Voci son contenu :
user nginx;
worker_processes auto;
error_log /var/log/nginx/error.log warn; #notice warn
pid /var/run/nginx.pid;

events {
worker_connections 1024;
}

http {
include /etc/nginx/mime.types;
default_type application/octet-stream;
log_format main ’$remote_addr - $remote_user [$time_local] "$request" ’
’$status $body_bytes_sent "$http_referer" ’
’"$http_user_agent" "$http_x_forwarded_for"’;

access_log /var/log/nginx/access.log main;

sendfile on;
#tcp_nopush on;

keepalive_timeout 65;

#gzip on;

include /etc/nginx/conf.d/app.conf;
}
Le fichier nginx.conf contient les configurations du serveur nginx .
Créez ensuite un dossier nommé conf.d qui contiendra le fichier app.conf. Voici son contenu :

server {
listen 80;
listen 443;
client_max_body_size 4G;
# server_name ;
keepalive_timeout 5;
# Rediriger les requ^etes du client vers le serveur Gunicorn quand l’utilisateur
# se rend sur le localhost/ ou sur le 127 0.0.1/
location / {
proxy_pass http://unix:/app/gunicorn.sock;
proxy_set_header Host $host;
proxy_set_header X-Real-IP $remote_addr;
}
}
Le fichier app.conf contient les configurations spécifiques à notre application Django.

3
6 Créer un fichier docker-compose.yml pour gérer nos conte-
neurs
Pour simplifier la gestion de nos conteneurs, nous utiliserons Docker Compose. Voici un fichier
docker-compose.yml qui configure nos services Django et Nginx :

version: "3"
services:
nginx:
container_name: serveur_web
build: ./nginx/
restart: always
ports:
- "8080:80"
depends_on:
- django_app
links:
- django_app
volumes:
- gunicorn-sock:/app

django_app:
container_name: gestion_contacts
build: ./webapp/
restart: always
volumes:
- gunicorn-sock:/app

volumes:
gunicorn-sock:

Ce fichier Docker Compose définit deux services : Nginx et Django. Nginx est configuré pour
rediriger les requêtes vers le service Django via un socket Unix.

7 Déploiement de l’application
Si vous avez suivi les étapes jusqu’ici, vous avez maintenant une structure de fichiers comme celle-ci :

Pour déployer l’application, suivez ces étapes :

1. Créez des images à partir du fichier Docker Compose en exécutant la commande suivante :
docker compose build
2. Démarrez la pile Docker Compose en mode détaché avec la commande suivante :

docker compose up -d
Vous pouvez désormais accéder à votre application Django déployée en utilisant Nginx comme
serveur web à l’adresse ‘http ://localhost :8080‘ ou à l’adresse de votre serveur.

4
Ce guide vous a montré comment déployer une application Django en utilisant Gunicorn, Nginx et
Docker. N’oubliez pas de personnaliser les fichiers de configuration en fonction de votre application et
de prendre en compte les aspects de sécurité et de maintenance pour un déploiement en production.