Déploiement d'une application Django

Comment déployer en production une application Web développée grâce au framework Django ? Les points abordés dans cet article sont les suivants :

Gestion du code source
Hébergement et déploiement
Création d'un nom de domaine

La procédure suivante utilise les services de sourcehut, PythonAnywhere et Gandi mais la procédure serait sensiblement identique avec d'autres prestataires tels que GitLab, OVH...

Le guide de DigitalOcean détaille la procédure pour installer un environnement de production complet sur un serveur.

Préparation du code source

Hébergement du code source sur sourcehut (à partir de 20 $ par an).

Générer une clé de chiffrement pour sécuriser l'accès au code source en indiquant une phrase de passe longue :

ssh-keygen -t ed25519

Ajouter la clé publique .ssh/id_ed25519.pub dans l'onglet meta > keys > ssh keys de sourcehut.

Initialiser le dépôt local et le pousser sur le dépôt distant :

git init
git remote add origin git@git.sr.ht:~user/project
git push -u origin main

Finaliser la création du dépôt distant en cliquant sur le lien affiché.

Configuration du projet

Dans l'environnement virtuel du projet, installer le module django-environ permettant de gérer simplement les fichiers de configuration des différents environnements (développement, validation, production...) :

pip install django-environ

Créer un fichier src/app/.env et l'ajouter dans .gitignore pour éviter qu'il soit pris en compte par le gestionnaire de versions :

SECRET_KEY=django-secretkey
DEBUG=True
ALLOWED_HOSTS=localhost
DATABASE_ENGINE=django.db.backends.postgresql
DATABASE_NAME=database_name
DATABASE_USER=database_user
DATABASE_PASSWORD=database_pass
DATABASE_HOST=localhost
DATABASE_PORT=5432

Attention : ce fichier contient la configuration de développement. Il ne faut pas le versionner. Un fichier similaire contenant la configuration de validation/production devra être ajouté dans les environnements concernés lors du déploiement.

Modifier le fichier src/app/settings.py pour récupérer les paramètres précédents grâce au module django-environ :

import environ

env = environ.Env()
environ.Env().read_env(BASE_DIR / 'app/.env')

SECRET_KEY = env('SECRET_KEY')
DEBUG = env.bool('DEBUG', False)
ALLOWED_HOSTS = env.list('ALLOWED_HOSTS')

DATABASES = {
    'default': {
        'ENGINE': env("DATABASE_ENGINE", default='django.db.backends.sqlite3'),
        'NAME': env("DATABASE_NAME", default=str(BASE_DIR / 'db.sqlite3')),
        'USER': env("DATABASE_USER", default=None),
        'PASSWORD': env("DATABASE_PASSWORD", default=None),
        'HOST': env("DATABASE_HOST", default=None),
        'PORT': env("DATABASE_PORT", default=None),
    }
}

Modifier également les chemins des fichiers statiques et dynamiques :

MEDIA_URL = 'media/'
MEDIA_ROOT = BASE_DIR / 'media'

STATIC_URL = 'static/'
STATIC_ROOT = BASE_DIR / 'static'

Générer le fichier requirements.txt nécessaire pour l'installation des dépendances :

pip freeze > requirements.txt

Enfin, sauvegarder toutes les modifications sur le dépôt distant avec les commandes git add, git commit et git push.

Installation de l'environnement de production

Déploiement de l'application sur PythonAnywhere (gratuit ou à partir de 60 $ par an).

Dans l'onglet Consoles de PythonAnywhere saisir les commandes suivantes.

Récupérer le code source :

git clone https://git.sr.ht/~user/project

Créer et activer un environnement virtuel dans le répertoire project :

python3.10 -m venv .venv
source .env/bin/activate

Installer les dépendances du projet :

pip install -r requirements.txt

Générer une nouvelle clé secrète :

python manage.py shell -c 'from django.core.management import utils; print(utils.get_random_secret_key())'

Créer le fichier de configuration src/app/.env :

SECRET_KEY=secretkey
DEBUG=False
ALLOWED_HOSTS=user.pythonanywhere.com
DATABASE_ENGINE=django.db.backends.postgresql
DATABASE_NAME=database_name
DATABASE_USER=database_user
DATABASE_PASSWORD=database_pass
DATABASE_HOST=localhost
DATABASE_PORT=5432

Vérifier la configuration pour le déploiement :

python manage.py check --deploy

Créer la base de données et le super utilisateur :

python manage.py migrate
python manage.py createsuperuser

Collecter les fichiers statiques dans un unique répertoire :

python manage.py collectstatic

Dans l'onglet Web de PythonAnywhere indiquer :

Virtualenv : /home/user/project/.venv/
Code > Source code : /home/user/project/
Code > WSGI configuration file : modifier /home/user/project/src et app.settings dans le fichier :

import os
import sys

# assuming your django settings file is at '/home/user/project/src/app/settings.py'
# and your manage.py is is at '/home/user/project/src/manage.py'
path = '/home/user/project/src'
if path not in sys.path:
    sys.path.append(path)

os.environ['DJANGO_SETTINGS_MODULE'] = 'app.settings'

from django.core.wsgi import get_wsgi_application
application = get_wsgi_application()

Pour que les changements soient pris en compte, recharger l'application web en cliquant sur "Reload user.pythonanywhere.com".

Mise à jour de l'environnement de production

Pour mettre à jour l'environnement de production, il suffit de récupérer les modifications avec la commande git pull et recharger l'application en cliquant sur "Reload user.pythonanywhere.com".

Il peut également être nécessaire d'installer les nouvelles dépendances à partir du fichier requirements.txt ou d'appliquer les migrations sur la bases de données s'il y a eu des modifications sur ces points.

Création d'un nom de domaine

Enregistrement du nom de domaine sur Gandi (à partir de 15 € par an).

Une fois le nom de domaine enregistré auprès du registrar il faut ajouter un enregistrement de type CNAME dans le fichier de zones pour faire pointer le nom de domaine vers l'application : www.mydomain.fr -> webapp-XXXX.pythonanywhere.com.

Il faut ensuite renommer l'application www.mydomain.fr dans l'onglet Web de PythonAnywhere (se référer à la documentation).