DevOpsFacile
AccueilParcours de formationCertificationsModulesCheat SheetÀ Propos
DevOpsFacile

Une plateforme d'apprentissage complète pour maîtriser les pratiques DevOps modernes, du débutant à l'expert.

contact@devopsfacile.fr

Formation

  • Parcours de formation
  • Modules

Informations

  • À Propos
  • Conditions d'utilisation
  • Confidentialité
  • Mentions légales

© 2026 DevOps Facile. Tous droits réservés.

Fait avec pour la communauté DevOps

ModulesCKAD - Guide Complet et Stratégie d'Examen

Module

Maîtrisez la CKAD : structure d'examen, domaines couverts, techniques kubectl, gestion du temps et plan de révision complet pour réussir.

  • 1 heure
  • Avancé

Formation 100 % Linux

Tous les modules nécessitent un environnement Linux. Si vous êtes sur Windows, installez d'abord WSL (Windows Subsystem for Linux) avant de continuer.

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.

#DomainePoidsFocus
1Application Design & Build20%Dockerfiles, images, construction d'apps
2Application Deployment20%Déployer des apps avec kubectl, Helm basics
3Application Observability & Maintenance15%Logs, debugging, mise à jour, rollbacks
4Application Environment, Configuration & Security25%ConfigMaps, Secrets, RBAC, Security Contexts
5Services & Networking20%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

bash
# 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 :

bash
# 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.yaml

Afficher et éditer rapidement

bash
# 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
# 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 :

bash
# 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/myapp

3. 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 :

bash
# 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:8080

4. 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 :

yaml
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 :

yaml
---
# 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 :

  1. Configure tes alias et variables dans le terminal
  2. Vérifie le contexte : k config current-context
  3. Lis l'énoncé entièrement avant de commencer
  4. 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
Retour aux modules

Sur cette page

  • 🎯 Objectifs
  • 📋 Prérequis
  • 📖 Qu'est-ce que la CKAD ?
  • Le problème qu'elle résout
  • Ce qui la distingue
  • Score et règles
  • 📊 Les 5 domaines CKAD
  • ⚡ Techniques kubectl pour les développeurs
  • Alias et variables d'environnement
  • Générer du YAML rapidement (mode impératif)
  • Afficher et éditer rapidement
  • 🔍 Les domaines en détail
  • 1. Application Design & Build (20%)
  • 2. Application Deployment (20%)
  • 3. Application Observability & Maintenance (15%)
  • 4. Application Environment, Configuration & Security (25%)
  • 5. Services & Networking (20%)
  • 📅 Plan de révision - 4 semaines
  • Semaine 1 : Fondamentaux
  • Semaine 2 : Configuration & Secrets
  • Semaine 3 : Sécurité & RBAC
  • Semaine 4 : Ingress & Observabilité
  • 🚀 Conseil d'examen
  • 🎓 Prochaines Étapes