Volúmenes en Kubernetes

Aprenderemos con ejemplos como crear volúmenes con kubernetes, trabajaremos con emptyDir

oscar Escrito por oscar 29 August 2025 621 0
DevOps CI/CD

En Kubernetes, los volúmenes (Volumes) son una forma de proporcionar almacenamiento persistente y compartido a los Pods y contenedores.

👉 Por defecto, los contenedores usan un sistema de archivos efímero: cuando el contenedor se reinicia o el Pod se destruye, los datos se pierden.

📂 Tipos de volúmenes más comunes

emptyDir

hostPath

configMap / secret

nfs

persistentVolumeClaim (PVC)

Ejemplo de volumenes

Volumen efímero compartido en el mismo Pod (No recomendado)

Para este ejemplo trabajaremos con el volumen mas simple que es emptyDir 

apiVersion: v1
kind: Pod
metadata:
  name: pod-con-dos-contenedores
spec:
  containers:
    - name: escritor
      image: busybox
      command: ["sh", "-c", "echo 'Hola desde el contenedor 1' > /datos/mensaje.txt && sleep 3600"]
      volumeMounts:
        - name: volumen-compartido
          mountPath: /datos

    - name: lector
      image: busybox
      command: ["sh", "-c", "cat /datos/mensaje.txt && sleep 3600"]
      volumeMounts:
        - name: volumen-compartido
          mountPath: /datos

  volumes:
    - name: volumen-compartido
      emptyDir: {}

🔎 Aquí:

Ejecutamos

kubectl apply -f pod-volumen.yaml
kubectl get pods

Respuesta

NAME                       READY   STATUS    RESTARTS   AGE
pod-con-dos-contenedores   2/2     Running   0          10s

Entrar al contenedor lector

kubectl exec -it pod-con-dos-contenedores -c lector -- sh

Dentro del contenedor lector ejecutamos 

cat /datos/mensaje.txt

Respuesta: Hola desde el contenedor 1

Volumen hostPath

Un volumen hostPath en Kubernetes monta un directorio o archivo del nodo host dentro de un contenedor.

👉 Esto significa que lo que guardes en el contenedor queda físicamente en el nodo, y otros Pods que usen el mismo hostPath pueden acceder a esos datos.

⚠️ Importante antes de usar hostPath

Procedemos a crear el archivo pod-con-hostpath

apiVersion: v1
kind: Pod
metadata:
  name: pod-con-hostpath
spec:
  containers:
    - name: escritor
      image: busybox
      command: ["sh", "-c", "echo 'Hola desde hostPath' > /datos/mensaje.txt && sleep 3600"]
      volumeMounts:
        - name: volumen-host
          mountPath: /datos
  volumes:
    - name: volumen-host
      hostPath:
        path: /mnt/data   # Ruta en el nodo
        type: DirectoryOrCreate  # Si no existe, Kubernetes la crea

🔎 Qué hace este Pod

Luego procedemos a crear pod-lector-hostpath

apiVersion: v1
kind: Pod
metadata:
  name: pod-lector-hostpath
spec:
  containers:
    - name: lector
      image: busybox
      command: ["sh", "-c", "cat /datos/mensaje.txt && sleep 3600"]
      volumeMounts:
        - name: volumen-host
          mountPath: /datos
  volumes:
    - name: volumen-host
      hostPath:
        path: /mnt/data
        type: Directory

Luego procedemos a crear

kubectl apply -f pod-con-hostpath.yaml
kubectl apply -f pod-lector-hostpath.yaml

Entra al Pod lector y verifica el archivo:

kubectl exec -it pod-lector-hostpath -- cat /datos/mensaje.txt

Respuesta: Hola desde hostPath

📌 En resumen:

Volumen NFS

Para realizar esta prueba, debemos tener un servidor NFS corriendo (puede ser en otra máquina o dentro del mismo cluster con un Pod NFS server). Revisa el post NFS Network File System

En ese servidor, haber exportado un directorio (/mnt/nfs_share) y darle permisos de acceso a los nodos de Kubernetes.

Procedemos a crear el pod pod-escritor-nfs donde colocamos:

apiVersion: v1
kind: Pod
metadata:
  name: pod-con-nfs
spec:
  containers:
    - name: app
      image: busybox
      command: ["sh", "-c", "echo 'Hola desde NFS' > /datos/mensaje.txt && sleep 3600"]
      volumeMounts:
        - name: volumen-nfs
          mountPath: /datos
  volumes:
    - name: volumen-nfs
      nfs:
        server: 192.168.1.100   # IP del servidor NFS
        path: /srv/nfs/kubedata # Carpeta exportada por NFS

Procedemos a crear el pod pod-lector-nfs donde colocamos:

apiVersion: v1
kind: Pod
metadata:
  name: pod-lector-nfs
spec:
  containers:
    - name: lector
      image: busybox
      command: ["sh", "-c", "cat /datos/mensaje.txt && sleep 3600"]
      volumeMounts:
        - name: volumen-nfs
          mountPath: /datos
  volumes:
    - name: volumen-nfs
      nfs:
        server: 192.168.1.100
        path: /srv/nfs/kubedata

Luego creamos los pods

kubectl apply -f pod-escritor-nfs.yaml
kubectl apply -f pod-lector-nfs.yaml

Entra al Pod lector y revisa el archivo:

kubectl exec -it pod-lector-nfs -- cat /datos/mensaje.txt

Respuesta: Hola desde NFS

Volumen con persistentVolumeClaim (PVC)

Creamos el archivo mi-pv.yaml

apiVersion: v1
kind: PersistentVolume
metadata:
  name: mi-pv
spec:
  capacity:
    storage: 1Gi            # tamaño del volumen
  accessModes:
    - ReadWriteOnce         # solo un nodo puede montar en modo lectura/escritura
  hostPath:
    path: /mnt/data         # carpeta en el nodo donde se guardarán los datos

 📌 Aquí le estamos diciendo a Kubernetes:

Luego, creamos mi-pvc.yaml

apiVersion: v1
kind: PersistentVolumeClaim
metadata:
  name: mi-pvc
spec:
  accessModes:
    - ReadWriteOnce
  resources:
    requests:
      storage: 500Mi       # el pod pide medio giga

📌 El PVC pide 500MB de almacenamiento.

Kubernetes busca un PV que cumpla:

Entonces este PVC se une al PV mi-pv.

Por ultimo, creamos pod-con-pvc.yaml

apiVersion: v1
kind: Pod
metadata:
  name: pod-con-pvc
spec:
  containers:
    - name: app
      image: nginx
      volumeMounts:
        - mountPath: "/usr/share/nginx/html"
          name: volumen-web
  volumes:
    - name: volumen-web
      persistentVolumeClaim:
        claimName: mi-pvc

📌 Explicación:

Procedemos a ejecutar 

kubectl apply -f .\mi-pv.yaml
kubectl apply -f .\mi-pvc.yaml
kubectl apply -f .\pod-con-pvc.yaml

Comentario

Debe aceptar antes de enviar