Crear una instancia con discos no de arranque adicionales

Cuando creas una instancia de computación, puedes crear y adjuntar discos no de arranque adicionales a la instancia al mismo tiempo. También puedes elegir discos que ya tengas para conectarlos como discos que no persistan en el arranque.

Si quieres crear un disco en modo de multiescritura, no puedes hacerlo al mismo tiempo que creas la instancia. Primero debes crear el disco y, después, puedes acoplarlo a la instancia.

Antes de empezar

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

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

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

Roles obligatorios

Para obtener los permisos que necesitas para crear una instancia con discos no de arranque añadidos, pide a tu administrador que te conceda el rol de gestión de identidades y accesos Administrador de instancias de Compute (v. 1) (roles/compute.instanceAdmin.v1) en el proyecto. Para obtener más información sobre cómo conceder roles, consulta el artículo Gestionar el acceso a proyectos, carpetas y organizaciones.

Este rol predefinido contiene los permisos necesarios para crear una instancia con discos que no son de arranque. Para ver los permisos exactos que se necesitan, despliega la sección Permisos necesarios:

Permisos obligatorios

Para crear una instancia con discos no de arranque añadidos, se necesitan los siguientes permisos:

  • compute.instances.create del proyecto
  • Para crear un disco para la instancia, sigue estos pasos: compute.disks.create en el proyecto

También puedes obtener estos permisos con roles personalizados u otros roles predefinidos.

Crear una instancia con discos no de arranque adicionales

Para crear una instancia que tenga discos no de arranque adicionales creados y conectados, sigue estos pasos:

