CKA · Módulo 8 · Storage

Almacenamiento	Sobrevive a
Filesystem del container	nada (se pierde al reiniciar)
Container filesystem	nothing (lost on restart)
Filesystem del container	nulla (perso al riavvio)
`emptyDir`	reinicio del container
`emptyDir`	a container restart
`emptyDir`	il riavvio del container
`hostPath`	borrado del pod (no al cambio de nodo)
`hostPath`	pod deletion (not a node change)
`hostPath`	la cancellazione del pod (non il cambio di nodo)
PV / PVC	todo: pod, nodo, cluster
PV / PVC	everything: pod, node, cluster
PV / PVC	tutto: pod, nodo, cluster

	PV	PVC
Scope	Cluster	Namespace
Scope	Cluster	Namespace
Scope	Cluster	Namespace
Lo crea	Admin (o la SC)	El dev
Created by	Admin (or the SC)	The developer
Creato da	Admin (o la SC)	Il dev
Expresa	Lo que hay	Lo que se necesita
Expresses	What exists	What is needed
Esprime	Ciò che c'è	Ciò che serve
Análogo	El disco	El vale por un disco
Analogy	The disk	The voucher for a disk
Analogia	Il disco	Il buono per un disco

Fase	Significa
Available	Libre, esperando una claim
Available	Free, waiting for a claim
Available	Libero, in attesa di una claim
Bound	Asignado a una PVC
Bound	Assigned to a PVC
Bound	Assegnato a una PVC
Released	La PVC se borró, los datos siguen ahí
Released	The PVC was deleted, the data is still there
Released	La PVC è stata cancellata, i dati sono ancora lì
Failed	Falló la recuperación automática
Failed	Automatic reclamation failed
Failed	Il recupero automatico è fallito

	Estático	Dinámico
Quién crea el PV	El admin, a mano	El provisioner
Who creates the PV	The admin, by hand	The provisioner
Chi crea il PV	L'admin, a mano	Il provisioner
Cuándo	Antes de la PVC	Al crear la PVC
When	Before the PVC	When the PVC is created
Quando	Prima della PVC	Alla creazione della PVC
Requiere SC	No	Sí
Requires an SC	No	Yes
Richiede una SC	No	Sì
Dónde se ve	Labs, bare-metal, CKA	Nube, producción
Where you see it	Labs, bare metal, CKA	Cloud, production
Dove si vede	Lab, bare metal, CKA	Cloud, produzione

Modo	Abrev.	Alcance
ReadWriteOnce	RWO	Un nodo, R/W
ReadWriteOnce	RWO	One node, R/W
ReadWriteOnce	RWO	Un nodo, R/W
ReadOnlyMany	ROX	Varios nodos, solo lectura
ReadOnlyMany	ROX	Several nodes, read only
ReadOnlyMany	ROX	Più nodi, sola lettura
ReadWriteMany	RWX	Varios nodos, R/W
ReadWriteMany	RWX	Several nodes, R/W
ReadWriteMany	RWX	Più nodi, R/W
ReadWriteOncePod	RWOP	Un solo pod, R/W
ReadWriteOncePod	RWOP	One single pod, R/W
ReadWriteOncePod	RWOP	Un solo pod, R/W

Política	El PV…	Los datos…
Retain	queda Released	se conservan
Retain	becomes Released	are kept
Retain	diventa Released	si conservano
Delete	se borra	se borran
Delete	is deleted	are deleted
Delete	viene cancellato	vengono cancellati
Recycle	deprecado, no lo uses
Recycle	deprecated, do not use it
Recycle	deprecato, non usarlo

Causa	Cómo se ve
storageClassName distinto	no PV available
Different storageClassName	no PV available
storageClassName diverso	no PV available
Pide más de lo que hay	no PV available
Asks for more than exists	no PV available
Chiede più di quel che c'è	no PV available
accessMode no ofrecido	no PV available
accessMode not offered	no PV available
accessMode non offerto	no PV available
La SC no existe	storageclass not found
The SC does not exist	storageclass not found
La SC non esiste	storageclass not found
WaitForFirstConsumer	waiting for first consumer
WaitForFirstConsumer	waiting for first consumer
WaitForFirstConsumer	waiting for first consumer

★

Fase 2 · resolver en vivo

Phase 2 · solve it live

Fase 2 · risolvere dal vivo

Práctica — 8 ejercicios

Practice — 8 exercises

Pratica — 8 esercizi

Todo se escribe a mano: no hay imperativo para PV ni PVC. Cronometrate.

Everything is written by hand: there is no imperative for PVs or PVCs. Time yourself.

Tutto si scrive a mano: non c'è imperativo per PV o PVC. Cronometrati.

0 / 8

🧠

Modelo mental. PVC = pedido → PV = oferta → el pod monta la PVC. Cada ejercicio se verifica igual: k get pv,pvc y, si algo está Pending, k describe pvc. Ese último evento es literalmente la respuesta — el dominio entero se resuelve leyendo, no adivinando.

Mental model. PVC = request → PV = supply → the pod mounts the PVC. Every exercise is verified the same way: k get pv,pvc and, if something is Pending, k describe pvc. That last event is literally the answer — the whole domain is solved by reading, not guessing.

