Uso de volúmenes en Kubernetes

En esta nueva entrada vamos a retomar los artículos sobre kubernetes y vamos a ver una introducción sobre el uso de volúmenes en Kubernetes, como una manera de otorgar almacenamiento a nuestros contenedores.

Para ello vamos a tratar los tres tipos de recursos en Kubernetes que se asocian a los volúmenes:

• PersistentVolume
• PersistentVolumeClaim
• Volumes

¿Qué es un volumen en kubernetes?

Debido a que nuestros Pods, son efímeros, hay que otorgarles algún tipo de almacenamiento, para que la información que se despliegue no se pierda. Para ello vamos a hacer uso de los volúmenes, con el objetivo principal de mantener nuestra información incluso cuando nuestros pods desaparezcan.

Estos volúmenes al estilo de unix, se van a montar en unas rutas que se especifícan en el pod y nos van a permitir persistir información.

¿Qué es un PersistentVolume en Kubernetes?

Los PersistentVolume nos ofrece un API tanto para usuarios como para administradores que nos hace abstraernos de los detalles de como se consume y proporciona lo que se almacena.

Un PersistentVolume es un recurso de Kubernetes que representa los volúmenes que tenemos en el cluster. Se van a definir detalles del backend, como políticas, modos de acceso, tamaños, políticas de reciclaje…

Podríamos decir que es una unidad de almacenamiento y un filesystem. Por ejemplo podríamos considerar como un PersistentVolumen (PV) a EBS (Amazon Elastic Block Store) de AWS.

En función a los modos de acceso tenemos tres tipos diferentes:

• ReadWriteOnce: read-write solo para un nodo (RWO)
• ReadOnlyMany: read-only para muchos nodos (ROX)
• ReadWriteMany: read-write para muchos nodos (RWX)

Y en función de las políticas de reciclaje podemos ver:

• Retain: Retiene el contenido.
• Recycle: Se reutilizará el contenido
• Delete: Borrará el contenido

Hay dos maneras de aprovisionar un volumen:

• Estático:  En este caso, primero se tienen que crear todos los PersistentVolumenCliams y estos se asignarán cuando se creen los PersistentVolume.
• Dinámico: Para el aprovisionamiento dinámico se crearán un PersistentVolumen a demanda cuando se cree un PersistentVolumenClaim.

Por lo gneral crearemos un PV de manera estática, en la que tendremos que crear primero una unidad de almacenamiento como puede ser nfs o EBS de AWS.

En el caso en el que nuestro cluster no sea capaz de encontrar un PersistentVolume para nuestro PersitentVolumeClaim, puede crear un nuevo almacenamiento para este PersitentVolumeClaim. Y si esto sucede sería la creación dinámica de un PersistentVolume.

¿Qué es un PersistentVolumeClaim?

Un PersistentVolumeClaim es una petición de almacenaje por un usuario. Podríamos decir que al igual que en un Pod se establecen quotas y recursos, en un PVC se establecen tamaños y solicitará los modos de acceso(definidos más arriba en PersistentVolume).

Como definir un Volumen en un Pod

Al mismo tiempo que definimos o creamos un Pod y le asignamos atributos, le podemos indicar y crear un volúmen en el que guardar la información.

Para crear un volúmen debemos de primero definir el tipo de montaje y después definir la ruta:

 volumeMounts:
    - mountPath: /home
      name: home
volumes:
  - name: home
    hostPath:
      path: /home/debian

En el anterior hemos montado un volúmen en la ruta /home/debian, es decir en un directorio, pero si queremos también podemos montar un volúmen en un repositorio git:

    - mountPath: /git
      name: git
      readOnly: true
  volumes:
  - name: git
    gitRepo:
      repository: https://github.com/refactorizando-web/kubernetes.git

En la documentación oficial de kubernetes podrás ver todos los diferentes volúmenes que se pueden montar.

Vamos a ver un ejemplo completo de un volúmen:

apiVersion: v1
kind: Pod
metadata:
  name: nginx
