Usa discos de arranque secundarios para precargar datos o imágenes de contenedor

Autopilot Estándar

En esta página, se muestra cómo mejorar la latencia de inicio de la carga de trabajo con discos de arranque secundarios en Google Kubernetes Engine (GKE) para precargar datos o imágenes de contenedores en nodos nuevos. Esto permite que las cargas de trabajo alcancen un inicio en frío rápido y mejoren el uso general de los recursos aprovisionados.

Antes de leer esta página, asegúrate de estar familiarizado con Google Cloud, Kubernetes, los contenedores, YAML, el entorno de ejecución de containerd y Google Cloud CLI.

Descripción general

A partir de la versión 1.28.3-gke.1067000 en clústeres estándar y de la versión 1.30.1-gke.1329000 en clústeres de Autopilot, puedes configurar el grupo de nodos con discos de arranque secundarios. Puedes indicarle a GKE que aprovisione los nodos y los precargue con datos, como un modelo de aprendizaje automático (AA) o una imagen de contenedor. El uso de imágenes o datos de contenedores precargados en un disco secundario tiene los siguientes beneficios para tus cargas de trabajo:

Menor latencia cuando se extraen imágenes de contenedores grandes o se descargan datos
Ajuste de escala automático más rápido
Recuperación más rápida de interrupciones, como eventos de mantenimiento y errores del sistema

En las siguientes secciones, se describe cómo configurar el disco de arranque secundario en los clústeres de GKE Autopilot y Standard.

Cómo funcionan los discos de arranque secundarios

Tu carga de trabajo puede iniciarse más rápido si usas la imagen o los datos del contenedor precargados en discos de inicio secundarios. Los discos de arranque secundarios tienen las siguientes características:

Los discos de arranque secundarios son discos persistentes que están respaldados por almacenamiento en bloque distribuido. Si la imagen del disco ya está en uso en la zona, el tiempo de creación de todos los discos posteriores de la misma imagen del disco será menor.
El tipo de disco de arranque secundario es el mismo que el del disco de arranque del nodo.
El tamaño del disco de arranque secundario se determina según el tamaño de la imagen del disco.

Agregar discos de arranque secundarios a tus grupos de nodos no aumenta el tiempo de aprovisionamiento de los nodos. GKE aprovisiona discos de arranque secundarios a partir de una imagen de disco en paralelo con el proceso de aprovisionamiento de nodos.

Práctica recomendada:

Para admitir imágenes de contenedor precargadas, GKE extiende el entorno de ejecución de containerd con complementos que leen las imágenes de contenedor desde discos de inicio secundarios. Las capas base reutilizan las imágenes del contenedor.

Carga previamente las capas base grandes en el disco de arranque secundario, mientras que las capas superiores pequeñas se pueden extraer del registro del contenedor.

Antes de comenzar

Antes de comenzar, asegúrate de haber realizado las siguientes tareas:

Habilita la API de Google Kubernetes Engine.

Habilitar la API de Google Kubernetes Engine

Si deseas usar Google Cloud CLI para esta tarea, instala y, luego, inicializa gcloud CLI. Si ya instalaste gcloud CLI, ejecuta gcloud components update para obtener la versión más reciente.
Nota: Para las instalaciones de gcloud CLI existentes, asegúrate de configurar las propiedades compute/region y compute/zone. Cuando configuras las ubicaciones predeterminadas, puedes evitar errores en la CLI de gcloud como el siguiente: One of [--zone, --region] must be supplied: Please specify location.

Habilita la API del sistema de archivos de contenedor.

Habilita la API del sistema de archivos de contenedor

Requisitos

Se aplican los siguientes requisitos para usar el disco de arranque secundario:

Tus clústeres ejecutan la versión 1.28.3-gke.1067000 de GKE en GKE Standard o la versión 1.30.1-gke.1329000 de GKE Autopilot.
Cuando modifiques la imagen del disco, debes crear un nuevo grupo de nodos. No se admite la actualización de la imagen del disco en nodos existentes.
Configura la transmisión de imágenes para usar la función de disco de arranque secundario.
Usa Container-Optimized OS con una imagen de nodo de containerd. Los nodos de Autopilot usan esta imagen de nodo de forma predeterminada.
Prepara la imagen de disco con datos listos durante el tiempo de compilación o con imágenes de contenedor precargadas. Asegúrate de que tu clúster tenga acceso a la imagen de disco para cargarla en los nodos.

