Aller au contenu

Lab 02 : Déploiement et exposition d'une application dans OKS

À l’issue de ce lab, vous serez capable de :

  • installer le contrôleur Ingress NGINX avec Helm ;
  • identifier le load balancer OUTSCALE créé automatiquement pour un Service Kubernetes de type LoadBalancer ;
  • déployer une application et l’exposer en HTTP avec une ressource Ingress ;
  • installer cert-manager et créer une autorité de certification (CA) auto-signée ;
  • exposer l’application en HTTPS avec un certificat émis par cert-manager.

Dans ce lab, vous travaillez dans le cluster oks-lab01-cluster créé au Lab 01, depuis le terminal de votre poste.

Vous installez le contrôleur Ingress NGINX dans le namespace ingress-nginx. Son Service de type LoadBalancer déclenche la création d’un load balancer OUTSCALE public dans le Net du projet OKS : c’est le point d’entrée unique du trafic HTTP et HTTPS vers le cluster.

Vous déployez ensuite l’application de test echoheaders dans le namespace oks-lab02. Une ressource Ingress indique au contrôleur de router les requêtes adressées au nom d’hôte oks-lab02.example.com vers le Service de l’application.

Enfin, cert-manager crée une CA auto-signée, oks-lab02-ca, qui émet le certificat TLS de l’application. Le contrôleur Ingress NGINX termine alors les connexions HTTPS avec ce certificat.

Remarque : le nom d’hôte oks-lab02.example.com est fictif et n’existe pas dans le DNS. Les tests indiquent à curl de joindre directement le load balancer, avec ce nom d’hôte dans la requête.

Avant de commencer, vous devez disposer :

  • du cluster oks-lab01-cluster à l’état ready, avec ses NodePools, créé dans le Lab 01 ;
  • du fichier oks-lab01-kubeconfig.yaml récupéré dans le Lab 01 ;
  • de kubectl et octl installés et configurés (Lab 01) ;
  • de Helm 4, installé à l’étape 1.1 ;
  • d’un terminal bash ou zsh avec curl.

Le lab utilise la région eu-west-2.

Important : le projet Ingress NGINX de la communauté Kubernetes a été retiré en mars 2026 : il ne reçoit plus de correctifs, y compris de sécurité. Il reste utilisé ici pour présenter le fonctionnement d’un contrôleur Ingress. En production, préférez un contrôleur maintenu ou l’API Gateway de Kubernetes. Consultez l’annonce officielle.

Helm est le gestionnaire de paquets de Kubernetes : il installe une application à partir d’un chart (un ensemble de manifestes paramétrables).

  1. Installez Helm 4 en suivant uniquement la méthode de votre système. N’utilisez pas les deux méthodes : vous auriez deux versions de Helm sur votre poste.

    Sous Linux :

    Terminal window
    curl -fsSL https://raw.githubusercontent.com/helm/helm/main/scripts/get-helm-4 | bash

    Sous macOS :

    Terminal window
    brew install helm
  2. Vérifiez l’installation :

    Terminal window
    which -a helm
    helm version

    Un seul chemin doit s’afficher, et la version doit commencer par v4.

  1. Placez-vous dans le répertoire qui contient le fichier oks-lab01-kubeconfig.yaml, puis indiquez à kubectl et Helm de l’utiliser :

    Terminal window
    export KUBECONFIG=$PWD/oks-lab01-kubeconfig.yaml

    Remarque : si vous avez supprimé ce fichier, récupérez-le de nouveau :

    Terminal window
    (umask 077; octl kube cluster kubeconfig oks-lab01-cluster --project oks-lab01-project > oks-lab01-kubeconfig.yaml)
  2. Vérifiez l’accès au cluster :

    Terminal window
    kubectl get nodes

    Les nœuds des NodePools du Lab 01 s’affichent à l’état Ready.