Consola

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

    Ir a Crear una instancia

    Si se te solicita, selecciona tu proyecto y haz clic en Continuar.

    Aparecerá la página Crear una instancia y se mostrará el panel Configuración de la máquina.

  2. En el panel Configuración de la máquina, haz lo siguiente:

    1. En el campo Nombre, especifica un nombre para la instancia. Para obtener más información, consulta el artículo Convenciones para asignar nombres de recursos.

    2. Opcional: En el campo Zona, selecciona una zona para esta instancia.

      La selección predeterminada es Cualquiera. Si no cambias esta selección predeterminada, Google elegirá automáticamente una zona en función del tipo de máquina y la disponibilidad.

    3. Selecciona la familia de máquinas de tu instancia. La consola Google Cloud muestra las series de máquinas disponibles para la familia de máquinas que hayas seleccionado. Estas son las opciones de familia de máquinas disponibles:

      • Uso general
      • Optimizada para la computación
      • Con memoria optimizada
      • Almacenamiento optimizado
      • GPUs

    4. En la columna Serie, selecciona la serie de máquinas de tu instancia.

      Si has seleccionado GPUs como familia de máquinas en el paso anterior, selecciona el tipo de GPU que quieras. La serie de máquinas se selecciona automáticamente para el tipo de GPU seleccionado.

    5. En la sección Tipo de máquina, selecciona el tipo de máquina de tu instancia.

  3. En el menú de navegación, haz clic en SO y almacenamiento. En el panel Sistema operativo y almacenamiento que aparece, sigue estos pasos.

    Para obtener más información sobre los parámetros que puedes configurar al añadir discos nuevos, consulta Acerca de los discos persistentes y Acerca de Google Cloud Hyperdisk.

    1. Para configurar el disco de arranque, haz clic en Cambiar. Aparece el panel Disco de arranque y se muestra la pestaña Imágenes públicas.

    2. Configure la fuente de datos del disco de arranque de una de las siguientes formas:

      • Para elegir una imagen pública como fuente de datos de tu disco de arranque, en la pestaña Imágenes públicas, especifica lo siguiente:

        1. En la lista Sistema operativo, selecciona el tipo de SO.
        2. En la lista Versión, selecciona la versión del SO.
        3. En la lista Tipo de disco de arranque, selecciona el tipo de disco de arranque.
        4. En el campo Tamaño (GB), especifica el tamaño del disco de arranque.

      • Para elegir una imagen personalizada como fuente de datos de tu disco de arranque, haz clic en Imágenes personalizadas y, en la pestaña Imágenes personalizadas que aparece, especifica lo siguiente:

        1. Para seleccionar el proyecto de imagen, haz clic en Cambiar y, a continuación, selecciona el proyecto que contiene la imagen.
        2. En la lista Imagen, selecciona la imagen que quieras importar.
        3. En la lista Tipo de disco de arranque, selecciona el tipo de disco de arranque.
        4. En el campo Tamaño (GB), especifica el tamaño del disco de arranque.

      • Para elegir una instantánea estándar como fuente de datos de tu disco de arranque, haz clic en Instantáneas y, en la pestaña Instantáneas que aparece, especifica lo siguiente:

        1. En la lista Snapshot, selecciona la instantánea.
        2. En la lista Tipo de disco de arranque, selecciona el tipo de disco de arranque.
        3. En el campo Tamaño (GB), especifica el tamaño del disco de arranque.

      • Para elegir una instantánea de archivo como fuente de datos de tu disco de arranque, haz clic en Instantáneas de archivo y, a continuación, en la pestaña Instantáneas de archivo que aparece, especifica lo siguiente:

        1. En la lista Instantánea de archivo, selecciona la instantánea de archivo.
        2. En la lista Tipo de disco de arranque, selecciona el tipo de disco de arranque.
        3. En el campo Tamaño (GB), especifica el tamaño del disco de arranque.

      • Para elegir un disco ya disponible como disco de arranque, haz clic en Discos disponibles. A continuación, en la pestaña Discos existentes que aparece, selecciona un disco persistente regional o un volumen de hiperdisco balanceado de alta disponibilidad en la lista Disco.

    3. Opcional: Para ver las opciones de configuración avanzada, despliega la sección Mostrar configuraciones avanzadas.

    4. Para confirmar las opciones del disco de arranque y volver al panel Sistema operativo y almacenamiento, haz clic en Seleccionar.

    5. Para crear un disco que no sea de arranque y adjuntarlo a tu instancia, en la sección Almacenamiento adicional y copias de seguridad de VMs, haz clic en Añadir disco.

      En el panel Añadir disco que aparece, haz lo siguiente:

      1. En el campo Name (Nombre), especifica un nombre para el disco que no es de arranque.
      2. En la lista Tipo de fuente del disco, selecciona el tipo de fuente del disco que no es de arranque.
      3. En la lista Tipo de disco, selecciona un tipo para el disco que no es de arranque.
      4. En el campo Tamaño, especifica el tamaño del disco que no es de arranque.
      5. En la sección Ajustes de archivos adjuntos, haga lo siguiente:
      6. En el campo Modo, selecciona el modo de adjunto de disco.
      7. En el campo Regla de eliminación, selecciona una opción para especificar qué ocurre con el disco cuando se elimina la instancia.

      Repite este paso con cada disco que no sea de arranque que quieras crear y adjuntar a tu instancia.

  4. En el menú de navegación, haga clic en Protección de datos. En el panel Protección de datos que aparece, especifique cómo quiere crear copias de seguridad y replicar los datos de su instancia. Para ello, siga estos pasos:

    1. Para especificar cómo quieres crear copias de seguridad de los datos, selecciona una opción en Crear copia de seguridad de los datos.

    2. Para especificar cómo quieres replicar los datos, haz lo siguiente:

      1. Si quieres que los nuevos discos de la instancia se repliquen de forma síncrona en una segunda zona mediante tipos de discos regionales, marca la casilla Discos regionales.
      1. Si quieres que los discos de la instancia se repliquen en una segunda región mediante la réplica asíncrona de Persistent Disk, selecciona la casilla Réplica asíncrona.

    3. Si solo quieres usar las opciones de protección de datos especificadas en discos que no sean de arranque, selecciona la casilla Excluir discos de arranque.

  5. En el menú de navegación, haga clic en Redes. En el panel Redes que aparece, haz lo siguiente:

    1. Ve a la sección Cortafuegos.

    2. Para permitir el tráfico HTTP o HTTPS a la instancia, selecciona Permitir el tráfico HTTP o Permitir el tráfico HTTPS.

      Compute Engine añade una etiqueta de red a tu instancia y crea la regla de cortafuegos de entrada correspondiente que permite todo el tráfico entrante en tcp:80 (HTTP) o tcp:443 (HTTPS). La etiqueta de red asocia la regla de cortafuegos con la instancia. Para obtener más información, consulta el resumen de las reglas de cortafuegos en la documentación de Cloud Next Generation Firewall.

  6. Opcional: Especifica otras opciones de configuración. Para obtener más información, consulta Opciones de configuración durante la creación de instancias.

  7. Para crear e iniciar la instancia, haz clic en Crear.

