Crear imágenes personalizadas

Puedes crear imágenes personalizadas a partir de discos, imágenes o instantáneas de origen, o bien a partir de imágenes almacenadas en Cloud Storage, y usar estas imágenes para crear instancias de máquina virtual (VM). Las imágenes personalizadas son ideales en situaciones en las que has creado y modificado un disco de arranque persistente o una imagen específica a un estado determinado y necesitas guardar ese estado para crear VMs.

También puedes usar la herramienta de importación de discos virtuales para importar imágenes de disco de arranque a Compute Engine desde tus sistemas y añadirlas a tu lista de imágenes personalizadas.

Antes de empezar

  • Consulta el documento Imágenes.
  • Si aún no lo has hecho, configura la autenticación. La autenticación verifica tu identidad para acceder a Google Cloud servicios y APIs. Para ejecutar código o ejemplos desde un entorno de desarrollo local, puedes autenticarte en Compute Engine seleccionando una de las siguientes opciones:

    Select the tab for how you plan to use the samples on this page:

    Console

    When you use the Google Cloud console to access Google Cloud services and APIs, you don't need to set up authentication.

    gcloud

    1. Instala Google Cloud CLI. Después de la instalación, inicializa la CLI de Google Cloud ejecutando el siguiente comando: 

      gcloud init

      Si utilizas un proveedor de identidades (IdP) externo, primero debes iniciar sesión en la CLI de gcloud con tu identidad federada.

    2. Set a default region and zone.

    Go

    Para usar las Go muestras de esta página en un entorno de desarrollo local, instala e inicializa la CLI de gcloud y, a continuación, configura las credenciales predeterminadas de la aplicación con tus credenciales de usuario.

      Instala Google Cloud CLI.

      Si utilizas un proveedor de identidades (IdP) externo, primero debes iniciar sesión en la CLI de gcloud con tu identidad federada.

      If you're using a local shell, then create local authentication credentials for your user account: 

      gcloud auth application-default login

      You don't need to do this if you're using Cloud Shell.

      If an authentication error is returned, and you are using an external identity provider (IdP), confirm that you have signed in to the gcloud CLI with your federated identity.

    Para obtener más información, consulta Set up authentication for a local development environment.

    Java

    Para usar las Java muestras de esta página en un entorno de desarrollo local, instala e inicializa la CLI de gcloud y, a continuación, configura las credenciales predeterminadas de la aplicación con tus credenciales de usuario.

      Instala Google Cloud CLI.

      Si utilizas un proveedor de identidades (IdP) externo, primero debes iniciar sesión en la CLI de gcloud con tu identidad federada.

      If you're using a local shell, then create local authentication credentials for your user account: 

      gcloud auth application-default login

      You don't need to do this if you're using Cloud Shell.

      If an authentication error is returned, and you are using an external identity provider (IdP), confirm that you have signed in to the gcloud CLI with your federated identity.

    Para obtener más información, consulta Set up authentication for a local development environment.

    Node.js

    Para usar las Node.js muestras de esta página en un entorno de desarrollo local, instala e inicializa la CLI de gcloud y, a continuación, configura las credenciales predeterminadas de la aplicación con tus credenciales de usuario.

      Instala Google Cloud CLI.

      Si utilizas un proveedor de identidades (IdP) externo, primero debes iniciar sesión en la CLI de gcloud con tu identidad federada.

      If you're using a local shell, then create local authentication credentials for your user account: 

      gcloud auth application-default login

      You don't need to do this if you're using Cloud Shell.

      If an authentication error is returned, and you are using an external identity provider (IdP), confirm that you have signed in to the gcloud CLI with your federated identity.

    Para obtener más información, consulta Set up authentication for a local development environment.

    Python

    Para usar las Python muestras de esta página en un entorno de desarrollo local, instala e inicializa la CLI de gcloud y, a continuación, configura las credenciales predeterminadas de la aplicación con tus credenciales de usuario.

      Instala Google Cloud CLI.

      Si utilizas un proveedor de identidades (IdP) externo, primero debes iniciar sesión en la CLI de gcloud con tu identidad federada.

      If you're using a local shell, then create local authentication credentials for your user account: 

      gcloud auth application-default login

      You don't need to do this if you're using Cloud Shell.

      If an authentication error is returned, and you are using an external identity provider (IdP), confirm that you have signed in to the gcloud CLI with your federated identity.

    Para obtener más información, consulta Set up authentication for a local development environment.

    REST

    Para usar las muestras de la API REST de esta página en un entorno de desarrollo local, debes usar las credenciales que proporciones a la CLI de gcloud.

      Instala Google Cloud CLI.

      Si utilizas un proveedor de identidades (IdP) externo, primero debes iniciar sesión en la CLI de gcloud con tu identidad federada.

    Para obtener más información, consulta el artículo Autenticarse para usar REST de la documentación sobre autenticación de Google Cloud .

Crear una imagen personalizada

En esta sección se describe cómo crear una imagen personalizada en una VM Linux. Para obtener información sobre cómo crear una imagen de Windows, consulta Crear una imagen de Windows.

Selecciona una ubicación de almacenamiento de imágenes

Cuando creas una imagen personalizada, puedes especificar la ubicación de Cloud Storage de la imagen, excepto las ubicaciones birregionales. Si especificas la ubicación de almacenamiento de las imágenes, puedes cumplir los requisitos normativos y de cumplimiento de la localidad de los datos, así como tus necesidades de alta disponibilidad, ya que se proporciona redundancia en varias regiones. Para crear, modificar y eliminar imágenes almacenadas en Cloud Storage, debes tener roles/compute.storageAdmin.

La función de ubicación de almacenamiento es opcional. Si no seleccionas ninguna ubicación, Compute Engine almacenará la imagen en la multirregión más cercana a la fuente de la imagen. Por ejemplo, si creas una imagen a partir de un disco de origen ubicado en us-central1 y no especificas una ubicación para la imagen personalizada, Compute Engine almacenará la imagen en la multirregión us.

Si la imagen no está disponible en una región en la que vas a crear una VM, Compute Engine la almacenará en caché en esa región la primera vez que crees una VM.

Para ver la ubicación en la que se almacena una imagen, usa el comando images describe de gcloud compute:

gcloud compute images describe IMAGE_NAME \
    --project=PROJECT_ID

