spec:
  selector:
    app: api-produits          # κάθε Pod που φέρει ΑΥΤΗ την ετικέτα προσεγγίζεται

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         # <-- δείχνει προς ένα Service headless του ίδιου ονόματος
  replicas: 3

bd-0.bd-interne         -> IP του Pod bd-0 ΜΟΝΟ
bd-1.bd-interne         -> IP του Pod bd-1 ΜΟΝΟ
bd-interne              -> IP των τριών Pods (λίστα)

spec:
  clusterIP: None                  # μετατρέπει το Service σε "headless"

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

ports:
  - name: web
    port: 80
    targetPort: web              # παραπέμπει στο containerPort με όνομα "web"

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

projet12-mission-services/
├── 00-ENONCE.md                      <- αυτό το έγγραφο
│
├── apps/                             <- Ο ΚΩΔΙΚΑΣ (ΠΑΡΑΡΤΗΜΑ A) — ΝΑ ΜΗΝ ΤΡΟΠΟΠΟΙΗΘΕΙ
│   ├── micro/
│   │   ├── app.py
│   │   ├── requirements.txt
│   │   └── Dockerfile
│   ├── metriques/
│   │   ├── app.py
│   │   ├── requirements.txt
│   │   └── Dockerfile
│   └── portail/
│       ├── app.py
│       ├── requirements.txt
│       └── Dockerfile
│
├── k8s/
│   ├── 01-deployments.yaml           <- ΠΑΡΕΧΕΤΑΙ (ΠΑΡΑΡΤΗΜΑ B) — ΝΑ ΜΗΝ ΤΡΟΠΟΠΟΙΗΘΕΙ
│   ├── 02-statefulset-bd.yaml        <- ΠΑΡΕΧΕΤΑΙ (ΠΑΡΑΡΤΗΜΑ B) — ΝΑ ΜΗΝ ΤΡΟΠΟΠΟΙΗΘΕΙ
│   │
│   └── services/                     <- ΣΕΙΡΑ ΣΑΣ
│       ├── 01-api-produits.yaml      <- σκελετός προς συμπλήρωση (ΠΑΡΑΡΤΗΜΑ C)
│       ├── 02-portail.yaml           <- σκελετός προς συμπλήρωση (ΠΑΡΑΡΤΗΜΑ C)
│       ├── 03-bd-interne.yaml        <- σκελετός προς συμπλήρωση (ΠΑΡΑΡΤΗΜΑ C)
│       ├── 04-metriques.yaml         <- σκελετός προς συμπλήρωση (ΠΑΡΑΡΤΗΜΑ C)
│       ├── 05-paiement-externe.yaml  <- σκελετός προς συμπλήρωση (ΠΑΡΑΡΤΗΜΑ C)
│       │
│       └── 06-casses/                <- ΠΑΡΕΧΟΝΤΑΙ αλλά ΕΛΑΤΤΩΜΑΤΙΚΑ (ΠΑΡΑΡΤΗΜΑ D)
│           ├── casse-1.yaml
│           ├── casse-2.yaml
│           └── casse-3.yaml
│
├── outils/
│   └── valider.ps1                   <- ΠΑΡΕΧΕΤΑΙ (ΠΑΡΑΡΤΗΜΑ E)
│
└── RAPPORT.md                        <- ΝΑ ΣΥΝΤΑΧΘΕΙ από εσάς

# 0) Τοποθέτηση στο σωστό σύμπλεγμα (απαραίτητο αν έχουν ήδη χρησιμοποιηθεί minikube ή kind)
kubectl config use-context docker-desktop
kubectl get nodes                       # πρέπει να εμφανίζει docker-desktop   Ready

# 1) Κατασκευή των τριών εικόνων
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) Ανάπτυξη της παρεχόμενης βάσης (Pods, και ΚΑΝΕΝΑ Service)
kubectl apply -f k8s/01-deployments.yaml
kubectl apply -f k8s/02-statefulset-bd.yaml

# 3) Αναμονή να είναι Ready ΟΛΑ τα Pods (περίπου 30 s)
kubectl wait --for=condition=ready pod --all --timeout=180s

# 4) Διαπίστωση της αρχικής κατάστασης
kubectl get pods                        # 14 Pods, όλα Running
kubectl get svc                         # μόνο "kubernetes" : κανένα από τα Services σας