gcloud

  1. In the Google Cloud console, activate Cloud Shell.

    Activate Cloud Shell

    At the bottom of the Google Cloud console, a Cloud Shell session starts and displays a command-line prompt. Cloud Shell is a shell environment with the Google Cloud CLI already installed and with values already set for your current project. It can take a few seconds for the session to initialize.

  2. Ejecuta el comando gcloud compute instances create para crear una instancia con discos adicionales que no sean de arranque.

    Puedes añadir hasta 127 discos que no sean de arranque mientras creas tu instancia. Especifica la marca --create-disk para cada disco que no sea de arranque que crees.

    Para crear discos que no sean de arranque a partir de una imagen pública o de stock, especifica las propiedades image o image-family y image-project con la marca --create-disk. Para crear un disco en blanco, no incluya estas propiedades.

    También puede incluir propiedades de:

    • Tamaño del disco: usa la propiedad --size.
    • Tipo de disco: usa la propiedad --type.
    • Discos regionales: incluye la propiedad replica-zones.
    gcloud compute instances create INSTANCE_NAME \
    --zone=ZONE \
    --image-project=IMAGE_PROJECT \
    IMAGE_FLAG \
    --create-disk DISK_IMAGE,image-project=DISK_IMAGE_PROJECT,size=SIZE_GB,type=DISK_TYPE \
    --create-disk device-name=DISK_NAME,replica-zones=^:^ZONE:REMOTE-ZONE,boot=false

    Haz los cambios siguientes:

    • INSTANCE_NAME: nombre de la nueva instancia
    • ZONE: zona en la que se creará la instancia
    • IMAGE_PROJECT: proyecto que contiene la imagen

    • IMAGE_FLAG: especifica una de las siguientes opciones:

      • Usa la marca --image IMAGE_NAME para especificar una versión concreta de una imagen pública o personalizada. Por ejemplo, --image debian-12-bookworm-v20241112.

      • Usa la marca --image-family IMAGE_FAMILY_NAME para especificar una familia de imágenes. De esta forma, se crea la instancia que usa la imagen de SO más reciente y no obsoleta de la familia de imágenes. Por ejemplo, si especificas --image-family debian-12, Compute Engine usará la versión más reciente de la imagen del SO de la familia de imágenes de Debian 12 al crear la instancia.

    • En el caso de los discos adicionales, sustituye lo siguiente:

      • DISK_IMAGE: especifica una de las siguientes opciones:
        • image=DISK_IMAGE_NAME: nombre de la imagen que quieras usar al crear un disco no de arranque
        • image-family=DISK_IMAGE_FAMILY>: una imagen de la familia que se usará al crear un disco que no sea de arranque
      • DISK_IMAGE_PROJECT: un proyecto de imagen al que pertenece la imagen de disco
      • SIZE_GB: tamaño del disco que no es de arranque (opcional).

      • DISK_TYPE: opcional: URL completa o parcial del tipo de disco.

        Por ejemplo, https://www.googleapis.com/compute/v1/projects/PROJECT_ID/zones/ZONE/diskTypes/hyperdisk-balanced. Para ver los tipos de disco disponibles en una o varias zonas, usa el comando gcloud compute disk-types list --zones=ZONE_LIST. Sustituye ZONE_LIST por una lista de zonas separadas por comas.

      • DISK_NAME: opcional: el nombre del disco que se muestra al sistema operativo invitado después de crear la instancia.

      • REMOTE_ZONE: la zona en la que se debe replicar el disco

      En el caso de los discos en blanco, no especifiques los parámetros image, image-project ni image-family.

      En el caso de los discos zonales, no especifiques la propiedad replica-zones del disco.

    3. Terraform

    Para generar el código de Terraform, puedes usar el componente Código equivalente de la Google Cloud consola.
    1. En la consola de Google Cloud , ve a la página Instancias de VM.

      Ir a Instancias de VM

    2. Haz clic en Crear instancia.
    3. Especifica los parámetros que quieras.
    4. En la parte superior o inferior de la página, haz clic en Código equivalente y, a continuación, en la pestaña Terraform para ver el código de Terraform.

    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"
	"google.golang.org/protobuf/proto"
)

// createWithAdditionalDisk create a new VM instance with Debian 10 operating system and a 11 GB additional empty disk.
func createWithAdditionalDisk(w io.Writer, projectID, zone, instanceName string) error {
	// projectID := "your_project_id"
	// zone := "europe-central2-b"
	// instanceName := "your_instance_name"

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

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

	// List of public operating system (OS) images: https://cloud.google.com/compute/docs/images/os-details.
	newestDebianReq := &computepb.GetFromFamilyImageRequest{
		Project: "debian-cloud",
		Family:  "debian-12",
	}
	newestDebian, err := imagesClient.GetFromFamily(ctx, newestDebianReq)
	if err != nil {
		return fmt.Errorf("unable to get image from family: %w", err)
	}

	req := &computepb.InsertInstanceRequest{
		Project: projectID,
		Zone:    zone,
		InstanceResource: &computepb.Instance{
			Name: proto.String(instanceName),
			Disks: []*computepb.AttachedDisk{
				{
					InitializeParams: &computepb.AttachedDiskInitializeParams{
						DiskSizeGb:  proto.Int64(10),
						SourceImage: newestDebian.SelfLink,
						DiskType:    proto.String(fmt.Sprintf("zones/%s/diskTypes/pd-standard", zone)),
					},
					AutoDelete: proto.Bool(true),
					Boot:       proto.Bool(true),
					Type:       proto.String(computepb.AttachedDisk_PERSISTENT.String()),
				},
				{
					InitializeParams: &computepb.AttachedDiskInitializeParams{
						DiskSizeGb: proto.Int64(11),
						DiskType:   proto.String(fmt.Sprintf("zones/%s/diskTypes/pd-standard", zone)),
					},
					AutoDelete: proto.Bool(true),
					Boot:       proto.Bool(false),
					Type:       proto.String(computepb.AttachedDisk_PERSISTENT.String()),
				},
			},
			MachineType: proto.String(fmt.Sprintf("zones/%s/machineTypes/n1-standard-1", zone)),
			NetworkInterfaces: []*computepb.NetworkInterface{
				{
					Name: proto.String("global/networks/default"),
				},
			},
		},
	}

	op, err := instancesClient.Insert(ctx, req)
	if err != nil {
		return fmt.Errorf("unable to create instance: %w", err)
	}

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

	fmt.Fprintf(w, "Instance created\n")

	return nil
}

    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.api.gax.longrunning.OperationFuture;