Haz los cambios siguientes:

  • IMAGE_NAME: el nombre de la imagen.

  • PROJECT_ID: el ID del proyecto al que pertenece la imagen.

Todas las imágenes que tenías antes del lanzamiento de esta función seguirán en el mismo sitio. Lo único que cambia es que ahora puedes ver la ubicación de todas tus imágenes. Si tienes una imagen que quieres mover, debes volver a crearla en la nueva ubicación.

Preparar una VM para crear una imagen

Puedes crear una imagen a partir de un disco aunque esté vinculado a una máquina virtual en ejecución. Sin embargo, la imagen será más fiable si pones la VM en un estado que le resulte más fácil capturar. En esta sección se describe cómo preparar el disco de arranque para la imagen.

Minimizar la escritura de datos en el disco persistente

Siga uno de estos procesos para reducir las escrituras en disco:

  • Detén la VM para que pueda apagarse y dejar de escribir datos en el disco persistente.

  • Si no puedes detener la VM antes de crear la imagen, reduce la cantidad de escrituras en el disco y sincroniza el sistema de archivos. Para minimizar la escritura en tu disco persistente, sigue estos pasos:

    1. Pausa las aplicaciones o los procesos del sistema operativo que escriban datos en ese disco persistente.
    2. Ejecuta un vaciado de la aplicación en el disco si es necesario. Por ejemplo, MySQL tiene una instrucción FLUSH. Es posible que otras aplicaciones tengan procesos similares.
    3. Impide que tus aplicaciones escriban en tu disco persistente.
    4. Ejecuta sudo sync.

Inhabilitar la opción de eliminación automática del disco

De forma predeterminada, la opción de eliminación automática está habilitada en los discos de arranque. Antes de crear una imagen a partir de un disco, inhabilita la eliminación automática para evitar que el disco se elimine automáticamente cuando elimines la VM.

Para inhabilitar la eliminación automática del disco, utiliza uno de los siguientes métodos:

Consola

  1. En la consola de Google Cloud , ve a la página Instancias de VM.

    Ve a la página Instancias de VM.

  2. Haz clic en el nombre de la VM que vas a usar como origen para crear una imagen.

    Se mostrará la página Detalles de la instancia de VM.

  3. Haz clic en Editar.

  4. En la sección Disco de arranque, en Regla de eliminación, comprueba que esté seleccionada la opción Conservar disco.

  5. Haz clic en Guardar.

gcloud

En la CLI de Google Cloud, usa el comando gcloud compute instances set-disk-auto-delete para inhabilitar la opción de eliminación automática del disco.

gcloud compute instances set-disk-auto-delete VM_NAME \
    --no-auto-delete \
    --disk=SOURCE_DISK

Haz los cambios siguientes:

  • VM_NAME: el nombre de tu instancia de VM.
  • SOURCE_DISK: el nombre del disco del que quieres crear la imagen.

Go

Go

Antes de probar este ejemplo, sigue las Go instrucciones de configuración de la guía de inicio rápido de Compute Engine con bibliotecas de cliente. Para obtener más información, consulta la documentación de referencia de la API Go de Compute Engine.

Para autenticarte en Compute Engine, configura las credenciales predeterminadas de la aplicación. Para obtener más información, consulta el artículo Configurar la autenticación en un entorno de desarrollo local. 

import (
	"context"
	"fmt"
	"io"

	compute "cloud.google.com/go/compute/apiv1"
	computepb "cloud.google.com/go/compute/apiv1/computepb"
)

// setDiskAutodelete sets the autodelete flag of a disk to given value.
func setDiskAutoDelete(
	w io.Writer,
	projectID, zone, instanceName, diskName string, autoDelete bool,
) error {
	// projectID := "your_project_id"
	// zone := "us-west3-b"
	// instanceName := "your_instance_name"
	// diskName := "your_disk_name"
	// autoDelete := true

	ctx := context.Background()
	instancesClient, err := compute.NewInstancesRESTClient(ctx)
	if err != nil {
		return fmt.Errorf("NewInstancesRESTClient: %w", err)
	}
	defer instancesClient.Close()

	getInstanceReq := &computepb.GetInstanceRequest{
		Project:  projectID,
		Zone:     zone,
		Instance: instanceName,
	}

	instance, err := instancesClient.Get(ctx, getInstanceReq)
	if err != nil {
		return fmt.Errorf("unable to get instance: %w", err)
	}

	diskExists := false

	for _, disk := range instance.GetDisks() {
		if disk.GetDeviceName() == diskName {
			diskExists = true
			break
		}
	}

	if !diskExists {
		return fmt.Errorf(
			"instance %s doesn't have a disk named %s attached",
			instanceName,
			diskName,
		)
	}

	req := &computepb.SetDiskAutoDeleteInstanceRequest{
		Project:    projectID,
		Zone:       zone,
		Instance:   instanceName,
		DeviceName: diskName,
		AutoDelete: autoDelete,
	}

	op, err := instancesClient.SetDiskAutoDelete(ctx, req)
	if err != nil {
		return fmt.Errorf("unable to set disk autodelete field: %w", err)
	}

	if err = op.Wait(ctx); err != nil {
		return fmt.Errorf("unable to wait for the operation: %w", err)
	}

	fmt.Fprintf(w, "disk autoDelete field updated.\n")

	return nil
}

Java

Java

Antes de probar este ejemplo, sigue las Java instrucciones de configuración de la guía de inicio rápido de Compute Engine con bibliotecas de cliente. Para obtener más información, consulta la documentación de referencia de la API Java de Compute Engine.

Para autenticarte en Compute Engine, configura las credenciales predeterminadas de la aplicación. Para obtener más información, consulta el artículo Configurar la autenticación en un entorno de desarrollo local. 


import com.google.cloud.compute.v1.Instance;
import com.google.cloud.compute.v1.InstancesClient;
import com.google.cloud.compute.v1.Operation;
import com.google.cloud.compute.v1.SetDiskAutoDeleteInstanceRequest;
import java.io.IOException;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.TimeoutException;

public class SetDiskAutodelete {

