Se usó la API de Cloud Translation para traducir esta página.

Crea y comienza una instancia de Compute Engine

En este documento, se explica cómo crear una instancia de máquina virtual (VM) o bare metal mediante una imagen de disco de arranque, una instantánea de disco de arranque o una imagen de contenedor. Algunas imágenes son compatibles con las funciones de VM protegida, que ofrecen funciones de seguridad como firmware compatible con UEFI, inicio seguro e inicio medido con protección de vTPM. En las VM protegidas el vTPM y la supervisión de integridad están habilitados de forma predeterminada.

Cuando creas tu instancia de procesamiento, puedes crear uno o más discos. También puedes agregar más discos a la VM después de crearla. Compute Engine inicia la instancia de VM automáticamente después de crearla. Para crear una instancia con un disco de arranque que se replica de forma síncrona en dos zonas, consulta Crea una VM nueva con un disco de arranque regional.

Cuando creas una instancia de procesamiento, también puedes agregar varias interfaces de red. Para mitigar la exposición de la instancia a amenazas en Internet, puedes omitir la dirección IP externa cuando agregues una interfaz de red a la instancia. En esos casos, solo se puede acceder a la instancia desde otras instancias de procesamiento en la misma red de VPC o desde una red vinculada, a menos que configures Cloud NAT.

Si creas una instancia de procesamiento por primera vez, consulta la Guía de inicio rápido para usar una VM de Linux o la Guía de inicio rápido para usar una VM de Windows Server.

Para obtener más información sobre las opciones de creación de instancias de Compute Engine más específicas o complicadas, consulta los siguientes recursos:

Si tienes una licencia existente, consulta Licencias adquiridas por el usuario.

Antes de comenzar

Cuando creas instancias de procesamiento a partir de imágenes o discos con Google Cloud CLI o REST, hay un límite de 20 instancias por segundo. Si necesitas crear una mayor cantidad de instancias por segundo, solicita un límite de cuota más alto para el recurso Imágenes.
Si aún no lo hiciste, configura la autenticación. La autenticación es el proceso mediante el cual se verifica tu identidad para acceder a los servicios y las API de Google Cloud. Para ejecutar código o muestras 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. Install the Google Cloud CLI, then initialize it by running the following command:
  gcloud init
  Note: If you installed the gcloud CLI previously, make sure you have the latest version by running gcloud components update.
2. Set a default region and zone.

Roles obligatorios

Para obtener los permisos que necesitas a fin de finalizar de forma automática, pídele al administrador que te otorgue el rol de IAM Administrador de instancias de Compute (v1) (roles/compute.instanceAdmin.v1) IAM en el proyecto. Para obtener más información sobre cómo otorgar roles, consulta Administra el acceso a proyectos, carpetas y organizaciones.

Este rol predefinido contiene los permisos necesarios para crear VM. Para ver los permisos exactos que son necesarios, expande la sección Permisos requeridos:

Permisos necesarios

Se requieren los siguientes permisos para crear VM:

compute.instances.create en el proyecto
Si deseas usar una imagen personalizada para crear la VM, sigue estos pasos: compute.images.useReadOnly en la imagen
Para usar una instantánea a fin de crear la VM, haz lo siguiente: compute.snapshots.useReadOnly en la instantánea
Si quieres usar una plantilla de instancias para crear la VM, sigue estos pasos: compute.instanceTemplates.useReadOnly en la plantilla de instancias
Para asignar una red heredada a la VM, ejecuta compute.networks.use en el proyecto.
Si deseas especificar una dirección IP estática para la VM: compute.addresses.use en el proyecto
Para asignar una dirección IP externa a la VM cuando se usa una red heredada, ejecuta compute.networks.useExternalIp en el proyecto
A fin de especificar una subred para tu VM: compute.subnetworks.use en el proyecto o en la subred elegida
Para asignar una dirección IP externa a la VM cuando se usa una red de VPC, compute.subnetworks.useExternalIp en el proyecto o en la subred elegida.
Para configurar los metadatos de la instancia de VM para la VM, compute.instances.setMetadata en el proyecto.
Para configurar etiquetas en la VM, haz lo siguiente: compute.instances.setTags en la VM
Para configurar etiquetas en la VM, haz lo siguiente: compute.instances.setLabels en la VM
A fin de configurar una cuenta de servicio para que la VM use: compute.instances.setServiceAccount en la VM
Crear un disco nuevo para la VM: compute.disks.create en el proyecto
Para conectar un disco existente en modo de solo lectura o de lectura y escritura, usa compute.disks.use en el disco.
Para conectar un disco existente en modo de solo lectura, haz lo siguiente: compute.disks.useReadOnly en el disco

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

Crea una instancia de VM a partir de una imagen

En esta sección se explica cómo crear una VM a partir de una imagen de SO pública o una imagen personalizada. Una VM contiene un bootloader, un sistema de archivos de inicio y una imagen de SO. Si vas a crear una VM de Arm, elige una imagen de SO que sea compatible con Arm.

Visualiza una lista de las imágenes públicas disponibles en Compute Engine

Antes de crear una VM mediante una imagen pública, revisa la lista de las imágenes públicas disponibles en Compute Engine.

Para obtener más información sobre las funciones disponibles con cada imagen pública, consulta Compatibilidad de funciones por sistema operativo.

Console

En la consola de Google Cloud, ve a la página Imágenes.

Ir a Imágenes

gcloud

Ejecuta el siguiente comando:
```
gcloud compute images list
```
Anota el nombre de las imágenes o familias de imágenes y el nombre del proyecto que la contiene.
(Opcional) Para determinar si la imagen admite funciones de VM protegida, ejecuta el siguiente comando:
```
gcloud compute images describe IMAGE_NAME \
    --project=IMAGE_PROJECT
```
Reemplaza lo siguiente:
- IMAGE_NAME: Nombre de la imagen cuya compatibilidad con funciones de VM protegida se quiere comprobar.
- IMAGE_PROJECT: Es el proyecto que contiene la imagen.
Si la imagen admite funciones de VM protegida, aparecerá la siguiente línea en el resultado: type: UEFI_COMPATIBLE.

C#

Antes de probar esta muestra, sigue las instrucciones de configuración de C# en la Guía de inicio rápido de Compute Engine: Usa las bibliotecas cliente. Si quieres obtener más información, consulta la documentación de referencia de la API de C# de Compute Engine.

Para autenticarte en Compute Engine, configura las credenciales predeterminadas de la aplicación. Si deseas obtener más información, consulta Configura la autenticación para un entorno de desarrollo local.


using Google.Cloud.Compute.V1;
using System;
using System.Threading.Tasks;

public class ListImagesAsyncSample
{
    public async Task ListImagesAsync(
        // TODO(developer): Set your own default values for these parameters or pass different values when calling this method.
        string projectId = "your-project-id")
    {
        // Initialize client that will be used to send requests. This client only needs to be created
        // once, and can be reused for multiple requests.
        ImagesClient client = await ImagesClient.CreateAsync();

        // Make the request to list all non-deprecated images in a project.
        ListImagesRequest request = new ListImagesRequest
        {
            Project = projectId,
            // Listing only non-deprecated images to reduce the size of the reply.
            Filter = "deprecated.state != DEPRECATED",
            // MaxResults indicates the maximum number of items that will be returned per page.
            MaxResults = 100
        };

        // Although the MaxResults parameter is specified in the request, the sequence returned
        // by the ListAsync() method hides the pagination mechanic. The library makes multiple
        // requests to the API for you, so you can simply iterate over all the images.
        await foreach (var image in client.ListAsync(request))
        {
            // The result is an Image collection.
            Console.WriteLine($"Image: {image.Name}");
        }
    }
}

Go

Antes de probar esta muestra, sigue las instrucciones de configuración de Go en la Guía de inicio rápido de Compute Engine: Usa las bibliotecas cliente. Si quieres obtener más información, consulta la documentación de referencia de la API de Go de Compute Engine.

import (
	"context"
	"fmt"
	"io"

	compute "cloud.google.com/go/compute/apiv1"
	computepb "cloud.google.com/go/compute/apiv1/computepb"
	"google.golang.org/api/iterator"
	"google.golang.org/protobuf/proto"
)

// printImagesList prints a list of all non-deprecated image names available in given project.
func printImagesList(w io.Writer, projectID string) error {
	// projectID := "your_project_id"
	ctx := context.Background()
	imagesClient, err := compute.NewImagesRESTClient(ctx)
	if err != nil {
		return fmt.Errorf("NewImagesRESTClient: %w", err)
	}
	defer imagesClient.Close()

	// Listing only non-deprecated images to reduce the size of the reply.
	req := &computepb.ListImagesRequest{
		Project:    projectID,
		MaxResults: proto.Uint32(3),
		Filter:     proto.String("deprecated.state != DEPRECATED"),
	}

	// Although the `MaxResults` parameter is specified in the request, the iterator returned
	// by the `list()` method hides the pagination mechanic. The library makes multiple
	// requests to the API for you, so you can simply iterate over all the images.
	it := imagesClient.List(ctx, req)
	for {
		image, err := it.Next()
		if err == iterator.Done {
			break
		}
		if err != nil {
			return err
		}
		fmt.Fprintf(w, "- %s\n", image.GetName())
	}
	return nil
}

Java

Antes de probar esta muestra, sigue las instrucciones de configuración de Java en la Guía de inicio rápido de Compute Engine: Usa las bibliotecas cliente. Si quieres obtener más información, consulta la documentación de referencia de la API de Java de Compute Engine.


