Docker / Kubernetes
From Zero to Hero

Deployment            # ce qu'on écrit, ce qu'on déploie
  └── ReplicaSet      # créé automatiquement, un par révision
        └── Pod(s)    # créés et surveillés par le ReplicaSet
              └── Container(s)   # 1 à N conteneurs par Pod

# Tuer un Pod manuellement
kubectl delete pod flask-7c9b4f-x2p9q -n todo

# Regarder Kubernetes en recréer un (option -w = watch)
kubectl get pods -n todo -w

# Sortie attendue :
# flask-7c9b4f-x2p9q   1/1   Terminating   0   5m
# flask-7c9b4f-k4m7r   0/1   Pending       0   0s   ← nouveau Pod
# flask-7c9b4f-k4m7r   1/1   Running       0   3s

# Monter Flask à 3 replicas
kubectl scale deployment flask --replicas=3 -n todo

# Vérifier que 3 Pods tournent
kubectl get pods -n todo -l app=flask

# Revenir à 1
kubectl scale deployment flask --replicas=1 -n todo

Ingress / Traefik
      ↓ (route HTTP)
Service flask            # IP stable, DNS stable : flask.todo.svc.cluster.local
      ↓ (sélection par label app=flask)
Pod flask-7c9b4f-x2p9q   # IP éphémère
Pod flask-7c9b4f-k4m7r   # IP éphémère
Pod flask-7c9b4f-r3n2v   # IP éphémère

spec:
  containers:
  - name: flask
    image: dmab44/todo-flask:v5
    ports:
    - name: http
      containerPort: 5000
    readinessProbe:
      httpGet:
        path: /health
        port: 5000
      initialDelaySeconds: 5     # attendre 5s avant la première vérif
      periodSeconds: 10            # puis vérifier toutes les 10s
    livenessProbe:
      httpGet:
        path: /health
        port: 5000
      initialDelaySeconds: 15    # plus tardive — laisser le temps de démarrer
      periodSeconds: 20

Deployment flask  (replicas: 3)
  ├── ReplicaSet v5   replicas: 3 → 2 → 1 → 0   # ancien, vidé progressivement
  └── ReplicaSet v6   replicas: 0 → 1 → 2 → 3   # nouveau, monté progressivement

À tout instant : nb Pods total entre (3 - maxUnavailable) et (3 + maxSurge)

spec:
  replicas: 3
  strategy:
    type: RollingUpdate
    rollingUpdate:
      maxUnavailable: 1   # max 1 Pod indisponible pendant la transition
      maxSurge: 1         # max 1 Pod en surnombre temporaire

spec:
  containers:
  - name: flask
    resources:
      requests:
        cpu: "100m"      # 0.1 vCPU réservé — le scheduler en a besoin pour placer le Pod
        memory: "128Mi"
      limits:
        cpu: "500m"      # 0.5 vCPU max — au-delà, throttling
        memory: "512Mi"   # au-delà, OOMKilled

Deployment.spec.template.metadata.labels    →  app: flask, version: v5
       ↓ crée des Pods avec ces labels
Pod.metadata.labels                          →  app: flask, version: v5
       ↑ sélectionnés par
Service.spec.selector                        →  app: flask
       ↑ sélectionné par
ServiceMonitor.spec.selector.matchLabels     →  app: flask
       ↑ sélectionné par
NetworkPolicy.spec.podSelector               →  app: flask

# Voir tous les labels des Pods
kubectl get pods -n todo --show-labels

# Voir le selector d'un Service
kubectl describe service flask -n todo

# Voir si le Service trouve effectivement des Pods
kubectl get endpoints -n todo
# Si vide → selector cassé, aucun Pod ne matche

# Auto-scaler Flask entre 1 et 5 replicas selon CPU
kubectl autoscale deployment flask -n todo \
  --cpu-percent=70 --min=1 --max=5

# Voir le HPA
kubectl get hpa -n todo

# NAME    REFERENCE          TARGETS    MINPODS  MAXPODS  REPLICAS  AGE
# flask   Deployment/flask   34%/70%    1        5        2         3m

# CONTROL PLANE (master node)
┌─────────────────────────────────────────────────────────────┐
│                                                             │
│   kubectl ──► kube-apiserver  ◄──► etcd                     │
│                    ▲                (stockage clé-valeur)   │
│                    │                                        │
│              ┌─────┴─────┐                                  │
│              ▼           ▼                                  │
│       kube-scheduler   kube-controller-manager              │
│       (placement)      (boucles de réconciliation)          │
│                                                             │
└─────────────────────────────────────────────────────────────┘
                              │
                              ▼ (instructions)
