mon-chart/
├── Chart.yaml            # metadata (nombre, versión)
├── values.yaml           # valores POR DEFECTO
└── templates/            # templates YAML
    ├── deployment.yaml
    ├── service.yaml
    └── _helpers.tpl      # funciones de template compartidas (nombre prefijado _)

helm lint ./chart                                              # verificar la sintaxis
helm template <release> ./chart -f values-<env>.yaml           # render SECO (ningún despliegue)
helm install <release> ./chart -f values-<env>.yaml -n <ns>    # despliegue real
helm upgrade <release> ./chart -f values-<env>.yaml -n <ns>    # modificación incremental
helm rollback <release> <revision> -n <ns>                     # vuelta atrás

spec.selector: Invalid value: ...: field is immutable

projet13-kubernetes-helm-tp/
├── 00-ENONCE.md                              <- este documento
│
├── apps/                                     <- EL CÓDIGO (ANEXO A) — NO MODIFICAR
│   ├── portail/
│   │   ├── app.py
│   │   ├── requirements.txt
│   │   └── Dockerfile
│   └── api/
│       ├── app.py
│       ├── requirements.txt
│       └── Dockerfile
│
├── chart/                                    <- EL CHART A COMPLETAR
│   ├── Chart.yaml                            <- esqueleto (ANEXO B)
│   ├── values.yaml                           <- valores por defecto (ANEXO B)
│   │
│   ├── environments/                         <- TE TOCA A TI
│   │   ├── values-dev.yaml                   <- esqueleto TODO (ANEXO B)
│   │   ├── values-staging.yaml               <- esqueleto TODO (ANEXO B)
│   │   └── values-prod.yaml                  <- esqueleto TODO (ANEXO B)
│   │
│   ├── templates/                            <- TE TOCA A TI
│   │   ├── _helpers.tpl                      <- esqueleto TODO (ANEXO B)
│   │   ├── portail-deployment.yaml           <- esqueleto TODO (ANEXO B)
│   │   ├── portail-service.yaml              <- esqueleto TODO (ANEXO B)
│   │   ├── api-deployment.yaml               <- esqueleto TODO (ANEXO B)
│   │   └── api-service.yaml                  <- esqueleto TODO (ANEXO B)
│   │
│   └── casses/                               <- SUMINISTRADOS pero DEFECTUOSOS (ANEXO C)
│       ├── casse-1-configmap.yaml
│       ├── casse-2-worker-deployment.yaml
│       └── casse-3-cache-deployment.yaml
│
├── outils/
│   └── valider.ps1                           <- SUMINISTRADO (ANEXO D)
│
└── RAPPORT.md                                <- A REDACTAR por ti

docker build -t hedge-portail:1.0 .\apps\portail
docker build -t hedge-api:1.0     .\apps\api

docker images | Select-String "^hedge"      # debe mostrar las 2 imágenes

helm lint .\chart
# debe mostrar : 1 chart(s) linted, 0 chart(s) failed

helm template check .\chart -f .\chart\environments\values-dev.yaml
# debe mostrar 2 Deployments + 2 Services, todos prefijados por "check-"

{{ include "hedge.labels" (dict "root" . "composant" "portail") | nindent 4 }}

helm install hedge-dev     .\chart -f .\chart\environments\values-dev.yaml     -n hedge-dev     --create-namespace
helm install hedge-staging .\chart -f .\chart\environments\values-staging.yaml -n hedge-staging --create-namespace
helm install hedge-prod    .\chart -f .\chart\environments\values-prod.yaml    -n hedge-prod    --create-namespace

kubectl wait --for=condition=ready pod --all -n hedge-dev     --timeout=120s
kubectl wait --for=condition=ready pod --all -n hedge-staging --timeout=120s
kubectl wait --for=condition=ready pod --all -n hedge-prod    --timeout=120s

