Kubernetes : apprendre, administrer, sécuriser et préparer les certifications

Kubernetes (K8s) orchestre vos conteneurs en production : déploiements automatiques, scaling, récupération de pannes. Ce parcours couvre l’apprentissage, l’administration, la sécurité et les certifications (CKA, CKAD, CKS) en 50+ guides pratiques.

Au terme de ce parcours, vous serez capable de :

Déployer une application de bout en bout (Pod → Deployment → Service → Ingress)
Administrer un cluster (architecture, installation, monitoring, troubleshooting)
Sécuriser vos workloads (RBAC, Network Policies, hardening CKS)
Certifier vos compétences (CKA, CKAD, CKS)

Débuter avec Kubernetes Cluster local, premiers Pods, concepts fondamentaux

Administrer un cluster Architecture, installation, monitoring, troubleshooting

Sécuriser Kubernetes RBAC, Network Policies, Secrets, hardening CKS

Certifications CKA/CKAD/CKS Guides de préparation, TP pratiques, conseils d'examen

Prérequis : Linux, Docker, YAML — voir la section dédiée.

Roadmap Kubernetes complète

Cliquez sur un nœud pour voir ses détails

🎨 Légende

Recommandé

Alternatif

Optionnel

Mon choix

🖱️ Interactions

Voir détails Clic sur nœud

Déplier / Replier Clic sur + ou −

Ouvrir la doc Clic sur ↗

Déplacer la vue Glisser-déposer

Zoomer Molette souris

Pourquoi suivre une formation Kubernetes ?

Avec Docker, vous savez créer des conteneurs. Mais en production, il faut gérer des dizaines de conteneurs sur plusieurs machines — impossible à la main. Kubernetes automatise tout ça : il déploie, scale, répare et met à jour vos applications sans intervention.

Ce que vous faites à la main	Ce que Kubernetes fait pour vous
Démarrer chaque conteneur	Déclarer “3 répliques” → K8s les crée
Redémarrer après une panne	Self-healing automatique
Ajouter des serveurs si trafic	Autoscaling selon la charge
Mettre à jour sans coupure	Rolling updates + rollback

Le concept clé : vous décrivez l’état souhaité dans un fichier YAML, Kubernetes le réalise et le maintient — même en cas de panne.

Prérequis : ce que vous devez maîtriser avant de commencer

Kubernetes s’appuie sur plusieurs technologies. Pas besoin d’être expert, mais vous devez être à l’aise avec les bases :

Linux (indispensable) Terminal, permissions, systemd — vous travaillerez en ligne de commande

Docker (indispensable) Conteneurs, images, Dockerfile — Kubernetes orchestre des conteneurs Docker

YAML (indispensable) Syntaxe, indentation, listes — tous les manifests Kubernetes sont en YAML

Réseaux TCP/IP (recommandé) Ports, DNS, routage — pour comprendre Services et Network Policies

Git (recommandé) Versionner vos manifests, collaborer, GitOps — essentiel en production

Conseil : si vous débutez complètement, commencez par Linux puis Docker. Comptez 2-4 semaines pour ces bases avant d’attaquer Kubernetes.

Comment est structuré cette formation Kubernetes ?

Cette formation est conçue pour vous accompagner de zéro à l’autonomie complète sur Kubernetes. Chaque guide combine théorie et pratique pour ancrer les concepts durablement :

Guides détaillés : explications progressives, du “pourquoi” au “comment”, avec exemples concrets
Schémas visuels : architecture, flux de données, cycles de vie — pour comprendre d’un coup d’œil
Commandes commentées : chaque commande expliquée, avec le résultat attendu
TP sur GitHub : exercices pratiques à faire sur votre cluster local
Quizz interactifs : validez vos acquis à la fin de chaque niveau
FAQ : réponses aux questions que tout le monde se pose

Exemples

Architecture d'un cluster Kubernetes avec Control Plane et Worker Nodes

Un cluster Kubernetes orchestre vos conteneurs sur deux types de nœuds : le Control Plane (cerveau décisionnel avec API Server, etcd, Scheduler) et les Worker Nodes (où s’exécutent vos conteneurs via Kubelet et containerd).

Extrait du TP “Création de Pods” — Voir le TP complet sur GitHub

# 1️⃣ Créer un Pod avec kubectl run
kubectl run mon-pod --image=nginx

# 2️⃣ Vérifier son état
kubectl get pods
# Le Pod doit être "Running"

# 3️⃣ Afficher les détails
kubectl describe pod mon-pod

# 4️⃣ Supprimer le Pod
kubectl delete pod mon-pod

Étape suivante : déployer avec un fichier YAML (meilleure pratique) :

apiVersion: v1
kind: Pod
metadata:
  name: mon-pod
spec:
  containers:
    - name: nginx
      image: nginx
      ports:
        - containerPort: 80

kubectl apply -f pod-nginx.yaml
kubectl logs mon-pod

🎯 Challenge : Ajoutez un deuxième conteneur (Alpine) dans le même Pod et testez s’ils peuvent communiquer.

Par où commencer ? Les guides Kubernetes essentiels

Ces guides couvrent 80% des cas d’usage — commencez par là avant d’explorer les sujets avancés.

Flux de déploiement Kubernetes : kubectl vers API Server, etcd, Scheduler, Kubelet et containerd

De kubectl apply à l’exécution : votre manifest YAML traverse l’API Server, est stocké dans etcd, puis le Scheduler assigne un nœud et le Kubelet lance le conteneur.

Pods L'unité de base — encapsuler vos conteneurs

Deployments Rolling updates, rollbacks, répliques

StatefulSets Applications stateful (bases de données)

Jobs & CronJobs Tâches ponctuelles et planifiées

Choisissez votre parcours

Selon votre profil, suivez le parcours adapté pour monter en compétence progressivement.

Ce parcours est conçu pour ceux qui découvrent Kubernetes. Aucune connaissance préalable de K8s n’est requise — seulement Linux, Docker et YAML.

Niveau 0 — Prérequis 2-4 semaines
- Linux — terminal, permissions, systemd
- Docker — images, conteneurs, Dockerfile
- YAML — syntaxe, indentation, listes
Niveau 1 — Concepts et premier cluster 1-2 semaines
- Concepts clés — Cluster, Node, Pod, Deployment, Service
- Premier cluster — créer un cluster local avec k3d ou Kind
- Architecture Kubernetes — Control Plane, Worker Nodes
Niveau 2 — Premier déploiement 1-2 semaines
- Premier déploiement — namespace, Deployment, Service, port-forward
- Écrire des manifests YAML — syntaxe et bonnes pratiques
- Ressources de base — vue d’ensemble des objets K8s
Niveau 3 — Validation 1 jour
- Contrôle de connaissances — quiz interactif (15 questions)
- Si score > 80% : passez au parcours Développeur → CKAD ou Administrateur → CKA

Travaux pratiques

Kubernetes s’apprend en faisant. Ces TP GitHub vous permettent de manipuler chaque concept sur un cluster réel.

Accéder aux TP Kubernetes sur GitHub

Les exercices couvrent :

Création et gestion de Pods et Deployments
Configuration avec ConfigMaps et Secrets
Exposition via Services et Ingress
Autoscaling avec HPA
Déploiement avec Helm

Préparer les certifications Kubernetes

La CNCF propose trois certifications 100% pratiques — pas de QCM, uniquement des problèmes réels à résoudre sur un cluster.

Certification	Pour qui	Durée
CKA	Admins, SRE	2h
CKAD	Développeurs	2h
CKS	Sécurité (CKA requis)	2h

Guide complet des certifications Domaines d'examen, conseils, ressources

Examen interactif Testez vos connaissances

On attaque la formation ?

Vous avez compris ce qu’est Kubernetes et pourquoi il est devenu incontournable. Maintenant, passez à la pratique ! Choisissez votre première étape selon votre profil :

Vous découvrez Kubernetes ? Installez un cluster local et manipulez les concepts de base avant d’aller plus loin.

Formation Docker Prérequis : maîtriser les conteneurs

Installer Minikube Cluster local pour vos premiers tests

Installer Kind Kubernetes dans Docker — léger et rapide

Architecture Kubernetes Comprendre les composants

Ressources de base Vue d'ensemble des objets Kubernetes

Guide des Pods L'unité de base de Kubernetes

Écrire des manifests Syntaxe YAML, bonnes pratiques

TP Pratiques Exercices guidés sur GitHub

Examen interactif Validez vos acquis

Vous vous posez encore des questions ?

Je vais vous aider à y répondre dans la FAQ ci-dessous !

Quels sont les prérequis pour apprendre Kubernetes ?