┌─────────────────────────────────────────────────────────────┐
│  WORKER NODES                                               │
│                                                             │
│   kubelet ───► container runtime (containerd, CRI-O)        │
│      │              ▼                                       │
│      │         Pods (vos conteneurs)                        │
│      ▼                                                      │
│   kube-proxy (règles iptables / IPVS pour les Services)     │
│                                                             │
└─────────────────────────────────────────────────────────────┘

apiVersion: networking.k8s.io/v1
kind: NetworkPolicy
metadata:
  name: default-deny-all
  namespace: todo
spec:
  podSelector: {}              # s'applique à tous les Pods du namespace
  policyTypes:
    - Ingress
    - Egress
  # Aucune règle = tout bloqué
  # Il faudra ensuite ajouter des NetworkPolicy spécifiques
  # pour autoriser flask → postgres, traefik → flask, etc.

# Image de base légère Python 3.10
FROM python:3.10-slim

# Répertoire de travail dans le conteneur
WORKDIR /app

# Installer uv
RUN pip install uv

# Copier le manifeste de dépendances EN PREMIER
# → Si le code change mais pas les dépendances, cette couche est cachée
COPY pyproject.toml uv.lock ./

# Installer les dépendances dans le venv
RUN uv sync --frozen --no-dev

# Copier le reste du code
COPY app/ ./app/
COPY main.py ./

# Créer le dossier uploads
RUN mkdir -p /app/uploads

# Port exposé (documentation — ne publie pas le port à l'hôte)
EXPOSE 5000

# Commande de démarrage
# debug=False obligatoire pour que /metrics fonctionne
CMD ["uv", "run", "python", "main.py"]

.git
.venv
__pycache__
*.pyc
*.pyo
uploads/
*.env
.env*

from app import create_app

app = create_app()

if __name__ == "__main__":
    # debug=False OBLIGATOIRE
    # Flask debug=True lance 2 process (reloader + worker)
    # prometheus-flask-exporter n'est init que dans 1 des 2 → /metrics cassé
    app.run(host="0.0.0.0", port=5000, debug=False)

from flask import Flask
from prometheus_flask_exporter import PrometheusMetrics
from .db import init_db
from .routes import bp

def create_app():
    app = Flask(__name__, static_folder="static", static_url_path="")

    # Exposition des métriques sur /metrics
    PrometheusMetrics(app)

    # Initialisation de la base de données
    with app.app_context():
        init_db()

    # Enregistrement des routes
    app.register_blueprint(bp)

    return app

import os
import psycopg2
from psycopg2.extras import RealDictCursor

def get_conn():
    # Toutes les variables lues depuis l'environnement
    # → injectées par ConfigMap + Secret en K8s, par -e en Docker
    return psycopg2.connect(
        host=os.environ["DB_HOST"],
        port=os.environ.get("DB_PORT", "5432"),
        dbname=os.environ["DB_NAME"],
        user=os.environ["DB_USER"],
        password=os.environ["DB_PASS"],
        cursor_factory=RealDictCursor,
    )

def init_db():
    with get_conn() as conn, conn.cursor() as cur:
        cur.execute("""
            CREATE TABLE IF NOT EXISTS tasks (
                id SERIAL PRIMARY KEY,
                title TEXT NOT NULL,
                done BOOLEAN DEFAULT FALSE,
                filename TEXT
            )
        """)
        conn.commit()

import os
from flask import Blueprint, request, jsonify, send_from_directory
from .db import get_conn

UPLOAD_DIR = "/app/uploads"
bp = Blueprint("api", __name__, url_prefix="/api")

# ── CRUD ──────────────────────────────────────────────────────────────

@bp.route("/tasks", methods=["GET"])
def list_tasks():
    with get_conn() as conn, conn.cursor() as cur:
        cur.execute("SELECT * FROM tasks ORDER BY id")
        return jsonify(cur.fetchall())

@bp.route("/tasks", methods=["POST"])
def create_task():
    data = request.get_json()
    with get_conn() as conn, conn.cursor() as cur:
        cur.execute("INSERT INTO tasks (title) VALUES (%s) RETURNING *", (data["title"],))
        conn.commit()
        return jsonify(cur.fetchone()), 201

@bp.route("/tasks/<int:task_id>", methods=["PUT"])
def update_task(task_id):
    data = request.get_json()
    with get_conn() as conn, conn.cursor() as cur:
        cur.execute("UPDATE tasks SET title=%s, done=%s WHERE id=%s RETURNING *",
                    (data["title"], data["done"], task_id))
        conn.commit()
        return jsonify(cur.fetchone())