import com.google.cloud.compute.v1.Image;
import com.google.cloud.compute.v1.ImagesClient;
import com.google.cloud.compute.v1.ImagesClient.ListPage;
import com.google.cloud.compute.v1.ListImagesRequest;
import java.io.IOException;
  // Prints a list of all non-deprecated image names available in given project.
  public static void listImages(String project) throws IOException {
    // 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 (ImagesClient imagesClient = ImagesClient.create()) {

      // Listing only non-deprecated images to reduce the size of the reply.
      ListImagesRequest imagesRequest = ListImagesRequest.newBuilder()
          .setProject(project)
          .setMaxResults(100)
          .setFilter("deprecated.state != DEPRECATED")
          .build();

      // Although the `setMaxResults` parameter is specified in the request, the iterable returned
      // by the `list()` method hides the pagination mechanic. The library makes multiple
      // requests to the API for you, so you can simply iterate over all the images.
      int imageCount = 0;
      for (Image image : imagesClient.list(imagesRequest).iterateAll()) {
        imageCount++;
        System.out.println(image.getName());
      }
      System.out.printf("Image count in %s is: %s", project, imageCount);
    }
  }

Node.js

Antes de probar esta muestra, sigue las instrucciones de configuración de Node.js en la Guía de inicio rápido de Compute Engine: Usa las bibliotecas cliente. Si quieres obtener más información, consulta la documentación de referencia de la API de Node.js de Compute Engine.

/**
 * TODO(developer): Uncomment and replace these variables before running the sample.
 */
// const projectId = 'YOUR_PROJECT_ID';

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

async function listImages() {
  const imagesClient = new compute.ImagesClient();

  // Listing only non-deprecated images to reduce the size of the reply.
  const images = imagesClient.listAsync({
    project: projectId,
    maxResults: 3,
    filter: 'deprecated.state != DEPRECATED',
  });

  // Although the `maxResults` parameter is specified in the request, the iterable returned
  // by the `listAsync()` method hides the pagination mechanic. The library makes multiple
  // requests to the API for you, so you can simply iterate over all the images.
  for await (const image of images) {
    console.log(` - ${image.name}`);
  }
}

listImages();

PHP

Antes de probar esta muestra, sigue las instrucciones de configuración de PHP en la Guía de inicio rápido de Compute Engine: Usa las bibliotecas cliente. Si quieres obtener más información, consulta la documentación de referencia de la API de PHP de Compute Engine.

use Google\Cloud\Compute\V1\Client\ImagesClient;
use Google\Cloud\Compute\V1\ListImagesRequest;

/**
 * Prints a list of all non-deprecated image names available in given project.
 *
 * @param string $projectId Project ID or project number of the Cloud project you want to list images from.
 *
 * @throws \Google\ApiCore\ApiException if the remote call fails.
 */
function list_all_images(string $projectId)
{
    $imagesClient = new ImagesClient();
    // Listing only non-deprecated images to reduce the size of the reply.
    $optionalArgs = ['maxResults' => 100, 'filter' => 'deprecated.state != DEPRECATED'];

    /**
     * Although the maxResults parameter is specified in the request, the iterateAllElements() method
     * hides the pagination mechanic. The library makes multiple requests to the API for you,
     * so you can simply iterate over all the images.
     */
    $request = (new ListImagesRequest())
        ->setProject($projectId)
        ->setMaxResults($optionalArgs['maxResults'])
        ->setFilter($optionalArgs['filter']);
    $pagedResponse = $imagesClient->list($request);
    print('=================== Flat list of images ===================' . PHP_EOL);
    foreach ($pagedResponse->iterateAllElements() as $element) {
        printf(' - %s' . PHP_EOL, $element->getName());
    }
}

Python

Antes de probar esta muestra, sigue las instrucciones de configuración de Python en la Guía de inicio rápido de Compute Engine: Usa las bibliotecas cliente. Si quieres obtener más información, consulta la documentación de referencia de la API de Python de Compute Engine.

import google.cloud.compute_v1 as compute_v1

def print_images_list(project: str) -> str:
    """
    Prints a list of all non-deprecated image names available in given project.

    Args:
        project: project ID or project number of the Cloud project you want to list images from.

    Returns:
        The output as a string.
    """
    images_client = compute_v1.ImagesClient()
    # Listing only non-deprecated images to reduce the size of the reply.
    images_list_request = compute_v1.ListImagesRequest(
        project=project, max_results=100, filter="deprecated.state != DEPRECATED"
    )
    output = []

    # Although the `max_results` parameter is specified in the request, the iterable returned
    # by the `list()` method hides the pagination mechanic. The library makes multiple
    # requests to the API for you, so you can simply iterate over all the images.
    for img in images_client.list(request=images_list_request):
        print(f" -  {img.name}")
        output.append(f" -  {img.name}")
    return "\n".join(output)

Ruby

Antes de probar esta muestra, sigue las instrucciones de configuración de Ruby en la Guía de inicio rápido de Compute Engine: Usa las bibliotecas cliente. Si quieres obtener más información, consulta la documentación de referencia de la API de Ruby de Compute Engine.


require "google/cloud/compute/v1"

# Prints a list of all non-deprecated image names available in given project.
#
# @param [String] project project ID or project number of the Cloud project you want to list images from.
def print_images_list project:
  client = ::Google::Cloud::Compute::V1::Images::Rest::Client.new

  # Make the request to list all non-deprecated images in a project.
  request = {
    project: project,
    # max_results indicates the maximum number of items that will be returned per page.
    max_results: 100,
    # Listing only non-deprecated images to reduce the size of the reply.
    filter: "deprecated.state != DEPRECATED"
  }

  # Although the `max_results` parameter is specified in the request, the iterable returned
  # by the `list` method hides the pagination mechanic. The library makes multiple
  # requests to the API for you, so you can simply iterate over all the images.
  client.list(request).each do |image|
    puts " - #{image.name}"
  end
end

REST

Ejecuta el siguiente comando:

GET https://compute.googleapis.com/compute/v1/projects/IMAGE_PROJECT/global/images/

Anota el nombre de las imágenes o familias de imágenes y el nombre del proyecto que la contiene.
(Opcional) Para determinar si la imagen admite funciones de VM protegida, ejecuta el siguiente comando:
```
GET https://compute.googleapis.com/compute/v1/projects/IMAGE_PROJECT/global/images/IMAGE_NAME
```
Reemplaza lo siguiente:
- IMAGE_PROJECT: Es el proyecto que contiene la imagen.
- IMAGE_NAME: Nombre de la imagen cuya compatibilidad con funciones de VM protegida se quiere comprobar.
Si la imagen admite funciones de VM protegida, aparecerá la siguiente línea en el resultado: type: UEFI_COMPATIBLE.

Crea una instancia de VM a partir de una imagen pública

Google, las comunidades de código abierto y los proveedores externos proporcionan y mantienen imágenes de SO públicas. Todos los proyectos de Google Cloud pueden crear VMs a partir de imágenes de SO públicas de forma predeterminada. Sin embargo, si tu proyecto de Google Cloud tiene una lista definida de imágenes confiables, solo puedes usar las imágenes de esa lista para crear una VM.

Si creas una imagen de VM protegida con SSD local, no puedes proteger los datos con la supervisión de integridad ni con el módulo de plataforma segura virtual (vTPM).

Console

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

Ir a Instancias de VM
Selecciona el proyecto y haz clic en Continuar.
Haz clic en Crear instancia.
Especifica un Nombre para la VM. Para obtener más información, consulta Convención de asignación de nombres de recursos.
Opcional: Cambia la Zona para esta VM. Si seleccionas Cualquiera, Google elige de forma automática una zona por ti según el tipo de máquina y la disponibilidad.
Selecciona una Configuración de máquina para la VM.
En la sección Disco de arranque, haz clic en Cambiar y, luego, haz lo siguiente:
1. En la pestaña Imágenes públicas, elige lo siguiente:
  - Sistema operativo
  - Versión del SO
  - Tipo de disco de arranque
  - Tamaño de disco de arranque
2. Opcional: Para ver las opciones de configuración avanzadas, haz clic en Mostrar configuración avanzada.
3. Para confirmar las opciones del disco de arranque, haz clic en Seleccionar.
Nota: A menos que elijas de forma explícita un disco de arranque diferente, si el nombre de la VM nueva coincide con el de un disco persistente que ya existe, este se agregará automáticamente a la VM nueva como disco de arranque.
En la sección Firewall, para permitir el tráfico HTTP o HTTPS a la VM, elige Permitir tráfico HTTP o Permitir tráfico HTTPS. Cuando seleccionas uno de estos, Compute Engine agrega una etiqueta de red a la VM, que asocia la regla de firewall con la VM. Luego, Compute Engine crea la regla de firewall de entrada correspondiente que permite todo el tráfico entrante en tcp:80 (HTTP) o tcp:443 (HTTPS).
Opcional: Puedes modificar la configuración de la VM protegida si elegiste una imagen de SO que admite estas funciones: Para modificar la configuración de las VM protegida, expande la sección Seguridad en la sección Opciones avanzadas y, luego, haz lo siguiente según sea necesario:
- Para activar el Inicio seguro, elige Activar el inicio seguro. El inicio seguro está inhabilitado de forma predeterminada.
- Para desactivar vTPM, desmarca la casilla de verificación Activar vTPM. vTPM está habilitado de forma predeterminada. Al inhabilitar el vTPM también se inhabilita la supervisión de integridad porque esta depende de los datos que se recopilan mediante el inicio medido.
- Para desactivar la supervisión de integridad, desmarca la casilla de verificación Activar la supervisión de integridad. La supervisión de la integridad está habilitada de forma predeterminada.
Para crear y, también, iniciar la VM, haz clic en Crear.