Une ressource Ingress décrit des règles de routage HTTP (nom d’hôte, chemin). Elle n’a aucun effet sans un contrôleur Ingress, qui lit ces règles et route le trafic.

  1. Ajoutez le dépôt Helm du projet Ingress NGINX :

    Terminal window
    helm repo add ingress-nginx https://kubernetes.github.io/ingress-nginx
    helm repo update
  2. Installez le contrôleur dans le namespace ingress-nginx :

    Terminal window
    helm install ingress-nginx ingress-nginx/ingress-nginx \
    --namespace ingress-nginx \
    --create-namespace
    • ingress-nginx (premier argument) : nom de la release Helm. Il sert de préfixe au nom des ressources créées.
    • --create-namespace : crée le namespace s’il n’existe pas.
  3. Vérifiez que le Pod du contrôleur est à l’état Running :

    Terminal window
    kubectl get pods -n ingress-nginx

    Exemple de sortie :

    NAME READY STATUS RESTARTS AGE
    ingress-nginx-controller-7bbfb99f87-s5cr6 1/1 Running 0 2m
  1. Affichez les Services du contrôleur :

    Terminal window
    kubectl get svc -n ingress-nginx

    Exemple de sortie :

    NAME TYPE CLUSTER-IP EXTERNAL-IP PORT(S) AGE
    ingress-nginx-controller LoadBalancer 10.92.12.41 <ADRESSE_DU_LB> 80:30080/TCP,443:30443/TCP 3m
    ingress-nginx-controller-admission ClusterIP 10.92.97.75 <none> 443/TCP 3m

    Le Service ingress-nginx-controller est de type LoadBalancer : le composant OUTSCALE du cluster a créé un load balancer public, dont l’adresse s’affiche dans la colonne EXTERNAL-IP. Tant qu’elle affiche <pending>, le load balancer est en cours de création (une à deux minutes).

  2. Enregistrez l’adresse IP publique du load balancer dans la variable LB :

    Terminal window
    LB=$(kubectl get svc ingress-nginx-controller -n ingress-nginx \
    -o jsonpath='{.status.loadBalancer.ingress[0].ip}')
    echo $LB

    L’adresse IP publique du load balancer s’affiche, par exemple 171.33.125.152.

  3. Affichez aussi le nom DNS du load balancer :

    Terminal window
    kubectl get svc ingress-nginx-controller -n ingress-nginx \
    -o jsonpath='{.status.loadBalancer.ingress[0].hostname}{"\n"}'

    Le nom DNS se termine par .eu-west-2.lbu.outscale.com, le domaine des load balancers OUTSCALE de la Région.

Remarque : le load balancer est créé et géré par OKS : il n’apparaît pas dans la liste des load balancers de votre compte (octl iaas loadbalancer list). Vous le gérez uniquement à travers le Service Kubernetes ingress-nginx-controller.

