spec:
  selector:
    app: api-produits          # todo Pod con ESTE label es alcanzado

kubectl get endpoints api-produits
# api-produits   10.244.0.3:8000,10.244.0.4:8000,10.244.0.5:8000

kind: StatefulSet
spec:
  serviceName: bd-interne         # <-- apunta a un Service headless del mismo nombre
  replicas: 3

bd-0.bd-interne         -> IP del Pod bd-0 ÚNICAMENTE
bd-1.bd-interne         -> IP del Pod bd-1 ÚNICAMENTE
bd-interne              -> IPs de los tres Pods (lista)

spec:
  clusterIP: None                  # transforma el Service en "headless"

ports:
  - name: web
    port: 80
    targetPort: 8080
  - name: prom
    port: 9090
    targetPort: 9090

ports:
  - name: web
    port: 80
    targetPort: web              # remite al containerPort nombrado "web"

apiVersion: v1
kind: Service
metadata:
  name: paiement-externe
spec:
  type: ExternalName
  externalName: example.com

projet12-mission-services/
├── 00-ENONCE.md                      <- este documento
│
├── apps/                             <- EL CÓDIGO (ANEXO A) — NO MODIFICAR
│   ├── micro/
│   │   ├── app.py
│   │   ├── requirements.txt
│   │   └── Dockerfile
│   ├── metriques/
│   │   ├── app.py
│   │   ├── requirements.txt
│   │   └── Dockerfile
│   └── portail/
│       ├── app.py
│       ├── requirements.txt
│       └── Dockerfile
│
├── k8s/
│   ├── 01-deployments.yaml           <- SUMINISTRADO (ANEXO B) — NO MODIFICAR
│   ├── 02-statefulset-bd.yaml        <- SUMINISTRADO (ANEXO B) — NO MODIFICAR
│   │
│   └── services/                     <- TE TOCA A TI
│       ├── 01-api-produits.yaml      <- esqueleto a completar (ANEXO C)
│       ├── 02-portail.yaml           <- esqueleto a completar (ANEXO C)
│       ├── 03-bd-interne.yaml        <- esqueleto a completar (ANEXO C)
│       ├── 04-metriques.yaml         <- esqueleto a completar (ANEXO C)
│       ├── 05-paiement-externe.yaml  <- esqueleto a completar (ANEXO C)
│       │
│       └── 06-casses/                <- SUMINISTRADOS pero DEFECTUOSOS (ANEXO D)
│           ├── casse-1.yaml
│           ├── casse-2.yaml
│           └── casse-3.yaml
│
├── outils/
│   └── valider.ps1                   <- SUMINISTRADO (ANEXO E)
│
└── RAPPORT.md                        <- A REDACTAR por ti

# 0) Situarse en el clúster correcto (imprescindible si minikube o kind ya se usaron)
kubectl config use-context docker-desktop
kubectl get nodes                       # debe mostrar docker-desktop   Ready

# 1) Construir las tres imágenes
docker build -t micro:1.0      ./apps/micro
docker build -t metriques:1.0  ./apps/metriques
docker build -t portail:1.0    ./apps/portail

# 2) Desplegar la base suministrada (Pods, y NINGÚN Service)
kubectl apply -f k8s/01-deployments.yaml
kubectl apply -f k8s/02-statefulset-bd.yaml

# 3) Esperar a que TODOS los Pods estén Ready (unos 30 s)
kubectl wait --for=condition=ready pod --all --timeout=180s

# 4) Constatar la situación de partida
kubectl get pods                        # 14 Pods, todos Running
kubectl get svc                         # solo "kubernetes": ninguno de tus Services

kubectl apply -f k8s/services/01-api-produits.yaml
kubectl get svc api-produits
kubectl get endpoints api-produits        # debe listar 3 direcciones IP

kubectl get svc portail                   # PORT(S) debe mostrar 80:30500/TCP
start http://localhost:30500

bd-0.bd-interne

