Les concepts clés de Kubernetes pour bien démarrer

Kubernetes ne lance pas simplement des conteneurs : il orchestre des applications sur un ensemble de machines. Vous ne démarrez pas un conteneur directement sur un serveur. Vous déclarez un état souhaité au cluster, et Kubernetes se charge d’y parvenir. Pour comprendre ce fonctionnement sans vous perdre, vous devez maîtriser six notions fondamentales : le Cluster, les Nodes, les Namespaces, les Pods, les Deployments et les Services.

Ce que vous allez apprendre

Cluster et Nodes : l’infrastructure sur laquelle tout repose
Namespace : comment organiser et isoler vos ressources
Pod : l’unité de base qui exécute vos conteneurs
Deployment : le contrôleur qui maintient vos applications en vie
Service : le point d’accès réseau stable vers vos pods
Comment tout s’articule : le modèle mental complet

Pourquoi ces concepts sont essentiels

Sans maîtriser ce vocabulaire, vous ne comprendrez ni la documentation officielle, ni les tutoriels. Chaque guide Kubernetes utilise ces termes en permanence. En les apprenant maintenant, vous gagnez du temps sur tous les guides suivants.

Vue d’ensemble : nature de chaque concept

Avant de détailler chaque notion, voici comment les situer :

Concept	Nature	Rôle
Cluster	Ensemble	Regroupe toutes les ressources
Node	Machine	Exécute les workloads
Namespace	Organisation logique	Isole et range les objets
Pod	Unité d’exécution	Fait tourner les conteneurs
Deployment	Contrôleur	Maintient et met à jour les pods
Service	Abstraction réseau	Fournit un accès stable

Le Cluster : votre infrastructure Kubernetes

Un cluster est un ensemble de machines qui travaillent ensemble pour exécuter vos applications. Il se compose de deux types de machines :

Type	Rôle
Control plane	Cerveau du cluster : décide où placer les pods, surveille l’état
Worker nodes	Muscles du cluster : exécutent réellement les conteneurs

Vous interagissez avec le cluster via kubectl, l’outil en ligne de commande.

kubectl cluster-info

Kubernetes control plane is running at https://0.0.0.0:46029
CoreDNS is running at https://0.0.0.0:46029/api/v1/namespaces/kube-system/services/kube-dns:dns/proxy

Cette commande confirme que votre machine peut communiquer avec le control plane.

Les Nodes : les serveurs de votre cluster

Un node est une machine (physique ou virtuelle) qui fait partie du cluster. Chaque node peut exécuter plusieurs pods.

kubectl get nodes

NAME                   STATUS   ROLES                  AGE   VERSION
k3d-doc-k8s-server-0   Ready    control-plane,master   17h   v1.31.5+k3s1
k3d-doc-k8s-agent-0    Ready    <none>                 17h   v1.31.5+k3s1

Dans cet exemple :

k3d-doc-k8s-server-0 est le control plane (rôle control-plane,master)
k3d-doc-k8s-agent-0 est un worker node (pas de rôle spécifique affiché)

Les Namespaces : organiser le cluster

Un namespace est un espace de noms qui isole logiquement les ressources. Avant de créer des pods, il faut savoir où les ranger.

kubectl get namespaces

NAME              STATUS   AGE
default           Active   17h
kube-node-lease   Active   17h
kube-public       Active   17h
kube-system       Active   17h

Namespace	Usage
`default`	Vos applications si vous ne spécifiez rien
`kube-system`	Composants internes de Kubernetes
`kube-public`	Ressources lisibles par tous
`kube-node-lease`	Gestion interne des heartbeats des nodes

Les Pods : l’unité de base

Un Pod est l’unité minimale que Kubernetes déploie. Dans la majorité des cas, il contient un seul conteneur applicatif. Plusieurs conteneurs dans un même Pod partagent le même réseau (même IP) et peuvent partager des volumes.

kubectl get pods -A

NAMESPACE     NAME                                      READY   STATUS    RESTARTS   AGE
kube-system   coredns-ccb96694c-l7wp8                   1/1     Running   0          17h
kube-system   metrics-server-5985cbc9d7-wslf9           1/1     Running   0          17h
kube-system   traefik-5d45fc8cc9-9vsfc                  1/1     Running   0          17h

Chaque ligne est un pod. La colonne READY indique le nombre de conteneurs prêts sur le total (1/1 = 1 conteneur prêt sur 1).

Le Deployment : le contrôleur qui maintient vos applications

Un Deployment est le contrôleur le plus courant pour faire tourner une application. Il ne se contente pas de “créer des pods” : il maintient le bon nombre de répliques, remplace ceux qui tombent et pilote les mises à jour progressives.

