Esta página se ha traducido con Cloud Translation API.

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

Autopilot Standard

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

Antes de leer esta página, asegúrate de que conoces Google Cloud, Kubernetes, los contenedores, YAML, el tiempo de ejecución de containerd y la CLI de Google Cloud.

Información general

A partir de la versión 1.28.3-gke.1067000 de GKE en clústeres Standard y de la versión 1.30.1-gke.1329000 de GKE en clústeres Autopilot, puedes configurar el grupo de nodos con discos de arranque secundarios. Puedes indicar a GKE que aprovisione los nodos y que precargue datos en ellos, como un modelo de aprendizaje automático o una imagen de contenedor. Usar imágenes de contenedor precargadas o datos en un disco secundario ofrece las siguientes ventajas para tus cargas de trabajo:

Latencia reducida al extraer imágenes de contenedor grandes o descargar datos
Autoescalado más rápido
Recuperación más rápida tras interrupciones, como eventos de mantenimiento y errores del sistema

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

Cómo funcionan los discos de arranque secundarios

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

Los discos de arranque secundarios son discos persistentes respaldados por almacenamiento en bloques distribuido.
El disco persistente se crea a partir de imágenes de disco que creas con antelación.
Por motivos de escalabilidad, cada nodo tiene su propia instancia de Persistent Disk creada a partir de la imagen de disco. Estas instancias de disco persistente se eliminan cuando se elimina el nodo.
Si la imagen de disco ya se está usando en la zona, la hora de creación de todos los discos posteriores creados a partir de la misma imagen de disco será inferior.
El tipo de disco de arranque secundario es el mismo que el del nodo.
El tamaño del disco de arranque secundario se determina en función del tamaño de la imagen de disco.

Normalmente, añadir 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 la imagen de disco en paralelo con el proceso de aprovisionamiento de nodos.

Práctica recomendada:

Para admitir imágenes de contenedor precargadas, GKE amplía el tiempo de ejecución de containerd con complementos que leen las imágenes de contenedor de los discos de arranque secundarios. Las imágenes de contenedor se reutilizan en las capas base.

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

Antes de empezar

Antes de empezar, asegúrate de que has realizado las siguientes tareas:

Habilita la API de Google Kubernetes Engine.

Habilitar la API de Google Kubernetes Engine

Si quieres usar Google Cloud CLI para esta tarea, instálala y, a continuación, inicialízala. Si ya has instalado la gcloud CLI, obtén la versión más reciente ejecutando gcloud components update.
Nota: Si ya tienes instalada la CLI de gcloud, asegúrate de definir la compute/region propiedad. Si usas principalmente clústeres zonales, define compute/zone en su lugar. Si defines una ubicación predeterminada, puedes evitar errores en gcloud CLI como el siguiente: One of [--zone, --region] must be supplied: Please specify location. Es posible que tengas que especificar la ubicación en determinados comandos si la ubicación de tu clúster es diferente de la predeterminada que hayas definido.

Habilita la API Container File System.

Habilitar la API Container File System

Requisitos

Se aplican los siguientes requisitos al usar un 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 en GKE Autopilot.
Cuando modifiques la imagen de disco, debes crear un grupo de nodos. No se admite la actualización de la imagen de disco en los nodos existentes.
Configura Streaming 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 los 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 un flujo de procesamiento de CI/CD.

Limitaciones

No puedes actualizar los discos de arranque secundarios de los nodos que ya tengas. Para adjuntar una nueva imagen de disco, crea un grupo de nodos.

Precios

Cuando creas grupos de nodos con discos de arranque secundarios, GKE adjunta un Persistent Disk a cada nodo del grupo de nodos. Los discos persistentes se facturan según los precios de los discos de Compute Engine.

Preparar la imagen del disco de arranque secundario

Para preparar la imagen del disco de arranque secundario, elige la pestaña Imágenes para precargar imágenes de contenedor o la pestaña Datos para precargar datos. A continuación, sigue estas 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, a continuación, crear una imagen de disco a partir de ese disco.

Para crear una imagen de disco con varias imágenes de contenedor precargadas, sigue estos pasos:

Crea un segmento 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

Haz los cambios siguientes:

PROJECT_ID: el nombre de tu Google Cloud proyecto.
DISK_IMAGE_NAME: el nombre de la imagen del disco. Por ejemplo, nginx-python-image.
LOCATION: la ubicación del clúster.
LOG_BUCKET_NAME: el nombre del segmento de Cloud Storage en el que se almacenarán 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). Una vez ejecutado, el generador de imágenes limpia todos los recursos, excepto la imagen de disco que has creado.

Datos

Para crear una imagen de disco personalizada como fuente de datos, sigue estos pasos:

Configurar el disco de arranque secundario

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

Prácticas recomendadas:

Usa un clúster de Autopilot para disfrutar de una experiencia de Kubernetes totalmente gestionada. Para elegir el modo de funcionamiento de GKE que mejor se adapte a tus cargas de trabajo, consulta Elegir un modo de funcionamiento de GKE.

Usa Autopilot de GKE

En esta sección, crearás una lista de permitidos de imágenes de disco para permitir la imagen de disco en un clúster de GKE Autopilot. A continuación, modifica el selector de nodos de Pod para usar un disco de arranque secundario.

Permitir las imágenes de disco en tu proyecto

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

Guarda el siguiente archivo de 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/.*"

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

Aplica el archivo de 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á la especificación del pod para que GKE cree los nodos con el disco de arranque secundario.

Añade 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
```
Haz los cambios siguientes:
- DISK_IMAGE_NAME: el nombre de la imagen de disco.
- PROJECT_ID: tu ID de 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 se está usando la caché del disco de arranque secundario:
```
kubectl get events --all-namespaces
```
El resultado debería ser similar al siguiente:
```
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
```
Nota: Ten en cuenta que Kubernetes podría limitar los eventos si el volumen es alto. La falta del evento no indica de forma definitiva que no se haya usado el disco de arranque secundario. El siguiente paso es una forma más fiable de verificar que se ha usado el disco de arranque secundario.
La forma más fiable de confirmar que se está usando la caché del disco de arranque secundario es la siguiente:

Consulta el registro del nodo que te interese con este nombre de registro:
```
logName="projects/PROJECT_ID/logs/gcfs-snapshotter"
```
Sustituye PROJECT_ID por el ID de tu proyecto. Google Cloud

El registro similar a Image gcr.io/k8s-staging-jobsejt/pytorch-mnist:latest is backed by secondary boot disk caching by 100.0%... indica que se ha usado la caché del disco de arranque secundario.

Comprueba la latencia de extracción de imágenes:

kubectl describe pod POD_NAME

Sustituye POD_NAME por el nombre del pod.

La salida es similar a la 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 de contenedor almacenada en caché debería reducirse significativamente, independientemente del tamaño de la imagen.

Usar GKE Standard

Para crear un clúster estándar de GKE y un grupo de nodos, sigue estas instrucciones. Elige la pestaña Imágenes o Datos en función de si quieres precargar imágenes de contenedor o datos en el disco de arranque secundario:

Imágenes

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

gcloud

Crea un clúster estándar de GKE con la función de streaming de imágenes habilitada:
```
gcloud container clusters create CLUSTER_NAME \
    --location=LOCATION \
    --cluster-version=VERSION \
    --enable-image-streaming
```
Haz los cambios siguientes:
- CLUSTER_NAME: el nombre de tu clúster.
- LOCATION: la ubicación del clúster.
- VERSION: la versión de GKE que se va a usar. La versión de GKE debe ser 1.28.3-gke.1067000 o una 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
```
Haz los cambios siguientes:
- NODE_POOL_NAME: el nombre del grupo de nodos.
- CLUSTER_NAME: el nombre del clúster.
- LOCATION: la zona o las zonas de computación del clúster separadas por comas.
- DISK_IMAGE_NAME: 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 de otro proyecto, sigue los pasos que se indican en Usar un disco de arranque secundario en otro proyecto.

Añade un nodeSelector a tu plantilla de pod:

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

Confirma que se está usando la caché del disco de arranque secundario:
```
kubectl get events --all-namespaces
```
El resultado debería ser similar al siguiente:
```
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
```
Nota: Ten en cuenta que Kubernetes podría limitar los eventos si el volumen es alto. La falta del evento no indica de forma definitiva que no se haya usado el disco de arranque secundario. El siguiente paso es una forma más fiable de verificar que se ha usado el disco de arranque secundario.
La forma más fiable de confirmar que se está usando la caché del disco de arranque secundario es la siguiente:

Consulta el registro del nodo que te interese con este nombre de registro:
```
logName="projects/PROJECT_ID/logs/gcfs-snapshotter"
```
Sustituye PROJECT_ID por el ID de tu proyecto. Google Cloud

El registro similar a Image gcr.io/k8s-staging-jobsejt/pytorch-mnist:latest is backed by secondary boot disk caching by 100.0%... indica que se ha usado la caché del disco de arranque secundario.

Para comprobar la latencia de extracción de imágenes, ejecuta el siguiente comando:

kubectl describe pod POD_NAME

Sustituye POD_NAME por el nombre del pod.

La salida es similar a la 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 de contenedor almacenada en caché no debería superar unos segundos, independientemente del tamaño de la imagen.

Terraform

Para crear un clúster con el grupo de nodos predeterminado mediante Terraform, consulta el siguiente ejemplo:

resource "google_container_cluster" "default" {
  name               = "default"
  location           = "us-central1-a"
  initial_node_count = 1

  # secondary_boot_disks require GKE 1.28.3-gke.106700 or later, which should
  # be true for all release channels apart from EXTENDED.
  # If required, Use `release_channel = "EXTENDED"` and set `min_master_version`.
}

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"
    }
  }
}

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

Añade un nodeSelector a tu plantilla de pod:

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

Confirma que se está usando la caché del disco de arranque secundario:

kubectl get events --all-namespaces

El resultado debería ser similar al siguiente:

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

Para comprobar la latencia de extracción de imágenes, ejecuta el siguiente comando:

kubectl describe pod POD_NAME

Sustituye POD_NAME por el nombre del pod.

La salida es similar a la siguiente:

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

La latencia de extracción de la imagen de contenedor almacenada en caché no debería superar los pocos segundos, independientemente del tamaño de la imagen.

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

Datos

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

gcloud

Crea un clúster estándar de GKE con la función de streaming de imágenes habilitada:
```
gcloud container clusters create CLUSTER_NAME \
    --location=LOCATION \
    --cluster-version=VERSION \
    --enable-image-streaming
```
Haz los cambios siguientes:
- CLUSTER_NAME: el nombre de tu clúster.
- LOCATION: la ubicación del clúster.
- VERSION: la versión de GKE que se va a usar. La versión de GKE debe ser 1.28.3-gke.1067000 o una 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
```
Haz los cambios siguientes:
- NODE_POOL_NAME: el nombre del grupo de nodos.
- CLUSTER_NAME: el nombre del clúster.
- LOCATION: la zona o las zonas de computación del clúster separadas por comas.
- DISK_IMAGE_NAME: 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 de otro proyecto, sigue los pasos que se indican en Usar un disco de arranque secundario en otro proyecto.

GKE crea un grupo de nodos en el que cada nodo tiene un disco secundario con datos precargados. GKE conecta y monta el disco de arranque secundario en el nodo.
Para acceder a los datos, monta la imagen del disco de arranque secundario en los contenedores del pod mediante un montaje de volumen hostPath. Define /usr/local/data_path_sbd como la ruta del contenedor en la que quieres que se encuentren los datos:
```
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
```
Sustituye DISK_IMAGE_NAME por el nombre de tu imagen de disco.

Nota: Todos los contenedores del mismo nodo comparten el disco de arranque secundario. Todos los contenedores del nodo que monte el disco de arranque secundario podrán ver los datos que escriba un contenedor en él. Para evitar cambios accidentales, puedes montar el volumen en modo de solo lectura.

Terraform

Para crear un clúster con el grupo de nodos predeterminado mediante Terraform, consulta el siguiente ejemplo:

resource "google_container_cluster" "default" {
  name               = "default"
  location           = "us-central1-a"
  initial_node_count = 1

  # secondary_boot_disks require GKE 1.28.3-gke.106700 or later, which should
  # be true for all release channels apart from EXTENDED.
  # If required, Use `release_channel = "EXTENDED"` and set `min_master_version`.
}

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 = ""
    }
  }
}

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

Para acceder a los datos, monta la imagen del disco de arranque secundario en los contenedores del pod mediante un montaje de volumen hostPath. Define /usr/local/data_path_sbd como la ruta del contenedor en la que quieres que se encuentren los datos:

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

Sustituye DISK_IMAGE_NAME por el nombre de tu imagen de disco.

Autoescalado de clústeres con discos de arranque secundarios

Para crear un grupo de nodos y configurar el autoescalado de clústeres en un disco de arranque secundario, usa la CLI de Google Cloud:

  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

Haz los cambios siguientes:

NODE_POOL_NAME: el nombre del grupo de nodos.
CLUSTER_NAME: el nombre del clúster.
LOCATION: la zona o las zonas de computación del clúster separadas por comas.
DISK_IMAGE_NAME: el nombre de la imagen de disco.
MIN_NODES: el número mínimo de nodos que se escalarán automáticamente para el grupo de nodos especificado por zona. Para especificar el número mínimo de nodos de 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 se excluyen mutuamente con las marcas --min-nodes y --max-nodes.
MAX_NODES: el número máximo de nodos que se pueden escalar automáticamente en el grupo de nodos especificado por zona. Para especificar el número máximo de nodos de todo el grupo de nodos en GKE 1.24 y versiones posteriores, usa --total-max-nodes. Las marcas --total-min-nodes y --total-max-nodes se excluyen mutuamente 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 eliminar automáticamente grupos de nodos con el fin de satisfacer las demandas de recursos de tus cargas de trabajo.

Crea un recurso personalizado de lista de permitidos de imágenes de disco para el disco de arranque secundario del aprovisionamiento automático de nodos de GKE, como el siguiente:
```
apiVersion: "node.gke.io/v1"
kind: GCPResourceAllowlist
metadata:
  name: gke-secondary-boot-disk-allowlist