  public static void main(String[] args)
      throws IOException, ExecutionException, InterruptedException, TimeoutException {
    // TODO(developer): Replace these variables before running the sample.

    // Project ID or project number of the Cloud project you want to use.
    String projectId = "YOUR_PROJECT_ID";

    // The zone of the disk that you want to modify.
    String zone = "europe-central2-b";

    // Name of the instance the disk is attached to.
    String instanceName = "YOUR_INSTANCE_NAME";

    // The name of the disk for which you want to modify the autodelete flag.
    String diskName = "YOUR_DISK_NAME";

    // The new value of the autodelete flag.
    boolean autoDelete = true;

    setDiskAutodelete(projectId, zone, instanceName, diskName, autoDelete);
  }

  // Sets the autodelete flag of a disk to given value.
  public static void setDiskAutodelete(String projectId, String zone, String instanceName,
      String diskName, boolean autoDelete)
      throws IOException, ExecutionException, InterruptedException, TimeoutException {

    // Initialize client that will be used to send requests. This client only needs to be created
    // once, and can be reused for multiple requests. After completing all of your requests, call
    // the `instancesClient.close()` method on the client to safely
    // clean up any remaining background resources.
    try (InstancesClient instancesClient = InstancesClient.create()) {

      // Retrieve the instance given by the instanceName.
      Instance instance = instancesClient.get(projectId, zone, instanceName);

      // Check if the instance contains a disk that matches the given diskName.
      boolean diskNameMatch = instance.getDisksList()
          .stream()
          .anyMatch(disk -> disk.getDeviceName().equals(diskName));

      if (!diskNameMatch) {
        throw new Error(
            String.format("Instance %s doesn't have a disk named %s attached", instanceName,
                diskName));
      }

      // Create the request object.
      SetDiskAutoDeleteInstanceRequest request = SetDiskAutoDeleteInstanceRequest.newBuilder()
          .setProject(projectId)
          .setZone(zone)
          .setInstance(instanceName)
          .setDeviceName(diskName)
          // Update the autodelete property.
          .setAutoDelete(autoDelete)
          .build();

      // Wait for the update instance operation to complete.
      Operation response = instancesClient.setDiskAutoDeleteAsync(request)
          .get(3, TimeUnit.MINUTES);

      if (response.hasError()) {
        System.out.println("Failed to update Disk autodelete field!" + response);
        return;
      }
      System.out.println(
          "Disk autodelete field updated. Operation Status: " + response.getStatus());
    }
  }
}

Node.js

Node.js

Antes de probar este ejemplo, sigue las Node.js instrucciones de configuración de la guía de inicio rápido de Compute Engine con bibliotecas de cliente. Para obtener más información, consulta la documentación de referencia de la API Node.js de Compute Engine.

Para autenticarte en Compute Engine, configura las credenciales predeterminadas de la aplicación. Para obtener más información, consulta el artículo Configurar la autenticación en un entorno de desarrollo local. 

/**
 * TODO(developer): Uncomment and replace these variables before running the sample.
 */
// const projectId = 'YOUR_PROJECT_ID';
// const zone = 'europe-central2-b';
// const instanceName = 'YOUR_INSTANCE_NAME';
// const diskName = 'YOUR_DISK_NAME';
// const autoDelete = true;

const compute = require('@google-cloud/compute');

async function setDiskAutodelete() {
  const instancesClient = new compute.InstancesClient();

  const [instance] = await instancesClient.get({
    project: projectId,
    zone,
    instance: instanceName,
  });

  if (!instance.disks.some(disk => disk.deviceName === diskName)) {
    throw new Error(
      `Instance ${instanceName} doesn't have a disk named ${diskName} attached.`
    );
  }

  const [response] = await instancesClient.setDiskAutoDelete({
    project: projectId,
    zone,
    instance: instanceName,
    deviceName: diskName,
    autoDelete,
  });
  let operation = response.latestResponse;
  const operationsClient = new compute.ZoneOperationsClient();

  // Wait for the update instance operation to complete.
  while (operation.status !== 'DONE') {
    [operation] = await operationsClient.wait({
      operation: operation.name,
      project: projectId,
      zone: operation.zone.split('/').pop(),
    });
  }

  console.log('Disk autoDelete field updated.');
}

setDiskAutodelete();

Python

Python

Antes de probar este ejemplo, sigue las Python instrucciones de configuración de la guía de inicio rápido de Compute Engine con bibliotecas de cliente. Para obtener más información, consulta la documentación de referencia de la API Python de Compute Engine.

Para autenticarte en Compute Engine, configura las credenciales predeterminadas de la aplicación. Para obtener más información, consulta el artículo Configurar la autenticación en un entorno de desarrollo local. 

from __future__ import annotations

import sys
from typing import Any

from google.api_core.extended_operation import ExtendedOperation
from google.cloud import compute_v1


def wait_for_extended_operation(
    operation: ExtendedOperation, verbose_name: str = "operation", timeout: int = 300
) -> Any:
    """
    Waits for the extended (long-running) operation to complete.

    If the operation is successful, it will return its result.
    If the operation ends with an error, an exception will be raised.
    If there were any warnings during the execution of the operation
    they will be printed to sys.stderr.

    Args:
        operation: a long-running operation you want to wait on.
        verbose_name: (optional) a more verbose name of the operation,
            used only during error and warning reporting.
        timeout: how long (in seconds) to wait for operation to finish.
            If None, wait indefinitely.

    Returns:
        Whatever the operation.result() returns.

    Raises:
        This method will raise the exception received from `operation.exception()`
        or RuntimeError if there is no exception set, but there is an `error_code`
        set for the `operation`.

        In case of an operation taking longer than `timeout` seconds to complete,
        a `concurrent.futures.TimeoutError` will be raised.
    """
    result = operation.result(timeout=timeout)

    if operation.error_code:
        print(
            f"Error during {verbose_name}: [Code: {operation.error_code}]: {operation.error_message}",
            file=sys.stderr,
            flush=True,
        )
        print(f"Operation ID: {operation.name}", file=sys.stderr, flush=True)
        raise operation.exception() or RuntimeError(operation.error_message)

    if operation.warnings:
        print(f"Warnings during {verbose_name}:\n", file=sys.stderr, flush=True)
        for warning in operation.warnings:
            print(f" - {warning.code}: {warning.message}", file=sys.stderr, flush=True)

    return result


