Accueil / Kubernetes

Kubernetes

Le chef d'orchestre de tes conteneurs Docker. Quand tu as plus d'un conteneur à faire tourner et qu'il faut gérer le déploiement, le passage à l'échelle, la résilience et le réseau, c'est lui qui prend le relais.

Orchestration DevOps

À quoi ça sert

Avec Docker, tu sais empaqueter une application dans un conteneur. Mais en production, on n'a jamais un seul conteneur : on en a des dizaines, sur plusieurs machines, avec des contraintes : si l'un crashe, il faut le relancer ; si la charge monte, il en faut plus ; il faut router le trafic, gérer les mises à jour sans coupure, partager des secrets…

Kubernetes (souvent abrégé K8s) automatise tout ça. Tu lui décris l'état désiré (« je veux 3 répliques de mon API exposées sur le port 80 ») et il se charge de l'atteindre et de le maintenir, peu importe ce qui se passe.

Les concepts à connaître pour démarrer :

  • Pod — la plus petite unité ; généralement 1 conteneur, parfois plusieurs liés.
  • Deployment — gère un groupe de Pods identiques (réplicas, mises à jour).
  • Service — donne une adresse réseau stable à un groupe de Pods.
  • Ingress — expose des Services sur l'extérieur (HTTP/HTTPS).
  • Namespace — un espace logique pour isoler des projets / environnements.
En une phrase

Kubernetes prend une description de ce que tu veux et garde ton infra dans cet état, automatiquement, en réagissant aux pannes et à la charge.

Un exemple d'usage

Tu as une API FastAPI conteneurisée. En prod, tu veux 3 instances qui tournent en parallèle pour encaisser la charge, qu'elles redémarrent automatiquement en cas de crash, et que le trafic soit réparti entre elles. Avec Kubernetes, tu écris ce manifeste :

yaml 
apiVersion: apps/v1
kind: Deployment
metadata:
  name: mon-api
spec:
  replicas: 3
  selector:
    matchLabels:
      app: mon-api
  template:
    metadata:
      labels:
        app: mon-api
    spec:
      containers:
        - name: api
          image: mon-api:1.0
          ports:
            - containerPort: 8000

Tu lances kubectl apply -f mon-api.yaml et Kubernetes crée 3 Pods. Si l'un meurt, il en relance un. Si tu veux 5 répliques, tu changes replicas: 5 et re-appliques. C'est tout.

How-to : essayer Kubernetes en local

  1. Installer kubectl (le CLI Kubernetes)

    kubectl est l'outil en ligne de commande qui te permet de parler à un cluster.

    Linux / macOS :

    bash 
    # macOS
brew install kubectl

# Linux (binaire)
curl -LO "https://dl.k8s.io/release/$(curl -L -s https://dl.k8s.io/release/stable.txt)/bin/linux/amd64/kubectl"
sudo install -o root -g root -m 0755 kubectl /usr/local/bin/kubectl

    Windows (avec winget) :

    powershell 
    winget install -e --id Kubernetes.kubectl

    Vérifie l'installation :

    bash 
    kubectl version --client

  2. Lancer un cluster local avec Minikube

    Pour expérimenter, on utilise un mini-cluster qui tourne sur ta machine. Minikube est l'option la plus populaire ; kind ou Docker Desktop (case « Enable Kubernetes ») marchent aussi.

    bash 
    # macOS
brew install minikube

# Linux
curl -LO https://storage.googleapis.com/minikube/releases/latest/minikube-linux-amd64
sudo install minikube-linux-amd64 /usr/local/bin/minikube

# Démarrer le cluster (nécessite Docker)
minikube start

# Vérifier
kubectl get nodes

    Tu devrais voir un nœud nommé minikube au statut Ready.

  3. Déployer une application de démo

    Crée app.yaml avec un Deployment + un Service :

    yaml 
    apiVersion: apps/v1
kind: Deployment
metadata:
  name: hello
spec:
  replicas: 2
  selector:
    matchLabels:
      app: hello
  template:
    metadata:
      labels:
        app: hello
    spec:
      containers:
        - name: web
          image: nginxdemos/hello:latest
          ports:
            - containerPort: 80
---
apiVersion: v1
kind: Service
metadata:
  name: hello
spec:
  type: NodePort
  selector:
    app: hello
  ports:
    - port: 80
      targetPort: 80

  4. Appliquer le manifeste et observer

    bash 
    kubectl apply -f app.yaml
kubectl get pods       # 2 pods en cours de démarrage
kubectl get deploy
kubectl get svc

# Ouvrir l'app dans le navigateur (Minikube)
minikube service hello

    Une page nginx s'ouvre. Recharge plusieurs fois : tu verras le nom du Pod changer entre les deux instances.

  5. Tester la résilience

    Supprime un Pod manuellement et regarde Kubernetes en relancer un :

    bash 
    kubectl get pods
kubectl delete pod <nom-d-un-pod>
kubectl get pods       # un nouveau Pod prend la place

    Pour mettre à l'échelle :

    bash 
    kubectl scale deployment hello --replicas=5

  6. Configurer VS Code

    Deux extensions très utiles pour bosser avec Kubernetes :

    1. Kubernetes de Microsoft (ms-kubernetes-tools.vscode-kubernetes-tools) : vue arborescente de ton cluster, déploiement en un clic, logs, exec dans les Pods.
    2. YAML de Red Hat (redhat.vscode-yaml) : autocomplétion et validation des manifestes Kubernetes.

    Pour activer la validation Kubernetes, ajoute dans .vscode/settings.json :

    json 
    {
    "yaml.schemas": {
        "kubernetes": "*.yaml"
    }
}
    Astuce

    L'extension Kubernetes affiche un panneau « Clusters » à gauche : tu peux y naviguer dans tes Pods, voir les logs en direct, ouvrir un terminal dans un conteneur — sans quitter VS Code.

  7. Nettoyer

    bash 
    kubectl delete -f app.yaml
minikube stop
minikube delete       # supprime complètement le cluster

Aide-mémoire kubectl

bash 
# Voir les ressources
kubectl get pods
kubectl get deploy,svc,ingress
kubectl get all -A             # tout, tous namespaces

# Détails & logs
kubectl describe pod <nom>
kubectl logs <pod> -f          # suivre les logs
kubectl exec -it <pod> -- bash # shell dans le pod

# Appliquer / supprimer
kubectl apply -f fichier.yaml
kubectl delete -f fichier.yaml

# Mise à l'échelle
kubectl scale deploy <nom> --replicas=5

# Port-forward (accéder à un service depuis ta machine)
kubectl port-forward svc/hello 8080:80

# Contexte (basculer entre clusters)
kubectl config get-contexts
kubectl config use-context <nom>

Pour aller plus loin