import com.google.cloud.compute.v1.AttachedDisk;
import com.google.cloud.compute.v1.AttachedDisk.Type;
import com.google.cloud.compute.v1.AttachedDiskInitializeParams;
import com.google.cloud.compute.v1.Image;
import com.google.cloud.compute.v1.ImagesClient;
import com.google.cloud.compute.v1.InsertInstanceRequest;
import com.google.cloud.compute.v1.Instance;
import com.google.cloud.compute.v1.InstancesClient;
import com.google.cloud.compute.v1.NetworkInterface;
import com.google.cloud.compute.v1.Operation;
import java.io.IOException;
import java.util.Vector;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.TimeoutException;

public class CreateInstancesAdvanced {

  /**
   * Create an AttachedDisk object to be used in VM instance creation. Uses an image as the source
   * for the new disk.
   *
   * @param diskType the type of disk you want to create. This value uses the following format:
   * "zones/{zone}/diskTypes/(pd-standard|pd-ssd|pd-balanced|pd-extreme)". For example:
   * "zones/us-west3-b/diskTypes/pd-ssd"
   * @param diskSizeGb size of the new disk in gigabytes
   * @param boot boolean flag indicating whether this disk should be used as a boot disk of an
   * instance
   * @param sourceImage source image to use when creating this disk. You must have read access to
   * this disk. This can be one of the publicly available images or an image from one of your
   * projects. This value uses the following format:
   * "projects/{project_name}/global/images/{image_name}"
   * @return AttachedDisk object configured to be created using the specified image.
   */
  private static AttachedDisk diskFromImage(String diskType, int diskSizeGb, boolean boot,
      String sourceImage) {
    AttachedDisk disk =
        AttachedDisk.newBuilder()
            .setBoot(boot)
            // Remember to set auto_delete to True if you want the disk to be deleted when
            // you delete your VM instance.
            .setAutoDelete(true)
            .setType(Type.PERSISTENT.toString())
            .setInitializeParams(
                AttachedDiskInitializeParams.newBuilder()
                    .setSourceImage(sourceImage)
                    .setDiskSizeGb(diskSizeGb)
                    .setDiskType(diskType)
                    .build())
            .build();
    return disk;
  }


  /**
   * Create an AttachedDisk object to be used in VM instance creation. The created disk contains no
   * data and requires formatting before it can be used.
   *
   * @param diskType the type of disk you want to create. This value uses the following format:
   * "zones/{zone}/diskTypes/(pd-standard|pd-ssd|pd-balanced|pd-extreme)". For example:
   * "zones/us-west3-b/diskTypes/pd-ssd"
   * @param diskSizeGb size of the new disk in gigabytes
   * @return AttachedDisk object configured to be created as an empty disk.
   */
  private static AttachedDisk emptyDisk(String diskType, int diskSizeGb) {
    AttachedDisk disk =
        AttachedDisk.newBuilder()
            .setBoot(false)
            // Remember to set auto_delete to True if you want the disk to be deleted when
            // you delete your VM instance.
            .setAutoDelete(true)
            .setType(Type.PERSISTENT.toString())
            .setInitializeParams(
                AttachedDiskInitializeParams.newBuilder()
                    .setDiskSizeGb(diskSizeGb)
                    .setDiskType(diskType)
                    .build())
            .build();
    return disk;
  }