Avant de vous lancer dans Kubernetes, vous devez maîtriser **trois fondamentaux** indispensables. Sans eux, vous risquez de vous perdre dans la complexité de l'orchestration. ### Prérequis essentiels | Compétence | Niveau requis | Concepts clés | Temps d'acquisition | |------------|---------------|---------------|---------------------| | **Linux** | Intermédiaire | Terminal, permissions, processus, systemd | 2-4 semaines | | **Docker** | Intermédiaire | Images, conteneurs, volumes, Dockerfile | 2-3 semaines | | **YAML** | Débutant | Syntaxe, indentation, listes, dictionnaires | 2-3 jours | | **Réseau** | Bases | TCP/IP, DNS, ports, load balancing | 1-2 semaines | ### Commandes Linux à connaître ```bash # Gestion fichiers ls -la cd /var/log cat fichier.txt grep "error" /var/log/syslog # Gestion processus ps aux top kill -9 <PID> # Réseau curl http://localhost:8080 netstat -tuln ping google.com ``` ### Compétences Docker requises ```bash # Lancer un conteneur docker run -d -p 80:80 nginx # Construire une image docker build -t mon-app:v1 . # Inspecter docker ps docker logs <container> docker exec -it <container> /bin/sh ``` ### Syntaxe YAML pour Kubernetes ```yaml # Structure de base d'un manifest apiVersion: v1 kind: Pod metadata: name: mon-pod labels: app: nginx spec: containers: - name: nginx image: nginx:1.25 ports: - containerPort: 80 ``` ### Checklist avant de commencer - [ ] Savoir naviguer dans un terminal Linux - [ ] Comprendre les permissions (chmod, chown) - [ ] Lancer et gérer des conteneurs Docker - [ ] Écrire un Dockerfile simple - [ ] Comprendre la syntaxe YAML (indentation !) - [ ] Connaître les bases réseau (IP, ports, DNS)

Avant de vous lancer dans Kubernetes, vous devez maîtriser trois fondamentaux indispensables. Sans eux, vous risquez de vous perdre dans la complexité de l'orchestration.

Prérequis essentiels

Compétence	Niveau requis	Concepts clés	Temps d'acquisition
Linux	Intermédiaire	Terminal, permissions, processus, systemd	2-4 semaines
Docker	Intermédiaire	Images, conteneurs, volumes, Dockerfile	2-3 semaines
YAML	Débutant	Syntaxe, indentation, listes, dictionnaires	2-3 jours
Réseau	Bases	TCP/IP, DNS, ports, load balancing	1-2 semaines

Commandes Linux à connaître

# Gestion fichiers
ls -la
cd /var/log
cat fichier.txt
grep "error" /var/log/syslog

# Gestion processus
ps aux
top
kill -9 <PID>

# Réseau
curl http://localhost:8080
netstat -tuln
ping google.com

Compétences Docker requises

# Lancer un conteneur
docker run -d -p 80:80 nginx

# Construire une image
docker build -t mon-app:v1 .

# Inspecter
docker ps
docker logs <container>
docker exec -it <container> /bin/sh

Syntaxe YAML pour Kubernetes

# Structure de base d'un manifest
apiVersion: v1
kind: Pod
metadata:
  name: mon-pod
  labels:
    app: nginx
spec:
  containers:
    - name: nginx
      image: nginx:1.25
      ports:
        - containerPort: 80

Checklist avant de commencer

Savoir naviguer dans un terminal Linux
Comprendre les permissions (chmod, chown)
Lancer et gérer des conteneurs Docker
Écrire un Dockerfile simple
Comprendre la syntaxe YAML (indentation !)
Connaître les bases réseau (IP, ports, DNS)

Combien de temps faut-il pour maîtriser Kubernetes ?

Le temps d'apprentissage dépend de votre niveau de départ et de vos objectifs. Voici un **parcours réaliste** basé sur une pratique régulière. ### Roadmap d'apprentissage | Phase | Durée | Compétences acquises | Objectif | |-------|-------|---------------------|----------| | **Niveau 1 - Bases** | 2-4 semaines | Pods, Services, Deployments | Déployer une app simple | | **Niveau 2 - Configuration** | 4-6 semaines | ConfigMaps, Secrets, Probes, Volumes | App production-ready | | **Niveau 3 - Production** | 4-6 semaines | RBAC, Network Policies, HPA, Helm | Cluster sécurisé | | **Niveau 4 - Expert** | 2-3 mois | Opérateurs, CRD, troubleshooting avancé | Architecture K8s | ### Estimation totale - **Bases opérationnelles** : 1-2 mois - **Prêt pour la production** : 3-4 mois - **Certification CKA/CKAD** : 4-6 mois - **Expert/Architecte** : 12+ mois ### Planning hebdomadaire recommandé ``` Lundi-Vendredi : 30-60 min/jour (théorie + pratique) Week-end : 2-3h (projet pratique, TP) Exemple semaine 1 : - Lun : Architecture K8s (vidéo + lecture) - Mar : Installation Minikube (pratique) - Mer : Premier Pod (hands-on) - Jeu : Deployments (théorie + pratique) - Ven : Services (ClusterIP, NodePort) - Sam : TP complet - déployer une app ``` ### Facteurs d'accélération | Facteur | Impact | Conseil | |---------|--------|--------| | **Pratique quotidienne** | ★★★ | 30 min/jour > 4h/week-end | | **Projets réels** | ★★★ | Déployer votre propre app | | **Cluster local** | ★★ | Minikube/Kind toujours disponible | | **Communauté** | ★★ | Slack CNCF, forums, meetups | | **TP guidés** | ★★ | Suivre des exercices structurés | ### Erreurs qui ralentissent - ❌ Lire sans pratiquer - ❌ Sauter les prérequis (Docker, Linux) - ❌ Vouloir tout apprendre d'un coup - ❌ Ne pas comprendre les erreurs (copier/coller) - ❌ Ignorer les logs et événements

Le temps d'apprentissage dépend de votre niveau de départ et de vos objectifs. Voici un parcours réaliste basé sur une pratique régulière.

Roadmap d'apprentissage

Phase	Durée	Compétences acquises	Objectif
Niveau 1 - Bases	2-4 semaines	Pods, Services, Deployments	Déployer une app simple
Niveau 2 - Configuration	4-6 semaines	ConfigMaps, Secrets, Probes, Volumes	App production-ready
Niveau 3 - Production	4-6 semaines	RBAC, Network Policies, HPA, Helm	Cluster sécurisé
Niveau 4 - Expert	2-3 mois	Opérateurs, CRD, troubleshooting avancé	Architecture K8s

Estimation totale

Bases opérationnelles : 1-2 mois
Prêt pour la production : 3-4 mois
Certification CKA/CKAD : 4-6 mois
Expert/Architecte : 12+ mois

Planning hebdomadaire recommandé

Lundi-Vendredi : 30-60 min/jour (théorie + pratique)
Week-end : 2-3h (projet pratique, TP)

Exemple semaine 1 :
- Lun : Architecture K8s (vidéo + lecture)
- Mar : Installation Minikube (pratique)
- Mer : Premier Pod (hands-on)
- Jeu : Deployments (théorie + pratique)
- Ven : Services (ClusterIP, NodePort)
- Sam : TP complet - déployer une app

Facteurs d'accélération

Facteur	Impact	Conseil
Pratique quotidienne	★★★	30 min/jour > 4h/week-end
Projets réels	★★★	Déployer votre propre app
Cluster local	★★	Minikube/Kind toujours disponible
Communauté	★★	Slack CNCF, forums, meetups
TP guidés	★★	Suivre des exercices structurés

Erreurs qui ralentissent

❌ Lire sans pratiquer
❌ Sauter les prérequis (Docker, Linux)
❌ Vouloir tout apprendre d'un coup
❌ Ne pas comprendre les erreurs (copier/coller)
❌ Ignorer les logs et événements

CKA ou CKAD : quelle certification Kubernetes choisir ?

