Django et Docker Compose

· 855 mots · Temps de lecture 5min

Nous allons aller une étape plus loin dans notre exploration de Docker. Si vous n'avez pas encore lus les posts précédents et que vous ne connaissez pas Docker, je vous suggère de les parcourir (Débuter avec Docker et Ma première application Django dans Docker) pour vous sentir à l'aise avec le sujet d'aujourd'hui: Docker Compose.

Docker Compose vs Dockerfile 🔗

Compose est un outil Docker pour créer et exécuter des applications Docker multi-conteneurs. Dans un seul fichier YAML, vous pouvez définir les différents services dont vous avez besoin pour exécuter votre application. Et, avec une seule commande (nous en reparlerons un peu plus tard), vous pouvez exécuter tous les conteneurs pour chaque service à partir de votre fichier docker-compose.

Supposons que vous souhaitiez créer une application Django conteneurisée et que vous souhaitiez utiliser Postgres comme base de données (c'est l'exemple que nous allons examiner aujourd'hui). Vous pouvez le faire en deux étapes:

  1. vous créez votre Dockerfile pour votre application Django, comme nous l'avons vu dans le post précédent
  2. vous créez un fichier docker-compose pour configurer les différents services: un pour l'application Django elle-même, un pour la base de données (et vous pouvez en ajouter plus pour un cache Redis ou tout autre service dont vous pourriez avoir besoin). Dans votre fichier docker-compose, votre service web (application Django) va dépendre du service postgres

Django et le Dockerfile 🔗

Ok, passons à l'écriture d'un peu de code. Vous connaissez maintenant notre configuration de base:

# créer un dossier nommé demo et aller dans ce dossier
mkdir demo && cd demo/

# créer un virtualenv et l'activer
virtualenv ~/.virtualenvs/demo && source ~/.virtualenvs/demo/bin/activate

# installet Django et psycopg2 (adpatateur PostgreSQL pour Python)
pip install Django
pip install psycopg2

# freeze les requirements actuels dans un fichier texte
pip freeze > requirements.txt

# créer un Dockerfile
touch Dockerfile

Ouvrons le Dockerfile dans un éditeur de texte et écrivons le texte suivant

# utiliser l'image Python taggée 3.7
FROM python:3.7

# utiliser un logging unbuffered (sans délais)
ENV PYTHONUNBUFFERED 1

# définir /app comme le dossier de travail dans le conteneur
WORKDIR /app

# ajouter le fichier de dans le dossier app/
ADD requirements.txt /app/

# Installer dans le conteneur les librairies définies dans le fichier requirements.txt
RUN pip install --trusted-host pypi.python.org -r requirements.txt

# copier le contenu du dossier actuel dans le conteneur sous le dossier /app
ADD . /app

Le fichier docker-compose 🔗

OK, nous en avons terminé avec le Dockerfile. Tournons nous vers le sujet principal de cet article, le fichier docker-compose. Depuis la racine du dossier demo/, si vous n'êtes pas sûr de votre emplacement, vous pouvez taper pwd pour vérifier, effectuez les opérations suivantes.

# créer le fichier docker-compose
touch docker-compose.yml

Et écrivez le code suivant dans le fichier docker-compose

# utiliser la version 3 du fichier docker-compose
version: '3'

services:
  # le service de base de données (db) utilise l'image officielle postgres pour Docker
  db:
    image: postgres
  web:
    # construire l'image depuis le Dockerfile dans le dossier actuel
    build: .
    # exécuter la commande Django runserver
    # qui démarre un serveur de développement
    # https://docs.djangoproject.com/en/2.1/ref/django-admin/#runserver
    command: python3 manage.py runserver 0.0.0.0:8000
    # monter le dossier local actuel (dossier du projet) dans /app
    # dans le conteneur
    volumes:
      - .:/app
    # lier le port 8000 dans le conteneur au port 8000 dans la machine locale
    ports:
      - 8000:8000
    # s'assurer que le service db est exécuté avant de démarrer le service web (Django)
    depends_on:
      - db

J'espère que les différents commentaires vous ont aidé à suivre.

Le service db réutilise simplement l' image postgres officielle, disponible sur dockerhub. Le service web est un peu plus complexe mais rien n'est très nouveau à part la ligne volumes. volumes vous permet notamment (cela fait beaucoup plus que cela) de modifier le code à chaud sans avoir à reconstruire l'image. C'est très pratique lorsque vous apportez des modifications à votre projet Django et que vous souhaitez voir les modifications appliquées sur le serveur de développement et disponibles immédiatement via votre navigateur local. Si vous voulez aller un peu plus loin, vous pouvez lire la page de documentation Docker sur les volumes.

Exécution locale de votre application Django avec docker-compose 🔗

Nous sommes maintenant prêts à utiliser les fichier Dockerfile et docker-compose. Nous avons «juste» besoin de créer le projet django et de l'exécuter pour vérifier que notre configuration fonctionne correctement. Nous devrons modifier les paramètres de la base de données Django car Django utilise sqlite3 par défaut. Au travail!

# créer le projet Django
docker-compose run web django-admin.py startproject demoproject .

Ouvrez le fichier demoproject/settings.py et changez la configuration existante DATABASES pour le texte suivant:

DATABASES = {
    'default': {
        'ENGINE': 'django.db.backends.postgresql',
        'NAME': 'postgres',
        'USER': 'postgres',
        'HOST': 'db',
        'PORT': 5432,
    }
}

Tout est désormais prêt et vous pouvez exécuter le code suivant

docker-compose up

Vous pouvez ouvrir votre navigateur préféré et consulter la page http://localhost:8000… si tout s'est bien passé, vous devriez maintenant voir la page d'accueil de Django! Yessss, vous avez maintenant une application Django fonctionnelle utilisant une base de données PostgreSQL et tout est géré grâce à un fichier docker-compose de quelques lignes. Félicitations :)'

Références 🔗

docker-compose django