CKA - Guide Complet et Stratégie d'Examen

🎯 Objectifs

Ce module est le point d'entrée de la série CKA. Tu vas :

• ✅ Comprendre ce qu'est la CKA et pourquoi elle est exigeante
• ✅ Connaître les 5 domaines et leur poids dans la note finale
• ✅ Maîtriser les techniques kubectl indispensables pour aller vite
• ✅ Mettre en place ton environnement d'entraînement
• ✅ Avoir un plan de révision semaine par semaine

📋 Prérequis

• Modules Kubernetes - Débutant et Kubernetes - Avancé complétés
• À l'aise avec kubectl apply, kubectl get, kubectl describe, kubectl logs
• Connaissances Linux : fichiers de config, systemctl, journalctl

📖 Qu'est-ce que la CKA ?

Le problème qu'elle résout

Tout le monde peut dire "je connais Kubernetes". La CKA le prouve.

C'est une certification créée par la CNCF (Cloud Native Computing Foundation) et la Linux Foundation. Elle valide que tu es capable d'administrer un cluster Kubernetes en conditions réelles - pas seulement de déployer des applications, mais de gérer, déboguer et maintenir l'infrastructure elle-même.

Ce qui la distingue

La CKA est 100% pratique. Pas de QCM. Tu travailles directement dans un vrai terminal, sur de vrais clusters Kubernetes, pendant 2 heures.

C'est ce qui la rend difficile - et précieuse.

Score et règles

• 66% minimum pour être certifié
• Durée : 2 heures
• 15 à 20 tâches pratiques, sur plusieurs clusters
• Documentation kubernetes.io autorisée (et seulement elle)
• Webcam et écran partagé obligatoires (examen en ligne)
• Validité : 3 ans

📊 Les 5 domaines

L'examen couvre 5 domaines. Comprendre leur poids permet de prioriser ta révision.

💡 Le Troubleshooting représente 30% de la note. C'est le domaine numéro 1 à maîtriser.

⚡ Techniques kubectl pour aller vite

La CKA est un examen de vitesse autant que de connaissance. Configurer ton terminal en début d'examen fait gagner plusieurs minutes.

Alias et variables - à taper en tout premier

# Alias kubectl → k
alias k=kubectl

# Raccourci pour générer du YAML sans créer
export do="--dry-run=client -o yaml"

# Raccourci pour forcer la suppression
export now="--force --grace-period=0"

Le mode impératif : générer du YAML rapidement

Ne jamais écrire du YAML à la main quand kubectl peut le générer :

# Pod
k run nginx --image=nginx $do > pod.yaml

# Deployment
k create deployment nginx --image=nginx --replicas=3 $do > deploy.yaml

# Service (expose un deployment)
k expose deployment nginx --port=80 --target-port=80 $do > svc.yaml

# ConfigMap
k create configmap app-config --from-literal=ENV=prod $do

# Secret
k create secret generic db-secret --from-literal=password=s3cr3t $do

# ServiceAccount
k create serviceaccount mon-sa

# Role
k create role pod-reader --verb=get,list,watch --resource=pods $do

# RoleBinding
k create rolebinding alice-reader --role=pod-reader --user=alice $do

# CronJob
k create cronjob backup --image=busybox --schedule="0 2 * * *" -- echo backup $do

# Job
k create job test --image=busybox -- echo done $do

Éditer et corriger

# Éditer en place
k edit pod <nom>
k edit deployment <nom>

# Remplacer avec force
k replace --force -f pod.yaml

# Supprimer rapidement
k delete pod <nom> $now

🗺️ Gestion des contextes multi-cluster

L'examen propose plusieurs clusters. Chaque question précise quel contexte utiliser.

# Voir tous les contextes disponibles
k config get-contexts

# Changer de contexte
k config use-context <nom-du-contexte>

# Voir le contexte actif
k config current-context

⚠️ Vérifie toujours le contexte avant de commencer une tâche. Travailler dans le mauvais cluster fait perdre des points sans s'en rendre compte.

📚 Naviguer dans la documentation officielle

La documentation kubernetes.io est ton seul allié. Entraîne-toi à y naviguer rapidement.

La recherche (Ctrl+F dans le navigateur) est indispensable. Objectif : trouver n'importe quel exemple YAML en moins de 30 secondes.

🖥️ Environnement d'entraînement local

# Option 1 : kind (le plus simple)
kind create cluster

# Cluster multi-nodes avec kind (proche des conditions d'examen)
cat <<EOF | kind create cluster --name cka --config=-
kind: Cluster
apiVersion: kind.x-k8s.io/v1alpha4
nodes:
  - role: control-plane
  - role: worker
  - role: worker
EOF

# Option 2 : Minikube
minikube start --nodes=2 --driver=docker

# Option 3 : kubeadm sur des VMs (le plus proche de l'examen)
# Utiliser Vagrant + VirtualBox pour créer 1 control plane + 2 workers

🗓️ Plan de révision recommandé

Semaines 1-2 : Maîtriser les bases

Objectif : kubectl en mode automatique, la doc navigable en < 30s.

• Refaire tous les exercices Kubernetes Débutant et Avancé de ce site
• S'entraîner au mode impératif 30 minutes par jour
• Lire CKA : Architecture et CKA : Workloads

Semaines 3-4 : Approfondir les domaines difficiles

Objectif : être à l'aise sur chaque domaine individuellement.

• Lire CKA : Services et Réseau - créer des NetworkPolicies, tester le DNS
• Lire CKA : Stockage - monter un cluster kubeadm, simuler une panne etcd
• Commencer CKA : Troubleshooting - s'entraîner sur des clusters cassés

Semaine 5 : Simulations d'examen

Objectif : atteindre 75%+ sur killer.sh en 2h.

• killer.sh (inclus avec l'achat de l'examen, 2 sessions de 36h) - les questions sont plus dures que l'examen réel
• killercoda.com/cka - gratuit, très proche du format réel
• Respecter strictement le timing : 2h, sans pause
• Après chaque simulation : analyser les erreurs, réviser les domaines faibles

📊 Récapitulatif des commandes à avoir en réflexe

# Navigation
k config use-context <ctx>
k config current-context

# Vue d'ensemble rapide
k get pods -A
k get nodes -o wide
k get events -A --sort-by='.lastTimestamp' | tail -20

# Générer du YAML
k run <pod> --image=<img> $do
k create deployment <name> --image=<img> --replicas=N $do
k expose deployment <name> --port=80 $do

# Diagnostiquer
k describe pod <pod> -n <ns>
k logs <pod> -n <ns> --previous
k exec -it <pod> -- sh

# Forcer
k delete pod <pod> $now
k replace --force -f file.yaml

# Explorer la doc en ligne de commande
k explain pod.spec.containers.resources
k api-resources

🚀 Par où commencer ?

Suis les modules dans cet ordre :

1. CKA : Architecture et Installation de Cluster ← commence ici
2. CKA : Workloads et Scheduling
3. CKA : Services et Réseau
4. CKA : Stockage
5. CKA : Troubleshooting ← termine par là

💡 La CKA n'est pas un test de mémoire. C'est un test de réflexes. Entraîne-toi jusqu'à ce que kubectl soit aussi naturel que ls et cd.