Lab2-Approche impérative et déclarative

Objectif du TP

Mettre en place une petite application web basée sur Nginx en utilisant uniquement des commandes impératives et de manière déclarative

Les ressources seront créées directement dans le cluster via kubectl.

Partie 1 - Approche impérative

1. Déploiement de l’application de manière impérative

Créer un déploiement Nginx :

kubectl create deployment nginx-lab-imperative --image=nginx

Vérifier que le pod est bien lancé :

kubectl get pods -l app=nginx-lab-imperative

2. Exposition de l’application via un Service

Créer un Service de type ClusterIP :

kubectl expose deployment nginx-lab-imperative \
  --port=80 \
  --target-port=80 \
  --type=ClusterIP

Vérifier :

kubectl get svc nginx-lab-imperative

3. Publication via un Ingress

Créer un Ingress directement avec une commande impérative :

kubectl create ingress nginx-lab-imperative \
  --rule="nginx.lab.imp/*=nginx-lab-imperative:80"

Vérifier que l’Ingress est bien créé :

kubectl get ingress nginx-lab-imperative

Note : ce TP suppose qu’un Ingress Controller est déjà installé dans le cluster (Traefik, nginx‑ingress, etc.).

4. Configuration du nom DNS local

Pour accéder au site via un nom, ajouter une entrée dans le fichier hosts de votre machine.

Modifier le fichier :

Linux / macOS

sudo nano /etc/hosts

Windows

notepad C:\Windows\System32\drivers\etc\hosts

Ajouter une ligne :

<IP_INGRESS>   nginx.lab.dec

Remplacer <IP_INGRESS> par l’adresse IP exposée par votre Ingress Controller.

5. Test d’accès

Ouvrir un navigateur et accéder à :

http://nginx.lab.dec

Vous devriez voir la page d’accueil par défaut de Nginx.

6. Vérifications en cas de problème

Quelques commandes utiles :

kubectl get pods -l app=nginx-lab-imperative
kubectl get svc nginx-lab-imperative
kubectl get ingress nginx-lab-imperative
kubectl describe ingress nginx-lab-imperative

Partie 2 - Approche déclarative

1. Déploiement de l’application de manière déclarative

Créer un fichier nommé deployment.yaml :

apiVersion: apps/v1
kind: Deployment
metadata:
  name: nginx-lab-declarative
spec:
  replicas: 1
  selector:
    matchLabels:
      app: nginx-lab-declarative
  template:
    metadata:
      labels:
        app: nginx-lab-declarative
    spec:
      containers:
      - name: nginx
        image: nginx
        ports:
        - containerPort: 80

Appliquer :

kubectl apply -f deployment.yaml

Vérifier :

kubectl get pods -l app=nginx-lab-declarative

2. Service (YAML)

Créer un fichier service.yaml :

apiVersion: v1
kind: Service
metadata:
  name: nginx-lab-declarative
spec:
  type: ClusterIP
  selector:
    app: nginx-lab-declarative
  ports:
  - port: 80
    targetPort: 80

Appliquer :

kubectl apply -f service.yaml

Vérifier :

kubectl get svc nginx-lab-declarative

3. Ingress (YAML)

Créer un fichier ingress.yaml :

apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
  name: nginx-lab-declarative
spec:
  rules:
  - host: nginx.lab.dec
    http:
      paths:
      - path: /
        pathType: Prefix
        backend:
          service:
            name: nginx-lab-declarative
            port:
              number: 80

Appliquer :

kubectl apply -f ingress.yaml

Vérifier :

kubectl get ingress nginx-lab-declarative

Note : ce TP suppose que votre Ingress Controller est déjà fonctionnel.

4. Entrée DNS locale

Comme dans la partie impérative, ajouter une entrée dans votre fichier hosts :

<IP_INGRESS>   nginx.lab.imp

Remplacer <IP_INGRESS> par l’adresse IP fournie par votre Ingress Controller.

5. Test d’accès

Accéder au site :

http://nginx.lab.imp

Vous devriez obtenir la page d’accueil de Nginx.

6. Vérifications

kubectl get pods -l app=nginx-lab-declarative
kubectl get svc nginx-lab-declarative
kubectl get ingress nginx-lab-declarative
kubectl describe ingress nginx-lab-declarative

Partie 3 - Importation de projets existant en manifeste

1. Recréer un manifeste à partir d’une ressource existante dans Kubernetes

Dans cette partie, vous allez partir d’un déploiement déjà présent dans le cluster (créé dans la partie impérative) et apprendre à :

récupérer sa configuration sous forme YAML
nettoyer le fichier pour enlever les champs inutiles
obtenir un manifeste déclaratif réutilisable
comparer le résultat avec la partie 2

L’objectif est de comprendre la différence entre l’état réel du cluster et l’état désiré exprimé dans un manifeste.

1. Récupération du YAML brut

Kubernetes permet d’obtenir la définition complète d’une ressource avec :

kubectl get deployment nginx-lab-imperative -o yaml > export-deployment.yaml

Faire la même chose pour le Service :

kubectl get svc nginx-lab-imperative -o yaml > export-service.yaml

Et pour l’Ingress :

kubectl get ingress nginx-lab-imperative -o yaml > export-ingress.yaml

Vous obtenez trois fichiers contenant l’état réel des ressources telles que Kubernetes les voit.

2. Analyse du YAML exporté

Ouvrir les fichiers et observer :

les champs ajoutés automatiquement par Kubernetes
les métadonnées internes
les sections qui ne devraient pas se retrouver dans un manifeste déclaratif

Quelques exemples de champs à retirer :

status:
metadata.creationTimestamp
metadata.resourceVersion
metadata.uid
metadata.managedFields
spec.clusterIP (pour les Services)
spec.ports[*].nodePort (si Service NodePort)

L’objectif est de comprendre que ces champs représentent l’état du cluster, pas l’intention de l’administrateur.

3. Nettoyage du manifeste

Créer une copie propre de chaque fichier, par exemple :

deployment-clean.yaml
service-clean.yaml
ingress-clean.yaml

Retirer manuellement les champs inutiles.
Le résultat doit ressembler à un manifeste déclaratif comparable à ceux de la partie 2.

Le but n’est pas d’obtenir un fichier parfait du premier coup, mais de comprendre ce qui doit être conservé ou non.

4. Validation du manifeste nettoyé

Tester l’application des fichiers nettoyés dans un namespace temporaire.

Créer un namespace :

kubectl create ns test-import

Appliquer les fichiers :

kubectl apply -n test-import -f deployment-clean.yaml
kubectl apply -n test-import -f service-clean.yaml
kubectl apply -n test-import -f ingress-clean.yaml

Vérifier :

kubectl get all -n test-import

Si les ressources se créent correctement, votre manifeste est valide.

5. Comparaison avec la version déclarative du TP précédent

Comparer :

deployment-clean.yaml
deployment.yaml de la partie 2