def set_disk_autodelete(
    project_id: str, zone: str, instance_name: str, disk_name: str, autodelete: bool
) -> None:
    """
    Set the autodelete flag of a disk to given value.

    Args:
        project_id: project ID or project number of the Cloud project you want to use.
        zone: name of the zone in which is the disk you want to modify.
        instance_name: name of the instance the disk is attached to.
        disk_name: the name of the disk which flag you want to modify.
        autodelete: the new value of the autodelete flag.
    """
    instance_client = compute_v1.InstancesClient()
    instance = instance_client.get(
        project=project_id, zone=zone, instance=instance_name
    )

    for disk in instance.disks:
        if disk.device_name == disk_name:
            break
    else:
        raise RuntimeError(
            f"Instance {instance_name} doesn't have a disk named {disk_name} attached."
        )

    disk.auto_delete = autodelete

    operation = instance_client.update(
        project=project_id,
        zone=zone,
        instance=instance_name,
        instance_resource=instance,
    )

    wait_for_extended_operation(operation, "disk update")

REST

Para definir la opción de eliminación automática de un disco, haz una solicitud POST al método instances.setDiskAutoDelete.

POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/zones/ZONE/instances/VM_NAME/setDiskAutoDelete?autoDelete=false&deviceName=SOURCE_DISK

Haz los cambios siguientes:

  • PROJECT_ID: el ID del proyecto al que pertenece la VM de origen.
  • ZONE: la zona en la que se encuentra la VM de origen.
  • VM_NAME: nombre de la VM de origen.
  • SOURCE_DISK: el nombre del dispositivo del disco del que quieres crear la imagen.

Después de preparar la VM, crea la imagen.

Crea la imagen

Puedes crear imágenes de disco a partir de las siguientes fuentes:

  • Un disco persistente, incluso cuando está conectado a una VM
  • Una captura de un disco persistente
  • Otra imagen de tu proyecto
  • Una imagen compartida desde otro proyecto
  • Una imagen RAW comprimida en Cloud Storage

Puedes crear una imagen de disco cada 10 minutos. Si quieres enviar una ráfaga de solicitudes para crear una imagen de disco, puedes enviar un máximo de 6 solicitudes en 60 minutos. Para obtener más información, consulta Límites de frecuencia de las copias de seguridad.

Consola

  1. En la Google Cloud consola, ve a la página Crear una imagen.

    Ir a Crear una imagen

  2. Especifica el nombre de la imagen.

  3. Especifica la fuente a partir de la que quieras crear una imagen. Puede ser un disco persistente, una captura, otra imagen o un archivo disk.raw en Cloud Storage.

  4. Si vas a crear una imagen a partir de un disco conectado a una VM en ejecución, marca la casilla Mantener la instancia en ejecución para confirmar que quieres crear la imagen mientras la VM está en ejecución. Puedes preparar tu VM antes de crear la imagen.

  5. En la lista desplegable Según la ubicación del disco de origen (opción predeterminada), especifica la ubicación en la que se almacenará la imagen. Por ejemplo, especifica us para almacenar la imagen en la multirregión us o us-central1 para almacenarla en la región us-central1. Si no haces ninguna selección, Compute Engine almacenará la imagen en la multirregión más cercana a la ubicación de origen de la imagen.

  6. Opcional: especifica las propiedades de la imagen.

    • Familia: la familia de imágenes a la que pertenece esta nueva imagen.
    • Descripción: descripción de la imagen personalizada.
    • Etiqueta: una etiqueta para agrupar recursos.

  7. Especifica la clave de cifrado. Puedes elegir entre una clave Google-owned and Google-managed encryption key, una clave de Cloud Key Management Service (Cloud KMS) o una clave de encriptado suministrada por el cliente (CSEK). Si no se especifica ninguna clave de cifrado, las imágenes se cifran con una Google-owned and Google-managed encryption key.

  8. Haz clic en Crear para crear la imagen.

gcloud

En la CLI de Google Cloud, usa el comando gcloud compute images create para crear una imagen personalizada.

Crea una imagen a partir de un disco de origen:

La marca --force es opcional y te permite crear la imagen a partir de una instancia en ejecución. De forma predeterminada, no puedes crear imágenes a partir de instancias en ejecución. Especifica esta marca solo si estás seguro de que quieres crear la imagen mientras la instancia está en ejecución.

gcloud compute images create IMAGE_NAME \
    --source-disk=SOURCE_DISK \
    --source-disk-zone=ZONE \
    [--family=IMAGE_FAMILY] \
    [--storage-location=LOCATION] \
    [--force]

Haz los cambios siguientes:

  • IMAGE_NAME: nombre de la nueva imagen
  • SOURCE_DISK: el disco del que quieres crear la imagen
  • ZONE: la zona en la que se encuentra el disco
  • IMAGE_FAMILY: opcional, una marca que especifica a qué familia de imágenes pertenece esta imagen.
  • LOCATION: opcional, una marca que te permite designar la región o multirregión en la que se almacena tu imagen. Por ejemplo, especifica us para almacenar la imagen en la multirregión us o us-central1 para almacenarla en la región us-central1. Si no haces ninguna selección, Compute Engine almacenará la imagen en la multirregión más cercana a la ubicación de origen de la imagen.

Crear una imagen a partir de una imagen de origen:

gcloud compute images create IMAGE_NAME \
  --source-image=SOURCE_IMAGE \
  [--source-image-project=IMAGE_PROJECT] \
  [--family=IMAGE_FAMILY] \
  [--storage-location=LOCATION]

Haz los cambios siguientes:

  • IMAGE_NAME: el nombre de la nueva imagen.
  • SOURCE_IMAGE: la imagen a partir de la que quieres crear la nueva imagen.
  • IMAGE_PROJECT: opcional: proyecto en el que se encuentra la imagen de origen. Utilice este parámetro si quiere copiar una imagen de otro proyecto.
  • IMAGE_FAMILY: opcional. Es la familia de imágenes a la que pertenece esta nueva imagen.
  • LOCATION: opcional, te permite designar la región o las regiones en las que se almacena tu imagen. Por ejemplo, especifica us para almacenar la imagen en la multirregión us o us-central1 para almacenarla en la región us-central1. Si no haces ninguna selección, Compute Engine almacenará la imagen en la multirregión más cercana a la ubicación de origen de la imagen.

Crear una imagen a partir de una captura:

gcloud compute images create IMAGE_NAME \
    --source-snapshot=SOURCE_SNAPSHOT \
    [--storage-location=LOCATION]