  /**
   * Send an instance creation request to the Compute Engine API and wait for it to complete.
   *
   * @param project project ID or project number of the Cloud project you want to use.
   * @param zone name of the zone to create the instance in. For example: "us-west3-b"
   * @param instanceName name of the new virtual machine (VM) instance.
   * @param disks a list of compute_v1.AttachedDisk objects describing the disks you want to attach
   * to your new instance.
   * @param machineType machine type of the VM being created. This value uses the following format:
   * "zones/{zone}/machineTypes/{type_name}".
   * For example: "zones/europe-west3-c/machineTypes/f1-micro"
   * @param network name of the network you want the new instance to use. For example:
   * "global/networks/default" represents the network named "default", which is created
   * automatically for each project.
   * @param subnetwork name of the subnetwork you want the new instance to use. This value uses the
   * following format: "regions/{region}/subnetworks/{subnetwork_name}"
   * @return Instance object.
   */
  private static Instance createWithDisks(String project, String zone, String instanceName,
      Vector<AttachedDisk> disks, String machineType, String network, String subnetwork)
      throws IOException, InterruptedException, ExecutionException, TimeoutException {
    try (InstancesClient instancesClient = InstancesClient.create()) {
      // Use the network interface provided in the networkName argument.
      NetworkInterface networkInterface;
      if (subnetwork != null) {
        networkInterface = NetworkInterface.newBuilder()
            .setName(network).setSubnetwork(subnetwork)
            .build();
      } else {
        networkInterface = NetworkInterface.newBuilder()
            .setName(network).build();
      }

      machineType = String.format("zones/%s/machineTypes/%s", zone, machineType);

      // Bind `instanceName`, `machineType`, `disk`, and `networkInterface` to an instance.
      Instance instanceResource =
          Instance.newBuilder()
              .setName(instanceName)
              .setMachineType(machineType)
              .addAllDisks(disks)
              .addNetworkInterfaces(networkInterface)
              .build();

      System.out.printf("Creating instance: %s at %s ", instanceName, zone);

      // Insert the instance in the specified project and zone.
      InsertInstanceRequest insertInstanceRequest = InsertInstanceRequest.newBuilder()
          .setProject(project)
          .setZone(zone)
          .setInstanceResource(instanceResource).build();

      OperationFuture<Operation, Operation> operation = instancesClient.insertAsync(
          insertInstanceRequest);

      // Wait for the operation to complete.
      Operation response = operation.get(3, TimeUnit.MINUTES);

      if (response.hasError()) {
        System.out.println("Instance creation failed ! ! " + response);
        return null;
      }
      System.out.println("Operation Status: " + response.getStatus());

      return instancesClient.get(project, zone, instanceName);
    }
  }