Práctica recomendada:
Automatiza la imagen de disco en una canalización de CI/CD.

Limitaciones

Los discos de arranque secundarios tienen las siguientes limitaciones:

No puedes actualizar los discos de arranque secundarios de los nodos existentes. Para conectar una nueva imagen de disco, crea un grupo de nodos nuevo.

Prepara el disco de arranque secundario

Para preparar el disco de arranque secundario, elige la pestaña Imágenes para precargar las imágenes del contenedor o la pestaña Datos para precargar los datos y, luego, completa las siguientes instrucciones:

Imágenes

GKE proporciona una herramienta llamada gke-disk-image-builder para crear una máquina virtual (VM), extraer las imágenes de contenedor en un disco y, luego, crear una imagen de disco a partir de ese disco.

Para crear una imagen de disco con varias imágenes de contenedor precargadas, completa los siguientes pasos:

Crea un bucket de Cloud Storage para almacenar los registros de ejecución de gke-disk-image-builder.
Crea una imagen de disco con gke-disk-image-builder.

go run ./cli \
    --project-name=PROJECT_ID \
    --image-name=DISK_IMAGE_NAME \
    --zone=LOCATION \
    --gcs-path=gs://LOG_BUCKET_NAME \
    --disk-size-gb=10 \
    --container-image=docker.io/library/python:latest \
    --container-image=docker.io/library/nginx:latest

Reemplaza lo siguiente:

PROJECT_ID: El nombre de tu proyecto de Google Cloud.
DISK_IMAGE_NAME: Es el nombre de la imagen del disco. Por ejemplo, nginx-python-image
LOCATION: Es la ubicación del clúster
LOG_BUCKET_NAME: el nombre del bucket de Cloud Storage para almacenar los registros de ejecución. Por ejemplo, gke-secondary-disk-image-logs/.

Cuando creas una imagen de disco con gke-disk-image-builder, Google Cloud crea varios recursos para completar el proceso (por ejemplo, una instancia de VM, un disco temporal y un disco persistente). Después de su ejecución, el compilador de imágenes limpia todos los recursos, excepto la imagen de disco que creaste.

Datos

Para crear una imagen de disco personalizada como fuente de datos, completa los siguientes pasos:

Configura el disco de arranque secundario

Puedes configurar el disco de arranque secundario en un clúster de GKE Autopilot o Standard.

Prácticas recomendadas:

Usa un clúster de Autopilot para una experiencia de Kubernetes completamente administrada. Para elegir el modo de operación de GKE que se adapte mejor a tus cargas de trabajo, consulta Elige un modo de operación de GKE.

Use GKE Autopilot

En esta sección, crearás una lista de entidades permitidas de imágenes de disco para permitir la imagen de disco en un clúster de Autopilot de GKE existente. Luego, modificas el selector de nodos de Pod para usar un disco de arranque secundario.

Permite las imágenes de disco en tu proyecto

En esta sección, crearás un GCPResourceAllowlist para permitir que GKE cree nodos con discos de arranque secundarios a partir de las imágenes de disco en tu proyecto de Google Cloud.

Guarda el siguiente manifiesto como allowlist-disk.yaml:

apiVersion: "node.gke.io/v1"
kind: GCPResourceAllowlist
metadata:
  name: gke-secondary-boot-disk-allowlist
spec:
  allowedResourcePatterns:
  - "projects/PROJECT_ID/global/images/.*"

Reemplaza PROJECT_ID por el ID de tu proyecto para alojar la imagen de disco.

Aplica el manifiesto
```
kubectl apply -f allowlist-disk.yaml
```
GKE crea nodos con discos de arranque secundarios a partir de todas las imágenes de disco del proyecto.

Actualiza el selector de nodos de Pod para usar un disco de arranque secundario

En esta sección, modificarás la especificación del Pod para que GKE cree los nodos con el disco de arranque secundario.