Haz los cambios siguientes:

  • IMAGE_NAME: nombre de la nueva imagen
  • SOURCE_SNAPSHOT: la captura a partir de la que quieres crear la imagen
  • LOCATION: opcional, una marca que te permite designar la región o multirregión en la que se almacena tu imagen. Por ejemplo, especifica us para almacenar la imagen en la multirregión us o us-central1 para almacenarla en la región us-central1. Si no haces ninguna selección, Compute Engine almacenará la imagen en la multirregión más cercana a la ubicación de origen de la imagen.

Ver la ubicación de una imagen:

Usa el comando gcloud compute images describe para ver la ubicación de una imagen. 

gcloud compute images describe IMAGE_NAME

Sustituye IMAGE_NAME por el nombre de la imagen que quieras revisar.

Go

Go

Antes de probar este ejemplo, sigue las Go instrucciones de configuración de la guía de inicio rápido de Compute Engine con bibliotecas de cliente. Para obtener más información, consulta la documentación de referencia de la API Go de Compute Engine.

Para autenticarte en Compute Engine, configura las credenciales predeterminadas de la aplicación. Para obtener más información, consulta el artículo Configurar la autenticación en un entorno de desarrollo local. 

import (
	"context"
	"fmt"
	"io"

	compute "cloud.google.com/go/compute/apiv1"
	computepb "cloud.google.com/go/compute/apiv1/computepb"
)

// Creates a disk image from an existing disk
func createImageFromDisk(
	w io.Writer,
	projectID, zone, sourceDiskName, imageName string,
	storageLocations []string,
	forceCreate bool,
) error {
	// projectID := "your_project_id"
	// zone := "us-central1-a"
	// sourceDiskName := "your_disk_name"
	// imageName := "my_image"
	// // If storageLocations empty, automatically selects the closest one to the source
	// storageLocations = []string{}
	// // If forceCreate is set to `true`, proceeds even if the disk is attached to
	// // a running instance. This may compromise integrity of the image!
	// forceCreate = false

	ctx := context.Background()
	disksClient, err := compute.NewDisksRESTClient(ctx)
	if err != nil {
		return fmt.Errorf("NewDisksRESTClient: %w", err)
	}
	defer disksClient.Close()
	imagesClient, err := compute.NewImagesRESTClient(ctx)
	if err != nil {
		return fmt.Errorf("NewImagesRESTClient: %w", err)
	}
	defer imagesClient.Close()

	// Get the source disk
	source_req := &computepb.GetDiskRequest{
		Disk:    sourceDiskName,
		Project: projectID,
		Zone:    zone,
	}

	disk, err := disksClient.Get(ctx, source_req)
	if err != nil {
		return fmt.Errorf("unable to get source disk: %w", err)
	}

	// Create the image
	req := computepb.InsertImageRequest{
		ForceCreate: &forceCreate,
		ImageResource: &computepb.Image{
			Name:             &imageName,
			SourceDisk:       disk.SelfLink,
			StorageLocations: storageLocations,
		},
		Project: projectID,
	}

	op, err := imagesClient.Insert(ctx, &req)

	if err = op.Wait(ctx); err != nil {
		return fmt.Errorf("unable to wait for the operation: %w", err)
	}

	fmt.Fprintf(w, "Disk image %s created\n", imageName)

	return nil
}

Java

Java

Antes de probar este ejemplo, sigue las Java instrucciones de configuración de la guía de inicio rápido de Compute Engine con bibliotecas de cliente. Para obtener más información, consulta la documentación de referencia de la API Java de Compute Engine.

Para autenticarte en Compute Engine, configura las credenciales predeterminadas de la aplicación. Para obtener más información, consulta el artículo Configurar la autenticación en un entorno de desarrollo local. 


import com.google.cloud.compute.v1.Disk;
import com.google.cloud.compute.v1.DisksClient;
import com.google.cloud.compute.v1.Image;
import com.google.cloud.compute.v1.ImagesClient;
import com.google.cloud.compute.v1.InsertImageRequest;
import com.google.cloud.compute.v1.Instance;
import com.google.cloud.compute.v1.InstancesClient;
import com.google.cloud.compute.v1.Operation;
import java.io.IOException;
import java.util.Arrays;
import java.util.HashMap;
import java.util.Map;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.TimeoutException;

public class CreateImage {

  public static void main(String[] args)
      throws IOException, ExecutionException, InterruptedException, TimeoutException {
    // TODO(developer): Replace these variables before running the sample.

    // Project ID or project number of the Cloud project you use.
    String project = "your-project-id";
    // Zone of the disk you copy from.
    String zone = "europe-central2-b";
    // Name of the source disk you copy from.
    String sourceDiskName = "source-disk-name";
    // Name of the image you want to create.
    String imageName = "your-image-name";
    // Storage location for the image. If the value is undefined,
    // function will store the image in the multi-region closest to your image's source location.
    String storageLocation = "eu";
    // Create the image even if the source disk is attached to a running instance.
    boolean forceCreate = false;

    createImage(project, zone, sourceDiskName, imageName, storageLocation, forceCreate);
  }

  // Creates a new disk image from the specified source disk.
  public static void createImage(String project, String zone, String sourceDiskName,
      String imageName, String storageLocation, boolean forceCreate)
      throws IOException, ExecutionException, InterruptedException, TimeoutException {
    // Initialize client that will be used to send requests. This client only needs to be created
    // once, and can be reused for multiple requests. After completing all of your requests, call
    // the `client.close()` method on the client to safely
    // clean up any remaining background resources.
    try (ImagesClient imagesClient = ImagesClient.create();
        InstancesClient instancesClient = InstancesClient.create();
        DisksClient disksClient = DisksClient.create()) {

      Disk disk = disksClient.get(project, zone, sourceDiskName);

      // Getting instances where source disk is attached.
      for (String fullInstanceName : disk.getUsersList()) {
        Map<String, String> instanceInfo = parseInstanceName(fullInstanceName);
        Instance instance = instancesClient.get(instanceInfo.get("instanceProjectId"),
            instanceInfo.get("instanceZone"), instanceInfo.get("instanceName"));

        // Сheck whether the instances are stopped.
        if (!Arrays.asList("TERMINATED", "STOPPED").contains(instance.getStatus())
            && !forceCreate) {
          throw new IllegalStateException(
              String.format(
                  "Instance %s should be stopped. For Windows instances please stop the instance "
                      + "using GCESysprep command. For Linux instances just shut it down normally."
                      + " You can suppress this error and create an image of the disk by setting "
                      + "'forceCreate' parameter to true (not recommended). "
                      + "More information here: "
                      + "* https://cloud.google.com/compute/docs/instances/windows/creating-windows-os-image#api"
                      + "* https://cloud.google.com/compute/docs/images/create-delete-deprecate-private-images#prepare_instance_for_image",
                  instanceInfo.get("instanceName")));
        }
      }

      if (forceCreate) {
        System.out.println(
            "Warning: forceCreate option compromise the integrity of your image. "
                + "Stop the instance before you create the image if possible.");
      }

      // Create Image.
      IImageimage = IImagenewBuilder()
          .setName(imageName)
          .setSourceDisk(String.format("/zones/%s/disks/%s", zone, sourceDiskName))
          .addStorageLocations(storageLocation.isEmpty() ? "" : storageLocation)
          .build();

      IInsertImageRequestinsertImageRequest = IInsertImageRequestnewBuilder()
          .setProject(project)
          .ssetForceCreateforceCreate)
          .setImageResource(image)
          .build();

      OOperationresponse = imagesClient.insertAsync(insertImageRequest).get(5, TimeUnit.MINUTES);

      if (rresponse.hasError() {
        System.out.println("Image creation failed ! ! " + response);
        return;
      }

      System.out.println("Image created.");
    }
  }


