SSD locales

En esta página, se proporciona una descripción general de la asistencia de SSD local en Kubernetes y cómo usar SSD locales con Google Kubernetes Engine.

Descripción general

Los SSD locales proporcionan almacenamiento efímero y de alto rendimiento para todos los nodos del clúster. Los SSD locales proporcionan mayor capacidad de procesamiento y menor latencia que los discos estándar. El almacenamiento en caché local y el procesamiento son cargas de trabajo adecuadas para los SSD locales.

Puedes crear grupos de nodos con SSD locales dentro de los límites del tipo de máquina de tu clúster y las cuotas de tu proyecto.

Restricciones

Ten en cuenta las restricciones siguientes cuando uses SSD locales:

  • Debido a que los SSD locales están conectados a nivel físico a la instancia de la máquina virtual del host del nodo, los datos almacenados en ellos solo existen en ese nodo. Dado que los datos almacenados en los discos son locales, tu aplicación debe ser capaz de resistir la falta de disponibilidad de estos datos.
  • Los datos almacenados en los SSD locales son efímeros. Un pod que escribe en un SSD local puede perder acceso a los datos almacenados en el disco si el pod se reprograma fuera de ese nodo. Además, si el nodo se finaliza, actualiza o repara, los datos se borrarán.
  • No puedes agregar SSD locales a un grupo de nodos existente.

Crea un clúster con SSD locales

Puedes crear un clúster con SSD locales con Google Cloud Platform Console o la herramienta de línea de comandos de gcloud.

gcloud

Para crear un clúster o un grupo de nodos con SSD locales mediante gcloud, especifica la marca --local-ssd count.

Para crear un clúster en el que el grupo predeterminado usa discos SSD locales, ejecuta el comando siguiente:

gcloud container clusters create [CLUSTER_NAME] \
    --num-nodes 2 --local-ssd-count [NUMBER_OF_DISKS]

donde [NUMBER_OF_DISKS] es la cantidad deseada de discos como número absoluto.

Para crear un grupo de nodos con los discos SSD locales en un clúster existente, sigue estos pasos:

gcloud beta container node-pools create [POOL_NAME] --cluster [CLUSTER_NAME] \
    --num-nodes 1 --local-ssd-count [NUMBER_OF_DISKS]

El --local-ssd-count especifica la cantidad de SSD locales que se crearán por nodo. La cantidad máxima varía según el tipo de máquina y la región (consulta SSD locales). Cuando se crean los nodos, los SSD locales se formatean de forma automática y se activan en el SO del host en el subdirectorio /mnt/disks/, con cada SSD local activado en un directorio "ssd#".

Console

Puedes crear un clúster o un grupo de nodos con SSD locales desde el menú de GKE en GCP Console.

Para crear un clúster en el que el grupo predeterminado usa discos SSD locales, sigue los pasos siguientes:

  1. Dirígete al menú de Google Kubernetes Engine en GCP Console.

    Ir al menú de Google Kubernetes Engine

  2. Haz clic en Crear clúster.

  3. En Grupos de nodos, haz clic en Edición avanzada.

  4. Para Cantidad de nodos, ingresa 2.

  5. Para los discos SSD locales, ingresa la cantidad deseada de SSD como número absoluto.

  6. Haz clic en Guardar y, a continuación, haz clic en Crear.

Para crear un grupo de nodos con los discos SSD locales en un clúster existente, sigue estos pasos:

  1. Dirígete al menú de Google Kubernetes Engine en GCP Console.

    Ir al menú de Google Kubernetes Engine

  2. Selecciona el clúster que desees.

  3. Haz clic en Editar.

  4. En grupos de nodos, haz clic en Agregar grupo de nodos.

  5. Para tamaño, ingresa 1.

  6. Para Discos SSD locales (por nodo), ingresa la cantidad deseada de SSD como número absoluto.

  7. Haz clic en Guardar.

Usa SSD locales

En la sección siguiente, se explica cómo usar SSD locales con GKE.

Puedes acceder a los SSD locales con uno de estos dos métodos:

  • Se recomienda usar los volúmenes de la ruta del host para las tareas siguientes:

    • Cargas de trabajo que usan DaemonSets.
    • Cargas de trabajo que usan grupos de nodos exclusivos. Se debe acceder a todos los SSD locales en la misma ruta en todas las instancias de un DaemonSet.
  • Los PersistentVolumes locales están disponibles en versión Beta a partir de Kubernetes 1.10 y se recomienda usarlos con los elementos siguientes:

    • Cargas de trabajo con StatefulSets y volumeClaimTemplates
    • Cargas de trabajo que comparten grupos de nodos. Cada SSD local se puede reservar a través de un PersistentVolumeClaim (PVC). Las rutas de acceso de host especificas no se codificarán de forma directa en la especificación del pod.
    • Pods que requieren gravedad de datos en el mismo SSD local. Un pod siempre se programa para el mismo nodo como su PersistentVolume local.

Ejemplo con volúmenes de la ruta del host

Si creas un grupo de nodos con tres SSD locales, el SO del host activa los discos en /mnt/disks/ssd0, /mnt/disks/ssd1 y /mnt/disks/ssd2. Tus contenedores de Kubernetes acceden a los discos con el parámetro hostPath definido en el archivo de configuración de tu objeto.