Agrega un nodeSelector a tu plantilla de Pod:
```
nodeSelector:
    cloud.google.com.node-restriction.kubernetes.io/gke-secondary-boot-disk-DISK_IMAGE_NAME=CONTAINER_IMAGE_CACHE.PROJECT_ID
```
Reemplaza lo siguiente:
- DISK_IMAGE_NAME: Es el nombre de la imagen de disco.
- PROJECT_ID: El ID de tu proyecto para alojar la imagen de disco.
Usa el comando kubectl apply para aplicar la especificación de Kubernetes con la plantilla de Pod.

Confirma que la memoria caché del disco de arranque secundario esté en uso:

kubectl get events --all-namespaces

El resultado es similar a este:

75s         Normal      SecondaryDiskCachin
node/gke-pd-cache-demo-default-pool-75e78709-zjfm   Image
gcr.io/k8s-staging-jobsejt/pytorch-mnist:latest is backed by secondary disk cache

Verifica la latencia de extracción de la imagen:

kubectl describe pod POD_NAME

Reemplaza POD_NAME con el nombre del pod.

El resultado es similar al siguiente:

…
  Normal  Pulled     15m   kubelet            Successfully pulled image "docker.io/library/nginx:latest" in 0.879149587s
…

La latencia de extracción de imágenes esperada para la imagen del contenedor almacenada en caché debería reducirse significativamente, independientemente del tamaño de la imagen.

Usa GKE Standard

Para crear un clúster de GKE Standard y un grupo de nodos, completa las siguientes instrucciones y elige la pestaña Imágenes o Datos según si deseas precargar imágenes de contenedor o datos en el disco de arranque secundario:

Imágenes

Para configurar un disco de arranque secundario, usa Google Cloud CLI o Terraform:

gcloud

Crea un clúster de GKE Standard con la transmisión de imágenes habilitada:
```
gcloud container clusters create CLUSTER_NAME \
    --location=LOCATION \
    --cluster-version=VERSION \
    --enable-image-streaming
```
Reemplaza lo siguiente:
- CLUSTER_NAME: El nombre de tu clúster.
- LOCATION: Es la ubicación del clúster
- VERSION: la versión de GKE que se usará. La versión de GKE debe ser 1.28.3-gke.1067000 o posterior.
Crea un grupo de nodos con un disco de arranque secundario en el mismo proyecto:
```
gcloud container node-pools create NODE_POOL_NAME \
--cluster=CLUSTER_NAME \
--location LOCATION \
--enable-image-streaming \
--secondary-boot-disk=disk-image=global/images/DISK_IMAGE_NAME,mode=CONTAINER_IMAGE_CACHE
```
Reemplaza lo siguiente:
- NODE_POOL_NAME: el nombre del grupo de nodos
- CLUSTER_NAME: es el nombre del clúster existente.
- LOCATION: Es la zona o zonas de procesamiento del clúster, separadas por comas.
- DISK_IMAGE_NAME: Es el nombre de la imagen de disco.
Para crear un grupo de nodos con un disco de arranque secundario a partir de la imagen de disco en un proyecto diferente, completa los pasos que se indican en Cómo usar un disco de arranque secundario en un proyecto diferente.

Agrega un nodeSelector a tu plantilla de Pod:

nodeSelector:
    cloud.google.com/gke-nodepool: NODE_POOL_NAME

Confirma que la memoria caché del disco de arranque secundario esté en uso:

kubectl get events --all-namespaces

El resultado es similar a este:

75s       Normal      SecondaryDiskCachin
node/gke-pd-cache-demo-default-pool-75e78709-zjfm Image
gcr.io/k8s-staging-jobsejt/pytorch-mnist:latest is backed by secondary disk cache

Ejecuta el siguiente comando para verificar la latencia de extracción de imágenes:

kubectl describe pod POD_NAME

Reemplaza POD_NAME con el nombre del pod.

El resultado es similar al siguiente:

…
  Normal  Pulled     15m   kubelet            Successfully pulled image "docker.io/library/nginx:latest" in 0.879149587s
…

La latencia de extracción de imágenes esperada para la imagen del contenedor almacenada en caché no debe ser superior a unos segundos, independientemente del tamaño de la imagen.

Terraform