Modello mentale. PVC = richiesta → PV = offerta → il pod monta la PVC. Ogni esercizio si verifica allo stesso modo: k get pv,pvc e, se qualcosa è Pending, k describe pvc. Quell'ultimo evento è letteralmente la risposta — l'intero dominio si risolve leggendo, non indovinando.

◆

Manifests publicados. Cada ejercicio tiene su YAML servido por este mismo sitio: k apply -f <url>/manifests/m8e1.yaml. Los E son la solución de referencia; los T plantan el problema — aplicalos y diagnosticá sin leerlos. Todos crean el namespace m8 y usan hostPath con type: DirectoryOrCreate, así que no hace falta entrar a ningún nodo. Los PV son cluster-scoped y van etiquetados ej=m8: k delete pv -l ej=m8. Ojo con E3, que crea una StorageClass default del cluster — k delete -f la saca.

Published manifests. Every exercise has its YAML served by this very site: k apply -f <url>/manifests/m8e1.yaml. The E ones are the reference solution; the T ones plant the problem — apply them and diagnose without reading them. All create namespace m8 and use hostPath with type: DirectoryOrCreate, so you never have to shell into a node. PVs are cluster-scoped and labelled ej=m8: k delete pv -l ej=m8. Watch out for E3, which creates a cluster default StorageClass — k delete -f removes it.

Manifest pubblicati. Ogni esercizio ha il suo YAML servito da questo stesso sito: k apply -f <url>/manifests/m8e1.yaml. Gli E sono la soluzione di riferimento; i T piantano il problema — applicali e diagnostica senza leggerli. Tutti creano il namespace m8 e usano hostPath con type: DirectoryOrCreate, quindi non devi entrare in nessun nodo. I PV sono cluster-scoped ed etichettati ej=m8: k delete pv -l ej=m8. Attenzione all'E3, che crea una StorageClass default del cluster — k delete -f la toglie.

◆

Preparación. Nada de esto rompe el cluster. Los PVs son cluster-scoped, así que etiquetalos (ej=storage) para limpiarlos después: k delete pv -l ej=storage. Para los hostPath, creá el directorio en el nodo primero: sudo mkdir -p /mnt/datos en el worker donde vaya a caer el pod.

Setup. None of this breaks the cluster. PVs are cluster-scoped, so label them (ej=storage) to clean up later: k delete pv -l ej=storage. For hostPath, create the directory on the node first: sudo mkdir -p /mnt/datos on whichever worker the pod will land on.

Preparazione. Nulla di questo rompe il cluster. I PV sono cluster-scoped, quindi etichettali (ej=storage) per ripulire dopo: k delete pv -l ej=storage. Per gli hostPath, crea prima la directory sul nodo: sudo mkdir -p /mnt/datos sul worker dove finirà il pod.

emptyDir entre dos containers

emptyDir between two containers

emptyDir fra due container

~5 min hecho

Creá un pod par con dos containers busybox: uno escribe la fecha cada 5 s en /data/log, el otro hace tail -f del mismo archivo pero montado en /in. Verificá que el lector ve lo que escribe el escritor. Después matá el container escritor y comprobá que el archivo sigue ahí cuando reinicia.

Create a pod par with two busybox containers: one writes the date every 5 s into /data/log, the other tail -fs the same file but mounted at /in. Verify the reader sees what the writer writes. Then kill the writer container and check the file is still there when it restarts.

Crea un pod par con due container busybox: uno scrive la data ogni 5 s in /data/log, l'altro fa tail -f dello stesso file ma montato in /in. Verifica che il lettore veda ciò che scrive lo scrittore. Poi uccidi il container scrittore e controlla che il file sia ancora lì al riavvio.

Ver soluciónShow solutionMostra soluzione

manifest · soluciónmanifest · solutionmanifest · soluzione

# el YAML de la sección 8.1, aplicado tal cual# the YAML from section 8.1, applied as-is# lo YAML della sezione 8.1, applicato così com'è
k apply -f par.yaml

k logs par -c lector -f
k exec par -c lector -- ls -l /in/log
k exec par -c lector -- df -h /in

# matar el proceso del escritor: el container reinicia, el archivo queda# kill the writer's process: the container restarts, the file stays# uccidi il processo dello scrittore: il container riparte, il file resta
k exec par -c escritor -- kill 1
k get pod par                # RESTARTS: 1# RESTARTS: 1# RESTARTS: 1
k exec par -c lector -- wc -l /in/log   # las líneas viejas siguen# the old lines are still there# le righe vecchie ci sono ancora

Claves

Key points

Punti chiave

El mismo volumen, dos mountPath distintos. Lo que tiene que coincidir es el name, no la ruta.
emptyDir sobrevive al reinicio del container, no al borrado del pod. Esa es la línea exacta.
Es el mecanismo natural para initContainers: preparan algo en el volumen y el container principal lo lee.

Same volume, two different mountPaths. What must match is the name, not the path.
emptyDir survives a container restart, not pod deletion. That is the exact line.
It is the natural mechanism for initContainers: they prepare something in the volume and the main container reads it.

