Crea e inicia una instancia de VM

En este documento se explica cómo crear una instancia de máquina virtual (VM) 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 características 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 VM, 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.

Cuando creas una VM, también puedes agregar múltiples interfaces de red. Para mitigar la exposición de la VM 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 VM desde otras VM en la misma red de VPC o desde una red vinculada, a menos que configures Cloud NAT.

Si creas una VM 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 detalles sobre las opciones de creación de VM más específicas o complicadas, consulta los siguientes recursos:

Si tienes una licencia existente, consulta Trae tu propia licencia con nodos de instancia única.

Antes de comenzar

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.

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

  1. En Google Cloud Console, ve a la página Imágenes.

    Ir a Imágenes

gcloud

  1. Ejecuta el siguiente comando:

    gcloud compute images list
  2. Anota el nombre de las imágenes o familias de imágenes y el nombre del proyecto que la contiene.

  3. (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: Es el 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.

API

  1. Ejecuta el siguiente comando:

    GET https://compute.googleapis.com/compute/v1/projects/IMAGE_PROJECT/global/images/
    
  2. Anota el nombre de las imágenes o familias de imágenes y el nombre del proyecto que la contiene.

  3. (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: Es el 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.

C#


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

import (
	"context"
	"fmt"
	"io"

	compute "cloud.google.com/go/compute/apiv1"
	"google.golang.org/api/iterator"
	computepb "google.golang.org/genproto/googleapis/cloud/compute/v1"
	"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: %v", 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


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

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

use Google\Cloud\Compute\V1\ImagesClient;

/**
 * Prints a list of all non-deprecated image names available in given project.
 * Example:
 * ```
 * list_all_images($projectId);
 * ```
 *
 * @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.
     */
    $pagedResponse = $imagesClient->list($projectId, $optionalArgs);
    print('=================== Flat list of images ===================' . PHP_EOL);
    foreach ($pagedResponse->iterateAllElements() as $element) {
        printf(' - %s' . PHP_EOL, $element->getName());
    }
}

Python

import google.cloud.compute_v1 as compute_v1

def print_images_list(project: str) -> None:
    """
    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:
        None.
    """
    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"
    )

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

Ruby


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

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 VM a partir de imágenes de SO públicas de forma predeterminada. Sin embargo, si tu proyecto de 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

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

    Ir a Instancias de VM

  2. Selecciona el proyecto y haz clic en Continuar.

  3. Haz clic en Crear instancia.

  4. Especifica un Nombre para la VM. Para obtener más información, consulta Convención de asignación de nombres de recursos.

  5. Opcional: Cambia la Zona para esta VM. Compute Engine aleatoriza la lista de zonas dentro de cada región para fomentar el uso en varias zonas.

  6. Selecciona una Configuración de máquina para la VM.

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

  9. 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 protegidas, expande la sección Seguridad en la sección Herramientas de redes, discos, seguridad, administración, instancia única y haz lo siguiente, según sea necesario:

  10. Para crear y, también, iniciar la VM, haz clic en Crear.

gcloud

  1. 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.
  2. 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 \
        [--image=IMAGE | --image-family=IMAGE_FAMILY] \
        --image-project=IMAGE_PROJECT
        --machine-type=MACHINE_TYPE

    Reemplaza lo siguiente:

    • VM_NAME: Nombre de la VM nueva
    • 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.

  3. Verifica si Compute Engine creó la VM:

    gcloud compute instances describe VM_NAME
    

    Reemplaza VM_NAME por el nombre de la VM.

API

  1. 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.
  2. 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
       }
     ],
     "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: Tipo de máquina, predefinido o personalizado, de la VM nueva
    • VM_NAME: Nombre de la VM nueva
    • IMAGE_PROJECT: Proyecto que contiene la imagen

      Por ejemplo, si especificas debian-10 como familia de imágenes, especifica debian-cloud como proyecto de imagen.

    • IMAGE o IMAGE_FAMILY: Especifica una de las siguientes opciones:

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

        Por ejemplo: "sourceImage": "projects/debian-cloud/global/images/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 "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.

    • ENABLE_SECURE_BOOT: Si eliges una imagen que admite funciones de VM protegida, Compute Engine habilita de forma predeterminada el Módulo de plataforma segura virtual (vTPM) y la supervisión de integridad (opcional). 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.

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-10",
        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 "google.golang.org/genproto/googleapis/cloud/compute/v1"
	"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-10"
	// networkName := "global/networks/default"

	ctx := context.Background()
	instancesClient, err := compute.NewInstancesRESTClient(ctx)
	if err != nil {
		return fmt.Errorf("NewInstancesRESTClient: %v", 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: %v", err)
	}

	zoneOperationsClient, err := compute.NewZoneOperationsRESTClient(ctx)
	if err != nil {
		return fmt.Errorf("NewZoneOperationsRESTClient: %v", err)
	}
	defer zoneOperationsClient.Close()

	for {
		waitReq := &computepb.WaitZoneOperationRequest{
			Operation: op.Proto().GetName(),
			Project:   projectID,
			Zone:      zone,
		}
		zoneOp, err := zoneOperationsClient.Wait(ctx, waitReq)
		if err != nil {
			return fmt.Errorf("unable to wait for the operation: %v", err)
		}

		if *zoneOp.Status.Enum() == computepb.Operation_DONE {
			fmt.Fprintf(w, "Instance created\n")
			break
		}
	}

	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;

public class CreateInstance {

  public static void main(String[] args)
      throws IOException, InterruptedException, ExecutionException {
    // 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 {
    // 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-10");
    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();

      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-10';
// 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\InstancesClient;
use Google\Cloud\Compute\V1\AttachedDisk;
use Google\Cloud\Compute\V1\AttachedDiskInitializeParams;
use Google\Cloud\Compute\V1\Instance;
use Google\Cloud\Compute\V1\NetworkInterface;

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

/**
 * Creates an instance in the specified project and zone.
 * Example:
 * ```
 * create_instance($projectId, $zone, $instanceName);
 * ```
 *
 * @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-10',
    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();
    $operation = $instancesClient->insert($instance, $projectId, $zone);

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

import re
import sys

import typing

import google.cloud.compute_v1 as compute_v1

def create_instance(
    project_id: str,
    zone: str,
    instance_name: str,
    machine_type: str = "n1-standard-1",
    source_image: str = "projects/debian-cloud/global/images/family/debian-10",
    network_name: str = "global/networks/default",
) -> 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 you want to use. For example: “us-west3-b”
        instance_name: name of the new virtual machine.
        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"
        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-10")
            or a private image you have access to.
        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.
    Returns:
        Instance object.
    """
    instance_client = compute_v1.InstancesClient()
    operation_client = compute_v1.ZoneOperationsClient()

    # Describe the size and source image of the boot disk to attach to the instance.
    disk = compute_v1.AttachedDisk()
    initialize_params = compute_v1.AttachedDiskInitializeParams()
    initialize_params.source_image = (
        source_image  # "projects/debian-cloud/global/images/family/debian-10"
    )
    initialize_params.disk_size_gb = 10
    disk.initialize_params = initialize_params
    disk.auto_delete = True
    disk.boot = True
    disk.type_ = "PERSISTENT"

    # Use the network interface provided in the network_name argument.
    network_interface = compute_v1.NetworkInterface()
    network_interface.name = network_name

    # Collect information into the Instance object.
    instance = compute_v1.Instance()
    instance.name = instance_name
    instance.disks = [disk]
    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.network_interfaces = [network_interface]

    # 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_unary(request=request)
    while operation.status != compute_v1.Operation.Status.DONE:
        operation = operation_client.wait(
            operation=operation.name, zone=zone, project=project_id
        )
    if operation.error:
        print("Error during creation:", operation.error, file=sys.stderr)
    if operation.warnings:
        print("Warning during creation:", operation.warnings, file=sys.stderr)
    print(f"Instance {instance_name} created.")
    return instance

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-10")
#         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-10",
                    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.operation, project: project

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

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

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

    Ir a Instancias de VM

  2. Selecciona el proyecto y haz clic en Continuar.

  3. Haz clic en Crear instancia.

  4. Especifica un Nombre para la VM. Para obtener más información, consulta Convención de asignación de nombres de recursos.

  5. Opcional: Cambia la Zona para esta VM. Compute Engine aleatoriza la lista de zonas dentro de cada región para fomentar el uso en varias zonas.

  6. Selecciona una Configuración de máquina para la VM.

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

    Cloud Console agrega una etiqueta de red a tu VM 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 la nube privada virtual.

  9. Para crear y, también, iniciar la VM, haz clic en Crear.

gcloud

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]

Reemplaza lo siguiente:

  • VM_NAME: Es el nombre de la VM.
  • IMAGE_PROJECT: Es el nombre 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.

API

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
   }
 ],
 .....
}

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: Tipo de máquina, predefinido o personalizado, de la VM nueva
  • VM_NAME: Nombre de la VM nueva
  • IMAGE_PROJECT: Es 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.

Go

import (
	"context"
	"fmt"
	"io"

	compute "cloud.google.com/go/compute/apiv1"
	computepb "google.golang.org/genproto/googleapis/cloud/compute/v1"
	"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-10"
	// networkName := "global/networks/default"

	ctx := context.Background()
	instancesClient, err := compute.NewInstancesRESTClient(ctx)
	if err != nil {
		return fmt.Errorf("NewInstancesRESTClient: %v", 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: %v", err)
	}

	zoneOperationsClient, err := compute.NewZoneOperationsRESTClient(ctx)
	if err != nil {
		return fmt.Errorf("NewZoneOperationsRESTClient: %v", err)
	}
	defer zoneOperationsClient.Close()

	for {
		waitReq := &computepb.WaitZoneOperationRequest{
			Operation: op.Proto().GetName(),
			Project:   projectID,
			Zone:      zone,
		}
		zoneOp, err := zoneOperationsClient.Wait(ctx, waitReq)
		if err != nil {
			return fmt.Errorf("unable to wait for the operation: %v", err)
		}

		if *zoneOp.Status.Enum() == computepb.Operation_DONE {
			fmt.Fprintf(w, "Instance created\n")
			break
		}
	}

	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;

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 {
    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();

      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 {
    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 createInstanceFromSnapshot() {
  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.');
}

createInstanceFromSnapshot();

Python

from google.cloud import compute_v1

def disk_from_image(
    disk_type: str, disk_size_gb: int, boot: bool, source_image: str
) -> 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}"

    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 = True
    boot_disk.boot = boot
    return boot_disk

def create_with_disks(
    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,
) -> 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.
        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"
        disks: a list of compute_v1.AttachedDisk objects describing the disks
            you want to attach to your new 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.
    """
    instance_client = compute_v1.InstancesClient()
    operation_client = compute_v1.ZoneOperationsClient()

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

    # Collect information into the Instance object.
    instance = compute_v1.Instance()
    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.network_interfaces = [network_interface]

    # Shielded Instance settings
    # Values presented here are the defaults.
    # instance.shielded_instance_config = compute_v1.ShieldedInstanceConfig()
    # instance.shielded_instance_config.enable_secure_boot = False
    # instance.shielded_instance_config.enable_vtpm = True
    # instance.shielded_instance_config.enable_integrity_monitoring = 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_unary(request=request)
    while operation.status != compute_v1.Operation.Status.DONE:
        operation = operation_client.wait(
            operation=operation.name, zone=zone, project=project_id
        )
    if operation.error:
        print("Error during creation:", operation.error, file=sys.stderr)
    if operation.warnings:
        print("Warning during creation:", operation.warnings, file=sys.stderr)
    print(f"Instance {instance_name} created.")
    return instance

def create_from_custom_image(
    project_id: str, zone: str, instance_name: str, custom_image_link: str
):
    """
    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)]
    instance = create_with_disks(project_id, zone, instance_name, disks)
    return instance

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

Console

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

    Ir a Instancias de VM

  2. Selecciona el proyecto y haz clic en Continuar.

  3. Haz clic en Crear instancia.

  4. Especifica un Nombre para la VM. Para obtener más información, consulta Convención de asignación de nombres de recursos.

  5. Opcional: Cambia la Zona para esta VM. Compute Engine aleatoriza la lista de zonas dentro de cada región para fomentar el uso en varias zonas.

  6. Selecciona una Configuración de máquina para la VM.

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

  9. Para agregar discos que no sean de arranque a la VM, expande la sección Herramientas de redes, discos, seguridad, administración, usuario único 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, selecciona 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 Crea y conecta un disco.
      3. Haz clic en Guardar.
  10. Para crear y, también, iniciar la VM, haz clic en Crear.

gcloud

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

Puedes agregar hasta 128 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 las opciones size y type del disco.

gcloud compute instances create VM_NAME \
    [--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

Reemplaza lo siguiente:

  • VM_NAME: Nombre de la VM nueva
  • 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.

    Para los discos en blanco, no especifiques los parámetros DISK_IMAGE, DISK_IMAGE_FAMILY ni DISK_IMAGE_PROJECT.

API

Puedes crear hasta 128 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.

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

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: Tipo de máquina, predefinido o personalizado, de la VM nueva
  • VM_NAME: Nombre de la VM nueva
  • IMAGE_PROJECT: Es 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 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 "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.

  • 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: Nombre de la imagen que deseas usar como disco que no sea de arranque

        Por ejemplo, "sourceImage": "projects/DISK_IMAGE_PROJECT/global/images/DISK_IMAGE".

      • DISK_IMAGE_FAMILY: Una familia de imágenes para usar como disco que no sea de arranque

        Por ejemplo, "sourceImage": "projects/DISK_IMAGE_PROJECT/global/images/family/DISK_IMAGE_FAMILY".

    • DISK_TYPE: La URL completa o parcial para el tipo de disco persistente

    Por ejemplo, https://www.googleapis.com/compute/v1/projects/PROJECT_ID/zones/ZONE/diskTypes/pd-ssd.

    Para los discos en blanco, no especifiques los parámetros DISK_IMAGE, DISK_IMAGE_FAMILY ni DISK_IMAGE_PROJECT.

Go

import (
	"context"
	"fmt"
	"io"

	compute "cloud.google.com/go/compute/apiv1"
	computepb "google.golang.org/genproto/googleapis/cloud/compute/v1"
	"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: %v", err)
	}
	defer instancesClient.Close()

	imagesClient, err := compute.NewImagesRESTClient(ctx)
	if err != nil {
		return fmt.Errorf("NewImagesRESTClient: %v", 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-10",
	}
	newestDebian, err := imagesClient.GetFromFamily(ctx, newestDebianReq)
	if err != nil {
		return fmt.Errorf("unable to get image from family: %v", 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: %v", err)
	}

	zoneOperationsClient, err := compute.NewZoneOperationsRESTClient(ctx)
	if err != nil {
		return fmt.Errorf("NewZoneOperationsRESTClient: %v", err)
	}
	defer zoneOperationsClient.Close()

	for {
		waitReq := &computepb.WaitZoneOperationRequest{
			Operation: op.Proto().GetName(),
			Project:   projectID,
			Zone:      zone,
		}
		zoneOp, err := zoneOperationsClient.Wait(ctx, waitReq)
		if err != nil {
			return fmt.Errorf("unable to wait for the operation: %v", err)
		}

		if *zoneOp.Status.Enum() == computepb.Operation_DONE {
			fmt.Fprintf(w, "Instance created\n")
			break
		}
	}

	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;

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 {
    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();

      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 10 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 {
    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-10");
      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-10',
  });

  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 google.cloud import compute_v1

def disk_from_image(
    disk_type: str, disk_size_gb: int, boot: bool, source_image: str
) -> 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}"

    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 = True
    boot_disk.boot = boot
    return boot_disk

def empty_disk(disk_type: str, disk_size_gb: int) -> 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

    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 = True
    disk.boot = False
    return disk

def create_with_disks(
    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,
) -> 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.
        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"
        disks: a list of compute_v1.AttachedDisk objects describing the disks
            you want to attach to your new 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.
    """
    instance_client = compute_v1.InstancesClient()
    operation_client = compute_v1.ZoneOperationsClient()

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

    # Collect information into the Instance object.
    instance = compute_v1.Instance()
    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.network_interfaces = [network_interface]

    # Shielded Instance settings
    # Values presented here are the defaults.
    # instance.shielded_instance_config = compute_v1.ShieldedInstanceConfig()
    # instance.shielded_instance_config.enable_secure_boot = False
    # instance.shielded_instance_config.enable_vtpm = True
    # instance.shielded_instance_config.enable_integrity_monitoring = 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_unary(request=request)
    while operation.status != compute_v1.Operation.Status.DONE:
        operation = operation_client.wait(
            operation=operation.name, zone=zone, project=project_id
        )
    if operation.error:
        print("Error during creation:", operation.error, file=sys.stderr)
    if operation.warnings:
        print("Warning during creation:", operation.warnings, file=sys.stderr)
    print(f"Instance {instance_name} created.")
    return instance

def create_with_additional_disk(project_id: str, zone: str, instance_name: str):
    """
    Create a new VM instance with Debian 10 operating system and a 11 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.
    """
    image_client = compute_v1.ImagesClient()
    # List of public operating system (OS) images: https://cloud.google.com/compute/docs/images/os-details
    newest_debian = image_client.get_from_family(
        project="debian-cloud", family="debian-10"
    )
    disk_type = f"zones/{zone}/diskTypes/pd-standard"
    disks = [
        disk_from_image(disk_type, 10, True, newest_debian.self_link),
        empty_disk(disk_type, 11),
    ]
    instance = create_with_disks(project_id, zone, instance_name, disks)
    return instance

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

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

    Ir a Crear una instancia

  2. Especifica un Nombre para la VM. Para obtener más información, consulta Convención de asignación de nombres de recursos.
  3. Opcional: Cambia la Zona para esta VM. Compute Engine aleatoriza la lista de zonas dentro de cada región para fomentar el uso en múltiples zonas.
  4. Selecciona una Configuración de máquina para la VM.
  5. En la sección Disco de arranque, haz clic en Cambiar para configurarlo y, luego, haz lo que se indica a continuación:
    1. Selecciona la pestaña Imágenes personalizadas.
    2. Para seleccionar 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. Para confirmar las opciones del disco de arranque, haz clic en Seleccionar.
  6. Para permitir el tráfico HTTP o HTTPS a la VM, en la sección Firewall, selecciona Permitir tráfico HTTP o Permitir tráfico HTTPS.

    Cloud Console agrega una etiqueta de red a tu VM 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 la Descripción general de las reglas de firewall en la documentación de la nube privada virtual.

  7. Para iniciar y crear una VM, haz clic en Crear.

gcloud

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

API

Sigue las instrucciones de la API para crear una VM a partir de una imagen pública, pero especifica el campo image en el cuerpo de la solicitud. Para agregar discos en blanco, no especifiques un origen de la imagen. De manera opcional, puedes especificar las propiedades diskSizeGb, diskType y labels.

    [...
    image: "projects/PROJECT_ID/global/images/IMAGE_NAME
    {
     "initializeParams": {
        "diskSizeGb": "SIZE_GB",
        "sourceImage": "IMAGE"
           }
     }
     ...]

Reemplaza lo siguiente:

  • PROJECT_ID: Proyecto que contiene la imagen
  • IMAGE_NAME: Imagen de origen
  • SIZE_GB: Es el tamaño del disco
  • IMAGE: Imagen de origen para el disco que no es de arranque
  • Para los discos en blanco, no especifiques un origen de la imagen.

Crea una instancia de VM a partir de una instantánea

Si realizaste una copia de seguridad de un disco de arranque persistente con una instantánea, puedes usar esa instantánea para crear una VM.

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 hacerlo a partir de la instantánea.

Crea un disco de arranque de instancia de VM a partir de una instantánea

Puedes restablecer una instantánea de un disco de arranque en uno nuevo cuando creas una VM.

Console

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

    Ir a Instancias de VM

  2. Selecciona el proyecto y haz clic en Continuar.

  3. Haz clic en Crear instancia.

  4. Especifica un Nombre para la VM. Para obtener más información, consulta Convención de asignación de nombres de recursos.

  5. Opcional: Cambia la Zona para esta VM. Compute Engine aleatoriza la lista de zonas dentro de cada región para fomentar el uso en varias zonas.

  6. Selecciona una Configuración de máquina para la VM.

  7. En la sección Disco de arranque, haz clic en Cambiar y, luego, haz lo siguiente:

    1. Haz clic en la pestaña Instantáneas.
    2. En la lista Instantánea, haz clic en una instantánea.
    3. Especifica el tipo y el tamaño del disco de arranque.
    4. Para ver las opciones de configuración avanzadas, haz clic en Mostrar configuración avanzada (opcional).
    5. Para confirmar las opciones del disco de arranque, haz clic en Seleccionar.
  8. 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.

    Cloud Console agrega una etiqueta de red a tu VM 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 la nube privada virtual.

  9. Para crear y, también, iniciar la VM, haz clic en Crear.

gcloud

Usa el comando gcloud compute instances create e incluye la marca --source-snapshot:

gcloud compute instances create VM_NAME \
    --source-snapshot=BOOT_SNAPSHOT_NAME \
    --boot-disk-size=BOOT_DISK_SIZE \
    --boot-disk-type=BOOT_DISK_TYPE \
    --boot-disk-device-name=BOOT_DISK_NAME

Reemplaza lo siguiente:

  • VM_NAME: Es el nombre de la VM nueva
  • BOOT_SNAPSHOT_NAME: nombre de la instantánea del disco de arranque que deseas restablecer en el disco de arranque de la nueva VM.
  • BOOT_DISK_SIZE: Es el tamaño, en gigabytes, del nuevo disco de arranque (opcional)

    El tamaño debe ser igual al tamaño del disco de origen desde el que se realizó la instantánea o mayor que este.

  • BOOT_DISK_TYPE: Es el tipo de disco persistente de arranque (opcional)

    Por ejemplo, pd-ssd.

  • BOOT_DISK_NAME: Nombre del disco de arranque nuevo para esta VM

API

Cuando usas la API para crear una VM a partir de una instantánea, se aplican las siguientes restricciones:

  • Solo se puede usar un disco persistente como disco de arranque.
  • Debes conectar el disco persistente de arranque como primer disco para esa VM.
  • Si especificas la propiedad source, no puedes especificar la propiedad initializeParams. Proporcionar una source indica que el disco persistente de arranque ya existe, pero la propiedad initializeParams indica que Compute Engine debería crear un nuevo disco persistente de arranque.

    Para crear una VM a partir de una instantánea del disco de arranque, especifica el campo sourceSnapshot en la propiedad disks. Especifica las propiedades diskSizeGb y diskType para el nuevo disco de arranque (opcional):

POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/zones/ZONE/instances
{
  "name": "VM_NAME",
  "machineType": "machineTypes/MACHINE_TYPE"
  "networkInterfaces": [{
    "accessConfigs": [{
      "type": "ONE_TO_ONE_NAT",
      "name": "External NAT"
    }],
    "network": "global/networks/default"
  }],
  "disks": [{
     "boot": true,
     "initializeParams": {
       "sourceSnapshot": "global/snapshots/BOOT_SNAPSHOT_NAME",
       "diskSizeGb": "BOOT_DISK_SIZE",
       "diskType": "BOOT_DISK_TYPE"
    }
   }],
 }

Reemplaza lo siguiente:

  • PROJECT_ID: El ID de tu proyecto
  • ZONE: Zona donde deseas crear la VM nueva
  • VM_NAME: Es el nombre de la VM en la que deseas restablecer una instantánea
  • MACHINE_TYPE: tipo de máquina de la VM
  • BOOT_SNAPSHOT_NAME: Nombre de la instantánea que deseas usar para crear el disco de arranque de una VM nueva
  • BOOT_DISK_SIZE: Es el tamaño, en gigabytes, del nuevo disco de arranque (opcional)

    El tamaño debe ser igual al tamaño del disco de origen desde el que se realizó la instantánea o mayor que este.

  • BOOT_DISK_TYPE: Es el tipo de disco de arranque (opcional)

    Por ejemplo, pd-ssd.

Go

import (
	"context"
	"fmt"
	"io"

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

// createInstanceFromSnapshot creates a new VM instance with boot disk created from a snapshot.
func createInstanceFromSnapshot(w io.Writer, projectID, zone, instanceName, snapshotLink string) error {
	// projectID := "your_project_id"
	// zone := "europe-central2-b"
	// instanceName := "your_instance_name"
	// snapshotLink := "projects/project_name/global/snapshots/snapshot_name"

	ctx := context.Background()
	instancesClient, err := compute.NewInstancesRESTClient(ctx)
	if err != nil {
		return fmt.Errorf("NewInstancesRESTClient: %v", 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(11),
						SourceSnapshot: proto.String(snapshotLink),
						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: %v", err)
	}

	zoneOperationsClient, err := compute.NewZoneOperationsRESTClient(ctx)
	if err != nil {
		return fmt.Errorf("NewZoneOperationsRESTClient: %v", err)
	}
	defer zoneOperationsClient.Close()

	for {
		waitReq := &computepb.WaitZoneOperationRequest{
			Operation: op.Proto().GetName(),
			Project:   projectID,
			Zone:      zone,
		}
		zoneOp, err := zoneOperationsClient.Wait(ctx, waitReq)
		if err != nil {
			return fmt.Errorf("unable to wait for the operation: %v", err)
		}

		if *zoneOp.Status.Enum() == computepb.Operation_DONE {
			fmt.Fprintf(w, "Instance created\n")
			break
		}
	}

	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;

public class CreateInstancesAdvanced {

  /**
   * @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 diskSnapshot disk snapshot to use when creating this disk. You must have read access to
   * this disk. This value uses the following format:
   * "projects/{project_name}/global/snapshots/{snapshot_name}"
   * @return AttachedDisk object configured to be created using the specified snapshot.
   */
  private static AttachedDisk diskFromSnapshot(String diskType, int diskSizeGb, boolean boot,
      String diskSnapshot) {
    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()
                    .setSourceSnapshot(diskSnapshot)
                    .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 {
    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();

      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 boot disk created from a snapshot.
   *
   * @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 snapshotName link to the snapshot you want to use as the source of your boot disk in the
   * form of: "projects/{project_name}/global/snapshots/{snapshot_name}"
   * @return Instance object.
   */
  public static Instance createFromSnapshot(String project, String zone, String instanceName,
      String snapshotName)
      throws IOException, InterruptedException, ExecutionException {
    String diskType = String.format("zones/%s/diskTypes/pd-standard", zone);
    Vector<AttachedDisk> disks = new Vector<>();
    disks.add(diskFromSnapshot(diskType, 11, true, snapshotName));
    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 snapshotLink = 'projects/YOUR_PROJECT/global/snapshots/YOUR_SNAPSHOT_NAME';

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

// Creates a new VM instance with boot disk created from a snapshot.
async function createInstanceFromSnapshot() {
  const instancesClient = new compute.InstancesClient();

  const [response] = await instancesClient.insert({
    project: projectId,
    zone,
    instanceResource: {
      name: instanceName,
      disks: [
        {
          initializeParams: {
            diskSizeGb: '11',
            sourceSnapshot: snapshotLink,
            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.');
}

createInstanceFromSnapshot();

Python

from google.cloud import compute_v1

def disk_from_snapshot(
    disk_type: str, disk_size_gb: int, boot: bool, disk_snapshot: str
) -> compute_v1.AttachedDisk():
    """
    Create an AttachedDisk object to be used in VM instance creation. Uses a disk snapshot 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
        disk_snapshot: disk snapshot to use when creating this disk. You must have read access to this disk.
            This value uses the following format: "projects/{project_name}/global/snapshots/{snapshot_name}"

    Returns:
        AttachedDisk object configured to be created using the specified snapshot.
    """
    disk = compute_v1.AttachedDisk()
    initialize_params = compute_v1.AttachedDiskInitializeParams()
    initialize_params.source_snapshot = disk_snapshot
    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 = True
    disk.boot = boot
    return disk

def create_with_disks(
    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,
) -> 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.
        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"
        disks: a list of compute_v1.AttachedDisk objects describing the disks
            you want to attach to your new 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.
    """
    instance_client = compute_v1.InstancesClient()
    operation_client = compute_v1.ZoneOperationsClient()

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

    # Collect information into the Instance object.
    instance = compute_v1.Instance()
    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.network_interfaces = [network_interface]

    # Shielded Instance settings
    # Values presented here are the defaults.
    # instance.shielded_instance_config = compute_v1.ShieldedInstanceConfig()
    # instance.shielded_instance_config.enable_secure_boot = False
    # instance.shielded_instance_config.enable_vtpm = True
    # instance.shielded_instance_config.enable_integrity_monitoring = 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_unary(request=request)
    while operation.status != compute_v1.Operation.Status.DONE:
        operation = operation_client.wait(
            operation=operation.name, zone=zone, project=project_id
        )
    if operation.error:
        print("Error during creation:", operation.error, file=sys.stderr)
    if operation.warnings:
        print("Warning during creation:", operation.warnings, file=sys.stderr)
    print(f"Instance {instance_name} created.")
    return instance

def create_from_snapshot(
    project_id: str, zone: str, instance_name: str, snapshot_link: str
):
    """
    Create a new VM instance with boot disk created from a snapshot.

    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.
        snapshot_link: link to the snapshot you want to use as the source of your
            boot disk in the form of: "projects/{project_name}/global/snapshots/{snapshot_name}"

    Returns:
        Instance object.
    """
    disk_type = f"zones/{zone}/diskTypes/pd-standard"
    disks = [disk_from_snapshot(disk_type, 11, True, snapshot_link)]
    instance = create_with_disks(project_id, zone, instance_name, disks)
    return instance

Restablece instantáneas que no sean de arranque en una nueva instancia de VM

Las instantáneas que no son de arranque son copias de seguridad de discos persistentes secundarios que la VM usa solo para el almacenamiento de datos. Puedes restablecer instantáneas que no sean de arranque en discos nuevos cada vez que creas una VM. De forma alternativa, también puedes restablecer instantáneas que no sean de arranque en una VM existente.

Para restablecer instantáneas que no sean de arranque en una VM nueva, sigue estos pasos adicionales cuando crees una VM.

Console

Para restablecer instantáneas que no sean de arranque en una VM nueva desde la consola, primero crea un disco a partir de cada instantánea. Luego, adjunta los discos nuevos cuando crees la VM.

  1. Restablece cada instantánea que no sea de arranque en un disco nuevo.

    1. En Google Cloud Console, ve a la página Discos.

      Ir a Discos

    2. Haz clic en Crear disco.

    3. Especifica un Nombre para el disco. Para obtener más información, consulta Convención de asignación de nombres de recursos.

    4. Selecciona la Región y la Zona para este disco. El disco y la VM deben estar en la misma zona.

    5. Selecciona un Tipo de disco.

    6. En Tipo de fuente, selecciona Instantánea.

    7. En el nuevo campo Instantánea de origen, selecciona una instantánea que no sea de arranque que quieras restablecer en el disco nuevo.

    8. Para crear el disco, haz clic en Crear.

    Repite estos pasos para crear un disco a partir de cada instantánea que desees restablecer. Cuando creas una VM, puedes agregar hasta 15 discos que no sean de arranque.

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

    Ir a Instancias de VM

  3. Selecciona el proyecto y haz clic en Continuar.

  4. Haz clic en Crear instancia.

    1. Especifica un Nombre para la VM. Para obtener más información, consulta Convención de asignación de nombres de recursos.
    2. Selecciona la Región y la Zona para esta VM. El disco y la VM deben estar en la misma zona.
    3. Selecciona un Tipo de máquina para tu VM.
    4. Si deseas permitir el tráfico externo entrante, cambia las reglas de firewall de la VM.
    5. Para conectar discos a la VM, expande la sección Herramientas de redes, discos, seguridad, administración, usuario único y, luego, haz lo siguiente:

      1. Expande la sección Discos.
      2. Haz clic en Conectar un disco existente.
        1. En la lista Disco, selecciona un disco para conectar a esta VM.
        2. En la sección Configuración de la conexión, selecciona el Modo de la conexión y la Regla de eliminación del disco. Si deseas obtener más información para agregar discos nuevos, consulta Crea y conecta un disco.
      3. Haz clic en Guardar.

      Repite estos pasos para cada disco que desees conectar. Cuando creas una VM, puedes agregar hasta 15 discos que no sean de arranque.

  5. Para crear y, también, iniciar la VM, haz clic en Crear.

gcloud

Crea una VM mediante el comando gcloud compute instances create. Para cada instantánea que no sea de arranque que quieras restablecer, incluye la marca --create-disk y especifica una source-snapshot. Cuando creas una VM, puedes agregar hasta 15 discos que no sean de arranque.

Por ejemplo, para restablecer dos instantáneas que no son de arranque en una VM nueva, usa el siguiente comando:

gcloud compute instances create VM_NAME \
    --create-disk source-snapshot=SNAPSHOT_1_NAME,name=DISK_1_NAME,size=DISK_1_SIZE,type=DISK_1_TYPE \
    --create-disk source-snapshot=SNAPSHOT_2_NAME,name=DISK_2_NAME,size=DISK_2_SIZE,type=DISK_2_TYPE

Reemplaza lo siguiente:

  • VM_NAME: Es el nombre de la VM nueva
  • SNAPSHOT_1_NAME y SNAPSHOT_2_NAME: Son los nombres de las instantáneas que no son de arranque que deseas restablecer
  • DISK_1_NAME y DISK_2_NAME: Son los nombres de los discos nuevos que no son de arranque para esta VM.
  • DISK_1_SIZE y DISK_2_SIZE: Son los tamaños, en gigabytes, de cada disco nuevo que no es de arranque (opcional)

    Los tamaños deben ser iguales o mayores que los tamaños de los discos de origen desde los que se realizó la instantánea.

  • DISK_1_TYPE y DISK_2_TYPE: Son los tipos de los discos persistentes (opcional)

    Por ejemplo, https://www.googleapis.com/compute/v1/projects/PROJECT_ID/zones/ZONE/diskTypes/pd-ssd.

API

Cuando se usa la API para restablecer una instantánea que no es de arranque en una VM nueva, se aplican las siguientes restricciones:

  • El disco de arranque solo puede ser un disco persistente.
  • Debes conectar el disco persistente de arranque como primer disco para esa VM.
  • Si especificas la propiedad source, no puedes especificar la propiedad initializeParams. Proporcionar una source indica que el disco persistente de arranque ya existe, pero la propiedad initializeParams indica que Compute Engine debería crear un nuevo disco persistente de arranque.

Con la API Beta, especifica el campo sourceSnapshot en la propiedad initializeParams. Puedes agregar hasta 15 discos que no sean de arranque si repites la propiedad initializeParams para cada disco que no sea de arranque que desees crear. De manera opcional, puedes especificar las propiedades diskSizeGb y diskType para cualquiera de los discos que crees.

Por ejemplo, para restablecer dos instantáneas que no sean de arranque en una VM nueva, realiza la siguiente solicitud:

POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/zones/ZONE/instances
{
  "name": "VM_NAME",
  "machineType": "machineTypes/MACHINE_TYPE"
  "networkInterfaces": [{
    "accessConfigs": [{
      "type": "ONE_TO_ONE_NAT",
      "name": "External NAT"
    }],
    "network": "global/networks/default"
  }],
  "disks": [{
     "autoDelete": "true",
     "boot": "true",
     "type": "PERSISTENT",
     "diskSizeGb": "DISK_SIZE",
     "diskType": "DISK_TYPE"
   },
   {
     "initializeParams": {
        "sourceSnapshot": "global/snapshots/SNAPSHOT_1_NAME",
        "diskSizeGb": "DISK_SIZE",
        "diskType": "DISK_TYPE"
     }
   },
   {
     "initializeParams": {
        "sourceSnapshot": "global/snapshots/SNAPSHOT_2_NAME",
        "diskSizeGb": "DISK_SIZE",
        "diskType": "DISK_TYPE"
     }
  }]
 }

Reemplaza lo siguiente:

  • PROJECT_ID: El ID de tu proyecto
  • ZONE: Zona donde deseas crear la VM
  • VM_NAME: Es el nombre de la VM en la que deseas restablecer una instantánea
  • MACHINE_TYPE: Tipo de máquina de la VM
  • DISK_SIZE: Es el tamaño, en gigabytes, del disco correspondiente (opcional)

    Cuando se proporciona, esta propiedad debe ser igual o mayor que el tamaño del disco de origen desde el que se realizó la instantánea.

  • DISK_TYPE: Es una URL completa o parcial para el tipo de disco persistente correspondiente (opcional).

    Por ejemplo, https://www.googleapis.com/compute/v1/projects/PROJECT_ID/zones/ZONE/diskTypes/pd-ssd.

  • SNAPSHOT_1_NAME y SNAPSHOT_2_NAME: Nombres de las instantáneas que no son de arranque que deseas restablecer en discos nuevos que no son de arranque en la nueva VM

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 Cloud Console o gcloud.

Console

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

    Ir a Instancias de VM

  2. Selecciona el proyecto y haz clic en Continuar.

  3. Haz clic en Crear instancia.

  4. Especifica un Nombre para la VM. Para obtener más información, consulta Convención de asignación de nombres de recursos.

  5. En la sección Contenedor, haz clic en Implementar contenedor.

    1. Especifica la Imagen de contenedor a utilizar. Por ejemplo:

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

  6. Para crear la VM, iníciala y, luego, inicia el contenedor, haz clic en Crear.

gcloud

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 con acceso a otros servicios de Google Cloud

Si planeas ejecutar una aplicación en tu VM que necesite acceso a otros servicios de Google Cloud, crea una cuenta de servicio antes de crear la VM y, luego, configura la VM para que se ejecute como una cuenta de servicio. Una cuenta de servicio es una cuenta especial cuyas credenciales puedes usar en el código de aplicación para acceder a otros servicios de Google Cloud.

Para obtener más información, consulta Cuentas de servicio.

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

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

    Ir a Instancias de VM

  2. Selecciona el proyecto y haz clic en Continuar.

  3. Haz clic en Crear instancia.

  4. Especifica un Nombre para la VM. Para obtener más información, consulta Convención de asignación de nombres de recursos.

  5. Opcional: Cambia la Zona para esta VM. Compute Engine aleatoriza la lista de zonas dentro de cada región para fomentar el uso en varias zonas.

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

    Cloud Console agrega una etiqueta de red a tu VM 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 la nube privada virtual.

  7. Expande la sección Herramientas de redes, discos, seguridad, administración, usuario único.

    1. Expande la sección Herramientas de redes.
    2. En Interfaces de red, especifica los detalles de la red:
      1. En el campo Red, selecciona la red de VPC que contiene la subred que creaste.
      2. En el campo Subred, selecciona la subred que usarás para la VM.
      3. Haga clic en Listo.
  8. Para crear y, también, iniciar la VM, haz clic en Crear.

gcloud

Con la herramienta de línea de comandos de gcloud, sigue las mismas instrucciones para crear una VM a partir de una imagen oinstantánea y agrega las marcas --subnet=SUBNET_NAME y --zone=ZONE cuando ejecutes 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.

API

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.

...
"networkInterfaces": [
{
  "network": "global/networks/NETWORK_NAME",
  "subnetwork": "regions/REGION/subnetworks/SUBNET_NAME",
  "accessConfigs":
    {
      "name": "External NAT",
      "type": "ONE_TO_ONE_NAT"
    }
    {
      "initializeParams": {
         "diskSizeGb": "SIZE_GB",
         "sourceImage": "IMAGE"
    {
      "initializeParams": {
      "diskSizeGb": "SIZE_GB"
     }
 }...]

Reemplaza lo siguiente:

  • NETWORK_NAME: Nombre de la red (opcional)
  • REGION: Región donde existe la subred especificada
  • SUBNET_NAME: Es el nombre de la subred
  • SIZE_GB: Es el tamaño del disco
  • IMAGE: Imagen de origen para el disco que no es de arranque

    Para los discos en blanco, no especifiques un origen de la imagen.

Go

import (
	"context"
	"fmt"
	"io"

	compute "cloud.google.com/go/compute/apiv1"
	computepb "google.golang.org/genproto/googleapis/cloud/compute/v1"
	"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: %v", err)
	}
	defer instancesClient.Close()

	imagesClient, err := compute.NewImagesRESTClient(ctx)
	if err != nil {
		return fmt.Errorf("NewImagesRESTClient: %v", 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-10",
	}
	newestDebian, err := imagesClient.GetFromFamily(ctx, newestDebianReq)
	if err != nil {
		return fmt.Errorf("unable to get image from family: %v", 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: %v", err)
	}

	zoneOperationsClient, err := compute.NewZoneOperationsRESTClient(ctx)
	if err != nil {
		return fmt.Errorf("NewZoneOperationsRESTClient: %v", err)
	}
	defer zoneOperationsClient.Close()

	for {
		waitReq := &computepb.WaitZoneOperationRequest{
			Operation: op.Proto().GetName(),
			Project:   projectID,
			Zone:      zone,
		}
		zoneOp, err := zoneOperationsClient.Wait(ctx, waitReq)
		if err != nil {
			return fmt.Errorf("unable to wait for the operation: %v", err)
		}

		if *zoneOp.Status.Enum() == computepb.Operation_DONE {
			fmt.Fprintf(w, "Instance created\n")
			break
		}
	}

	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;

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 {
    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();

      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-10',
  });

  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 google.cloud import compute_v1

def disk_from_image(
    disk_type: str, disk_size_gb: int, boot: bool, source_image: str
) -> 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}"

    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 = True
    boot_disk.boot = boot
    return boot_disk

def create_with_disks(
    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,
) -> 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.
        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"
        disks: a list of compute_v1.AttachedDisk objects describing the disks
            you want to attach to your new 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.
    """
    instance_client = compute_v1.InstancesClient()
    operation_client = compute_v1.ZoneOperationsClient()

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

    # Collect information into the Instance object.
    instance = compute_v1.Instance()
    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.network_interfaces = [network_interface]

    # Shielded Instance settings
    # Values presented here are the defaults.
    # instance.shielded_instance_config = compute_v1.ShieldedInstanceConfig()
    # instance.shielded_instance_config.enable_secure_boot = False
    # instance.shielded_instance_config.enable_vtpm = True
    # instance.shielded_instance_config.enable_integrity_monitoring = 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_unary(request=request)
    while operation.status != compute_v1.Operation.Status.DONE:
        operation = operation_client.wait(
            operation=operation.name, zone=zone, project=project_id
        )
    if operation.error:
        print("Error during creation:", operation.error, file=sys.stderr)
    if operation.warnings:
        print("Warning during creation:", operation.warnings, file=sys.stderr)
    print(f"Instance {instance_name} created.")
    return instance

def create_with_subnet(
    project_id: str, zone: str, instance_name: str, network_link: str, subnet_link: str
):
    """
    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.
    """
    image_client = compute_v1.ImagesClient()
    # List of public operating system (OS) images: https://cloud.google.com/compute/docs/images/os-details
    newest_debian = image_client.get_from_family(
        project="debian-cloud", family="debian-10"
    )
    disk_type = f"zones/{zone}/diskTypes/pd-standard"
    disks = [disk_from_image(disk_type, 10, True, newest_debian.self_link)]
    instance = create_with_disks(
        project_id,
        zone,
        instance_name,
        disks,
        network_link=network_link,
        subnetwork_link=subnet_link,
    )
    return instance

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

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