# 1) Desde un Pod utilitario, alcanzar directamente bd-0:
kubectl run test --rm -i --restart=Never --image=busybox:1.36 -- wget -qO- http://bd-0.bd-interne:5432/ping
# debe responder : {"pod":"bd-0","port":5432,"service":"base-de-donnees"}

# 2) Verificar las entradas DNS con el nombre plenamente cualificado
#    (busybox nslookup NO aplica los search domains, hay que dar el FQDN):
kubectl run test --rm -i --restart=Never --image=busybox:1.36 -- nslookup bd-0.bd-interne.default.svc.cluster.local
# debe devolver UNA sola dirección (la del Pod bd-0)

kubectl run test --rm -i --restart=Never --image=busybox:1.36 -- nslookup bd-interne.default.svc.cluster.local
# debe devolver TRES direcciones (una por Pod del StatefulSet)

kubectl describe svc metriques            # deben aparecer los DOS puertos

kubectl run test --rm -i --restart=Never --image=busybox:1.36 -- nslookup paiement-externe.default.svc.cluster.local
# debe mostrar:
#   paiement-externe.default.svc.cluster.local  canonical name = example.com
#   Name: example.com
#   Address: <IP publique>

kubectl apply -f k8s/services/06-casses/

.\outils\valider.ps1

[OK]     Mission 1 - api-produits ............. 15/15
[OK]     Mission 2 - portail .................. 15/15
[ECHEC]  Mission 3 - bd-interne ...............  0/20   -> clusterIP doit valoir None
[OK]     Mission 4 - metriques ................ 15/15
[ECHEC]  Mission 5 - paiement-externe .........  0/10   -> Service introuvable
[ECHEC]  Mission 6 - reparations ..............  7/20   -> cache : aucun Pod ne repond

SCORE : 52 / 100

kubectl get svc                              # tipos, IP, puertos
kubectl describe svc <nom>                   # detalles + Endpoints
kubectl get endpoints <nom>                  # ¿QUIÉN está detrás del Service?
kubectl get pods --show-labels               # los labels reales de los Pods
kubectl get pods -l app=<valeur>             # probar un selector
kubectl port-forward deploy/portail 5000:5000    # acceder a un Pod SIN Service
kubectl run test --rm -i --restart=Never --image=busybox:1.36 -- wget -qO- http://<nom>/ping
kubectl run test --rm -i --restart=Never --image=busybox:1.36 -- nslookup <nom>.default.svc.cluster.local
kubectl logs -l app=portail --tail=30        # lo que el portal no consigue alcanzar
kubectl delete svc <nom>                     # volver a cero en un Service

"""Microservicio genérico de demostración.

La misma imagen sirve a varios componentes: el nombre y el puerto de escucha
los aportan variables de entorno (APP_NAME, PORT).
Cada respuesta contiene el nombre del Pod, lo que hace visible el
reparto de carga que realiza un Service.
"""

import os
import socket

from flask import Flask, jsonify

app = Flask(__name__)

NOM = os.environ.get("APP_NAME", "micro")
PORT = int(os.environ.get("PORT", "8000"))


@app.route("/")
@app.route("/ping")
def ping():
    return jsonify(service=NOM, pod=socket.gethostname(), port=PORT)


@app.route("/health")
def health():
    return "OK", 200


if __name__ == "__main__":
    app.run(host="0.0.0.0", port=PORT)

flask==3.0.3

FROM python:3.12-slim
WORKDIR /app
COPY requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt
COPY app.py .
CMD ["python", "app.py"]

"""Componente que expone DOS puertos a la vez.

  - 8080 : interfaz web          (ruta /ping)
  - 9090 : métricas Prometheus   (ruta /metrics)

Dos servidores Flask corren en dos hilos de ejecución distintos.
"""

import socket
import threading

from flask import Flask, jsonify

web = Flask("web")
prom = Flask("prom")


@web.route("/")
@web.route("/ping")
def ping():
    return jsonify(service="metriques", pod=socket.gethostname(), port=8080)