kubectl apply -f k8s/services/01-api-produits.yaml
kubectl get svc api-produits
kubectl get endpoints api-produits        # πρέπει να απαριθμεί 3 διευθύνσεις IP

kubectl get svc portail                   # PORT(S) πρέπει να εμφανίζει 80:30500/TCP
start http://localhost:30500

bd-0.bd-interne

# 1) Από ένα βοηθητικό Pod, σύνδεση απευθείας στο bd-0 :
kubectl run test --rm -i --restart=Never --image=busybox:1.36 -- wget -qO- http://bd-0.bd-interne:5432/ping
# πρέπει να απαντήσει : {"pod":"bd-0","port":5432,"service":"base-de-donnees"}

# 2) Επαλήθευση των εγγραφών DNS με το πλήρως προσδιορισμένο όνομα
#    (το busybox nslookup ΔΕΝ εφαρμόζει τα search domains, πρέπει να δοθεί το FQDN) :
kubectl run test --rm -i --restart=Never --image=busybox:1.36 -- nslookup bd-0.bd-interne.default.svc.cluster.local
# πρέπει να επιστρέψει ΜΙΑ μόνο διεύθυνση (αυτή του Pod bd-0)

kubectl run test --rm -i --restart=Never --image=busybox:1.36 -- nslookup bd-interne.default.svc.cluster.local
# πρέπει να επιστρέψει ΤΡΕΙΣ διευθύνσεις (μία ανά Pod του StatefulSet)

kubectl describe svc metriques            # οι ΔΥΟ θύρες πρέπει να εμφανίζονται

kubectl run test --rm -i --restart=Never --image=busybox:1.36 -- nslookup paiement-externe.default.svc.cluster.local
# πρέπει να εμφανίζει :
#   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                              # τύποι, IP, θύρες
kubectl describe svc <nom>                   # λεπτομέρειες + Endpoints
kubectl get endpoints <nom>                  # ΠΟΙΟΣ βρίσκεται πίσω από το Service ;
kubectl get pods --show-labels               # οι πραγματικές ετικέτες των Pods
kubectl get pods -l app=<valeur>             # δοκιμή ενός επιλογέα
kubectl port-forward deploy/portail 5000:5000    # πρόσβαση σε Pod ΧΩΡΙΣ 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        # αυτό που το portail δεν καταφέρνει να φτάσει
kubectl delete svc <nom>                     # επανεκκίνηση από το μηδέν σε ένα Service

"""Γενική μικροϋπηρεσία επίδειξης.

Η ίδια εικόνα χρησιμεύει σε πολλά στοιχεία : το όνομα και η θύρα ακρόασης
παρέχονται από μεταβλητές περιβάλλοντος (APP_NAME, PORT).
Κάθε απάντηση περιέχει το όνομα του Pod, κάτι που καθιστά ορατή την κατανομή
φορτίου που πραγματοποιεί ένα 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"]

"""Στοιχείο που εκθέτει ΔΥΟ θύρες ταυτόχρονα.

  - 8080 : διεπαφή web         (διαδρομή /ping)
  - 9090 : μετρικές Prometheus  (διαδρομή /metrics)

Δύο διακομιστές Flask τρέχουν σε δύο διακριτά νήματα εκτέλεσης.
"""

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

"""Πίνακας ελέγχου των συνδέσεων του συμπλέγματος.

Για κάθε σύνδεση, το portail διακρίνει ΤΡΕΙΣ καταστάσεις :
  - ΚΟΚΚΙΝΟ  : το όνομα DNS δεν υπάρχει       -> το Service δεν δημιουργήθηκε
  - ΠΟΡΤΟΚΑΛΙ : το όνομα επιλύεται, καμία απάντηση -> εσφαλμένος επιλογέας ή θύρα
  - ΠΡΑΣΙΝΟ   : η επικοινωνία λειτουργεί   -> το Service είναι σωστό
