Commandes essentielles CKA — Cheatsheet enrichie

Cette page est une référence opérationnelle pour la CKA. Elle contient les commandes essentielles organisées par domaine d’examen, avec le contexte d’usage et les pièges à éviter.

Pour les explications détaillées, consultez les guides dédiés (kubeadm, etcd, RBAC, etc.). Ici, l’objectif est de mémoriser les commandes et les réflexes.

Versions

Les exemples utilisent des versions comme v1.X.0. Adaptez à la version de l’environnement d’examen (actuellement Kubernetes v1.34 ou plus récent).

Configuration initiale

Ces alias sont indispensables. Configurez-les immédiatement au début de chaque session.

# Alias fondamentaux
alias k=kubectl
alias kn='kubectl config set-context --current --namespace'
export do="--dry-run=client -o yaml"

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

# Éditeur
export KUBE_EDITOR=vim

Premier réflexe de chaque question :

# Vérifier et changer le contexte
kubectl config current-context
kubectl config use-context <cluster-name>
kubectl config get-contexts

Réflexes par situation

Ce tableau est votre outil de diagnostic rapide. Face à un symptôme, appliquez le premier réflexe.

Situation	Premier réflexe	Commande
Pod en erreur	Describe + logs previous	kubectl describe pod X puis kubectl logs X --previous
Node NotReady	Describe + logs kubelet	kubectl describe node X puis journalctl -u kubelet
Service ne répond pas	Vérifier endpoints	kubectl get endpoints X
PVC Pending	Vérifier PV et SC	kubectl get pv,pvc,sc puis kubectl describe pvc X
Scheduling échoue	Events du Pod	kubectl describe pod X → section Events
Cluster cassé	État global	kubectl get nodes + kubectl get pods -n kube-system
API server down	Static pods	crictl ps ou vérifier /etc/kubernetes/manifests/
etcd cassé	Logs etcd	kubectl logs -n kube-system etcd-master
DNS ne résout pas	CoreDNS up?	kubectl get pods -n kube-system -l k8s-app=kube-dns
Permissions refusées	Test RBAC	kubectl auth can-i <verb> <resource> --as=<user>

Glissez pour voir

À connaître par cœur

Ces éléments reviennent constamment. Ne les cherchez pas pendant l’examen.

Chemins critiques

# Static pods (control plane)
/etc/kubernetes/manifests/

# Certificats PKI
/etc/kubernetes/pki/

# Certificats etcd
/etc/kubernetes/pki/etcd/

# Configuration kubelet
/var/lib/kubelet/config.yaml
/etc/kubernetes/kubelet.conf

# Kubeconfig admin
/etc/kubernetes/admin.conf
~/.kube/config

Ordre d’upgrade cluster

1. kubeadm sur le control plane
2. kube-apiserver, scheduler, controller-manager (automatique via kubeadm)
3. kubelet + kubectl sur le control plane
4. Drain le premier worker
5. kubeadm + kubelet + kubectl sur ce worker
6. Uncordon ce worker
7. Répéter pour chaque worker

Différences cordon / drain / uncordon

Action	Scheduling	Pods existants
cordon	❌ Bloqué	✅ Restent
drain	❌ Bloqué	❌ Évacués
uncordon	✅ Autorisé	—

Glissez pour voir

Différences Role / ClusterRole

Type	Portée	Ressources
Role + RoleBinding	1 namespace	Pods, Deployments, Secrets…
ClusterRole + ClusterRoleBinding	Tout le cluster	Nodes, PVs, Namespaces + tout
ClusterRole + RoleBinding	1 namespace	Réutilisation d’un ClusterRole, limité

Glissez pour voir

Labels PSA (Pod Security Admission)

# Appliquer la politique Restricted
kubectl label ns production pod-security.kubernetes.io/enforce=restricted

À retrouver dans la doc

Ces éléments sont plus complexes. Copiez-les depuis kubernetes.io le jour J.

• Syntaxe complète d’un Ingress avec TLS
• Champs avancés d’une NetworkPolicy (namespaceSelector, ipBlock)
• Options de kubeadm init avancées (HA, —upload-certs)
• Configuration EncryptionConfiguration pour secrets etcd
• Syntaxe PodDisruptionBudget

Bookmark recommandés :

