El módulo de calentamiento. Aliases, dry-run como generador de YAML, y la diferencia imperativo/declarativo que te ahorra el 20% del tiempo en el examen. Sin esto, todo lo demás es lento.
--dry-run, y saber cuándo usar imperativo vs declarativo.
El CKA corre sobre un cluster armado con kubeadm sobre máquinas Linux reales. El mejor entorno de práctica es el que más se parece al examen: 3 VMs Ubuntu con kubeadm.
El setup completo paso a paso está en su propia guía (CKA_Setup_VMs_kubeadm.html), con la estrategia de snapshots para repetir escenarios destructivos. Topología:
kind corre cada nodo como contenedor Docker, sin systemd real. No podés practicar kubeadm, etcd backup/restore, ni systemctl restart kubelet — que juntos son más del 40% del examen.
minikube es mejor que kind pero tampoco te da kubeadm-from-scratch ni el control total del control plane que el examen evalúa.
El examen evalúa tareas que solo tienen sentido con nodos reales y múltiples:
Como muchos ejercicios son destructivos (romper el cluster a propósito para troubleshooting), los snapshots te dan repetición infinita: rompés, arreglás, restaurás, repetís.
Apenas empieza el examen, antes de leer la primera pregunta, tipeás esto:
# El alias k ya viene seteado en el examen, pero por si acaso:
alias k=kubectl
# Generador de YAML — el más importante
export do="--dry-run=client -o yaml"
# Borrado instantáneo (sin esperar grace period)
export now="--force --grace-period=0"
# Autocompletado (suele venir activo, verificalo)
source <(kubectl completion bash)
complete -F __start_kubectl k
# Generar YAML de un pod sin crearlo (con el alias $do)
k run nginx --image=nginx $do > pod.yaml
# Borrar un pod al instante (con $now)
k delete pod nginx $now
k, $do y $now son suficientes. Más que eso es contraproducente bajo presión.Tipear kubectl completo vs k: son 7 caracteres menos por comando. En un examen donde tipeás ~100+ comandos, eso es tiempo real.
Pero el ahorro grande es $do. Escribir --dry-run=client -o yaml son 27 caracteres que vas a tipear decenas de veces. Con el alias son 3.
| Alias | Para qué |
|---|---|
| k | kubectl (siempre) |
| $do | generar YAML sin aplicar |
| $now | borrar sin esperar |
k desde el día 1, para el examen ya es automático. Si lo dejás para el final, vas a tipear kubectl por costumbre y perdés el beneficio.Un comando que ejecuta una acción directa. Rápido, ideal para objetos simples.
# Crear un pod directo
k run nginx --image=nginx
# Crear un deployment
k create deployment web --image=nginx --replicas=3
# Exponer como service
k expose deployment web --port=80 --type=ClusterIP
# Crear configmap desde literales
k create configmap app-cfg --from-literal=KEY=value
# Escalar
k scale deployment web --replicas=5
Un archivo YAML que define cómo querés que sea el objeto. Necesario para configuraciones complejas.
# Aplicar un manifiesto
k apply -f deployment.yaml
# Aplicar todos los YAML de un directorio
k apply -f ./manifests/
$do, después editás el YAML solo para lo que el comando no soporta. Nunca escribas YAML desde cero.| Situación | Modo |
|---|---|
| Objeto simple (pod, deploy) | Imperativo |
| Necesita campos no soportados por flags | Genera + edita |
| Multi-container, volumes, probes | Declarativo |
| Borrar / escalar / exponer rápido | Imperativo |
Algunas cosas requieren YAML sí o sí porque no hay flag:
Para estos: generás el esqueleto con $do y agregás a mano solo el bloque que falta.
Esta es LA técnica del CKA. En vez de escribir YAML desde cero (lento, propenso a errores de indentación), generás el esqueleto y editás.
# 1. Generar el esqueleto YAML (NO crea nada todavía)
k run nginx --image=nginx $do > pod.yaml
# 2. Editar el YAML para agregar lo que falta
vim pod.yaml
# (agregás resources, volumes, probes, etc.)
# 3. Crear desde el YAML editado
k apply -f pod.yaml
# Pod
k run nginx --image=nginx $do
# Deployment con replicas
k create deploy web --image=nginx --replicas=3 $do
# Service (requiere que exista el deploy o usar --dry-run sobre expose)
k expose deploy web --port=80 $do
# Job
k create job pi --image=perl -- perl -Mbignum=bpi -wle 'print bpi(20)' $do
# CronJob
k create cronjob backup --image=busybox --schedule="*/5 * * * *" $do
# ConfigMap y Secret
k create cm app --from-literal=K=V $do
k create secret generic db --from-literal=pass=1234 $do
# Pod que ejecuta un comando y termina
k run test --image=busybox $do -- /bin/sh -c "sleep 3600" > pod.yaml
| Flag | Qué hace |
|---|---|
| --dry-run=client | simula, no envía al API server |
| -o yaml | output en formato YAML |
| > archivo | guarda en archivo en vez de stdout |
client: solo valida localmente y muestra el YAML. NO toca el cluster. Es el que usás para generar.
server: envía al API server que valida pero no persiste. Útil para testear que algo es válido sin crearlo.
=client. El =server es para validación avanzada, rara vez en el examen.Escribir YAML a mano en vim bajo presión = errores de indentación que te hacen perder minutos. Generar el esqueleto correcto y solo editar elimina el 90% de esos errores.
~/.vimrc al practicar): set et ts=2 sw=2 — expande tabs a 2 espacios, esencial para que el YAML no se rompa.# Los 3 aliases (primeros 30 segundos)
alias k=kubectl
export do="--dry-run=client -o yaml"
export now="--force --grace-period=0"
# vim para YAML
# ~/.vimrc: set et ts=2 sw=2
# El patrón maestro
k <crear-algo> $do > obj.yaml # generar
vim obj.yaml # editar
k apply -f obj.yaml # aplicar
$do$nowEn DP-700 ganabas eligiendo la respuesta correcta. En CKA ganás ejecutando correcto Y rápido. El conocimiento es necesario pero no suficiente — la velocidad es lo que separa.
$do.