Les deux certifications sont **100% pratiques** (2h sur un vrai cluster). Le choix dépend de votre **profil métier** et de vos objectifs. ### Comparatif CKA vs CKAD | Critère | CKA | CKAD | |---------|-----|------| | **Public cible** | Admins, SRE, DevOps | Développeurs | | **Focus** | Cluster (installation, sécurité, troubleshooting) | Applications (déploiement, configuration) | | **Durée** | 2 heures | 2 heures | | **Questions** | 15-20 | 15-20 | | **Score requis** | 66% | 66% | | **Prérequis** | 6-12 mois pratique K8s | 3-6 mois pratique K8s | | **Difficulté** | ★★★ | ★★☆ | | **Validité** | 3 ans | 3 ans | | **Prix** | $395 | $395 | ### Domaines CKA (Administrateur) ``` Cluster Architecture (25%) ├── Installation avec kubeadm ├── Upgrade cluster └── Backup/restore etcd Workloads & Scheduling (15%) ├── Deployments, scaling ├── ConfigMaps, Secrets └── Node affinity, taints Services & Networking (20%) ├── Services (ClusterIP, NodePort, LB) ├── Ingress controllers └── Network Policies Storage (10%) ├── PV, PVC ├── StorageClass └── Volume modes Troubleshooting (30%) ├── Logs, events ├── Cluster components └── Application debugging ``` ### Domaines CKAD (Développeur) ``` Application Design & Build (20%) ├── Dockerfile, multi-container Pods ├── Init containers └── Volumes Application Deployment (20%) ├── Deployments, rolling updates ├── Helm basics └── Blue/green, canary Application Observability (15%) ├── Probes (liveness, readiness) ├── Logs, debugging └── Monitoring basics Application Environment (25%) ├── ConfigMaps, Secrets ├── ServiceAccounts └── Resources (requests, limits) Services & Networking (20%) ├── Services ├── Ingress └── Network Policies ``` ### Quel choix selon votre profil ? | Votre profil | Certification recommandée | |--------------|---------------------------| | Développeur backend/frontend | **CKAD** puis CKA | | Admin système / SRE | **CKA** puis CKAD | | DevOps Engineer | **CKA** puis CKAD | | Architecte Cloud | **CKA** + CKAD | | Reconversion | **CKAD** (plus accessible) | ### Conseil stratégique Si vous hésitez, commencez par la **CKAD** : - Courbe d'apprentissage plus douce - Compétences directement applicables - Prépare le terrain pour la CKA

Les deux certifications sont 100% pratiques (2h sur un vrai cluster). Le choix dépend de votre profil métier et de vos objectifs.

Comparatif CKA vs CKAD

Critère	CKA	CKAD
Public cible	Admins, SRE, DevOps	Développeurs
Focus	Cluster (installation, sécurité, troubleshooting)	Applications (déploiement, configuration)
Durée	2 heures	2 heures
Questions	15-20	15-20
Score requis	66%	66%
Prérequis	6-12 mois pratique K8s	3-6 mois pratique K8s
Difficulté	★★★	★★☆
Validité	3 ans	3 ans
Prix	$395	$395

Domaines CKA (Administrateur)

Cluster Architecture (25%)
├── Installation avec kubeadm
├── Upgrade cluster
└── Backup/restore etcd

Workloads & Scheduling (15%)
├── Deployments, scaling
├── ConfigMaps, Secrets
└── Node affinity, taints

Services & Networking (20%)
├── Services (ClusterIP, NodePort, LB)
├── Ingress controllers
└── Network Policies

Storage (10%)
├── PV, PVC
├── StorageClass
└── Volume modes

Troubleshooting (30%)
├── Logs, events
├── Cluster components
└── Application debugging

Domaines CKAD (Développeur)

Application Design & Build (20%)
├── Dockerfile, multi-container Pods
├── Init containers
└── Volumes

Application Deployment (20%)
├── Deployments, rolling updates
├── Helm basics
└── Blue/green, canary

Application Observability (15%)
├── Probes (liveness, readiness)
├── Logs, debugging
└── Monitoring basics

Application Environment (25%)
├── ConfigMaps, Secrets
├── ServiceAccounts
└── Resources (requests, limits)

Services & Networking (20%)
├── Services
├── Ingress
└── Network Policies

Quel choix selon votre profil ?

Votre profil	Certification recommandée
Développeur backend/frontend	CKAD puis CKA
Admin système / SRE	CKA puis CKAD
DevOps Engineer	CKA puis CKAD
Architecte Cloud	CKA + CKAD
Reconversion	CKAD (plus accessible)

Conseil stratégique

Si vous hésitez, commencez par la CKAD :

Courbe d'apprentissage plus douce
Compétences directement applicables
Prépare le terrain pour la CKA

Peut-on apprendre Kubernetes sans viser de certification ?

**Absolument.** La certification valide vos compétences, mais la vraie valeur est dans ce que vous **savez faire concrètement**. Beaucoup de professionnels utilisent K8s quotidiennement sans certification. ### Certification vs Compétences réelles | Aspect | Sans certification | Avec certification | |--------|-------------------|--------------------| | **Compétences** | Identiques si pratique régulière | Validées officiellement | | **Employabilité** | Démo portfolio + expérience | Badge reconnu + filtre ATS | | **Salaire** | Négociation sur expérience | +10-15% en moyenne | | **Coût** | 0€ | $395 + temps préparation | | **Stress** | Apprentissage libre | Examen chronométré | ### Quand la certification est utile ✅ **Recommandée si** : - Recherche d'emploi (filtre automatique des CV) - Changement de carrière (preuve de compétence) - Entreprise qui valorise les certifications - Besoin de structurer son apprentissage - Client exige des certifications (consulting) ❌ **Pas nécessaire si** : - Poste actuel utilise déjà K8s - Portfolio de projets démontrable - Petite structure / startup - Budget limité ### Alternative : construire un portfolio ```bash # Projets qui démontrent vos compétences : 1. Déployer une app multi-tier └── Frontend + Backend + Base de données └── Ingress avec TLS └── ConfigMaps, Secrets 2. Pipeline CI/CD complet └── Build Docker └── Push registry └── Deploy sur K8s └── Tests automatisés 3. Monitoring stack └── Prometheus + Grafana └── Alerting └── Dashboards custom 4. GitOps avec ArgoCD └── Repo Git = source de vérité └── Sync automatique └── Rollback facile ``` ### Parcours sans certification | Étape | Durée | Livrable | |-------|-------|----------| | Bases K8s | 1 mois | App déployée sur Minikube | | Production-ready | 1 mois | App avec Probes, ConfigMaps, Secrets | | CI/CD | 2 semaines | Pipeline GitLab/GitHub Actions | | Monitoring | 2 semaines | Stack Prometheus/Grafana | | Projet perso | 1 mois | App complète sur repo GitHub | ### Conseil Concentrez-vous d'abord sur la **pratique**. Si vous maîtrisez K8s concrètement, la certification devient une formalité (1-2 semaines de révision suffisent).

Absolument. La certification valide vos compétences, mais la vraie valeur est dans ce que vous savez faire concrètement. Beaucoup de professionnels utilisent K8s quotidiennement sans certification.

Certification vs Compétences réelles

Aspect	Sans certification	Avec certification
Compétences	Identiques si pratique régulière	Validées officiellement
Employabilité	Démo portfolio + expérience	Badge reconnu + filtre ATS
Salaire	Négociation sur expérience	+10-15% en moyenne
Coût	0€	$395 + temps préparation
Stress	Apprentissage libre	Examen chronométré

Quand la certification est utile

✅ Recommandée si :

Recherche d'emploi (filtre automatique des CV)
Changement de carrière (preuve de compétence)
Entreprise qui valorise les certifications
Besoin de structurer son apprentissage
Client exige des certifications (consulting)

❌ Pas nécessaire si :

Poste actuel utilise déjà K8s
Portfolio de projets démontrable
Petite structure / startup
Budget limité

Alternative : construire un portfolio

# Projets qui démontrent vos compétences :

1. Déployer une app multi-tier
   └── Frontend + Backend + Base de données
   └── Ingress avec TLS
   └── ConfigMaps, Secrets

2. Pipeline CI/CD complet
   └── Build Docker
   └── Push registry
   └── Deploy sur K8s
   └── Tests automatisés

3. Monitoring stack
   └── Prometheus + Grafana
   └── Alerting
   └── Dashboards custom

4. GitOps avec ArgoCD
   └── Repo Git = source de vérité
   └── Sync automatique
   └── Rollback facile

Parcours sans certification

Étape	Durée	Livrable
Bases K8s	1 mois	App déployée sur Minikube
Production-ready	1 mois	App avec Probes, ConfigMaps, Secrets
CI/CD	2 semaines	Pipeline GitLab/GitHub Actions
Monitoring	2 semaines	Stack Prometheus/Grafana
Projet perso	1 mois	App complète sur repo GitHub

Conseil

Concentrez-vous d'abord sur la pratique. Si vous maîtrisez K8s concrètement, la certification devient une formalité (1-2 semaines de révision suffisent).

Comment pratiquer Kubernetes sans serveur cloud ?

