spec:
  selector:
    app: api-produits          # tout Pod portant CE label est atteint

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         # <-- pointe vers un Service headless du même nom
  replicas: 3

bd-0.bd-interne         -> IP du Pod bd-0 UNIQUEMENT
bd-1.bd-interne         -> IP du Pod bd-1 UNIQUEMENT
bd-interne              -> IPs des trois Pods (liste)

spec:
  clusterIP: None                  # transforme le Service en "headless"

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

ports:
  - name: web
    port: 80
    targetPort: web              # renvoie au containerPort nommé "web"

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

projet12-mission-services/
├── 00-ENONCE.md                      <- este documento
│
├── apps/                             <- O CODIGO (ANEXO A) — NAO MODIFICAR
│   ├── micro/
│   │   ├── app.py
│   │   ├── requirements.txt
│   │   └── Dockerfile
│   ├── metriques/
│   │   ├── app.py
│   │   ├── requirements.txt
│   │   └── Dockerfile
│   └── portail/
│       ├── app.py
│       ├── requirements.txt
│       └── Dockerfile
│
├── k8s/
│   ├── 01-deployments.yaml           <- FORNECIDO (ANEXO B) — NAO MODIFICAR
│   ├── 02-statefulset-bd.yaml        <- FORNECIDO (ANEXO B) — NAO MODIFICAR
│   │
│   └── services/                     <- A SUA VEZ
│       ├── 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/                <- FORNECIDOS mas DEFEITUOSOS (ANEXO D)
│           ├── casse-1.yaml
│           ├── casse-2.yaml
│           └── casse-3.yaml
│
├── outils/
│   └── valider.ps1                   <- FORNECIDO (ANEXO E)
│
└── RAPPORT.md                        <- A REDIGIR por si

# 0) Se placer sur le bon cluster (indispensable si minikube ou kind a déjà servi)
kubectl config use-context docker-desktop
kubectl get nodes                       # doit afficher docker-desktop   Ready

# 1) Construire les trois images
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) Déployer la base fournie (des Pods, et AUCUN Service)
kubectl apply -f k8s/01-deployments.yaml
kubectl apply -f k8s/02-statefulset-bd.yaml

# 3) Attendre que TOUS les Pods soient Ready (environ 30 s)
kubectl wait --for=condition=ready pod --all --timeout=180s

# 4) Constater la situation de départ
kubectl get pods                        # 14 Pods, tous Running
kubectl get svc                         # seulement "kubernetes" : aucun de vos Services

kubectl apply -f k8s/services/01-api-produits.yaml
kubectl get svc api-produits
kubectl get endpoints api-produits        # doit lister 3 adresses IP

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

bd-0.bd-interne

# 1) Depuis un Pod utilitaire, joindre directement bd-0 :
kubectl run test --rm -i --restart=Never --image=busybox:1.36 -- wget -qO- http://bd-0.bd-interne:5432/ping
# doit repondre : {"pod":"bd-0","port":5432,"service":"base-de-donnees"}

# 2) Verifier les entrees DNS avec le nom pleinement qualifie
#    (busybox nslookup n'applique PAS les search domains, il faut donner le FQDN) :
kubectl run test --rm -i --restart=Never --image=busybox:1.36 -- nslookup bd-0.bd-interne.default.svc.cluster.local
# doit renvoyer UNE seule adresse (celle du Pod bd-0)

kubectl run test --rm -i --restart=Never --image=busybox:1.36 -- nslookup bd-interne.default.svc.cluster.local
# doit renvoyer TROIS adresses (une par Pod du StatefulSet)

kubectl describe svc metriques            # les DEUX ports doivent apparaître

kubectl run test --rm -i --restart=Never --image=busybox:1.36 -- nslookup paiement-externe.default.svc.cluster.local
# doit afficher :
#   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                              # types, IP, ports
kubectl describe svc <nom>                   # détails + Endpoints
kubectl get endpoints <nom>                  # QUI se trouve derrière le Service ?
kubectl get pods --show-labels               # les labels réels des Pods
kubectl get pods -l app=<valeur>             # tester un sélecteur
kubectl port-forward deploy/portail 5000:5000    # accéder à un Pod SANS 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        # ce que le portail n'arrive pas à joindre
kubectl delete svc <nom>                     # repartir de zéro sur un Service