@web.route("/health")
def health_web():
    return "OK", 200


@prom.route("/metrics")
def metrics():
    pod = socket.gethostname()
    corps = (
        "# HELP demo_requetes_total Nombre total de requetes\n"
        "# TYPE demo_requetes_total counter\n"
        'demo_requetes_total{pod="%s"} 42\n' % pod
    )
    return corps, 200, {"Content-Type": "text/plain; charset=utf-8"}


@prom.route("/health")
def health_prom():
    return "OK", 200


def demarrer(application, port):
    application.run(host="0.0.0.0", port=port)


if __name__ == "__main__":
    threading.Thread(target=demarrer, args=(prom, 9090), daemon=True).start()
    demarrer(web, 8080)

flask==3.0.3

FROM python:3.12-slim
WORKDIR /app
COPY requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt
COPY app.py .
CMD ["python", "app.py"]

"""Tablero de las conexiones del clúster.

Para cada conexión, el portail distingue TRES situaciones:
  - ROUGE  : el nombre DNS no existe       -> el Service no se ha creado
  - ORANGE : el nombre resuelve, sin respuesta -> selector o puerto erróneo
  - VERT   : la comunicación funciona      -> el Service es correcto
"""

import socket
import urllib.error
import urllib.parse
import urllib.request

from flask import Flask, request

app = Flask(__name__)

DELAI = 1.5          # segundos
PORT_ATTENDU = 30500  # puerto por el que debe consultarse el portail

CIBLES = [
    {"cle": "externe", "titre": "Acces externe", "mode": "externe",
     "aide": "Le portail doit etre consulte via http://localhost:30500"},
    {"cle": "produits", "titre": "API Produits", "mode": "http",
     "url": "http://api-produits/ping"},
    {"cle": "bd", "titre": "Base de donnees (bd-0)", "mode": "http",
     "url": "http://bd-0.bd-interne:5432/ping"},
    {"cle": "metriques", "titre": "Metriques (2 ports)", "mode": "http2",
     "url": "http://metriques/ping", "url2": "http://metriques:9090/metrics"},
    {"cle": "paiement", "titre": "Paiement externe", "mode": "dns",
     "hote": "paiement-externe"},
    {"cle": "commandes", "titre": "API Commandes", "mode": "http",
     "url": "http://api-commandes/ping"},
    {"cle": "cache", "titre": "Cache", "mode": "http",
     "url": "http://cache/ping"},
    {"cle": "notifications", "titre": "Notifications", "mode": "http",
     "url": "http://notifications/ping"},
]


def resout(hote):
    try:
        socket.getaddrinfo(hote, None)
        return True
    except socket.gaierror:
        return False


def tester_http(url):
    hote = urllib.parse.urlparse(url).hostname
    if not resout(hote):
        return "rouge", "nom DNS introuvable : le Service n'existe pas"
    try:
        with urllib.request.urlopen(url, timeout=DELAI) as reponse:
            corps = reponse.read(160).decode("utf-8", "ignore")
        return "vert", corps.strip()
    except urllib.error.HTTPError as err:
        return "orange", "reponse HTTP %s" % err.code
    except Exception as err:
        return "orange", "nom resolu mais aucune reponse (%s)" % type(err).__name__


def evaluer(cible):
    mode = cible["mode"]

    if mode == "externe":
        port = (request.host.split(":") + ["80"])[1]
        if str(port) == str(PORT_ATTENDU):
            return "vert", "consulte via le port %s" % PORT_ATTENDU
        return "orange", "consulte via le port %s : ecrivez le Service du portail" % port

    if mode == "dns":
        if resout(cible["hote"]):
            return "vert", "le nom %s est resolu" % cible["hote"]
        return "rouge", "le nom %s n'est pas resolu" % cible["hote"]

    if mode == "http2":
        etat1, det1 = tester_http(cible["url"])
        etat2, det2 = tester_http(cible["url2"])
        if etat1 == "vert" and etat2 == "vert":
            return "vert", "les deux ports repondent"
        if etat1 == "rouge" or etat2 == "rouge":
            return "rouge", "port 80 : %s | port 9090 : %s" % (det1, det2)
        return "orange", "port 80 : %s | port 9090 : %s" % (det1, det2)

    return tester_http(cible["url"])


