Aller au contenu principal

Lab 1.1 - Premier Déploiement sur Kubernetes

Objectifs du Lab​

À la fin de ce lab, vous serez capable de:

  • Déployer votre première application sur Kubernetes
  • Utiliser kubectl pour créer des ressources
  • Comprendre les Pods et Deployments
  • Vérifier l'état de votre déploiement
  • Accéder à votre application

Durée Estimée​

30-45 minutes

Prérequis​

  • kubectl installé et configuré
  • Cluster Kubernetes local fonctionnel (minikube ou kind)
  • Connexion Internet (pour télécharger les images Docker)

Vérification de l'Environnement​

Avant de commencer, vérifions que tout est prêt:

# 1. Vérifier kubectl
kubectl version --client

# 2. Vérifier la connexion au cluster
kubectl cluster-info

# 3. Lister les nodes (devrait montrer au moins 1 node)
kubectl get nodes

Résultat attendu:

NAME           STATUS   ROLES           AGE   VERSION
minikube       Ready    control-plane   5m    v1.28.0

Si vous voyez une erreur, retournez au Chapitre 1 pour configurer votre environnement.

Partie 1: Déploiement Simple avec kubectl​

Étape 1: Créer un Pod Simple​

Commençons par créer un Pod simple qui exécute nginx:

kubectl run nginx-pod --image=nginx:latest

Explication:

  • kubectl run: Commande pour créer un Pod
  • nginx-pod: Nom du Pod
  • --image=nginx:latest: Image Docker à utiliser

Étape 2: Vérifier le Pod​

Vérifions que le Pod a été créé:

kubectl get pods

Résultat attendu:

NAME        READY   STATUS    RESTARTS   AGE
nginx-pod   1/1     Running   0          30s

