Exercices CKAD — Entraînement chronométré

Entraînement brutal, précis, rapide. Ces exercices reproduisent les types de tâches et les patterns récurrents de la CKAD. Chronométrez-vous et visez 80% de réussite.

Prérequis

Cluster Kubernetes fonctionnel (Kind, Minikube, K3s). L’examen CKAD dure 2 heures et est aligné sur Kubernetes v1.35.

Réflexes CKAD

Configurez votre environnement avant de commencer :

# Alias essentiels
alias k=kubectl
alias kn='kubectl config set-context --current --namespace'
alias kgp='kubectl get pods'
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 ckad-exercises
kn ckad-exercises

Commandes critiques à connaître par cœur

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

# Vérifier / observer
kubectl logs <pod> --previous
kubectl describe pod <pod> | tail -20
kubectl get events --sort-by='.lastTimestamp'

# Modifier rapidement
kubectl set image deploy/<name> <container>=<image>
kubectl rollout status deploy/<name>
kubectl rollout undo deploy/<name>

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

---

Application Design & Build (20%)

Exercice 1 : Pod multi-conteneurs (sidecar)

Temps cible : 4 minutes

Contexte	Namespace ckad-exercises
Tâche	Créer un Pod log-processor avec un conteneur app (busybox:1.36) qui écrit “Processing…” dans /logs/app.log toutes les 5s, et un sidecar reader qui lit ce fichier en continu
Contrainte	Les deux conteneurs partagent un volume emptyDir monté sur /logs
Validation	kubectl logs log-processor -c reader affiche “Processing…”

Glissez pour voir

Solution

kubectl apply -f - <<'EOF'
apiVersion: v1
kind: Pod
metadata:
  name: log-processor
  namespace: ckad-exercises
spec:
  containers:
  - name: app
    image: busybox:1.36
    command: ['sh', '-c', 'while true; do echo "Processing..." >> /logs/app.log; sleep 5; done']
    volumeMounts:
    - name: logs
      mountPath: /logs
  - name: reader
    image: busybox:1.36
    command: ['sh', '-c', 'tail -f /logs/app.log']
    volumeMounts:
    - name: logs
      mountPath: /logs
  volumes:
  - name: logs
    emptyDir: {}
EOF

# Validation
kubectl logs log-processor -c reader -n ckad-exercises

---

Exercice 2 : Init Container

Temps cible : 3 minutes

Contexte	Namespace ckad-exercises
Tâche	Créer un Pod web-init avec un init container init-config qui crée /config/app.conf contenant “ready=true”, puis un conteneur web (nginx:1.25) qui monte ce volume
Contrainte	Volume emptyDir nommé config, monté sur /config (init) et /etc/app (web)
Validation	kubectl exec web-init -- cat /etc/app/app.conf retourne “ready=true”

Glissez pour voir

Solution

kubectl apply -f - <<'EOF'
apiVersion: v1
kind: Pod
metadata:
  name: web-init
  namespace: ckad-exercises
spec:
  initContainers:
  - name: init-config
    image: busybox:1.36
    command: ['sh', '-c', 'echo "ready=true" > /config/app.conf']
    volumeMounts:
    - name: config
      mountPath: /config
  containers:
  - name: web
    image: nginx:1.25
    volumeMounts:
    - name: config
      mountPath: /etc/app
  volumes:
  - name: config
    emptyDir: {}
EOF

# Validation
kubectl exec web-init -n ckad-exercises -- cat /etc/app/app.conf

---

Application Deployment (20%)

Exercice 3 : Deployment avec label explicite

Temps cible : 4 minutes

Contexte	Namespace ckad-exercises
Tâche	Créer un Deployment api avec 3 replicas, image nginx:1.24, et le label app=api sur les Pods. Ajouter des requests CPU (100m) pour préparer le HPA
Contrainte	Le label app=api doit être explicitement défini (pas le label auto app=api)
Validation	kubectl get pods -l app=api affiche 3 pods

Glissez pour voir

Solution

