Has arribat al final del recorregut tècnic. Durant onze mòduls has construït, trencat, arreglat, assegurat i escalat la plataforma Rutas Norte: des del primer Pod solt fins a un clúster de producció amb Ingress, TLS, polítiques de xarxa, emmagatzematge persistent, observabilitat completa i desplegaments canari governats per GitOps. Aquest coneixement és exactament el que mesura la certificació CKA (Certified Kubernetes Administrator). L'única cosa que et separa del certificat és el format: un examen pràctic, en un terminal, contrarellotge, amb un cronòmetre que no perdona el dubte.

Aquesta lliçó converteix el curs que acabes de fer en un pla d'estudi per al CKA. Veuràs què certifica exactament, com és l'examen per dins, quins dominis hi entren i amb quin pes, i —el més important— una taula que mapa cada objectiu oficial del temari amb la lliçó d'aquest curs on el vas estudiar. A partir d'aquí tindràs un pla de sis setmanes i una bateria de vuit tasques tipus examen resoltes amb la comanda exacta i el seu temps objectiu.

Avís imprescindible. Les dades concretes de l'examen (preu, durada exacta, nombre d'intents inclosos, percentatge d'aprovat i repartiment dels dominis) canvien amb el temps. Tot el que llegeixis aquí és orientatiu i correspon al moment d'escriure aquesta lliçó. Abans de matricular-te, consulta sempre el temari oficial vigent al web de la Linux Foundation / CNCF (training.linuxfoundation.org i cncf.io/certification/cka). El programa de certificació revisa els objectius amb cada versió de Kubernetes.

Contingut

  1. Què certifica el CKA i a qui va dirigit
  2. El format de l'examen per dins
  3. Els dominis del temari i el seu pes orientatiu
  4. Mapa complet: cada objectiu del CKA i la seva lliçó en aquest curs
  5. Habilitats específiques del CKA que convé practicar a part
  6. Pla d'estudi de sis setmanes
  7. Recursos oficials i el simulador de pràctiques
  8. Vuit tasques tipus CKA resoltes contrarellotge

  1. Què certifica el CKA i a qui va dirigit

El CKA certifica que saps administrar i operar un clúster de Kubernetes. No és una certificació sobre teoria de contenidors ni sobre desenvolupament d'aplicacions: és la certificació del perfil que manté el clúster viu.

1.1 El perfil que mesura

La persona amb CKA és la que, en una organització com Rutas Norte, s'encarrega de:

Responsabilitat Exemple a Rutas Norte
Instal·lar i mantenir el clúster Muntar el clúster amb kubeadm, unir nodes nous, actualitzar d'1.30 a 1.31
Gestionar el pla de control Diagnosticar un kube-apiserver que no arrenca, fer còpia d'etcd
Operar nodes Drenar node-3 per canviar el disc, gestionar taints i cordons
Configurar l'accés Crear el Role que permet a l'equip de suport llegir logs a rutas-norte-pro
Donar servei de xarxa i emmagatzematge Publicar botiga-web amb Ingress, aprovisionar el PVC de postgres-reserves
Resoldre problemes El worker-notificacions està en CrashLoopBackOff i cal esbrinar per què

1.2 El seu lloc entre les tres certificacions

  • CKA: administrar el clúster. Nodes, pla de control, etcd, RBAC, xarxa, emmagatzematge i diagnòstic.
  • CKAD: desenvolupar sobre el clúster; manifests d'aplicació i velocitat amb kubectl (lliçó 12-02).
  • CKS: assegurar el clúster; enduriment, polítiques i detecció (lliçó 12-03). Exigeix CKA vigent.

El CKA és el punt d'entrada natural si la teva feina és de plataforma, SRE o infraestructura.

1.3 Requisits previs i què NO hi entra

No hi ha requisits formals: qualsevol pot matricular-s'hi. Els requisits reals són pràctics: maneig còmode de la línia de comandes de Linux (systemctl, journalctl, permisos de fitxer, vim), comprensió de contenidors, i haver tocat un clúster de debò —el quilometratge que t'ha donat aquest curs.

I convé saber què no hi cau. No hi ha preguntes tipus test: tot és pràctic. No hi entren Helm, Kustomize ni Argo CD en profunditat, ni els proveïdors gestionats (EKS/AKS/GKE), ni Prometheus o Grafana com a productes —sí kubectl top i el metrics-server—, ni desenvolupament d'aplicacions. L'examen se centra en Kubernetes pur.


  1. El format de l'examen per dins

Aquest és l'apartat que més gent subestima. Conèixer Kubernetes i aprovar el CKA són coses diferents, i la diferència és aquí.

2.1 Característiques de l'examen

Aspecte Descripció orientativa
Tipus 100 % pràctic, sense preguntes teòriques
Entorn Terminal al navegador, supervisat remotament
Durada Al voltant de dues hores
Nombre de tasques Aproximadament entre 15 i 20
Puntuació d'aprovat Aproximadament un 66 %
Intents La matrícula sol incloure un segon intent gratuït
Validesa Al voltant de dos anys (veure lliçó 12-04)
Documentació permesa , la documentació oficial i només aquesta

Ho repeteixo: tots aquests números són orientatius. Verifica el temari i les condicions vigents al web oficial abans de pagar la matrícula.

2.2 Diversos clústers i el canvi de context

Aquesta és la trampa número u de l'examen i la que més punts regala als descuidats.

L'examen no et dona un clúster: te'n dona uns quants, cadascun amb un nom de context diferent. Cada tasca comença indicant-te en quin context has de treballar, amb una comanda que pots copiar i enganxar:

kubectl config use-context rutas-norte-pro

Si resols la tasca perfectament al clúster equivocat, la puntuació és zero. No hi ha puntuació parcial per bona intenció.

Comandes que has de tenir automatitzades al dit:

# Veure tots els contextos disponibles
kubectl config get-contexts

# Veure en quin sóc ARA
kubectl config current-context

# Canviar de context
kubectl config use-context <nom>

# Fixar un namespace per defecte al context actual
kubectl config set-context --current --namespace=rutas-norte-pro

Hàbit obligatori: la primera comanda de cada tasca és el use-context que et donen. Sense excepcions, ni tan sols quan "és el mateix d'abans".