Stesso volume, due mountPath diversi. Ciò che deve corrispondere è il name, non il percorso.
emptyDir sopravvive al riavvio del container, non alla cancellazione del pod. È esattamente questa la linea.
È il meccanismo naturale per gli initContainer: preparano qualcosa nel volume e il container principale lo legge.

El trío completo, y que persista de verdad

The full trio, and real persistence

Il trio completo, e persistenza vera

~8 min hecho

Escribí los tres YAML: un PV pv-datos de 1Gi, RWO, clase manual, reclaim Retain, respaldado por /mnt/datos; una PVC pvc-datos que pida 500Mi; y un pod nginx que la monte en /usr/share/nginx/html. Escribí un archivo, borrá el pod, recrealo y comprobá que el archivo sigue. Después mirá cuánto quedó bindeado.

Write the three YAMLs: a PV pv-datos of 1Gi, RWO, class manual, reclaim Retain, backed by /mnt/datos; a PVC pvc-datos requesting 500Mi; and an nginx pod mounting it at /usr/share/nginx/html. Write a file, delete the pod, recreate it and check the file is still there. Then look at how much ended up bound.

Scrivi i tre YAML: un PV pv-datos da 1Gi, RWO, classe manual, reclaim Retain, con backend /mnt/datos; una PVC pvc-datos che chieda 500Mi; e un pod nginx che la monti in /usr/share/nginx/html. Scrivi un file, cancella il pod, ricrealo e verifica che il file ci sia ancora. Poi guarda quanto è stato legato.

Ver soluciónShow solutionMostra soluzione

manifest · soluciónmanifest · solutionmanifest · soluzione

# los tres YAML de la sección 8.2, aplicados en ese orden# the three YAMLs from section 8.2, applied in that order# i tre YAML della sezione 8.2, applicati in quell'ordine
k apply -f pv.yaml -f pvc.yaml -f pod.yaml
k get pv,pvc

k exec app -- sh -c 'echo hola > /usr/share/nginx/html/i.html'
k delete pod app
k apply -f pod.yaml
k exec app -- cat /usr/share/nginx/html/i.html    #  hola

k get pvc pvc-datos
#   CAPACITY 1Gi — pidió 500Mi y se quedó con el PV entero#   CAPACITY 1Gi — it asked 500Mi and took the whole PV#   CAPACITY 1Gi — ha chiesto 500Mi e ha preso l'intero PV

Claves

Key points

Punti chiave

El pod referencia la PVC, nunca el PV. Si en el pod escribiste el nombre del PV, no bindea nada.
La PVC se quedó con 1Gi, no con los 500Mi que pidió: la relación es uno a uno y no hay subdivisión.
Con hostPath el pod queda atado al nodo donde está el directorio. Si el scheduler lo manda a otro, el archivo "desaparece" — no es magia, es otro disco.

The pod references the PVC, never the PV. Write the PV's name in the pod and nothing binds.
The PVC took 1Gi, not the 500Mi it asked for: the relationship is one-to-one and there is no subdivision.
With hostPath the pod is tied to the node holding that directory. If the scheduler sends it elsewhere the file "vanishes" — no magic, just a different disk.

Il pod referenzia la PVC, mai il PV. Se nel pod scrivi il nome del PV, non lega nulla.
La PVC ha preso 1Gi, non i 500Mi richiesti: la relazione è uno a uno e non c'è suddivisione.
Con hostPath il pod è legato al nodo che ha quella directory. Se lo scheduler lo manda altrove il file "sparisce" — nessuna magia, è un altro disco.

Omitido vs `""`: los tres casos

Omitted vs `""`: the three cases

Omesso contro `""`: i tre casi

~6 min hecho

Creá tres PVCs idénticas salvo por el storageClassName: (a) omitido, (b) "", (c) manual. Predecí el estado de cada una antes de aplicarlas, sabiendo que existe una StorageClass default y el PV de clase manual del E2 ya está Bound. Después comprobá.

Create three PVCs identical except for storageClassName: (a) omitted, (b) "", (c) manual. Predict each one's state before applying, knowing there is a default StorageClass and that E2's manual-class PV is already Bound. Then check.

Crea tre PVC identiche tranne che per storageClassName: (a) omesso, (b) "", (c) manual. Prevedi lo stato di ciascuna prima di applicarle, sapendo che esiste una StorageClass default e che il PV di classe manual dell'E2 è già Bound. Poi verifica.

Ver soluciónShow solutionMostra soluzione

manifest · soluciónmanifest · solutionmanifest · soluzione

(a) omitido → toma la default → provisiona un PV → Boundomitted → takes the default → provisions a PV → Boundomesso → prende la default → fa il provisioning di un PV → Bound
        (o Pending "waiting for first consumer" si es WaitForFirstConsumer)    (or Pending "waiting for first consumer" if it is WaitForFirstConsumer)    (o Pending "waiting for first consumer" se è WaitForFirstConsumer)
(b) ""       → sin dinámico, y no hay PV con "" → Pending para siempre→ no dynamic, and no PV with "" → Pending forever→ niente dinamico, e nessun PV con "" → Pending per sempre
(c) manual   → el único PV manual ya está Bound → Pending→ the only manual PV is already Bound → Pending→ l'unico PV manual è già Bound → Pending

