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

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 logren un inicio en frío rápido y mejoren la utilización general de los recursos aprovisionados.

Antes de leer esta página, asegúrate de estar familiarizado con Google Cloud, Kubernetes, los contenedores, YAML, el tiempo 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. Usar imágenes de contenedor o datos 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 ante 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 de contenedor o los datos precargados en los 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 bloque distribuido.
  • El Persistent Disk se instancia a partir de imágenes de disco que creas con anticipación.
  • Por motivos de escalabilidad, cada nodo obtiene su propia instancia de Persistent Disk creada a partir de la imagen de disco. Estas instancias de disco persistente se borran cuando se borra el nodo.
  • Si la imagen de disco ya está en uso en la zona, el tiempo de creación de todos los discos posteriores creados a partir de la misma imagen de 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 decide según el tamaño de la imagen del disco.

Por lo general, agregar discos de arranque secundarios a tus grupos de nodos no aumenta el tiempo de aprovisionamiento de 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 extiende el entorno 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 de Container Registry.

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 el comando gcloud components update para obtener la versión más reciente. Es posible que las versiones anteriores de gcloud CLI no admitan la ejecución de los comandos que se describen en este documento.

Requisitos

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

  1. 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.
  2. Cuando modifiques la imagen del disco, deberás crear un grupo de nodos nuevo. No se admite la actualización de la imagen de disco en nodos existentes.
  3. Configura la transmisión de imágenes para usar la función de disco de arranque secundario.
  4. Usa Container-Optimized OS con una imagen de nodo de containerd. Los nodos de Autopilot usan esta imagen de nodo de forma predeterminada.

  5. 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

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

Precios

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

Prepara la imagen de 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 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:

  1. Crea un bucket de Cloud Storage para almacenar los registros de ejecución de gke-disk-image-builder.
  2. 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:

  1. Crea una VM con un disco en blanco.
  2. Usa SSH para conectarte a la VM.
    1. Monta el disco en blanco.
    2. Descarga los datos en el disco en blanco.
  3. Crea una imagen personalizada a partir del disco.

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 deGoogle Cloud .

  1. 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.

  2. 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.

  1. 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 tu imagen de disco.
    • PROJECT_ID: Es el ID de tu proyecto para alojar la imagen de disco.

  2. Usa el comando kubectl apply para aplicar la especificación de Kubernetes con la plantilla de Pod.

  3. 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

  4. La forma más confiable de confirmar que la memoria caché del disco de arranque secundario está en uso es la siguiente:

    Consulta el registro del nodo que te interesa con este nombre de registro:

    logName="projects/PROJECT_ID/logs/gcfs-snapshotter"

    Reemplaza PROJECT_ID por el Google Cloud ID del proyecto.

    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 usó la memoria caché del disco de arranque secundario.

  5. 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 esperada de extracción de la imagen de 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 contenedores o datos en el disco de arranque secundario:

Imágenes

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

gcloud

  1. 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.

  2. 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 las zonas de procesamiento del clúster, separadas por comas.
    • DISK_IMAGE_NAME: Es el nombre de tu 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 Usa un disco de arranque secundario en un proyecto diferente.

  3. Agrega un nodeSelector a tu plantilla de Pod:

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

  4. 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

  5. La forma más confiable de confirmar que la memoria caché del disco de arranque secundario está en uso es la siguiente:

    Consulta el registro del nodo que te interesa con este nombre de registro:

    logName="projects/PROJECT_ID/logs/gcfs-snapshotter"

    Reemplaza PROJECT_ID por el Google Cloud ID del proyecto.

    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 usó la memoria caché del disco de arranque secundario.

  6. Para verificar la latencia de extracción de la imagen, ejecuta el siguiente comando:

    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 esperada de extracción de la imagen del contenedor almacenada en caché no debería superar unos pocos segundos, independientemente del tamaño de la imagen.

Terraform

  1. 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

  # 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`.
}

  2. 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.

  3. Agrega un nodeSelector a tu plantilla de Pod:

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

  4. 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

  5. Para verificar la latencia de extracción de la imagen, ejecuta el siguiente comando:

    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 esperada de extracción de la imagen del contenedor almacenada en caché no debería ser de más de 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

  1. 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.

  2. 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 las zonas de procesamiento del clúster, separadas por comas.
    • DISK_IMAGE_NAME: Es el nombre de tu 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 Usa 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 adjunta y activa el disco de arranque secundario en el nodo.

  3. Para acceder a los datos, activa la imagen de disco de arranque secundaria en los contenedores del Pod con una activación de volumen hostPath. Establece /usr/local/data_path_sbd en la ruta de acceso del contenedor en la que deseas que residan 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

    Reemplaza DISK_IMAGE_NAME por el nombre de tu imagen de disco.

Terraform

  1. 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

  # 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`.
}

  2. 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.

  3. Para acceder a los datos, activa la imagen de disco de arranque secundaria en los contenedores del Pod con una activación de volumen hostPath. Establece /usr/local/data_path_sbd en la ruta de acceso del contenedor en la que deseas que residan 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

    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 arranque 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 las zonas de procesamiento del clúster, separadas por comas.
  • DISK_IMAGE_NAME: Es el nombre de tu 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 automáticamente grupos de nodos y satisfacer las demandas de recursos de tus cargas de trabajo.

  1. Crea un recurso personalizado de lista de entidades permitidas de imágenes de disco para el disco de arranque secundario del 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 de disco.

  2. 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.

  3. Actualiza el selector de nodos de Pod para usar un 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 tu imagen de disco.
    • PROJECT_ID: Es 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 de disco en un proyecto diferente con la marca --secondary-boot-disk.

  1. 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 tu imagen de disco.
    • IMAGE_PROJECT_ID: Es 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.

  2. Otorga acceso a imágenes de disco que pertenecen a otro proyecto agregando roles de "Usuario de imagen de Compute" para las cuentas de servicio del clúster:

    • Cuenta de servicio de Compute 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?