Deployer Django avec Docker

Pourquoi Deployer Django avec Docker ?

Deployer Django avec Docker est un processus crucial pour les développeurs qui cherchent à rendre leur application plus portable, sécurisée et facilement déployable. Dans un environnement professionnel, il est fréquent d'avoir besoin de partager son application entre différents développeurs ou même sur différents serveurs. En utilisant Docker, on peut s'assurer que l'environnement de développement est identique à celui du production, réduisant ainsi les risques liés aux différences d'environnements.

Un cas d'usage concret serait le déploiement d'une application Django sur une infrastructure cloud comme AWS ou Azure. En utilisant Docker, vous pouvez créer une image de votre application qui est facilement déployable et scalable. De plus, Docker offre des avantages en matière de sécurité, car il isoler chaque conteneur dans son propre espace mémoire.

Prerequis

• Connaissance approfondie de Django (version 3.x recommandée)
• Compréhension des concepts de base de Python
• Familiarité avec les commandes Linux ou macOS (pour les environnements de développement)
• Installation d'outils suivants :
  • Docker Desktop pour Windows/Mac : https://docs.docker.com/docker-for-mac/install/
  • Docker Engine pour Linux : https://docs.docker.com/engine/install/
  • Python (version 3.7 ou supérieure) : https://www.python.org/downloads/
• Éditeur de texte comme VSCode, PyCharm ou Sublime Text

Concepts fondamentaux

Concept 1 : Dockerfile

Un Dockerfile est un fichier texte qui contient des instructions pour construire une image Docker. Chaque instruction crée une nouvelle couche dans l'image.

## Dockerfile
FROM python:3.9-slim as base

## Copier le requirements.txt et installer les dépendances
COPY requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt

## Créer un environnement virtuel et activer-le
RUN python -m venv /venv
ENV PATH="/venv/bin:$PATH"

## Copier l'application dans le conteneur
COPY . .

## Définir la commande par défaut pour exécuter l'application
CMD ["python", "manage.py", "runserver"]

Concept 2 : docker-compose.yml

Le fichier docker-compose.yml est utilisé pour définir et gérer les services, les réseaux et les volumes Docker.

## docker-compose.yml
version: '3.9'

services:
  web:
    build:
      context: .
      dockerfile: Dockerfile
    command: python manage.py runserver 0.0.0.0:8000
    ports:
      - "8000:8000"
    volumes:
      - .:/app
      - /app/staticfiles
    depends_on:
      - db

  db:
    image: postgres:13
    environment:
      POSTGRES_DB: mydatabase
      POSTGRES_USER: myuser
      POSTGRES_PASSWORD: mypassword
    volumes:
      - db_data:/var/lib/postgresql/data

volumes:
  db_data:

Concept 3 : Construire et lancer votre application

Pour construire votre image Docker, utilisez la commande suivante :

docker-compose build

Puis pour lancer votre application :

docker-compose up

Mise en pratique : projet fil rouge

Nous allons créer un petit gestionnaire de tâches appelé "TaskMaster". Il s'agira d'une application Django simple avec une interface web permettant d'afficher, ajouter et supprimer des tâches.

Étape 1 : Créer le projet Django

django-admin startproject taskmaster .

Étape 2 : Créer l'application de tâches

python manage.py startapp tasks

Étape 3 : Configurer les chemins d'URL

Modifier taskmaster/urls.py pour inclure les urls de notre application :

## taskmaster/urls.py
from django.contrib import admin
from django.urls import path, include

urlpatterns = [
    path('admin/', admin.site.urls),
    path('', include('tasks.urls')),
]

Modifier tasks/urls.py pour définir les routes :

## tasks/urls.py
from django.urls import path
from . import views

urlpatterns = [
    path('', views.task_list, name='task-list'),
    path('add/', views.add_task, name='add-task'),
    path('delete/<int:task_id>/', views.delete_task, name='delete-task'),
]

Étape 4 : Créer les vues et modèles

Modifier tasks/views.py pour créer les vues :

## tasks/views.py
from django.shortcuts import render, redirect
from .models import Task

def task_list(request):
    tasks = Task.objects.all()
    return render(request, 'tasks/task_list.html', {'tasks': tasks})

def add_task(request):
    if request.method == 'POST':
        content = request.POST.get('content')
        Task.objects.create(content=content)
        return redirect('task-list')
    return render(request, 'tasks/add_task.html')

def delete_task(request, task_id):
    task = Task.objects.get(id=task_id)
    task.delete()
    return redirect('task-list')

Modifier tasks/models.py pour créer le modèle :

## tasks/models.py
from django.db import models

class Task(models.Model):
    content = models.CharField(max_length=255)

    def __str__(self):
        return self.content

Étape 5 : Créer les templates

Créer les fichiers HTML dans tasks/templates/tasks/ :

• task_list.html
• add_task.html

Étape 6 : Ajouter des migrations et mettre à jour la base de données

python manage.py makemigrations tasks
python manage.py migrate

Étape 7 : Installer les dépendances et construire l'image Docker

Créer un fichier requirements.txt :

Django==3.2
psycopg2-binary

Ajouter le Dockerfile et docker-compose.yml comme expliqué précédemment.

Étape 8 : Lancer l'application

docker-compose up --build

Erreurs frequentes et debugging

1. Erreur : Error response from daemon: Ports are not available: listen tcp 0.0.0.0:8000: bind: address already in use

   Code incorrect :

   docker-compose up
   

   Code correct :

   docker-compose down -v && docker-compose up --build
   

2. Erreur : ModuleNotFoundError: No module named 'django'

   Code incorrect :

   # taskmaster/settings.py
   import os
   
   BASE_DIR = os.path.dirname(os.path.dirname(__file__))
   

   Code correct :

   # taskmaster/settings.py
   import os
   
   BASE_DIR = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
   

3. Erreur : OperationalError: no such table

   Code incorrect :

   python manage.py migrate
   

   Code correct :

   docker-compose run web python manage.py migrate
   

Pour aller plus loin

1. Mise en place de Django avec Docker Compose
2. Optimisation des performances avec Django et Docker
3. Gestion des environnements avec Docker Swarm

Défi pratique : Créez une application Django complète pour un simple forum en utilisant Docker et Docker Compose.