Crear una instancia en una subred específica


De forma predeterminada, cada instancia tiene una única interfaz de red que determina la red de VPC que usa la instancia. Puedes crear una instancia con varias interfaces de red, pero cada interfaz debe conectarse a una red de VPC diferente. Cada red debe tener al menos una subred, que define el intervalo de direcciones IPv4 o IPv6 que se pueden asignar a la instancia.

Para obtener más información, consulta las siguientes secciones:

De forma predeterminada, Google Cloud crea una red de VPC de modo automático llamada default para cada proyecto. Para usar otra red o una subred que hayas creado manualmente en una red de VPC en modo automático o personalizado, debes especificar la subred al crear la instancia y configurar la interfaz de red.

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 una subred específica, 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 una subred específica. Para ver los permisos exactos que se necesitan, despliega la sección Permisos necesarios:

Permisos obligatorios

Para crear una instancia con una subred específica, se necesitan los siguientes permisos:

  • compute.instances.create del proyecto
  • Para especificar una subred para tu instancia, haz lo siguiente: compute.subnetworks.use en el proyecto o en la subred elegida
  • Para asignar una dirección IP externa a la instancia cuando se usa una red de VPC, haz lo siguiente: compute.subnetworks.useExternalIp en el proyecto o en la subred elegida

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

Requisitos

Cuando crees una instancia en una subred, ten en cuenta estas reglas:

  • Si no especificas una red o una subred, Compute Engine usará la red VPC predeterminada y la subred automática que se encuentre en la misma región que la instancia.
  • Si no especificas ninguna red, Compute Engine inferirá la red a partir de la subred especificada.
  • Si especificas una red, también debes especificar una subred que pertenezca a la misma red. De lo contrario, no se podrá crear la instancia.

Debes crear la subred que quieras usar antes de crear la instancia. Para obtener más información, consulta Crear y gestionar redes de VPC.

Crear una instancia en una subred específica