k get pvc
k describe pvc b | tail -5
#   no persistent volumes available for this claim and no storage class is set

Claves

Key points

Punti chiave

Omitir no es lo mismo que "". Omitido = "usá la default"; "" = "sin clase, y no me provisiones nada". Cae en el examen redactado como "sin dynamic provisioning".
El caso (c) muestra la otra mitad: un PV ya bindeado no se comparte. Uno a uno, siempre.
El mensaje del describe distingue las causas: no PV available (no hay candidato) vs storageclass not found (la clase no existe) vs waiting for first consumer (no es un error).
En el lab (kubeadm, sin provisioner) el caso (a) también queda Pending, pero con otro mensaje: waiting for a volume to be created, either by external provisioner.... Ese contraste es la prueba de que omitir sí tomó la default: mirá k get pvc a -o jsonpath='{.spec.storageClassName}' y vas a ver que la API te la escribió sola.

Omitting is not the same as "". Omitted = "use the default"; "" = "no class, and provision nothing for me". It shows up in the exam worded as "without dynamic provisioning".
Case (c) shows the other half: an already-bound PV is not shared. One to one, always.
The describe message distinguishes the causes: no PV available (no candidate) vs storageclass not found (the class does not exist) vs waiting for first consumer (not an error).
In the lab (kubeadm, no provisioner) case (a) also stays Pending, but with a different message: waiting for a volume to be created, either by external provisioner.... That contrast proves omitting did take the default: run k get pvc a -o jsonpath='{.spec.storageClassName}' and you will see the API filled it in for you.

Omettere non è come "". Omesso = "usa la default"; "" = "nessuna classe, e non farmi provisioning". All'esame compare come "senza dynamic provisioning".
Il caso (c) mostra l'altra metà: un PV già legato non si condivide. Uno a uno, sempre.
Il messaggio del describe distingue le cause: no PV available (nessun candidato) contro storageclass not found (la classe non esiste) contro waiting for first consumer (non è un errore).
Nel lab (kubeadm, senza provisioner) anche il caso (a) resta Pending, ma con un altro messaggio: waiting for a volume to be created, either by external provisioner.... Quel contrasto prova che omettere ha preso la default: lancia k get pvc a -o jsonpath='{.spec.storageClassName}' e vedrai che l'API l'ha scritta da sola.

Traducir el enunciado al access mode

Translating the wording into an access mode

Tradurre il testo in un access mode

~5 min hecho

Elegí el access mode correcto para cada caso y justificá en una línea: (1) una base Postgres con su disco; (2) tres réplicas de un CMS en distintos nodos que escriben los mismos uploads; (3) un job que necesita garantía de que ningún otro pod monte el volumen mientras corre; (4) varios pods que solo leen un dataset compartido.

Pick the right access mode for each case and justify in one line: (1) a Postgres database with its disk; (2) three CMS replicas on different nodes writing the same uploads; (3) a job needing a guarantee that no other pod mounts the volume while it runs; (4) several pods that only read a shared dataset.

Scegli l'access mode giusto per ogni caso e giustifica in una riga: (1) un database Postgres col suo disco; (2) tre repliche di un CMS su nodi diversi che scrivono gli stessi upload; (3) un job che ha bisogno della garanzia che nessun altro pod monti il volume mentre gira; (4) più pod che leggono soltanto un dataset condiviso.

Ver soluciónShow solutionMostra soluzione

manifest · soluciónmanifest · solutionmanifest · soluzione

1  ReadWriteOnce      RWO   # un solo nodo escribe; es el default de los discos de bloque# one node writes; the default for block disks# scrive un solo nodo; è il default dei dischi a blocchi
2  ReadWriteMany      RWX   # varios NODOS escriben → hace falta un FS de red (NFS, CephFS)# several NODES write → needs a network FS (NFS, CephFS)# scrivono più NODI → serve un FS di rete (NFS, CephFS)
3  ReadWriteOncePod   RWOP  # exclusividad de UN POD, no de un nodo# exclusivity of ONE POD, not one node# esclusività di UN POD, non di un nodo
4  ReadOnlyMany       ROX   # muchos nodos, solo lectura# many nodes, read only# molti nodi, sola lettura

Claves

Key points

Punti chiave

El "Once" de RWO cuenta nodos, no pods. Dos pods del mismo nodo pueden compartir un RWO — por eso existe RWOP.
El enunciado esconde el modo en el lenguaje: "distintos nodos" → RWX; "ningún otro pod" → RWOP; "solo leen" → ROX.
El modo declarado describe una capacidad del backend, no la crea: pedir RWX sobre un disco de bloque no lo convierte en compartible.

The "Once" in RWO counts nodes, not pods. Two pods on the same node can share an RWO — which is why RWOP exists.
The wording hides the mode in plain language: "different nodes" → RWX; "no other pod" → RWOP; "only read" → ROX.
The declared mode describes a backend capability, it does not create it: asking for RWX on a block disk does not make it shareable.

Il "Once" di RWO conta nodi, non pod. Due pod dello stesso nodo possono condividere un RWO — per questo esiste RWOP.
Il testo nasconde la modalità nel linguaggio: "nodi diversi" → RWX; "nessun altro pod" → RWOP; "solo leggono" → ROX.
La modalità dichiarata descrive una capacità del backend, non la crea: chiedere RWX su un disco a blocchi non lo rende condivisibile.