En este ejemplo, el archivo de configuración del pod hace referencia al SSD local: /mnt/disks/ssd0:

apiVersion: v1
kind: Pod
metadata:
  name: "test-ssd"
spec:
  containers:
  - name: "shell"
    image: "ubuntu:14.04"
    command: ["/bin/sh", "-c"]
    args: ["echo 'hello world' > /test-ssd/test.txt && sleep 1 && cat /test-ssd/test.txt"]
    volumeMounts:
    - mountPath: "/test-ssd/"
      name: "test-ssd"
  volumes:
  - name: "test-ssd"
    hostPath:
      path: "/mnt/disks/ssd0"
  nodeSelector:
    cloud.google.com/gke-local-ssd: "true"

Ejemplo con PersistentVolumes locales

A partir de Kubernetes versión 1.10, los SSD locales se podrán especificar como PersistentVolumes.

Puedes crear PersistentVolumes desde SSD locales si creas de forma manual un PersistentVolume o si ejecutas el aprovisionador estático de volumen local.

Advertencias

En la actualidad, el ajuste de escala automático del clúster y el aprovisionamiento dinámico no son compatibles con esta característica.

Actualizar un clúster de GKE o reparar los nodos hacen que se borren las instancias de Compute Engine, lo que también borra todos los datos de los SSD locales.

No debes habilitar las actualizaciones automáticas del nodo o la reparación automática del nodo de los clústeres o grupo de nodos con SSD locales para datos persistentes. Primero, debes realizar una copia de seguridad de los datos de tu aplicación y, a continuación, restablecer los datos en un clúster nuevo o en grupo de nodos.

Crea el PersistentVolume de forma manual

Puedes crear un PersistentVolume de forma manual para todos los SSD locales de cada nodo del clúster.

Usa el campo nodeAffinity en un objeto PersistentVolume para hacer referencia a un SSD local en un nodo específico. Por ejemplo, a continuación, se muestra una especificación de PersistentVolume para un SSD local activado en /mnt/disks/ssd0 en el nodo gke-test-cluster-default-pool-926ddf80-f166:

apiVersion: v1
kind: PersistentVolume
metadata:
  name: "example-local-pv"
spec:
  capacity:
    storage: 375Gi
  accessModes:
  - "ReadWriteOnce"
  persistentVolumeReclaimPolicy: "Retain"
  storageClassName: "local-storage"
  local:
    path: "/mnt/disks/ssd0"
  nodeAffinity:
    required:
      nodeSelectorTerms:
      - matchExpressions:
        - key: "kubernetes.io/hostname"
          operator: "In"
          values: "gke-test-cluster-default-pool-926ddf80-f166"

Si borras el PersistentVolume, deberás borrar de forma manual los datos del disco.

Ejecuta el aprovisionador estático de volumen local

Puedes crear PersistentVolumes para SSD locales de forma automática con el aprovisionador estático de volumen local. El aprovisionador es un DaemonSet que administra los SSD locales en cada nodo, crea y borra PersistentVolumes para estos y limpia los datos en el SSD local cuando se actualiza PersistentVolume.

Para ejecutar el aprovisionador estático de volumen local, haz lo siguiente:

  1. Descarga la especificación provisioner_generated_gce_ssd_count.yaml del repositorio del almacenamiento externo y modifica los campos namespace de la especificación según sea necesario.

    La especificación incluye estos elementos:

    • ServiceAccount para el aprovisionador
    • ClusterRole y ClusterRoleBindings con permiso para realizar estas acciones:
      • Crear y borrar los objetos PersistentVolume
      • Obtener objetos del nodo
    • ConfigMap con la configuración del aprovisionador para GKE
    • DaemonSet para ejecutar el aprovisionador
  2. Vincula tu cuenta de IAM a la función de administrador de clústeres de Kubernetes. Es obligatorio para obtener los permisos de creación de ClusterRole.

  3. Implementa el aprovisionador:

    kubectl apply -f provisioner_generated_gce_ssd_count.yaml

Luego de que el aprovisionador se ejecute de manera correcta, creará un objeto PersistentVolume para cada SSD local en el clúster.

Habilita la vinculación de volumen retrasada

Para mejorar la programación, también se recomienda crear un StorageClass con volumeBindingMode: WaitForFirstConsumer. Esto retrasará la vinculación de PersistentVolumeClaim (PVC) hasta la programación del pod, por lo que se elige un SSD local desde un nodo adecuado que puede ejecutar el pod. Este comportamiento de programación mejorado implica que las solicitudes de la CPU del pod y de la memoria, la afinidad del nodo, la afinidad del pod y la antiafinidad, y varias solicitudes PVC se consideran junto con los nodos que cuentan con SSD locales disponibles.

local_class.yaml

apiVersion: storage.k8s.io/v1
kind: StorageClass
metadata:
name: "local-scsi"
provisioner: "kubernetes.io/no-provisioner"
volumeBindingMode: "WaitForFirstConsumer"

Para crear un StorageClass con vinculación retrasada, ejecuta el comando siguiente:

kubectl apply -f local_class.yaml

Pasos siguientes

¿Te ha resultado útil esta página? Enviar comentarios:

Enviar comentarios sobre...