Exercices CKA — Entraînement chronométré

Entraînement brutal, précis, rapide. Chaque exercice reproduit le format CKA : énoncé court, objectif observable, contrainte de temps. Visez 80% de réussite.

Types d'exercices

Ce guide contient deux types d’exercices :

• Exercices génériques : réalisables sur tout cluster Kubernetes (Kind, Minikube, K3s, cloud)
• Exercices kubeadm : nécessitent un cluster installé avec kubeadm et accès SSH aux nodes

Les exercices kubeadm sont signalés par l’icône [kubeadm].

Réflexes CKA

Configurez votre environnement avant de commencer :

# Alias essentiels
alias k=kubectl
alias kn='kubectl config set-context --current --namespace'
alias kgp='kubectl get pods'
alias kgn='kubectl get nodes'
export do="--dry-run=client -o yaml"
export now="--force --grace-period=0"

# Autocomplétion
source <(kubectl completion bash)
complete -F __start_kubectl k

# Namespace de travail
kubectl create ns cka-exercises
kn cka-exercises

Commandes critiques à connaître par cœur

# Générer un YAML rapidement
kubectl run nginx --image=nginx $do > pod.yaml

# Vérifier les permissions
kubectl auth can-i list pods --as=jane -n default

# Trouver la doc kubernetes.io
kubectl explain pod.spec.containers --recursive | grep -i <mot>

# Debug rapide
kubectl logs <pod> --previous
kubectl describe pod <pod> | tail -20
kubectl get events --sort-by='.lastTimestamp'

Cluster Architecture (25%)

Exercice 1 : Upgrade du cluster [kubeadm]

Temps cible : 15 minutes

Contexte	Cluster kubeadm en version 1.30.x
Tâche	Upgrade le control plane et un worker vers la dernière version patch de 1.31
Contrainte	Utiliser les versions disponibles dans le repo apt
Validation	kubectl get nodes affiche tous les nodes en v1.31.x

Glissez pour voir

Solution

# 1. Identifier la dernière version patch disponible
apt update
apt-cache madison kubeadm | grep 1.31
# Exemple : 1.31.4-1.1

# 2. Sur le control plane
apt-get install -y kubeadm=1.31.4-1.1
kubeadm upgrade plan
kubeadm upgrade apply v1.31.4

apt-get install -y kubelet=1.31.4-1.1 kubectl=1.31.4-1.1
systemctl daemon-reload && systemctl restart kubelet

# 3. Drain le worker depuis le control plane
kubectl drain worker1 --ignore-daemonsets --delete-emptydir-data

# 4. Sur le worker (via SSH)
apt-get install -y kubeadm=1.31.4-1.1
kubeadm upgrade node
apt-get install -y kubelet=1.31.4-1.1
systemctl daemon-reload && systemctl restart kubelet

# 5. Uncordon depuis le control plane
kubectl uncordon worker1
kubectl get nodes

Point clé : Toujours upgrader vers la dernière version patch (1.31.4), pas la version .0.

---

Exercice 2 : Backup etcd [kubeadm]

Temps cible : 6 minutes

Contexte	Cluster kubeadm standard
Tâche	Créer un snapshot etcd dans /opt/backup/etcd-snapshot.db
Contrainte	Certificats dans /etc/kubernetes/pki/etcd/
Validation	etcdctl snapshot status /opt/backup/etcd-snapshot.db --write-out=table affiche les infos

Glissez pour voir

Solution

export ETCDCTL_API=3
mkdir -p /opt/backup

etcdctl snapshot save /opt/backup/etcd-snapshot.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

# Validation
etcdctl snapshot status /opt/backup/etcd-snapshot.db --write-out=table

---

Exercice 3 : Restore etcd [kubeadm]

Temps cible : 10 minutes

Contexte	Snapshot etcd disponible dans /opt/backup/etcd-snapshot.db
Tâche	Restaurer etcd vers /var/lib/etcd-restore et reconfigurer le cluster
Contrainte	Utiliser etcdutl (pas etcdctl restore qui est déprécié)
Validation	kubectl get pods -n kube-system fonctionne après la restauration