@bp.route("/tasks/<int:task_id>", methods=["DELETE"])
def delete_task(task_id):
    with get_conn() as conn, conn.cursor() as cur:
        cur.execute("DELETE FROM tasks WHERE id=%s", (task_id,))
        conn.commit()
    return "", 204

# ── FICHIERS ──────────────────────────────────────────────────────────

@bp.route("/tasks/<int:task_id>/file", methods=["POST"])
def upload_file(task_id):
    f = request.files["file"]
    path = os.path.join(UPLOAD_DIR, f"{task_id}_{f.filename}")
    f.save(path)
    with get_conn() as conn, conn.cursor() as cur:
        cur.execute("UPDATE tasks SET filename=%s WHERE id=%s", (f.filename, task_id))
        conn.commit()
    return jsonify({"filename": f.filename}), 201

@bp.route("/tasks/<int:task_id>/file", methods=["GET"])
def download_file(task_id):
    with get_conn() as conn, conn.cursor() as cur:
        cur.execute("SELECT filename FROM tasks WHERE id=%s", (task_id,))
        row = cur.fetchone()
    return send_from_directory(UPLOAD_DIR, f"{task_id}_{row['filename']}")

@bp.route("/tasks/<int:task_id>/file", methods=["DELETE"])
def delete_file(task_id):
    with get_conn() as conn, conn.cursor() as cur:
        cur.execute("SELECT filename FROM tasks WHERE id=%s", (task_id,))
        row = cur.fetchone()
        path = os.path.join(UPLOAD_DIR, f"{task_id}_{row['filename']}")
        if os.path.exists(path):
            os.remove(path)
        cur.execute("UPDATE tasks SET filename=NULL WHERE id=%s", (task_id,))
        conn.commit()
    return "", 204

version: "3.9"

services:

  traefik:
    image: traefik:v3.3
    ports:
      - "80:80"
    volumes:
      - /var/run/docker.sock:/var/run/docker.sock
    command:
      - --providers.docker=true
      - --providers.docker.exposedbydefault=false
      - --entrypoints.web.address=:80

  postgres:
    image: postgres:16
    environment:
      POSTGRES_USER: todouser
      POSTGRES_PASSWORD: todopass
      POSTGRES_DB: tododb
    volumes:
      - todo-pgdata:/var/lib/postgresql/data
    healthcheck:
      test: ["CMD", "pg_isready", "-U", "todouser", "-d", "tododb"]
      interval: 5s
      timeout: 3s
      retries: 5

  flask:
    build: .
    environment:
      DB_HOST: postgres
      DB_PORT: "5432"
      DB_NAME: tododb
      DB_USER: todouser
      DB_PASS: todopass
    volumes:
      - ./uploads:/app/uploads
    depends_on:
      postgres:
        condition: service_healthy
    labels:
      - "traefik.enable=true"
      - "traefik.http.routers.flask.rule=Host(`localhost`)"
      - "traefik.http.routers.flask.entrypoints=web"
      - "traefik.http.services.flask.loadbalancer.server.port=5000"

volumes:
  todo-pgdata:

apiVersion: v1
kind: Secret
metadata:
  name: postgres-secret
  namespace: todo
type: Opaque
data:
  # Valeurs encodées en base64 — PAS chiffrées
  # echo -n "todouser" | base64  →  dG9kb3VzZXI=
  DB_USER: dG9kb3VzZXI=
  DB_PASS: dG9kb3Bhc3M=

apiVersion: v1
kind: ConfigMap
metadata:
  name: flask-config
  namespace: todo
data:
  # Variables non sensibles
  # DB_HOST = nom du Service Postgres (DNS interne K8s)
  DB_HOST: postgres
  DB_PORT: "5432"
  DB_NAME: tododb

apiVersion: v1
kind: PersistentVolumeClaim
metadata:
  name: postgres-pvc
  namespace: todo
spec:
  accessModes:
    # RWO = ReadWriteOnce : 1 seul nœud peut monter en écriture
    # Adapté à Postgres (1 writer). RWX nécessiterait CephFS/NFS
    - ReadWriteOnce
  resources:
    requests:
      storage: 1Gi

apiVersion: apps/v1
kind: Deployment
metadata:
  name: postgres
  namespace: todo
spec:
  replicas: 1
  selector:
    matchLabels:
      app: postgres
  template:
    metadata:
      labels:
        app: postgres
    spec:
      containers:
      - name: postgres
        image: postgres:16
        env:
        - name: POSTGRES_USER
          valueFrom:
            secretKeyRef:
              name: postgres-secret
              key: DB_USER
        - name: POSTGRES_PASSWORD
          valueFrom:
            secretKeyRef:
              name: postgres-secret
              key: DB_PASS
        - name: POSTGRES_DB
          value: tododb
        ports:
        - containerPort: 5432
        volumeMounts:
        - name: pgdata
          mountPath: /var/lib/postgresql/data
      volumes:
      - name: pgdata
        persistentVolumeClaim:
          claimName: postgres-pvc