Explication des colonnes:

  • NAME: Nom du Pod
  • READY: Nombre de conteneurs prêts / nombre total (1/1 = prêt)
  • STATUS: État du Pod (Running = en cours d'exécution)
  • RESTARTS: Nombre de redémarrages
  • AGE: Temps depuis la création

Étape 3: Obtenir Plus de Détails​

Pour voir plus d'informations sur le Pod:

kubectl describe pod nginx-pod

Cette commande affiche:

  • Les événements du Pod
  • L'état des conteneurs
  • Les ressources allouées
  • Les labels et annotations

Étape 4: Voir les Logs​

Consultez les logs du Pod:

kubectl logs nginx-pod

Vous devriez voir les logs du serveur nginx.

Étape 5: Exécuter une Commande dans le Pod​

Exécutons une commande à l'intérieur du Pod:

kubectl exec -it nginx-pod -- /bin/bash

Explication:

  • exec: Exécuter une commande dans un conteneur
  • -it: Mode interactif avec terminal
  • -- /bin/bash: Commande à exécuter

Une fois dans le Pod, essayez:

# Voir le contenu du répertoire
ls -la

# Vérifier que nginx fonctionne
curl localhost

# Sortir du Pod
exit

Étape 6: Supprimer le Pod​

Supprimons le Pod que nous venons de créer:

kubectl delete pod nginx-pod

Vérifions qu'il a été supprimé:

kubectl get pods

Partie 2: Déploiement avec un Fichier YAML​

Maintenant, créons un déploiement plus professionnel en utilisant un fichier YAML.

Étape 1: Créer le Fichier YAML​

Créez un fichier nginx-deployment.yaml:

apiVersion: apps/v1
kind: Deployment
metadata:
  name: nginx-deployment
  labels:
    app: nginx
spec:
  replicas: 3
  selector:
    matchLabels:
      app: nginx
  template:
    metadata:
      labels:
        app: nginx
    spec:
      containers:
      - name: nginx
        image: nginx:1.25
        ports:
        - containerPort: 80

Explication du fichier:

  • apiVersion: Version de l'API Kubernetes
  • kind: Type de ressource (Deployment)
  • metadata: Métadonnées (nom, labels)
  • spec: Spécification du déploiement
    • replicas: Nombre d'instances (3)
    • selector: Comment identifier les Pods
    • template: Modèle pour créer les Pods

Étape 2: Appliquer le Déploiement​

Appliquons le fichier YAML:

kubectl apply -f nginx-deployment.yaml

Résultat attendu:

deployment.apps/nginx-deployment created

Étape 3: Vérifier le Déploiement​

Vérifions que le déploiement a été créé:

kubectl get deployments

Résultat attendu:

NAME               READY   UP-TO-DATE   AVAILABLE   AGE
nginx-deployment   3/3     3            3           30s

Explication:

  • READY: 3/3 = 3 Pods prêts sur 3 désirés
  • UP-TO-DATE: 3 Pods à jour
  • AVAILABLE: 3 Pods disponibles

Étape 4: Voir les Pods Créés​

Le Deployment a créé 3 Pods:

kubectl get pods -l app=nginx

Résultat attendu:

NAME                                READY   STATUS    RESTARTS   AGE
nginx-deployment-7d4b8c9f5c-abc12   1/1     Running   0          1m
nginx-deployment-7d4b8c9f5c-def34   1/1     Running   0          1m
nginx-deployment-7d4b8c9f5c-ghi56   1/1     Running   0          1m

Note: Les noms des Pods sont générés automatiquement avec un hash unique.

Étape 5: Détails du Déploiement​

Obtenons plus d'informations sur le déploiement:

kubectl describe deployment nginx-deployment

Cette commande affiche:

  • Le nombre de réplicas
  • La stratégie de déploiement
  • Les événements
  • Les conditions

Partie 3: Exposer l'Application​

Maintenant, exposons l'application pour y accéder depuis l'extérieur.

Étape 1: Créer un Service​

Créez un fichier nginx-service.yaml:

apiVersion: v1
kind: Service
metadata:
  name: nginx-service
spec:
  type: NodePort
  selector:
    app: nginx
  ports:
    - protocol: TCP
      port: 80
      targetPort: 80
      nodePort: 30080

Explication:

  • kind: Service: Crée un Service
  • type: NodePort: Expose le service sur un port de chaque node
  • selector: Sélectionne les Pods avec le label app: nginx
  • nodePort: 30080: Port accessible depuis l'extérieur

Étape 2: Appliquer le Service​

kubectl apply -f nginx-service.yaml

Étape 3: Vérifier le Service​

kubectl get services

Résultat attendu:

NAME            TYPE        CLUSTER-IP      EXTERNAL-IP   PORT(S)        AGE
nginx-service   NodePort    10.96.123.45    <none>        80:30080/TCP   30s

Étape 4: Accéder à l'Application​

Avec minikube:​

# Obtenir l'URL du service
minikube service nginx-service --url

# Ou ouvrir directement dans le navigateur
minikube service nginx-service

Avec kind:​

# Trouver l'adresse IP du node
kubectl get nodes -o wide

# Accéder via http://<NODE-IP>:30080

Test avec curl:​

# Depuis votre machine
curl http://localhost:30080

# Ou depuis un Pod
kubectl run curl-test --image=curlimages/curl --rm -it -- curl http://nginx-service

Vous devriez voir la page d'accueil par défaut de nginx!

Partie 4: Scaling et Mise à Jour​

Étape 1: Augmenter le Nombre de Réplicas​

Augmentons le nombre de Pods de 3 à 5:

kubectl scale deployment nginx-deployment --replicas=5

Vérifions:

kubectl get pods -l app=nginx

Vous devriez maintenant voir 5 Pods!

Étape 2: Réduire le Nombre de Réplicas​

Réduisons à 2 Pods:

kubectl scale deployment nginx-deployment --replicas=2

Étape 3: Mise à Jour de l'Image​

Mettons à jour l'image nginx vers une version plus récente:

kubectl set image deployment/nginx-deployment nginx=nginx:1.26

Vérifions la mise à jour:

kubectl rollout status deployment/nginx-deployment

Cette commande montre la progression du rolling update.

Étape 4: Voir l'Historique des Déploiements​

kubectl rollout history deployment/nginx-deployment

Étape 5: Rollback (Optionnel)​

Si quelque chose ne va pas, on peut revenir en arrière:

kubectl rollout undo deployment/nginx-deployment

Partie 5: Nettoyage​

Nettoyons les ressources créées:

# Supprimer le Service
kubectl delete -f nginx-service.yaml

# Supprimer le Deployment (supprime aussi les Pods)
kubectl delete -f nginx-deployment.yaml

# Vérifier que tout est supprimé
kubectl get all

Résumé du Lab​

Dans ce lab, vous avez:

Créé votre premier Pod avec kubectl
Créé un Deployment avec un fichier YAML
Exposé l'application avec un Service NodePort
Scalé le déploiement (augmenté/réduit le nombre de réplicas)
Mis à jour l'image Docker
Nettoyé les ressources

Questions de Réflexion​

  1. Quelle est la différence entre un Pod et un Deployment?

    • Un Pod est une instance unique d'un conteneur
    • Un Deployment gère plusieurs Pods (réplicas) et leur cycle de vie

  2. Pourquoi utiliser un Deployment plutôt qu'un Pod directement?

    • Le Deployment gère automatiquement les réplicas
    • Il permet les rolling updates
    • Il redémarre automatiquement les Pods qui plantent

  3. Qu'est-ce qu'un Service et pourquoi en avons-nous besoin?

    • Un Service expose un ensemble de Pods de manière stable
    • Il fournit le load balancing
    • Il permet l'accès depuis l'extérieur du cluster

Prochaines Étapes​

Maintenant que vous avez déployé votre première application, vous êtes prêt pour:

Chapitre 2: Exploration approfondie des Pods
Module 2: Architecture détaillée de Kubernetes

Ressources​

Lab créé le: Décembre 2024