  /**
   * Create a new VM instance with Debian 11 operating system and a 11 GB additional empty disk.
   *
   * @param project project ID or project number of the Cloud project you want to use.
   * @param zone name of the zone to create the instance in. For example: "us-west3-b"
   * @param instanceName name of the new virtual machine (VM) instance.
   * @return Instance object.
   */
  public static Instance createWithAdditionalDisk(String project, String zone, String instanceName)
      throws IOException, InterruptedException, ExecutionException, TimeoutException {
    try (ImagesClient imagesClient = ImagesClient.create()) {
      // List of public operating system (OS) images: https://cloud.google.com/compute/docs/images/os-details
      Image image = imagesClient.getFromFamily("debian-cloud", "debian-11");
      String diskType = String.format("zones/%s/diskTypes/pd-standard", zone);
      Vector<AttachedDisk> disks = new Vector<>();
      disks.add(diskFromImage(diskType, 10, true, image.getSelfLink()));
      disks.add(emptyDisk(diskType, 11));
      return createWithDisks(project, zone, instanceName, disks, "n1-standard-1",
          "global/networks/default", null);
    }
  }

    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 compute = require('@google-cloud/compute');

// Create a new VM instance with Debian 10 operating system and a 11 GB additional empty disk.
async function createWithAdditionalDisk() {
  const instancesClient = new compute.InstancesClient();
  const imagesClient = new compute.ImagesClient();

  // List of public operating system (OS) images: https://cloud.google.com/compute/docs/images/os-details.
  const [newestDebian] = await imagesClient.getFromFamily({
    project: 'debian-cloud',
    family: 'debian-11',
  });

  const [response] = await instancesClient.insert({
    project: projectId,
    zone,
    instanceResource: {
      name: instanceName,
      disks: [
        {
          initializeParams: {
            diskSizeGb: '10',
            sourceImage: newestDebian.selfLink,
            diskType: `zones/${zone}/diskTypes/pd-standard`,
          },
          autoDelete: true,
          boot: true,
          type: 'PERSISTENT',
        },
        {
          initializeParams: {
            diskSizeGb: '11',
            diskType: `zones/${zone}/diskTypes/pd-standard`,
          },
          autoDelete: true,
          boot: false,
          type: 'PERSISTENT',
        },
      ],
      machineType: `zones/${zone}/machineTypes/n1-standard-1`,
      networkInterfaces: [
        {
          name: 'global/networks/default',
        },
      ],
    },
  });
  let operation = response.latestResponse;
  const operationsClient = new compute.ZoneOperationsClient();

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

  console.log('Instance created.');
}

createWithAdditionalDisk();

    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 re
import sys
from typing import Any
import warnings

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


def get_image_from_family(project: str, family: str) -> compute_v1.Image:
    """
    Retrieve the newest image that is part of a given family in a project.

    Args:
        project: project ID or project number of the Cloud project you want to get image from.
        family: name of the image family you want to get image from.

    Returns:
        An Image object.
    """
    image_client = compute_v1.ImagesClient()
    # List of public operating system (OS) images: https://cloud.google.com/compute/docs/images/os-details
    newest_image = image_client.get_from_family(project=project, family=family)
    return newest_image


def disk_from_image(
    disk_type: str,
    disk_size_gb: int,
    boot: bool,
    source_image: str,
    auto_delete: bool = True,
) -> compute_v1.AttachedDisk:
    """
    Create an AttachedDisk object to be used in VM instance creation. Uses an image as the
    source for the new disk.

    Args:
         disk_type: the type of disk you want to create. This value uses the following format:
            "zones/{zone}/diskTypes/(pd-standard|pd-ssd|pd-balanced|pd-extreme)".
            For example: "zones/us-west3-b/diskTypes/pd-ssd"
        disk_size_gb: size of the new disk in gigabytes
        boot: boolean flag indicating whether this disk should be used as a boot disk of an instance
        source_image: source image to use when creating this disk. You must have read access to this disk. This can be one
            of the publicly available images or an image from one of your projects.
            This value uses the following format: "projects/{project_name}/global/images/{image_name}"
        auto_delete: boolean flag indicating whether this disk should be deleted with the VM that uses it

    Returns:
        AttachedDisk object configured to be created using the specified image.
    """
    boot_disk = compute_v1.AttachedDisk()
    initialize_params = compute_v1.AttachedDiskInitializeParams()
    initialize_params.source_image = source_image
    initialize_params.disk_size_gb = disk_size_gb
    initialize_params.disk_type = disk_type
    boot_disk.initialize_params = initialize_params
    # Remember to set auto_delete to True if you want the disk to be deleted when you delete
    # your VM instance.
    boot_disk.auto_delete = auto_delete
    boot_disk.boot = boot
    return boot_disk


def empty_disk(
    disk_type: str, disk_size_gb: int, boot: bool = False, auto_delete: bool = True
) -> compute_v1.AttachedDisk():
    """
    Create an AttachedDisk object to be used in VM instance creation. The created disk contains
    no data and requires formatting before it can be used.

    Args:
         disk_type: the type of disk you want to create. This value uses the following format:
            "zones/{zone}/diskTypes/(pd-standard|pd-ssd|pd-balanced|pd-extreme)".
            For example: "zones/us-west3-b/diskTypes/pd-ssd"
        disk_size_gb: size of the new disk in gigabytes
        boot: boolean flag indicating whether this disk should be used as a boot disk of an instance
        auto_delete: boolean flag indicating whether this disk should be deleted with the VM that uses it

    Returns:
        AttachedDisk object configured to be created as an empty disk.
    """
    disk = compute_v1.AttachedDisk()
    initialize_params = compute_v1.AttachedDiskInitializeParams()
    initialize_params.disk_type = disk_type
    initialize_params.disk_size_gb = disk_size_gb
    disk.initialize_params = initialize_params
    # Remember to set auto_delete to True if you want the disk to be deleted when you delete
    # your VM instance.
    disk.auto_delete = auto_delete
    disk.boot = boot
    return disk


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 create_instance(
    project_id: str,
    zone: str,
    instance_name: str,
    disks: list[compute_v1.AttachedDisk],
    machine_type: str = "n1-standard-1",
    network_link: str = "global/networks/default",
    subnetwork_link: str = None,
    internal_ip: str = None,
    external_access: bool = False,
    external_ipv4: str = None,
    accelerators: list[compute_v1.AcceleratorConfig] = None,
    preemptible: bool = False,
    spot: bool = False,
    instance_termination_action: str = "STOP",
    custom_hostname: str = None,
    delete_protection: bool = False,
) -> compute_v1.Instance:
    """
    Send an instance creation request to the Compute Engine API and wait for it to complete.

    Args:
        project_id: project ID or project number of the Cloud project you want to use.
        zone: name of the zone to create the instance in. For example: "us-west3-b"
        instance_name: name of the new virtual machine (VM) instance.
        disks: a list of compute_v1.AttachedDisk objects describing the disks
            you want to attach to your new instance.
        machine_type: machine type of the VM being created. This value uses the
            following format: "zones/{zone}/machineTypes/{type_name}".
            For example: "zones/europe-west3-c/machineTypes/f1-micro"
        network_link: name of the network you want the new instance to use.
            For example: "global/networks/default" represents the network
            named "default", which is created automatically for each project.
        subnetwork_link: name of the subnetwork you want the new instance to use.
            This value uses the following format:
            "regions/{region}/subnetworks/{subnetwork_name}"
        internal_ip: internal IP address you want to assign to the new instance.
            By default, a free address from the pool of available internal IP addresses of
            used subnet will be used.
        external_access: boolean flag indicating if the instance should have an external IPv4
            address assigned.
        external_ipv4: external IPv4 address to be assigned to this instance. If you specify
            an external IP address, it must live in the same region as the zone of the instance.
            This setting requires `external_access` to be set to True to work.
        accelerators: a list of AcceleratorConfig objects describing the accelerators that will
            be attached to the new instance.
        preemptible: boolean value indicating if the new instance should be preemptible
            or not. Preemptible VMs have been deprecated and you should now use Spot VMs.
        spot: boolean value indicating if the new instance should be a Spot VM or not.
        instance_termination_action: What action should be taken once a Spot VM is terminated.
            Possible values: "STOP", "DELETE"
        custom_hostname: Custom hostname of the new VM instance.
            Custom hostnames must conform to RFC 1035 requirements for valid hostnames.
        delete_protection: boolean value indicating if the new virtual machine should be
            protected against deletion or not.
    Returns:
        Instance object.
    """
    instance_client = compute_v1.InstancesClient()