COULEURS = {"vert": "#16a34a", "orange": "#ea580c", "rouge": "#b91c1c"}


@app.route("/health")
def health():
    return "OK", 200


@app.route("/")
def accueil():
    resultats = []
    for cible in CIBLES:
        etat, detail = evaluer(cible)
        resultats.append((cible["titre"], etat, detail))

    score = sum(1 for _, etat, _ in resultats if etat == "vert")
    total = len(resultats)

    tuiles = ""
    for titre, etat, detail in resultats:
        tuiles += """
        <div class="tuile" style="border-left:10px solid {couleur}">
          <div class="t">{titre}</div>
          <div class="e" style="color:{couleur}">{etat}</div>
          <div class="d">{detail}</div>
        </div>""".format(couleur=COULEURS[etat], titre=titre,
                         etat=etat.upper(), detail=detail)

    couleur_score = "#16a34a" if score == total else "#ea580c"

    return """<!DOCTYPE html>
<html lang="fr">
<head>
  <meta charset="UTF-8">
  <meta http-equiv="refresh" content="3">
  <title>Mission : retablir les communications</title>
  <style>
    body {{ font-family: system-ui, sans-serif; background:#0f172a; color:#e2e8f0;
            margin:0; padding:32px; }}
    h1 {{ margin:0 0 4px; }}
    .sous {{ color:#94a3b8; margin-bottom:24px; }}
    .score {{ font-size:2.4rem; font-weight:800; color:{couleur_score}; margin-bottom:24px; }}
    .grille {{ display:grid; grid-template-columns:repeat(auto-fill,minmax(320px,1fr)); gap:16px; }}
    .tuile {{ background:#1e293b; border-radius:12px; padding:16px 20px;
              box-shadow:0 6px 20px rgba(0,0,0,.35); }}
    .t {{ font-weight:700; font-size:1.05rem; }}
    .e {{ font-weight:800; font-size:.8rem; letter-spacing:2px; margin:6px 0; }}
    .d {{ color:#94a3b8; font-size:.85rem; word-break:break-word; }}
    .pied {{ margin-top:28px; color:#64748b; font-size:.85rem; }}
  </style>
</head>
<body>
  <h1>Mission : retablir les communications du cluster</h1>
  <div class="sous">Servi par le pod <strong>{pod}</strong> &middot; rafraichissement automatique toutes les 3 s</div>
  <div class="score">{score} / {total}</div>
  <div class="grille">{tuiles}</div>
  <div class="pied">ROUGE : le Service n'existe pas &middot; ORANGE : selecteur ou port errone &middot; VERT : liaison etablie</div>
</body>
</html>""".format(pod=socket.gethostname(), score=score, total=total,
                  tuiles=tuiles, couleur_score=couleur_score)


if __name__ == "__main__":
    app.run(host="0.0.0.0", port=5000)

flask==3.0.3

FROM python:3.12-slim
WORKDIR /app
COPY requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt
COPY app.py .
CMD ["python", "app.py"]

# ---------------------------------------------------------------------------
# LOS PODS DE LA PLATAFORMA — SUMINISTRADO, NO MODIFICAR
# Observa con atención: los LABELS y los PUERTOS declarados aquí son la única
# información de la que dispones para escribir tus Services.
# ---------------------------------------------------------------------------
apiVersion: apps/v1
kind: Deployment
metadata:
  name: portail
spec:
  replicas: 1
  selector:
    matchLabels:
      app: portail
  template:
    metadata:
      labels:
        app: portail
    spec:
      containers:
        - name: portail
          image: portail:1.0
          imagePullPolicy: IfNotPresent
          ports:
            - containerPort: 5000
          readinessProbe:
            httpGet: { path: /health, port: 5000 }
            initialDelaySeconds: 3
            periodSeconds: 5
