Lab : conteneuriser l'application Signalements

"""Signalements : une petite application de démonstration.

Les habitants d'une commune signalent un problème (lampadaire en panne,
nid-de-poule...). Sans DATABASE_URL, les signalements sont gardés en mémoire.
"""
import os
import socket

from flask import Flask, jsonify, request

app = Flask(__name__)
DATABASE_URL = os.environ.get("DATABASE_URL")
_memoire = []


def connexion():
    import psycopg
    return psycopg.connect(DATABASE_URL, connect_timeout=3)


def initialiser():
    if DATABASE_URL:
        with connexion() as cnx:
            cnx.execute(
                "CREATE TABLE IF NOT EXISTS signalements ("
                " id serial PRIMARY KEY,"
                " lieu text NOT NULL,"
                " description text NOT NULL,"
                " cree_le timestamptz NOT NULL DEFAULT now())"
            )


@app.get("/")
def accueil():
    return jsonify(
        application="signalements",
        version=os.environ.get("APP_VERSION", "dev"),
        conteneur=socket.gethostname(),
        stockage="postgresql" if DATABASE_URL else "memoire",
    )


@app.get("/signalements")
def lister():
    if not DATABASE_URL:
        return jsonify(_memoire)
    with connexion() as cnx:
        lignes = cnx.execute(
            "SELECT id, lieu, description FROM signalements ORDER BY id"
        ).fetchall()
    return jsonify([{"id": i, "lieu": l, "description": d} for i, l, d in lignes])


@app.post("/signalements")
def creer():
    donnees = request.get_json(force=True)
    lieu, description = donnees["lieu"], donnees["description"]
    if not DATABASE_URL:
        _memoire.append({"id": len(_memoire) + 1, "lieu": lieu, "description": description})
        return jsonify(_memoire[-1]), 201
    with connexion() as cnx:
        (ident,) = cnx.execute(
            "INSERT INTO signalements (lieu, description) VALUES (%s, %s) RETURNING id",
            (lieu, description),
        ).fetchone()
    return jsonify(id=ident, lieu=lieu, description=description), 201


@app.get("/sante")
def sante():
    if DATABASE_URL:
        try:
            with connexion() as cnx:
                cnx.execute("SELECT 1")
        except Exception as erreur:  # la base est injoignable
            return jsonify(etat="degrade", erreur=str(erreur)), 503
    return jsonify(etat="ok")


initialiser()

flask==3.1.3
gunicorn==26.2.0
psycopg[binary]==3.3.6

$ docker build -t signalements:1.0 .
$ docker run --rm -d --name essai -p 127.0.0.1:8000:8000 signalements:1.0
$ curl -s localhost:8000/
$ docker stop essai

$ printf 'POSTGRES_PASSWORD=%s\n' "$(openssl rand -base64 24)" > .env
$ chmod 600 .env

#!/usr/bin/env bash
# Vérifie que le projet Signalements respecte les exigences du lab.
# Usage : ./verifier.sh   (depuis le répertoire du projet, avec un fichier .env)
set -uo pipefail
projet=signalements
ok=0; ko=0
verifier() {  # verifier "description" commande...
  local description=$1; shift
  if "$@" >/dev/null 2>&1; then echo "  OK  $description"; ok=$((ok+1))
  else echo "  KO  $description"; ko=$((ko+1)); fi
}
app() { docker compose ps -q app; }
db()  { docker compose ps -q db; }

echo "Démarrage du projet..."
docker compose -f compose.yaml up -d --wait --build >/dev/null 2>&1 || { echo "échec du démarrage"; exit 1; }

echo "Image et exécution"
verifier "l'application ne tourne pas en root" \
  bash -c '[ "$(docker exec '"$(app)"' id -u)" != "0" ]'
verifier "toutes les capabilities retirées (cap_drop: ALL)" \
  bash -c 'docker inspect -f "{{.HostConfig.CapDrop}}" '"$(app)"' | grep -q ALL'
verifier "no-new-privileges actif" \
  bash -c 'docker exec '"$(app)"' grep -q "NoNewPrivs:\s*1" /proc/1/status'
verifier "racine en lecture seule" \
  bash -c '[ "$(docker inspect -f "{{.HostConfig.ReadonlyRootfs}}" '"$(app)"')" = true ]'
verifier "limite mémoire définie" \
  bash -c '[ "$(docker inspect -f "{{.HostConfig.Memory}}" '"$(app)"')" -gt 0 ]'
verifier "CMD en forme exec (PID 1 n'est pas un shell)" \
  bash -c '! docker top '"$(app)"' -o pid,cmd | sed -n 2p | grep -q "/bin/sh -c"'

echo "Réseau"
verifier "la base n'a aucun port publié" \
  bash -c '[ -z "$(docker port '"$(db)"')" ]'
verifier "l'application est publiée sur 127.0.0.1 seulement" \
  bash -c 'docker port '"$(app)"' | grep -qx "8000/tcp -> 127.0.0.1:8000"'
verifier "la base est sur un réseau interne uniquement" \
  bash -c 'for n in $(docker inspect -f "{{range \$k,\$v := .NetworkSettings.Networks}}{{\$k}} {{end}}" '"$(db)"'); do [ "$(docker network inspect -f "{{.Internal}}" $n)" = true ] || exit 1; done'

echo "Fonctionnement"
verifier "vérification de santé : healthy" \
  bash -c '[ "$(docker inspect -f "{{.State.Health.Status}}" '"$(app)"')" = healthy ]'
verifier "création d'un signalement" \
  curl -sf -X POST localhost:8000/signalements -H 'Content-Type: application/json' -d '{"lieu":"Lab","description":"vérification"}'
verifier "arrêt propre en moins de 5 secondes" \
  bash -c 'debut=$(date +%s); docker compose stop app; fin=$(date +%s); [ $((fin-debut)) -lt 5 ] && [ "$(docker inspect -f "{{.State.ExitCode}}" '"$(app)"')" = 0 ]'

echo "Persistance"
docker compose -f compose.yaml down >/dev/null 2>&1
docker compose -f compose.yaml up -d --wait >/dev/null 2>&1
verifier "les données survivent à docker compose down / up" \
  bash -c 'curl -sf localhost:8000/signalements | grep -q "\"lieu\":\"Lab\""'

echo
echo "Résultat : $ok vérification(s) réussie(s), $ko échouée(s)."
[ "$ko" -eq 0 ]

Démarrage du projet...
Image et exécution
  OK  l'application ne tourne pas en root
  OK  toutes les capabilities retirées (cap_drop: ALL)
  OK  no-new-privileges actif
  OK  racine en lecture seule
  OK  limite mémoire définie
  OK  CMD en forme exec (PID 1 n'est pas un shell)
Réseau
  OK  la base n'a aucun port publié
  OK  l'application est publiée sur 127.0.0.1 seulement
  OK  la base est sur un réseau interne uniquement
Fonctionnement
  OK  vérification de santé : healthy
  OK  création d'un signalement
  OK  arrêt propre en moins de 5 secondes
Persistance
  OK  les données survivent à docker compose down / up

Résultat : 13 vérification(s) réussie(s), 0 échouée(s).

  KO  toutes les capabilities retirées (cap_drop: ALL)
Résultat : 12 vérification(s) réussie(s), 1 échouée(s).