• kubernetes.io/docs/reference/kubectl/quick-reference/
• kubernetes.io/docs/concepts/security/
• kubernetes.io/docs/tasks/administer-cluster/

Commandes par domaine

Cluster Admin

kubeadm — Initialisation et upgrade

# Initialiser le control plane
kubeadm init --pod-network-cidr=10.244.0.0/16

# Configurer kubectl après init
mkdir -p $HOME/.kube
cp -i /etc/kubernetes/admin.conf $HOME/.kube/config

# Générer la commande join
kubeadm token create --print-join-command

# Vérifier le plan d'upgrade
kubeadm upgrade plan

# Appliquer l'upgrade (adapter la version)
kubeadm upgrade apply v1.X.0

# Upgrade d'un worker
kubeadm upgrade node

Piège : Oublier de faire systemctl daemon-reload && systemctl restart kubelet après upgrade de kubelet.

Upgrade complet d’un worker

# Sur le control plane
kubectl drain worker1 --ignore-daemonsets --delete-emptydir-data

# Sur le worker
apt-get install -y kubeadm=1.X.0-1.1
kubeadm upgrade node
apt-get install -y kubelet=1.X.0-1.1 kubectl=1.X.0-1.1
systemctl daemon-reload
systemctl restart kubelet

# Sur le control plane
kubectl uncordon worker1

Guide kubeadm détaillé Installation et administration complète

etcd

Backup etcd

export ETCDCTL_API=3

etcdctl snapshot save /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

Où trouver les certs ? Regardez dans /etc/kubernetes/manifests/etcd.yaml.

Vérifier le backup

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

Restore etcd

# 1. Arrêter l'API server
mv /etc/kubernetes/manifests/kube-apiserver.yaml /etc/kubernetes/

# 2. Restaurer dans un NOUVEAU répertoire
etcdctl snapshot restore /backup/etcd-snapshot.db \
  --data-dir=/var/lib/etcd-restore

# 3. Modifier etcd.yaml → hostPath.path: /var/lib/etcd-restore

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

Piège : Restaurer directement dans /var/lib/etcd au lieu d’un nouveau répertoire.

Health check

etcdctl endpoint health \
  --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

Nodes

Gestion des nodes

# Lister avec détails
kubectl get nodes -o wide

# Diagnostic
kubectl describe node worker1

# Labels
kubectl label node worker1 disktype=ssd
kubectl label node worker1 disktype-   # Supprimer

# Taints
kubectl taint node worker1 dedicated=database:NoSchedule
kubectl taint node worker1 dedicated=database:NoSchedule-  # Supprimer

# Maintenance
kubectl cordon worker1
kubectl drain worker1 --ignore-daemonsets --delete-emptydir-data
kubectl uncordon worker1

# Métriques (Metrics Server requis)
kubectl top nodes
kubectl top pods --sort-by=memory

Effets des taints

Effet	Comportement
NoSchedule	Nouveaux Pods bloqués, existants restent
PreferNoSchedule	Évite si possible (soft)
NoExecute	Évacue les existants + bloque nouveaux

Glissez pour voir

RBAC

Créer des Roles

# Role dans un namespace
kubectl create role pod-reader \
  --verb=get,list,watch \
  --resource=pods \
  -n development

# ClusterRole
kubectl create clusterrole node-reader \
  --verb=get,list,watch \
  --resource=nodes

Créer des Bindings

# RoleBinding → user
kubectl create rolebinding reader-binding \
  --role=pod-reader \
  --user=jane \
  -n development

# RoleBinding → ServiceAccount
kubectl create rolebinding sa-binding \
  --role=pod-reader \
  --serviceaccount=development:myapp \
  -n development

# ClusterRoleBinding
kubectl create clusterrolebinding admin-binding \
  --clusterrole=cluster-admin \
  --user=admin

Tester les permissions

# Mes permissions
kubectl auth can-i create pods

# Permissions d'un user
kubectl auth can-i delete pods --as=jane -n development

# Permissions d'un ServiceAccount
kubectl auth can-i list secrets \
  --as=system:serviceaccount:development:myapp \
  -n development

# Lister toutes les permissions
kubectl auth can-i --list --as=jane -n development

Format ServiceAccount : system:serviceaccount:NAMESPACE:NOM

