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:1.25 $do > pod.yaml
kubectl create deploy api --image=nginx:1.25 $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@sha256:73aaf090f3d85aa34ee199857f03fa3a95c8ede2ffd4cc2cdb5b94e566b11662
    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@sha256:73aaf090f3d85aa34ee199857f03fa3a95c8ede2ffd4cc2cdb5b94e566b11662
    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@sha256:73aaf090f3d85aa34ee199857f03fa3a95c8ede2ffd4cc2cdb5b94e566b11662
    command: ['sh', '-c', 'echo "ready=true" > /config/app.conf']
    volumeMounts:
    - name: config
      mountPath: /config
  containers:
  - name: web
    image: nginx:1.25@sha256:a484819eb60211f5299034ac80f6a681b06f89e65866ce91f356ed7c72af059c
    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@sha256:f6daac2445b0ce70e64d77442ccf62839f3f1b4c24bf6746a857eff014e798c8
        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=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@sha256:a484819eb60211f5299034ac80f6a681b06f89e65866ce91f356ed7c72af059c
    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@sha256:a484819eb60211f5299034ac80f6a681b06f89e65866ce91f356ed7c72af059c
    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@sha256:a484819eb60211f5299034ac80f6a681b06f89e65866ce91f356ed7c72af059c
    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@sha256:73aaf090f3d85aa34ee199857f03fa3a95c8ede2ffd4cc2cdb5b94e566b11662
    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@sha256:73aaf090f3d85aa34ee199857f03fa3a95c8ede2ffd4cc2cdb5b94e566b11662
    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@sha256:a484819eb60211f5299034ac80f6a681b06f89e65866ce91f356ed7c72af059c
    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@sha256:a484819eb60211f5299034ac80f6a681b06f89e65866ce91f356ed7c72af059c
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@sha256:73aaf090f3d85aa34ee199857f03fa3a95c8ede2ffd4cc2cdb5b94e566b11662
    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@sha256:a484819eb60211f5299034ac80f6a681b06f89e65866ce91f356ed7c72af059c
    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 endpointslice -l kubernetes.io/service-name=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 api-svc -n ckad-exercises
kubectl get endpointslice -n ckad-exercises -l kubernetes.io/service-name=api-svc

---

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@sha256:73aaf090f3d85aa34ee199857f03fa3a95c8ede2ffd4cc2cdb5b94e566b11662
        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@sha256:73aaf090f3d85aa34ee199857f03fa3a95c8ede2ffd4cc2cdb5b94e566b11662
            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 endpointslice -l kubernetes.io/service-name=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 endpointslice -n ckad-exercises -l kubernetes.io/service-name=app-prod

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

# Validation
kubectl get endpointslice -n ckad-exercises -l kubernetes.io/service-name=app-prod

---

Capstone : la livraison complète, à partir d'un cahier des charges

Les exercices ci-dessus disent quoi créer. Le capstone ne le dit pas, et c'est toute la différence avec l'examen : il donne six exigences à satisfaire dans un namespace, configuration, secret, sondes, identité, exposition et isolation, sans jamais nommer l'objet Kubernetes qui les porte. À vous de choisir, et d'assumer le choix.

Comptez 45 minutes. Le dernier test porte le seul critère de réussite qui compte pour une livraison : un Pod frontend joint la boutique, un Pod qui n'en est pas un ne la joint pas.

Lab pratique

Capstone : livrer la boutique, à partir du seul cahier des charges

$ dsoxlab run ckad-capstone-boutique

Environnement : VM·Durée : ~45 min

Validé : l'état du système est vérifié après reboot, pas la commande tapée.

Première fois ? Qu'est-ce que dsoxlab et comment l'installer

dsoxlab est la ligne de commande qui prépare un environnement jetable (un shell isolé ou une VM), déroule le scénario du lab, puis vérifie l'état réel du système et calcule un score. Rien n'est installé ni cassé sur votre poste de travail.

Installer la CLI et brancher le catalogue, une seule fois :

uv tool install dsoxlab   # ou : pipx install dsoxlab
dsoxlab catalog add https://github.com/stephrobert/kubernetes-dsoxlab-training

Lancer ce lab, puis valider votre travail :

dsoxlab run ckad-capstone-boutique
dsoxlab check ckad-capstone-boutique

Voir tous les labs : dsoxlab list-labs. Suivre sa progression : dsoxlab progress. Le guide complet de dsoxlab détaille l'installation, le calcul du score et les pièges.

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

---

Contrôle de connaissances

Vérifiez que l'essentiel de ce guide est acquis. Les questions portent uniquement sur ce qui vient d'être expliqué ici.

Contrôle de connaissances

Validez vos connaissances avec ce quiz interactif

6 questions

6 min.

70% requis

Informations

• Le chronomètre démarre au clic sur Démarrer
• Questions à choix multiples, vrai/faux et réponses courtes
• Vous pouvez naviguer entre les questions
• Les résultats détaillés sont affichés à la fin

Démarrer le quiz

Lance le quiz et démarre le chronomètre

À 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)

---

Pour aller plus loin

• Exercices chronométrés CKA : Enchaîner sur les mises en situation du versant administrateur.
• Aide-mémoire CKA : Les commandes à connaître par cœur pour l'examen suivant.

×

📖 Voir la documentation →