kubectl apply -f - <<'EOF'
apiVersion: apps/v1
kind: Deployment
metadata:
  name: api
  namespace: ckad-exercises
spec:
  replicas: 3
  selector:
    matchLabels:
      app: api
  template:
    metadata:
      labels:
        app: api
    spec:
      containers:
      - name: nginx
        image: nginx:1.24
        resources:
          requests:
            cpu: 100m
EOF

# Validation
kubectl get pods -l app=api -n ckad-exercises

Point clé : kubectl create deploy génère le label app=<name> automatiquement, mais ici on le définit explicitement pour contrôler les selectors.

---

Exercice 4 : Rolling Update et Rollback

Temps cible : 3 minutes

Contexte	Deployment api créé à l’exercice 3
Tâche	Mettre à jour l’image vers nginx:1.25 avec maxSurge=1 et maxUnavailable=0, puis rollback vers nginx:1.24
Validation	kubectl get deploy api -o jsonpath='{.spec.template.spec.containers[0].image}' retourne nginx:1.24

Glissez pour voir

Solution

# Appliquer la stratégie
kubectl patch deploy api -n ckad-exercises -p '{"spec":{"strategy":{"type":"RollingUpdate","rollingUpdate":{"maxSurge":1,"maxUnavailable":0}}}}'

# Mise à jour
kubectl set image deploy api nginx=nginx:1.25 -n ckad-exercises
kubectl rollout status deploy api -n ckad-exercises

# Rollback
kubectl rollout undo deploy api -n ckad-exercises

# Validation
kubectl get deploy api -n ckad-exercises -o jsonpath='{.spec.template.spec.containers[0].image}'

---

Exercice 5 : Horizontal Pod Autoscaler

Temps cible : 3 minutes

Contexte	Deployment api avec requests CPU définies
Tâche	Créer un HPA api-hpa : min 2, max 10, target CPU 70%
Contrainte	Nécessite un Metrics Server opérationnel
Validation	kubectl get hpa api-hpa affiche le HPA

Glissez pour voir

Solution

kubectl autoscale deploy api -n ckad-exercises --name=api-hpa --min=2 --max=10 --cpu-percent=70

# Validation
kubectl get hpa api-hpa -n ckad-exercises

Point clé : Un HPA basé sur CPU nécessite des resources.requests.cpu sur les Pods et un Metrics Server fonctionnel.

---

Application Observability & Maintenance (15%)

Exercice 6 : Probes complètes

Temps cible : 5 minutes

Contexte	Namespace ckad-exercises
Tâche	Créer un Pod health-check (nginx:1.25) avec liveness (HTTP GET /, délai 10s, période 5s), readiness (délai 5s, période 3s), startup (failureThreshold 30, période 2s)
Validation	kubectl describe pod health-check montre les 3 probes configurées

Glissez pour voir

Solution

kubectl apply -f - <<'EOF'
apiVersion: v1
kind: Pod
metadata:
  name: health-check
  namespace: ckad-exercises
spec:
  containers:
  - name: nginx
    image: nginx:1.25
    ports:
    - containerPort: 80
    livenessProbe:
      httpGet:
        path: /
        port: 80
      initialDelaySeconds: 10
      periodSeconds: 5
    readinessProbe:
      httpGet:
        path: /
        port: 80
      initialDelaySeconds: 5
      periodSeconds: 3
    startupProbe:
      httpGet:
        path: /
        port: 80
      failureThreshold: 30
      periodSeconds: 2
EOF

# Validation
kubectl describe pod health-check -n ckad-exercises | grep -E "Liveness|Readiness|Startup"

---

Exercice 7 : Debugging — ConfigMap manquant

Temps cible : 4 minutes

Contexte	Pod broken-app ne démarre pas
Tâche	Diagnostiquer pourquoi le Pod reste en Pending/Error, créer la ressource manquante, et faire démarrer le Pod
Validation	kubectl get pod broken-app affiche Running

Glissez pour voir

Créez d’abord le Pod problématique :