gcloud

Selecciona una imagen pública. Anota el nombre de las imágenes o familias de imágenes y el nombre del proyecto que la contiene.
Usa el comando gcloud compute instances create para crear una VM a partir de una familia de imágenes o de una versión específica de una imagen de SO.

Si especificas la marca opcional --shielded-secure-boot, Compute Engine crea una VM con las tres funciones de la VM protegida habilitadas:
Después de que Compute Engine inicie tu VM, debes detenerla para modificar las opciones de VM protegida.
```
gcloud compute instances create VM_NAME \
    --zone=ZONE \
    [--image=IMAGE | --image-family=IMAGE_FAMILY] \
    --image-project=IMAGE_PROJECT \
    --machine-type=MACHINE_TYPE
```
Reemplaza lo siguiente:
- VM_NAME: Nombre de la VM nueva
- ZONE: Es la zona en la que se creará la instancia.
- IMAGE o IMAGE_FAMILY: Especifica una de las siguientes opciones:
  - IMAGE: Es una versión específica de una imagen pública
    
    Por ejemplo, --image=debian-10-buster-v20200309.
  - IMAGE_FAMILY: Es una familia de imágenes.
    
    Esto crea la VM a partir de la imagen de SO no obsoleta más reciente. Por ejemplo, si especificas --image-family=debian-10, Compute Engine crea una VM a partir de la última versión de la imagen de SO en la familia de imágenes Debian 10.
- IMAGE_PROJECT: Proyecto que contiene la imagen
- MACHINE_TYPE: Tipo de máquina, predefinido o personalizado, de la VM nueva
  
  Para obtener una lista de los tipos de máquinas disponibles en una zona, usa el comando gcloud compute machine-types list con la marca --zones.
Verifica si Compute Engine creó la VM:
```
gcloud compute instances describe VM_NAME
```
Reemplaza VM_NAME por el nombre de la VM.

Terraform

Para crear una VM, puedes usar el recurso google_compute_instance.


# Create a VM instance from a public image
# in the `default` VPC network and subnet

resource "google_compute_instance" "default" {
  name         = "my-vm"
  machine_type = "n1-standard-1"
  zone         = "us-central1-a"

  boot_disk {
    initialize_params {
      image = "ubuntu-minimal-2210-kinetic-amd64-v20230126"
    }
  }

  network_interface {
    network = "default"
    access_config {}
  }
}

Si deseas obtener más información para aplicar o quitar una configuración de Terraform, consulta los comandos básicos de Terraform.

Para generar el código de Terraform, puedes usar el componente Código equivalente en la consola de Google Cloud.

En la consola de Google Cloud, ve a la página Instancias de VM.
Ir a Instancias de VM
Haz clic en Crear instancia.
Especifica los parámetros que desees.
En la parte superior o inferior de la página, haz clic en Código equivalente y, luego, en la pestaña Terraform para ver el código de Terraform.

C#


using Google.Cloud.Compute.V1;
using System.Threading.Tasks;

public class CreateInstanceAsyncSample
{
    public async Task CreateInstanceAsync(
        // TODO(developer): Set your own default values for these parameters or pass different values when calling this method.
        string projectId = "your-project-id",
        string zone = "us-central1-a",
        string machineName = "test-machine",
        string machineType = "n1-standard-1",
        string diskImage = "projects/debian-cloud/global/images/family/debian-12",
        long diskSizeGb = 10,
        string networkName = "default")
    {
        Instance instance = new Instance
        {
            Name = machineName,
            // See https://cloud.google.com/compute/docs/machine-types for more information on machine types.
            MachineType = $"zones/{zone}/machineTypes/{machineType}",
            // Instance creation requires at least one persistent disk.
            Disks =
            {
                new AttachedDisk
                {
                    AutoDelete = true,
                    Boot = true,
                    Type = ComputeEnumConstants.AttachedDisk.Type.Persistent,
                    InitializeParams = new AttachedDiskInitializeParams 
                    {
                        // See https://cloud.google.com/compute/docs/images for more information on available images.
                        SourceImage = diskImage,
                        DiskSizeGb = diskSizeGb
                    }
                }
            },
            NetworkInterfaces = { new NetworkInterface { Name = networkName } }
        };

        // Initialize client that will be used to send requests. This client only needs to be created
        // once, and can be reused for multiple requests.
        InstancesClient client = await InstancesClient.CreateAsync();

        // Insert the instance in the specified project and zone.
        var instanceCreation = await client.InsertAsync(projectId, zone, instance);

        // Wait for the operation to complete using client-side polling.
        // The server-side operation is not affected by polling,
        // and might finish successfully even if polling times out.
        await instanceCreation.PollUntilCompletedAsync();
    }
}

Go

import (
	"context"
	"fmt"
	"io"

	compute "cloud.google.com/go/compute/apiv1"
	computepb "cloud.google.com/go/compute/apiv1/computepb"
	"google.golang.org/protobuf/proto"
)

// createInstance sends an instance creation request to the Compute Engine API and waits for it to complete.
func createInstance(w io.Writer, projectID, zone, instanceName, machineType, sourceImage, networkName string) error {
	// projectID := "your_project_id"
	// zone := "europe-central2-b"
	// instanceName := "your_instance_name"
	// machineType := "n1-standard-1"
	// sourceImage := "projects/debian-cloud/global/images/family/debian-12"
	// networkName := "global/networks/default"

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

	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: proto.String(sourceImage),
					},
					AutoDelete: proto.Bool(true),
					Boot:       proto.Bool(true),
					Type:       proto.String(computepb.AttachedDisk_PERSISTENT.String()),
				},
			},
			MachineType: proto.String(fmt.Sprintf("zones/%s/machineTypes/%s", zone, machineType)),
			NetworkInterfaces: []*computepb.NetworkInterface{
				{
					Name: proto.String(networkName),
				},
			},
		},
	}

	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


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.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.concurrent.ExecutionException;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.TimeoutException;

public class CreateInstance {

  public static void main(String[] args)
      throws IOException, InterruptedException, ExecutionException, TimeoutException {
    // TODO(developer): Replace these variables before running the sample.
    String project = "your-project-id";
    String zone = "zone-name";
    String instanceName = "instance-name";
    createInstance(project, zone, instanceName);
  }


  // Create a new instance with the provided "instanceName" value in the specified project and zone.
  public static void createInstance(String project, String zone, String instanceName)
      throws IOException, InterruptedException, ExecutionException, TimeoutException {
    // Below are sample values that can be replaced.
    // machineType: machine type of the VM being created.
    // *   This value uses the format zones/{zone}/machineTypes/{type_name}.
    // *   For a list of machine types, see https://cloud.google.com/compute/docs/machine-types
    // sourceImage: path to the operating system image to mount.
    // *   For details about images you can mount, see https://cloud.google.com/compute/docs/images
    // diskSizeGb: storage size of the boot disk to attach to the instance.
    // networkName: network interface to associate with the instance.
    String machineType = String.format("zones/%s/machineTypes/n1-standard-1", zone);
    String sourceImage = String
        .format("projects/debian-cloud/global/images/family/%s", "debian-11");
    long diskSizeGb = 10L;
    String networkName = "default";

    // 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()) {
      // Instance creation requires at least one persistent disk and one network interface.
      AttachedDisk disk =
          AttachedDisk.newBuilder()
              .setBoot(true)
              .setAutoDelete(true)
              .setType(Type.PERSISTENT.toString())
              .setDeviceName("disk-1")
              .setInitializeParams(
                  AttachedDiskInitializeParams.newBuilder()
                      .setSourceImage(sourceImage)
                      .setDiskSizeGb(diskSizeGb)
                      .build())
              .build();

      // Use the network interface provided in the networkName argument.
      NetworkInterface networkInterface = NetworkInterface.newBuilder()
          .setName(networkName)
          .build();

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

      System.out.printf("Creating instance: %s at %s %n", 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;
      }
      System.out.println("Operation Status: " + response.getStatus());
    }
  }
}

Node.js

/**
 * 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 machineType = 'n1-standard-1';
// const sourceImage = 'projects/debian-cloud/global/images/family/debian-11';
// const networkName = 'global/networks/default';

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

// Create a new instance with the values provided above in the specified project and zone.
async function createInstance() {
  const instancesClient = new compute.InstancesClient();

  console.log(`Creating the ${instanceName} instance in ${zone}...`);

  const [response] = await instancesClient.insert({
    instanceResource: {
      name: instanceName,
      disks: [
        {
          // Describe the size and source image of the boot disk to attach to the instance.
          initializeParams: {
            diskSizeGb: '10',
            sourceImage,
          },
          autoDelete: true,
          boot: true,
          type: 'PERSISTENT',
        },
      ],
      machineType: `zones/${zone}/machineTypes/${machineType}`,
      networkInterfaces: [
        {
          // Use the network interface provided in the networkName argument.
          name: networkName,
        },
      ],
    },
    project: projectId,
    zone,
  });
  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.');
}

createInstance();

PHP

use Google\Cloud\Compute\V1\AttachedDisk;
use Google\Cloud\Compute\V1\AttachedDiskInitializeParams;
use Google\Cloud\Compute\V1\Client\InstancesClient;
use Google\Cloud\Compute\V1\Enums\AttachedDisk\Type;
use Google\Cloud\Compute\V1\InsertInstanceRequest;

/**
 * To correctly handle string enums in Cloud Compute library
 * use constants defined in the Enums subfolder.
 */