"""

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

from flask import Flask, request

app = Flask(__name__)

DELAI = 1.5          # δευτερόλεπτα
PORT_ATTENDU = 30500  # θύρα μέσω της οποίας πρέπει να συμβουλεύεται το 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"]

# ---------------------------------------------------------------------------
# ΤΑ PODS ΤΗΣ ΠΛΑΤΦΟΡΜΑΣ — ΠΑΡΕΧΕΤΑΙ, ΝΑ ΜΗΝ ΤΡΟΠΟΠΟΙΗΘΕΙ
# Παρατηρήστε προσεκτικά : οι ΕΤΙΚΕΤΕΣ και οι ΘΥΡΕΣ που δηλώνονται εδώ είναι οι μόνες
# πληροφορίες που διαθέτετε για να γράψετε τα 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            # <-- ΟΝΟΜΑΣΜΕΝΗ θύρα
              containerPort: 8080
            - name: prom           # <-- ΟΝΟΜΑΣΜΕΝΗ θύρα
              containerPort: 9090
          readinessProbe:
            httpGet: { path: /health, port: 8080 }
            initialDelaySeconds: 3
            periodSeconds: 5

# ---------------------------------------------------------------------------
# Η ΒΑΣΗ ΔΕΔΟΜΕΝΩΝ (3 αντίγραφα) — ΠΑΡΕΧΕΤΑΙ, ΝΑ ΜΗΝ ΤΡΟΠΟΠΟΙΗΘΕΙ
#
# ΠΡΟΣΟΧΗ : το πεδίο serviceName παρακάτω επιβάλλει το ΟΝΟΜΑ του Service που
# θα πρέπει να γράψετε ώστε τα bd-0, bd-1 και bd-2 να λάβει καθένα ένα όνομα DNS.
# ---------------------------------------------------------------------------
apiVersion: apps/v1
kind: StatefulSet
metadata:
  name: bd
spec:
  serviceName: bd-interne          # <-- διαβάστε καλά αυτή τη γραμμή
  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

# ΑΠΟΣΤΟΛΗ 1 — Να καταστήσετε την API προϊόντων προσβάσιμη από το portail.
#
# Το portail καλεί :  http://api-produits        (άρα τη θύρα 80)
# Τα Pods ακούν στο : 8000
# Τα Pods φέρουν την ετικέτα : app: api-produits
#
# ? Ποιος τύπος Service για ΕΣΩΤΕΡΙΚΗ επικοινωνία στο σύμπλεγμα ;
apiVersion: v1
kind: Service
metadata:
  name: api-produits          # ΕΠΙΒΕΒΛΗΜΕΝΟ όνομα : να μην αλλάξει
spec:
  type: TODO
  selector:
    TODO: TODO
  ports:
    - port: TODO              # η θύρα μέσω της οποίας καλούν οι πελάτες
      targetPort: TODO        # η θύρα που ακούει πραγματικά το κοντέινερ

# ΑΠΟΣΤΟΛΗ 2 — Να καταστήσετε τον πίνακα ελέγχου προσβάσιμο από τον περιηγητή,
#             στην ακριβή διεύθυνση : http://localhost:30500
#
# Τα Pods ακούν στο : 5000
# Τα Pods φέρουν την ετικέτα : app: portail
#
# ? Ποιος τύπος Service ανοίγει μια θύρα στο ΜΗΧΑΝΗΜΑ ;
# ? Ποιο είναι το επιτρεπόμενο εύρος για αυτή τη θύρα ;
# ? Ποιο συμπληρωματικό πεδίο πρέπει να προστεθεί για να επιβληθεί η θύρα 30500 ;
apiVersion: v1
kind: Service
metadata:
  name: portail               # ΕΠΙΒΕΒΛΗΜΕΝΟ όνομα : να μην αλλάξει
spec:
  type: TODO
  selector:
    TODO: TODO
  ports:
    - port: TODO
      targetPort: TODO
      # ? μια γραμμή λείπει εδώ

# ΑΠΟΣΤΟΛΗ 3 — Να δώσετε ΑΤΟΜΙΚΟ όνομα DNS σε κάθε αντίγραφο της βάσης,
#             ώστε να μπορείτε να φτάσετε ακριβώς : bd-0.bd-interne
#
# Τα Pods ακούν στο : 5432
# Τα Pods φέρουν την ετικέτα : app: bd
#
# ? Ποιος τύπος Service ΔΕΝ διαθέτει μοναδική εικονική IP ;
# ? Ποιο πεδίο, με ποια πολύ ιδιαίτερη τιμή, παράγει αυτό το αποτέλεσμα ;
# ? Το όνομα παρακάτω πρέπει να αντιστοιχεί σε ποιο πεδίο του StatefulSet ;
apiVersion: v1
kind: Service
metadata:
  name: bd-interne            # ΕΠΙΒΕΒΛΗΜΕΝΟ όνομα : να μην αλλάξει
spec:
  # ? μια ουσιώδης γραμμή λείπει εδώ
  selector:
    TODO: TODO
  ports:
    - port: TODO
      targetPort: TODO

# ΑΠΟΣΤΟΛΗ 4 — Έκθεση ΔΥΟ θυρών στο ίδιο Service.
#
# Το portail καλεί :  http://metriques         (θύρα 80)
#                  και : http://metriques:9090/metrics
#
# Τα Pods ακούν στο : 8080 (θύρα με όνομα "web") και 9090 (θύρα με όνομα "prom")
# Τα Pods φέρουν την ετικέτα : app: metriques
#
# ? Ποιος περιορισμός γίνεται ΥΠΟΧΡΕΩΤΙΚΟΣ μόλις ένα Service εκθέτει πολλές θύρες ;
# ? Πώς κάνουμε το targetPort να δείχνει σε θύρα του κοντέινερ ΜΕ ΤΟ ΟΝΟΜΑ ΤΗΣ ;
apiVersion: v1
kind: Service
metadata:
  name: metriques             # ΕΠΙΒΕΒΛΗΜΕΝΟ όνομα : να μην αλλάξει
spec:
  type: TODO
  selector:
    TODO: TODO
  ports:
    - TODO: TODO              # ? ένα υποχρεωτικό πεδίο λείπει σε κάθε εγγραφή
      port: TODO
      targetPort: TODO
    - TODO: TODO
      port: TODO
      targetPort: TODO

# ΑΠΟΣΤΟΛΗ 5 — Να δείξει ένα ΕΣΩΤΕΡΙΚΟ όνομα προς ΕΞΩΤΕΡΙΚΗ υπηρεσία.
#
# Το portail χρησιμοποιεί το όνομα : paiement-externe
# Αυτό το όνομα πρέπει να παραπέμπει στο : example.com
#
# ? Ποιος τύπος Service δημιουργεί ένα απλό ψευδώνυμο DNS (CNAME) ;
# ? Αυτός ο τύπος διαθέτει επιλογέα ; θύρες ; Pods ;
apiVersion: v1
kind: Service
metadata:
  name: paiement-externe      # ΕΠΙΒΕΒΛΗΜΕΝΟ όνομα : να μην αλλάξει
spec:
  type: TODO
  TODO: TODO                  # ? το πεδίο που δηλώνει τον εξωτερικό στόχο

# ΒΛΑΒΗ 1
# Σύμπτωμα : το Service υπάρχει, αλλά το "kubectl get endpoints api-commandes"
#            επιστρέφει <none>. Το portail εμφανίζει ΠΟΡΤΟΚΑΛΙ πλακίδιο.
apiVersion: v1
kind: Service
metadata:
  name: api-commandes
spec:
  type: ClusterIP
  selector:
    app: api-commande
  ports:
    - port: 80
      targetPort: 8000

# ΒΛΑΒΗ 2
# Σύμπτωμα : το "kubectl get endpoints cache" εμφανίζει όντως μια διεύθυνση IP,
#            αλλά κάθε σύνδεση αποτυγχάνει. Το portail εμφανίζει ΠΟΡΤΟΚΑΛΙ πλακίδιο.
apiVersion: v1
kind: Service
metadata:
  name: cache
spec:
  type: ClusterIP
  selector:
    app: cache
  ports:
    - port: 80
      targetPort: 6380

# ΒΛΑΒΗ 3
# Σύμπτωμα : αυτό το Service φαίνεται τέλειο (σωστός τύπος, σωστός επιλογέας,
#            γεμάτα Endpoints, συνεπείς θύρες)... και όμως το portail
#            εμφανίζει ΚΟΚΚΙΝΟ πλακίδιο και δεν το φτάνει ΠΟΤΕ.
apiVersion: v1
kind: Service
metadata:
  name: notification
spec:
  type: ClusterIP
  selector:
    app: notifications
  ports:
    - port: 80
      targetPort: 7000

# ---------------------------------------------------------------------------
# Σενάριο επικύρωσης — δίνει βαθμολογία, ΠΟΤΕ τη λύση.
# Χρήση :  .\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 ""

# --- Αποστολή 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

# --- Αποστολή 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

# --- Αποστολή 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

# --- Αποστολή 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

# --- Αποστολή 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

# --- Αποστολή 6 : οι τρεις επισκευές --------------------------------------
$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 ""