  public static Map<String, String> parseInstanceName(String name) {
    String[] parsedName = name.split("/");
    int splitLength = parsedName.length;

    if (splitLength < 5) {
      throw new IllegalArgumentException(
          "Provide correct instance name in the following format: "
              + "https://www.googleapis.com/compute/v1/projects/PROJECT/zones/ZONE/instances/INSTANCE_NAME");
    }

    return new HashMap<>() {
      {
        put("instanceName", parsedName[splitLength - 1]);
        put("instanceZone", parsedName[splitLength - 3]);
        put("instanceProjectId", parsedName[splitLength - 5]);
      }
    };
  }

}

Python

Python

Antes de probar este ejemplo, sigue las Python instrucciones de configuración de la guía de inicio rápido de Compute Engine con bibliotecas de cliente. Para obtener más información, consulta la documentación de referencia de la API Python de Compute Engine.

Para autenticarte en Compute Engine, configura las credenciales predeterminadas de la aplicación. Para obtener más información, consulta el artículo Configurar la autenticación en un entorno de desarrollo local. 

from __future__ import annotations

import sys
from typing import Any
import warnings

from google.api_core.extended_operation import ExtendedOperation
from google.cloud import compute_v1


def wait_for_extended_operation(
    operation: ExtendedOperation, verbose_name: str = "operation", timeout: int = 300
) -> Any:
    """
    Waits for the extended (long-running) operation to complete.

    If the operation is successful, it will return its result.
    If the operation ends with an error, an exception will be raised.
    If there were any warnings during the execution of the operation
    they will be printed to sys.stderr.

    Args:
        operation: a long-running operation you want to wait on.
        verbose_name: (optional) a more verbose name of the operation,
            used only during error and warning reporting.
        timeout: how long (in seconds) to wait for operation to finish.
            If None, wait indefinitely.

    Returns:
        Whatever the operation.result() returns.

    Raises:
        This method will raise the exception received from `operation.exception()`
        or RuntimeError if there is no exception set, but there is an `error_code`
        set for the `operation`.

        In case of an operation taking longer than `timeout` seconds to complete,
        a `concurrent.futures.TimeoutError` will be raised.
    """
    result = operation.result(timeout=timeout)

    if operation.error_code:
        print(
            f"Error during {verbose_name}: [Code: {operation.error_code}]: {operation.error_message}",
            file=sys.stderr,
            flush=True,
        )
        print(f"Operation ID: {operation.name}", file=sys.stderr, flush=True)
        raise operation.exception() or RuntimeError(operation.error_message)

    if operation.warnings:
        print(f"Warnings during {verbose_name}:\n", file=sys.stderr, flush=True)
        for warning in operation.warnings:
            print(f" - {warning.code}: {warning.message}", file=sys.stderr, flush=True)

    return result


STOPPED_MACHINE_STATUS = (
    compute_v1.Instance.Status.TERMINATED.name,
    compute_v1.Instance.Status.STOPPED.name,
)


def create_image_from_disk(
    project_id: str,
    zone: str,
    source_disk_name: str,
    image_name: str,
    storage_location: str | None = None,
    force_create: bool = False,
) -> compute_v1.Image:
    """
    Creates a new disk image.

    Args:
        project_id: project ID or project number of the Cloud project you use.
        zone: zone of the disk you copy from.
        source_disk_name: name of the source disk you copy from.
        image_name: name of the image you want to create.
        storage_location: storage location for the image. If the value is undefined,
            function will store the image in the multi-region closest to your image's
            source location.
        force_create: create the image even if the source disk is attached to a
            running instance.

    Returns:
        An Image object.
    """
    image_client = compute_v1.ImagesClient()
    disk_client = compute_v1.DisksClient()
    instance_client = compute_v1.InstancesClient()

    # Get source disk
    disk = disk_client.get(project=project_id, zone=zone, disk=source_disk_name)

    for disk_user in disk.users:
        instance_name = disk_user.split("/")[-1]
        instance = instance_client.get(
            project=project_id, zone=zone, instance=instance_name
        )
        if instance.status in STOPPED_MACHINE_STATUS:
            continue
        if not force_create:
            raise RuntimeError(
                f"Instance {disk_user} should be stopped. For Windows instances please "
                f"stop the instance using `GCESysprep` command. For Linux instances just "
                f"shut it down normally. You can supress this error and create an image of"
                f"the disk by setting `force_create` parameter to true (not recommended). \n"
                f"More information here: \n"
                f" * https://cloud.google.com/compute/docs/instances/windows/creating-windows-os-image#api \n"
                f" * https://cloud.google.com/compute/docs/images/create-delete-deprecate-private-images#prepare_instance_for_image"
            )
        else:
            warnings.warn(
                f"Warning: The `force_create` option may compromise the integrity of your image. "
                f"Stop the {disk_user} instance before you create the image if possible."
            )

    # Create image
    image = compute_v1.Image()
    image.source_disk = disk.self_link
    image.name = image_name
    if storage_location:
        image.storage_locations = [storage_location]

    operation = image_client.insert(project=project_id, image_resource=image)

    wait_for_extended_operation(operation, "image creation from disk")

    return image_client.get(project=project_id, image=image_name)

