DevOpsFacile
AccueilParcours de formationCertificationsModulesCheat SheetÀ Propos
DevOpsFacile

Une plateforme d'apprentissage complète pour maîtriser les pratiques DevOps modernes, du débutant à l'expert.

contact@devopsfacile.fr

Formation

  • Parcours de formation
  • Modules

Informations

  • À Propos
  • Conditions d'utilisation
  • Confidentialité
  • Mentions légales

© 2026 DevOps Facile. Tous droits réservés.

Fait avec pour la communauté DevOps

ModulesDécouvrir Kubernetes : pods, services et kubectl

Module

Découvrez l'orchestration de conteneurs : pods, services et premières commandes kubectl.

  • 1h30
  • Débutant
  • 6 exercices
Voir les exercices

Formation 100 % Linux

Tous les modules nécessitent un environnement Linux. Si vous êtes sur Windows, installez d'abord WSL (Windows Subsystem for Linux) avant de continuer.

Découvrir Kubernetes : pods, services et kubectl

🎯 Objectifs

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

  • ✅ Comprendre l'architecture d'un cluster Kubernetes
  • ✅ Installer un environnement local avec Minikube
  • ✅ Créer et gérer des Pods
  • ✅ Exposer des applications avec des Services
  • ✅ Utiliser les namespaces et les labels
  • ✅ Maîtriser les commandes kubectl essentielles

📋 Prérequis

  • Module Docker Intermédiaire complété
  • Docker installé et fonctionnel
  • Terminal Bash ou Zsh
  • Notions de base en réseau (ports, IP)

☸️ Pourquoi Kubernetes ?

Le problème

Avec Docker, vous savez lancer des conteneurs. Mais en production :

  • Comment gérer des dizaines de conteneurs sur plusieurs serveurs ?
  • Comment redémarrer automatiquement un conteneur qui plante ?
  • Comment répartir la charge entre plusieurs instances ?

La solution : Kubernetes (K8s)

Kubernetes est une plateforme d'orchestration qui automatise :

FonctionnalitéDescription
Self-healingRedémarre les conteneurs en échec
ScalingAjuste le nombre de réplicas
Rolling updatesMise à jour sans interruption
Service discoveryRéseau interne automatique
Load balancingRépartition de charge

🏗️ Architecture Kubernetes

Vue d'ensemble

┌──────────────────────────────────────────────┐
│                 CLUSTER K8S                  │
│                                              │
│  ┌────────────────┐    ┌──────────────────┐  │
│  │ Control Plane  │    │  Worker Node 1   │  │
│  │                │    │                  │  │
│  │  · API Server  ├───►│  ┌────┐  ┌────┐  │  │
│  │  · etcd        │    │  │ Pod│  │ Pod│  │  │
│  │  · Scheduler   │    │  └────┘  └────┘  │  │
│  │  · Controller  │    └──────────────────┘  │
│  │                │                          │
│  └────────────────┘    ┌──────────────────┐  │
│                        │  Worker Node 2   │  │
│                        │                  │  │
│                        │  ┌────┐  ┌────┐  │  │
│                        │  │ Pod│  │ Pod│  │  │
│                        │  └────┘  └────┘  │  │
│                        └──────────────────┘  │
└──────────────────────────────────────────────┘

Composants principaux

ComposantRôleEmplacement
API ServerPoint d'entrée de toutes les requêtesControl Plane
etcdBase de données clé-valeur (état du cluster)Control Plane
SchedulerAssigne les pods aux nœudsControl Plane
Controller ManagerMaintient l'état désiréControl Plane
kubeletAgent qui exécute les podsWorker Node
kube-proxyGère le réseau des servicesWorker Node

🔧 Installation Locale

Minikube (recommandé)

bash
# Installation sur 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
minikube start

# Vérifier le statut
minikube status

kubectl

bash
# Installation
curl -LO "https://dl.k8s.io/release/$(curl -L -s https://dl.k8s.io/release/stable.txt)/bin/linux/amd64/kubectl"
sudo install kubectl /usr/local/bin/kubectl

# Vérification
kubectl version --client

💡 Alternative : kind (Kubernetes in Docker) est plus léger. Docker Desktop inclut aussi une option Kubernetes intégrée dans les paramètres.


🚀 Premiers Pas avec kubectl

bash
# Informations du cluster
kubectl cluster-info

# Lister les nœuds
kubectl get nodes

# Version complète
kubectl version

Résultat attendu :

NAME       STATUS   ROLES           AGE   VERSION
minikube   Ready    control-plane   2m    v1.30.0

📦 Pods

Concept

Un Pod est la plus petite unité déployable dans Kubernetes. Il contient un ou plusieurs conteneurs qui partagent le même réseau et stockage.

Créer un Pod avec YAML

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

Commandes essentielles

bash
# Créer le pod
kubectl apply -f nginx-pod.yaml

# Lister les pods
kubectl get pods

# Détails complets
kubectl describe pod nginx-pod

# Voir les logs
kubectl logs nginx-pod

# Ouvrir un shell dans le pod
kubectl exec -it nginx-pod -- /bin/bash

# Supprimer le pod
kubectl delete pod nginx-pod

Cycle de vie d'un Pod

Pending → Running → Succeeded / Failed
   │                      │
   └── ContainerCreating  └── CrashLoopBackOff

⚠️ Attention : un Pod seul n'est jamais redémarré automatiquement. Utilisez un Deployment pour la haute disponibilité (module avancé).