Plusieurs solutions permettent de créer un **cluster Kubernetes local** gratuitement sur votre machine. C'est suffisant pour **90% de l'apprentissage**. ### Comparatif des solutions locales | Outil | Ressources | Installation | Cas d'usage | Recommandé pour | |-------|------------|--------------|-------------|------------------| | **Minikube** | 2 CPU, 4 GB RAM | Facile | Dev, apprentissage | Débutants ★★★ | | **Kind** | 2 CPU, 2 GB RAM | Très facile | CI/CD, tests | DevOps ★★★ | | **K3s** | 1 CPU, 512 MB RAM | Facile | Edge, IoT, léger | Production légère ★★ | | **Docker Desktop** | 4 CPU, 8 GB RAM | Intégré | Dev Mac/Windows | Développeurs ★★ | | **Rancher Desktop** | 4 CPU, 4 GB RAM | Facile | Alternative Docker Desktop | Multi-runtime ★★ | ### Installation Minikube (recommandé) ```bash # Linux curl -LO https://storage.googleapis.com/minikube/releases/latest/minikube-linux-amd64 sudo install minikube-linux-amd64 /usr/local/bin/minikube # macOS brew install minikube # Windows (PowerShell admin) winget install minikube # Démarrer le cluster minikube start --cpus=2 --memory=4096 # Vérifier kubectl get nodes minikube status # Addons utiles minikube addons enable ingress minikube addons enable metrics-server minikube addons enable dashboard # Accéder au dashboard minikube dashboard ``` ### Installation Kind (Kubernetes in Docker) ```bash # Installation curl -Lo ./kind https://kind.sigs.k8s.io/dl/v0.20.0/kind-linux-amd64 chmod +x ./kind sudo mv ./kind /usr/local/bin/kind # Créer un cluster kind create cluster --name mon-cluster # Cluster multi-nœuds cat <<EOF | kind create cluster --config=- kind: Cluster apiVersion: kind.x-k8s.io/v1alpha4 nodes: - role: control-plane - role: worker - role: worker EOF # Supprimer kind delete cluster --name mon-cluster ``` ### Premier déploiement de test ```bash # Créer un deployment kubectl create deployment nginx --image=nginx # Exposer le service kubectl expose deployment nginx --port=80 --type=NodePort # Voir le résultat kubectl get pods,svc # Accéder (Minikube) minikube service nginx # Nettoyer kubectl delete deployment nginx kubectl delete service nginx ``` ### Ressources machine recommandées | Niveau | RAM | CPU | Disque | |--------|-----|-----|--------| | Minimum | 8 GB | 2 cores | 20 GB | | Confortable | 16 GB | 4 cores | 50 GB | | Multi-clusters | 32 GB | 8 cores | 100 GB | ### Alternatives cloud gratuites Si votre machine est limitée : - **Killercoda** : Labs K8s gratuits dans le navigateur - **Play with Kubernetes** : Cluster éphémère (4h) - **Google Cloud Free Tier** : $300 crédits - **AWS Free Tier** : t2.micro (limité mais gratuit)

Plusieurs solutions permettent de créer un cluster Kubernetes local gratuitement sur votre machine. C'est suffisant pour 90% de l'apprentissage.

Comparatif des solutions locales

Outil	Ressources	Installation	Cas d'usage	Recommandé pour
Minikube	2 CPU, 4 GB RAM	Facile	Dev, apprentissage	Débutants ★★★
Kind	2 CPU, 2 GB RAM	Très facile	CI/CD, tests	DevOps ★★★
K3s	1 CPU, 512 MB RAM	Facile	Edge, IoT, léger	Production légère ★★
Docker Desktop	4 CPU, 8 GB RAM	Intégré	Dev Mac/Windows	Développeurs ★★
Rancher Desktop	4 CPU, 4 GB RAM	Facile	Alternative Docker Desktop	Multi-runtime ★★

Installation Minikube (recommandé)

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

# macOS
brew install minikube

# Windows (PowerShell admin)
winget install minikube

# Démarrer le cluster
minikube start --cpus=2 --memory=4096

# Vérifier
kubectl get nodes
minikube status

# Addons utiles
minikube addons enable ingress
minikube addons enable metrics-server
minikube addons enable dashboard

# Accéder au dashboard
minikube dashboard

Installation Kind (Kubernetes in Docker)

# Installation
curl -Lo ./kind https://kind.sigs.k8s.io/dl/v0.20.0/kind-linux-amd64
chmod +x ./kind
sudo mv ./kind /usr/local/bin/kind

# Créer un cluster
kind create cluster --name mon-cluster

# Cluster multi-nœuds
cat <<EOF | kind create cluster --config=-
kind: Cluster
apiVersion: kind.x-k8s.io/v1alpha4
nodes:
- role: control-plane
- role: worker
- role: worker
EOF

# Supprimer
kind delete cluster --name mon-cluster

Premier déploiement de test

# Créer un deployment
kubectl create deployment nginx --image=nginx

# Exposer le service
kubectl expose deployment nginx --port=80 --type=NodePort

# Voir le résultat
kubectl get pods,svc

# Accéder (Minikube)
minikube service nginx

# Nettoyer
kubectl delete deployment nginx
kubectl delete service nginx

Ressources machine recommandées

Niveau	RAM	CPU	Disque
Minimum	8 GB	2 cores	20 GB
Confortable	16 GB	4 cores	50 GB
Multi-clusters	32 GB	8 cores	100 GB

Alternatives cloud gratuites

Si votre machine est limitée :

Killercoda : Labs K8s gratuits dans le navigateur
Play with Kubernetes : Cluster éphémère (4h)
Google Cloud Free Tier : $300 crédits
AWS Free Tier : t2.micro (limité mais gratuit)

Quel parcours suivre pour devenir administrateur Kubernetes (CKA) ?

Le parcours **administrateur Kubernetes** mène à la certification **CKA** et aux postes SRE/DevOps. Il couvre l'installation, la configuration, la sécurité et le troubleshooting de clusters. ### Roadmap CKA complète | Phase | Durée | Thèmes | Validation | |-------|-------|--------|------------| | **1. Fondamentaux** | 2-4 sem | Architecture, kubectl, Pods | Quiz architecture | | **2. Workloads** | 3-4 sem | Deployments, Services, ConfigMaps | App déployée | | **3. Cluster Admin** | 4-6 sem | kubeadm, etcd, upgrades | Cluster installé | | **4. Stockage** | 2-3 sem | PV, PVC, StorageClass | Volume persistant | | **5. Réseau** | 3-4 sem | Services, Ingress, Network Policies | App exposée + sécurisée | | **6. Sécurité** | 3-4 sem | RBAC, ServiceAccounts, secrets | Cluster hardened | | **7. Troubleshooting** | 3-4 sem | Logs, events, debugging | Incidents résolus | | **8. Préparation exam** | 2-4 sem | Killer.sh, examens blancs | Score >75% | ### Phase 1 : Architecture (semaines 1-4) ```bash # Comprendre les composants kubectl get nodes kubectl get pods -n kube-system # Control Plane # - kube-apiserver : point d'entrée API # - etcd : stockage cluster # - kube-scheduler : placement Pods # - kube-controller-manager : boucles de contrôle # Worker Nodes # - kubelet : agent sur chaque nœud # - kube-proxy : règles réseau # - container runtime : containerd/CRI-O # Commandes essentielles kubectl cluster-info kubectl get componentstatuses kubectl describe node <node-name> ``` ### Phase 3 : Installation cluster (kubeadm) ```bash # Sur le control plane sudo kubeadm init --pod-network-cidr=10.244.0.0/16 # Configurer kubectl mkdir -p $HOME/.kube sudo cp /etc/kubernetes/admin.conf $HOME/.kube/config # Installer CNI (Calico) kubectl apply -f https://docs.projectcalico.org/manifests/calico.yaml # Joindre les workers kubeadm token create --print-join-command # Sur chaque worker : sudo kubeadm join <control-plane>:6443 --token ... --discovery-token-ca-cert-hash ... # Backup etcd (critique !) ETCDCTL_API=3 etcdctl snapshot save backup.db \ --endpoints=https://127.0.0.1:2379 \ --cacert=/etc/kubernetes/pki/etcd/ca.crt \ --cert=/etc/kubernetes/pki/etcd/server.crt \ --key=/etc/kubernetes/pki/etcd/server.key ``` ### Phase 6 : Sécurité RBAC ```yaml # Role : permissions dans un namespace apiVersion: rbac.authorization.k8s.io/v1 kind: Role metadata: namespace: dev name: pod-reader rules: - apiGroups: [""] resources: ["pods"] verbs: ["get", "list", "watch"] --- # RoleBinding : assigner le Role apiVersion: rbac.authorization.k8s.io/v1 kind: RoleBinding metadata: name: read-pods namespace: dev subjects: - kind: User name: alice roleRef: kind: Role name: pod-reader apiGroup: rbac.authorization.k8s.io ``` ### Phase 7 : Troubleshooting (30% de l'examen !) ```bash # Diagnostic Pod kubectl describe pod <pod-name> kubectl logs <pod-name> --previous kubectl get events --sort-by='.lastTimestamp' # Diagnostic Node kubectl describe node <node-name> ssh <node> systemctl status kubelet ssh <node> journalctl -u kubelet -f # Diagnostic Cluster kubectl get componentstatuses kubectl get pods -n kube-system sudo crictl ps # sur le nœud # Erreurs fréquentes # CrashLoopBackOff → kubectl logs # ImagePullBackOff → vérifier image/registry # Pending → kubectl describe (events) # OOMKilled → augmenter limits ``` ### Checklist avant examen CKA - [ ] Cluster installé avec kubeadm (from scratch) - [ ] Backup/restore etcd fonctionnel - [ ] Upgrade cluster maîtrisé - [ ] RBAC configuré (Role, RoleBinding) - [ ] Network Policies appliquées - [ ] Ingress controller déployé - [ ] Troubleshooting : 5 scénarios résolus - [ ] Killer.sh : 2 sessions complètes - [ ] Temps : chaque question <5 min