Glissez pour voir

Solution

# 1. Arrêter l'API server (déplacer le manifest)
mv /etc/kubernetes/manifests/kube-apiserver.yaml /tmp/

# 2. Restore avec etcdutl (pas etcdctl !)
etcdutl snapshot restore /opt/backup/etcd-snapshot.db \
  --data-dir=/var/lib/etcd-restore

# 3. Modifier le manifest etcd pour pointer vers le nouveau répertoire
sed -i 's|/var/lib/etcd|/var/lib/etcd-restore|g' /etc/kubernetes/manifests/etcd.yaml

# 4. Remettre l'API server
mv /tmp/kube-apiserver.yaml /etc/kubernetes/manifests/

# 5. Attendre que les composants redémarrent (~30 secondes)
sleep 30
kubectl get pods -n kube-system

Point clé : etcdctl snapshot restore est déprécié depuis etcd 3.5. Utiliser etcdutl snapshot restore.

---

RBAC (partie de Cluster Architecture)

Exercice 4 : Role et RoleBinding

Temps cible : 4 minutes

Contexte	Namespace cka-exercises
Tâche	Créer un Role pod-reader (get, list, watch pods) et un RoleBinding read-pods pour l’utilisateur jane
Validation	kubectl auth can-i list pods -n cka-exercises --as=jane retourne yes

Glissez pour voir

Solution

kubectl create role pod-reader \
  --verb=get,list,watch \
  --resource=pods \
  -n cka-exercises

kubectl create rolebinding read-pods \
  --role=pod-reader \
  --user=jane \
  -n cka-exercises

# Validation
kubectl auth can-i list pods -n cka-exercises --as=jane    # yes
kubectl auth can-i delete pods -n cka-exercises --as=jane  # no

---

Exercice 5 : ClusterRole pour nodes

Temps cible : 4 minutes

Contexte	Ressource cluster-wide : nodes
Tâche	Créer un ClusterRole node-viewer (get, list, watch nodes) et un ClusterRoleBinding node-view-binding pour l’utilisateur bob
Validation	kubectl auth can-i list nodes --as=bob retourne yes

Glissez pour voir

Solution

kubectl create clusterrole node-viewer \
  --verb=get,list,watch \
  --resource=nodes

kubectl create clusterrolebinding node-view-binding \
  --clusterrole=node-viewer \
  --user=bob

# Validation
kubectl auth can-i list nodes --as=bob     # yes
kubectl auth can-i delete nodes --as=bob   # no

---

Exercice 6 : ServiceAccount avec permissions

Temps cible : 5 minutes

Contexte	Namespace cka-exercises
Tâche	Créer un ServiceAccount app-sa, un Role secret-reader (get, list secrets), les lier, et créer un Pod app-pod utilisant ce SA
Contrainte	Le Pod doit utiliser serviceAccountName dans le YAML (pas le flag déprécié --serviceaccount)
Validation	kubectl auth can-i list secrets --as=system:serviceaccount:cka-exercises:app-sa -n cka-exercises retourne yes

Glissez pour voir

Solution

# ServiceAccount
kubectl create sa app-sa -n cka-exercises

# Role
kubectl create role secret-reader \
  --verb=get,list \
  --resource=secrets \
  -n cka-exercises

# RoleBinding
kubectl create rolebinding app-secret-binding \
  --role=secret-reader \
  --serviceaccount=cka-exercises:app-sa \
  -n cka-exercises

# Pod avec serviceAccountName (pas --serviceaccount qui est déprécié)
kubectl apply -f - <<'EOF'
apiVersion: v1
kind: Pod
metadata:
  name: app-pod
  namespace: cka-exercises
spec:
  serviceAccountName: app-sa
  containers:
  - name: nginx
    image: nginx
EOF