REST

Haz una solicitud POST al método images().insert, una URL en el cuerpo de la solicitud que apunte al objeto de origen del que quieres crear la imagen. Especifica las URLs de tus recursos con tu ID de proyecto y los nombres de los recursos.

Crea una imagen a partir de un disco persistente:

POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/global/images

{
  "name": "IMAGE_NAME",
  "sourceDisk": "/zones/ZONE/disks/SOURCE_DISK",
  ("storageLocations": "LOCATION",)
  ("forceCreate": "TRUE")
}

Haz los cambios siguientes:

  • PROJECT_ID: el ID del proyecto al que pertenece la imagen.
  • IMAGE_NAME: el nombre de la nueva imagen que quieras crear.
  • ZONE: la zona en la que se encuentra el disco de origen.
  • SOURCE_DISK: el disco del que quieras crear la imagen.
  • LOCATION: opcional, la ubicación de almacenamiento de la imagen. Por ejemplo, especifica us para almacenar la imagen en la multirregión us o us-central1 para almacenarla en la región us-central1. Si no seleccionas ninguna, Compute Engine almacenará la imagen en la multirregión más cercana a la ubicación de origen de la imagen.

El parámetro opcional forceCreate te permite crear la imagen a partir de una VM en ejecución. Especifica TRUE solo si quieres crear la imagen a partir de una VM en ejecución. El forceCreate ajuste predeterminado es FALSE.

Crear una imagen a partir de otra:

POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/global/images

{
  "name": "IMAGE_NAME",
  "sourceImage": "/global/images/SOURCE_IMAGE",
  ("storageLocations": "LOCATION")
}

Haz los cambios siguientes:

  • PROJECT_ID: el proyecto al que pertenece la imagen.
  • IMAGE_NAME: el nombre de la nueva imagen que quieras crear.
  • SOURCE_IMAGE: la imagen a partir de la que quieres crear la imagen.
  • LOCATION: opcional, la ubicación de almacenamiento de la imagen. Por ejemplo, especifica us para almacenar la imagen en la multirregión us o us-central1 para almacenarla en la región us-central1. Si no seleccionas ninguna, Compute Engine almacenará la imagen en la multirregión más cercana a la ubicación de origen de la imagen.

Crear una imagen a partir de una captura:

POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/global/images
{
  "name": "IMAGE_NAME",
  "sourceSnapshot": "(/SOURCE_PROJECT_ID)/global/snapshots/SOURCE_SNAPSHOT",
  ("storageLocations": "LOCATION")
}

Haz los cambios siguientes:

  • PROJECT_ID: el proyecto al que pertenece la imagen.
  • IMAGE_NAME: el nombre de la nueva imagen que quieras crear.
  • SOURCE_PROJECT_ID: opcional: proyecto en el que se encuentra la instantánea. Debes tener permiso para acceder al recurso de captura de ese proyecto.
  • SOURCE_SNAPSHOT: la captura a partir de la que quieres crear la imagen.
  • LOCATION: opcional, la ubicación de almacenamiento de la imagen. Por ejemplo, especifica us para almacenar la imagen en la multirregión us o us-central1 para almacenarla en la región us-central1. Si no seleccionas ninguna, Compute Engine almacenará la imagen en la multirregión más cercana a la ubicación de origen de la imagen.

Para obtener más información sobre cómo añadir imágenes, consulta la referencia de imágenes.

Comparte la imagen

Después de crear una imagen personalizada, puedes compartirla en varios proyectos. Si permites que los usuarios de otro proyecto usen tus imágenes personalizadas, podrán acceder a ellas especificando el proyecto de la imagen en su solicitud.

Habilitar funciones del sistema operativo invitado

Usa las funciones del sistema operativo invitado para configurar las siguientes opciones de redes, seguridad, almacenamiento y SO en imágenes personalizadas. Las imágenes personalizadas con estas funciones configuradas se usan como discos de arranque.

gcloud

Usa el comando gcloud compute images create con la marca --guest-os-features para crear una imagen personalizada a partir de otra imagen personalizada.

gcloud compute images create IMAGE_NAME \
    --source-image=SOURCE_IMAGE \
    [--source-image-project=IMAGE_PROJECT] \
    --guest-os-features="FEATURES,..." \
    [--storage-location=LOCATION]

Haz los cambios siguientes:

  • IMAGE_NAME: el nombre de la nueva imagen
  • SOURCE_IMAGE: una imagen en la que basar la nueva imagen

  • IMAGE_PROJECT: Opcional: el proyecto que contiene la imagen de origen.

    Usa este parámetro para copiar una imagen de otro proyecto.

  • FEATURES: etiquetas del SO invitado para habilitar funciones en las VMs que crees a partir de imágenes

    Para añadir varios valores, sepáralos con comas. Se debe configurar como uno o varios de los siguientes valores:

    • VIRTIO_SCSI_MULTIQUEUE. Úsala en dispositivos SSD locales como alternativa a NVMe. Para obtener más información sobre las imágenes que admiten SCSI, consulta Elegir una interfaz.

      En el caso de las imágenes de Linux, puedes habilitar SCSI de varias colas en dispositivos SSD locales en imágenes con versiones del kernel 3.17 o posteriores. En las imágenes de Windows, puedes habilitar SCSI de varias colas en dispositivos SSD locales en imágenes con el controlador de Windows de Compute Engine versión 1.2.

    • WINDOWS. Etiqueta las imágenes de arranque personalizadas de Windows Server como imágenes de Windows.
    • MULTI_IP_SUBNET. Configurar interfaces con una máscara de red distinta de /32. Para obtener más información sobre las interfaces de red múltiples y cómo funcionan, consulta el artículo Descripción general y ejemplos de interfaces de red múltiples.
    • UEFI_COMPATIBLE. Arranca con firmware UEFI y las siguientes funciones de VM blindada:
    • GVNIC. Admite anchos de banda de red más altos, de hasta entre 50 y 100 Gbps. Para obtener más información, consulta Usar NIC virtual de Google.
    • IDPF. Admite interfaces de red de función de ruta de datos de infraestructura de Intel (IDPF).
    • SEV_CAPABLE o SEV_SNP_CAPABLE. Usa estas etiquetas si quieres usar tu imagen en una instancia de VM confidencial con compatibilidad con AMD Secure Encrypted Virtualization (SEV) o AMD Secure Encrypted Virtualization-Secure Nested Paging (SEV-SNP). Para comprobar si tu kernel es compatible con AMD SEV o AMD SEV-SNP, consulta los detalles del kernel de Linux.
    • SEV_LIVE_MIGRATABLE_V2. Usa esta etiqueta si quieres usar tu imagen en una instancia de Confidential VM que admita la migración activa en AMD SEV. Para comprobar si tu kernel admite la migración en tiempo real, consulta los detalles del kernel de Linux.
    • TDX_CAPABLE. Usa esta etiqueta si quieres usar tu imagen en una instancia de VM confidencial con compatibilidad con las extensiones de dominio de confianza (TDX) de Intel. Para comprobar si tu kernel es compatible con Intel TDX, consulta Detalles del kernel de Linux.

  • LOCATION: opcional: región o multirregión en la que almacenar la imagen

    Por ejemplo, especifica us para almacenar la imagen en la multirregión us o us-central1 para almacenarla en la región us-central1. Si no haces ninguna selección, Compute Engine almacenará la imagen en la multirregión más cercana a la ubicación de origen de la imagen.