Para crear un clúster con el grupo de nodos predeterminado a través de Terraform, consulta el siguiente ejemplo:

resource "google_container_cluster" "default" {
  name               = "default"
  location           = "us-central1-a"
  initial_node_count = 1
  # Set `min_master_version` because secondary_boot_disks require GKE 1.28.3-gke.106700 or later.
  min_master_version = "1.28"
  # Setting `deletion_protection` to `true` would prevent
  # accidental deletion of this instance using Terraform.
  deletion_protection = false
}

Crea un grupo de nodos con un disco de arranque secundario en el mismo proyecto:

resource "google_container_node_pool" "secondary-boot-disk-container" {
  name               = "secondary-boot-disk-container"
  location           = "us-central1-a"
  cluster            = google_container_cluster.default.name
  initial_node_count = 1

  node_config {
    machine_type = "e2-medium"
    image_type   = "COS_CONTAINERD"
    gcfs_config {
      enabled = true
    }
    secondary_boot_disks {
      disk_image = ""
      mode       = "CONTAINER_IMAGE_CACHE"
    }
  }
}

Si deseas obtener más información sobre el uso de Terraform, consulta Compatibilidad con Terraform para GKE.

Agrega un nodeSelector a tu plantilla de Pod:

nodeSelector:
    cloud.google.com/gke-nodepool: NODE_POOL_NAME

Confirma que la memoria caché del disco de arranque secundario esté en uso:

kubectl get events --all-namespaces

El resultado es similar a este:

75s       Normal      SecondaryDiskCachin
node/gke-pd-cache-demo-default-pool-75e78709-zjfm Image
gcr.io/k8s-staging-jobsejt/pytorch-mnist:latest is backed by secondary disk cache

Ejecuta el siguiente comando para verificar la latencia de extracción de imágenes:

kubectl describe pod POD_NAME

Reemplaza POD_NAME con el nombre del pod.

El resultado es similar al siguiente:

…
  Normal  Pulled     15m   kubelet            Successfully pulled image "docker.io/library/nginx:latest" in 0.879149587s
…

La latencia de extracción de imágenes esperada para la imagen del contenedor almacenada en caché no debe ser superior a unos segundos, independientemente del tamaño de la imagen.

Si deseas obtener más información sobre el uso de Terraform, consulta Compatibilidad con Terraform para GKE.

Datos

Puedes configurar un disco de arranque secundario y precargar datos con Google Cloud CLI o Terraform:

gcloud

Crea un clúster de GKE Standard con la transmisión de imágenes habilitada:
```
gcloud container clusters create CLUSTER_NAME \
    --location=LOCATION \
    --cluster-version=VERSION \
    --enable-image-streaming
```
Reemplaza lo siguiente:
- CLUSTER_NAME: El nombre de tu clúster.
- LOCATION: Es la ubicación del clúster
- VERSION: la versión de GKE que se usará. La versión de GKE debe ser 1.28.3-gke.1067000 o posterior.
Crea un grupo de nodos con un disco de arranque secundario mediante la marca --secondary-boot-disk:
```
gcloud container node-pools create NODE_POOL_NAME \
--cluster=CLUSTER_NAME \
--location LOCATION \
--enable-image-streaming \
--secondary-boot-disk=disk-image=global/images/DISK_IMAGE_NAME
```
Reemplaza lo siguiente:
- NODE_POOL_NAME: el nombre del grupo de nodos
- CLUSTER_NAME: es el nombre del clúster existente.
- LOCATION: Es la zona o zonas de procesamiento del clúster, separadas por comas.
- DISK_IMAGE_NAME: Es el nombre de la imagen de disco.
Para crear un grupo de nodos con un disco de arranque secundario a partir de la imagen de disco en un proyecto diferente, completa los pasos que se indican en Cómo usar un disco de arranque secundario en un proyecto diferente.