Lister RBAC existant

kubectl get roles,rolebindings -A
kubectl get clusterroles,clusterrolebindings
kubectl describe role pod-reader -n development

Services

Créer des Services

# ClusterIP (défaut)
kubectl expose deploy webapp --port=80 --target-port=8080

# NodePort
kubectl expose deploy webapp --port=80 --type=NodePort

# Avec nom personnalisé
kubectl expose deploy webapp --port=80 --name=webapp-svc

# Générer YAML
kubectl expose deploy webapp --port=80 $do > svc.yaml

Vérifier et débugger

# Lister
kubectl get svc -o wide

# Endpoints (IPs des Pods)
kubectl get endpoints webapp-svc

# Tester depuis un Pod
kubectl run test --image=busybox:1.36 --rm -it -- wget -qO- webapp-svc

# Test DNS
kubectl run test --image=busybox:1.36 --rm -it -- nslookup webapp-svc

Piège : Endpoints vide = selector ne matche aucun Pod.

DNS interne

<service>.<namespace>.svc.cluster.local

• Même namespace : webapp-svc
• Cross-namespace : webapp-svc.production

Storage

PersistentVolume (admin)

apiVersion: v1
kind: PersistentVolume
metadata:
  name: pv-data
spec:
  capacity:
    storage: 10Gi
  accessModes: [ReadWriteOnce]
  persistentVolumeReclaimPolicy: Retain
  storageClassName: manual
  hostPath:
    path: /data/pv

PersistentVolumeClaim (dev)

apiVersion: v1
kind: PersistentVolumeClaim
metadata:
  name: pvc-data
spec:
  accessModes: [ReadWriteOnce]
  resources:
    requests:
      storage: 5Gi
  storageClassName: manual

Commandes utiles

# Lister et vérifier binding
kubectl get pv,pvc

# Détails
kubectl describe pvc pvc-data

# StorageClasses
kubectl get sc

# SC par défaut
kubectl get sc -o jsonpath='{.items[?(@.metadata.annotations.storageclass\.kubernetes\.io/is-default-class=="true")].metadata.name}'

Access Modes

Mode	Description
RWO	Read/Write par 1 node
ROX	Read-only par plusieurs nodes
RWX	Read/Write par plusieurs nodes

Glissez pour voir

Piège : PVC Pending = taille ou accessMode ou storageClassName incompatible avec les PV disponibles.

NetworkPolicy

Deny all par défaut

apiVersion: networking.k8s.io/v1
kind: NetworkPolicy
metadata:
  name: deny-all
  namespace: production
spec:
  podSelector: {}
  policyTypes: [Ingress, Egress]

Autoriser un trafic spécifique

apiVersion: networking.k8s.io/v1
kind: NetworkPolicy
metadata:
  name: allow-frontend
  namespace: production
spec:
  podSelector:
    matchLabels:
      app: backend
  policyTypes: [Ingress]
  ingress:
  - from:
    - podSelector:
        matchLabels:
          app: frontend
    ports:
    - port: 8080

Vérifier

kubectl get netpol -A
kubectl describe netpol allow-frontend -n production

Piège : NetworkPolicy nécessite un CNI compatible (Calico, Cilium). Flannel seul ne les applique pas.

Troubleshooting (30% de l’examen)

Domaine le plus lourd

Le troubleshooting représente 30% de la CKA. Maîtrisez la méthodologie et les commandes de diagnostic.

Méthodologie

1. Identifier le symptôme : Que se passe-t-il exactement ?
2. Localiser le niveau : Pod, Node, ou Cluster ?
3. Collecter : describe, logs, events
4. Hypothèse : Quelle pourrait être la cause ?
5. Corriger et vérifier

État du cluster

# Vue d'ensemble
kubectl cluster-info
kubectl get nodes
kubectl get pods -n kube-system

# Health check
kubectl get --raw='/readyz?verbose'

Diagnostic Pod

# État
kubectl get pod mypod -o wide

# Détails (ESSENTIEL)
kubectl describe pod mypod

# Logs
kubectl logs mypod
kubectl logs mypod --previous    # Après crash
kubectl logs mypod -c container  # Multi-container

# Shell
kubectl exec -it mypod -- /bin/sh

Diagnostic Node