spec:
  containers:
  - name: nginx
    image: nginx:1.14.2
    volumeMounts:
    - mountPath: /home
      name: home
    - mountPath: /git
      name: git
      readOnly: true
    - mountPath: /temp
      name: temp
  volumes:
  - name: home
    hostPath:
      path: /home/debian
  - name: git
    gitRepo:
      repository: https://github.com/refactorizando-web/kubernetes.git
  - name: temp
    emptyDir: {}

El pod que hemos definido anteriormente utiliza una imagen de nginx y tiene la siguiente escturctura:

• Kind: Le indicamos el tipo de recurso de kubernetes
• name: Este atributo dentro de la definición del contenedor nos dice el nombre que va a tener la imagen.
• image: Este atributo dentro de la definición del contenedor nos dice que imagen vamos a usar para desplegar el pod.
• volumeMounts: En este atributo vamos a indicar los volúmenes que vamos a montar en nuestro pod, mediante los atributos mountPath y name.
• volumes: VolumeMounts hace referencia a donde se van a montar, y en volumes le indicamos el path a través del nombre que hemos definido anteriormente.
• temp: Este volúmen que montamos en temp se borrará una vez que el pod se haya eliminado.

Como definir un PersistentVolume

A continuación vamos a definir un PersistentVolume haciendo uso de un servidor NFS (Network File System).

apiVersion: v1
kind: PersistentVolume
metadata:
  name: nfs
spec:
  capacity:
    storage: 2Gi
  accessModes:
    - ReadWriteMany
  persistentVolumeReclaimPolicy: Recycle
  nfs:
    path: /var/shared
    server: 192.0.0.96

En la creación del PersistentVolume anterior hemos creado un volumen persitente para hacer uso de un servidor de nfs, al que le hemos dotado de 2Gb con una política de reciclaje y un acceso de ReadWriteMany.

Como definir un PersistentVolumenClaim

A continuación vamos a definir un PersistentVolumeClaim, y seguir con nuestro ejemplo de nfs anterior vamos a crear un PersistentVolumeClaim de la siguiente manera:

apiVersion: v1
kind: PersistentVolumeClaim
metadata:
  name: nfs
spec:
  accessModes:
    - ReadWriteMany
  resources:
    requests:
      storage: 1Gi

Al crear el recurso anterior se intenta asociar con el PersistentVolume creado anteriormente. Es decir uno que cumpla con sus necesidades.

Usar PersistentVolumeClaim en Pods

El objetivo de crear un PersistentVolumeClaim, es poder hacer uso de el en un Pod o en la creación del un deployment.yaml. Por lo que vamos a ver como hacer uso de un PersistentVolumeClaim en la construcción de un Pod y de un Deployment:

apiVersion: v1
kind: Pod
metadata:
  name: nginx
spec:
  containers:
  - name: nginx
    image: nginx:1.14.2
    volumeMounts:
      - mountPath: /usr/share/nginx/html
        name: nfs
  volumes:
    - name: nfs
      persistentVolumeClaim:
        claimName: nfs

El anterior sería la descripción de un Pod haciendo uso del PersistenVolumeClaim creado anteriormente con nombre nfs. Vamos ahora a ver como sería con un deployment:

apiVersion: apps/v1
kind: Deployment
metadata:
  labels:
    app: nginx
  name: nginx-deployment
  namespace: infrastructure
spec:
  replicas: 1
  selector:
    matchLabels:
      app: nginx
  template:
    metadata:
      labels:
        app: nginx
    spec:
      containers:
        - name: nginx
          image: nginx:1.14.2
          resources:
            requests:
              memory: "1200Mi"
              cpu: .10
            limits:
              memory: "2500Mi"
              cpu: .50
         volumeMounts:
           - mountPath: /usr/share/nginx/html
             name: nfs
         ports:
          - containerPort: 80
  volumes:
    - name: nfs
      persistentVolumeClaim:
        claimName: nfs

Conclusión

Entender para poder hacer uso de volúmenes en nuestros Pods es algo esencial para crear una arquitectura en Kubernetes. Sin el uso de volúmenes toda la información de cualquier Pod se pierde. En este artículo sobre el uso de volúmenes en Kubernetes, hemos visto sus principales características y como crearlos.

No te olvides de seguirnos en nuestras redes sociales Facebook o Twitter para estar actualizado.