Kubernetes pour les débutants : Pods, Deployments, Services et premiers pas

Kubernetes est devenu le standard pour déployer et gérer des applications en production. Mais quand on débute, la courbe d'apprentissage peut sembler raide : Pods, Services, Deployments, Ingress, Helm… Les termes s'accumulent et on ne sait pas par où commencer.

Ce guide est là pour changer ça. En 15 minutes de lecture, tu comprendras ce que fait Kubernetes, pourquoi il existe, et comment l'utiliser concrètement — avec des exemples de commandes que tu peux tester immédiatement.

Qu'est-ce que Kubernetes ?

Kubernetes (souvent abrégé K8s) est un orchestrateur de conteneurs open source, créé par Google et maintenu par la Cloud Native Computing Foundation (CNCF). Son rôle : automatiser le déploiement, la mise à l'échelle et la gestion d'applications conteneurisées.

Pour comprendre simplement : si Docker te permet de créer des conteneurs (des "boîtes" isolées contenant ton application), Kubernetes te permet de gérer des dizaines ou des centaines de ces boîtes en production — en s'assurant qu'elles tournent, qu'elles se parlent, et qu'elles redémarrent si elles plantent.

Kubernetes, c'est un chef d'orchestre pour tes conteneurs : tu lui dis "je veux 3 copies de mon app web, reliées à ma base de données", et il s'occupe du reste.

Pourquoi pas juste Docker ?

Docker seul fonctionne très bien pour un ou deux conteneurs sur une machine. Mais dès que tu as besoin de faire tourner des conteneurs sur plusieurs serveurs, de redémarrer automatiquement un conteneur qui plante, de répartir le trafic entre plusieurs instances, de faire des mises à jour sans interruption ou de scaler automatiquement selon la charge, tu as besoin d'un orchestrateur. Et Kubernetes est devenu le standard de l'industrie.

L'architecture de Kubernetes expliquée simplement

Un cluster Kubernetes se compose de deux types de machines :

Le Control Plane (le cerveau)

C'est le "chef d'orchestre". Il contient :

• API Server : le point d'entrée pour toutes les commandes (kubectl)
• etcd : la base de données qui stocke l'état du cluster
• Scheduler : décide sur quel nœud placer chaque conteneur
• Controller Manager : vérifie que l'état réel correspond à l'état souhaité

Les Nodes (les ouvriers)

Ce sont les machines qui exécutent réellement tes conteneurs. Chaque nœud contient le Kubelet (agent de communication), le Container Runtime (containerd ou CRI-O) et Kube-proxy (routage réseau).

┌─────────────────────────────────────────┐
│            CONTROL PLANE                │
│  ┌──────────┐ ┌─────┐ ┌───────────┐    │
│  │API Server│ │etcd │ │ Scheduler │    │
│  └──────────┘ └─────┘ └───────────┘    │
└─────────────────┬───────────────────────┘
                  │
    ┌─────────────┼──────────────┐
┌───▼───┐   ┌────▼──┐    ┌─────▼─┐
│ Node 1│   │Node 2 │    │Node 3 │
│ Pod A │   │ Pod B │    │ Pod C │
└───────┘   └───────┘    └───────┘

Les concepts clés de Kubernetes

Pod : l'unité de base

Un Pod est le plus petit objet dans Kubernetes. Il contient un ou plusieurs conteneurs qui partagent le même réseau et le même stockage. Dans 90% des cas, un Pod = un conteneur.

# mon-premier-pod.yaml
apiVersion: v1
kind: Pod
metadata:
  name: nginx-pod
  labels:
    app: nginx
spec:
  containers:
  - name: nginx
    image: nginx:latest
    ports:
    - containerPort: 80

# Créer le Pod
kubectl apply -f mon-premier-pod.yaml

# Vérifier qu'il tourne
kubectl get pods

# Voir les logs
kubectl logs nginx-pod

# Se connecter au conteneur
kubectl exec -it nginx-pod -- /bin/bash

Deployment : gérer les réplicas

