Vous ne souhaitez pas effectuer cette configuration manuellement ? Collez un lien vers cette page dans une session Devin et demandez-lui de tout configurer pour vous. Si vous ne savez pas sur quels services repose votre application Django ni comment le projet est structuré, utilisez [Ask Devin](https://app.devin.ai/search?utm_source=docs\&utm_medium=use-case-gallery) pour commencer votre analyse : ```txt Délimiter le périmètre du projet Django pour la conteneurisation theme={null} De quoi notre application Django dans src/ dépend-elle ? 1. À quelles bases de données et à quels caches se connecte-t-elle ? 2. Utilise-t-elle Celery ou des workers en arrière-plan ? 3. Que contiennent requirements.txt ou pyproject.toml ? 4. Existe-t-il déjà des fichiers Docker ou des configurations de déploiement ? 5. Comment l'application gère-t-elle les fichiers statiques et les médias ? ``` Vous pouvez également démarrer une session Devin directement depuis Ask Devin, et Devin conservera tout ce qu'il a appris comme contexte. Indiquez à Devin quel projet Django containeriser et mentionnez tout besoin spécifique : préférences d’image de base, services dont l’application dépend ou contraintes de taille d’image. Devin lit votre `requirements.txt` ou `pyproject.toml` pour déduire le reste. ```txt Dockeriser une API Django avec Postgres et Redis theme={null} Conteneurise l’API Django située dans src/. Elle utilise PostgreSQL pour la base de données et Redis pour la mise en cache et les files de tâches Celery. - Dockerfile multi‑étapes : installer les dépendances dans une étape de build (builder), copier uniquement le venv dans une image d’exécution python:3.12-slim minimale - docker-compose.yml avec Django (gunicorn), PostgreSQL 16 et Redis 7 - .dockerignore qui exclut les tests, la documentation, .git et __pycache__ - Exécuter sous un utilisateur non‑root - Health check sur /api/health/ - Worker Celery comme service séparé dans compose ## Tests et vérification - Construire l’image et exécuter docker-compose up - Attendre que tous les services soient opérationnels - Vérifier que l’API répond sur localhost:8000/api/health/ - Exécuter la suite de tests Django à l’intérieur du conteneur - Si quelque chose échoue — erreurs de build, variables d’environnement manquantes, problèmes de connexion, tests en échec — déboguer et corriger. Continuer à itérer jusqu’à ce que toute la stack démarre proprement et que tous les tests passent. - Ne pas ouvrir de PR tant que tout ne fonctionne pas de bout en bout ``` Devin lit votre projet Django et les fichiers de dépendance pour comprendre le processus de build, puis génère la configuration Docker : 1. **Lit les fichiers de dépendance** — Analyse `requirements.txt` ou `pyproject.toml`, identifie Django, psycopg2, redis, celery et gunicorn 2. **Écrit le Dockerfile** — Crée un build multi-étapes qui installe les dépendances dans une étape de build et copie l'environnement virtuel dans une image d'exécution minimale `python:3.12-slim` ```dockerfile theme={null} # ---- Builder ---- FROM python:3.12-slim AS builder WORKDIR /app COPY requirements.txt . RUN python -m venv /opt/venv \ && /opt/venv/bin/pip install --no-cache-dir -r requirements.txt # ---- Runtime ---- FROM python:3.12-slim RUN groupadd -r django && useradd -r -g django django COPY --from=builder /opt/venv /opt/venv ENV PATH="/opt/venv/bin:$PATH" WORKDIR /app COPY src/ . RUN python manage.py collectstatic --noinput EXPOSE 8000 USER django CMD ["gunicorn", "config.wsgi:application", "--bind", "0.0.0.0:8000", "--workers", "3"] ``` 3. **Crée le fichier docker-compose.yml** — Ajoute Django, PostgreSQL, Redis et un worker Celery, avec des contrôles d’état, des volumes et un réseau partagé ```yaml theme={null} services: web: build: . ports: - "8000:8000" env_file: .env depends_on: db: condition: service_healthy redis: condition: service_healthy healthcheck: test: ["CMD", "python", "-c", "import urllib.request; urllib.request.urlopen('http://localhost:8000/api/health/')"] interval: 10s retries: 3 db: image: postgres:16-alpine environment: POSTGRES_DB: app_db POSTGRES_USER: app_user POSTGRES_PASSWORD: app_pass volumes: - pgdata:/var/lib/postgresql/data healthcheck: test: ["CMD-SHELL", "pg_isready -U app_user -d app_db"] interval: 5s retries: 5 redis: image: redis:7-alpine healthcheck: test: ["CMD", "redis-cli", "ping"] interval: 5s retries: 5 celery: build: . command: celery -A config worker -l info env_file: .env depends_on: db: condition: service_healthy redis: condition: service_healthy volumes: pgdata: ``` 4. **Ajoute .dockerignore** — Exclut les fichiers qui n’appartiennent pas au contexte de build (`__pycache__`, `.git`, `tests/`, `docs/`, `*.pyc`) 5. **Exécute `docker compose up --build`** — Construit l’image et démarre tous les services dans le terminal de Devin 6. **Vérifie l’application** — Envoie une requête `curl` vers `/api/health/` pour confirmer que Django démarre correctement, se connecte à PostgreSQL et accède à Redis Utilisez les commandes slash pendant la session pour orienter le flux de travail de Devin : * **`/plan`** — Demandez à Devin de présenter sa démarche avant d’écrire toute configuration Docker. Passez en revue le plan et proposez des modifications. * **`/test`** — Demandez à Devin de reconstruire et de revérifier la pile de conteneurs. Utilisez cette commande après chaque modification pour détecter les problèmes le plus tôt possible. * **`/review`** — Demandez à Devin de relire son propre Dockerfile et la configuration Compose afin de détecter les problèmes de sécurité, d’optimiser la taille de l’image et d’appliquer les bonnes pratiques avant d’ouvrir la PR. Une fois que Devin a ouvert la PR, passez en revue les fichiers générés. Suites possibles : ```txt Optimiser la taille de l'image theme={null} L'image Docker fait 520 Mo. Réduisez sa taille : assurez-vous que nous ne copions pas de fichiers inutiles, supprimez les fichiers .pyc du venv et retirez pip de l'image finale. ``` ```txt Ajouter le rechargement à chaud en dev theme={null} Ajoutez un fichier docker-compose.override.yml pour le développement local qui monte le répertoire source et exécute le serveur de développement de Django avec rechargement automatique au lieu de gunicorn. ``` ```txt Ajouter un build Docker en CI theme={null} Créez un workflow GitHub Actions qui construit l'image Docker à chaque PR, exécute pytest dans le conteneur et la publie sur ECR lors de la fusion sur main. Marquez-la avec le SHA Git. ``` Une fois que Devin a ouvert la PR, utilisez [Devin Review](https://app.devin.ai/review?utm_source=docs\&utm_medium=use-case-gallery) pour examiner la configuration Docker. Devin Review peut détecter des problèmes de sécurité (exécution en tant que root, secrets exposés), le non-respect de certaines bonnes pratiques (pas de `.dockerignore`, aucun health check défini) ainsi que des incohérences avec votre infrastructure existante.

{title}