---
apiVersion: apps/v1
kind: Deployment
metadata:
  name: api-produits
spec:
  replicas: 3
  selector:
    matchLabels:
      app: api-produits
  template:
    metadata:
      labels:
        app: api-produits
    spec:
      containers:
        - name: micro
          image: micro:1.0
          imagePullPolicy: IfNotPresent
          env:
            - { name: APP_NAME, value: "api-produits" }
            - { name: PORT,     value: "8000" }
          ports:
            - containerPort: 8000
          readinessProbe:
            httpGet: { path: /health, port: 8000 }
            initialDelaySeconds: 3
            periodSeconds: 5
---
apiVersion: apps/v1
kind: Deployment
metadata:
  name: api-commandes
spec:
  replicas: 2
  selector:
    matchLabels:
      app: api-commandes
  template:
    metadata:
      labels:
        app: api-commandes
    spec:
      containers:
        - name: micro
          image: micro:1.0
          imagePullPolicy: IfNotPresent
          env:
            - { name: APP_NAME, value: "api-commandes" }
            - { name: PORT,     value: "8000" }
          ports:
            - containerPort: 8000
          readinessProbe:
            httpGet: { path: /health, port: 8000 }
            initialDelaySeconds: 3
            periodSeconds: 5
---
apiVersion: apps/v1
kind: Deployment
metadata:
  name: cache
spec:
  replicas: 1
  selector:
    matchLabels:
      app: cache
  template:
    metadata:
      labels:
        app: cache
    spec:
      containers:
        - name: micro
          image: micro:1.0
          imagePullPolicy: IfNotPresent
          env:
            - { name: APP_NAME, value: "cache" }
            - { name: PORT,     value: "6379" }
          ports:
            - containerPort: 6379
          readinessProbe:
            httpGet: { path: /health, port: 6379 }
            initialDelaySeconds: 3
            periodSeconds: 5
---
apiVersion: apps/v1
kind: Deployment
metadata:
  name: notifications
spec:
  replicas: 2
  selector:
    matchLabels:
      app: notifications
  template:
    metadata:
      labels:
        app: notifications
    spec:
      containers:
        - name: micro
          image: micro:1.0
          imagePullPolicy: IfNotPresent
          env:
            - { name: APP_NAME, value: "notifications" }
            - { name: PORT,     value: "7000" }
          ports:
            - containerPort: 7000
          readinessProbe:
            httpGet: { path: /health, port: 7000 }
            initialDelaySeconds: 3
            periodSeconds: 5
---
apiVersion: apps/v1
kind: Deployment
metadata:
  name: metriques
spec:
  replicas: 2
  selector:
    matchLabels:
      app: metriques
  template:
    metadata:
      labels:
        app: metriques
    spec:
      containers:
        - name: metriques
          image: metriques:1.0
          imagePullPolicy: IfNotPresent
          ports:
            - name: web            # <-- puerto NOMBRADO
              containerPort: 8080
            - name: prom           # <-- puerto NOMBRADO
              containerPort: 9090
          readinessProbe:
            httpGet: { path: /health, port: 8080 }
            initialDelaySeconds: 3
            periodSeconds: 5

# ---------------------------------------------------------------------------
# LA BASE DE DATOS (3 réplicas) — SUMINISTRADO, NO MODIFICAR
#
# ATENCIÓN: el campo serviceName de abajo impone el NOMBRE del Service que
# deberás escribir para que bd-0, bd-1 y bd-2 obtengan cada uno un nombre DNS.
# ---------------------------------------------------------------------------
apiVersion: apps/v1
kind: StatefulSet
metadata:
  name: bd