2.3 Puntuació per tasca i puntuacions parcials

Cada tasca té un pes en punts que es mostra a l'enunciat (per exemple, "Task weight: 7 %"). La suma de totes dona 100.

El que és rellevant:

  • Hi ha puntuacions parcials. Si una tasca demana crear un Deployment amb 3 rèpliques, exposar-lo amb un Service i afegir-li una sonda, i només fas les dues primeres coses, t'endús part dels punts. No deixis mai una tasca en blanc.
  • La correcció és automàtica i per estat final del clúster. Ningú no mira com ho vas fer. Si l'objecte existeix amb la configuració demanada, puntua; tant se val si el vas crear amb kubectl create, amb un YAML o editant a mà.
  • Això significa que la via imperativa és tan vàlida com la declarativa, i molt més ràpida.

2.4 La documentació permesa: l'arma decisiva

Durant l'examen pots obrir una pestanya addicional del navegador per consultar:

  • https://kubernetes.io/docs/ (inclosa la referència de l'API i el blog)
  • La documentació dels subprojectes oficials que s'hi enllacen (per exemple kubernetes.io/docs/reference/kubectl/)

No pots fer servir cercadors generals, fòrums, notes pròpies, altres webs ni eines d'IA. Està supervisat.

Això canvia completament l'estratègia d'estudi: no necessites memoritzar YAML. Necessites saber on és cada exemple i adaptar-lo en segons. Un manifest de PersistentVolume, una NetworkPolicy o un Ingress amb TLS són llargs d'escriure i fàcils de copiar.

Pàgines que convé tenir localitzades mentalment (es detalla més a la lliçó 12-04):

Necessito... Buscar a kubernetes.io
Manifest de PV / PVC "persistent volumes"
NetworkPolicy d'exemple "network policies"
Ingress amb regles de ruta "ingress"
Backup d'etcd "operating etcd clusters for kubernetes"
Actualitzar el clúster "upgrading kubeadm clusters"
RBAC (Role/RoleBinding) "using rbac authorization"
Static pods "static pods"
Sondes "configure liveness readiness startup probes"

2.5 L'entorn de treball

  • El terminal és un navegador. Copiar i enganxar funciona, però amb dreceres particulars (habitualment Ctrl+Shift+C / Ctrl+Shift+V a Linux). Practica-ho.
  • L'editor disponible és vim (i nano). Si no manegues vim amb una soltesa mínima, dedica-li un parell d'hores abans de l'examen.
  • Tens accés sudo als nodes via ssh quan la tasca ho requereix (per exemple, per arreglar el kubelet).
  • Hi ha un bloc de notes a la interfície de l'examen per apuntar coses; fes-lo servir per dur la llista de tasques pendents.

  1. Els dominis del temari i el seu pes orientatiu

El temari oficial del CKA s'organitza en cinc dominis. Aquest és el repartiment publicat en el moment d'escriure aquesta lliçó; verifica'l al web oficial, perquè el programa es revisa periòdicament.

Domini Pes orientatiu De què va
Arquitectura, instal·lació i configuració del clúster ~25 % Muntar el clúster, RBAC, actualitzar-lo, etcd, alta disponibilitat, gestors de paquets de Helm/Kustomize a nivell bàsic
Càrrega de treball i planificació ~15 % Deployments, escalat, rollouts, ConfigMaps i Secrets, planificació de pods, autoescalat
Serveis i xarxes ~20 % Services, DNS, Ingress, CNI, NetworkPolicies
Emmagatzematge ~10 % StorageClasses, PV, PVC, modes d'accés, volums en pods
Resolució de problemes ~30 % Diagnòstic d'aplicacions, del clúster, de nodes, de xarxa, logs i monitoratge

Fixa't bé en el repartiment: resolució de problemes és el domini més pesat, gairebé un terç de l'examen. No és un tema que s'estudiï llegint: s'entrena trencant coses i arreglant-les. És exactament el que vas fer al mòdul 7 (07-06) i al mòdul 11 (11-06).

3.1 Com es tradueix el pes en temps

Amb dues hores i ~17 tasques, la mitjana és d'uns 7 minuts per tasca, però el repartiment real és molt desigual:

Tasques de 2-4 %  →  objectiu 3-4 minuts  (crear un Secret, escalar un Deployment)
Tasques de 5-7 %  →  objectiu 6-8 minuts  (Ingress amb TLS, NetworkPolicy, PV+PVC+Pod)
Tasques de 8-10 % →  objectiu 10-12 minuts (backup/restore d'etcd, upgrade de node,
                                            pla de control trencat)

Deixa 10 minuts finals sense assignar per revisar. És el millor ús possible d'aquests minuts.


  1. Mapa complet: cada objectiu del CKA i la seva lliçó en aquest curs

Aquesta és la secció que converteix el curs en un pla d'estudi. Cada objectiu del temari està enllaçat amb la lliçó on el vas treballar. Repassar el CKA és, literalment, rellegir aquestes lliçons i tornar a fer-ne els exercicis en un clúster real.

4.1 Arquitectura, instal·lació i configuració del clúster (~25 %)

Objectiu oficial Lliçó del curs
Gestionar el control d'accés basat en rols (RBAC) 08-01-control-dacces-basat-en-rols
Preparar la infraestructura per instal·lar un clúster 10-02-kubeadm, 01-04-configuracio-dun-cluster-kubernetes
Crear i gestionar clústers amb kubeadm 10-02-kubeadm
Gestionar el cicle de vida del clúster (actualitzacions) 10-02-kubeadm
Implementar i configurar una infraestructura d'alta disponibilitat 10-02-kubeadm, 09-05-alta-disponibilitat-i-pdb
Fer servir Helm i Kustomize per instal·lar components 10-03-helm, 10-04-kustomize
Comprendre la interfície d'extensió (CNI, CSI, CRI, ...) 04-01-xarxes-de-cluster, 05-04-classes-demmagatzematge, 01-02-arquitectura-de-kubernetes
CRDs, operadors i components de l'API agregada 06-06-definicions-de-recursos-personalitzats, 06-07-operadors-i-el-patro-controlador
ServiceAccounts i accés a l'API 03-06-serviceaccounts-i-acces-a-la-api

4.2 Càrrega de treball i planificació (~15 %)