GKE crea un grupo de nodos en el que cada nodo tiene un disco secundario con datos precargados. GKE conecta y activa el disco de arranque secundario en el nodo.
De forma opcional, puedes activar la imagen de disco secundaria en los contenedores del Pod mediante una activación de volumen hostPath. Usa el siguiente manifiesto para definir los recursos de un Pod y usa una activación de volumen hostPath para precargar el disco de datos en sus contenedores:
```
apiVersion: v1
kind: Pod
metadata:
  name: pod-name
spec:
  containers:
  ...
  volumeMounts:
  - mountPath: /usr/local/data_path_sbd
    name: data_path_sbd
...
volumes:
  - name: data_path_sbd
    hostPath:
        path: /mnt/disks/gke-secondary-disks/gke-DISK_IMAGE_NAME-disk
```
Reemplaza DISK_IMAGE_NAME por el nombre de tu imagen de disco.

Terraform

Para crear un clúster con el grupo de nodos predeterminado a través de Terraform, consulta el siguiente ejemplo:

resource "google_container_cluster" "default" {
  name               = "default"
  location           = "us-central1-a"
  initial_node_count = 1
  # Set `min_master_version` because secondary_boot_disks require GKE 1.28.3-gke.106700 or later.
  min_master_version = "1.28"
  # Setting `deletion_protection` to `true` would prevent
  # accidental deletion of this instance using Terraform.
  deletion_protection = false
}

Crea un grupo de nodos con un disco de arranque secundario en el mismo proyecto:

resource "google_container_node_pool" "secondary-boot-disk-data" {
  name               = "secondary-boot-disk-data"
  location           = "us-central1-a"
  cluster            = google_container_cluster.default.name
  initial_node_count = 1

  node_config {
    machine_type = "e2-medium"
    image_type   = "COS_CONTAINERD"
    gcfs_config {
      enabled = true
    }
    secondary_boot_disks {
      disk_image = ""
    }
  }
}

Si deseas obtener más información sobre el uso de Terraform, consulta Compatibilidad con Terraform para GKE.

De forma opcional, puedes activar la imagen de disco secundaria en los contenedores del Pod mediante una activación de volumen hostPath. Usa el siguiente manifiesto para definir los recursos de un Pod y usa una activación de volumen hostPath para precargar el disco de datos en sus contenedores:
```
apiVersion: v1
kind: Pod
metadata:
  name: pod-name
spec:
  containers:
  ...
  volumeMounts:
  - mountPath: /usr/local/data_path_sbd
    name: data_path_sbd
...
volumes:
  - name: data_path_sbd
    hostPath:
        path: /mnt/disks/gke-secondary-disks/gke-DISK_IMAGE_NAME-disk
```
Reemplaza DISK_IMAGE_NAME por el nombre de tu imagen de disco.

Ajuste de escala automático de clústeres con discos de arranque secundarios

Para crear un grupo de nodos y configurar el ajuste de escala automático del clúster en un disco de inicio secundario, usa Google Cloud CLI:

  gcloud container node-pools create NODE_POOL_NAME \
      --cluster=CLUSTER_NAME \
      --location LOCATION \
      --enable-image-streaming \
      --secondary-boot-disk=disk-image=global/images/DISK_IMAGE_NAME,mode=CONTAINER_IMAGE_CACHE \
      --enable-autoscaling \
      --num-nodes NUM_NODES \
      --min-nodes MIN_NODES \
      --max-nodes MAX_NODES

Reemplaza lo siguiente:

NODE_POOL_NAME: el nombre del grupo de nodos
CLUSTER_NAME: es el nombre del clúster existente.
LOCATION: Es la zona o zonas de procesamiento del clúster, separadas por comas.
DISK_IMAGE_NAME: Es el nombre de la imagen de disco.
MIN_NODES: es la cantidad mínima de nodos que se deben escalar de forma automática para el grupo de nodos especificado por zona. A fin de especificar la cantidad mínima de nodos para todo el grupo de nodos en las versiones 1.24 y posteriores de GKE, usa --total-min-nodes. Las marcas --total-min-nodes y --total-max-nodes son mutuamente excluyentes con las marcas --min-nodes y --max-nodes.
MAX_NODES: la cantidad máxima de nodos que se escalarán de forma automática para el grupo de nodos especificado por zona. A fin de especificar la cantidad máxima de nodos para todo el grupo de nodos en las versiones 1.24 de GKE y posteriores, usa --total-max-nodes. Las marcas --total-min-nodes y --total-max-nodes son mutuamente excluyentes con las marcas --min-nodes y --max-nodes.