kubectl apply -f - <<'EOF'
apiVersion: v1
kind: Pod
metadata:
  name: broken-app
  namespace: ckad-exercises
spec:
  containers:
  - name: app
    image: nginx:1.25
    command: ['sh', '-c', 'cat /config/settings.conf && nginx -g "daemon off;"']
    volumeMounts:
    - name: config
      mountPath: /config
  volumes:
  - name: config
    configMap:
      name: app-settings
EOF

Solution

# Diagnostic
kubectl describe pod broken-app -n ckad-exercises | tail -15
# Event: configmap "app-settings" not found

# Créer le ConfigMap manquant
kubectl create cm app-settings -n ckad-exercises --from-literal=settings.conf="debug=true"

# Recréer le Pod (le Pod existant reste bloqué)
kubectl delete pod broken-app -n ckad-exercises $now
kubectl apply -f - <<'EOF'
apiVersion: v1
kind: Pod
metadata:
  name: broken-app
  namespace: ckad-exercises
spec:
  containers:
  - name: app
    image: nginx:1.25
    command: ['sh', '-c', 'cat /config/settings.conf && nginx -g "daemon off;"']
    volumeMounts:
    - name: config
      mountPath: /config
  volumes:
  - name: config
    configMap:
      name: app-settings
EOF

# Validation
kubectl get pod broken-app -n ckad-exercises

---

Environment, Configuration & Security (25%)

Exercice 8 : ConfigMap comme variables d’environnement

Temps cible : 3 minutes

Contexte	Namespace ckad-exercises
Tâche	Créer un ConfigMap db-config avec DB_HOST=mysql.default.svc et DB_PORT=3306, puis un Pod backend (busybox:1.36) qui injecte ces valeurs comme variables d’environnement
Validation	kubectl logs backend affiche DB_HOST=mysql.default.svc

Glissez pour voir

Solution

kubectl create cm db-config -n ckad-exercises \
  --from-literal=DB_HOST=mysql.default.svc \
  --from-literal=DB_PORT=3306

kubectl apply -f - <<'EOF'
apiVersion: v1
kind: Pod
metadata:
  name: backend
  namespace: ckad-exercises
spec:
  containers:
  - name: backend
    image: busybox:1.36
    command: ['sh', '-c', 'env | grep DB_ && sleep 3600']
    envFrom:
    - configMapRef:
        name: db-config
EOF

# Validation
kubectl logs backend -n ckad-exercises | grep DB_

---

Exercice 9 : Secret comme fichier

Temps cible : 4 minutes

Contexte	Namespace ckad-exercises
Tâche	Créer un Secret api-creds avec username=admin et token=abc123xyz, puis un Pod api-client qui monte ce Secret dans /etc/credentials en lecture seule
Validation	kubectl exec api-client -- cat /etc/credentials/username retourne admin

Glissez pour voir

Solution

kubectl create secret generic api-creds -n ckad-exercises \
  --from-literal=username=admin \
  --from-literal=token=abc123xyz

kubectl apply -f - <<'EOF'
apiVersion: v1
kind: Pod
metadata:
  name: api-client
  namespace: ckad-exercises
spec:
  containers:
  - name: client
    image: busybox:1.36
    command: ['sh', '-c', 'ls /etc/credentials && sleep 3600']
    volumeMounts:
    - name: creds
      mountPath: /etc/credentials
      readOnly: true
  volumes:
  - name: creds
    secret:
      secretName: api-creds
EOF

# Validation
kubectl exec api-client -n ckad-exercises -- cat /etc/credentials/username

---

Exercice 10 : Requests et Limits

Temps cible : 3 minutes

Contexte	Namespace ckad-exercises
Tâche	Créer un Pod resource-pod (nginx:1.25) avec requests 100m CPU / 128Mi RAM et limits 200m CPU / 256Mi RAM
Validation	kubectl describe pod resource-pod montre les resources configurées

Glissez pour voir

Solution