REST

Usa el método images().insert con la marca guestOsFeatures para crear una imagen personalizada a partir de una imagen personalizada.


POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/global/images

{
 "name": "IMAGE_NAME",
 "sourceImage": "(projects/IMAGE_PROJECT)/global/images/SOURCE_IMAGE",
 ("storageLocations": "LOCATION",)
 "guestOsFeatures": [
  {
   "type": "FEATURES"
  }
 ]
}

Haz los cambios siguientes:

  • PROJECT_ID: ID del proyecto en el que se va a crear la imagen.
  • IMAGE_NAME: nombre de la nueva imagen

  • IMAGE_PROJECT: Opcional: el proyecto que contiene la imagen de origen.

    Usa este parámetro para copiar una imagen de otro proyecto.

  • SOURCE_IMAGE: la imagen en la que se basará la nueva imagen

  • LOCATION: opcional: una región o multirregión en la que almacenar la imagen

    Por ejemplo, especifica us para almacenar la imagen en la multirregión us o us-central1 para almacenarla en la región us-central1. Si no seleccionas ninguna, Compute Engine almacenará la imagen en la multirregión más cercana a la ubicación de origen de la imagen.

  • FEATURES: etiquetas del SO invitado para habilitar funciones en las VMs que crees a partir de imágenes

    Para añadir varios valores, sepáralos con comas. Se debe configurar como uno o varios de los siguientes valores:

    • VIRTIO_SCSI_MULTIQUEUE. Úsala en dispositivos SSD locales como alternativa a NVMe. Para obtener más información sobre las imágenes que admiten SCSI, consulta Elegir una interfaz.

      En el caso de las imágenes de Linux, puedes habilitar SCSI de varias colas en dispositivos SSD locales en imágenes con versiones del kernel 3.17 o posteriores. En las imágenes de Windows, puedes habilitar SCSI de varias colas en dispositivos SSD locales en imágenes con el controlador de Windows de Compute Engine versión 1.2.

    • WINDOWS. Etiqueta las imágenes de arranque personalizadas de Windows Server como imágenes de Windows.
    • MULTI_IP_SUBNET. Configurar interfaces con una máscara de red distinta de /32. Para obtener más información sobre las interfaces de red múltiples y cómo funcionan, consulta el artículo Descripción general y ejemplos de interfaces de red múltiples.
    • UEFI_COMPATIBLE. Arranca con firmware UEFI y las siguientes funciones de VM blindada:
    • GVNIC. Admite anchos de banda de red más altos, de hasta entre 50 y 100 Gbps. Para obtener más información, consulta Usar NIC virtual de Google.
    • IDPF. Admite interfaces de red de función de ruta de datos de infraestructura de Intel (IDPF).
    • SEV_CAPABLE o SEV_SNP_CAPABLE. Usa estas etiquetas si quieres usar tu imagen en una instancia de VM confidencial con compatibilidad con AMD Secure Encrypted Virtualization (SEV) o AMD Secure Encrypted Virtualization-Secure Nested Paging (SEV-SNP). Para comprobar si tu kernel es compatible con AMD SEV o AMD SEV-SNP, consulta los detalles del kernel de Linux.
    • SEV_LIVE_MIGRATABLE_V2. Usa esta etiqueta si quieres usar tu imagen en una instancia de Confidential VM que admita la migración activa en AMD SEV. Para comprobar si tu kernel admite la migración en tiempo real, consulta los detalles del kernel de Linux.
    • TDX_CAPABLE. Usa esta etiqueta si quieres usar tu imagen en una instancia de VM confidencial con compatibilidad con las extensiones de dominio de confianza (TDX) de Intel. Para comprobar si tu kernel es compatible con Intel TDX, consulta Detalles del kernel de Linux.

Evitar la información sensible en las variables UEFI

Las variables de la interfaz de firmware extensible unificada (UEFI) son variables de pares clave-valor que usa el firmware de la UEFI durante el tiempo de arranque para iniciar el sistema operativo de una VM. A diferencia de las máquinas físicas, en las que las variables se almacenan en un chip de hardware, Compute Engine virtualiza el almacenamiento de estas variables. Por lo tanto, en muchos sistemas operativos, todas las aplicaciones y los usuarios pueden acceder a estas variables y a esta información.

Por este motivo, Google recomienda encarecidamente que no escriba ni almacene información sensible o personal identificable, como contraseñas o claves privadas, en variables UEFI.

Consideraciones sobre las imágenes de Arm

Google ofrece las series de máquinas A4X, C4A y Tau T2A que se ejecutan en plataformas de CPU Arm. Puedes iniciar una VM con una de estas series de máquinas y, a continuación, usar esa VM de origen para crear una imagen de Arm. El proceso para crear una imagen de Arm personalizada es idéntico al de crear una imagen x86.

Para ayudar a los usuarios a diferenciar entre imágenes Arm e x86, las imágenes Arm tendrán el campo architecture definido como ARM64. Los valores posibles de este campo son:

  • ARCHITECTURE_UNSPECIFIED
  • X86_64
  • ARM64

Los usuarios de imágenes pueden filtrar por este campo para encontrar imágenes basadas en x86 o Arm.

Siguientes pasos