Aprovisionamiento automático de nodos con discos de arranque secundarios

En GKE 1.30.1-gke.1329000 y versiones posteriores, puedes configurar el aprovisionamiento automático de nodos para crear y borrar grupos de nodos automáticamente y satisfacer las demandas de recursos de tus cargas de trabajo.

Crea un recurso personalizado de lista de entidades permitidas de imagen de disco para el disco de arranque secundario para el aprovisionamiento automático de nodos de GKE similar al siguiente:
```
apiVersion: "node.gke.io/v1"
kind: GCPResourceAllowlist
metadata:
  name: gke-secondary-boot-disk-allowlist
spec:
  allowedResourcePatterns:
  - "projects/<PROJECT_ID>/global/images/.*"
```
Reemplaza PROJECT_ID por el ID de tu proyecto para alojar la imagen del disco.
Para implementar el recurso personalizado de la lista de entidades permitidas en el clúster, ejecuta el siguiente comando:
```
kubectl apply -f ALLOWLIST_FILE
```
Reemplaza ALLOWLIST_FILE por el nombre del archivo de manifiesto.
Actualiza el selector de nodos del Pod para usar el disco de arranque secundario:
```
nodeSelector:
    cloud.google.com.node-restriction.kubernetes.io/gke-secondary-boot-disk-DISK_IMAGE_NAME=CONTAINER_IMAGE_CACHE.PROJECT_ID
```
Reemplaza lo siguiente:
- DISK_IMAGE_NAME: Es el nombre de la imagen de disco.
- PROJECT_ID: El ID de tu proyecto para alojar la imagen de disco.

Usa un disco de arranque secundario en un proyecto diferente

Cuando creas un grupo de nodos con un disco de arranque secundario, puedes indicarle a GKE que use la imagen del disco en un proyecto diferente con la marca --secondary-boot-disk.

Crea un grupo de nodos con un disco de arranque secundario a partir de la imagen de disco en un proyecto diferente con la marca --secondary-boot-disk. Por ejemplo:
```
gcloud beta container node-pools create NODE_POOL_NAME \
    --cluster=CLUSTER_NAME \
    --location LOCATION \
    --enable-image-streaming \
    --secondary-boot-disk=disk-image=projects/IMAGE_PROJECT_ID/global/images/DISK_IMAGE_NAME,mode=CONTAINER_IMAGE_CACHE
```
Reemplaza lo siguiente:
- DISK_IMAGE_NAME: Es el nombre de la imagen de disco.
- IMAGE_PROJECT_ID: El nombre del proyecto al que pertenece la imagen de disco.
GKE crea un grupo de nodos en el que cada nodo tiene un disco secundario con datos precargados. GKE adjunta y activa el disco de arranque secundario en el nodo.

Para otorgar acceso a imágenes de disco que pertenecen a un proyecto diferente, agrega roles de “Usuario de imagen de Compute” a las cuentas de servicio del clúster:

Cuenta de servicio de procesamiento predeterminada: CLUSTER_PROJECT_NUMBER@cloudservices.gserviceaccount.com
Cuenta de servicio de GKE: service-CLUSTER_PROJECT_NUMBER@container-engine-robot.iam.gserviceaccount.com

gcloud projects add-iam-policy-binding IMAGE_PROJECT_ID \
    --member serviceAccount:CLUSTER_PROJECT_NUMBER@cloudservices.gserviceaccount.com \
    --role roles/compute.imageUser

gcloud projects add-iam-policy-binding IMAGE_PROJECT_ID \
    --member serviceAccount:service-CLUSTER_PROJECT_NUMBER@container-engine-robot.iam.gserviceaccount.com \
    --role roles/compute.imageUser

¿Qué sigue?

Usa Usa la transmisión de imágenes para extraer imágenes de contenedor para extraer imágenes de contenedor mediante la transmisión de datos de imágenes según tus cargas de trabajo.
Consulta Mejora la eficiencia de la carga de trabajo con Fast Socket de NCCL para aprender a usar el complemento Fast Socket de la biblioteca de comunicación colectiva (NCCL) de NVIDIA.