Remarque : les variables du shell (LB, etc.) sont perdues si vous fermez votre terminal. Dans ce cas, exécutez de nouveau la commande de l’étape 2.2.

  1. Créez le namespace de l’application :

    Terminal window
    kubectl create namespace oks-lab02
  2. Créez un fichier oks-lab02-app.yaml avec le contenu suivant :

    apiVersion: apps/v1
    kind: Deployment
    metadata:
    name: echoheaders
    namespace: oks-lab02
    labels:
    app: echoheaders
    spec:
    replicas: 1
    selector:
    matchLabels:
    app: echoheaders
    template:
    metadata:
    labels:
    app: echoheaders
    spec:
    containers:
    - name: echoheaders
    image: registry.k8s.io/echoserver:1.10
    ports:
    - containerPort: 8080
    protocol: TCP
    ---
    apiVersion: v1
    kind: Service
    metadata:
    name: echoheaders
    namespace: oks-lab02
    labels:
    app: echoheaders
    spec:
    type: ClusterIP
    selector:
    app: echoheaders
    ports:
    - port: 8080
    targetPort: 8080
    protocol: TCP

    L’application echoheaders renvoie le détail de chaque requête HTTP reçue. Son Service est de type ClusterIP : il n’est joignable que depuis l’intérieur du cluster.

  3. Appliquez le manifeste et vérifiez que le Pod est à l’état Running :

    Terminal window
    kubectl apply -f oks-lab02-app.yaml
    kubectl get pods -n oks-lab02
  1. Créez un fichier oks-lab02-ingress.yaml avec le contenu suivant :

    apiVersion: networking.k8s.io/v1
    kind: Ingress
    metadata:
    name: echoheaders
    namespace: oks-lab02
    spec:
    ingressClassName: nginx
    rules:
    - host: oks-lab02.example.com
    http:
    paths:
    - path: /
    pathType: Prefix
    backend:
    service:
    name: echoheaders
    port:
    number: 8080
    • ingressClassName: nginx : cet Ingress est pris en charge par le contrôleur Ingress NGINX.
    • host : seules les requêtes adressées à oks-lab02.example.com sont routées vers le Service echoheaders.
  2. Appliquez le manifeste :

    Terminal window
    kubectl apply -f oks-lab02-ingress.yaml
  3. Vérifiez l’Ingress :

    Terminal window
    kubectl get ingress -n oks-lab02

    Exemple de sortie :

    NAME CLASS HOSTS ADDRESS PORTS AGE
    echoheaders nginx oks-lab02.example.com <ADRESSE_DU_LB> 80 1m
  1. Envoyez une requête HTTP au load balancer, pour le nom d’hôte oks-lab02.example.com :

    Terminal window
    curl --connect-to oks-lab02.example.com:80:$LB:80 http://oks-lab02.example.com/

    --connect-to indique à curl de se connecter au load balancer tout en envoyant le nom d’hôte oks-lab02.example.com, comme le ferait un navigateur si ce nom existait dans le DNS.

    Exemple de sortie (extrait) :

    Hostname: echoheaders-65475f6b6-llqkw
    Request Information:
    client_address=10.91.0.130
    method=GET
    real path=/
    request_scheme=http
    request_uri=http://oks-lab02.example.com:8080/
    Request Headers:
    host=oks-lab02.example.com
    x-forwarded-for=10.50.44.176
    x-forwarded-proto=http
    x-real-ip=10.50.44.176

    La réponse vient du Pod echoheaders. L’en-tête x-forwarded-for, ajouté par le contrôleur Ingress NGINX, ne contient pas votre adresse IP publique, mais l’IP privée d’un nœud du cluster (10.50.x.x). Le load balancer envoie le trafic à un nœud, qui le transmet au Pod du contrôleur en remplaçant l’adresse source : l’IP réelle du client est perdue. client_address est l’IP du Pod du contrôleur Ingress NGINX, dans la plage des Pods (10.91.0.0/16).

  2. Envoyez une requête sans le nom d’hôte :

    Terminal window
    curl http://$LB/

    Le contrôleur répond 404 Not Found : aucune règle Ingress ne correspond à cette requête.

cert-manager est un contrôleur Kubernetes qui crée et renouvelle des certificats TLS, et les stocke dans des Secrets.

  1. Installez cert-manager avec Helm :

    Terminal window
    helm repo add jetstack https://charts.jetstack.io --force-update
    helm install cert-manager jetstack/cert-manager \
    --namespace cert-manager \
    --create-namespace \
    --version v1.19.1 \
    --set crds.enabled=true

    crds.enabled=true installe aussi les CRDs (Custom Resource Definitions) de cert-manager : ClusterIssuer, Issuer, Certificate, etc.

  2. Vérifiez que les trois Pods de cert-manager sont à l’état Running :

    Terminal window
    kubectl get pods -n cert-manager

4.2 Créer une autorité de certification auto-signée

Section intitulée « 4.2 Créer une autorité de certification auto-signée »

