Docker Minikube

Jour 5 : Orchestration, Scalabilité et Résilience (Minikube)

5.1. Introduction à l’Orchestration (Kubernetes)

Avec Docker Compose, si votre machine meurt, tout meurt. Si le conteneur webapp crashe, Compose ne le relance pas toujours intelligemment, et surtout, on ne peut pas avoir 3 instances de webapp qui se partagent la charge facilement sans configuration complexe.

Kubernetes (K8s) résout cela.

  • Analogie : Docker est un musicien soliste. Kubernetes est le chef d’orchestre qui gère 100 musiciens.

Les concepts clés (Simplifiés)

  1. Cluster : L’ensemble des machines (Minikube simule un cluster d’un seul nœud).

  2. Pod : L’atome de K8s. C’est un ou plusieurs conteneurs encapsulés. C’est ce qu’on déploie.

  3. Deployment : Le manager. On lui dit “Je veux 3 copies de mon Pod tout le temps”. Il surveille et répare.

  4. Service : L’adresse réseau stable. Les Pods meurent et changent d’IP, le Service reste fixe.

Extrait de code

@startuml
!theme plain
skinparam componentStyle rectangle

package "Cluster Kubernetes" {
    component "Service (LoadBalancer)" as Svc #Yellow

    node "Node 1" {
        component "Pod A (App)" as P1
        component "Pod B (App)" as P2
        component "Pod C (App)" as P3
    }
}

actor Client
Client -> Svc : Requête HTTP
Svc --> P1
Svc --> P2
Svc --> P3
note right of Svc : Répartition de charge\nautomatique (Round-robin)
@enduml

5.2. Installation et Prise en main Minikube

Minikube crée une VM (ou un conteneur Docker) qui contient un cluster K8s complet.

Bash

# Démarrage
minikube start

# Vérification
kubectl get nodes

# L'interface graphique (Tableau de bord)
minikube dashboard

Note Enseignant : Insistez bien sur la commande kubectl. C’est le nouveau docker.

docker run devient (grossièrement) kubectl create deployment.

5.3. Migration : De Compose à Manifeste K8s

On reprend l’application Web du J4 (sans Caddy pour simplifier, ou avec si on est à l’aise, mais souvent on utilise les fonctionnalités natives de K8s pour l’exposition).

Exercice : Créer le fichier deployment.yaml

YAML

apiVersion: apps/v1
kind: Deployment
metadata:
  name: webapp-deployment
spec:
  replicas: 1              # On commence doucement
  selector:
    matchLabels:
      app: webapp
  template:                # La définition du Pod (ressemble au Docker Compose)
    metadata:
      labels:
        app: webapp
    spec:
      containers:
      - name: wordpress
        image: wordpress:latest
        env:
        - name: WORDPRESS_DB_HOST
          value: "mysql-service" # Nom du service DB K8s
        ports:
        - containerPort: 80

Commandes à pratiquer :

Bash

kubectl apply -f deployment.yaml
kubectl get pods

5.4. Le Service et l’Exposition

Pour accéder à l’application, il faut un Service.

YAML

apiVersion: v1
kind: Service
metadata:
  name: webapp-service
spec:
  type: LoadBalancer # Sur Minikube, demande "minikube tunnel"
  selector:
    app: webapp      # Pointe vers les pods avec le label "webapp"
  ports:
    - protocol: TCP
      port: 80       # Port externe
      targetPort: 80 # Port du conteneur

5.5. Activité Finale : “Le Chaos Monkey & Scale-up”

C’est ici que K8s brille. On va jouer avec la résilience.

Phase 1 : Scalabilité (Scale-up)

Le site est lent ? Il y a trop de monde ?

Au lieu de racheter un serveur plus gros, on ajoute des instances.

  • Action :

    Bash

      kubectl scale deployment webapp-deployment --replicas=5

  • Observation :

    Faire un kubectl get pods -w (watch). Voir les 4 nouveaux conteneurs naître instantanément.

Phase 2 : Résilience (Self-Healing)

C’est le clou du spectacle.

  • Action :

    Repérez un Pod actif : kubectl get pods (ex: webapp-deployment-xyz).

    Tuez-le froidement :

    Bash

      kubectl delete pod webapp-deployment-xyz

  • Observation :

    Le Pod passe en statut Terminating.

    MAIS, instantanément, Kubernetes voit qu’il en manque un (on en a demandé 5, il n’y en a plus que 4).

    Il en recrée un nouveau immédiatement (ContainerCreating).

Conclusion du cours : Avec Docker (J1-J4), vous avez appris à empaqueter et livrer. Avec Kubernetes (J5), vous avez appris à rendre votre application immortelle.

5.6. Ressources pour aller plus loin

Pour conclure le module, fournir une liste de mots clés à explorer :

  • Helm : Le gestionnaire de paquets pour K8s (Le “apt-get” de Kubernetes).

  • Ingress Controller : Le remplaçant K8s natif de notre Caddy/Traefik.

  • Cloud Providers : AWS EKS, Google GKE, Azure AKS (où K8s est géré pour vous).