use Google\Cloud\Compute\V1\Instance;
use Google\Cloud\Compute\V1\NetworkInterface;

/**
 * Creates an instance in the specified project and zone.
 *
 * @param string $projectId Project ID of the Cloud project to create the instance in.
 * @param string $zone Zone to create the instance in (like "us-central1-a").
 * @param string $instanceName Unique name for this Compute Engine instance.
 * @param string $machineType Machine type of the instance being created.
 * @param string $sourceImage Boot disk image name or family.
 * @param string $networkName Network interface to associate with the instance.
 *
 * @throws \Google\ApiCore\ApiException if the remote call fails.
 * @throws \Google\ApiCore\ValidationException if local error occurs before remote call.
 */
function create_instance(
    string $projectId,
    string $zone,
    string $instanceName,
    string $machineType = 'n1-standard-1',
    string $sourceImage = 'projects/debian-cloud/global/images/family/debian-11',
    string $networkName = 'global/networks/default'
) {
    // Set the machine type using the specified zone.
    $machineTypeFullName = sprintf('zones/%s/machineTypes/%s', $zone, $machineType);

    // Describe the source image of the boot disk to attach to the instance.
    $diskInitializeParams = (new AttachedDiskInitializeParams())
        ->setSourceImage($sourceImage);
    $disk = (new AttachedDisk())
        ->setBoot(true)
        ->setAutoDelete(true)
        ->setType(Type::PERSISTENT)
        ->setInitializeParams($diskInitializeParams);

    // Use the network interface provided in the $networkName argument.
    $network = (new NetworkInterface())
        ->setName($networkName);

    // Create the Instance object.
    $instance = (new Instance())
        ->setName($instanceName)
        ->setDisks([$disk])
        ->setMachineType($machineTypeFullName)
        ->setNetworkInterfaces([$network]);

    // Insert the new Compute Engine instance using InstancesClient.
    $instancesClient = new InstancesClient();
    $request = (new InsertInstanceRequest())
        ->setInstanceResource($instance)
        ->setProject($projectId)
        ->setZone($zone);
    $operation = $instancesClient->insert($request);

    // Wait for the operation to complete.
    $operation->pollUntilComplete();
    if ($operation->operationSucceeded()) {
        printf('Created instance %s' . PHP_EOL, $instanceName);
    } else {
        $error = $operation->getError();
        printf('Instance creation failed: %s' . PHP_EOL, $error?->getMessage());
    }
}

Python

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)

Ruby


require "google/cloud/compute/v1"

# Sends an instance creation request to the Compute Engine API and waits for it to complete.
#
# @param [String] project project ID or project number of the Cloud project you want to use.
# @param [String] zone name of the zone you want to use. For example: "us-west3-b"
# @param [String] instance_name name of the new virtual machine.
# @param [String] machine_type machine type of the VM being created. For example: "e2-standard-2"
#         See https://cloud.google.com/compute/docs/machine-types for more information
#         on machine types.
# @param [String] source_image path to the operating system image to mount on your boot
#         disk. This can be one of the public images
#         (like "projects/debian-cloud/global/images/family/debian-11")
#         or a private image you have access to.
#         See https://cloud.google.com/compute/docs/images for more information on available images.
# @param [String] network_name name of the network you want the new instance to use.
#         For example: "global/networks/default" represents the `default`
#         network interface, which is created automatically for each project.
def create_instance project:, zone:, instance_name:,
                    machine_type: "n2-standard-2",
                    source_image: "projects/debian-cloud/global/images/family/debian-11",
                    network_name: "global/networks/default"
  # Initialize client that will be used to send requests. This client only needs to be created
  # once, and can be reused for multiple requests.
  client = ::Google::Cloud::Compute::V1::Instances::Rest::Client.new

  # Construct the instance object.
  # It can be either a hash or ::Google::Cloud::Compute::V1::Instance instance.
  instance = {
    name: instance_name,
    machine_type: "zones/#{zone}/machineTypes/#{machine_type}",
    # Instance creation requires at least one persistent disk.
    disks: [{
      auto_delete: true,
      boot: true,
      type: :PERSISTENT,
      initialize_params: {
        source_image: source_image,
        disk_size_gb: 10
      }
    }],
    network_interfaces: [{ name: network_name }]
  }

  # Prepare a request to create the instance in the specified project and zone.
  request = { project: project, zone: zone, instance_resource: instance }

  puts "Creating the #{instance_name} instance in #{zone}..."
  begin
    # Send the insert request.
    operation = client.insert request
    # Wait for the create operation to complete.
    operation = wait_until_done operation: operation

    if operation.error?
      warn "Error during creation:", operation.error
    else
      compute_operation = operation.operation
      warn "Warning during creation:", compute_operation.warnings unless compute_operation.warnings.empty?
      puts "Instance #{instance_name} created."
    end
  rescue ::Google::Cloud::Error => e
    warn "Exception during creation:", e
  end
end

REST

Selecciona una imagen pública. Anota el nombre de las imágenes o familias de imágenes y el nombre del proyecto que la contiene.
Usa el método instances.insert para crear una VM a partir de una familia de imágenes o de una versión específica de una imagen de SO:
```
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"
      }
   ],
   
  
   "shieldedInstanceConfig":{
      "enableSecureBoot":"ENABLE_SECURE_BOOT"
   }
}
```
Reemplaza lo siguiente:
- 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 usará para la VM nueva
- MACHINE_TYPE: El tipo de máquina, predefinido o personalizado de la VM nueva
- VM_NAME: Nombre de la VM nueva
- IMAGE_PROJECT: El proyecto que contiene la imagen
  Por ejemplo, si especificas debian-10 como familia de imágenes, especifica debian-cloud como proyecto de imagen.
- IMAGE or IMAGE_FAMILY: 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
    Esto crea la VM a partir de la imagen de SO no obsoleta más reciente. Por ejemplo, si especificas "sourceImage": "projects/debian-cloud/global/images/family/debian-10", Compute Engine crea una VM a partir de la última versión de la imagen de SO en la familia de imágenes Debian 10.
- NETWORK_NAME: La red de VPC que deseas usar para la VM. Puedes especificar default para usar tu red predeterminada
- ENABLE_SECURE_BOOT: Si eliges una imagen que admite funciones de VM protegida, Compute Engine habilita de forma predeterminada el módulo virtual de plataforma de confianza (vTPM) y la supervisión de la integridad. Compute Engine no habilita el Inicio seguro de forma predeterminada.
  
  Si especificas true para enableSecureBoot, Compute Engine crea una VM con las tres funciones de VM protegida habilitadas. Después de que Compute Engine inicie la VM, debes detenerla para modificar las opciones de VM protegida.

Crea una instancia de Bare Metal a partir de una imagen pública

Google, las comunidades de código abierto y los proveedores externos proporcionan y mantienen imágenes de SO públicas. De forma predeterminada, todos los proyectos de Google Cloud pueden crear instancias de Bare Metal con imágenes de SO públicas compatibles. Sin embargo, si tu proyecto de Google Cloud tiene una lista definida de imágenes de confianza, solo puedes usar esas imágenes para crear una instancia de Bare Metal.

Console

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

Ir a Instancias de VM
Selecciona el proyecto y haz clic en Continuar.
Haz clic en Crear instancia.
Especifica un nombre para tu instancia. Para obtener más información, consulta Convención de asignación de nombres de recursos.
Opcional: Cambia la Zona para esta instancia. Si eliges una zona que no tiene ningún servidor Bare Metal disponible, se te solicitará que elijas una zona diferente.
En la sección Configuración de la máquina, realiza una de las siguientes acciones:
- Haz clic en la pestaña Uso general y, luego, selecciona C3.
- Haz clic en la pestaña Memoria optimizada y, luego, selecciona X4.
En Tipo de máquina, haz clic en la lista. En el cuadro de filtro, escribe metal y, luego, selecciona uno de los tipos disponibles.
En la sección Políticas de disponibilidad, haz clic en Configuración avanzada del modelo de aprovisionamiento de VM para expandir la sección. Asegúrate de que el valor de Mantenimiento en el host sea Terminate instance.
En la sección Disco de arranque, haz clic en Cambiar y, luego, haz lo siguiente:
1. En la pestaña Imágenes públicas, elige lo siguiente:
  - Sistema operativo
  - Versión del SO
  - Tipo de disco de arranque
  - Tamaño de disco de arranque
  - Opcional: Para los discos de arranque Hyperdisk Balanced, elige la configuración de IOPS aprovisionadas y Capacidad de procesamiento aprovisionada para el disco.
2. Opcional: Para ver las opciones de configuración adicionales del disco, haz clic en Mostrar configuración avanzada.
3. Para confirmar las opciones del disco de arranque, haz clic en Seleccionar.
  Note: A menos que elijas de forma explícita un disco de arranque diferente, si el nombre de la instancia nueva coincide con el de un disco que ya existe, este se agregará automáticamente a la instancia nueva como disco de arranque.
En la sección Firewall, para permitir el tráfico HTTP o HTTPS a la instancia de bare metal, selecciona Permitir tráfico HTTP o Permitir tráfico HTTPS. Cuando seleccionas una de estas opciones, Compute Engine agrega una etiqueta de red a tu instancia, que asocia la regla de firewall con la instancia. Luego, Compute Engine crea la regla de firewall de entrada correspondiente que permite todo el tráfico entrante en tcp:80 (HTTP) o tcp:443 (HTTPS).
Expande la sección Opciones avanzadas y, luego, la sección Herramientas de redes. Asegúrate de que la tarjeta de interfaz de red esté configurada en IDPF.
Para crear y, luego, iniciar la instancia de Bare Metal, haz clic en Crear.