"""Micro-servico generico de demonstracao.

A mesma imagem serve varios componentes: o nome e a porta de escuta sao
fornecidos por variaveis de ambiente (APP_NAME, PORT).
Cada resposta contem o nome do Pod, o que torna visivel a distribuicao
de carga realizada por um 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 expoe DUAS portas em simultaneo.

  - 8080 : interface web         (rota /ping)
  - 9090 : metricas Prometheus   (rota /metrics)

Dois servidores Flask correm em duas threads distintas.
"""

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"]

"""Painel das ligacoes do cluster.

Para cada ligacao, o portal distingue TRES situacoes :
  - VERMELHO : o nome DNS nao existe        -> o Service nao foi criado
  - LARANJA  : o nome resolve, sem resposta -> seletor ou porta errados
  - VERDE    : a comunicacao funciona       -> o Service esta correto
"""

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  # porta pela qual o portal deve ser consultado

CIBLES = [
    {"cle": "externe", "titre": "Acesso externo", "mode": "externe",
     "aide": "O portal deve ser consultado via http://localhost:30500"},
    {"cle": "produits", "titre": "API Produtos", "mode": "http",
     "url": "http://api-produits/ping"},
    {"cle": "bd", "titre": "Base de dados (bd-0)", "mode": "http",
     "url": "http://bd-0.bd-interne:5432/ping"},
    {"cle": "metriques", "titre": "Metricas (2 portas)", "mode": "http2",
     "url": "http://metriques/ping", "url2": "http://metriques:9090/metrics"},
    {"cle": "paiement", "titre": "Pagamento externo", "mode": "dns",
     "hote": "paiement-externe"},
    {"cle": "commandes", "titre": "API Encomendas", "mode": "http",
     "url": "http://api-commandes/ping"},
    {"cle": "cache", "titre": "Cache", "mode": "http",
     "url": "http://cache/ping"},
    {"cle": "notifications", "titre": "Notificacoes", "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", "nome DNS nao encontrado : o Service nao existe"
    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", "resposta HTTP %s" % err.code
    except Exception as err:
        return "orange", "nome resolvido mas nenhuma resposta (%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", "consultado via a porta %s" % PORT_ATTENDU
        return "orange", "consultado via a porta %s : escreva o Service do portal" % port

    if mode == "dns":
        if resout(cible["hote"]):
            return "vert", "o nome %s esta resolvido" % cible["hote"]
        return "rouge", "o nome %s nao esta resolvido" % 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", "as duas portas respondem"
        if etat1 == "rouge" or etat2 == "rouge":
            return "rouge", "porta 80 : %s | porta 9090 : %s" % (det1, det2)
        return "orange", "porta 80 : %s | porta 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="pt">
<head>
  <meta charset="UTF-8">
  <meta http-equiv="refresh" content="3">
  <title>Missao : restabelecer as comunicacoes</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>Missao : restabelecer as comunicacoes do cluster</h1>
  <div class="sous">Servido pelo pod <strong>{pod}</strong> &middot; atualizacao automatica a cada 3 s</div>
  <div class="score">{score} / {total}</div>
  <div class="grille">{tuiles}</div>
  <div class="pied">VERMELHO : o Service nao existe &middot; LARANJA : seletor ou porta errados &middot; VERDE : ligacao estabelecida</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"]

# ---------------------------------------------------------------------------
# OS PODS DA PLATAFORMA — FORNECIDO, NAO MODIFICAR
# Observe com atencao: os LABELS e as PORTAS declarados aqui sao as unicas
# informacoes de que dispõe para escrever os seus 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            # <-- porta NOMEADA
              containerPort: 8080
            - name: prom           # <-- porta NOMEADA
              containerPort: 9090
          readinessProbe:
            httpGet: { path: /health, port: 8080 }
            initialDelaySeconds: 3
            periodSeconds: 5

# ---------------------------------------------------------------------------
# A BASE DE DADOS (3 replicas) — FORNECIDO, NAO MODIFICAR
#
# ATENCAO: o campo serviceName abaixo impõe o NOME do Service que
# tera de escrever para que bd-0, bd-1 e bd-2 obtenham cada um um nome DNS.
# ---------------------------------------------------------------------------
apiVersion: apps/v1
kind: StatefulSet
metadata:
  name: bd
spec:
  serviceName: bd-interne          # <-- leia bem esta linha
  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

# MISSION 1 — Tornar a API produtos alcancavel a partir do portal.
#
# O portal chama :  http://api-produits        (logo a porta 80)
# Os Pods escutam em : 8000
# Os Pods levam o label : app: api-produits
#
# ? Que tipo de Service para uma comunicacao INTERNA ao cluster ?
apiVersion: v1
kind: Service
metadata:
  name: api-produits          # nome IMPOSTO : nao mudar
spec:
  type: TODO
  selector:
    TODO: TODO
  ports:
    - port: TODO              # a porta pela qual os clientes chamam
      targetPort: TODO        # a porta realmente escutada pelo contentor

# MISSION 2 — Tornar o painel acessivel a partir do navegador,
#             no endereco exato : http://localhost:30500
#
# Os Pods escutam em : 5000
# Os Pods levam o label : app: portail
#
# ? Que tipo de Service abre uma porta na MAQUINA ?
# ? Qual e a gama autorizada para esta porta ?
# ? Que campo suplementar e preciso acrescentar para impor a porta 30500 ?
apiVersion: v1
kind: Service
metadata:
  name: portail               # nome IMPOSTO : nao mudar
spec:
  type: TODO
  selector:
    TODO: TODO
  ports:
    - port: TODO
      targetPort: TODO
      # ? falta aqui uma linha

# MISSION 3 — Dar um nome DNS INDIVIDUAL a cada replica da base,
#             para poder alcancar precisamente : bd-0.bd-interne
#
# Os Pods escutam em : 5432
# Os Pods levam o label : app: bd
#
# ? Que tipo de Service NAO possui IP virtual unico ?
# ? Que campo, com que valor muito particular, produz este efeito ?
# ? O nome abaixo deve corresponder a que campo do StatefulSet ?
apiVersion: v1
kind: Service
metadata:
  name: bd-interne            # nome IMPOSTO : nao mudar
spec:
  # ? falta aqui uma linha essencial
  selector:
    TODO: TODO
  ports:
    - port: TODO
      targetPort: TODO

# MISSION 4 — Expor DUAS portas num unico e mesmo Service.
#
# O portal chama :  http://metriques         (porta 80)
#              e : http://metriques:9090/metrics
#
# Os Pods escutam em : 8080 (porta nomeada "web") e 9090 (porta nomeada "prom")
# Os Pods levam o label : app: metriques
#
# ? Que restricao se torna OBRIGATORIA assim que um Service expoe varias portas ?
# ? Como fazer targetPort apontar para uma porta do contentor PELO SEU NOME ?
apiVersion: v1
kind: Service
metadata:
  name: metriques             # nome IMPOSTO : nao mudar
spec:
  type: TODO
  selector:
    TODO: TODO
  ports:
    - TODO: TODO              # ? falta um campo obrigatorio em cada entrada
      port: TODO
      targetPort: TODO
    - TODO: TODO
      port: TODO
      targetPort: TODO

# MISSION 5 — Fazer um nome INTERNO apontar para um servico EXTERNO.
#
# O portal usa o nome : paiement-externe
# Este nome deve apontar para : example.com
#
# ? Que tipo de Service cria um simples alias DNS (CNAME) ?
# ? Este tipo possui seletor ? portas ? Pods ?
apiVersion: v1
kind: Service
metadata:
  name: paiement-externe      # nome IMPOSTO : nao mudar
spec:
  type: TODO
  TODO: TODO                  # ? o campo que indica o alvo externo

# PANNE 1
# Sintoma : o Service existe, mas "kubectl get endpoints api-commandes"
#            devolve <none>. O portal mostra um cartao LARANJA.
apiVersion: v1
kind: Service
metadata:
  name: api-commandes
spec:
  type: ClusterIP
  selector:
    app: api-commande
  ports:
    - port: 80
      targetPort: 8000

# PANNE 2
# Sintoma : "kubectl get endpoints cache" mostra mesmo um endereco IP,
#            mas qualquer ligacao falha. O portal mostra um cartao LARANJA.
apiVersion: v1
kind: Service
metadata:
  name: cache
spec:
  type: ClusterIP
  selector:
    app: cache
  ports:
    - port: 80
      targetPort: 6380

# PANNE 3
# Sintoma : este Service parece perfeito (tipo correto, seletor correto,
#            Endpoints preenchidos, portas coerentes)... e no entanto o portal
#            mostra um cartao VERMELHO e NUNCA o alcanca.
apiVersion: v1
kind: Service
metadata:
  name: notification
spec:
  type: ClusterIP
  selector:
    app: notifications
  ports:
    - port: 80
      targetPort: 7000

# ---------------------------------------------------------------------------
# Script de validacao — da uma pontuacao, NUNCA a solucao.
# Utilizacao :  .\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 ""

# --- Mission 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

# --- Mission 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

# --- Mission 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

# --- Mission 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

# --- Mission 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

# --- Mission 6 : les trois reparations --------------------------------------
$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 ""