Conteneurisation
avec DockerContainerization
with Docker

macOS et Windows : installez Docker Desktop depuis docker.com (Windows : activez WSL 2 quand l'installeur le propose), lancez l'application, puis vérifiez dans un terminal. Ubuntu/Debian : le dépôt officiel, puis le groupe docker pour travailler sans sudo. macOS and Windows: install Docker Desktop from docker.com (Windows: enable WSL 2 when the installer offers it), launch the app, then verify in a terminal. Ubuntu/Debian: the official repository, then the docker group to work without sudo.

# macOS / Windows: install Docker Desktop, start it, then:
docker --version

# Ubuntu / Debian:
sudo apt-get update
sudo apt-get install -y ca-certificates curl
sudo install -m 0755 -d /etc/apt/keyrings
sudo curl -fsSL https://download.docker.com/linux/ubuntu/gpg -o /etc/apt/keyrings/docker.asc
sudo chmod a+r /etc/apt/keyrings/docker.asc
echo "deb [arch=$(dpkg --print-architecture) signed-by=/etc/apt/keyrings/docker.asc] \
  https://download.docker.com/linux/ubuntu $(. /etc/os-release && echo $VERSION_CODENAME) stable" \
  | sudo tee /etc/apt/sources.list.d/docker.list > /dev/null
sudo apt-get update
sudo apt-get install -y docker-ce docker-ce-cli containerd.io docker-buildx-plugin docker-compose-plugin

# post-install (Linux): use docker without sudo
sudo usermod -aG docker $USER
newgrp docker

docker run hello-world

À la racine de fraud-detection/ : la liste exacte de ce que la boîte doit contenir. C'est cette couche qui sera mise en cache — elle change rarement, elle passe en premier dans le Dockerfile. At the root of fraud-detection/: the exact list of what the box must contain. This is the layer that gets cached — it rarely changes, so it goes first in the Dockerfile.

fastapi
uvicorn[standard]
pydantic
scikit-learn
joblib
numpy
pandas

Fichier Dockerfile, à la racine. Notez l'ordre : requirements avant le code, pour que la couche pip reste en cache. Et dès la v1, la boîte n'est pas root : un utilisateur dédié, qui possède data/ pour que /feedback puisse écrire. File Dockerfile, at the root. Note the order: requirements before the code, so the pip layer stays cached. And from v1 on, the box is not root: a dedicated user, who owns data/ so /feedback can write.

FROM python:3.11-slim
WORKDIR /app
COPY requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt
COPY src/ src/
COPY models/ models/
RUN adduser --disabled-password --gecos "" apiuser \
    && mkdir -p /app/data \
    && chown -R apiuser /app/data
USER apiuser
EXPOSE 8000
CMD ["uvicorn", "src.serve.app:app", "--host", "0.0.0.0", "--port", "8000"]

Fichier .dockerignore, à la racine lui aussi. Sans lui, COPY embarque les CSV de data/, le venv et le .git dans le contexte de build — des centaines de Mo inutiles, et parfois des secrets. File .dockerignore, at the root as well. Without it, COPY drags data/'s CSVs, the venv and the .git into the build context — hundreds of useless MB, and sometimes secrets.

data/
.venv/
.git/
notebooks/
__pycache__/
*.pyc
.pytest_cache/
mlruns/

Premier build : chaque instruction crée une couche. Relancez la commande juste après : tout sort du cache en quelques secondes. Notez la taille — c'est la référence à battre. First build: each instruction creates a layer. Rerun the command right after: everything comes from the cache in seconds. Note the size — that is the number to beat.

cd fraud-detection
docker build -t fraud-api:0.1 .
docker images fraud-api

Arrêtez d'abord l'uvicorn local du bloc 3 s'il tourne encore (il occupe le port 8000). Puis lancez le conteneur en arrière-plan et interrogez-le exactement comme au bloc 3 — même API, mais servie depuis la boîte. First stop block 3's local uvicorn if it is still running (it holds port 8000). Then start the container in the background and query it exactly like in block 3 — same API, now served from the box.

docker run -d -p 8000:8000 --name fraud-api fraud-api:0.1
curl -s http://127.0.0.1:8000/health
curl -s -X POST http://127.0.0.1:8000/predict \
  -H "Content-Type: application/json" \
  -d '{"time": 3600, "amount": 129.90, "v14": -8.31, "v12": -5.20}'

Remplacez le Dockerfile : un étage atelier qui installe les dépendances dans /install, un étage final propre qui ne reçoit que le résultat. On livre la boîte, pas l'atelier. Replace the Dockerfile: a workshop stage installing the dependencies into /install, a clean final stage that only receives the result. We ship the box, not the workshop.

FROM python:3.11-slim AS builder
WORKDIR /app
COPY requirements.txt .
RUN pip install --no-cache-dir --prefix=/install -r requirements.txt

FROM python:3.11-slim
WORKDIR /app
COPY --from=builder /install /usr/local
COPY src/ src/
COPY models/ models/
RUN adduser --disabled-password --gecos "" apiuser \
    && mkdir -p /app/data \
    && chown -R apiuser /app/data
USER apiuser
EXPOSE 8000
CMD ["uvicorn", "src.serve.app:app", "--host", "0.0.0.0", "--port", "8000"]

docker build -t fraud-api:0.2 .
docker images fraud-api

Fichier docker-compose.yml, à la racine. Trois organes : l'API construite depuis votre Dockerfile, PostgreSQL avec un volume pour que les transactions survivent, MLflow (qui arrive au bloc 5) avec sa base SQLite sur volume. Les services se joignent par leur nom : db:5432, mlflow:5000 — jamais localhost. File docker-compose.yml, at the root. Three organs: the API built from your Dockerfile, PostgreSQL with a volume so the transactions survive, MLflow (arriving in block 5) with its SQLite store on a volume. Services reach each other by name: db:5432, mlflow:5000 — never localhost.

services:
  api:
    build: .
    image: fraud-api:0.2
    ports:
      - "8000:8000"
    depends_on:
      - db
      - mlflow

  db:
    image: postgres:16-alpine
    environment:
      POSTGRES_USER: dotika
      POSTGRES_PASSWORD: dotika
      POSTGRES_DB: transactions
    ports:
      - "5432:5432"
    volumes:
      - pgdata:/var/lib/postgresql/data

  mlflow:
    image: ghcr.io/mlflow/mlflow:v2.14.1
    command: mlflow server --host 0.0.0.0 --backend-store-uri sqlite:////mlflow/mlflow.db
    ports:
      - "5000:5000"
    volumes:
      - mlflowdata:/mlflow

volumes:
  pgdata:
  mlflowdata:

Retirez le conteneur solo de la mission 1 (il occupe le port 8000), puis une seule commande lève l'organisme entier. Vérifiez ensuite les trois URLs : l'API, MLflow dans le navigateur (http://localhost:5000), et le pouls de la base. Remove mission 1's solo container (it holds port 8000), then a single command raises the whole organism. Then check the three URLs: the API, MLflow in the browser (http://localhost:5000), and the database's pulse.

docker rm -f fraud-api
docker compose up -d
docker compose ps
curl -s http://127.0.0.1:8000/health
curl -s -o /dev/null -w "MLflow: HTTP %{http_code}\n" http://127.0.0.1:5000
docker compose exec db pg_isready -U dotika

Premier geste de tout diagnostic : relire ce que le processus a dit. Le flag -f suit le flux en direct (Ctrl+C pour quitter, le conteneur continue de tourner). The first move of any diagnosis: reread what the process said. The -f flag follows the stream live (Ctrl+C to quit; the container keeps running).

docker compose logs api --tail 20
docker compose logs -f api

Quand les logs ne suffisent pas, on entre dans la boîte : un shell dans le conteneur, pour vérifier que les fichiers attendus sont bien là et sous quelle identité tourne le processus. When the logs are not enough, step into the box: a shell inside the container, to check that the expected files are there and which identity the process runs as.

docker compose exec api sh
ls models/
whoami
python -c "import sklearn; print(sklearn.__version__)"
exit

Un tag versionné dit exactement ce qui tourne — :latest peut changer entre deux déploiements. Épinglez votre image comme les images de base le sont déjà (python:3.11-slim, postgres:16-alpine, mlflow:v2.14.1). A versioned tag says exactly what is running — :latest can change between two deployments. Pin your image just like the base images already are (python:3.11-slim, postgres:16-alpine, mlflow:v2.14.1).

docker tag fraud-api:0.2 fraud-api:1.0.0
docker images fraud-api
docker compose ps