Dans ce lab, vous n’utilisez pas d’autorité de certification publique (comme Let’s Encrypt), car le nom d’hôte est fictif. Vous créez votre propre CA en trois ressources :

  • le ClusterIssuer oks-lab02-selfsigned signe un certificat avec sa propre clé ;
  • le Certificate oks-lab02-ca utilise ce ClusterIssuer pour créer le certificat de la CA, stocké dans le Secret oks-lab02-ca ;
  • l’Issuer oks-lab02-ca-issuer utilise la CA stockée dans ce Secret pour émettre les certificats de l’application.
  1. Créez un fichier oks-lab02-ca.yaml avec le contenu suivant :

    apiVersion: cert-manager.io/v1
    kind: ClusterIssuer
    metadata:
    name: oks-lab02-selfsigned
    spec:
    selfSigned: {}
    ---
    apiVersion: cert-manager.io/v1
    kind: Certificate
    metadata:
    name: oks-lab02-ca
    namespace: oks-lab02
    spec:
    isCA: true
    commonName: oks-lab02-ca
    secretName: oks-lab02-ca
    privateKey:
    rotationPolicy: Always
    issuerRef:
    name: oks-lab02-selfsigned
    kind: ClusterIssuer
    group: cert-manager.io
    ---
    apiVersion: cert-manager.io/v1
    kind: Issuer
    metadata:
    name: oks-lab02-ca-issuer
    namespace: oks-lab02
    spec:
    ca:
    secretName: oks-lab02-ca

    La ligne rotationPolicy: Always demande à cert-manager de générer une nouvelle clé privée à chaque renouvellement du certificat. C’est la valeur par défaut depuis cert-manager 1.18 : l’indiquer explicitement évite un avertissement à l’application du manifeste.

  2. Appliquez le manifeste :

    Terminal window
    kubectl apply -f oks-lab02-ca.yaml
  3. Vérifiez que le certificat de la CA est prêt et que l’Issuer est utilisable :

    Terminal window
    kubectl get certificate,issuer -n oks-lab02

    La colonne READY affiche True pour le Certificate oks-lab02-ca et pour l’Issuer oks-lab02-ca-issuer.

  1. Créez un fichier oks-lab02-ingress-tls.yaml avec le contenu suivant :

    apiVersion: networking.k8s.io/v1
    kind: Ingress
    metadata:
    name: echoheaders
    namespace: oks-lab02
    annotations:
    cert-manager.io/issuer: oks-lab02-ca-issuer
    nginx.ingress.kubernetes.io/ssl-redirect: "false"
    spec:
    ingressClassName: nginx
    tls:
    - hosts:
    - oks-lab02.example.com
    secretName: oks-lab02-tls
    rules:
    - host: oks-lab02.example.com
    http:
    paths:
    - path: /
    pathType: Prefix
    backend:
    service:
    name: echoheaders
    port:
    number: 8080
    • L’annotation cert-manager.io/issuer demande à cert-manager d’émettre un certificat pour les noms d’hôte de la section tls, avec l’Issuer oks-lab02-ca-issuer.
    • secretName: oks-lab02-tls : Secret dans lequel cert-manager stocke le certificat de l’application. Il doit être différent du Secret de la CA.
    • L’annotation ssl-redirect: "false" conserve l’accès HTTP, pour comparer les deux protocoles. Sans elle, le contrôleur redirige le HTTP vers le HTTPS.
  2. Appliquez le manifeste. L’Ingress echoheaders existe déjà : il est mis à jour.

    Terminal window
    kubectl apply -f oks-lab02-ingress-tls.yaml
  3. Vérifiez que cert-manager a émis le certificat de l’application :

    Terminal window
    kubectl get certificate -n oks-lab02

    Exemple de sortie :

    NAME READY SECRET AGE
    oks-lab02-ca True oks-lab02-ca 5m
    oks-lab02-tls True oks-lab02-tls 30s
  1. Envoyez une requête HTTPS et affichez le certificat présenté par le contrôleur :

    Terminal window
    curl -kv --connect-to oks-lab02.example.com:443:$LB:443 \
    https://oks-lab02.example.com/ 2>&1 | grep -E "issuer:|request_scheme"
    • -k accepte un certificat signé par une CA inconnue de votre poste (votre CA auto-signée).
    • -v affiche le détail de la connexion TLS.

    Exemple de sortie :

    * issuer: CN=oks-lab02-ca
    request_scheme=http

    Le certificat est émis par votre CA oks-lab02-ca. Le contrôleur Ingress NGINX termine la connexion HTTPS, puis transmet la requête en HTTP au Pod : c’est la terminaison TLS.

  2. Vérifiez que l’accès HTTP fonctionne toujours :

    Terminal window
    curl --connect-to oks-lab02.example.com:80:$LB:80 http://oks-lab02.example.com/

