CKAD - Guide Complet et Stratégie d'Examen
🎯 Objectifs
Ce module te prépare à la CKAD (Certified Kubernetes Application Developer). Tu vas :
- ✅ Comprendre ce qu'est la CKAD et comment elle diffère de la CKA
- ✅ Maîtriser les 5 domaines et leur poids dans la note finale
- ✅ Configurer ton environnement pour maximiser ta vitesse d'examen
- ✅ Apprendre les techniques kubectl pour les développeurs
- ✅ Avoir un plan de révision semaine par semaine
📋 Prérequis
- Module Kubernetes - Intermédiaire ou Kubernetes - Avancé complété
- À l'aise avec
kubectl apply,kubectl get,kubectl describe,kubectl logs - Connaissance pratique des Deployments, Services et ConfigMaps
- Connaissances Linux de base : fichiers de config, variables d'environnement
📖 Qu'est-ce que la CKAD ?
Le problème qu'elle résout
La CKAD (Certified Kubernetes Application Developer) valide que tu es capable de développer et déployer des applications sur Kubernetes - pas d'administrer l'infrastructure, mais de construire les workloads qui tournent dessus.
Contrairement à la CKA qui vise les administrateurs cluster, la CKAD vise les développeurs qui veulent prouver qu'ils savent écrire du code qui fonctionne correctement dans Kubernetes.
Ce qui la distingue
La CKAD est 100% pratique comme la CKA. Tu travailles directement dans un terminal sur de vrais clusters Kubernetes pendant 2 heures.
Les tâches sont orientées développeur : créer des Deployments, configurer des Variables d'environnement, gérer les Secrets, configurer des Volumes, déboguer des applications.
Score et règles
- 66% minimum pour être certifié
- Durée : 2 heures
- 19 tâches pratiques (en moyenne)
- Documentation kubernetes.io autorisée (et seulement elle)
- Webcam et écran partagé obligatoires
- Validité : 3 ans
📊 Les 5 domaines CKAD
La CKAD couvre 5 domaines avec des poids spécifiques. Comprendre leur importance te permet de prioriser ta révision.
| # | Domaine | Poids | Focus |
|---|---|---|---|
| 1 | Application Design & Build | 20% | Dockerfiles, images, construction d'apps |
| 2 | Application Deployment | 20% | Déployer des apps avec kubectl, Helm basics |
| 3 | Application Observability & Maintenance | 15% | Logs, debugging, mise à jour, rollbacks |
| 4 | Application Environment, Configuration & Security | 25% | ConfigMaps, Secrets, RBAC, Security Contexts |
| 5 | Services & Networking | 20% | Services, Ingress, DNS, communication inter-pods |
💡 La configuration (Secrets, ConfigMaps, RBAC) représente 25% de la note. C'est le domaine le plus important pour la CKAD.
⚡ Techniques kubectl pour les développeurs
Comme pour la CKA, la vitesse compte. Commence ton examen en configurant ton terminal avec ces raccourcis.
Alias et variables d'environnement
# Alias kubectl
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"Générer du YAML rapidement (mode impératif)
Ne jamais écrire du YAML à la main quand kubectl peut le générer :
# Pod simple
k run nginx --image=nginx $do > pod.yaml
# Deployment avec replicas
k create deployment webapp --image=app:1.0 --replicas=3 $do > deploy.yaml
# Service ClusterIP
k expose deployment webapp --port=80 --target-port=8080 $do > service.yaml
# ConfigMap à partir d'une valeur
k create configmap app-config --from-literal=DB_HOST=db.example.com $do > configmap.yaml
# Secret
k create secret generic db-secret --from-literal=password=secret123 $do > secret.yamlAfficher et éditer rapidement
# Voir le YAML complet d'une ressource
k get pod nginx -o yaml
# Éditer directement
k edit deployment webapp
# Voir les logs en temps réel
k logs -f deployment/webapp
# Exécuter une commande dans un pod
k exec -it nginx -- /bin/sh🔍 Les domaines en détail
1. Application Design & Build (20%)
Tu dois comprendre comment les applications sont construites pour Kubernetes.
Ce que tu dois savoir :
- Lire et écrire des Dockerfiles simples
- Comprendre les images multi-étapes
- Connaître les patterns de base (entryballs, signaux)
- Comprendre les health checks
Exemple :
# Dockerfile simple
FROM golang:1.21 as builder
WORKDIR /app
COPY . .
RUN go build -o app
FROM alpine:3.18
COPY --from=builder /app/app /app
EXPOSE 8080
CMD ["/app"]2. Application Deployment (20%)
Savoir déployer et mettre à jour des applications.
Ce que tu dois savoir :
- Créer et mettre à jour des Deployments
- Stratégies de rolling update
- Rollbacks
- Helm basics (templates simples)
Exemple :
# Déployer une application
k create deployment myapp --image=myapp:1.0 --replicas=3 $do > deploy.yaml
# Mettre à jour l'image
k set image deployment/myapp myapp=myapp:2.0
# Voir l'historique et rollback
k rollout history deployment/myapp
k rollout undo deployment/myapp3. Application Observability & Maintenance (15%)
Déboguer, surveiller et maintenir des applications.
Ce que tu dois savoir :
- Lire les logs
- Exécuter des commandes dans les pods
- Voir l'état des ressources
- Dépanner les problèmes courants
Exemple :
# Voir les logs
k logs pod/myapp
# Logs d'un deployment (tous les pods)
k logs -l app=myapp
# Voir les events
k describe pod/myapp
# Exécuter une commande
k exec pod/myapp -- curl localhost:80804. Application Environment, Configuration & Security (25%)
Le domaine le PLUS important. Configurer les apps et les sécuriser.
Ce que tu dois savoir :
- ConfigMaps et Secrets
- Variables d'environnement
- Volumes et mounts
- RBAC (Service Accounts, Roles, RoleBindings)
- Security Contexts
- Pod Security Standards
Exemple :
apiVersion: v1
kind: Pod
metadata:
name: secure-app
spec:
serviceAccountName: app-sa
containers:
- name: app
image: myapp:1.0
env:
- name: DB_HOST
valueFrom:
configMapKeyRef:
name: app-config
key: db_host
- name: DB_PASSWORD
valueFrom:
secretKeyRef:
name: db-secret
key: password
volumeMounts:
- name: data
mountPath: /data
securityContext:
runAsNonRoot: true
runAsUser: 1000
volumes:
- name: data
emptyDir: {}5. Services & Networking (20%)
Exposer et connecter tes applications.
Ce que tu dois savoir :
- Types de Services (ClusterIP, NodePort, LoadBalancer)
- Ingress
- DNS Kubernetes
- Communication inter-pods
Exemple :
---
# Service ClusterIP (défaut)
apiVersion: v1
kind: Service
metadata:
name: myapp
spec:
selector:
app: myapp
ports:
- port: 80
targetPort: 8080
---
# Ingress
apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
name: myapp
spec:
rules:
- host: myapp.example.com
http:
paths:
- path: /
pathType: Prefix
backend:
service:
name: myapp
port:
number: 80📅 Plan de révision - 4 semaines
Semaine 1 : Fondamentaux
- Comprendre les Deployments, Pods, Services
- Maîtriser
kubectl(get, describe, logs, exec) - Créer des Deployments et Services en mode impératif
Semaine 2 : Configuration & Secrets
- ConfigMaps : créer, utiliser, mettre à jour
- Secrets : types, utilisation, bonnes pratiques
- Variables d'environnement et volumes
Semaine 3 : Sécurité & RBAC
- Service Accounts et RBAC (Roles, RoleBindings)
- Security Contexts (runAsUser, runAsNonRoot)
- Pod Security Standards
- Network Policies basics
Semaine 4 : Ingress & Observabilité
- Ingress et routage
- Logs et debugging
- Health checks et probes
- Mise à jour et rollbacks
- Examen blanc
🚀 Conseil d'examen
Avant de commencer :
- Configure tes alias et variables dans le terminal
- Vérifie le contexte :
k config current-context - Lis l'énoncé entièrement avant de commencer
- Marque les problèmes compliqués et reviens-y
Pendant l'examen :
- Commence par les questions simples (générer du YAML)
- N'hésite pas à utiliser la documentation
- Teste tes pods :
k logs,k describe,k exec - Vérifie que tes ressources sont dans le bon namespace
Gestion du temps :
- 2 heures, ~19 tâches = ~6 minutes par tâche en moyenne
- Les 5 premières minutes doivent être des configurations faciles
- Garde les problèmes compliqués pour la fin
🎓 Prochaines Étapes
Selon ton progression, explore les modules en profondeur :
- CKAD : Applications et Workloads - Déployer et gérer les applications
- CKAD : Configuration et Sécurité - ConfigMaps, Secrets et RBAC
- CKAD : Services et Networking - Services, Ingress et DNS
- CKAD : Volumes et Persistance - Stockage et données persistantes