# Validation
kubectl auth can-i list secrets \
  --as=system:serviceaccount:cka-exercises:app-sa \
  -n cka-exercises

Point clé : Le flag --serviceaccount de kubectl run est déprécié. Utiliser un manifest YAML avec serviceAccountName.

---

Workloads & Scheduling (15%)

Exercice 7 : Taints, Tolerations et placement garanti

Temps cible : 6 minutes

Contexte	Node worker1 disponible
Tâche	Ajouter un taint env=prod:NoSchedule sur worker1, créer un Pod prod-app qui tolère ce taint et qui est garanti d’être placé sur worker1
Contrainte	La toleration seule ne garantit pas le placement — il faut aussi un nodeSelector
Validation	kubectl get pod prod-app -o wide montre worker1 dans la colonne NODE

Glissez pour voir

Solution

# Taint
kubectl taint node worker1 env=prod:NoSchedule

# Pod avec toleration ET nodeSelector
kubectl apply -f - <<'EOF'
apiVersion: v1
kind: Pod
metadata:
  name: prod-app
  namespace: cka-exercises
spec:
  nodeSelector:
    kubernetes.io/hostname: worker1
  tolerations:
  - key: env
    operator: Equal
    value: prod
    effect: NoSchedule
  containers:
  - name: nginx
    image: nginx
EOF

# Validation
kubectl get pod prod-app -n cka-exercises -o wide | grep worker1

# Nettoyage
kubectl taint node worker1 env-

Point clé : Une toleration permet de scheduler sur un node tainté, mais ne garantit pas le placement. Pour garantir, ajouter un nodeSelector ou nodeAffinity.

---

Exercice 8 : Node Affinity

Temps cible : 5 minutes

Contexte	Node worker1 disponible
Tâche	Labeler worker1 avec disktype=ssd, créer un Deployment storage-app (3 replicas, nginx) qui préfère les nodes avec ce label
Validation	kubectl get pods -o wide montre les pods sur worker1 (si disponible)

Glissez pour voir

Solution

# Label
kubectl label node worker1 disktype=ssd

# Deployment
kubectl apply -f - <<'EOF'
apiVersion: apps/v1
kind: Deployment
metadata:
  name: storage-app
  namespace: cka-exercises
spec:
  replicas: 3
  selector:
    matchLabels:
      app: storage-app
  template:
    metadata:
      labels:
        app: storage-app
    spec:
      affinity:
        nodeAffinity:
          preferredDuringSchedulingIgnoredDuringExecution:
          - weight: 100
            preference:
              matchExpressions:
              - key: disktype
                operator: In
                values:
                - ssd
      containers:
      - name: nginx
        image: nginx
EOF

# Validation
kubectl get pods -n cka-exercises -o wide

---

Exercice 9 : Drain et Cordon

Temps cible : 3 minutes

Contexte	Node worker1 avec des pods
Tâche	Cordon, drain, puis uncordon worker1
Validation	kubectl get nodes montre worker1 Ready sans SchedulingDisabled

Glissez pour voir

Solution

kubectl cordon worker1
kubectl drain worker1 --ignore-daemonsets --delete-emptydir-data
kubectl uncordon worker1
kubectl get nodes

---

Services & Networking (20%)

CNI requis pour NetworkPolicies

Les exercices NetworkPolicy nécessitent un CNI qui supporte les NetworkPolicies : Calico, Cilium, Weave. Flannel seul ne supporte pas les policies.

Exercice 10 : Service ClusterIP

Temps cible : 3 minutes

Contexte	Namespace cka-exercises
Tâche	Créer un Deployment web (2 replicas, nginx), l’exposer en ClusterIP sur port 80
Validation	kubectl run test --rm -it --image=busybox:1.36 -- wget -qO- web retourne du HTML

Glissez pour voir

Solution

kubectl create deploy web --image=nginx --replicas=2 -n cka-exercises
kubectl expose deploy web --port=80 -n cka-exercises

# Validation
kubectl run test --rm -it --image=busybox:1.36 -n cka-exercises -- wget -qO- web