gcloud

Selecciona una imagen pública que admita instancias de Bare Metal. Anota el nombre de las imágenes o familias de imágenes y el nombre del proyecto que la contiene.
Usa el comando gcloud compute instances create para crear una instancia de Bare Metal a partir de una familia de imágenes o de una versión específica de una imagen de SO.
```
gcloud compute instances create INSTANCE_NAME \
    --zone=ZONE \
    --machine-type=MACHINE_TYPE \
    --network-interface=nic-type=IDPF \
    --maintenance-policy=TERMINATE \
    --create-disk=boot=yes,image=projects/IMAGE_PROJECT/global/images/IMAGE,provisioned-iops=IOPS,provisioned-throughput=THROUGHPUT,size=SIZE,type=hyperdisk-balanced \
    --no-shielded-secure-boot
```
Reemplaza lo siguiente:
- INSTANCE_NAME: Un nombre para la nueva instancia de Bare Metal
- ZONE: Es la zona en la que se creará la instancia de Bare Metal.
- MACHINE_TYPE: Es el tipo de máquina física que se usará para la instancia. El nombre del tipo de máquina debe terminar en -metal.
  
  Para obtener una lista de los tipos de máquinas disponibles en una zona, usa el comando gcloud compute machine-types list con la marca --zones.
- IMAGE_PROJECT: Es el proyecto de imagen que contiene la imagen.
- IMAGE: especifica una de las siguientes opciones:
  - una versión específica de la imagen de SO; por ejemplo, sles-15-sp4-sap-v20240208-x86-6.
  - Una familia de imágenes, que debe tener el formato family/IMAGE_FAMILY. Esto crea la instancia a partir de la imagen de SO no obsoleta más reciente. Por ejemplo, si especificas family/sles-15-sp4-sap, Compute Engine crea una instancia de bare metal a partir de la versión más reciente de la imagen de SO en la familia de imágenes de SUSE Linux Enterprise Server 15 SP4. Para obtener más información sobre el uso de las familias de imágenes, consulta Prácticas recomendadas para las familias de imágenes.
- IOPS: Opcional: Es la cantidad más alta de operaciones de E/S por segundo (IOPS) que el disco puede controlar.
- THROUGHPUT: Opcional: Es un número entero que representa la capacidad de procesamiento más alta, medida en MiB por segundo, que el disco puede controlar.
- SIZE: Opcional: Es el tamaño del disco nuevo. El valor debe ser un número entero. La unidad de medida predeterminada es GiB.
Verifica si Compute Engine creó la instancia:
```
gcloud compute instances describe INSTANCE_NAME
```
Reemplaza INSTANCE_NAME por el nombre de la instancia nueva.

REST

Selecciona una imagen pública que admita instancias de Bare Metal. Anota el nombre de las imágenes o familias de imágenes y el nombre del proyecto que la contiene.
Usa el método instances.insert para crear una instancia de Bare Metal a partir de una familia de imágenes o de una versión específica de una imagen de SO:
```
POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/zones/ZONE/instances
{
 "machineType": "projects/PROJECT_ID/zones/MACHINE_TYPE_ZONE/machineTypes/MACHINE_TYPE",
 "name": "INSTANCE_NAME",
 "disks": [
   {
     "boot": true,
     "initializeParams": {
       "diskSizeGb": "DISK_SIZE",
       "diskType": "hyperdisk-balanced",
       "provisionedIops": "IOPS_LIMIT",
       "provisionedThroughput": "THROUGHPUT_LIMIT",
       "sourceImage": "projects/IMAGE_PROJECT/global/images/IMAGE"
     }
   }
 ],
 "networkInterfaces": [
   {
     "nicType": "IDPF"
   }
 ],
 "scheduling": {
   "onHostMaintenance": "TERMINATE"
 }
}
```
Reemplaza lo siguiente:
- PROJECT_ID: Es el ID del proyecto en el que se creará la instancia de bare metal.
- ZONE: Es la zona en la que se creará la instancia de Bare Metal.
- MACHINE_TYPE_ZONE: Es la zona que contiene el tipo de máquina que se usará para la nueva instancia de Bare Metal.
- MACHINE_TYPE: Es el tipo de máquina que se usará para la instancia. El nombre del tipo de máquina debe terminar en -metal.
- INSTANCE_NAME: Nombre de la instancia nueva
- DISK_SIZE: Es el tamaño del disco, expresado en GiB.
- IOPS_LIMIT: Es la cantidad de operaciones de E/S por segundo que deseas aprovisionar para el disco.
- THROUGHPUT_LIMIT: Un número entero que representa la capacidad de procesamiento, medida en MB por segundo, que deseas aprovisionar para el disco.
- IMAGE_PROJECT: Es el proyecto de imagen que contiene la imagen.
- IMAGE: Especifica una de las siguientes opciones:
  - una versión específica de la imagen de SO; por ejemplo, sles-15-sp4-sap-v20240208-x86-6.
  - Una familia de imágenes, que debe tener el formato family/IMAGE_FAMILY. Esto crea la instancia a partir de la imagen de SO no obsoleta más reciente. Por ejemplo, si especificas family/sles-15-sp4-sap, Compute Engine crea una instancia de bare metal a partir de la versión más reciente de la imagen de SO en la familia de imágenes de SUSE Linux Enterprise Server 15 SP4. Para obtener más información sobre el uso de las familias de imágenes, consulta Prácticas recomendadas para las familias de imágenes.

Crea una VM a partir de una imagen personalizada

La imagen personalizada pertenece solo a tu proyecto. Para crear una VM con una imagen personalizada, primero debes crear una imagen personalizada, si aún no tienes una.

Console

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

Ir a Instancias de VM
Selecciona el proyecto y haz clic en Continuar.
Haz clic en Crear instancia.
Especifica un Nombre para la VM. Para obtener más información, consulta Convención de asignación de nombres de recursos.
Opcional: Cambia la Zona para esta VM. Si seleccionas Cualquiera, Google elige de forma automática una zona por ti según el tipo de máquina y la disponibilidad.
Selecciona una Configuración de máquina para la VM.
En la sección Disco de arranque, haz clic en Cambiar y, luego, haz lo siguiente:
1. Selecciona la pestaña Imágenes personalizadas.
2. Para elegir el proyecto de imagen, haz clic en Seleccionar un proyecto y, luego, haz lo siguiente:
  1. Selecciona el proyecto que contiene la imagen.
  2. Haz clic en Abrir.
3. En la lista Imagen, haz clic en la imagen que deseas importar.
4. Selecciona el tipo y tamaño de tu disco de arranque.
5. Opcional: Para ver las opciones de configuración avanzadas, haz clic en Mostrar configuración avanzada.
6. Para confirmar las opciones del disco de arranque, haz clic en Seleccionar.
En la sección Firewall, para permitir el tráfico HTTP o HTTPS a la VM, elige Permitir tráfico HTTP o Permitir tráfico HTTPS.

La consola de Google Cloud agrega una etiqueta de red a tu instancia y crea la regla de firewall 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 firewall con la VM. Para obtener más información, consulta Descripción general de las reglas de firewall en la documentación del firewall de nueva generación de Cloud.
Para crear y, también, iniciar la VM, haz clic en Crear.

gcloud

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.
Ejecuta el comando gcloud compute instances create para crear una VM con una imagen personalizada:
```
gcloud compute instances create VM_NAME \
    --image-project IMAGE_PROJECT \
    [--image IMAGE | --image-family IMAGE_FAMILY]
    --subnet SUBNET
```
Reemplaza lo siguiente:
- VM_NAME: Es el nombre de la VM
- IMAGE_PROJECT: Es el ID del proyecto que contiene la imagen.
- IMAGE o IMAGE_FAMILY: Especifica una de las siguientes opciones:
  - IMAGE: Es el nombre de tu imagen personalizada.
    Por ejemplo, --image=my-debian-image-v2.
  - IMAGE_FAMILY: Si creaste tus imágenes personalizadas como parte de una familia de imágenes personalizadas, especifica esa familia de imágenes.
    Esto crea la VM a partir de la versión de SO de la imagen de SO no obsoleta más reciente de tu familia de imágenes personalizadas. Por ejemplo, si especificas --image-family=my-debian-family, Compute Engine crea una VM a partir de la última imagen de SO en tu familia de imágenes personalizadas my-debian-family.
  Nota: Compute Engine usa el proyecto y la familia de imágenes predeterminados si no especificas una imagen. La familia de imágenes y el proyecto predeterminados son debian-10 y debian-cloud respectivamente.
- SUBNET: Si la subred y la instancia están en el mismo proyecto, reemplaza SUBNET por el nombre de una subred que esté en la misma región que la instancia.

Terraform

Para generar el código de Terraform, puedes usar el componente Código equivalente en la consola de Google Cloud.

En la consola de Google Cloud, ve a la página Instancias de VM.
Ir a Instancias de VM
Haz clic en Crear instancia.
Especifica los parámetros que desees.
En la parte superior o inferior de la página, haz clic en Código equivalente y, luego, en la pestaña Terraform para ver el código de Terraform.

Go

import (
	"context"
	"fmt"
	"io"

	compute "cloud.google.com/go/compute/apiv1"
	computepb "cloud.google.com/go/compute/apiv1/computepb"
	"google.golang.org/protobuf/proto"
)