Objectiu oficial Lliçó del curs
Comprendre els desplegaments i fer rollouts i rollbacks 02-03-deployments, 02-04-actualitzacions-rollbacks-i-estrategies
Fer servir ConfigMaps i Secrets per configurar aplicacions 03-01-configmaps, 03-02-secrets, 03-03-variables-dentorn
Configurar escalat d'aplicacions 09-01-autoescalat-horitzontal-de-pods, 02-03-deployments
Comprendre les primitives per crear càrregues robustes 02-01-pods, 02-02-replicasets, 06-01-statefulsets, 06-02-daemonsets
Configurar Pods i contenidors: recursos i límits 03-04-quotes-i-limits-de-recursos, 03-05-limitranges-i-classes-de-qos
Planificació: afinitat, taints, toleracions, nodeSelector 06-05-planificacio-afinitat-taints-i-toleracions
Jobs i CronJobs 06-03-treballs-i-cronjobs
Etiquetes i selectors 02-07-etiquetes-selectors-i-anotacions

4.3 Serveis i xarxes (~20 %)

Objectiu oficial Lliçó del curs
Comprendre la connectivitat entre pods 04-01-xarxes-de-cluster
Tipus de Service i endpoints 04-02-tipus-de-serveis
Fer servir el DNS del clúster 04-03-dns-intern-i-descobriment-de-serveis
Configurar i fer servir Ingress i IngressClass 04-04-controladors-dingress
Configurar TLS a Ingress 04-05-tls-i-certificats-amb-cert-manager
Fer servir NetworkPolicies 04-06-politiques-de-xarxa, 08-04-seguretat-de-xarxa
Triar i instal·lar un plugin CNI 04-01-xarxes-de-cluster
Gateway API (coneixement bàsic) 04-04-controladors-dingress

4.4 Emmagatzematge (~10 %)

Objectiu oficial Lliçó del curs
Implementar StorageClasses i aprovisionament dinàmic 05-04-classes-demmagatzematge, 05-05-aprovisionament-dinamic-expansio-i-snapshots
Configurar volums: tipus, modes d'accés, reclaim policy 05-01-volums, 05-02-volums-persistents
Gestionar PersistentVolumeClaims 05-03-reclamacions-de-volums-persistents
Fer servir emmagatzematge en càrregues de treball 05-01-volums, 06-01-statefulsets
Còpies de seguretat i restauració 05-06-copies-de-seguretat-i-restauracio

4.5 Resolució de problemes (~30 %)

Objectiu oficial Lliçó del curs
Depurar aplicacions (pods, contenidors, esdeveniments) 07-06-depuracio-i-esdeveniments-del-cluster
Monitorar aplicacions i components del clúster 07-02-servidor-de-metriques-i-kubectl-top, 07-03-monitoratge-amb-prometheus
Gestionar logs de contenidors 07-05-registre-centralitzat-amb-efk, 07-06-depuracio-i-esdeveniments-del-cluster
Diagnosticar fallades del clúster i dels nodes 07-06-depuracio-i-esdeveniments-del-cluster, 11-06-operacio-en-produccio
Resoldre problemes de xarxa i de serveis 04-03-dns-intern-i-descobriment-de-serveis, 04-06-politiques-de-xarxa
Verificacions de salut i sondes 07-01-verificacions-de-salut-i-sondes
Incidències i runbooks 11-06-operacio-en-produccio

  1. Habilitats específiques del CKA que convé practicar a part

El curs t'ha donat el coneixement, però hi ha set procediments que a l'examen apareixen gairebé amb seguretat i que cal tenir memoritzats com una coreografia. Repassa'ls fins que surtin sense pensar.

5.1 Muntar un clúster amb kubeadm i unir nodes

Al node de control:

# Inicialitzar el pla de control
sudo kubeadm init --pod-network-cidr=10.244.0.0/16

# Configurar kubectl per a l'usuari actual
mkdir -p $HOME/.kube
sudo cp -i /etc/kubernetes/admin.conf $HOME/.kube/config
sudo chown $(id -u):$(id -g) $HOME/.kube/config

# Instal·lar el CNI (el manifest exacte el dona l'enunciat)
kubectl apply -f https://raw.githubusercontent.com/.../calico.yaml

Al node treballador:

sudo kubeadm join 10.0.0.10:6443 --token <token> \
  --discovery-token-ca-cert-hash sha256:<hash>

Si el token va caducar (dura 24 h), es regenera des del node de control:

kubeadm token create --print-join-command

Comprovació: kubectl get nodes -o wide ha de mostrar tots els nodes en Ready.

5.2 Actualitzar la versió del clúster