---

Exercice 11 : NetworkPolicy Deny All

Temps cible : 4 minutes

Contexte	Namespace cka-exercises avec le Deployment web
Tâche	Créer une NetworkPolicy deny-all bloquant tout trafic ingress et egress dans le namespace
Validation	kubectl describe netpol deny-all montre Allowing ingress traffic: <none>

Glissez pour voir

Solution

kubectl apply -f - <<'EOF'
apiVersion: networking.k8s.io/v1
kind: NetworkPolicy
metadata:
  name: deny-all
  namespace: cka-exercises
spec:
  podSelector: {}
  policyTypes:
  - Ingress
  - Egress
EOF

# Validation
kubectl describe netpol deny-all -n cka-exercises

---

Exercice 12 : NetworkPolicy Allow specific

Temps cible : 6 minutes

Contexte	Deployment web avec label app=web dans cka-exercises
Tâche	Créer une NetworkPolicy allow-frontend autorisant le trafic ingress sur port 80 uniquement depuis les pods avec label role=frontend
Contrainte	Le podSelector de la policy doit cibler app=web
Validation	Un pod avec role=frontend peut accéder à web, un pod sans ce label ne peut pas

Glissez pour voir

Solution

kubectl apply -f - <<'EOF'
apiVersion: networking.k8s.io/v1
kind: NetworkPolicy
metadata:
  name: allow-frontend
  namespace: cka-exercises
spec:
  podSelector:
    matchLabels:
      app: web
  policyTypes:
  - Ingress
  ingress:
  - from:
    - podSelector:
        matchLabels:
          role: frontend
    ports:
    - protocol: TCP
      port: 80
EOF

# Test positif
kubectl run frontend --image=busybox:1.36 -n cka-exercises \
  --labels="role=frontend" --rm -it -- wget -qO- --timeout=2 web

# Test négatif (doit timeout)
kubectl run other --image=busybox:1.36 -n cka-exercises \
  --rm -it -- wget -qO- --timeout=2 web

Point clé : Vérifier que les labels dans le podSelector correspondent aux labels réels des pods target.

---

Exercice 13 : Ingress

Temps cible : 5 minutes

Contexte	Service web exposé sur port 80
Tâche	Créer un Ingress web-ingress routant web.example.com/ vers le service web port 80
Contrainte	Utiliser ingressClassName: nginx
Validation	kubectl get ingress web-ingress montre l’Ingress créé

Glissez pour voir

Solution

kubectl apply -f - <<'EOF'
apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
  name: web-ingress
  namespace: cka-exercises
spec:
  ingressClassName: nginx
  rules:
  - host: web.example.com
    http:
      paths:
      - path: /
        pathType: Prefix
        backend:
          service:
            name: web
            port:
              number: 80
EOF

# Validation
kubectl get ingress web-ingress -n cka-exercises

---

Storage (10%)

Exercice 14 : PersistentVolume et PVC

Temps cible : 7 minutes

Contexte	StorageClass manual pour hostPath
Tâche	Créer un PV pv-data (1Gi, RWO, hostPath /data/pv-data), un PVC pvc-data (500Mi), et un Pod storage-pod montant le PVC
Validation	kubectl get pv montre BOUND, kubectl get pvc -n cka-exercises montre BOUND

Glissez pour voir

Solution

# PV (cluster-scoped, pas de namespace)
kubectl apply -f - <<'EOF'
apiVersion: v1
kind: PersistentVolume
metadata:
  name: pv-data
spec:
  capacity:
    storage: 1Gi
  accessModes:
    - ReadWriteOnce
  persistentVolumeReclaimPolicy: Retain
  storageClassName: manual
  hostPath:
    path: /data/pv-data
EOF

# PVC (namespaced)
kubectl apply -f - <<'EOF'
apiVersion: v1
kind: PersistentVolumeClaim
metadata:
  name: pvc-data
  namespace: cka-exercises