    # Use the network interface provided in the network_link argument.
    network_interface = compute_v1.NetworkInterface()
    network_interface.network = network_link
    if subnetwork_link:
        network_interface.subnetwork = subnetwork_link

    if internal_ip:
        network_interface.network_i_p = internal_ip

    if external_access:
        access = compute_v1.AccessConfig()
        access.type_ = compute_v1.AccessConfig.Type.ONE_TO_ONE_NAT.name
        access.name = "External NAT"
        access.network_tier = access.NetworkTier.PREMIUM.name
        if external_ipv4:
            access.nat_i_p = external_ipv4
        network_interface.access_configs = [access]

    # Collect information into the Instance object.
    instance = compute_v1.Instance()
    instance.network_interfaces = [network_interface]
    instance.name = instance_name
    instance.disks = disks
    if re.match(r"^zones/[a-z\d\-]+/machineTypes/[a-z\d\-]+$", machine_type):
        instance.machine_type = machine_type
    else:
        instance.machine_type = f"zones/{zone}/machineTypes/{machine_type}"

    instance.scheduling = compute_v1.Scheduling()
    if accelerators:
        instance.guest_accelerators = accelerators
        instance.scheduling.on_host_maintenance = (
            compute_v1.Scheduling.OnHostMaintenance.TERMINATE.name
        )

    if preemptible:
        # Set the preemptible setting
        warnings.warn(
            "Preemptible VMs are being replaced by Spot VMs.", DeprecationWarning
        )
        instance.scheduling = compute_v1.Scheduling()
        instance.scheduling.preemptible = True

    if spot:
        # Set the Spot VM setting
        instance.scheduling.provisioning_model = (
            compute_v1.Scheduling.ProvisioningModel.SPOT.name
        )
        instance.scheduling.instance_termination_action = instance_termination_action

    if custom_hostname is not None:
        # Set the custom hostname for the instance
        instance.hostname = custom_hostname

    if delete_protection:
        # Set the delete protection bit
        instance.deletion_protection = True

    # Prepare the request to insert an instance.
    request = compute_v1.InsertInstanceRequest()
    request.zone = zone
    request.project = project_id
    request.instance_resource = instance

    # Wait for the create operation to complete.
    print(f"Creating the {instance_name} instance in {zone}...")

    operation = instance_client.insert(request=request)

    wait_for_extended_operation(operation, "instance creation")

    print(f"Instance {instance_name} created.")
    return instance_client.get(project=project_id, zone=zone, instance=instance_name)


def create_with_additional_disk(
    project_id: str, zone: str, instance_name: str
) -> compute_v1.Instance:
    """
    Create a new VM instance with Debian 10 operating system on a 20 GB disk
    and a 25 GB additional empty disk.

    Args:
        project_id: project ID or project number of the Cloud project you want to use.
        zone: name of the zone to create the instance in. For example: "us-west3-b"
        instance_name: name of the new virtual machine (VM) instance.

    Returns:
        Instance object.
    """
    newest_debian = get_image_from_family(project="debian-cloud", family="debian-12")
    disk_type = f"zones/{zone}/diskTypes/pd-standard"
    disks = [
        disk_from_image(disk_type, 20, True, newest_debian.self_link),
        empty_disk(disk_type, 25),
    ]
    instance = create_instance(project_id, zone, instance_name, disks)
    return instance

    REST