Le parcours administrateur Kubernetes mène à la certification CKA et aux postes SRE/DevOps. Il couvre l'installation, la configuration, la sécurité et le troubleshooting de clusters.

Roadmap CKA complète

Phase	Durée	Thèmes	Validation
1. Fondamentaux	2-4 sem	Architecture, kubectl, Pods	Quiz architecture
2. Workloads	3-4 sem	Deployments, Services, ConfigMaps	App déployée
3. Cluster Admin	4-6 sem	kubeadm, etcd, upgrades	Cluster installé
4. Stockage	2-3 sem	PV, PVC, StorageClass	Volume persistant
5. Réseau	3-4 sem	Services, Ingress, Network Policies	App exposée + sécurisée
6. Sécurité	3-4 sem	RBAC, ServiceAccounts, secrets	Cluster hardened
7. Troubleshooting	3-4 sem	Logs, events, debugging	Incidents résolus
8. Préparation exam	2-4 sem	Killer.sh, examens blancs	Score >75%

Phase 1 : Architecture (semaines 1-4)

# Comprendre les composants
kubectl get nodes
kubectl get pods -n kube-system

# Control Plane
# - kube-apiserver : point d'entrée API
# - etcd : stockage cluster
# - kube-scheduler : placement Pods
# - kube-controller-manager : boucles de contrôle

# Worker Nodes
# - kubelet : agent sur chaque nœud
# - kube-proxy : règles réseau
# - container runtime : containerd/CRI-O

# Commandes essentielles
kubectl cluster-info
kubectl get componentstatuses
kubectl describe node <node-name>

Phase 3 : Installation cluster (kubeadm)

# Sur le control plane
sudo kubeadm init --pod-network-cidr=10.244.0.0/16

# Configurer kubectl
mkdir -p $HOME/.kube
sudo cp /etc/kubernetes/admin.conf $HOME/.kube/config

# Installer CNI (Calico)
kubectl apply -f https://docs.projectcalico.org/manifests/calico.yaml

# Joindre les workers
kubeadm token create --print-join-command
# Sur chaque worker :
sudo kubeadm join <control-plane>:6443 --token ... --discovery-token-ca-cert-hash ...

# Backup etcd (critique !)
ETCDCTL_API=3 etcdctl snapshot save backup.db \
  --endpoints=https://127.0.0.1:2379 \
  --cacert=/etc/kubernetes/pki/etcd/ca.crt \
  --cert=/etc/kubernetes/pki/etcd/server.crt \
  --key=/etc/kubernetes/pki/etcd/server.key

Phase 6 : Sécurité RBAC

# Role : permissions dans un namespace
apiVersion: rbac.authorization.k8s.io/v1
kind: Role
metadata:
  namespace: dev
  name: pod-reader
rules:
- apiGroups: [""]
  resources: ["pods"]
  verbs: ["get", "list", "watch"]
---
# RoleBinding : assigner le Role
apiVersion: rbac.authorization.k8s.io/v1
kind: RoleBinding
metadata:
  name: read-pods
  namespace: dev
subjects:
- kind: User
  name: alice
roleRef:
  kind: Role
  name: pod-reader
  apiGroup: rbac.authorization.k8s.io