Para crear una instancia en una subred específica, 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, haga clic en Redes. En el panel Redes que aparece, haz lo siguiente:

    1. Para permitir el tráfico HTTP o HTTPS a la instancia, ve a la sección Cortafuegos y 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.

    2. Para especificar los detalles de la interfaz de red, ve a la sección Interfaces de red y haz clic en Añadir una interfaz de red.

      En la sección Nueva interfaz de red que aparece, haz lo siguiente:

      1. En el campo Red, selecciona la red de VPC que contiene la subred que has creado.
      2. En la lista Subred, selecciona la subred que quieres que use la instancia.
      3. En el campo Tipo de pila de IP, selecciona el tipo de pila de IP de la interfaz de red.
      4. Para confirmar los detalles de la interfaz de red, haz clic en Hecho.
  4. Opcional: Especifica otras opciones de configuración. Para obtener más información, consulta Opciones de configuración durante la creación de instancias.

  5. 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. Con la CLI de Google Cloud, sigue las mismas instrucciones para crear una instancia a partir de una imagen pública o una instantánea, e incluye las marcas de redes que se muestran en esta sección cuando ejecutes el comando gcloud compute instances create:

    gcloud compute instances create INSTANCE_NAME \
        --zone=ZONE \
        --machine-type=MACHINE_TYPE \
        --create-disk=boot=yes,image=projects/IMAGE_PROJECT/global/images/IMAGE,size=SIZE \
        --network=NETWORK_NAME \
        --subnet=SUBNET_NAME \
        --stack-type=STACK_TYPE \
        --private-network-ip=INTERNAL_IPV4_ADDRESS \
        --address=EXTERNAL_IPV4_ADDRESS \
        --nic-type=GVNIC
    

    Haz los cambios siguientes:

    • INSTANCE_NAME: el nombre de la instancia de computación
    • ZONE: la zona en la que se crea la instancia, como europe-west1-b. La región de la instancia se deduce de la zona.
    • MACHINE_TYPE: opcional, el tipo de máquina que se va a usar en la instancia.
    • IMAGE_PROJECT: opcional: el proyecto de imagen que contiene la imagen
    • IMAGE: Opcional: especifica una de las siguientes opciones:
      • Una versión específica de la imagen del SO, por ejemplo, rocky-linux-9-optimized-gcp-v20240717.
      • Una familia de imágenes, que debe tener el formato family/IMAGE_FAMILY. De este modo, se crea la instancia a partir de la imagen de SO más reciente que no esté obsoleta. Por ejemplo, si especificas family/rocky-linux-9-optimized-gcp, Compute Engine creará una instancia con la versión más reciente de la imagen del SO de la familia de imágenesGoogle Cloud optimizada para Rocky Linux 9. Para obtener más información sobre cómo usar familias de imágenes, consulte las prácticas recomendadas para familias de imágenes.
    • SIZE: opcional, tamaño del nuevo disco. El valor debe ser un número entero. La unidad de medida predeterminada es GiB.
    • NETWORK_NAME: nombre de la red (opcional).
    • SUBNET_NAME: nombre de la subred que se va a usar con la instancia.

      Para ver una lista de subredes de la red, usa el comando gcloud compute networks subnets list.

    • STACK_TYPE: opcional: el tipo de pila de la interfaz de red. STACK_TYPE debe ser uno de los siguientes valores: IPV4_ONLY, IPV4_IPV6 o IPV6_ONLY (Vista previa). El valor predeterminado es IPV4_ONLY.

    • INTERNAL_IPV4_ADDRESS: Opcional: la dirección IPv4 interna que quieres que use la instancia de proceso en la subred de destino. Omite esta marca si no necesitas una dirección IP específica.

      Para especificar una dirección IPv6 interna, usa la marca --internal-ipv6-address.

    • EXTERNAL_IPV4_ADDRESS: opcional: la dirección IPv4 externa estática que se va a usar con la interfaz de red. Debes haber reservado una dirección IPv4 externa previamente. Elige una de estas opciones:

      • Especifica una dirección IPv4 válida de la subred.
      • Usa la marca --network-interface=no-address si no quieres que la interfaz de red tenga una dirección IP externa.
      • Especifica address='' si quieres que la interfaz reciba una dirección IP externa efímera.

      Para especificar una dirección IPv6 externa, usa la marca --external-ipv6-address.

  3. Terraform

    Para crear una instancia en una subred específica, puedes usar el recurso google_compute_instance.

    
    # Create a VM in a custom VPC network and subnet
    
    resource "google_compute_instance" "custom_subnet" {
      name         = "my-vm-instance"
      tags         = ["allow-ssh"]
      zone         = "europe-west1-b"
      machine_type = "e2-small"
      network_interface {
        network    = google_compute_network.custom.id
        subnetwork = google_compute_subnetwork.custom.id
      }
      boot_disk {
        initialize_params {
          image = "debian-cloud/debian-12"
        }
      }
    }

    Para saber cómo aplicar o quitar una configuración de Terraform, consulta Comandos básicos de 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"
    )
    
    // createInstanceWithSubnet creates a new VM instance with Debian 10 operating system in specified network and subnetwork.
    func createInstanceWithSubnet(w io.Writer, projectID, zone, instanceName, networkLink, subnetworkLink string) error {
    	// projectID := "your_project_id"
    	// zone := "europe-central2-b"
    	// instanceName := "your_instance_name"
    	// networkLink := "global/networks/default"
    	// subnetworkLink := "regions/region/subnetworks/subnetwork_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()),
    				},
    			},
    			MachineType: proto.String(fmt.Sprintf("zones/%s/machineTypes/n1-standard-1", zone)),
    			NetworkInterfaces: []*computepb.NetworkInterface{
    				{
    					Name:       proto.String(networkLink),
    					Subnetwork: proto.String(subnetworkLink),
    				},
    			},
    		},
    	}
    
    	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;
      }
    
    
      /**
       * 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);
        }
      }

    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 networkLink = 'global/networks/default';
    // const subnetworkLink = 'regions/europe-central2/subnetworks/default';
    
    const compute = require('@google-cloud/compute');
    
    // Creates a new VM instance with Debian 10 operating system in specified network and subnetwork.
    async function createInstanceWithSubnet() {
      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',
            },
          ],
          machineType: `zones/${zone}/machineTypes/n1-standard-1`,
          networkInterfaces: [
            {
              name: networkLink,
              subnetwork: subnetworkLink,
            },
          ],
        },
      });
      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.');
    }
    
    createInstanceWithSubnet();

    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 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_subnet(
        project_id: str, zone: str, instance_name: str, network_link: str, subnet_link: str
    ) -> compute_v1.Instance:
        """
        Create a new VM instance with Debian 10 operating system in specified network and subnetwork.
    
        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.
            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}"
    
        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, 10, True, newest_debian.self_link)]
        instance = create_instance(
            project_id,
            zone,
            instance_name,
            disks,
            network_link=network_link,
            subnetwork_link=subnet_link,
        )
        return instance
    
    

    REST

    Sigue las REST instrucciones para crear una instancia a partir de una imagen pública o una captura, pero especifica el campo subnet en el cuerpo de la solicitud.

    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
          }
       ],
       
       
       "networkInterfaces":[
          {
             "network":"global/networks/NETWORK_NAME",
             "subnetwork":"regions/REGION/subnetworks/SUBNET_NAME",
             "stackType":"STACK_TYPE"
          }
       ],
       
      
       "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.

    • NETWORK_NAME: opcional: la red de VPC que quieras usar en la VM. Puedes especificar default para usar tu red predeterminada.
    • REGION: región en la que se encuentra la subred especificada. Debe ser la misma región que la VM.
    • SUBNET_NAME: nombre de la subred que se va a usar
    • STACK_TYPE: opcional: el tipo de pila de la interfaz de red. Puedes especificar IPV4_ONLY, IPV4_IPV6 o IPV6_ONLY. El valor predeterminado es IPV4_ONLY.
    • 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.

Siguientes pasos