apiVersion: v1
kind: Service
metadata:
  name: postgres   ← DNS interne : postgres.todo.svc.cluster.local
  namespace: todo
spec:
  selector:
    app: postgres  ← doit correspondre aux labels du Pod Postgres
  ports:
  - port: 5432
    targetPort: 5432
  type: ClusterIP  ← interne uniquement, jamais exposé à l'extérieur

apiVersion: apps/v1
kind: Deployment
metadata:
  name: flask
  namespace: todo
spec:
  replicas: 1
  selector:
    matchLabels:
      app: flask       ← ① colle Deployment → ReplicaSet → Pods
  template:
    metadata:
      labels:
        app: flask     ← ① même valeur
    spec:
      containers:
      - name: flask
        image: dmab44/todo-flask:v5  ← ② tag versionné, jamais :latest
        imagePullPolicy: IfNotPresent
        ports:
        - containerPort: 5000
        envFrom:
        - configMapRef:
            name: flask-config     ← ③ DB_HOST, DB_PORT, DB_NAME
        - secretRef:
            name: postgres-secret  ← ③ DB_USER, DB_PASS

apiVersion: v1
kind: Service
metadata:
  name: flask
  namespace: todo
  labels:
    app: flask   ← ④ label du Service lui-même, ciblé par le ServiceMonitor
spec:
  selector:
    app: flask   ← ① route vers les Pods flask
  ports:
  - name: http   ← ⑤ OBLIGATOIRE — le ServiceMonitor référence ce nom
    port: 80
    targetPort: 5000
    nodePort: 30000
  type: NodePort

apiVersion: traefik.io/v1alpha1
kind: IngressRoute   ← CRD Traefik, plus puissant que l'Ingress K8s natif
metadata:
  name: flask
  namespace: todo
spec:
  entryPoints:
    - web
  routes:
  - match: Host(`localhost`) || Host(`127.0.0.1`)
    kind: Rule
    services:
    - name: flask
      port: 80

apiVersion: monitoring.coreos.com/v1
kind: ServiceMonitor   ← CRD installé par kube-prometheus-stack
metadata:
  name: flask
  namespace: todo
spec:
  selector:
    matchLabels:
      app: flask   ← ④ cible le Service dont labels.app=flask
  endpoints:
  - port: http     ← ⑤ nom du port, pas le numéro
    path: /metrics
    interval: 15s

# Ajouter les repos (à faire une seule fois)
helm repo add traefik https://traefik.github.io/charts
helm repo add prometheus-community https://prometheus-community.github.io/helm-charts
helm repo update

# Installer kube-prometheus-stack
# Ce chart installe : Prometheus + Grafana + AlertManager + node-exporter + kube-state-metrics
# + l'Operator Prometheus + toutes les CRDs associées
helm install prometheus prometheus-community/kube-prometheus-stack \
  --namespace todo \
  --set grafana.adminPassword=admin \
  --set prometheus.prometheusSpec.serviceMonitorSelectorNilUsesHelmValues=false
# ↑ Ce flag est critique : sans lui, l'Operator ignore les ServiceMonitors
#   qui ne portent pas le label Helm de la release. Il faut le passer à false
#   pour que l'Operator scrape TOUS les ServiceMonitors du namespace.

# Vérifier ce que Helm a déployé
helm list -n todo
kubectl get all -n todo

from prometheus_flask_exporter import PrometheusMetrics

def create_app():
    app = Flask(__name__, ...)
    PrometheusMetrics(app)  # expose /metrics automatiquement
    ...

# 1. Vérifier que Flask expose bien /metrics
#    (depuis un shell dans le Pod Flask)
kubectl exec -it -n todo deployment/flask -- curl localhost:5000/metrics

# 2. Vérifier que le ServiceMonitor est reconnu par l'Operator
kubectl get servicemonitor -n todo

# 3. Ouvrir Prometheus et vérifier que Flask est dans les targets
kubectl port-forward -n todo svc/prometheus-kube-prometheus-prometheus 9090:9090
# http://127.0.0.1:9090/targets → chercher "flask"
# État attendu : UP. Si DOWN ou absent : vérifier la chaîne de labels

# 4. Ouvrir Grafana
kubectl port-forward -n todo svc/prometheus-grafana 3000:80
# http://127.0.0.1:3000 — admin / admin
# Explore → datasource Prometheus → requête : flask_http_request_total