Reciclar un PV en Released

Recycling a Released PV

Riciclare un PV in Released

~6 min hecho

Borrá el pod y la PVC del E2 (en ese orden). Observá el estado del PV. Después creá una PVC nueva con el mismo pedido y explicá por qué queda Pending. Devolvé el PV a Available sin perder los datos y confirmá que la PVC nueva bindea.

Delete E2's pod and PVC (in that order). Observe the PV's state. Then create a new PVC with the same request and explain why it stays Pending. Return the PV to Available without losing the data and confirm the new PVC binds.

Cancella il pod e la PVC dell'E2 (in quell'ordine). Osserva lo stato del PV. Poi crea una nuova PVC con la stessa richiesta e spiega perché resta Pending. Riporta il PV ad Available senza perdere i dati e conferma che la nuova PVC lega.

Ver soluciónShow solutionMostra soluzione

manifest · soluciónmanifest · solutionmanifest · soluzione

k delete pod app && k delete pvc pvc-datos
k get pv
#   pv-datos  ...  Released  default/pvc-datos

k apply -f pvc.yaml            # queda Pending# stays Pending# resta Pending
k get pv pv-datos -o jsonpath='{.spec.claimRef}'
#   todavía apunta a la PVC muerta (por su uid)#   still points at the dead PVC (by its uid)#   punta ancora alla PVC morta (per il suo uid)

k patch pv pv-datos -p '{"spec":{"claimRef":null}}'
k get pv,pvc                   # Available → y enseguida Bound# Available → then Bound# Available → e subito Bound
k exec app -- cat /usr/share/nginx/html/i.html   # los datos siguen# the data is still there# i dati ci sono ancora

Claves

Key points

Punti chiave

Released no es Available. Con Retain, el PV conserva el claimRef de la PVC muerta a propósito: nadie más puede tomar esos datos por accidente.
El fix es de una línea: patch ... claimRef: null. Es el único caso del dominio donde se edita un PV a mano.
Si el reclaim hubiera sido Delete, el PV y el disco ya no existirían. Por eso los PVs con datos que importan van en Retain.

Released is not Available. With Retain, the PV keeps the dead PVC's claimRef on purpose: nobody else can pick up that data by accident.
The fix is one line: patch ... claimRef: null. It is the only case in this domain where you hand-edit a PV.
Had the reclaim been Delete, the PV and the disk would already be gone. That is why PVs with data that matters use Retain.

Released non è Available. Con Retain, il PV conserva di proposito il claimRef della PVC morta: nessun altro può prendere quei dati per sbaglio.
Il fix è di una riga: patch ... claimRef: null. È l'unico caso del dominio in cui si modifica un PV a mano.
Se il reclaim fosse stato Delete, il PV e il disco non esisterebbero più. Per questo i PV con dati che contano vanno in Retain.

Expandir una PVC

Expanding a PVC

Espandere una PVC

~5 min hecho

Con una PVC dinámica de 2Gi, llevala a 5Gi sin recrearla. Antes de intentarlo, verificá que la StorageClass lo permita. Después intentá bajarla a 1Gi y anotá el error exacto.

With a 2Gi dynamic PVC, take it to 5Gi without recreating it. Before trying, check the StorageClass allows it. Then try shrinking it to 1Gi and note the exact error.

Con una PVC dinamica da 2Gi, portala a 5Gi senza ricrearla. Prima di provare, verifica che la StorageClass lo permetta. Poi prova a ridurla a 1Gi e annota l'errore esatto.

Ver soluciónShow solutionMostra soluzione

manifest · soluciónmanifest · solutionmanifest · soluzione

k get sc standard -o jsonpath='{.allowVolumeExpansion}'   #  true

k patch pvc pvc-din -p \
  '{"spec":{"resources":{"requests":{"storage":"5Gi"}}}}'
k get pvc pvc-din -w
k describe pvc pvc-din | grep -i condition -A3
#   FileSystemResizePending → reiniciá el pod para que crezca el FS#   FileSystemResizePending → restart the pod so the FS grows#   FileSystemResizePending → riavvia il pod perché il FS cresca

k patch pvc pvc-din -p '{"spec":{"resources":{"requests":{"storage":"1Gi"}}}}'
#   Forbidden: field can not be less than previous value

Claves

Key points

Punti chiave

Solo hacia arriba, y solo con allowVolumeExpansion: true. Si la SC no lo permite, ni siquiera te deja editar.
El tamaño es lo único mutable de una PVC. Clase y access modes son inmutables: si te equivocaste, se borra y se recrea.
FileSystemResizePending no es un error: el volumen ya creció, falta que el filesystem se entere. Un reinicio del pod lo resuelve.
En el lab no vas a ver esa condición: sin CSI driver nadie agranda nada, el status.capacity no se mueve. Lo que sí reproducís —y es lo que evalúa el examen— es la respuesta de la API: el patch hacia arriba se acepta, el de abajo se rechaza.