spec:
  serviceName: bd-interne          # <-- lee bien esta línea
  replicas: 3
  selector:
    matchLabels:
      app: bd
  template:
    metadata:
      labels:
        app: bd
    spec:
      containers:
        - name: micro
          image: micro:1.0
          imagePullPolicy: IfNotPresent
          env:
            - { name: APP_NAME, value: "base-de-donnees" }
            - { name: PORT,     value: "5432" }
          ports:
            - containerPort: 5432
          readinessProbe:
            httpGet: { path: /health, port: 5432 }
            initialDelaySeconds: 3
            periodSeconds: 5

# MISIÓN 1 — Hacer que la API productos sea accesible desde el portail.
#
# El portail llama a:  http://api-produits        (luego el puerto 80)
# Los Pods escuchan en: 8000
# Los Pods llevan el label: app: api-produits
#
# ? ¿Qué tipo de Service para una comunicación INTERNA al clúster?
apiVersion: v1
kind: Service
metadata:
  name: api-produits          # nombre IMPUESTO: no cambiar
spec:
  type: TODO
  selector:
    TODO: TODO
  ports:
    - port: TODO              # el puerto por el que llaman los clientes
      targetPort: TODO        # el puerto que realmente escucha el contenedor

# MISIÓN 2 — Hacer accesible el tablero desde el navegador,
#             en la dirección exacta: http://localhost:30500
#
# Los Pods escuchan en: 5000
# Los Pods llevan el label: app: portail
#
# ? ¿Qué tipo de Service abre un puerto en la MÁQUINA?
# ? ¿Cuál es el rango autorizado para ese puerto?
# ? ¿Qué campo extra hay que añadir para imponer el puerto 30500?
apiVersion: v1
kind: Service
metadata:
  name: portail               # nombre IMPUESTO: no cambiar
spec:
  type: TODO
  selector:
    TODO: TODO
  ports:
    - port: TODO
      targetPort: TODO
      # ? aquí falta una línea

# MISIÓN 3 — Dar un nombre DNS INDIVIDUAL a cada réplica de la base,
#             para poder contactar exactamente: bd-0.bd-interne
#
# Los Pods escuchan en: 5432
# Los Pods llevan el label: app: bd
#
# ? ¿Qué tipo de Service NO tiene una IP virtual única?
# ? ¿Qué campo, con qué valor muy particular, produce ese efecto?
# ? El nombre de abajo debe coincidir con qué campo del StatefulSet?
apiVersion: v1
kind: Service
metadata:
  name: bd-interne            # nombre IMPUESTO: no cambiar
spec:
  # ? aquí falta una línea esencial
  selector:
    TODO: TODO
  ports:
    - port: TODO
      targetPort: TODO

# MISIÓN 4 — Exponer DOS puertos en un solo y mismo Service.
#
# El portail llama a:  http://metriques         (puerto 80)
#                  y a: http://metriques:9090/metrics
#
# Los Pods escuchan en: 8080 (puerto nombrado "web") y 9090 (puerto nombrado "prom")
# Los Pods llevan el label: app: metriques
#
# ? ¿Qué restricción se vuelve OBLIGATORIA en cuanto un Service expone varios puertos?
# ? ¿Cómo hacer que targetPort apunte a un puerto del contenedor POR SU NOMBRE?
apiVersion: v1
kind: Service
metadata:
  name: metriques             # nombre IMPUESTO: no cambiar
spec:
  type: TODO
  selector:
    TODO: TODO
  ports:
    - TODO: TODO              # ? falta un campo obligatorio en cada entrada
      port: TODO
      targetPort: TODO
    - TODO: TODO
      port: TODO
      targetPort: TODO

# MISIÓN 5 — Hacer que un nombre INTERNO apunte a un servicio EXTERNO.
#
# El portail usa el nombre: paiement-externe
# Ese nombre debe resolver hacia: example.com
#
# ? ¿Qué tipo de Service crea un simple alias DNS (CNAME)?
# ? ¿Este tipo tiene un selector? ¿puertos? ¿Pods?
apiVersion: v1
kind: Service
metadata:
  name: paiement-externe      # nombre IMPUESTO: no cambiar