Procediment canònic (sempre: pla de control primer, després els treballadors, d'un en un).

# --- Al node de control ---
# 1. Permetre la nova versió al repositori (ajustar la minor a la URL del repo)
sudo apt-get update
sudo apt-cache madison kubeadm    # veure versions disponibles

# 2. Actualitzar kubeadm
sudo apt-mark unhold kubeadm
sudo apt-get install -y kubeadm=1.31.1-1.1
sudo apt-mark hold kubeadm

# 3. Veure el pla i aplicar
sudo kubeadm upgrade plan
sudo kubeadm upgrade apply v1.31.1

# 4. Drenar el node, actualitzar kubelet i kubectl, i tornar-lo al servei
kubectl drain node-control --ignore-daemonsets
sudo apt-mark unhold kubelet kubectl
sudo apt-get install -y kubelet=1.31.1-1.1 kubectl=1.31.1-1.1
sudo apt-mark hold kubelet kubectl
sudo systemctl daemon-reload
sudo systemctl restart kubelet
kubectl uncordon node-control
# --- A cada node treballador ---
sudo apt-get install -y kubeadm=1.31.1-1.1
sudo kubeadm upgrade node          # compte: "node", no "apply"!
kubectl drain node-1 --ignore-daemonsets
sudo apt-get install -y kubelet=1.31.1-1.1 kubectl=1.31.1-1.1
sudo systemctl daemon-reload && sudo systemctl restart kubelet
kubectl uncordon node-1

Trampes clàssiques: oblidar --ignore-daemonsets al drain (falla sempre, perquè hi ha DaemonSets del CNI i de kube-proxy); fer servir upgrade apply en un treballador; oblidar l'uncordon final.

5.3 Còpia i restauració d'etcd

És la tasca que més punts val i la que més gent falla. Memoritza-la.

Còpia de seguretat:

ETCDCTL_API=3 etcdctl snapshot save /opt/backup-etcd.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

Verificar la còpia:

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

Restauració:

# 1. Restaurar en un directori NOU
sudo ETCDCTL_API=3 etcdctl snapshot restore /opt/backup-etcd.db \
  --data-dir=/var/lib/etcd-restaurat

# 2. Apuntar el pod estàtic d'etcd al nou directori
sudo vim /etc/kubernetes/manifests/etcd.yaml
#    A volumes: canviar hostPath.path de /var/lib/etcd a /var/lib/etcd-restaurat

# 3. El kubelet recrea el pod sol. Esperar i comprovar.
sudo systemctl restart kubelet
kubectl get pods -n kube-system

Claus que s'obliden:

  • Els certificats d'etcd són a /etc/kubernetes/pki/etcd/, no a /etc/kubernetes/pki/.
  • Si l'enunciat et dona rutes de certificats diferents, fes servir les seves.
  • Cal restaurar a un directori nou, no sobre l'existent.
  • El que es modifica és el volum hostPath, no només l'argument --data-dir del contenidor. Canvia'ls tots dos si el manifest els té desalineats.

5.4 Gestió de certificats

sudo kubeadm certs check-expiration     # caducitat de tots els certificats
sudo kubeadm certs renew all            # renovar-los tots
sudo kubeadm certs renew apiserver      # renovar-ne només un

Després de renovar cal reiniciar els pods estàtics del pla de control —movent temporalment els manifests fora de /etc/kubernetes/manifests/ o reiniciant el kubelet— i regenerar ~/.kube/config si ha canviat el certificat d'administració.

També es pot demanar aprovar una CSR per a un usuari nou:

kubectl get csr
kubectl certificate approve suport-rutas-norte
kubectl get csr suport-rutas-norte -o jsonpath='{.status.certificate}' | base64 -d > suport.crt

El manifest de la CertificateSigningRequest (grup certificates.k8s.io/v1, amb el camp request en base64, signerName: kubernetes.io/kube-apiserver-client i usages: ["client auth"]) es copia de la documentació buscant "certificate signing requests": és més ràpid i més segur que escriure'l.

5.5 Drenatge i manteniment de nodes

# Marcar com a no planificable (els pods existents continuen)
kubectl cordon node-2

# Buidar el node (els DaemonSets no es poden desallotjar: cal ignorar-los)
kubectl drain node-2 --ignore-daemonsets --delete-emptydir-data

# Tornar-lo al servei
kubectl uncordon node-2
Flag Quan es necessita
--ignore-daemonsets Gairebé sempre: hi ha DaemonSets de xarxa i de logs
--delete-emptydir-data Si algun pod fa servir emptyDir (per exemple el sidecar de logs)
--force Si hi ha pods "orfes" sense controlador (un Pod solt)
--grace-period=0 Només si l'enunciat demana immediatesa

5.6 Diagnòstic d'un pla de control trencat

Aquest és l'escenari estrella del domini de resolució de problemes. La seqüència mental és sempre la mateixa:

# 1. Respon l'API?
kubectl get nodes
#    Si dona "connection refused" → l'apiserver no està amunt.

# 2. Està viu el kubelet? (al node de control, per ssh)
sudo systemctl status kubelet
sudo journalctl -u kubelet -n 50 --no-pager

# 3. Quins contenidors del pla de control corren?
sudo crictl ps -a
sudo crictl logs <container-id>

# 4. Estan bé els manifests dels pods estàtics?
ls -l /etc/kubernetes/manifests/
sudo cat /etc/kubernetes/manifests/kube-apiserver.yaml

Causes típiques que et posaran, i el seu símptoma:

Causa introduïda Símptoma Arranjament
Error de sintaxi a kube-apiserver.yaml L'API no respon, crictl ps no mostra apiserver Corregir el YAML; el kubelet el recrea sol
Ruta equivocada en un volum del manifest El contenidor arrenca i mor Corregir hostPath
--etcd-servers amb port dolent apiserver en bucle, logs de connexió Corregir l'argument
staticPodPath canviat a /var/lib/kubelet/config.yaml Cap pod estàtic no arrenca Restaurar staticPodPath: /etc/kubernetes/manifests i reiniciar kubelet
kubelet aturat o deshabilitat Node NotReady sudo systemctl enable --now kubelet
Permisos incorrectes a /etc/kubernetes/pki/* apiserver no llegeix les seves claus chmod/chown correctes (claus 600, root:root)
kubeconfig del kubelet apuntant malament Node NotReady, logs d'autenticació Corregir /etc/kubernetes/kubelet.conf

Regla d'or: els pods estàtics no es gestionen amb kubectl. Es gestionen editant fitxers a /etc/kubernetes/manifests/, i el kubelet hi reacciona en segons.

5.7 RBAC

Apareix pràcticament a tots els exàmens. Aquestes quatre comandes resolen el 90 % dels casos:

# Role limitat a un namespace
kubectl create role lector-reserves \
  --verb=get,list,watch --resource=pods,pods/log \
  -n rutas-norte-pro

# Vincular-lo a una ServiceAccount
kubectl create rolebinding lector-reserves-binding \
  --role=lector-reserves \
  --serviceaccount=rutas-norte-pro:suport \
  -n rutas-norte-pro

# ClusterRole i ClusterRoleBinding (àmbit de clúster)
kubectl create clusterrole lector-nodes --verb=get,list --resource=nodes
kubectl create clusterrolebinding lector-nodes-binding \
  --clusterrole=lector-nodes --serviceaccount=rutas-norte-pro:suport

I la comprovació que sempre cal deixar feta:

kubectl auth can-i list pods \
  --as=system:serviceaccount:rutas-norte-pro:suport \
  -n rutas-norte-pro
# yes

  1. Pla d'estudi de sis setmanes

Aquest pla assumeix entre 8 i 10 hores setmanals i que ja has fet el curs. La regla que el governa: per cada hora de lectura, dues hores de teclat.

Setmana Focus Lliçons a repassar Objectiu mesurable en acabar
1 Fonaments i velocitat amb kubectl 01-05, 01-06, 02-01 a 02-07 Crear un Deployment de 3 rèpliques, exposar-lo, escalar-lo i verificar-lo en menys de 2 minuts
2 Càrregues de treball, configuració i planificació 03-01 a 03-05, 06-01 a 06-03, 06-05, 09-01 Consumir un ConfigMap i un Secret de les quatre formes possibles sense obrir la documentació
3 Xarxes 04-01 a 04-06 Escriure de memòria una NetworkPolicy de denegació per defecte i un Ingress amb TLS
4 Emmagatzematge i administració del clúster 05-01 a 05-06, 10-02, 08-01 Muntar un clúster amb kubeadm des de zero en dues VM i actualitzar-lo una versió menor completa
5 etcd, certificats i resolució de problemes 07-01, 07-02, 07-06 i els apartats 5.3 a 5.7 d'aquesta lliçó Backup i restore d'etcd sense documentació; arreglar les set fallades de la taula de l'apartat 5.6
6 Simulacres Lliçó 12-05 i el simulador oficial Dos simulacres complets cronometrats, corregits, amb repàs dirigit dels dominis fluixos

Com fer-lo servir. La setmana 6 no és per aprendre res nou: és per mesurar, corregir i descansar. Deixa l'últim dia per preparar l'entorn físic de l'examen (veure 12-04) i no toquis temes nous les últimes 48 hores.


  1. Recursos oficials i el simulador de pràctiques

7.1 Els que importen

Recurs Per a què
Pàgina oficial del CKA (Linux Foundation) Temari vigent, preu, condicions, política de reintents
Curriculum al repositori cncf/curriculum de GitHub El PDF amb els objectius exactes per domini
kubernetes.io/docs L'única documentació permesa a l'examen: familiaritza't amb el seu cercador
Handbook del candidat (Candidate Handbook) Requisits de l'entorn, identificació, normes de la supervisió
Simulador de pràctiques inclòs amb la matrícula Entorn pràcticament idèntic a l'examen

7.2 El simulador inclòs

La matrícula sol incloure accés a un simulador d'examen (habitualment dues sessions d'unes 36 hores cadascuna, en un entorn equivalent al real). Consells d'ús:

  • No el gastis aviat. Fes-lo servir quan ja et sentis raonablement preparat, a la setmana 6.
  • La seva dificultat sol ser superior a la de l'examen real. Si hi treus un 60 %, vas bé.
  • El valuós no és la nota, sinó el solucionari: llegeix-lo sencer, incloses les tasques que vas encertar, perquè gairebé sempre hi ha una manera més ràpida.

7.3 Entorn de pràctica propi

No cal res de pagament. Amb kind tens un clúster d'un node de control i dos treballadors en menys d'un minut (repassa 10-01):

kind create cluster --name cka --config kind-cka.yaml   # 1 control-plane + 2 workers
kubectl get nodes

Ara bé, per practicar kubeadm, etcd i el pla de control trencat necessites màquines de debò (VM amb Multipass, Vagrant o similar): kind executa el pla de control dins de contenidors i no reprodueix fidelment ni systemctl ni els pods estàtics de l'amfitrió.


  1. Vuit tasques tipus CKA resoltes contrarellotge

Practica aquestes vuit com si fossin l'examen: cronòmetre en marxa, només kubernetes.io obert. Els escenaris són de Rutas Norte.


Tasca 1 — Crear un Deployment i exposar-lo (pes ~4 %, objectiu: 4 min)

Context: kubectl config use-context rutas-norte-dev

Al namespace rutas-norte-dev, crea un Deployment anomenat botiga-web amb la imatge nginx:1.27-alpine i 3 rèpliques. Exposa'l amb un Service ClusterIP anomenat botiga-web-svc al port 80.

kubectl config use-context rutas-norte-dev

kubectl create deployment botiga-web \
  --image=nginx:1.27-alpine --replicas=3 -n rutas-norte-dev

kubectl expose deployment botiga-web \
  --name=botiga-web-svc --port=80 --target-port=80 -n rutas-norte-dev

Comprovació:

kubectl get deploy,svc,endpoints -n rutas-norte-dev -l app=botiga-web
NAME                         READY   UP-TO-DATE   AVAILABLE
deployment.apps/botiga-web   3/3     3            3

NAME                     TYPE        CLUSTER-IP      PORT(S)
service/botiga-web-svc   ClusterIP   10.96.140.22    80/TCP

NAME                       ENDPOINTS
endpoints/botiga-web-svc   10.244.1.5:80,10.244.2.7:80,10.244.2.8:80

La trampa: si endpoints surt buit, el selector no casa. kubectl expose l'hereta bé; escriure'l a mà és on es trenca.


Tasca 2 — Còpia de seguretat i restauració d'etcd (pes ~8 %, objectiu: 10 min)

Context: kubectl config use-context rutas-norte-pro

Fes una còpia de seguretat d'etcd a /opt/etcd-rutas-norte.db. Després, restaura la còpia prèvia /opt/snapshot-anterior.db al directori /var/lib/etcd-restore. Els certificats són a /etc/kubernetes/pki/etcd/.

# Còpia
sudo ETCDCTL_API=3 etcdctl snapshot save /opt/etcd-rutas-norte.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

# Verificació de la còpia
sudo ETCDCTL_API=3 etcdctl --write-out=table snapshot status /opt/etcd-rutas-norte.db

# Restauració
sudo ETCDCTL_API=3 etcdctl snapshot restore /opt/snapshot-anterior.db \
  --data-dir=/var/lib/etcd-restore

# Reapuntar el pod estàtic
sudo vim /etc/kubernetes/manifests/etcd.yaml

Al manifest, el volum queda així:

  volumes:
  - hostPath:
      path: /var/lib/etcd-restore   # abans: /var/lib/etcd
      type: DirectoryOrCreate
    name: etcd-data

Comprovació:

sudo crictl ps | grep etcd
kubectl get nodes

La trampa: snapshot save no necessita sudo si el teu usuari llegeix els certificats, però restore escriu a /var/lib, així que sí. I cal canviar el hostPath del volum, no n'hi ha prou amb el --data-dir del contenidor.


Tasca 3 — Drenar un node per manteniment (pes ~4 %, objectiu: 3 min)

Context: kubectl config use-context rutas-norte-pro

El node node-2 rebrà manteniment. Buida'l de càrregues de treball sense eliminar els DaemonSets, i assegura't que no s'hi planifiquin pods nous.

kubectl drain node-2 --ignore-daemonsets --delete-emptydir-data

Comprovació:

kubectl get nodes
NAME     STATUS                     ROLES    VERSION
node-1   Ready                      <none>   v1.30.4
node-2   Ready,SchedulingDisabled   <none>   v1.30.4
kubectl get pods -A -o wide --field-selector spec.nodeName=node-2
# Només hi han de quedar pods de DaemonSets (CNI, kube-proxy)

La trampa: drain ja fa cordon. Si falla per un pod solt sense controlador, afegeix --force.


Tasca 4 — RBAC per a l'equip de suport (pes ~6 %, objectiu: 6 min)

Context: kubectl config use-context rutas-norte-pro

Crea la ServiceAccount suport a rutas-norte-pro. Concedeix-li permís per veure pods i llegir-ne els logs en aquest namespace, i res més. Verifica el resultat.

kubectl create serviceaccount suport -n rutas-norte-pro

kubectl create role suport-lectura \
  --verb=get,list,watch \
  --resource=pods,pods/log \
  -n rutas-norte-pro

kubectl create rolebinding suport-lectura-binding \
  --role=suport-lectura \
  --serviceaccount=rutas-norte-pro:suport \
  -n rutas-norte-pro

Comprovació:

kubectl auth can-i get pods --as=system:serviceaccount:rutas-norte-pro:suport -n rutas-norte-pro
# yes
kubectl auth can-i delete pods --as=system:serviceaccount:rutas-norte-pro:suport -n rutas-norte-pro
# no
kubectl auth can-i get pods --as=system:serviceaccount:rutas-norte-pro:suport -n rutas-norte-dev
# no

La trampa: pods/log és un subrecurs independent. Sense ell, kubectl logs falla encara que puguis llistar pods.


Tasca 5 — PV, PVC i Pod que l'utilitza (pes ~7 %, objectiu: 8 min)

Context: kubectl config use-context rutas-norte-pre

Crea un PersistentVolume pv-informes de 2Gi, mode ReadWriteOnce, hostPath a /mnt/informes, amb storageClassName: manual. Crea un PVC pvc-informes d'1Gi que el consumeixi, i un Pod informes-ocupacio amb imatge busybox:1.36 que el munti a /dades i executi sleep 3600.

# informes.yaml
apiVersion: v1
kind: PersistentVolume
metadata:
  name: pv-informes
spec:
  capacity:
    storage: 2Gi
  accessModes:
  - ReadWriteOnce
  persistentVolumeReclaimPolicy: Retain
  storageClassName: manual
  hostPath:
    path: /mnt/informes
---
apiVersion: v1
kind: PersistentVolumeClaim
metadata:
  name: pvc-informes
  namespace: rutas-norte-pre
spec:
  accessModes:
  - ReadWriteOnce
  storageClassName: manual
  resources:
    requests:
      storage: 1Gi
---
apiVersion: v1
kind: Pod
metadata:
  name: informes-ocupacio
  namespace: rutas-norte-pre
spec:
  containers:
  - name: informes
    image: busybox:1.36
    command: ["sleep", "3600"]
    volumeMounts:
    - name: dades
      mountPath: /dades
  volumes:
  - name: dades
    persistentVolumeClaim:
      claimName: pvc-informes
kubectl apply -f informes.yaml

Comprovació:

kubectl get pv,pvc -n rutas-norte-pre
NAME                          CAPACITY   ACCESS MODES   STATUS   CLAIM
persistentvolume/pv-informes   2Gi        RWO            Bound    rutas-norte-pre/pvc-informes

NAME                                 STATUS   VOLUME        CAPACITY
persistentvolumeclaim/pvc-informes   Bound    pv-informes   2Gi

La trampa: si el storageClassName no coincideix exactament entre PV i PVC, el PVC es queda en Pending per sempre. I el PV és d'àmbit de clúster: no porta namespace.


Tasca 6 — Node NotReady (pes ~8 %, objectiu: 8 min)

Context: kubectl config use-context rutas-norte-pro

El node node-3 apareix com a NotReady. Investiga-ho i torna'l a l'estat Ready sense reinstal·lar res.

kubectl get nodes
kubectl describe node node-3 | tail -20

# Entrar al node
ssh node-3
sudo systemctl status kubelet
sudo journalctl -u kubelet -n 40 --no-pager

Sortida típica del diagnòstic:

● kubelet.service - kubelet: The Kubernetes Node Agent
     Loaded: loaded (/lib/systemd/system/kubelet.service; disabled)
     Active: inactive (dead)
sudo systemctl enable --now kubelet
sudo systemctl status kubelet
exit

kubectl get nodes
NAME     STATUS   ROLES    AGE   VERSION
node-3   Ready    <none>   42d   v1.30.4

La trampa: enable a més de start. Si només fas start, el corrector pot reiniciar el node i tornaràs a suspendre. Si el kubelet arrenca però mor, mira journalctl: sol ser una ruta mal posada a /var/lib/kubelet/config.yaml o un kubeconfig invàlid.


Tasca 7 — NetworkPolicy d'aïllament (pes ~7 %, objectiu: 7 min)

Context: kubectl config use-context rutas-norte-pro

A rutas-norte-pro, postgres-reserves només ha d'acceptar trànsit entrant al port 5432 des de pods amb l'etiqueta app=api-reserves del mateix namespace. Tota la resta, denegat.

# np-postgres.yaml
apiVersion: networking.k8s.io/v1
kind: NetworkPolicy
metadata:
  name: postgres-nomes-api
  namespace: rutas-norte-pro
spec:
  podSelector:
    matchLabels:
      app: postgres-reserves
  policyTypes:
  - Ingress
  ingress:
  - from:
    - podSelector:
        matchLabels:
          app: api-reserves
    ports:
    - protocol: TCP
      port: 5432
kubectl apply -f np-postgres.yaml

Comprovació:

# Ha de funcionar
kubectl run test-ok --rm -it --image=busybox:1.36 \
  --labels=app=api-reserves -n rutas-norte-pro --restart=Never \
  -- nc -zv postgres-reserves 5432

# Ha de fallar (timeout)
kubectl run test-ko --rm -it --image=busybox:1.36 \
  --labels=app=intrus -n rutas-norte-pro --restart=Never \
  -- nc -zv -w 3 postgres-reserves 5432

La trampa: declarar policyTypes: [Ingress] és el que fa que la política denegui tot allò no permès. Si l'omets i no hi ha regles d'egress, el comportament no és el que esperes. I el CNI ha de suportar NetworkPolicies (Calico sí; el CNI per defecte de kind, no).


Tasca 8 — Actualitzar un node treballador (pes ~9 %, objectiu: 12 min)

Context: kubectl config use-context rutas-norte-pro

Actualitza el node treballador node-1 de la versió 1.30.4 a la 1.31.1. El pla de control ja està a 1.31.1.

# Des del node de control
kubectl drain node-1 --ignore-daemonsets --delete-emptydir-data

# A node-1 per ssh
ssh node-1
sudo apt-get update
sudo apt-mark unhold kubeadm
sudo apt-get install -y kubeadm=1.31.1-1.1
sudo apt-mark hold kubeadm

sudo kubeadm upgrade node

sudo apt-mark unhold kubelet kubectl
sudo apt-get install -y kubelet=1.31.1-1.1 kubectl=1.31.1-1.1
sudo apt-mark hold kubelet kubectl

sudo systemctl daemon-reload
sudo systemctl restart kubelet
exit

# De tornada al node de control
kubectl uncordon node-1

Comprovació:

kubectl get nodes
NAME          STATUS   ROLES           VERSION
node-control  Ready    control-plane   v1.31.1
node-1        Ready    <none>          v1.31.1

La trampa: als treballadors és kubeadm upgrade node, mai upgrade apply. I si el repositori de paquets està fixat a la minor 1.30, primer cal canviar la URL del repositori de pkgs.k8s.io a v1.31, o apt no veurà la versió nova.


Errors Comuns i Consells

Errors que costen punts a l'examen

Error Conseqüència Prevenció
No executar el use-context de la tasca Zero punts en una tasca perfecta Primera comanda de cada tasca, sempre
Oblidar el -n <namespace> demanat L'objecte es crea a default i no puntua Fer servir kubectl config set-context --current --namespace=X
Escriure YAML des de zero Se't va el temps i hi fiques errors d'indentació Fer servir --dry-run=client -o yaml o copiar de la documentació
Perseverar en una tasca difícil Deixes 4 tasques fàcils sense fer Límit de temps per tasca; marcar i saltar
No verificar el que has fet Et penses que puntues i no Un kubectl get/describe de tancament per tasca
Deixar la tasca en blanc Perds la puntuació parcial Fes sempre la part que sàpigues
Fer servir apt-get upgrade en lloc d'instal·lar la versió exacta Trenques el clúster apt-get install -y kubelet=<versio>
Restaurar etcd sobre /var/lib/etcd La restauració falla o corromp Restaurar a un directori nou
drain sense --ignore-daemonsets La comanda falla i perds minuts Posa-l'hi sempre

Consells de preparació

  1. Practica en un clúster real, no llegint. El CKA s'aprova amb les mans.
  2. Cronometra des del dia u. Saber fer alguna cosa en 15 minuts no serveix si l'objectiu són 6.
  3. Domina kubectl explain. kubectl explain pod.spec.containers.livenessProbe --recursive t'estalvia obrir el navegador.
  4. Tingues la documentació al cap com un mapa. No memoritzis YAML: memoritza en quina pàgina és.
  5. Aprèn a llegir esdeveniments. kubectl describe pod i kubectl get events --sort-by=.lastTimestamp resolen la meitat del domini de troubleshooting.
  6. Treballa amb sudo còmode. Moltes tasques d'administració són al node, no a kubectl.
  7. Simula l'entorn de l'examen. Mateix navegador, mateix terminal, mateix teclat. Redueix fricció el dia D.

Exercicis

Exercici 1 — Construeix el teu propi mapa d'estudi

Agafa el temari oficial vigent del CKA (descarrega'l del repositori cncf/curriculum) i, per a cada objectiu, anota en una taula pròpia tres coses: la lliçó d'aquest curs on es cobreix, el teu nivell de confiança de l'1 al 5, i si el sabries resoldre sense documentació. Ordena la taula per confiança ascendent: aquest ordre és el teu pla de repàs.

Exercici 2 — Bloc cronometrat d'administració

En un clúster de tres nodes muntat amb kubeadm (o VM), resol en 30 minuts seguits i sense pauses:

  1. Còpia de seguretat d'etcd a /opt/backup.db i verificació amb snapshot status.
  2. Drenar node-1, actualitzar-ne el kubelet a la següent versió de pedaç, tornar-lo al servei.
  3. Crear la ServiceAccount auditor amb permisos de només lectura sobre pods i services a tots els namespaces, i demostrar-ho amb auth can-i.

Exercici 3 — Trenca i arregla el pla de control

Provoca deliberadament aquestes tres fallades, d'una en una, i arregla cadascuna mesurant el temps:

  1. Canvia el port de --secure-port a /etc/kubernetes/manifests/kube-apiserver.yaml a 6444.
  2. Reanomena /etc/kubernetes/pki/etcd/server.key a server.key.bak.
  3. Canvia staticPodPath a /var/lib/kubelet/config.yaml a /etc/kubernetes/manifestos.

Objectiu: diagnosticar i arreglar cadascuna en menys de 6 minuts.


Solucions

Solució a l'Exercici 1

No hi ha una solució única, però la teva taula s'ha d'assemblar a aquesta (extracte); el criteri decisiu és l'última columna:

Objectiu Lliçó Confiança Sense docs?
Backup/restore d'etcd 05-06 + apartat 5.3 2 No
Crear un Deployment i escalar-lo 02-03 5
NetworkPolicy de denegació 04-06 3 No
Actualitzar el clúster 10-02 2 No
Diagnosticar un pod en CrashLoop 07-06 4

Tot el que tingui confiança ≤ 3 i "No" a l'última columna va a les setmanes 4 i 5 del pla. La trampa habitual és puntuar-se alt en allò que s'entén però mai no s'ha executat: si no ho has fet amb les mans aquesta setmana, la confiança és 3 com a màxim.

Solució a l'Exercici 2

Bloc d'etcd (objectiu 8 min):

sudo ETCDCTL_API=3 etcdctl snapshot save /opt/backup.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

sudo ETCDCTL_API=3 etcdctl --write-out=table snapshot status /opt/backup.db
+----------+----------+------------+------------+
|   HASH   | REVISION | TOTAL KEYS | TOTAL SIZE |
+----------+----------+------------+------------+
| 8f2e91ac |    41207 |       1382 |     5.9 MB |
+----------+----------+------------+------------+

Bloc de node (objectiu 15 min):

kubectl drain node-1 --ignore-daemonsets --delete-emptydir-data

ssh node-1 '
  sudo apt-get update &&
  sudo apt-mark unhold kubelet kubectl &&
  sudo apt-get install -y kubelet=1.30.5-1.1 kubectl=1.30.5-1.1 &&
  sudo apt-mark hold kubelet kubectl &&
  sudo systemctl daemon-reload && sudo systemctl restart kubelet'

kubectl uncordon node-1
kubectl get nodes

Per a un canvi només de pedaç (1.30.4 → 1.30.5) n'hi ha prou amb actualitzar el kubelet; en un canvi de versió menor caldria a més sudo kubeadm upgrade node.

Bloc d'RBAC (objectiu 7 min): en ser "tots els namespaces", exigeix ClusterRole + ClusterRoleBinding:

kubectl create serviceaccount auditor -n rutas-norte-pro
kubectl create clusterrole auditor-lectura --verb=get,list,watch --resource=pods,services
kubectl create clusterrolebinding auditor-lectura-binding \
  --clusterrole=auditor-lectura --serviceaccount=rutas-norte-pro:auditor

kubectl auth can-i list services --as=system:serviceaccount:rutas-norte-pro:auditor -A   # yes
kubectl auth can-i create pods  --as=system:serviceaccount:rutas-norte-pro:auditor -A    # no

L'error clàssic és fer servir Role+RoleBinding: només cobriria un namespace. El segon error és ClusterRole amb RoleBinding, que restringeix els permisos a un namespace concret —útil en altres casos, però no és el que es demana.

Solució a l'Exercici 3

Fallada provocada Símptoma Arranjament
--secure-port=6444 a l'apiserver kubectl respon The connection to the server ... was refused; el contenidor arrenca i mor Tornar a 6443 i ajustar també el port a livenessProbe i readinessProbe: el manifest ho repeteix en tres llocs i canviar-ne només un deixa el pod en bucle
server.key d'etcd reanomenada L'API no respon; els logs d'etcd mostren no such file or directory Restaurar el nom i deixar-lo en chmod 600, root:root. Amb permisos incorrectes el símptoma és idèntic, i l'arranjament és només el chmod/chown
staticPodPath canviat Tots els pods del pla de control desapareixen alhora; aquesta simultaneïtat el delata davant d'una fallada aïllada Restaurar staticPodPath: /etc/kubernetes/manifests a /var/lib/kubelet/config.yaml i reiniciar el kubelet

La seqüència de diagnòstic és sempre la mateixa, i val la pena automatitzar-la:

kubectl get nodes                              # respon l'API?
sudo systemctl status kubelet                  # viu el kubelet?
sudo journalctl -u kubelet -n 40 --no-pager
sudo crictl ps -a                              # quins contenidors del pla de control hi ha?
sudo crictl logs <container-id>
ls -l /etc/kubernetes/manifests/

Diferència clau que aquest exercici grava: els manifests de /etc/kubernetes/manifests/ els rellegeix el kubelet sol, en segons; /var/lib/kubelet/config.yaml que requereix sudo systemctl restart kubelet per fer efecte.


Conclusió

El CKA no mesura si saps Kubernetes en abstracte: mesura si saps operar un clúster amb les mans i amb pressa. Després d'onze mòduls construint Rutas Norte, el coneixement ja el tens; el que aquesta lliçó t'ha donat és la traducció d'aquest coneixement al llenguatge de l'examen.

Els punts que t'has d'endur:

  • El CKA certifica el perfil d'administració: nodes, pla de control, etcd, xarxa, emmagatzematge, RBAC i, sobretot, diagnòstic (el domini de més pes, al voltant del 30 %).
  • L'examen és pràctic, cronometrat i amb diversos clústers. El use-context és la primera comanda de cada tasca, sense excepció.
  • Hi ha puntuació parcial: no deixis mai una tasca buida.
  • Pots consultar la documentació oficial i només aquesta. Estudia on és cada cosa, no memoritzis YAML.
  • La taula de l'apartat 4 converteix aquest curs en el teu pla d'estudi: cada objectiu oficial té la seva lliçó.
  • Set procediments cal tenir-los automatitzats: kubeadm, upgrade, etcd, certificats, drain, pla de control trencat i RBAC.
  • Consulta sempre el temari oficial vigent al web de la Linux Foundation / CNCF abans de matricular-te: pesos, durada i condicions canvien.

A la lliçó següent canviem de perfil. Si el CKA és la certificació de qui manté el clúster, el CKAD és la de qui construeix a sobre: menys etcd i més manifests d'aplicació, menys administració i molta més velocitat amb kubectl. Veurem en què es diferencien, quins dominis hi entren i com s'entrena la competència que decideix aquest examen: fer moltes coses correctes en molt poc temps.

Curs de Kubernetes

Mòdul 1: Introducció a Kubernetes

Mòdul 2: Components Principals de Kubernetes

Mòdul 3: Gestió de Configuració i Secrets

Mòdul 4: Xarxes a Kubernetes

Mòdul 5: Emmagatzematge a Kubernetes

Mòdul 6: Conceptes Avançats de Kubernetes

Mòdul 7: Monitoratge i Registre

Mòdul 8: Seguretat a Kubernetes

Mòdul 9: Escalat i Rendiment

Mòdul 10: Ecosistema i Eines de Kubernetes

Mòdul 11: Estudis de Cas i Aplicacions del Món Real

Mòdul 12: Preparació per a la Certificació de Kubernetes

© Copyright 2026. Tots els drets reservats