spec:
  accessModes:
    - ReadWriteOnce
  resources:
    requests:
      storage: 500Mi
  storageClassName: manual
EOF

# Pod
kubectl apply -f - <<'EOF'
apiVersion: v1
kind: Pod
metadata:
  name: storage-pod
  namespace: cka-exercises
spec:
  containers:
  - name: app
    image: nginx
    volumeMounts:
    - name: data
      mountPath: /data
  volumes:
  - name: data
    persistentVolumeClaim:
      claimName: pvc-data
EOF

# Validation
kubectl get pv                          # cluster-scoped
kubectl get pvc -n cka-exercises        # namespaced

Point clé : Les PV sont cluster-scoped (kubectl get pv sans -n). Les PVC sont namespaced (kubectl get pvc -n <ns>).

---

Troubleshooting (30%)

C’est le domaine le plus important de l’examen : 30% des points.

Exercice 15 : Pod ImagePullBackOff

Temps cible : 3 minutes

Contexte	Pod broken-pod avec image nginx:nonexistent-tag
Tâche	Diagnostiquer et corriger le Pod
Validation	kubectl get pod broken-pod montre Running

Glissez pour voir

Solution

# Créer le problème
kubectl run broken-pod --image=nginx:nonexistent-tag -n cka-exercises

# Diagnostic
kubectl get pod broken-pod -n cka-exercises
kubectl describe pod broken-pod -n cka-exercises | tail -10

# Correction
kubectl set image pod/broken-pod broken-pod=nginx -n cka-exercises

# Validation
kubectl get pod broken-pod -n cka-exercises

---

Exercice 16 : Node NotReady [kubeadm]

Temps cible : 8 minutes

Contexte	Node worker1 en status NotReady
Tâche	Identifier la cause et réparer le node
Simulation	Sur worker1 : systemctl stop kubelet
Validation	kubectl get nodes montre worker1 Ready

Glissez pour voir

Solution

# Diagnostic depuis le control plane
kubectl get nodes
kubectl describe node worker1 | grep -A5 Conditions

# SSH vers le worker
ssh worker1

# Vérifier kubelet
systemctl status kubelet
journalctl -u kubelet --since "5 minutes ago" | tail -20

# Réparer
systemctl start kubelet
systemctl status kubelet

# Retour sur le control plane
exit
kubectl get nodes

---

Exercice 17 : Service sans endpoints

Temps cible : 4 minutes

Contexte	Service broken-svc avec selector app=myapp, Pod avec label application=myapp
Tâche	Diagnostiquer pourquoi le Service n’a pas d’endpoints et corriger
Validation	kubectl get endpoints broken-svc montre une IP

Glissez pour voir

Solution

# Créer le problème
kubectl apply -f - <<'EOF'
apiVersion: v1
kind: Service
metadata:
  name: broken-svc
  namespace: cka-exercises
spec:
  selector:
    app: myapp
  ports:
  - port: 80
---
apiVersion: v1
kind: Pod
metadata:
  name: myapp-pod
  namespace: cka-exercises
  labels:
    application: myapp
spec:
  containers:
  - name: nginx
    image: nginx
EOF

# Diagnostic
kubectl get endpoints broken-svc -n cka-exercises
kubectl describe svc broken-svc -n cka-exercises | grep Selector
kubectl get pod myapp-pod -n cka-exercises --show-labels

# Correction (labels ne matchent pas)
kubectl label pod myapp-pod -n cka-exercises app=myapp

# Validation
kubectl get endpoints broken-svc -n cka-exercises

---

Exercice 18 : kubelet ne démarre pas [kubeadm]

Temps cible : 8 minutes

Contexte	Node worker ne rejoint pas le cluster
Tâche	Le kubelet ne démarre pas. Identifier la cause et réparer
Indices	Vérifier les logs kubelet avec journalctl -u kubelet
Validation	kubectl get nodes montre le node Ready

Glissez pour voir

Solution

# Sur le worker - vérifier le status
systemctl status kubelet