Upwards only, and only with allowVolumeExpansion: true. If the SC forbids it, you cannot even edit.
Size is the only mutable thing on a PVC. Class and access modes are immutable: get them wrong and you delete and recreate.
FileSystemResizePending is not an error: the volume already grew, the filesystem just has not noticed. A pod restart resolves it.
You will not see that condition in the lab: with no CSI driver nothing actually grows and status.capacity does not move. What you do reproduce — and what the exam grades — is the API response: the upward patch is accepted, the downward one is rejected.

Solo verso l'alto, e solo con allowVolumeExpansion: true. Se la SC lo vieta, non ti lascia nemmeno modificare.
La dimensione è l'unica cosa mutabile di una PVC. Classe e access mode sono immutabili: se sbagli, si cancella e si ricrea.
FileSystemResizePending non è un errore: il volume è già cresciuto, manca che il filesystem se ne accorga. Un riavvio del pod lo risolve.
Nel lab quella condizione non la vedrai: senza driver CSI nessuno ingrandisce nulla e status.capacity non si muove. Quello che riproduci davvero — ed è ciò che valuta l'esame — è la risposta dell'API: la patch verso l'alto viene accettata, quella verso il basso rifiutata.

Troubleshooting — PVC Pending, ¿cuál criterio falla?

Troubleshooting — PVC Pending, which criterion fails?

Troubleshooting — PVC Pending, quale criterio fallisce?

~7 min hecho

Un pod está Pending y su PVC también. Hay un PV libre en el cluster. Encontrá cuál de los tres criterios no se cumple y arreglalo sin tocar el PV (asumí que el PV es de producción y no es tuyo).

Para plantarlo: creá un PV de 1Gi RWO clase lento y una PVC que pida 2Gi de clase lento.

A pod is Pending and so is its PVC. There is a free PV in the cluster. Find which of the three criteria fails and fix it without touching the PV (assume the PV is production and not yours).

To plant it: create a 1Gi RWO PV of class lento and a PVC requesting 2Gi of class lento.

Un pod è Pending e così la sua PVC. C'è un PV libero nel cluster. Trova quale dei tre criteri fallisce e sistemalo senza toccare il PV (supponi che il PV sia di produzione e non tuo).

Per prepararlo: crea un PV da 1Gi RWO di classe lento e una PVC che chieda 2Gi di classe lento.

manifest · plantar el problemamanifest · plant the problemmanifest · piantare il problema

Ver soluciónShow solutionMostra soluzione

k describe pod app | tail -5
#   FailedScheduling: pod has unbound immediate PersistentVolumeClaims

k describe pvc mi-pvc | tail -5
#   no persistent volumes available for this claim

# comparar oferta y pedido campo por campo# compare supply and request field by field# confrontare offerta e richiesta campo per campo
k get pv -o custom-columns=NAME:.metadata.name,CAP:.spec.capacity.storage,\
MODES:.spec.accessModes,SC:.spec.storageClassName,ST:.status.phase
#   pv-lento  1Gi  [RWO]  lento  Available   ← la clase y el modo coinciden#   pv-lento  1Gi  [RWO]  lento  Available   ← class and mode match#   pv-lento  1Gi  [RWO]  lento  Available   ← classe e modalità coincidono
k get pvc mi-pvc -o jsonpath='{.spec.resources.requests.storage}'   #  2Gi

# el tamaño es inmutable hacia abajo → recrear la PVC pidiendo 1Gi# size is immutable downwards → recreate the PVC asking for 1Gi# la dimensione è immutabile verso il basso → ricreare la PVC chiedendo 1Gi
k delete pvc mi-pvc && k apply -f pvc-1gi.yaml
k get pv,pvc

Claves

Key points

Punti chiave

El custom-columns sobre los PVs es el atajo del dominio: te pone los tres criterios en una línea y la comparación se vuelve visual.
El evento no persistent volumes available cubre las tres causas por igual; no te dice cuál. Por eso la comparación campo por campo no es opcional.
Una PVC no se achica ni se le cambia la clase: se borra y se recrea. Como no tenía datos todavía, no se pierde nada.

custom-columns over the PVs is this domain's shortcut: it puts the three criteria on one line and the comparison becomes visual.
The no persistent volumes available event covers all three causes equally; it does not say which. That is why the field-by-field comparison is not optional.
A PVC cannot shrink or change class: delete and recreate. Since it held no data yet, nothing is lost.

Il custom-columns sui PV è la scorciatoia del dominio: mette i tre criteri su una riga e il confronto diventa visivo.
L'evento no persistent volumes available copre le tre cause allo stesso modo; non dice quale. Per questo il confronto campo per campo non è opzionale.
Una PVC non si riduce né cambia classe: si cancella e si ricrea. Non avendo ancora dati, non si perde nulla.

Troubleshooting — la PVC que no se borra

Troubleshooting — the PVC that will not delete

Troubleshooting — la PVC che non si cancella

~5 min hecho

Borraste una PVC y quedó en Terminating. Pasaron cinco minutos y sigue igual. Explicá qué la retiene, arreglalo sin borrar el finalizer a mano, y explicá por qué borrar el finalizer sería la peor opción.

You deleted a PVC and it is stuck in Terminating. Five minutes later it is unchanged. Explain what holds it, fix it without removing the finalizer by hand, and explain why removing the finalizer would be the worst option.