Phase 7 : Troubleshooting (30% de l'examen !)

# Diagnostic Pod
kubectl describe pod <pod-name>
kubectl logs <pod-name> --previous
kubectl get events --sort-by='.lastTimestamp'

# Diagnostic Node
kubectl describe node <node-name>
ssh <node> systemctl status kubelet
ssh <node> journalctl -u kubelet -f

# Diagnostic Cluster
kubectl get componentstatuses
kubectl get pods -n kube-system
sudo crictl ps  # sur le nœud

# Erreurs fréquentes
# CrashLoopBackOff → kubectl logs
# ImagePullBackOff → vérifier image/registry
# Pending → kubectl describe (events)
# OOMKilled → augmenter limits

Checklist avant examen CKA

Cluster installé avec kubeadm (from scratch)
Backup/restore etcd fonctionnel
Upgrade cluster maîtrisé
RBAC configuré (Role, RoleBinding)
Network Policies appliquées
Ingress controller déployé
Troubleshooting : 5 scénarios résolus
Killer.sh : 2 sessions complètes
Temps : chaque question <5 min

Quel parcours suivre pour un développeur sur Kubernetes (CKAD) ?

Le parcours **développeur Kubernetes** mène à la certification **CKAD**. L'objectif : savoir **packager, déployer et configurer** vos applications pour qu'elles tournent sur K8s. ### Roadmap CKAD complète | Phase | Durée | Thèmes | Validation | |-------|-------|--------|------------| | **1. Conteneurs** | 1-2 sem | Dockerfile, images, registries | Image buildée et pushée | | **2. Pods** | 2-3 sem | Pods, multi-containers, init containers | Pod complexe déployé | | **3. Deployments** | 2-3 sem | Deployments, rolling updates, rollback | App scalée | | **4. Configuration** | 3-4 sem | ConfigMaps, Secrets, env vars | App configurée | | **5. Observabilité** | 2-3 sem | Probes, logs, debugging | App résiliente | | **6. Services** | 2-3 sem | Services, Ingress | App exposée | | **7. Packaging** | 2-3 sem | Helm, Kustomize | Chart Helm créé | | **8. Préparation** | 2-3 sem | Killer.sh, examens blancs | Score >75% | ### Phase 2 : Maîtriser les Pods ```yaml # Pod multi-containers apiVersion: v1 kind: Pod metadata: name: app-with-sidecar spec: initContainers: - name: init-db image: busybox command: ['sh', '-c', 'until nc -z db-service 5432; do sleep 2; done'] containers: - name: app image: mon-app:v1 ports: - containerPort: 8080 volumeMounts: - name: shared-logs mountPath: /var/log/app - name: log-shipper image: fluent/fluent-bit volumeMounts: - name: shared-logs mountPath: /var/log/app volumes: - name: shared-logs emptyDir: {} ``` ### Phase 4 : Configuration (ConfigMaps & Secrets) ```yaml # ConfigMap apiVersion: v1 kind: ConfigMap metadata: name: app-config data: DATABASE_HOST: "postgres.default.svc" LOG_LEVEL: "info" config.json: | { "feature_x": true, "max_connections": 100 } --- # Secret apiVersion: v1 kind: Secret metadata: name: app-secrets type: Opaque stringData: DATABASE_PASSWORD: "super-secret" API_KEY: "abc123" --- # Utilisation dans un Pod apiVersion: v1 kind: Pod metadata: name: app spec: containers: - name: app image: mon-app:v1 envFrom: - configMapRef: name: app-config - secretRef: name: app-secrets volumeMounts: - name: config-volume mountPath: /etc/config volumes: - name: config-volume configMap: name: app-config ``` ### Phase 5 : Probes (résilience) ```yaml apiVersion: apps/v1 kind: Deployment metadata: name: app spec: replicas: 3 template: spec: containers: - name: app image: mon-app:v1 resources: requests: cpu: "100m" memory: "128Mi" limits: cpu: "500m" memory: "512Mi" livenessProbe: httpGet: path: /healthz port: 8080 initialDelaySeconds: 10 periodSeconds: 5 readinessProbe: httpGet: path: /ready port: 8080 initialDelaySeconds: 5 periodSeconds: 3 startupProbe: httpGet: path: /healthz port: 8080 failureThreshold: 30 periodSeconds: 10 ``` ### Phase 7 : Helm basics ```bash # Créer un chart helm create mon-app # Structure mon-app/ ├── Chart.yaml ├── values.yaml ├── templates/ │ ├── deployment.yaml │ ├── service.yaml │ └── ingress.yaml # Installer helm install mon-app ./mon-app -f values-prod.yaml # Mettre à jour helm upgrade mon-app ./mon-app --set image.tag=v2 # Rollback helm rollback mon-app 1 ``` ### Raccourcis kubectl (vitesse = clé CKAD) ```bash # Créer rapidement kubectl run nginx --image=nginx --port=80 kubectl create deployment nginx --image=nginx --replicas=3 kubectl expose deployment nginx --port=80 --type=NodePort # Générer YAML (ne pas écrire from scratch !) kubectl run nginx --image=nginx --dry-run=client -o yaml > pod.yaml kubectl create deployment nginx --image=nginx --dry-run=client -o yaml > deploy.yaml # Alias essentiels alias k=kubectl export do="--dry-run=client -o yaml" # Exemples k run nginx --image=nginx $do > pod.yaml k create deploy nginx --image=nginx $do > deploy.yaml ``` ### Checklist avant examen CKAD - [ ] Pods multi-containers maîtrisés - [ ] ConfigMaps et Secrets (envFrom, volumeMounts) - [ ] Probes (liveness, readiness, startup) - [ ] Resources (requests, limits) - [ ] Services et Ingress - [ ] Jobs et CronJobs - [ ] Helm install/upgrade/rollback - [ ] Raccourcis kubectl fluides - [ ] Killer.sh : 2 sessions complètes - [ ] Chaque question <4 min

Le parcours développeur Kubernetes mène à la certification CKAD. L'objectif : savoir packager, déployer et configurer vos applications pour qu'elles tournent sur K8s.

Roadmap CKAD complète

Phase	Durée	Thèmes	Validation
1. Conteneurs	1-2 sem	Dockerfile, images, registries	Image buildée et pushée
2. Pods	2-3 sem	Pods, multi-containers, init containers	Pod complexe déployé
3. Deployments	2-3 sem	Deployments, rolling updates, rollback	App scalée
4. Configuration	3-4 sem	ConfigMaps, Secrets, env vars	App configurée
5. Observabilité	2-3 sem	Probes, logs, debugging	App résiliente
6. Services	2-3 sem	Services, Ingress	App exposée
7. Packaging	2-3 sem	Helm, Kustomize	Chart Helm créé
8. Préparation	2-3 sem	Killer.sh, examens blancs	Score >75%

Phase 2 : Maîtriser les Pods

# Pod multi-containers
apiVersion: v1
kind: Pod
metadata:
  name: app-with-sidecar
spec:
  initContainers:
    - name: init-db
      image: busybox
      command: ['sh', '-c', 'until nc -z db-service 5432; do sleep 2; done']
  containers:
    - name: app
      image: mon-app:v1
      ports:
        - containerPort: 8080
      volumeMounts:
        - name: shared-logs
          mountPath: /var/log/app
    - name: log-shipper
      image: fluent/fluent-bit
      volumeMounts:
        - name: shared-logs
          mountPath: /var/log/app
  volumes:
    - name: shared-logs
      emptyDir: {}

Phase 4 : Configuration (ConfigMaps & Secrets)

# ConfigMap
apiVersion: v1
kind: ConfigMap
metadata:
  name: app-config
data:
  DATABASE_HOST: "postgres.default.svc"
  LOG_LEVEL: "info"
  config.json: |
    {
      "feature_x": true,
      "max_connections": 100
    }
---
# Secret
apiVersion: v1
kind: Secret
metadata:
  name: app-secrets
type: Opaque
stringData:
  DATABASE_PASSWORD: "super-secret"
  API_KEY: "abc123"
---
# Utilisation dans un Pod
apiVersion: v1
kind: Pod
metadata:
  name: app
spec:
  containers:
    - name: app
      image: mon-app:v1
      envFrom:
        - configMapRef:
            name: app-config
        - secretRef:
            name: app-secrets
      volumeMounts:
        - name: config-volume
          mountPath: /etc/config
  volumes:
    - name: config-volume
      configMap:
        name: app-config

Phase 5 : Probes (résilience)

apiVersion: apps/v1
kind: Deployment
metadata:
  name: app
spec:
  replicas: 3
  template:
    spec:
      containers:
        - name: app
          image: mon-app:v1
          resources:
            requests:
              cpu: "100m"
              memory: "128Mi"
            limits:
              cpu: "500m"
              memory: "512Mi"
          livenessProbe:
            httpGet:
              path: /healthz
              port: 8080
            initialDelaySeconds: 10
            periodSeconds: 5
          readinessProbe:
            httpGet:
              path: /ready
              port: 8080
            initialDelaySeconds: 5
            periodSeconds: 3
          startupProbe:
            httpGet:
              path: /healthz
              port: 8080
            failureThreshold: 30
            periodSeconds: 10

Phase 7 : Helm basics

# Créer un chart
helm create mon-app

# Structure
mon-app/
├── Chart.yaml
├── values.yaml
├── templates/
│   ├── deployment.yaml
│   ├── service.yaml
│   └── ingress.yaml

# Installer
helm install mon-app ./mon-app -f values-prod.yaml

# Mettre à jour
helm upgrade mon-app ./mon-app --set image.tag=v2

# Rollback
helm rollback mon-app 1

Raccourcis kubectl (vitesse = clé CKAD)

# Créer rapidement
kubectl run nginx --image=nginx --port=80
kubectl create deployment nginx --image=nginx --replicas=3
kubectl expose deployment nginx --port=80 --type=NodePort

# Générer YAML (ne pas écrire from scratch !)
kubectl run nginx --image=nginx --dry-run=client -o yaml > pod.yaml
kubectl create deployment nginx --image=nginx --dry-run=client -o yaml > deploy.yaml

# Alias essentiels
alias k=kubectl
export do="--dry-run=client -o yaml"

# Exemples
k run nginx --image=nginx $do > pod.yaml
k create deploy nginx --image=nginx $do > deploy.yaml

Checklist avant examen CKAD

Pods multi-containers maîtrisés
ConfigMaps et Secrets (envFrom, volumeMounts)
Probes (liveness, readiness, startup)
Resources (requests, limits)
Services et Ingress
Jobs et CronJobs
Helm install/upgrade/rollback
Raccourcis kubectl fluides
Killer.sh : 2 sessions complètes
Chaque question <4 min

La certification CKS (sécurité) vaut-elle le coup ?

La **CKS** (Certified Kubernetes Security Specialist) est la certification **la plus avancée**. Elle s'adresse aux professionnels expérimentés qui veulent se spécialiser en sécurité Kubernetes. ### Prérequis et positionnement | Critère | CKS | |---------|-----| | **Prérequis** | CKA valide (obligatoire) | | **Expérience recommandée** | 1-2 ans K8s en production | | **Durée examen** | 2 heures | | **Score requis** | 67% | | **Validité** | 2 ans (vs 3 ans CKA/CKAD) | | **Prix** | $395 | | **Difficulté** | ★★★★ (la plus difficile) | ### Domaines couverts ``` Cluster Setup (10%) ├── Network Policies pour isoler les Pods ├── CIS Kubernetes Benchmark └── Ingress avec TLS Cluster Hardening (15%) ├── RBAC : moindre privilège ├── ServiceAccounts : tokens, automount └── Restriction des API non nécessaires System Hardening (15%) ├── Réduire la surface d'attaque (AppArmor, seccomp) ├── Limiter les syscalls └── Kernel hardening Minimize Microservice Vulnerabilities (20%) ├── SecurityContext (runAsNonRoot, readOnlyRootFilesystem) ├── Pod Security Standards ├── Gestion des Secrets (encryption at rest) └── Runtime sandboxing (gVisor, Kata) Supply Chain Security (20%) ├── Scan d'images (Trivy, Grype) ├── Signature d'images (Cosign, Notary) ├── Admission controllers (OPA Gatekeeper, Kyverno) └── Base images minimales Monitoring & Logging (20%) ├── Audit logs Kubernetes ├── Détection d'anomalies (Falco) └── Analyse comportementale ``` ### Exemple : Pod Security ```yaml apiVersion: v1 kind: Pod metadata: name: secure-pod spec: securityContext: runAsNonRoot: true runAsUser: 1000 fsGroup: 2000 containers: - name: app image: mon-app:v1 securityContext: allowPrivilegeEscalation: false readOnlyRootFilesystem: true capabilities: drop: - ALL resources: limits: cpu: "500m" memory: "512Mi" ``` ### Pour qui est la CKS ? ✅ **Recommandée si** : - Security Engineer / DevSecOps - SRE senior responsable de la sécurité - Consultant sécurité cloud - Architecte avec focus sécurité - Évolution de carrière vers la sécurité ❌ **Pas prioritaire si** : - Moins de 1 an d'expérience K8s - Rôle purement développeur - Pas de responsabilité sécurité - CKA pas encore obtenue ### ROI de la CKS | Bénéfice | Impact | |----------|--------| | Salaire | +15-25% vs CKA seule | | Postes accessibles | Security Engineer, DevSecOps | | Crédibilité | Expertise reconnue | | Rareté | Moins de 10% des certifiés K8s | ### Parcours recommandé ``` 1. CKA (6-12 mois expérience K8s) ↓ 2. Production K8s (6-12 mois) ↓ 3. CKS (focus sécurité) ```

La CKS (Certified Kubernetes Security Specialist) est la certification la plus avancée. Elle s'adresse aux professionnels expérimentés qui veulent se spécialiser en sécurité Kubernetes.

Prérequis et positionnement

Critère	CKS
Prérequis	CKA valide (obligatoire)
Expérience recommandée	1-2 ans K8s en production
Durée examen	2 heures
Score requis	67%
Validité	2 ans (vs 3 ans CKA/CKAD)
Prix	$395
Difficulté	★★★★ (la plus difficile)

Domaines couverts

Cluster Setup (10%)
├── Network Policies pour isoler les Pods
├── CIS Kubernetes Benchmark
└── Ingress avec TLS

Cluster Hardening (15%)
├── RBAC : moindre privilège
├── ServiceAccounts : tokens, automount
└── Restriction des API non nécessaires

System Hardening (15%)
├── Réduire la surface d'attaque (AppArmor, seccomp)
├── Limiter les syscalls
└── Kernel hardening

Minimize Microservice Vulnerabilities (20%)
├── SecurityContext (runAsNonRoot, readOnlyRootFilesystem)
├── Pod Security Standards
├── Gestion des Secrets (encryption at rest)
└── Runtime sandboxing (gVisor, Kata)

Supply Chain Security (20%)
├── Scan d'images (Trivy, Grype)
├── Signature d'images (Cosign, Notary)
├── Admission controllers (OPA Gatekeeper, Kyverno)
└── Base images minimales

Monitoring & Logging (20%)
├── Audit logs Kubernetes
├── Détection d'anomalies (Falco)
└── Analyse comportementale

Exemple : Pod Security

apiVersion: v1
kind: Pod
metadata:
  name: secure-pod
spec:
  securityContext:
    runAsNonRoot: true
    runAsUser: 1000
    fsGroup: 2000
  containers:
    - name: app
      image: mon-app:v1
      securityContext:
        allowPrivilegeEscalation: false
        readOnlyRootFilesystem: true
        capabilities:
          drop:
            - ALL
      resources:
        limits:
          cpu: "500m"
          memory: "512Mi"

Pour qui est la CKS ?

✅ Recommandée si :

Security Engineer / DevSecOps
SRE senior responsable de la sécurité
Consultant sécurité cloud
Architecte avec focus sécurité
Évolution de carrière vers la sécurité

❌ Pas prioritaire si :

Moins de 1 an d'expérience K8s
Rôle purement développeur
Pas de responsabilité sécurité
CKA pas encore obtenue

ROI de la CKS

Bénéfice	Impact
Salaire	+15-25% vs CKA seule
Postes accessibles	Security Engineer, DevSecOps
Crédibilité	Expertise reconnue
Rareté	Moins de 10% des certifiés K8s

Parcours recommandé

1. CKA (6-12 mois expérience K8s)
   ↓
2. Production K8s (6-12 mois)
   ↓
3. CKS (focus sécurité)

Quelles ressources pour se préparer aux certifications Kubernetes ?

La préparation aux certifications K8s combine **théorie**, **pratique intensive** et **simulation d'examen**. Voici les meilleures ressources par catégorie. ### Ressources officielles (gratuites) | Ressource | Type | URL | Usage | |-----------|------|-----|-------| | **kubernetes.io/docs** | Documentation | kubernetes.io | Référence pendant l'examen | | **Kubernetes The Hard Way** | Tutorial | github.com/kelseyhightower | Comprendre les internals | | **CNCF Training** | Cours gratuits | training.linuxfoundation.org | Bases solides | ### Plateformes de formation (payantes) | Plateforme | Prix | Points forts | Recommandé pour | |------------|------|--------------|------------------| | **Killer.sh** | Inclus exam | Simulateur identique | Tous (essentiel) | | **KodeKloud** | $15-30/mois | Labs interactifs, parcours complet | Débutants → CKA/CKAD | | **Udemy (Mumshad)** | $15-30 | Cours + labs, très complet | CKA/CKAD | | **A Cloud Guru** | $35/mois | Multicloud, certifications | Multi-certifications | | **Linux Foundation** | $300+ | Officiel, certification bundle | Budget entreprise | ### Killer.sh : le simulateur essentiel ```bash # Inclus avec l'inscription à l'examen CNCF # 2 sessions de simulation (36h chacune) # Environnement identique à l'examen Conseils Killer.sh : 1. Faire la 1ère session 2 semaines avant l'examen 2. Analyser chaque erreur en détail 3. Refaire les questions ratées 4. Faire la 2ème session 3-5 jours avant 5. Viser >80% avant de passer l'examen réel ``` ### Labs pratiques gratuits | Plateforme | Durée | Niveau | Accès | |------------|-------|--------|-------| | **Killercoda** | Illimité | Débutant-Intermédiaire | killercoda.com | | **Play with K8s** | 4h/session | Débutant | labs.play-with-k8s.com | | **Katacoda** | Variable | Tous | katacoda.com | | **Google Qwiklabs** | Crédits | Intermédiaire | qwiklabs.com | ### Livres recommandés ``` Débutant : - "Kubernetes: Up and Running" (O'Reilly) - "The Kubernetes Book" (Nigel Poulton) CKA/CKAD : - "Certified Kubernetes Administrator Study Guide" (Benjamin Muschko) - "Certified Kubernetes Application Developer Study Guide" (Benjamin Muschko) Avancé : - "Production Kubernetes" (O'Reilly) - "Kubernetes Patterns" (O'Reilly) ``` ### Planning de révision optimisé ``` 8 semaines avant : ├── Semaine 1-2 : Cours complet (KodeKloud/Udemy) ├── Semaine 3-4 : Labs pratiques intensifs ├── Semaine 5-6 : Killer.sh session 1 + révision points faibles ├── Semaine 7 : Killer.sh session 2 └── Semaine 8 : Révision finale + examen Quotidien (dernières 2 semaines) : ├── 30 min : Révision théorie (domaines faibles) ├── 60 min : Pratique kubectl (sans doc) └── 30 min : Questions type examen ``` ### Checklist pré-examen - [ ] Documentation K8s bookmarkée (sections utiles) - [ ] Alias kubectl configurés (`alias k=kubectl`) - [ ] Killer.sh : score >75% sur les 2 sessions - [ ] Chaque domaine d'examen couvert - [ ] Vitesse : <5 min par question - [ ] Environnement test : webcam, micro, pièce calme - [ ] ID valide prêt - [ ] Check technique PSI (navigateur, webcam)

La préparation aux certifications K8s combine théorie, pratique intensive et simulation d'examen. Voici les meilleures ressources par catégorie.

Ressources officielles (gratuites)

Ressource	Type	URL	Usage
kubernetes.io/docs	Documentation	kubernetes.io	Référence pendant l'examen
Kubernetes The Hard Way	Tutorial	github.com/kelseyhightower	Comprendre les internals
CNCF Training	Cours gratuits	training.linuxfoundation.org	Bases solides

Plateformes de formation (payantes)

Plateforme	Prix	Points forts	Recommandé pour
Killer.sh	Inclus exam	Simulateur identique	Tous (essentiel)
KodeKloud	$15-30/mois	Labs interactifs, parcours complet	Débutants → CKA/CKAD
Udemy (Mumshad)	$15-30	Cours + labs, très complet	CKA/CKAD
A Cloud Guru	$35/mois	Multicloud, certifications	Multi-certifications
Linux Foundation	$300+	Officiel, certification bundle	Budget entreprise

Killer.sh : le simulateur essentiel

# Inclus avec l'inscription à l'examen CNCF
# 2 sessions de simulation (36h chacune)
# Environnement identique à l'examen

Conseils Killer.sh :
1. Faire la 1ère session 2 semaines avant l'examen
2. Analyser chaque erreur en détail
3. Refaire les questions ratées
4. Faire la 2ème session 3-5 jours avant
5. Viser >80% avant de passer l'examen réel

Labs pratiques gratuits

Plateforme	Durée	Niveau	Accès
Killercoda	Illimité	Débutant-Intermédiaire	killercoda.com
Play with K8s	4h/session	Débutant	labs.play-with-k8s.com
Katacoda	Variable	Tous	katacoda.com
Google Qwiklabs	Crédits	Intermédiaire	qwiklabs.com

Livres recommandés

Débutant :
- "Kubernetes: Up and Running" (O'Reilly)
- "The Kubernetes Book" (Nigel Poulton)

CKA/CKAD :
- "Certified Kubernetes Administrator Study Guide" (Benjamin Muschko)
- "Certified Kubernetes Application Developer Study Guide" (Benjamin Muschko)

Avancé :
- "Production Kubernetes" (O'Reilly)
- "Kubernetes Patterns" (O'Reilly)

Planning de révision optimisé

8 semaines avant :
├── Semaine 1-2 : Cours complet (KodeKloud/Udemy)
├── Semaine 3-4 : Labs pratiques intensifs
├── Semaine 5-6 : Killer.sh session 1 + révision points faibles
├── Semaine 7 : Killer.sh session 2
└── Semaine 8 : Révision finale + examen

Quotidien (dernières 2 semaines) :
├── 30 min : Révision théorie (domaines faibles)
├── 60 min : Pratique kubectl (sans doc)
└── 30 min : Questions type examen

Checklist pré-examen

Documentation K8s bookmarkée (sections utiles)
Alias kubectl configurés (alias k=kubectl)
Killer.sh : score >75% sur les 2 sessions
Chaque domaine d'examen couvert
Vitesse : <5 min par question
Environnement test : webcam, micro, pièce calme
ID valide prêt
Check technique PSI (navigateur, webcam)

Kubernetes est-il indispensable pour un DevOps ?

Kubernetes est devenu le **standard de facto** pour l'orchestration de conteneurs. Sa maîtrise est un **atout majeur** pour tout profil DevOps, même si vous n'administrez pas directement de clusters. ### Kubernetes dans l'écosystème DevOps | Domaine DevOps | Rôle de Kubernetes | Importance | |----------------|-------------------|------------| | **CI/CD** | Target de déploiement | ★★★ Essentiel | | **Infrastructure as Code** | Manifests YAML, Helm | ★★★ Essentiel | | **GitOps** | ArgoCD, Flux | ★★★ Essentiel | | **Monitoring** | Prometheus, Grafana | ★★★ Essentiel | | **Sécurité** | RBAC, Network Policies | ★★ Important | | **Logging** | ELK, Loki | ★★ Important | ### Statistiques du marché (2024-2025) ``` Adoption Kubernetes : ├── 96% des organisations utilisent ou évaluent K8s (CNCF Survey) ├── 78% en production ├── 5.6M+ développeurs utilisent K8s └── Croissance : +30% par an Offres d'emploi DevOps : ├── 85% mentionnent Kubernetes ├── 70% mentionnent Docker ├── 60% mentionnent Terraform └── K8s = compétence #1 demandée Salaires DevOps (France, 2024) : ├── Sans K8s : 45-55k€ ├── Avec K8s : 55-70k€ ├── Expert K8s : 70-90k€ └── +20-30% avec certifications ``` ### Profils DevOps et niveau K8s requis | Profil | Niveau K8s requis | Compétences clés | |--------|-------------------|------------------| | **DevOps Junior** | Bases | Deployments, Services, kubectl | | **DevOps Engineer** | Intermédiaire | Helm, CI/CD, monitoring | | **SRE** | Avancé | Troubleshooting, scaling, sécurité | | **Platform Engineer** | Expert | Architecture, opérateurs, multi-cluster | | **DevSecOps** | Avancé | RBAC, Network Policies, scanning | ### Pipeline CI/CD typique avec K8s ```yaml # .gitlab-ci.yml stages: - build - test - deploy build: stage: build script: - docker build -t $CI_REGISTRY_IMAGE:$CI_COMMIT_SHA . - docker push $CI_REGISTRY_IMAGE:$CI_COMMIT_SHA deploy-staging: stage: deploy script: - kubectl config use-context staging - helm upgrade --install app ./chart \ --set image.tag=$CI_COMMIT_SHA - kubectl rollout status deployment/app deploy-prod: stage: deploy script: - kubectl config use-context production - helm upgrade --install app ./chart \ --set image.tag=$CI_COMMIT_SHA when: manual only: - main ``` ### Alternatives à Kubernetes | Solution | Cas d'usage | Quand préférer | |----------|-------------|----------------| | **Docker Compose** | Dev local, petites apps | <10 conteneurs, 1 serveur | | **Docker Swarm** | Simplicité, petit cluster | Équipe petite, migration Docker | | **Nomad** | Multi-workload | VMs + conteneurs + batch | | **ECS/Fargate** | AWS native | 100% AWS, serverless | | **Cloud Run** | GCP serverless | Apps stateless, scaling auto | ### Conclusion **Kubernetes n'est pas obligatoire**, mais sa maîtrise : - Ouvre 85% des offres DevOps - Augmente le salaire de 20-30% - Permet de travailler sur des projets complexes - Est transférable (tous les clouds, on-premise) **Recommandation** : même si vous n'administrez pas de clusters, comprenez les concepts (Pods, Services, Deployments) pour collaborer efficacement avec les équipes infra et débugger en production.

Kubernetes est devenu le standard de facto pour l'orchestration de conteneurs. Sa maîtrise est un atout majeur pour tout profil DevOps, même si vous n'administrez pas directement de clusters.

Kubernetes dans l'écosystème DevOps

Domaine DevOps	Rôle de Kubernetes	Importance
CI/CD	Target de déploiement	★★★ Essentiel
Infrastructure as Code	Manifests YAML, Helm	★★★ Essentiel
GitOps	ArgoCD, Flux	★★★ Essentiel
Monitoring	Prometheus, Grafana	★★★ Essentiel
Sécurité	RBAC, Network Policies	★★ Important
Logging	ELK, Loki	★★ Important

Statistiques du marché (2024-2025)

Adoption Kubernetes :
├── 96% des organisations utilisent ou évaluent K8s (CNCF Survey)
├── 78% en production
├── 5.6M+ développeurs utilisent K8s
└── Croissance : +30% par an

Offres d'emploi DevOps :
├── 85% mentionnent Kubernetes
├── 70% mentionnent Docker
├── 60% mentionnent Terraform
└── K8s = compétence #1 demandée

Salaires DevOps (France, 2024) :
├── Sans K8s : 45-55k€
├── Avec K8s : 55-70k€
├── Expert K8s : 70-90k€
└── +20-30% avec certifications

Profils DevOps et niveau K8s requis

Profil	Niveau K8s requis	Compétences clés
DevOps Junior	Bases	Deployments, Services, kubectl
DevOps Engineer	Intermédiaire	Helm, CI/CD, monitoring
SRE	Avancé	Troubleshooting, scaling, sécurité
Platform Engineer	Expert	Architecture, opérateurs, multi-cluster
DevSecOps	Avancé	RBAC, Network Policies, scanning

Pipeline CI/CD typique avec K8s

# .gitlab-ci.yml
stages:
  - build
  - test
  - deploy

build:
  stage: build
  script:
    - docker build -t $CI_REGISTRY_IMAGE:$CI_COMMIT_SHA .
    - docker push $CI_REGISTRY_IMAGE:$CI_COMMIT_SHA

deploy-staging:
  stage: deploy
  script:
    - kubectl config use-context staging
    - helm upgrade --install app ./chart \
        --set image.tag=$CI_COMMIT_SHA
    - kubectl rollout status deployment/app

deploy-prod:
  stage: deploy
  script:
    - kubectl config use-context production
    - helm upgrade --install app ./chart \
        --set image.tag=$CI_COMMIT_SHA
  when: manual
  only:
    - main

Alternatives à Kubernetes

Solution	Cas d'usage	Quand préférer
Docker Compose	Dev local, petites apps	<10 conteneurs, 1 serveur
Docker Swarm	Simplicité, petit cluster	Équipe petite, migration Docker
Nomad	Multi-workload	VMs + conteneurs + batch
ECS/Fargate	AWS native	100% AWS, serverless
Cloud Run	GCP serverless	Apps stateless, scaling auto

Conclusion

Kubernetes n'est pas obligatoire, mais sa maîtrise :

Ouvre 85% des offres DevOps
Augmente le salaire de 20-30%
Permet de travailler sur des projets complexes
Est transférable (tous les clouds, on-premise)

Recommandation : même si vous n'administrez pas de clusters, comprenez les concepts (Pods, Services, Deployments) pour collaborer efficacement avec les équipes infra et débugger en production.