// createInstanceFromCustomImage creates a new VM instance with custom image used as its boot disk.
func createInstanceFromCustomImage(w io.Writer, projectID, zone, instanceName, customImageLink string) error {
	// projectID := "your_project_id"
	// zone := "europe-central2-b"
	// instanceName := "your_instance_name"
	// customImageLink := "projects/project_name/global/images/image_name"

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

	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: proto.String(customImageLink),
						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("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


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);
    }
  }

  /**
   * Create a new VM instance with custom image used as its boot 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.
   * @param customImage link to the custom image you want to use in the form of:
   * "projects/{project_name}/global/images/{image_name}"
   * @return Instance object.
   */
  public static Instance createFromCustomImage(String project, String zone, String instanceName,
      String customImage)
      throws IOException, InterruptedException, ExecutionException, TimeoutException {
    String diskType = String.format("zones/%s/diskTypes/pd-standard", zone);
    Vector<AttachedDisk> disks = new Vector<>();
    disks.add(diskFromImage(diskType, 10, true, customImage));
    return createWithDisks(project, zone, instanceName, disks, "n1-standard-1",
        "global/networks/default", null);
  }

Node.js

/**
 * 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 customImageLink = 'projects/YOUR_PROJECT/global/images/YOUR_IMAGE_NAME';

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

// Creates a new VM instance with custom image used as its boot disk.
async function createInstanceFromCustomImage() {
  const instancesClient = new compute.InstancesClient();

  const [response] = await instancesClient.insert({
    project: projectId,
    zone,
    instanceResource: {
      name: instanceName,
      disks: [
        {
          initializeParams: {
            diskSizeGb: '10',
            sourceImage: customImageLink,
            diskType: `zones/${zone}/diskTypes/pd-standard`,
          },
          autoDelete: true,
          boot: true,
          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.');
}

createInstanceFromCustomImage();

Python

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_from_custom_image(
    project_id: str, zone: str, instance_name: str, custom_image_link: str
) -> compute_v1.Instance:
    """
    Create a new VM instance with custom image used as its boot 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.
        custom_image_link: link to the custom image you want to use in the form of:
            "projects/{project_name}/global/images/{image_name}"

    Returns:
        Instance object.
    """
    disk_type = f"zones/{zone}/diskTypes/pd-standard"
    disks = [disk_from_image(disk_type, 10, True, custom_image_link, True)]
    instance = create_instance(project_id, zone, instance_name, disks)
    return instance

REST

El proceso para crear una VM con una imagen personalizada en la API es el mismo que si crearas una VM con una imagen disponible de forma pública.

Para crear la VM a partir de una imagen personalizada, usa el método instances.insert.

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"
      }
   ],
   
  
   "shieldedInstanceConfig":{
      "enableSecureBoot":"ENABLE_SECURE_BOOT"
   }
}

Reemplaza lo siguiente:

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 usará para la VM nueva
MACHINE_TYPE: El tipo de máquina, predefinido o personalizado de la VM nueva
VM_NAME: Nombre de la VM nueva
IMAGE_PROJECT: El nombre del proyecto que contiene la imagen personalizada
IMAGE o IMAGE_FAMILY: Especifica una de las siguientes opciones:
- IMAGE: Es el nombre de tu imagen personalizada. Por ejemplo, "sourceImage": "projects/my-project-1234/global/images/my-debian-image-v2".
- IMAGE_FAMILY: Si creaste tus imágenes personalizadas como parte de una familia de imágenes personalizadas, especifica esa familia de imágenes.
  Esto crea la VM a partir de la imagen de SO no obsoleta más reciente de tu familia de imágenes personalizadas. Por ejemplo, si especificas "sourceImage": "projects/my-project-1234/global/images/family/my-debian-family", Compute Engine crea una VM a partir de la última versión de la imagen de SO en la familia de imágenes personalizadas my-debian-family.
NETWORK_NAME: La red de VPC que deseas usar para la VM. Puedes especificar default para usar tu red predeterminada
ENABLE_SECURE_BOOT: Si eliges una imagen que admite funciones de VM protegida, Compute Engine habilita de forma predeterminada el módulo virtual de plataforma de confianza (vTPM) y la supervisión de la integridad. Compute Engine no habilita el Inicio seguro de forma predeterminada.

Si especificas true para enableSecureBoot, Compute Engine crea una VM con las tres funciones de VM protegida habilitadas. Después de que Compute Engine inicie la VM, debes detenerla para modificar las opciones de VM protegida.

Crea una instancia de VM con discos adicionales que no sean de arranque

Cuando creas una VM, también puedes crear y conectar discos adicionales que no sean de arranque a la VM al mismo tiempo.

Sin embargo, si deseas crear un disco en modo de multiescritura, no puedes crearlo al mismo tiempo que creas la VM. Primero debes crear el disco y, luego, puedes conectarlo a la VM.

Console

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

Ir a Instancias de VM
Selecciona el proyecto y haz clic en Continuar.
Haz clic en Crear instancia.
Especifica un Nombre para la VM. Para obtener más información, consulta Convención de asignación de nombres de recursos.
Opcional: Cambia la Zona para esta VM. Si seleccionas Cualquiera, Google elige de forma automática una zona por ti según el tipo de máquina y la disponibilidad.
Selecciona una Configuración de máquina para la VM.
En la sección Disco de arranque, haz clic en Cambiar y, luego, haz lo siguiente:
1. En la pestaña Imágenes públicas, elige lo siguiente:
  - Sistema operativo
  - Versión del SO
  - Tipo de disco de arranque
  - Tamaño de disco de arranque
2. Opcional: Para ver las opciones de configuración avanzadas, haz clic en Mostrar configuración avanzada.
3. Para confirmar las opciones del disco de arranque, haz clic en Seleccionar.
Nota: A menos que elijas de forma explícita un disco de arranque diferente, si el nombre de la VM nueva coincide con el de un disco persistente que ya existe, este se agregará automáticamente a la VM nueva como disco de arranque.
En la sección Firewall, para permitir el tráfico HTTP o HTTPS a la VM, elige Permitir tráfico HTTP o Permitir tráfico HTTPS. Cuando seleccionas uno de estos, Compute Engine agrega una etiqueta de red a la VM, que asocia la regla de firewall con la VM. Luego, Compute Engine crea la regla de firewall de entrada correspondiente que permite todo el tráfico entrante en tcp:80 (HTTP) o tcp:443 (HTTPS).
Para agregar discos que no sean de arranque a la VM, expande la sección Opciones avanzadas y, luego, haz lo siguiente:
1. Expande la sección Discos.
2. Haz clic en Agregar disco nuevo y, luego, haz lo siguiente:
  1. Especifica las opciones Nombre, Tipo, Tipo de origen y Tamaño del disco.
  2. En la sección Configuración de la conexión, elige el Modo de la conexión del disco y la Regla de eliminación. Si deseas obtener más información para agregar discos nuevos, consulta Agrega un disco persistente a tu VM.
  3. Haz clic en Guardar.
Para crear y, también, iniciar la VM, haz clic en Crear.

gcloud

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.
Ejecuta el comando gcloud compute instances create para crear una VM con discos adicionales que no sean de arranque.

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

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

De manera opcional, puedes incluir propiedades para lo siguiente:
- 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 VM_NAME \
  --zone=ZONE \
  [--image=IMAGE | --image-family=IMAGE_FAMILY] \
  --image-project=IMAGE_PROJECT \
  --create-disk [image=DISK_IMAGE | image-family=DISK_IMAGE_FAMILY ], \
    image-project=DISK_IMAGE_PROJECT,size=SIZE_GB,type=DISK_TYPE \
  --create-disk device-name=DISK_NAME, \
    replica-zones=^:^ZONE:REMOTE-ZONE,boot=false
```
Reemplaza lo siguiente:
- VM_NAME: Nombre de la VM nueva
- ZONE: Zona en la que se creará la VM
- IMAGE o IMAGE_FAMILY. Especifica una de las siguientes opciones:
  - IMAGE: Es una versión específica de una imagen pública
    
    Por ejemplo, --image=debian-10-buster-v20200309.
  - IMAGE_FAMILY: Es una familia de imágenes
    
    Esto crea la VM a partir de la imagen de SO no obsoleta más reciente. Por ejemplo, si especificas --image-family=debian-10, Compute Engine crea una VM a partir de la última versión de la imagen de SO en la familia de imágenes Debian 10.
- IMAGE_PROJECT: Proyecto que contiene la imagen
- Para discos adicionales, reemplaza los siguientes valores:
  - DISK_IMAGE o DISK_IMAGE_FAMILY: Especifica una de las siguientes opciones:
    - DISK_IMAGE: Nombre de la imagen que deseas usar como disco que no sea de arranque
    - DISK_IMAGE_FAMILY: Una familia de imágenes para usar como disco que no sea de arranque
  - DISK_IMAGE_PROJECT: Es el proyecto de imagen al que pertenece la imagen de disco
  - SIZE_GB: Es el tamaño del disco que no es de arranque (opcional)
  - DISK_TYPE: Es la URL completa o parcial para el tipo de disco persistente (opcional).
    
    Por ejemplo, https://www.googleapis.com/compute/v1/projects/PROJECT_ID/zones/ZONE/diskTypes/pd-ssd. Para ver los tipos de discos disponibles, ejecuta el comando gcloud compute disk-types list.
  - DISK_NAME: Es el nombre del disco que se muestra al SO invitado después de crear la VM (opcional).
  - REMOTE_ZONE: Es la zona en la que se debe replicar el disco.
  Para los discos en blanco, no especifiques los parámetros DISK_IMAGE, DISK_IMAGE_FAMILY ni DISK_IMAGE_PROJECT.
  
  Para los discos zonales, no especifiques la propiedad de disco replica-zones.

Terraform

Para generar el código de Terraform, puedes usar el componente Código equivalente en la consola de Google Cloud.

En la consola de Google Cloud, ve a la página Instancias de VM.
Ir a Instancias de VM
Haz clic en Crear instancia.
Especifica los parámetros que desees.
En la parte superior o inferior de la página, haz clic en Código equivalente y, luego, en la pestaña Terraform para ver el código de Terraform.

Go

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


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

/**
 * 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

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 cuando creas una instancia de VM mediante la propiedad initializeParams para cada disco adicional. Crea discos adicionales con una imagen pública o privada. Para agregar un disco en blanco, define la entrada initializeParams sin ningún valor sourceImage. Incluye la propiedad de disco replicaZones para crear discos regionales en lugar de discos zonales.

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

Reemplaza lo siguiente:

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 usará para la VM nueva
MACHINE_TYPE: El tipo de máquina, predefinido o personalizado de la VM nueva
VM_NAME: Nombre de la VM nueva
IMAGE_PROJECT: El proyecto que contiene la imagen
Por ejemplo, si especificas debian-10 como familia de imágenes, especifica debian-cloud como proyecto de imagen.
IMAGE or IMAGE_FAMILY: 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
  Esto crea la VM a partir de la imagen de SO no obsoleta más reciente. Por ejemplo, si especificas "sourceImage": "projects/debian-cloud/global/images/family/debian-10", Compute Engine crea una VM a partir de la última versión de la imagen de SO en la familia de imágenes Debian 10.
Para discos adicionales, reemplaza los siguientes valores:
- SIZE_GB: Es el tamaño del disco
- DISK_IMAGE o
- DISK_IMAGE_FAMILY: Especifica una imagen de origen o familia de imágenes para el disco que no es de arranque:
  - DISK_IMAGE: Es el nombre de la imagen que deseas usar como disco que no es de arranque. Por ejemplo, "sourceImage": "projects/DISK_IMAGE_PROJECT/global/images/DISK_IMAGE".
  - DISK_IMAGE_FAMILY: Es una familia de imágenes que se usará como disco que no es de arranque. Por ejemplo, "sourceImage": "projects/DISK_IMAGE_PROJECT/global/images/family/DISK_IMAGE_FAMILY".
- DISK_TYPE: Es la URL parcial o completa para el tipo de disco persistente. Por ejemplo, https://www.googleapis.com/compute/v1/projects/PROJECT_ID/zones/ZONE/diskTypes/pd-ssd.
- DISK_NAME: Opcional El nombre del disco que se muestra al SO invitado después de crear la VM.
- REMOTE_ZONE: Es la zona a la que se replica el disco regional.
NETWORK_NAME: La red de VPC que deseas usar para la VM. Puedes especificar default para usar tu red predeterminada
ENABLE_SECURE_BOOT: Si eliges una imagen que admite funciones de VM protegida, Compute Engine habilita de forma predeterminada el módulo virtual de plataforma de confianza (vTPM) y la supervisión de la integridad. Compute Engine no habilita el Inicio seguro de forma predeterminada.

Si especificas true para enableSecureBoot, Compute Engine crea una VM con las tres funciones de VM protegida habilitadas. Después de que Compute Engine inicie la VM, debes detenerla para modificar las opciones de VM protegida.

Formatea y activa los discos antes de usarlos.

Crea una instancia de VM a partir de una imagen compartida

Si otro usuario compartió una imagen contigo, puedes usarla para crear una VM.

Console

En la consola de Google Cloud, ve a la página Crea una instancia.

Ir a Crear una instancia
Especifica un Nombre para la VM. Para obtener más información, consulta Convención de asignación de nombres de recursos.
Opcional: Cambia la Zona para esta VM. Si seleccionas Cualquiera, Google elige de forma automática una zona por ti según el tipo de máquina y la disponibilidad.
Selecciona una Configuración de máquina para la VM.
En la sección Disco de arranque, haz clic en Cambiar para configurarlo y, luego, haz lo que se indica a continuación:

Selecciona la pestaña Imágenes personalizadas.
Para elegir el proyecto de imagen, haz clic en Seleccionar un proyecto y, luego, haz lo siguiente:
1. Selecciona el proyecto que contiene la imagen.
2. Haz clic en Abrir.
En la lista Imagen, haz clic en la imagen que deseas importar.
Selecciona el tipo y tamaño de tu disco de arranque.
Para confirmar las opciones del disco de arranque, haz clic en Seleccionar.

Para permitir el tráfico HTTP o HTTPS a la VM, en la sección Firewall, elige Permitir tráfico HTTP o Permitir tráfico HTTPS.

La consola de Google Cloud agrega una etiqueta de red a tu instancia y crea la regla de firewall 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 firewall con la VM. Para obtener más información, consulta Descripción general de las reglas de firewall en la documentación del firewall de nueva generación de Cloud.
Para iniciar y crear una VM, haz clic en Crear.

gcloud

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.

Crea una VM con el comando gcloud compute instances create command y usa las marcas --image y --image-project para especificar el nombre de la imagen y el proyecto donde la imagen reside:

gcloud compute instances create VM_NAME \
        --image=IMAGE \
        --image-project=IMAGE_PROJECT

Reemplaza lo siguiente:

VM_NAME: Es el nombre de la VM nueva.
IMAGE: Es el nombre de la imagen
IMAGE_PROJECT: Es el proyecto al que pertenece la imagen.

Si el comando se ejecuta con éxito, gcloud responde con las propiedades de la VM nueva:

    Created [https://compute.googleapis.com/compute/v1/projects/myproject/zones/us-central1-b/instances/example-instance].
    NAME                 ZONE           MACHINE_TYPE   PREEMPTIBLE  INTERNAL_IP  EXTERNAL_IP    STATUS
    example-instance     us-central1-b  e2-standard-2               10.240.0.4   104.198.53.60  RUNNING

Terraform

El proceso para crear una VM con una imagen compartida en Terraform es el mismo que si crearas una VM con una imagen disponible de forma pública.

En la consola de Google Cloud, ve a la página Instancias de VM.
Ir a Instancias de VM
Haz clic en Crear instancia.
Especifica los parámetros que desees.
En la parte superior o inferior de la página, haz clic en Código equivalente y, luego, en la pestaña Terraform para ver el código de Terraform.

REST

El proceso para crear una VM con una imagen compartida en la API es el mismo que si crearas una VM con una imagen disponible de forma pública. Para crear la VM a partir de una imagen personalizada, usa el método instances.insert.

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"
      }
   ],
   
  
   "shieldedInstanceConfig":{
      "enableSecureBoot":"ENABLE_SECURE_BOOT"
   }
}

Reemplaza lo siguiente:

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 usará para la VM nueva
MACHINE_TYPE: El tipo de máquina, predefinido o personalizado de la VM nueva
VM_NAME: Nombre de la VM nueva
IMAGE_PROJECT: nombre del proyecto que contiene la imagen compartida
IMAGE o IMAGE_FAMILY: especifica una de las siguientes opciones:
- IMAGE: nombre de la imagen compartida. Por ejemplo, "sourceImage": "projects/finance-project-1234/global/images/finance-debian-image-v2".
- IMAGE_FAMILY: si la imagen compartida se crea como parte de una familia de imágenes personalizadas, especifica esa familia de imágenes personalizada.
  Esto crea la VM a partir de la imagen de SO no obsoleta más reciente de tu familia de imágenes personalizadas. Por ejemplo, si especificas "sourceImage": "projects/finance-project-1234/global/images/family/finance-debian-family", Compute Engine crea una VM a partir de la última versión de la imagen de SO en la familia de imágenes personalizadas finance-debian-family.
NETWORK_NAME: La red de VPC que deseas usar para la VM. Puedes especificar default para usar tu red predeterminada
ENABLE_SECURE_BOOT: Si eliges una imagen que admite funciones de VM protegida, Compute Engine habilita de forma predeterminada el módulo virtual de plataforma de confianza (vTPM) y la supervisión de la integridad. Compute Engine no habilita el Inicio seguro de forma predeterminada.

Si especificas true para enableSecureBoot, Compute Engine crea una VM con las tres funciones de VM protegida habilitadas. Después de que Compute Engine inicie la VM, debes detenerla para modificar las opciones de VM protegida.

Crea una VM a partir de una instantánea

Puedes crear una VM nueva a partir de una instantánea de las siguientes maneras:

Restablece un disco de arranque de VM: Si creaste una copia de seguridad del disco de arranque de una VM con una instantánea, puedes usar esa instantánea para crear una VM nueva. Para obtener instrucciones, consulta Restablece una instantánea de disco de arranque en una VM nueva.
Restablece un disco que no es de arranque: Si creaste una copia de seguridad de un disco que no es de arranque con una instantánea, puedes restablecer la instantánea en un nuevo disco que no es de arranque cuando crees una VM. Para obtener instrucciones, consulta Crea una VM con un disco que no es de arranque basado en una instantánea.

Para crear más de una VM con rapidez con el mismo disco de arranque, crea una imagen personalizada y, luego, crea VM a partir de esa imagen, en lugar de usar una instantánea.

Crea una instancia de VM a partir de una imagen de contenedor

Para implementar y, luego, iniciar un contenedor en una VM de Compute Engine, especifica un nombre de imagen de contenedor y los parámetros de configuración opcionales cuando crees la VM. Compute Engine crea la VM con la última versión de la imagen pública de Container-Optimized OS, que tiene instalado Docker. Luego Compute Engine inicia el contenedor cuando se inicia la VM. Si deseas obtener más información, consulta la sección Implementa contenedores en VM.

Para crear una VM a partir de una imagen de contenedor, debes usar la consola de Google Cloud o gcloud.

Console

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

Ir a Instancias de VM
Selecciona el proyecto y haz clic en Continuar.
Haz clic en Crear instancia.
Especifica un Nombre para la VM. Para obtener más información, consulta Convención de asignación de nombres de recursos.
En la sección Contenedor, haz clic en Implementar contenedor.
1. Especifica la Imagen de contenedor a utilizar. Por ejemplo:
  - Para elegir una imagen de contenedor NGINX 1.12 en Cloud Launcher, haz lo siguiente:
    
    gcr.io/cloud-marketplace/google/nginx1:1.12
  - Para implementar una imagen de contenedor de Apache desde Docker Hub, especifica siempre el nombre completo de la imagen de Docker:
    
    docker.io/httpd:2.4
2. De manera opcional, haz clic en Opciones avanzadas de contenedor. Para obtener más información, consulta la página Configura opciones para ejecutar tu contenedor.
Para crear la VM, iníciala y, luego, inicia el contenedor, haz clic en Crear.

gcloud

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.
Ejecuta el comando gcloud compute instances create-with-container:
```
gcloud compute instances create-with-container VM_NAME \
  --container-image=CONTAINER_IMAGE
```
Reemplaza lo siguiente:
- VM_NAME: Es el nombre de la VM nueva.
- CONTAINER_IMAGE: Es el nombre de la imagen del contenedor.
Por ejemplo, el siguiente comando crea una VM llamada nginx-vm, que inicia y ejecuta la imagen del contenedor:

gcr.io/cloud-marketplace/google/nginx1:1.12
```
gcloud compute instances create-with-container nginx-vm \
  --container-image=gcr.io/cloud-marketplace/google/nginx1:1.12
```
Para implementar una imagen de contenedor de Apache desde Docker Hub, especifica siempre el nombre completo de la imagen de Docker:

docker.io/httpd:2.4.

Crea una instancia de VM en una subred específica

De forma predeterminada, Google Cloud crea una red de VPC en modo automático llamada default para cada proyecto. Para usar una red diferente o una subred que creaste de forma manual en un modo automático o en una red de VPC en modo personalizado, debes especificar la subred cuando crees la VM.

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

Si no especificas una red o subred, Compute Engine usa la red de VPC predeterminada y la subred automática que se encuentra en la misma región que la VM.
Si no especificas una red, Compute Engine infiere la red desde la subred especificada.
Si especificas una red, debes especificar una subred y esta debe pertenecer a la misma red. De lo contrario, la creación de la VM fallará.

Console

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

Ir a Instancias de VM
Selecciona el proyecto y haz clic en Continuar.
Haz clic en Crear instancia.
Especifica un Nombre para la VM. Para obtener más información, consulta Convención de asignación de nombres de recursos.
Opcional: Cambia la Zona para esta VM. Si seleccionas Cualquiera, Google elige de forma automática una zona por ti según el tipo de máquina y la disponibilidad.
En la sección Firewall, para permitir el tráfico HTTP o HTTPS a la VM, selecciona Permitir tráfico HTTP o Permitir tráfico HTTPS.

La consola de Google Cloud agrega una etiqueta de red a tu instancia y crea la regla de firewall 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 firewall con la VM. Para obtener más información, consulta Descripción general de las reglas de firewall en la documentación de Cloud NGFW.
Expanda la sección Opciones avanzadas.
1. Expande la sección Herramientas de redes.
2. En Interfaces de red, especifica los detalles de la red:
  1. En el campo Red, elige la red de VPC que contiene la subred que creaste.
  2. En el campo Subred, elige la subred que usarás para la VM.
  3. Haz clic en Listo.
Para crear y, también, iniciar la VM, haz clic en Crear.

gcloud

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.
Con Google Cloud CLI, sigue las mismas instrucciones para crear una VM a partir de una imagen o una instantánea y agrega las marcas --subnet=SUBNET_NAME y --zone=ZONE cuando ejecutas el comando gcloud compute instances create:
```
gcloud compute instances create VM_NAME \
  --network=NETWORK_NAME \
  --subnet=SUBNET_NAME \
  --zone=ZONE
```
Reemplaza lo siguiente:
- VM_NAME: Nombre de la VM
- NETWORK_NAME: nombre de la red (opcional)
- SUBNET_NAME: Es el nombre de la subred
  
  Para ver una lista de subredes en la red, usa el comando gcloud compute networks subnets list.
- ZONE: Es la zona en la que se crea la VM, como europe-west1-b
  
  La región de la VM se infiere de la zona.

Terraform

Para crear una VM 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"
    }
  }
}

Si deseas obtener más información para aplicar o quitar una configuración de Terraform, consulta los comandos básicos de Terraform.

El proceso para crear una VM con una imagen compartida en Terraform es el mismo que si crearas una VM con una imagen disponible de forma pública.

En la consola de Google Cloud, ve a la página Instancias de VM.
Ir a Instancias de VM
Haz clic en Crear instancia.
Especifica los parámetros que desees.
En la parte superior o inferior de la página, haz clic en Código equivalente y, luego, en la pestaña Terraform para ver el código de Terraform.

Go

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


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

/**
 * 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

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 instrucciones de la API para crear una VM a partir de una imagen o de una instantánea, pero especifica el campo subnet en el cuerpo de la solicitud. Para agregar discos en blanco, no agregues una imagen de origen. De manera opcional, puedes especificar las propiedades diskSizeGb, diskType y labels.

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",
         "accessConfigs":{
            "name":"External NAT",
            "type":"ONE_TO_ONE_NAT"
         }
      }
   ],
   
  
   "shieldedInstanceConfig":{
      "enableSecureBoot":"ENABLE_SECURE_BOOT"
   }
}

Reemplaza lo siguiente:

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 usará para la VM nueva
MACHINE_TYPE: El tipo de máquina, predefinido o personalizado de la VM nueva
VM_NAME: Nombre de la VM nueva
IMAGE_PROJECT: El proyecto que contiene la imagen
Por ejemplo, si especificas debian-10 como familia de imágenes, especifica debian-cloud como proyecto de imagen.
IMAGE or IMAGE_FAMILY: 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
  Esto crea la VM a partir de la imagen de SO no obsoleta más reciente. Por ejemplo, si especificas "sourceImage": "projects/debian-cloud/global/images/family/debian-10", Compute Engine crea una VM a partir de la última versión de la imagen de SO en la familia de imágenes Debian 10.
NETWORK_NAME: Es la red de VPC que deseas usar para la VM. Puedes especificar default para usar tu red predeterminada
REGION: Región donde existe la subred especificada
SUBNET_NAME: Es el nombre de la subred
ENABLE_SECURE_BOOT: Si eliges una imagen que admite funciones de VM protegida, Compute Engine habilita de forma predeterminada el módulo virtual de plataforma de confianza (vTPM) y la supervisión de la integridad. Compute Engine no habilita el Inicio seguro de forma predeterminada.

Si especificas true para enableSecureBoot, Compute Engine crea una VM con las tres funciones de VM protegida habilitadas. Después de que Compute Engine inicie la VM, debes detenerla para modificar las opciones de VM protegida.

Crea una VM configurada para la supervisión y el registro del agente de operaciones

El agente de operaciones recopila datos de telemetría de las VMs que puedes usar para solucionar problemas y ajustar el rendimiento. Puedes instalar el agente de operaciones mientras creas una VM o en VMs existentes, como se describe en los siguientes temas:

Instala el agente de operaciones cuando creas una VM con la consola de Google Cloud: Habilita la instalación automática del agente de operaciones seleccionando la casilla de verificación Instalar el agente de operaciones para Monitoring y Logging en la página Crear una instancia. Esta opción habilita VM Manager en el modo de funcionalidad limitada y crea una asignación de política del SO para instalar el Agente de operaciones en la VM. Para obtener más información, consulta Instala el agente de operaciones durante la creación de la VM.
Instala el agente de operaciones en VM existentes: Usa la consola de Google Cloud, la CLI de gcloud o una herramienta de automatización para instalar el agente de operaciones en una flota de VM o en VMs individuales. Para obtener instrucciones, consulta Instala el agente de operaciones.
Nota: Si instalas el agente de operaciones, es posible que se te cobre por las métricas y los registros que el agente envía a tu proyecto de Google Cloud. Para obtener más información, consulta los precios de Google Cloud Observability.

Soluciona problemas

Si quieres encontrar métodos para resolver errores comunes de creación de VM, consulta Soluciona problemas de creación de VM.

Próximos pasos
- Comprueba el estado de la VM para saber cuándo estará lista para usar.
- Obtén más información para usar instantáneas y crear copias de seguridad de tus discos.
- Obtén información para crear y conectar un disco de almacenamiento que no sea de arranque a tu VM para almacenar los datos por separado del disco de arranque.
- Obtén información para conectarte a tu VM.
- Obtén información para escalar horizontalmente tu VM en un grupo de VMs.
Pruébalo tú mismo

Si es la primera vez que usas Google Cloud, crea una cuenta para evaluar el rendimiento de Compute Engine en situaciones reales. Los clientes nuevos también obtienen $300 en créditos gratuitos para ejecutar, probar y, además, implementar cargas de trabajo.
Probar Compute Engine gratis