kubectl apply -f - <<'EOF'
apiVersion: v1
kind: Pod
metadata:
  name: resource-pod
  namespace: ckad-exercises
spec:
  containers:
  - name: nginx
    image: nginx:1.25
    resources:
      requests:
        cpu: 100m
        memory: 128Mi
      limits:
        cpu: 200m
        memory: 256Mi
EOF

# Validation
kubectl describe pod resource-pod -n ckad-exercises | grep -A4 "Limits\|Requests"

---

Exercice 11 : ServiceAccount sans token auto-monté

Temps cible : 4 minutes

Contexte	Namespace ckad-exercises
Tâche	Créer un ServiceAccount app-sa, puis un Pod sa-pod (nginx:1.25) qui utilise ce SA avec automountServiceAccountToken: false
Validation	kubectl exec sa-pod -- ls /var/run/secrets/kubernetes.io/serviceaccount échoue (répertoire inexistant)

Glissez pour voir

Solution

kubectl create sa app-sa -n ckad-exercises

kubectl apply -f - <<'EOF'
apiVersion: v1
kind: Pod
metadata:
  name: sa-pod
  namespace: ckad-exercises
spec:
  serviceAccountName: app-sa
  automountServiceAccountToken: false
  containers:
  - name: nginx
    image: nginx:1.25
EOF

# Validation
kubectl exec sa-pod -n ckad-exercises -- ls /var/run/secrets/kubernetes.io/serviceaccount 2>&1 | grep -i "no such"

---

Exercice 12 : SecurityContext

Temps cible : 4 minutes

Contexte	Namespace ckad-exercises
Tâche	Créer un Pod secure-pod (busybox:1.36) avec runAsUser 1000, runAsGroup 3000, fsGroup 2000, et readOnlyRootFilesystem true
Validation	kubectl logs secure-pod affiche uid=1000 gid=3000 groups=2000

Glissez pour voir

Solution

kubectl apply -f - <<'EOF'
apiVersion: v1
kind: Pod
metadata:
  name: secure-pod
  namespace: ckad-exercises
spec:
  securityContext:
    runAsUser: 1000
    runAsGroup: 3000
    fsGroup: 2000
  containers:
  - name: secure
    image: busybox:1.36
    command: ['sh', '-c', 'id && sleep 3600']
    securityContext:
      readOnlyRootFilesystem: true
EOF

# Validation
kubectl logs secure-pod -n ckad-exercises

---

Exercice 13 : PersistentVolumeClaim

Temps cible : 5 minutes

Contexte	Namespace ckad-exercises
Tâche	Créer un PVC data-pvc (500Mi, RWO, StorageClass default), puis un Pod data-pod (nginx:1.25) qui monte ce PVC dans /data
Contrainte	Le StorageClass doit supporter le provisionnement dynamique (standard sur Kind/Minikube)
Validation	kubectl get pvc data-pvc montre Bound

Glissez pour voir

Solution

kubectl apply -f - <<'EOF'
apiVersion: v1
kind: PersistentVolumeClaim
metadata:
  name: data-pvc
  namespace: ckad-exercises
spec:
  accessModes:
  - ReadWriteOnce
  resources:
    requests:
      storage: 500Mi
---
apiVersion: v1
kind: Pod
metadata:
  name: data-pod
  namespace: ckad-exercises
spec:
  containers:
  - name: nginx
    image: nginx:1.25
    volumeMounts:
    - name: data
      mountPath: /data
  volumes:
  - name: data
    persistentVolumeClaim:
      claimName: data-pvc
EOF

# Validation
kubectl get pvc data-pvc -n ckad-exercises
kubectl exec data-pod -n ckad-exercises -- df -h /data

---

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 14 : Service ClusterIP

Temps cible : 2 minutes

Contexte	Deployment api avec label app=api
Tâche	Créer un Service api-svc de type ClusterIP exposant le Deployment sur port 8080 → port 80 des Pods
Contrainte	Le selector doit être app=api
Validation	kubectl get endpoints api-svc montre des IPs

Glissez pour voir

Solution