spec:
  type: TODO
  TODO: TODO                  # ? el campo que indica el destino externo

# AVERÍA 1
# Síntoma: el Service existe, pero "kubectl get endpoints api-commandes"
#            devuelve <none>. El portail muestra una baldosa ORANGE.
apiVersion: v1
kind: Service
metadata:
  name: api-commandes
spec:
  type: ClusterIP
  selector:
    app: api-commande
  ports:
    - port: 80
      targetPort: 8000

# AVERÍA 2
# Síntoma: "kubectl get endpoints cache" muestra bien una dirección IP,
#            pero cualquier conexión falla. El portail muestra una baldosa ORANGE.
apiVersion: v1
kind: Service
metadata:
  name: cache
spec:
  type: ClusterIP
  selector:
    app: cache
  ports:
    - port: 80
      targetPort: 6380

# AVERÍA 3
# Síntoma: este Service parece perfecto (tipo correcto, selector correcto,
#            Endpoints rellenos, puertos coherentes)... y sin embargo el portail
#            muestra una baldosa ROUGE y NUNCA lo alcanza.
apiVersion: v1
kind: Service
metadata:
  name: notification
spec:
  type: ClusterIP
  selector:
    app: notifications
  ports:
    - port: 80
      targetPort: 7000

# ---------------------------------------------------------------------------
# Script de validación — da una puntuación, NUNCA la solución.
# Uso:  .\outils\valider.ps1
# ---------------------------------------------------------------------------

$total = 0

function Existe($nom) {
    kubectl get svc $nom -o name 2>$null | Out-Null
    return $LASTEXITCODE -eq 0
}

function Afficher($libelle, $points, $max, $note) {
    $etat = if ($points -eq $max) { "[OK]    " } else { "[ECHEC] " }
    $ligne = "{0} {1} {2}/{3}" -f $etat, $libelle.PadRight(34, '.'), $points, $max
    if ($note) { $ligne += "   -> $note" }
    Write-Host $ligne
}

Write-Host ""
Write-Host "=== VALIDATION — Mission : retablir les communications ===" -ForegroundColor Cyan
Write-Host ""

# --- Misión 1 : api-produits ---------------------------------------------
$p = 0; $note = ""
if (-not (Existe "api-produits")) { $note = "Service api-produits introuvable" }
else {
    $eps = (kubectl get endpoints api-produits -o jsonpath="{.subsets[*].addresses[*].ip}" 2>$null)
    $tp  = (kubectl get svc api-produits -o jsonpath="{.spec.ports[0].targetPort}" 2>$null)
    if (-not $eps) { $note = "Endpoints vides : le selecteur ne correspond a aucun Pod" }
    elseif ("$tp" -ne "8000") { $note = "targetPort ne correspond pas au port ecoute" }
    else { $p = 15 }
}
Afficher "Mission 1 - api-produits" $p 15 $note; $total += $p

# --- Misión 2 : portail ---------------------------------------------------
$p = 0; $note = ""
if (-not (Existe "portail")) { $note = "Service portail introuvable" }
else {
    $type = (kubectl get svc portail -o jsonpath="{.spec.type}" 2>$null)
    $np   = (kubectl get svc portail -o jsonpath="{.spec.ports[0].nodePort}" 2>$null)
    if ("$np" -ne "30500") { $note = "le port expose sur la machine doit etre 30500 (actuel : '$np')" }
    elseif ($type -notin @("NodePort", "LoadBalancer")) { $note = "type inadapte a un acces externe" }
    else { $p = 15 }
}
Afficher "Mission 2 - portail" $p 15 $note; $total += $p