spec:
  allowedResourcePatterns:
  - "projects/<PROJECT_ID>/global/images/.*"
```
Sustituye PROJECT_ID por el ID de tu proyecto para alojar la imagen de disco.
Para desplegar el recurso personalizado de lista de permitidos en el clúster, ejecuta el siguiente comando:
```
kubectl apply -f ALLOWLIST_FILE
```
Sustituye ALLOWLIST_FILE por el nombre del archivo de manifiesto.
Actualiza el selector de nodos de 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
```
Haz los cambios siguientes:
- DISK_IMAGE_NAME: el nombre de la imagen de disco.
- PROJECT_ID: tu ID de proyecto para alojar la imagen de disco.

Usar un disco de arranque secundario en otro proyecto

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

Crea un grupo de nodos con un disco de arranque secundario a partir de la imagen de disco de otro proyecto mediante 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
```
Haz los cambios siguientes:
- DISK_IMAGE_NAME: 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 monta el disco de arranque secundario en el nodo.

Para conceder acceso a imágenes de disco que pertenezcan a otro proyecto, añade los roles "Usuario de imagen de Compute" a las cuentas de servicio del clúster:

Cuenta de servicio predeterminada de Compute: 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

Siguientes pasos

Usa la opción Usar streaming de imágenes para extraer imágenes de contenedor para extraer imágenes de contenedor mediante el streaming de los datos de la imagen a medida que los necesiten tus cargas de trabajo.
Consulta Mejorar la eficiencia de las cargas de trabajo con NCCL Fast Socket para saber cómo usar el plugin Fast Socket de la biblioteca de comunicación colectiva de NVIDIA (NCCL).

Usar discos de arranque secundarios para precargar datos o imágenes de contenedor Organízate con las colecciones Guarda y clasifica el contenido según tus preferencias.

Información general

Cómo funcionan los discos de arranque secundarios

Antes de empezar

Requisitos

Limitaciones

Precios

Preparar la imagen del disco de arranque secundario

Imágenes

Datos

Configurar el disco de arranque secundario

Usa Autopilot de GKE

Permitir las imágenes de disco en tu proyecto

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

Usar GKE Standard

Imágenes

gcloud

Terraform

Datos

gcloud

Terraform

Autoescalado de clústeres con discos de arranque secundarios

Aprovisionamiento automático de nodos con discos de arranque secundarios

Usar un disco de arranque secundario en otro proyecto

Siguientes pasos

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