Pour valider votre lab, vérifiez les points suivants :

  • kubectl get pods -n ingress-nginx affiche le Pod ingress-nginx-controller à l’état Running.
  • kubectl get svc -n ingress-nginx affiche une adresse dans la colonne EXTERNAL-IP du Service ingress-nginx-controller.
  • echo $LB affiche l’adresse IP publique du load balancer.
  • curl --connect-to oks-lab02.example.com:80:$LB:80 http://oks-lab02.example.com/ renvoie la réponse du Pod echoheaders.
  • kubectl get certificate -n oks-lab02 affiche oks-lab02-ca et oks-lab02-tls à l’état READY True.
  • La requête HTTPS de l’étape 4.4 affiche issuer: CN=oks-lab02-ca.
  1. Passez le Deployment echoheaders à 3 réplicas, puis envoyez plusieurs requêtes HTTP : observez la valeur de Hostname dans les réponses.
  2. Supprimez l’annotation nginx.ingress.kubernetes.io/ssl-redirect de l’Ingress, appliquez de nouveau le manifeste, puis envoyez une requête HTTP avec curl -I.

Question : Pourquoi le Secret oks-lab02-tls doit-il être différent du Secret oks-lab02-ca ?

💡 Correction — Passage à 3 réplicas
Terminal window
kubectl scale deployment echoheaders -n oks-lab02 --replicas=3
for i in 1 2 3 4 5 6; do
curl -s --connect-to oks-lab02.example.com:80:$LB:80 http://oks-lab02.example.com/ | grep Hostname
done

La valeur de Hostname change d’une requête à l’autre : le contrôleur Ingress NGINX répartit les requêtes entre les trois Pods.

💡 Correction — Redirection HTTP vers HTTPS
Terminal window
curl -I --connect-to oks-lab02.example.com:80:$LB:80 http://oks-lab02.example.com/

Le contrôleur répond 308 Permanent Redirect, avec un en-tête Location: https://oks-lab02.example.com/. Dès qu’un Ingress déclare une section tls, le contrôleur redirige par défaut le HTTP vers le HTTPS.

💡 Correction — Question du challenge

cert-manager écrit le certificat de l’application dans le Secret indiqué par secretName. Si ce Secret était oks-lab02-ca, cert-manager remplacerait le certificat de la CA par celui de l’application : l’Issuer oks-lab02-ca-issuer ne pourrait plus émettre de certificats.

Attention : avant de supprimer une ressource, vérifiez qu’elle n’est pas utilisée par d’autres labs.

Si vous prévoyez de continuer avec le Lab 03, ne supprimez pas les ressources du Lab 01 :

  • le cluster OKS oks-lab01-cluster et ses NodePools ;
  • le fichier kubeconfig oks-lab01-kubeconfig.yaml.

Supprimez les ressources suivantes, qui ne seront pas réutilisées :

  1. Supprimer l’application, l’Ingress et la CA :

    Terminal window
    kubectl delete namespace oks-lab02
    kubectl delete clusterissuer oks-lab02-selfsigned
  2. Désinstaller cert-manager :

    Terminal window
    helm uninstall cert-manager -n cert-manager
    kubectl delete namespace cert-manager
  3. Désinstaller le contrôleur Ingress NGINX. La suppression du Service ingress-nginx-controller entraîne celle du load balancer :

    Terminal window
    helm uninstall ingress-nginx -n ingress-nginx
    kubectl delete namespace ingress-nginx
  4. Vérifiez qu’il ne reste aucun Service de type LoadBalancer dans le cluster :

    Terminal window
    kubectl get svc -A | grep LoadBalancer

    La commande n’affiche rien.