# --- Misión 3 : bd-interne (headless) -------------------------------------
$p = 0; $note = ""
if (-not (Existe "bd-interne")) { $note = "Service bd-interne introuvable (verifiez serviceName du StatefulSet)" }
else {
    $cip = (kubectl get svc bd-interne -o jsonpath="{.spec.clusterIP}" 2>$null)
    $eps = (kubectl get endpoints bd-interne -o jsonpath="{.subsets[*].addresses[*].ip}" 2>$null)
    if ("$cip" -ne "None") { $note = "ce Service ne doit PAS avoir d'IP virtuelle" }
    elseif (-not $eps) { $note = "Endpoints vides : verifiez le selecteur" }
    else { $p = 20 }
}
Afficher "Mission 3 - bd-interne" $p 20 $note; $total += $p

# --- Misión 4 : metriques (multi-port) ------------------------------------
$p = 0; $note = ""
if (-not (Existe "metriques")) { $note = "Service metriques introuvable" }
else {
    $ports = (kubectl get svc metriques -o jsonpath="{.spec.ports[*].port}" 2>$null)
    $noms  = (kubectl get svc metriques -o jsonpath="{.spec.ports[*].name}" 2>$null)
    $cible = (kubectl get svc metriques -o jsonpath="{.spec.ports[*].targetPort}" 2>$null)
    $liste = ($ports -split '\s+') | Where-Object { $_ }
    if ($liste.Count -lt 2) { $note = "il manque un port : deux sont attendus (80 et 9090)" }
    elseif (-not $noms) { $note = "chaque port doit porter un nom lorsqu'il y en a plusieurs" }
    elseif ($cible -match '^\s*\d+(\s+\d+)*\s*$') { $note = "targetPort doit referencer les ports PAR LEUR NOM" }
    else { $p = 15 }
}
Afficher "Mission 4 - metriques" $p 15 $note; $total += $p

# --- Misión 5 : paiement-externe -------------------------------------------
$p = 0; $note = ""
if (-not (Existe "paiement-externe")) { $note = "Service paiement-externe introuvable" }
else {
    $type = (kubectl get svc paiement-externe -o jsonpath="{.spec.type}" 2>$null)
    $cible = (kubectl get svc paiement-externe -o jsonpath="{.spec.externalName}" 2>$null)
    if ("$type" -ne "ExternalName") { $note = "ce n'est pas le type attendu pour un alias DNS" }
    elseif (-not $cible) { $note = "la cible externe n'est pas renseignee" }
    else { $p = 10 }
}
Afficher "Mission 5 - paiement-externe" $p 10 $note; $total += $p

# --- Misión 6 : las tres reparaciones --------------------------------------
$p = 0; $notes = @()
foreach ($cas in @(
    @{ nom = "api-commandes"; port = "8000" },
    @{ nom = "cache";         port = "6379" },
    @{ nom = "notifications"; port = "7000" })) {

    if (-not (Existe $cas.nom)) { $notes += "$($cas.nom) : Service introuvable"; continue }
    $eps = (kubectl get endpoints $cas.nom -o jsonpath="{.subsets[*].addresses[*].ip}" 2>$null)
    $tp  = (kubectl get svc $cas.nom -o jsonpath="{.spec.ports[0].targetPort}" 2>$null)
    if (-not $eps) { $notes += "$($cas.nom) : Endpoints vides" }
    elseif ("$tp" -ne $cas.port) { $notes += "$($cas.nom) : aucun Pod ne repond sur ce port" }
    else { $p += 7 }
}
if ($p -gt 20) { $p = 20 }
Afficher "Mission 6 - reparations" $p 20 ($notes -join " | "); $total += $p

Write-Host ""
$couleur = if ($total -ge 90) { "Green" } elseif ($total -ge 50) { "Yellow" } else { "Red" }
Write-Host ("SCORE AUTOMATIQUE : {0} / 95" -f $total) -ForegroundColor $couleur
Write-Host "   (+5 pour la qualite du rapport, +5 de bonus : evalues manuellement)" -ForegroundColor DarkGray
Write-Host ""
Write-Host "Rappel : le tableau de bord doit afficher 8 / 8 sur http://localhost:30500" -ForegroundColor DarkGray
Write-Host ""