# Voir les logs
journalctl -u kubelet --no-pager | tail -50

# Causes courantes et corrections :
# 1. Fichier de config manquant
ls -la /var/lib/kubelet/config.yaml
ls -la /etc/kubernetes/kubelet.conf

# 2. Container runtime non démarré
systemctl status containerd
systemctl start containerd

# 3. Swap activé (interdit par défaut)
swapoff -a

# 4. Erreur de configuration
cat /var/lib/kubelet/config.yaml

# Redémarrer kubelet après correction
systemctl restart kubelet
systemctl status kubelet

---

Exercice 19 : API Server inaccessible [kubeadm]

Temps cible : 10 minutes

Contexte	kubectl retourne connection refused
Tâche	L’API Server ne répond pas. Diagnostiquer et réparer
Simulation	Modifier /etc/kubernetes/manifests/kube-apiserver.yaml pour introduire une erreur
Validation	kubectl get nodes fonctionne

Glissez pour voir

Solution

# 1. Vérifier si le container tourne
crictl ps | grep kube-apiserver
# Si vide → le pod static n'a pas démarré

# 2. Vérifier les logs du container mort
crictl ps -a | grep kube-apiserver
crictl logs <container-id>

# Ou via les logs du pod static
ls /var/log/pods/kube-system_kube-apiserver-*/
cat /var/log/pods/kube-system_kube-apiserver-*/kube-apiserver/*.log | tail -50

# 3. Vérifier le manifest
cat /etc/kubernetes/manifests/kube-apiserver.yaml

# Erreurs courantes :
# - Port incorrect (--secure-port)
# - Chemin de certificat erroné (--tls-cert-file)
# - Typo dans une option

# 4. Corriger le manifest
vim /etc/kubernetes/manifests/kube-apiserver.yaml

# 5. Le kubelet redémarre automatiquement le pod static
# Attendre 30-60 secondes
sleep 30

# 6. Validation
kubectl get nodes

Point clé : Les composants du control plane sont des pods statiques. Modifier le manifest dans /etc/kubernetes/manifests/ déclenche un redémarrage automatique par le kubelet.

---

Exercice 20 : CoreDNS — Pods en crash

Temps cible : 5 minutes

Contexte	La résolution DNS ne fonctionne pas
Tâche	Les pods CoreDNS sont en CrashLoopBackOff. Diagnostiquer et réparer
Validation	kubectl run test --rm -it --image=busybox:1.36 -- nslookup kubernetes retourne une IP

Glissez pour voir

Solution

# Diagnostic
kubectl get pods -n kube-system -l k8s-app=kube-dns
kubectl logs -n kube-system -l k8s-app=kube-dns --tail=20

# Si crash loop, redémarrer le deployment
kubectl rollout restart deploy coredns -n kube-system

# Attendre que les pods soient Ready
kubectl get pods -n kube-system -l k8s-app=kube-dns -w

# Validation
kubectl run test --rm -it --image=busybox:1.36 -- nslookup kubernetes

---

Exercice 21 : CoreDNS — ConfigMap corrompu

Temps cible : 6 minutes

Contexte	CoreDNS pods Running mais résolution DNS échoue
Tâche	Le ConfigMap coredns contient une erreur. Identifier et corriger
Validation	kubectl run test --rm -it --image=busybox:1.36 -- nslookup kubernetes retourne une IP

Glissez pour voir

Solution

# Vérifier le ConfigMap
kubectl get cm coredns -n kube-system -o yaml

# Chercher les erreurs de syntaxe dans le Corefile
# Erreurs courantes :
# - Bloc mal fermé
# - Directive inconnue
# - Mauvais format d'upstream

# Sauvegarder et corriger
kubectl get cm coredns -n kube-system -o yaml > coredns-backup.yaml
kubectl edit cm coredns -n kube-system

# Redémarrer CoreDNS pour appliquer
kubectl rollout restart deploy coredns -n kube-system

# Validation
kubectl run test --rm -it --image=busybox:1.36 -- nslookup kubernetes

---

Exercice 22 : CoreDNS — Service kube-dns absent

Temps cible : 5 minutes

Contexte	Pods CoreDNS Running mais le service kube-dns n’existe pas
Tâche	Recréer le service kube-dns pour que la résolution fonctionne
Contrainte	Le service doit cibler les pods CoreDNS et exposer les ports 53 TCP/UDP
Validation	kubectl get endpoints kube-dns -n kube-system montre des IPs

Glissez pour voir

Solution

# Vérifier que le service n'existe pas
kubectl get svc kube-dns -n kube-system

# Recréer le service
kubectl apply -f - <<'EOF'
apiVersion: v1
kind: Service
metadata:
  name: kube-dns
  namespace: kube-system
  labels:
    k8s-app: kube-dns
spec:
  selector:
    k8s-app: kube-dns
  clusterIP: 10.96.0.10
  ports:
  - name: dns
    port: 53
    protocol: UDP
  - name: dns-tcp
    port: 53
    protocol: TCP
EOF

# Validation
kubectl get svc,endpoints kube-dns -n kube-system
kubectl run test --rm -it --image=busybox:1.36 -- nslookup kubernetes

Point clé : L’IP du service kube-dns (souvent 10.96.0.10) est configurée dans le kubelet. Recréer le service avec la même IP cluster.

---

Récapitulatif des temps

#	Exercice	Domaine	Temps	Type
1	Upgrade cluster	Architecture	15 min	kubeadm
2	Backup etcd	Architecture	6 min	kubeadm
3	Restore etcd	Architecture	10 min	kubeadm
4	Role et RoleBinding	RBAC	4 min	générique
5	ClusterRole nodes	RBAC	4 min	générique
6	ServiceAccount	RBAC	5 min	générique
7	Taints + placement	Scheduling	6 min	générique
8	Node Affinity	Scheduling	5 min	générique
9	Drain et Cordon	Scheduling	3 min	générique
10	Service ClusterIP	Networking	3 min	générique
11	NetworkPolicy Deny	Networking	4 min	générique
12	NetworkPolicy Allow	Networking	6 min	générique
13	Ingress	Networking	5 min	générique
14	PV et PVC	Storage	7 min	générique
15	ImagePullBackOff	Troubleshooting	3 min	générique
16	Node NotReady	Troubleshooting	8 min	kubeadm
17	Service endpoints	Troubleshooting	4 min	générique
18	kubelet crash	Troubleshooting	8 min	kubeadm
19	API Server down	Troubleshooting	10 min	kubeadm
20	CoreDNS crash	Troubleshooting	5 min	générique
21	CoreDNS config	Troubleshooting	6 min	générique
22	CoreDNS service	Troubleshooting	5 min	générique

Glissez pour voir

Temps total : ~132 minutes

L’examen CKA dure 2 heures (120 min). Si vous complétez ces exercices en moins de 110 minutes avec 80%+ de réussite, vous êtes prêt.

---

Nettoyage

kubectl delete ns cka-exercises
kubectl taint node worker1 env- 2>/dev/null
kubectl label node worker1 disktype- 2>/dev/null

---

À retenir

1. etcdutl pour restore (pas etcdctl restore déprécié)
2. Upgrade vers la dernière patch (1.31.4), pas la .0
3. serviceAccountName dans le YAML (pas --serviceaccount)
4. Toleration ≠ placement garanti — ajouter nodeSelector
5. PV cluster-scoped, PVC namespaced
6. Pods statiques : modifier le manifest → redémarrage auto
7. CoreDNS : 3 points de défaillance (pods, config, service)
8. Alias CKA : k, kn, $do, $now

---

Prochaines étapes

Commandes essentielles CKA Mémo des commandes à connaître par cœur

Guide de préparation CKA Stratégie complète pour réussir l'examen

Killer.sh Simulateur officiel inclus avec l'inscription

×

📖 Voir la documentation →