Hai cancellato una PVC ed è rimasta in Terminating. Sono passati cinque minuti e non cambia. Spiega cosa la trattiene, sistemala senza togliere il finalizer a mano, e spiega perché togliere il finalizer sarebbe l'opzione peggiore.

manifest · plantar el problemamanifest · plant the problemmanifest · piantare il problema

Ver soluciónShow solutionMostra soluzione

k get pvc mi-pvc -o jsonpath='{.metadata.finalizers}'
#   ["kubernetes.io/pvc-protection"]

# ¿quién la está usando?# who is using it?# chi la sta usando?
k get pods -o json | jq -r '.items[] | select(.spec.volumes[]?.persistentVolumeClaim.claimName=="mi-pvc") | .metadata.name'
#   (o más simple, sin jq)#   (or simpler, without jq)#   (o più semplice, senza jq)
k describe pvc mi-pvc | grep -i -A2 'used by'

# la solución: sacar al consumidor# the solution: remove the consumer# la soluzione: togliere il consumatore
k delete pod app
k get pvc                # se fue sola# it went away on its own# se n'è andata da sola

Claves

Key points

Punti chiave

No es un cuelgue, es una protección. El finalizer pvc-protection impide que le saques el disco de abajo a un pod que está escribiendo.
El orden correcto es siempre pod primero, PVC después. Si lo hacés al revés, la PVC espera — y eso está bien.
Borrar el finalizer a mano es la peor opción: la PVC desaparece del API pero el volumen sigue montado en el pod, y quedás con un PV en un estado inconsistente y un pod escribiendo en un disco que el cluster ya considera libre.

It is not a hang, it is a protection. The pvc-protection finalizer stops you pulling the disk out from under a pod that is writing.
The right order is always pod first, PVC second. Do it the other way and the PVC waits — and that is correct.
Removing the finalizer by hand is the worst option: the PVC vanishes from the API but the volume stays mounted in the pod, leaving you with a PV in an inconsistent state and a pod writing to a disk the cluster already considers free.

Non è un blocco, è una protezione. Il finalizer pvc-protection impedisce di sfilare il disco a un pod che sta scrivendo.
L'ordine giusto è sempre prima il pod, poi la PVC. Se lo fai al contrario, la PVC aspetta — ed è corretto così.
Togliere il finalizer a mano è l'opzione peggiore: la PVC sparisce dall'API ma il volume resta montato nel pod, lasciandoti un PV in stato incoerente e un pod che scrive su un disco che il cluster considera già libero.

Autoevaluación — antes de marcar M8 como ★ dominado

Self-check — before marking M8 as ★ mastered

Autovalutazione — prima di segnare M8 come ★ padroneggiato

Escribir PV + PVC + pod de memoria en menos de 4 min.
Decir los tres criterios del binding sin mirar.
Explicar por qué una PVC de 500Mi contra un PV de 1Gi termina con 1Gi.
Distinguir storageClassName omitido, "" y con nombre.
Traducir un enunciado en lenguaje natural al access mode correcto.
Devolver un PV Released a Available.
Expandir una PVC y saber por qué no se puede achicar.
Diagnosticar un pod Pending llegando al evento del describe pvc.

Write PV + PVC + pod from memory in under 4 min.
State the three binding criteria without looking.
Explain why a 500Mi PVC against a 1Gi PV ends up with 1Gi.
Distinguish omitted storageClassName, "", and a named one.
Translate plain-language wording into the right access mode.
Return a Released PV to Available.
Expand a PVC and know why it cannot shrink.
Diagnose a Pending pod all the way to the describe pvc event.

Scrivere PV + PVC + pod a memoria in meno di 4 min.
Enunciare i tre criteri del binding senza guardare.
Spiegare perché una PVC da 500Mi contro un PV da 1Gi finisce con 1Gi.
Distinguere storageClassName omesso, "", e con un nome.
Tradurre un testo in linguaggio naturale nell'access mode giusto.
Riportare un PV Released ad Available.
Espandere una PVC e sapere perché non si può ridurre.
Diagnosticare un pod Pending fino all'evento del describe pvc.

Almacenamiento	Sobrevive a
Storage	Survives
Storage	Sopravvive a
Filesystem del container	nada (se pierde al reiniciar)
Container filesystem	nothing (lost on restart)
Filesystem del container	nulla (perso al riavvio)
`emptyDir`	reinicio del container
`emptyDir`	a container restart
`emptyDir`	il riavvio del container
`hostPath`	borrado del pod (no al cambio de nodo)
`hostPath`	pod deletion (not a node change)
`hostPath`	la cancellazione del pod (non il cambio di nodo)
PV / PVC	todo: pod, nodo, cluster
PV / PVC	everything: pod, node, cluster
PV / PVC	tutto: pod, nodo, cluster

Fase	Significa
Phase	Means
Fase	Significa
Available	Libre, esperando una claim
Available	Free, waiting for a claim
Available	Libero, in attesa di una claim
Bound	Asignado a una PVC
Bound	Assigned to a PVC
Bound	Assegnato a una PVC
Released	La PVC se borró, los datos siguen ahí
Released	The PVC was deleted, the data is still there
Released	La PVC è stata cancellata, i dati sono ancora lì
Failed	Falló la recuperación automática
Failed	Automatic reclamation failed
Failed	Il recupero automatico è fallito

	Estático	Dinámico
	Static	Dynamic
	Statico	Dinamico