# Depuis le control plane
kubectl describe node worker1

# Sur le node problématique
systemctl status kubelet
journalctl -u kubelet | tail -50
journalctl -u kubelet --since "10 minutes ago" | grep -i error

Diagnostic composants control plane

# Logs des static pods
kubectl logs -n kube-system kube-apiserver-master
kubectl logs -n kube-system etcd-master
kubectl logs -n kube-system kube-scheduler-master
kubectl logs -n kube-system kube-controller-manager-master

# Ou directement sur le node
crictl ps
cat /var/log/pods/kube-system_kube-apiserver-*/kube-apiserver/*.log

Problèmes courants et solutions

Symptôme	Cause probable	Solution
Pod Pending	Pas de node eligible	Vérifier taints, resources, nodeSelector
Pod ImagePullBackOff	Image inexistante ou credentials	Vérifier nom image, registry secret
Pod CrashLoopBackOff	App crash	kubectl logs --previous
Pod CreateContainerConfigError	ConfigMap/Secret manquant	kubectl describe pod → Events
Node NotReady	kubelet down	systemctl restart kubelet
Node MemoryPressure	RAM saturée	Évacuer des Pods
Service non accessible	Endpoints vide	Vérifier selector vs labels Pods
DNS timeout	CoreDNS down	Vérifier Pods kube-dns
kubectl timeout	API server down	Vérifier /etc/kubernetes/manifests/

Glissez pour voir

Génération YAML rapide

# Pod
kubectl run nginx --image=nginx $do > pod.yaml

# Deployment
kubectl create deploy webapp --image=nginx --replicas=3 $do > deploy.yaml

# Service
kubectl expose deploy webapp --port=80 $do > svc.yaml

# Job
kubectl create job myjob --image=busybox -- /bin/sh -c "echo hello" $do

# CronJob
kubectl create cronjob mycron --image=busybox --schedule="*/5 * * * *" -- date $do

# ConfigMap
kubectl create cm myconfig --from-literal=key=value $do

# Secret
kubectl create secret generic mysecret --from-literal=password=secret $do

# Role
kubectl create role myrole --verb=get,list --resource=pods $do

# RoleBinding
kubectl create rolebinding mybinding --role=myrole --user=jane $do

# ServiceAccount
kubectl create sa mysa $do

Cheatsheet condensée

# === CONTEXTE ===
kubectl config use-context <cluster>
kubectl config set-context --current --namespace=<ns>

# === CLUSTER ===
kubeadm init --pod-network-cidr=10.244.0.0/16
kubeadm token create --print-join-command
kubeadm upgrade plan && kubeadm upgrade apply v1.X.0

# === ETCD ===
export ETCDCTL_API=3
etcdctl snapshot save /backup/snap.db --endpoints=... --cacert=... --cert=... --key=...
etcdctl snapshot restore /backup/snap.db --data-dir=/var/lib/etcd-new

# === NODES ===
kubectl cordon/drain/uncordon <node>
kubectl taint node <node> key=value:NoSchedule
kubectl label node <node> disktype=ssd

# === RBAC ===
kubectl create role <name> --verb=get,list --resource=pods
kubectl create rolebinding <name> --role=<role> --user=<user>
kubectl auth can-i create pods --as=jane

# === TROUBLESHOOT ===
kubectl describe pod/node/svc <name>
kubectl logs <pod> --previous
journalctl -u kubelet | grep error
systemctl restart kubelet

À retenir

1. Alias + autocomplétion : configurez-les immédiatement à chaque session
2. Contexte : vérifiez-le avant chaque question
3. etcd : mémorisez le chemin des certs (/etc/kubernetes/pki/etcd/)
4. Upgrade : control plane d’abord, puis workers avec drain/uncordon
5. RBAC : Role = namespace, ClusterRole = cluster
6. Troubleshooting = 30% : maîtrisez describe, logs, events, journalctl
7. Static pods : manifests dans /etc/kubernetes/manifests/
8. Génération YAML : utilisez $do systématiquement

Prochaines étapes

Guide de préparation CKA Programme complet et stratégie

Exercices CKA Pratiquez avec des exercices type examen

Guide kubeadm Installation et administration détaillée

Guide RBAC Contrôle d'accès approfondi

×

📖 Voir la documentation →