🌐 Services

Pourquoi ?

Les Pods ont des adresses IP éphémères qui changent à chaque redémarrage. Un Service fournit un point d'accès stable.

Types de Services

TypeAccèsCas d'usage
ClusterIPInterne au cluster uniquementCommunication entre services
NodePortDepuis l'extérieur via un port du nœudDéveloppement, tests
LoadBalancerVia un load balancer externeProduction (cloud)

Exemple : NodePort

yaml
# nginx-service.yaml
apiVersion: v1
kind: Service
metadata:
  name: nginx-service
spec:
  type: NodePort
  selector:
    app: nginx
  ports:
    - port: 80
      targetPort: 80
      nodePort: 30080
bash
# Créer le service
kubectl apply -f nginx-service.yaml

# Lister les services
kubectl get svc

# Détails du service
kubectl describe svc nginx-service

# Accéder avec Minikube
minikube service nginx-service --url

💡 Le selector app: nginx lie le service aux pods ayant le label correspondant.


📁 Namespaces

Les namespaces sont des clusters virtuels au sein d'un même cluster physique.

Namespaces par défaut

NamespaceRôle
defaultEspace par défaut pour vos ressources
kube-systemComposants internes de Kubernetes
kube-publicRessources accessibles publiquement
bash
# Lister les namespaces
kubectl get ns

# Créer un namespace
kubectl create ns mon-projet

# Lister les pods d'un namespace
kubectl get pods -n mon-projet

# Créer une ressource dans un namespace
kubectl apply -f nginx-pod.yaml -n mon-projet

🏷️ Labels et Selectors

Les labels sont des paires clé-valeur pour organiser vos ressources.

yaml
metadata:
  labels:
    app: nginx
    env: production
    team: backend
bash
# Filtrer par label
kubectl get pods -l app=nginx

# Filtrer avec plusieurs labels
kubectl get pods -l app=nginx,env=production

# Ajouter un label à un pod existant
kubectl label pod nginx-pod version=1.0

💡 Les selectors dans les Services utilisent matchLabels pour cibler les bons Pods.


📋 Commandes Essentielles

CommandeDescription
kubectl get <ressource>Lister les ressources
kubectl describe <ressource> <nom>Détails d'une ressource
kubectl apply -f <fichier>Créer/mettre à jour une ressource
kubectl delete <ressource> <nom>Supprimer une ressource
kubectl logs <pod>Voir les logs
kubectl exec -it <pod> -- <cmd>Exécuter une commande dans un pod
kubectl get allVoir toutes les ressources
kubectl get pods -o wideAfficher plus de détails (IP, nœud)

❌ Erreurs Courantes

ErreurCauseSolution
ImagePullBackOffImage introuvableVérifier le nom et le tag de l'image
CrashLoopBackOffLe conteneur plante en boucleConsulter kubectl logs
PendingPas de nœud disponibleVérifier les ressources du cluster
ErrImagePullErreur d'authentification au registryConfigurer un imagePullSecret
Connection refusedService mal configuréVérifier les selectors et les ports

🎯 Points Clés

  • Un cluster = Control Plane + Worker Nodes
  • Un Pod = plus petite unité déployable (un ou plusieurs conteneurs)
  • Un Service = point d'accès réseau stable vers des Pods
  • Les namespaces isolent les ressources
  • Les labels organisent et ciblent les ressources
  • kubectl est l'outil principal d'interaction avec le cluster

📚 Ressources

  • Documentation officielle Kubernetes
  • kubectl Cheat Sheet
  • Minikube - Getting Started
  • Kubernetes The Hard Way

🚀 Prochaines étapes

Vous gérez vos premiers Pods et Services. Montez en compétence :

  1. Kubernetes en production : Deployments, Ingress et Secrets - Deployments, ConfigMaps, Secrets et Ingress

Exercices Pratiques

6 exercices pour mettre en pratique

01

01 - Maîtriser les commandes kubectl essentielles

15 minutesDébutant
02

02 - Créer et gérer des Pods

25 minutesDébutant
03

03 - Exposer des applications avec les Services

30 minutesDébutant
04

04 - Organiser avec les Namespaces et les Labels

15 minutesDébutant
05

05 - Gérer les Deployments

20 minutesDébutant
06

06 - Projet Capstone : Déployer une application web sur Kubernetes avec Minikube

45 minutesIntermédiaire
Retour aux modules

Sur cette page

  • 🎯 Objectifs
  • 📋 Prérequis
  • ☸️ Pourquoi Kubernetes ?
  • Le problème
  • La solution : Kubernetes (K8s)
  • 🏗️ Architecture Kubernetes
  • Vue d'ensemble
  • Composants principaux
  • 🔧 Installation Locale
  • Minikube (recommandé)
  • kubectl
  • 🚀 Premiers Pas avec kubectl
  • 📦 Pods
  • Concept
  • Créer un Pod avec YAML
  • Commandes essentielles
  • Cycle de vie d'un Pod
  • 🌐 Services
  • Pourquoi ?
  • Types de Services
  • Exemple : NodePort
  • 📁 Namespaces
  • Namespaces par défaut
  • 🏷️ Labels et Selectors
  • 📋 Commandes Essentielles
  • ❌ Erreurs Courantes
  • 🎯 Points Clés
  • 📚 Ressources
  • 🚀 Prochaines étapes