kubectl apply -f - <<'EOF'
apiVersion: v1
kind: Service
metadata:
  name: api-svc
  namespace: ckad-exercises
spec:
  selector:
    app: api
  ports:
  - port: 8080
    targetPort: 80
EOF

# Validation
kubectl get svc,endpoints api-svc -n ckad-exercises

---

Exercice 15 : Service NodePort

Temps cible : 3 minutes

Contexte	Namespace ckad-exercises
Tâche	Créer un nouveau Deployment web (2 replicas, nginx:1.25, label app=web) et un Service NodePort web-np sur port 30080
Validation	kubectl get svc web-np montre type NodePort avec port 30080

Glissez pour voir

Solution

kubectl create deploy web --image=nginx:1.25 --replicas=2 -n ckad-exercises

kubectl apply -f - <<'EOF'
apiVersion: v1
kind: Service
metadata:
  name: web-np
  namespace: ckad-exercises
spec:
  type: NodePort
  selector:
    app: web
  ports:
  - port: 80
    targetPort: 80
    nodePort: 30080
EOF

# Validation
kubectl get svc web-np -n ckad-exercises

---

Exercice 16 : Ingress

Temps cible : 4 minutes

Contexte	Service web-np exposant le Deployment web
Tâche	Créer un Ingress web-ingress routant web.example.com/ vers le Service web-np 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: ckad-exercises
spec:
  ingressClassName: nginx
  rules:
  - host: web.example.com
    http:
      paths:
      - path: /
        pathType: Prefix
        backend:
          service:
            name: web-np
            port:
              number: 80
EOF

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

Note : L’API Ingress reste pertinente pour la CKAD, même si l’écosystème évolue vers Gateway API.

---

Exercice 17 : NetworkPolicy — Allow specific

Temps cible : 5 minutes

Contexte	Deployment api avec label app=api
Tâche	Créer une NetworkPolicy api-policy autorisant le trafic ingress sur port 80 uniquement depuis les Pods avec label role=frontend
Contrainte	Le CNI doit supporter les NetworkPolicies
Validation	kubectl describe netpol api-policy montre la règle

Glissez pour voir

Solution

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

# Test
kubectl run frontend --image=busybox:1.36 -n ckad-exercises \
  --labels="role=frontend" --rm -it -- wget -qO- --timeout=2 api-svc:8080

# Validation
kubectl describe netpol api-policy -n ckad-exercises

---

Batch Jobs (partie de Design & Build)

Exercice 18 : Job avec parallélisme

Temps cible : 3 minutes

Contexte	Namespace ckad-exercises
Tâche	Créer un Job batch-job exécutant 5 tâches (completions), max 2 en parallèle, image busybox:1.36, commande echo "Task done" && sleep 5
Validation	kubectl get job batch-job montre 5/5 completions

Glissez pour voir

Solution

kubectl apply -f - <<'EOF'
apiVersion: batch/v1
kind: Job
metadata:
  name: batch-job
  namespace: ckad-exercises
spec:
  completions: 5
  parallelism: 2
  template:
    spec:
      containers:
      - name: worker
        image: busybox:1.36
        command: ['sh', '-c', 'echo "Task done" && sleep 5']
      restartPolicy: Never
EOF

# Observer
kubectl get pods -n ckad-exercises -l job-name=batch-job -w

---

Exercice 19 : CronJob

Temps cible : 3 minutes

Contexte	Namespace ckad-exercises
Tâche	Créer un CronJob cleanup-job qui s’exécute toutes les 5 minutes, conserve 3 jobs réussis et 1 échoué, commande echo "Cleanup at $(date)"
Validation	kubectl get cronjob cleanup-job montre le schedule */5 * * * *

Glissez pour voir

Solution

kubectl apply -f - <<'EOF'
apiVersion: batch/v1
kind: CronJob
metadata:
  name: cleanup-job
  namespace: ckad-exercises
