Introduction

Lorsque vous construisez une application web générée par IA sur votre ordinateur portable, elle fonctionne parce que Python est installé, que les dépendances sont au bon endroit et que les variables d'environnement sont configurées correctement. Déplacez cette application sur un serveur, la machine d'un collègue ou une plateforme cloud, et soudain plus rien ne marche. Docker résout ce problème en empaquetant votre application avec tout ce dont elle a besoin dans une unité portable unique appelée conteneur.

Dans cette leçon, vous écrirez un Dockerfile pour une application web Python typique, vous le construirez en image, et utiliserez Docker Compose pour exécuter l'application aux côtés des services dont elle dépend (comme une base de données ou Redis). L'approche est pratique : à la fin, vous devriez être capable de conteneuriser une petite application web générée par IA en toute confiance.

Écrire votre premier Dockerfile

Un Dockerfile est un fichier texte contenant des instructions que Docker lit pour assembler une image. Considérez-le comme une recette : chaque ligne ajoute une couche. Pour une application web générée par IA, la configuration la plus courante est une application FastAPI ou Flask servie par Uvicorn.

Voici un Dockerfile minimal pour une application web Python :

FROM python:3.11-slim
WORKDIR /app
COPY requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt
COPY . .
EXPOSE 8000
CMD ["uvicorn", "main:app", "--host", "0.0.0.0", "--port", "8000"]

Décortiquons chaque ligne. `FROM python:3.11-slim` part d'une image Python officielle légère. `WORKDIR /app` définit le répertoire de travail à l'intérieur du conteneur pour que les commandes suivantes s'y exécutent. `COPY requirements.txt .` copie d'abord uniquement le fichier de dépendances, ce qui permet à Docker de mettre en cache l'étape `pip install` et de la sauter quand seul votre code change. `COPY . .` copie ensuite votre code source. `EXPOSE 8000` documente le port sur lequel l'application écoute. `CMD` définit la commande qui s'exécute au démarrage du conteneur.

Une erreur fréquente consiste à tout copier avant d'installer les dépendances. Cela force Docker à reconstruire la couche lourde `pip install` à chaque fois que vous modifiez un seul fichier Python. L'ordre importe pour la rapidité.

Construire et exécuter l'image

Une fois le Dockerfile créé, deux commandes le transforment en conteneur en cours d'exécution. D'abord, construisez l'image et étiquetez-la avec un nom :

docker build -t my-ai-app:1.0 .

Le `.` indique à Docker où trouver le Dockerfile (répertoire courant). Le flag `-t` attribue un nom et une étiquette de version, ce qui facilite la référence à l'image plus tard. Ensuite, exécutez-la :

docker run -p 8000:8000 my-ai-app:1.0

Le flag `-p 8000:8000` mappe le port 8000 de votre hôte sur le port 8000 à l'intérieur du conteneur. Sans cela, l'application tourne mais vous ne pouvez pas y accéder depuis votre navigateur. Visitez `http://localhost:8000` et vous devriez voir votre application répondre.

Pour vérifier que l'image a été construite correctement, listez toutes les images :

docker images

Pour voir les conteneurs en cours d'exécution, utilisez `docker ps`. Ajoutez `-a` pour inclure ceux qui sont arrêtés.

Utiliser Docker Compose pour les applications multi-services

La plupart des applications web IA ne fonctionnent pas seules. Elles ont généralement besoin d'une base de données (PostgreSQL), d'un cache (Redis), ou des deux. Gérer chacun avec des commandes `docker run` séparées devient vite compliqué. Docker Compose vous permet de déclarer tous les services dans un seul fichier YAML et de les démarrer ensemble.

Créez un fichier nommé `docker-compose.yml` :

services:
  web:
    build: .
    ports:
      - "8000:8000"
    environment:
      - DATABASE_URL=postgresql://user:pass@db:5432/mydb
    depends_on:
      - db
  db:
    image: postgres:16
    environment:
      - POSTGRES_USER=user
      - POSTGRES_PASSWORD=pass
      - POSTGRES_DB=mydb
    volumes:
      - pgdata:/var/lib/postgresql/data
volumes:
  pgdata:

Notez comment le service `web` fait référence à `db` par nom d'hôte. Docker Compose crée un réseau privé où les services se joignent par nom de service. La directive `depends_on` indique à Docker de démarrer la base de données avant l'application web. Le volume nommé `pgdata` conserve les données de la base en sécurité même si le conteneur est supprimé.

Pour tout démarrer :

docker compose up --build

Ajoutez `-d` pour exécuter en arrière-plan. Pour arrêter et supprimer les conteneurs :

docker compose down

Erreurs courantes et comment les éviter

Oublier le fichier `.dockerignore` est un oubli fréquent. Créez-le à côté de votre Dockerfile :

echo -e "__pycache__\n.git\n.env\n*.pyc" > .dockerignore

Sans cela, votre image contient des fichiers inutiles, ralentit les builds et risque de divulguer des secrets comme les fichiers `.env` contenant des clés API.

Un autre piège consiste à coder en dur les secrets dans l'image. Ne mettez jamais de clés API ou de mots de passe de base de données directement dans le Dockerfile. Utilisez plutôt des variables d'environnement ou montez des fichiers de secrets au moment de l'exécution.

Enfin, exécuter des conteneurs en tant que root par défaut est un risque de sécurité pour la production. Ajoutez un utilisateur non-root à votre Dockerfile lorsque vous êtes prêt à déployer sérieusement.

Résumé

Un Dockerfile décrit comment empaqueter votre application dans une image. Docker Compose orchestre plusieurs conteneurs ensemble via un seul fichier YAML. Pour une application web générée par IA, le flux de travail typique est : écrire un Dockerfile qui copie d'abord les dépendances, construire une image avec `docker build`, l'exécuter avec `docker run -p`, et étendre avec Compose lorsque vous ajoutez des services comme des bases de données. Maîtriser ces quatre commandes et une structure YAML vous mène à 90 % du chemin vers une application conteneurisée prête pour toute plateforme cloud.