CKAD sin filtros: sí, puedes (y debes) usar la documentación de Kubernetes como un arma

Kubernetes es una de esas tecnologías con las que consigues tener algo funcionando rápido, pero dominarla de verdad exige método,
repetición y práctica real bajo presión de tiempo. Justo eso es lo que pone a prueba el examen CKAD.

🧠 Mi objetivo: de usuario a operador de Kubernetes

Prepararme el CKAD no va de coleccionar certificaciones. Va de ganar verdadera soltura operativa con:

• Workloads (Pods, Deployments, Jobs, CronJobs)
• Configuración (ConfigMaps, Secrets)
• Red (Services, Ingress)
• Almacenamiento (PVCs, StorageClasses)

Mi objetivo es simple: ver un problema de Kubernetes y saber al instante cuál es el YAML mínimo necesario para resolverlo.

📚 Cómo me estoy preparando el CKAD

Para prepararme uso KodeKloud como plataforma principal de aprendizaje.
En concreto, me centro sobre todo en sus CKAD Mock Exams.

Estos simulacros son tremendamente valiosos porque reproducen el entorno real del examen:

• Presión de tiempo (este es el verdadero reto)
• Problemas de Kubernetes basados en tareas
• Crear y editar YAML con tus propias manos
• Flujos de trabajo a base de kubectl (sin paja teórica)

La meta no es solo «aprender Kubernetes», sino desarrollar memoria muscular para resolver tareas rápido y bien.

⚡ Lo que de verdad evalúa el examen CKAD

El CKAD no consiste en memorizar YAML. Consiste en generarlo, adaptarlo y simplificarlo con el reloj en contra.

No te premian por un YAML perfecto: te premian por soluciones que funcionan, entregadas rápido.

El flujo de trabajo se vuelve casi mecánico:

kubectl create deployment myapp --image=nginx --dry-run=client -o yaml
vim myapp.yaml
kubectl apply -f myapp.yaml

Generar → Recortar → Desplegar → Repetir.

📚 Cómo usar bien la documentación de Kubernetes

La documentación de Kubernetes está permitida en el examen, y es clave.

Pero la verdadera habilidad no es leerla. La verdadera habilidad es:

• encontrar rápido el ejemplo correcto
• ignorar los campos innecesarios
• reducir el YAML al mínimo absoluto

La mayoría de los ejemplos oficiales son prolijos a propósito. En el CKAD:
la verbosidad es tu enemiga.

⚡ kubectl es el verdadero truco

La forma más rápida de crear recursos no es escribir YAML, sino generarlo:

kubectl create deployment myapp --image=nginx --dry-run=client -o yaml
kubectl create job myjob --image=busybox --dry-run=client -o yaml
kubectl create cronjob mycron --image=busybox --schedule="*/5 * * * *" --dry-run=client -o yaml

Así te quitas de encima la carga de la sintaxis y puedes centrarte en resolver el problema.

🧠 kubectl explain: tu documentación integrada

kubectl explain pod.spec.containers
kubectl explain deployment.spec.template.spec

Es tu salvavidas cuando se te queda la mente en blanco.

📚 Chuleta de YAML mínimo (la verdadera arma del examen)

Conocer el YAML mínimo que funciona para cada recurso es una de las mayores ventajas en el CKAD.

🚀 Pod

apiVersion: v1
kind: Pod
metadata:
  name: mypod
spec:
  containers:
    - name: c1
      image: nginx

Se necesita a menudo: ports, env, volumeMounts

🚀 Deployment

apiVersion: apps/v1
kind: Deployment
metadata:
  name: mydeploy
spec:
  replicas: 1
  selector:
    matchLabels:
      app: myapp
  template:
    metadata:
      labels:
        app: myapp
    spec:
      containers:
        - name: c1
          image: nginx

Se necesita a menudo: replicas, resources, probes

🚀 Service

apiVersion: v1
kind: Service
metadata:
  name: mysvc
spec:
  selector:
    app: myapp
  ports:
    - port: 80
      targetPort: 80

Se necesita a menudo: type: NodePort / ClusterIP

🚀 ConfigMap

apiVersion: v1
kind: ConfigMap
metadata:
  name: myconfig
data:
  key: value

🚀 Secret

apiVersion: v1
kind: Secret
metadata:
  name: mysecret
type: Opaque
data:
  password: cGFzcw==

🚀 Job

apiVersion: batch/v1
kind: Job
metadata:
  name: myjob
spec:
  template:
    spec:
      containers:
        - name: c1
          image: busybox
          command: ["sh", "-c", "echo hello"]
      restartPolicy: OnFailure

🚀 CronJob

apiVersion: batch/v1
kind: CronJob
metadata:
  name: mycron
spec:
  schedule: "*/5 * * * *"
  jobTemplate:
    spec:
      template:
        spec:
          containers:
            - name: c1
              image: busybox
              command: ["sh", "-c", "echo hello"]
          restartPolicy: OnFailure

🚀 PVC

apiVersion: v1
kind: PersistentVolumeClaim
metadata:
  name: mypvc
spec:
  accessModes:
    - ReadWriteOnce
  resources:
    requests:
      storage: 1Gi

🚀 Guía de supervivencia CKAD: chuleta de kubectl

No escribas YAML. Genéralo.

⚙️ Flujo de trabajo básico

kubectl create/run ... --dry-run=client -o yaml > resource.yaml
vim resource.yaml
kubectl apply -f resource.yaml

⚡ Generadores imprescindibles

kubectl run mypod --image=nginx --dry-run=client -o yaml
kubectl create deployment mydeploy --image=nginx --dry-run=client -o yaml
kubectl create job myjob --image=busybox --dry-run=client -o yaml
kubectl create cronjob mycron --image=busybox --schedule="*/5 * * * *" --dry-run=client -o yaml

🔍 Depuración

kubectl get pods
kubectl describe pod mypod
kubectl logs mypod
kubectl exec -it mypod -- sh

⚡ Trucos para ir más rápido

alias k=kubectl
kubectl get pod mypod -o yaml
kubectl edit deployment mydeploy

🔥 Reflexiones finales

• Gana el YAML mínimo
• Usa los generadores de kubectl
• Piensa en flujos de trabajo, no en sintaxis

El CKAD no es un examen de conocimientos: es un examen de velocidad y ejecución.

Si lo entrenas como es debido, aprobar el examen se convierte en un efecto secundario.

Happy hacking 🧠⚡