Quién crea el PV	El admin, a mano	El provisioner
Who creates the PV	The admin, by hand	The provisioner
Chi crea il PV	L'admin, a mano	Il provisioner
Cuándo	Antes de la PVC	Al crear la PVC
When	Before the PVC	When the PVC is created
Quando	Prima della PVC	Alla creazione della PVC
Requiere SC	No	Sí
Requires an SC	No	Yes
Richiede una SC	No	Sì
Dónde se ve	Labs, bare-metal, CKA	Nube, producción
Where you see it	Labs, bare metal, CKA	Cloud, production
Dove si vede	Lab, bare metal, CKA	Cloud, produzione

Modo	Abrev.	Alcance
Mode	Short	Reach
Modalità	Sigla	Portata
ReadWriteOnce	RWO	Un nodo, R/W
ReadWriteOnce	RWO	One node, R/W
ReadWriteOnce	RWO	Un nodo, R/W
ReadOnlyMany	ROX	Varios nodos, solo lectura
ReadOnlyMany	ROX	Several nodes, read only
ReadOnlyMany	ROX	Più nodi, sola lettura
ReadWriteMany	RWX	Varios nodos, R/W
ReadWriteMany	RWX	Several nodes, R/W
ReadWriteMany	RWX	Più nodi, R/W
ReadWriteOncePod	RWOP	Un solo pod, R/W
ReadWriteOncePod	RWOP	One single pod, R/W
ReadWriteOncePod	RWOP	Un solo pod, R/W

Política	El PV…	Los datos…
Policy	The PV…	The data…
Policy	Il PV…	I dati…
Retain	queda Released	se conservan
Retain	becomes Released	are kept
Retain	diventa Released	si conservano
Delete	se borra	se borran
Delete	is deleted	are deleted
Delete	viene cancellato	vengono cancellati
Recycle	deprecado, no lo uses
Recycle	deprecated, do not use it
Recycle	deprecato, non usarlo

Causa	Cómo se ve
Cause	How it looks
Causa	Come appare
storageClassName distinto	no PV available
Different storageClassName	no PV available
storageClassName diverso	no PV available
Pide más de lo que hay	no PV available
Asks for more than exists	no PV available
Chiede più di quel che c'è	no PV available
accessMode no ofrecido	no PV available
accessMode not offered	no PV available
accessMode non offerto	no PV available
La SC no existe	storageclass not found
The SC does not exist	storageclass not found
La SC non esiste	storageclass not found
WaitForFirstConsumer	waiting for first consumer
WaitForFirstConsumer	waiting for first consumer
WaitForFirstConsumer	waiting for first consumer

Volumes: el almacenamiento atado al pod

Volumes: storage tied to the pod

Volume: lo storage legato al pod

emptyDir: scratch compartido

emptyDir: shared scratch space

emptyDir: scratch condiviso

emptyDir en RAM

emptyDir in RAM

emptyDir in RAM

hostPath: un directorio del nodo

hostPath: a directory on the node

hostPath: una directory del nodo

ConfigMap y Secret también son volumes (M4)

ConfigMaps and Secrets are volumes too (M4)

Anche ConfigMap e Secret sono volume (M4)

Verificar el montaje

Verifying the mount

Verificare il mount

Tres ciclos de vida distintos

Three different lifecycles

Tre cicli di vita diversi

emptyDir, con precisión

emptyDir, precisely

emptyDir, con precisione

La regla del montaje

The mounting rule

La regola del mount

Por qué el volumen se define en el pod

Why the volume is defined on the pod

Perché il volume si definisce sul pod

PersistentVolumes & PersistentVolumeClaims

1. El PV (lo crea el admin)

1. The PV (created by the admin)

1. Il PV (lo crea l'admin)

2. La PVC (la crea el dev)

2. The PVC (created by the dev)

2. La PVC (la crea il dev)

3. El pod que la monta

3. The pod that mounts it

3. Il pod che la monta

Verificar el binding

Verifying the binding

Verificare il binding

Quién es quién

Who is who

Chi è chi

Los cuatro criterios del match

The four matching criteria

I quattro criteri di corrispondenza

Fases del PV

PV phases

Fasi del PV

Released no es Available

Released is not Available

Released non è Available

StatefulSets: volumeClaimTemplates

StatefulSets: volumeClaimTemplates

StatefulSet: volumeClaimTemplates

StorageClasses y provisioning dinámico

StorageClasses and dynamic provisioning

StorageClass e provisioning dinamico

Ver qué hay

See what exists

Vedere cosa c'è

Una StorageClass

A StorageClass

Una StorageClass

PVC dinámica: sin PV previo

Dynamic PVC: no PV beforehand

PVC dinamica: senza PV preesistente

Los tres valores de storageClassName

The three values of storageClassName

I tre valori di storageClassName

Cambiar la default

Changing the default

Cambiare la default

Los dos mundos

The two worlds

I due mondi

Qué es un provisioner