start http://localhost:30130       # DEV — franja azul, 1 réplica
start http://localhost:30131       # STAGING — franja naranja, 2 réplicas
start http://localhost:30132       # PROD — franja verde, 3 réplicas

# render SECO de un solo template (no instala nada)
helm template hedge-dev .\chart -f .\chart\environments\values-dev.yaml `
  --show-only templates/casse-3-cache-deployment.yaml --debug

.\outils\valider.ps1

[OK]    Mission 1 - Chart valide.............. 10/10
[OK]    Mission 2 - Templating de base........ 20/20
[ECHEC] Mission 3 - Helpers et labels.........  0/15   -> helper hedge.selectorLabels manquant
[OK]    Mission 4 - Trois environnements...... 20/20
[ECHEC] Mission 5 - Upgrade + rollback........  0/10   -> aucun rollback detecte dans l'historique
[OK]    Mission 6 - Reparations (3 pannes).... 14/20   -> casse-3 : typo .Values.portal toujours present

SCORE AUTOMATIQUE : 64 / 95

# ANÁLISIS (ningún despliegue)
helm lint .\chart                                                        # sintaxis + buenas prácticas
helm template <release> .\chart -f <values.yaml>                         # render completo
helm template <release> .\chart -f <values.yaml> --show-only templates/<fichier>   # render puntual
helm template <release> .\chart -f <values.yaml> --debug                 # con trazas
helm show values .\chart                                                 # valores por defecto

# DESPLIEGUE
helm install <release> .\chart -f <values.yaml> -n <ns> --create-namespace
helm upgrade <release> .\chart -f <values.yaml> -n <ns>
helm upgrade <release> .\chart -f <values.yaml> --set portail.replicas=5 -n <ns>
helm rollback <release> <revision> -n <ns>
helm uninstall <release> -n <ns>

# OBSERVACIÓN
helm list -A                                                             # todas las releases
helm status <release> -n <ns>
helm history <release> -n <ns>
helm get values <release> -n <ns>                                        # los valores activos
helm get manifest <release> -n <ns>                                      # los manifiestos aplicados

"""Portail — tablero multi-entorno.

Este Pod muestra el entorno en el que corre (DEV / STAGING / PROD),
la versión de la aplicación, el número de réplicas y el estado del backend.

Todos los valores mostrados vienen de VARIABLES DE ENTORNO inyectadas
por Helm desde values-<env>.yaml. El mismo código se adapta a cada
entorno sin ninguna modificación.
"""

import os
import socket
import time
import urllib.error
import urllib.request

from flask import Flask, jsonify, request

app = Flask(__name__)
DEMARRAGE = time.time()


def cfg():
    return {
        "env": os.environ.get("ENVIRONMENT", "inconnu"),
        "version": os.environ.get("APP_VERSION", "0.0.0"),
        "theme": os.environ.get("THEME_COLOR", "#64748b"),
        "message": os.environ.get("BANNIERE_MESSAGE", "Deploye avec Helm"),
        "backend_url": os.environ.get("BACKEND_URL", "http://api"),
        "replicas_info": os.environ.get("REPLICAS_INFO", "?"),
        "pod": socket.gethostname(),
        "uptime": int(time.time() - DEMARRAGE),
    }


def tester_backend(url):
    try:
        with urllib.request.urlopen(url + "/ping", timeout=1.5) as reponse:
            corps = reponse.read(200).decode("utf-8", "ignore")
        return "ok", corps.strip()
    except urllib.error.HTTPError as err:
        return "http", "HTTP %s" % err.code
    except Exception as err:
        return "ko", type(err).__name__


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


@app.route("/api-json")
def api_json():
    """Ruta útil para la validación automática."""
    c = cfg()
    etat, detail = tester_backend(c["backend_url"])
    return jsonify(pod=c["pod"], env=c["env"], version=c["version"],
                   backend=etat, backend_detail=detail, uptime=c["uptime"])


@app.route("/")
def accueil():
    c = cfg()
    etat, detail = tester_backend(c["backend_url"])
    # ... (plantilla HTML completa en el archivo — no se repite aquí para que siga legible)

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

"""API — backend simple para el ejemplo Helm."""

import os
import socket
import time

from flask import Flask, jsonify

app = Flask(__name__)
DEMARRAGE = time.time()

ENV = os.environ.get("ENVIRONMENT", "inconnu")
VERSION = os.environ.get("APP_VERSION", "0.0.0")


@app.route("/")
@app.route("/ping")
def ping():
    return jsonify(service="api", env=ENV, version=VERSION,
                   pod=socket.gethostname(),
                   uptime=int(time.time() - DEMARRAGE))


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


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

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

# ? Rellena los campos obligatorios de un Chart Helm.
# ? apiVersion debe valer v2 (la v1 está deprecada desde Helm 3).
# ? type es "application" (por oposición a "library").

apiVersion: TODO
name: hedge
description: TODO
type: TODO
version: 0.1.0
appVersion: "1.0.0"

# values.yaml — valores por defecto del chart hedge.
# Cada entorno aporta un archivo values-<env>.yaml que SOBRESCRIBE
# estos valores por encima. Mantén este archivo NEUTRO (ningún valor específico
# de un entorno).

environment: default

banniere:
  message: "Chart Helm — application multi-environnement"
  couleur: "#64748b"

portail:
  image:
    repository: hedge-portail
    tag: "1.0"
    pullPolicy: IfNotPresent
  replicas: 1
  service:
    type: NodePort
    port: 80
    targetPort: 5000
    nodePort: 30130

api:
  image:
    repository: hedge-api
    tag: "1.0"
    pullPolicy: IfNotPresent
  replicas: 1
  service:
    type: ClusterIP
    port: 80
    targetPort: 8000

{{/*
Nombre completo de un recurso: "<release>-<composant>".
Uso: {{ include "hedge.fullname" (dict "root" . "composant" "portail") }}
*/}}
{{- define "hedge.fullname" -}}
{{- printf "TODO" .root.Release.Name .composant | trunc 63 | trimSuffix "-" -}}
{{- end -}}


{{/*
Labels comunes a todos los recursos.
Uso: {{ include "hedge.labels" (dict "root" . "composant" "portail") | nindent 4 }}
*/}}
{{- define "hedge.labels" -}}
# ? rellena los 7 labels pedidos en la Misión 3
app.kubernetes.io/name: TODO
app.kubernetes.io/instance: TODO
# ... continúa ...
{{- end -}}


{{/*
Selector labels: subconjunto ESTABLE de los labels.
Pon aquí SOLO labels que NUNCA cambiarán para una instancia.
*/}}
{{- define "hedge.selectorLabels" -}}
# ? únicamente los 3 labels ESTRICTAMENTE inmutables
{{- end -}}

# ? Deployment del portail. Usa:
#   - .Values.portail.replicas
#   - .Values.portail.image.{repository,tag,pullPolicy}
#   - .Values.portail.service.targetPort
#   - .Values.environment
#   - .Values.banniere.{couleur,message}
#   - .Chart.AppVersion (para APP_VERSION)
#   - El NOMBRE del Service api construido con .Release.Name (para BACKEND_URL)
apiVersion: apps/v1
kind: Deployment
metadata:
  name: TODO
  labels:
    TODO
spec:
  replicas: TODO
  selector:
    matchLabels:
      TODO
  template:
    metadata:
      labels:
        TODO
    spec:
      containers:
        - name: portail
          image: TODO
          imagePullPolicy: TODO
          ports:
            - containerPort: TODO
          env:
            - name: ENVIRONMENT
              value: TODO
            # ? añade APP_VERSION, THEME_COLOR, BANNIERE_MESSAGE,
            #   BACKEND_URL, REPLICAS_INFO
          readinessProbe:
            httpGet:
              path: /health
              port: TODO
            initialDelaySeconds: 3
            periodSeconds: 5

# ? Service para el portail. Tipo NodePort. Usa la condición
#   {{- if eq .Values.portail.service.type "NodePort" }} ... {{- end }}
#   para incluir "nodePort" SOLO si es realmente un NodePort.
apiVersion: v1
kind: Service
metadata:
  name: TODO
  labels:
    TODO
spec:
  type: TODO
  selector:
    TODO
  ports:
    - port: TODO
      targetPort: TODO
      # ? nodePort únicamente si type == NodePort

# ? Misma estructura que portail-deployment.yaml, pero:
#   - composant = "api"
#   - variables de entorno: ENVIRONMENT y APP_VERSION solamente
#   - puerto del contenedor = .Values.api.service.targetPort (8000)
apiVersion: apps/v1
kind: Deployment
metadata:
  name: TODO
spec:
  # ... (estructura similar a la del portail) ...

# ? Service ClusterIP para la api. Un solo puerto. Sin nodePort.
apiVersion: v1
kind: Service
metadata:
  name: TODO
spec:
  type: TODO
  selector:
    TODO
  ports:
    - port: TODO
      targetPort: TODO

# ? Entorno DEV: 1 réplica, franja azul #2563eb, NodePort 30130.
environment: TODO

banniere:
  message: TODO
  couleur: TODO

portail:
  replicas: TODO
  service:
    nodePort: TODO

api:
  replicas: TODO

# ? Entorno STAGING: 2 réplicas, franja naranja #ea580c, NodePort 30131.
environment: TODO
# ... completa siguiendo el modelo de values-dev.yaml ...

# ? Entorno PROD: 3 réplicas, franja verde #16a34a, NodePort 30132.
environment: TODO
# ...

# AVERÍA 1
# Síntoma: despliega hedge-dev, luego intenta desplegar hedge-staging
# EN EL MISMO NAMESPACE. La segunda instalación falla con:
#   ConfigMap "hedge-config" ... exists and cannot be imported ...
apiVersion: v1
kind: ConfigMap
metadata:
  name: hedge-config
  labels:
    {{- include "hedge.labels" (dict "root" . "composant" "config") | nindent 4 }}
data:
  timezone: "America/Toronto"
  langue: "fr-CA"

# AVERÍA 2
# Síntoma: "helm install" funciona. "helm upgrade" con un
# --set environment=recette falla con:
#   spec.selector: Invalid value: ...: field is immutable
apiVersion: apps/v1
kind: Deployment
metadata:
  name: {{ include "hedge.fullname" (dict "root" . "composant" "worker") }}
spec:
  replicas: 1
  selector:
    matchLabels:
      app.kubernetes.io/name: {{ .Chart.Name }}
      app.kubernetes.io/instance: {{ .Release.Name }}
      app.kubernetes.io/component: worker
      hedge/environment: {{ .Values.environment | quote }}
  template:
    metadata:
      labels:
        {{- include "hedge.labels" (dict "root" . "composant" "worker") | nindent 8 }}
    spec:
      containers:
        - name: worker
          image: "{{ .Values.api.image.repository }}:{{ .Values.api.image.tag }}"

# AVERÍA 3
# Síntoma: "helm install" falla con:
#   Error: template ...at <.Values.portal.replicas>:
#   nil pointer evaluating interface {}.replicas
apiVersion: apps/v1
kind: Deployment
metadata:
  name: {{ include "hedge.fullname" (dict "root" . "composant" "cache") }}
spec:
  replicas: {{ .Values.portal.replicas }}
  selector:
    matchLabels:
      {{- include "hedge.selectorLabels" (dict "root" . "composant" "cache") | nindent 6 }}
  template:
    metadata:
      labels:
        {{- include "hedge.selectorLabels" (dict "root" . "composant" "cache") | nindent 8 }}
    spec:
      containers:
        - name: cache
          image: "{{ .Values.api.image.repository }}:{{ .Values.api.image.tag }}"

.\outils\valider.ps1