Ce que vous déclarez	Ce que le Deployment fait
`replicas: 3`	Crée et maintient 3 pods
Image `nginx:1.25`	S’assure que tous les pods utilisent cette image
Un pod plante	En relance un automatiquement
Nouvelle version d’image	Rolling update sans coupure de service

kubectl get deployments -A

NAMESPACE     NAME                     READY   UP-TO-DATE   AVAILABLE   AGE
kube-system   coredns                  1/1     1            1           17h
kube-system   metrics-server           1/1     1            1           17h
kube-system   traefik                  1/1     1            1           17h

La colonne READY montre pods-prêts/pods-désirés. Un deployment avec 1/1 signifie : 1 réplique demandée, 1 réplique en service.

Le Service : l’accès réseau stable

Un Service fournit un point d’accès stable à un groupe de pods. Comme les pods sont éphémères (ils peuvent être recréés avec une nouvelle IP), on ne les contacte pas directement : on passe par le Service, qui garde une adresse stable et répartit le trafic.

Problème	Solution du Service
Les pods changent d’IP quand ils redémarrent	Le Service garde une IP fixe
Plusieurs pods font le même travail	Le Service répartit le trafic (load balancing)
Besoin d’un nom DNS pour l’application	Le Service expose un nom stable

kubectl get services -A

NAMESPACE     NAME             TYPE           CLUSTER-IP      EXTERNAL-IP   PORT(S)                      AGE
default       kubernetes       ClusterIP      10.43.0.1       <none>        443/TCP                      17h
kube-system   kube-dns         ClusterIP      10.43.0.10      <none>        53/UDP,53/TCP,9153/TCP       17h
kube-system   traefik          LoadBalancer   10.43.91.86     172.22.0.2    80:30619/TCP,443:30490/TCP   17h

Types de services les plus courants :

ClusterIP (défaut) : accessible uniquement depuis l’intérieur du cluster
LoadBalancer : accessible depuis l’extérieur via une IP publique

Comment tout s’articule

Voici comment ces objets travaillent ensemble dans un scénario typique :

Cluster
├── Control plane
│   └── Décide et observe l'état du cluster
│
└── Worker nodes
    └── Namespace: demo
        │
        ├── Deployment: web (replicas: 3)
        │   ├── Pod: web-abc12
        │   ├── Pod: web-def34
        │   └── Pod: web-ghi56
        │
        └── Service: web (ClusterIP)
            └── Route le trafic vers les 3 pods

Je crée un namespace demo pour ranger mes ressources
Je déclare un Deployment web avec 3 répliques
Le Deployment crée 3 Pods qui tournent sur les worker nodes
Je crée un Service web qui cible ces pods
Les autres applications appellent le Service, pas les pods directement

Ce modèle déclaratif est la clé de Kubernetes : vous décrivez l’état souhaité, le cluster s’assure de l’atteindre.

Ce que vous n’avez pas besoin de comprendre tout de suite

Vous croiserez ces composants plus tard dans votre parcours. Pour bien démarrer, concentrez-vous d’abord sur les objets que vous manipulez directement :

Composant	Quand l’apprendre
etcd	Administration avancée
Scheduler	Administration avancée
kube-proxy	Réseau avancé
CNI (Calico, Cilium…)	Réseau avancé
Admission controllers	Sécurité avancée

À retenir

Concept	Définition en une phrase
Cluster	Ensemble de machines qui exécutent Kubernetes
Node	Une machine du cluster
Namespace	Isolation logique pour ranger les ressources
Pod	Unité minimale qui exécute un ou plusieurs conteneurs
Deployment	Contrôleur qui maintient et met à jour les pods
Service	Point d’accès réseau stable vers un groupe de pods

Les 4 idées fondamentales à retenir :

Je ne déploie pas mon application directement sur un node — je la déclare au cluster
Je déploie des pods, généralement via un Deployment
Je passe par un Service pour joindre mes pods
Le cluster répartit tout cela sur les machines disponibles

Les commandes essentielles :

kubectl cluster-info            # Vérifier la connexion
kubectl get nodes               # Lister les machines
kubectl get namespaces          # Lister les espaces de noms
kubectl get pods -A             # Lister tous les pods
kubectl get deployments -A      # Lister tous les deployments
kubectl get services -A         # Lister tous les services

Prochaines étapes

Vous avez maintenant le vocabulaire minimum pour comprendre les guides suivants. La prochaine étape : créer un cluster local, puis déployer votre première application avec un Deployment et un Service.

Créer votre premier cluster Installez un cluster local avec Kind ou k3d en 5 minutes

Votre premier déploiement Déployez une application et exposez-la sur le réseau

Les Pods en détail Anatomie, cycle de vie et manipulation des pods