En production, tu ne crées jamais un Pod directement. Tu utilises un Deployment, qui gère automatiquement les réplicas et les mises à jour.

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

# Déployer
kubectl apply -f mon-deployment.yaml

# Scaler à 5 réplicas
kubectl scale deployment nginx-deployment --replicas=5

# Mettre à jour l'image (rolling update)
kubectl set image deployment/nginx-deployment nginx=nginx:1.26

L'avantage du Deployment : si un Pod plante, Kubernetes en recrée un automatiquement. Les mises à jour se font un Pod à la fois (zero downtime).

Service : exposer ton application

Les Pods ont des IP éphémères. Un Service crée une adresse stable. Trois types : ClusterIP (interne), NodePort (tests) et LoadBalancer (production cloud).

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

Ingress : le routeur HTTP

Un Ingress gère le routage HTTP/HTTPS vers tes Services — comme un reverse proxy Nginx intégré à Kubernetes.

apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
  name: mon-ingress
spec:
  rules:
  - host: monapp.example.com
    http:
      paths:
      - path: /
        pathType: Prefix
        backend:
          service:
            name: nginx-service
            port:
              number: 80

ConfigMap et Secret

ConfigMap pour la configuration non sensible, Secret pour les mots de passe et tokens.

kubectl create configmap app-config --from-literal=DB_HOST=postgres
kubectl create secret generic db-secret --from-literal=DB_PASSWORD=monsupermdp

Kubernetes vs Docker Compose

Docker Compose : développement local, un seul serveur, simple. Kubernetes : production, multi-serveurs, haute disponibilité, scaling automatique, rolling updates. Utilise Compose pour prototyper, Kubernetes pour la production.

Les commandes kubectl essentielles

kubectl cluster-info                     # Vérifier la connexion
kubectl get pods / deployments / services # Lister les ressources
kubectl get all                          # Tout d'un coup
kubectl apply -f fichier.yaml            # Créer/appliquer
kubectl delete -f fichier.yaml           # Supprimer
kubectl describe pod mon-pod             # Détails + events
kubectl logs mon-pod                     # Logs
kubectl exec -it mon-pod -- sh           # Shell interactif
kubectl scale deployment mon-app --replicas=5
kubectl rollout undo deployment/mon-app  # Rollback

Les certifications Kubernetes

La CKA (Certified Kubernetes Administrator) est la plus demandée par les recruteurs. Examen 100% pratique sur un vrai cluster, 2 heures, ~395 $. Il existe aussi la CKAD (développeur) et la CKS (sécurité).

→ Prépare la CKA avec nos labs + examen blanc

FAQ

Kubernetes est-il gratuit ?

Oui, Kubernetes est open source. Tu paies l'infrastructure (serveurs, cloud). Les services managés (EKS, GKE, AKS) facturent la gestion du control plane en plus.

Faut-il connaître Docker avant Kubernetes ?

Fortement recommandé. Kubernetes orchestre des conteneurs — comprendre Docker est un prérequis quasi indispensable. Nos labs Docker sont un bon point de départ.

Combien de temps pour apprendre Kubernetes ?

2-4 semaines pour les bases. 2-3 mois pour être autonome en production. 4-8 semaines pour la certification CKA.

Kubernetes ou Docker Swarm ?

Kubernetes a gagné la bataille de l'adoption. Docker Swarm est plus simple mais beaucoup moins utilisé en entreprise en 2026.

Puis-je utiliser Kubernetes sans le cloud ?

Oui. K3s, Minikube et kubeadm tournent sur n'importe quel serveur Linux, y compris un Raspberry Pi.

Quelle distribution Kubernetes choisir ?

Pour apprendre : k3s. En production cloud : EKS, GKE ou AKS. On-premise : kubeadm ou Rancher.

Prêt à passer à la pratique ?

Sur LabsDevOps, chaque étudiant dispose de son propre cluster k3s — pas un simulateur, un vrai cluster Kubernetes certifié CNCF. 48 labs progressifs avec tuteur IA en français. Les 5 premiers labs sont gratuits.

→ Commencer les labs Kubernetes gratuitement