    Puedes crear hasta 127 discos que no sean de arranque al crear una instancia mediante la propiedad initializeParams para cada disco adicional. Crea discos adicionales con una imagen pública o privada. Para añadir un disco en blanco, define la entrada initializeParams sin el valor sourceImage. Incluya la propiedad de disco replicaZones para crear discos regionales en lugar de discos de zona.

    POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/zones/ZONE/instances

{
   "machineType":"zones/MACHINE_TYPE_ZONE/machineTypes/MACHINE_TYPE",
   "name":"VM_NAME",
   
   "disks":[
      {
         "initializeParams":{
            "sourceImage":"projects/IMAGE_PROJECT/global/images/IMAGE"
         },
         "boot":true
      },
      {
         "initializeParams":{
            "diskSizeGb":"SIZE_GB",
            "sourceImage":"projects/DISK_IMAGE_PROJECT/global/images/DISK_IMAGE",
            "diskType":"DISK_TYPE"
         }
      },
      {
         "initializeParams":{
            "diskSizeGb":"SIZE_GB",
            "diskType":"DISK_TYPE"
         },
      },
      {
         "boot": false,
         "deviceName":"DISK_NAME",
         "initializeParams": {
            "diskType": "DISK_TYPE",
            "replicaZones": [
               "projects/PROJECT_ID/zones/ZONE",
               "projects/PROJECT_ID/zones/REMOTE_ZONE"
            ]
         }
      }
   ],
   
   
   "networkInterfaces":[
      {
         "network":"global/networks/NETWORK_NAME"
      }
   ],
   
  
   "shieldedInstanceConfig":{
      "enableSecureBoot":"ENABLE_SECURE_BOOT"
   }
}

    Haz los cambios siguientes:

    • PROJECT_ID: ID del proyecto en el que se creará la VM.
    • ZONE: zona en la que se creará la VM
    • MACHINE_TYPE_ZONE: zona que contiene el tipo de máquina que se va a usar en la nueva VM.
    • MACHINE_TYPE: tipo de máquina, predefinido o personalizado, para la nueva VM
    • VM_NAME: nombre de la nueva VM
    • IMAGE_PROJECT: proyecto que contiene la imagen
      Por ejemplo, si especificas debian-10 como familia de imágenes, especifica debian-cloud como proyecto de imagen.
    • IMAGE: especifica una de las siguientes opciones:

      • IMAGE: una versión específica de una imagen pública

        Por ejemplo: "sourceImage": "projects/debian-cloud/global/images/debian-10-buster-v20200309"

      • IMAGE_FAMILY: una familia de imágenes

        De esta forma, se crea la VM a partir de la imagen del SO más reciente que no esté obsoleta. Por ejemplo, si especificas "sourceImage": "projects/debian-cloud/global/images/family/debian-10", Compute Engine crea una VM a partir de la versión más reciente de la imagen del SO de la familia de imágenes Debian 10.

    • En el caso de los discos adicionales, sustituye lo siguiente:

      • SIZE_GB: tamaño del disco
      • DISK_IMAGE o
      • DISK_IMAGE_FAMILY: especifica una imagen de origen o una familia de imágenes para el disco que no es de inicio:
        • DISK_IMAGE: nombre de la imagen que quieras usar como disco no de arranque. Por ejemplo, "sourceImage": "projects/DISK_IMAGE_PROJECT/global/images/DISK_IMAGE".
        • DISK_IMAGE_FAMILY: una familia de imágenes que se usará como disco no de arranque. Por ejemplo, "sourceImage": "projects/DISK_IMAGE_PROJECT/global/images/family/DISK_IMAGE_FAMILY".
      • DISK_TYPE: URL completa o parcial del tipo de tipo de disco. Por ejemplo, https://www.googleapis.com/compute/v1/projects/PROJECT_ID/zones/ZONE/diskTypes/hyperdisk-balanced.
      • DISK_NAME: opcional. Nombre del disco que se muestra al sistema operativo invitado después de crear la VM.

      • REMOTE_ZONE: la zona en la que se replicará el disco regional.

      En el caso de los discos en blanco, no especifiques la propiedad sourceImage.

      En el caso de los discos zonales, no especifiques la propiedad replicaZones.

    • NETWORK_NAME: la red de VPC que quieres usar en la VM. Puedes especificar default para usar tu red predeterminada.

    • ENABLE_SECURE_BOOT: Opcional: Si has elegido una imagen que admite las funciones de VM blindada, Compute Engine habilita de forma predeterminada el módulo de plataforma segura virtual (vTPM) y la monitorización de la integridad. En Compute Engine, Arranque seguro no está habilitado de forma predeterminada.

      Si especificas true en enableSecureBoot, Compute Engine crea una VM con las tres funciones de VM blindada habilitadas. Una vez que Compute Engine inicie tu VM, para modificar las opciones de VM blindada, debes detenerla.

Formatea y monta los discos antes de usarlos.