spec:
  schedule: "*/5 * * * *"
  successfulJobsHistoryLimit: 3
  failedJobsHistoryLimit: 1
  jobTemplate:
    spec:
      template:
        spec:
          containers:
          - name: cleanup
            image: busybox:1.36
            command: ['sh', '-c', 'echo "Cleanup at $(date)"']
          restartPolicy: OnFailure
EOF

# Validation
kubectl get cronjob cleanup-job -n ckad-exercises

---

Exercice 20 : Blue-Green avec Services

Temps cible : 5 minutes

Contexte	Namespace ckad-exercises
Tâche	Créer deux Deployments app-blue (nginx:1.24, label version=blue) et app-green (nginx:1.25, label version=green), puis un Service app-prod pointant vers blue. Basculer vers green
Validation	Après bascule, kubectl get endpoints app-prod montre les IPs des Pods green

Glissez pour voir

Solution

# Créer les deux versions
kubectl create deploy app-blue --image=nginx:1.24 --replicas=2 -n ckad-exercises
kubectl label deploy app-blue -n ckad-exercises version=blue
kubectl patch deploy app-blue -n ckad-exercises -p '{"spec":{"template":{"metadata":{"labels":{"version":"blue"}}}}}'

kubectl create deploy app-green --image=nginx:1.25 --replicas=2 -n ckad-exercises
kubectl label deploy app-green -n ckad-exercises version=green
kubectl patch deploy app-green -n ckad-exercises -p '{"spec":{"template":{"metadata":{"labels":{"version":"green"}}}}}'

# Service pointant vers blue
kubectl apply -f - <<'EOF'
apiVersion: v1
kind: Service
metadata:
  name: app-prod
  namespace: ckad-exercises
spec:
  selector:
    version: blue
  ports:
  - port: 80
EOF

# Vérifier
kubectl get endpoints app-prod -n ckad-exercises

# Basculer vers green
kubectl patch svc app-prod -n ckad-exercises -p '{"spec":{"selector":{"version":"green"}}}'

# Validation
kubectl get endpoints app-prod -n ckad-exercises

---

Récapitulatif des temps

#	Exercice	Domaine	Temps	Indépendant
1	Multi-conteneurs	Design & Build	4 min	✅
2	Init Container	Design & Build	3 min	✅
3	Deployment labels	Deployment	4 min	✅
4	Rolling Update/Rollback	Deployment	3 min	⚠️ Ex.3
5	HPA	Deployment	3 min	⚠️ Ex.3
6	Probes	Observability	5 min	✅
7	Debugging	Observability	4 min	✅
8	ConfigMap env	Environment	3 min	✅
9	Secret fichier	Environment	4 min	✅
10	Resources	Environment	3 min	✅
11	ServiceAccount	Environment	4 min	✅
12	SecurityContext	Environment	4 min	✅
13	PVC	Environment	5 min	✅
14	Service ClusterIP	Networking	2 min	⚠️ Ex.3
15	Service NodePort	Networking	3 min	✅
16	Ingress	Networking	4 min	⚠️ Ex.15
17	NetworkPolicy	Networking	5 min	⚠️ Ex.3
18	Job	Batch	3 min	✅
19	CronJob	Batch	3 min	✅
20	Blue-Green	Deployment	5 min	✅

Glissez pour voir

Temps total : ~74 minutes

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

---

Nettoyage

kubectl delete ns ckad-exercises

---

À retenir

1. Labels cohérents : Un label unique (app=api) pour Deployment, Service, NetworkPolicy
2. Requests CPU obligatoires pour HPA
3. kubectl explain pour trouver la syntaxe rapidement
4. $do = --dry-run=client -o yaml pour générer des YAML
5. Init containers : exécutés séquentiellement avant les containers principaux
6. Probes : startup → readiness → liveness (ordre de vérification)
7. PVC : provisionnement dynamique avec StorageClass default
8. NetworkPolicy : nécessite un CNI compatible (pas Flannel seul)

---

Prochaines étapes

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

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

Killer.sh Simulateur officiel inclus avec l'inscription

×

📖 Voir la documentation →