Esta página se ha traducido con Cloud Translation API.

Crear una instancia a partir de una imagen pública

Una instancia contiene un gestor de arranque, un sistema de archivos de arranque y una imagen del SO. En este documento se explica cómo crear una instancia a partir de una imagen de SO pública. Si vas a crear una instancia Arm, elige una imagen de SO que sea compatible con Arm.

Algunas imágenes admiten las funciones de VM blindada, que ofrecen funciones de seguridad como firmware compatible con UEFI, arranque seguro y arranque medido protegido por vTPM. En las VMs blindadas, el vTPM y la monitorización de integridad están habilitados de forma predeterminada.

Antes de empezar

Cuando se crean instancias a partir de imágenes mediante la CLI de Google Cloud o la API de Compute Engine, hay un límite de 20 instancias por segundo. Si necesitas crear un número mayor de instancias por segundo, solicita un ajuste de cuota para el recurso Imágenes.

Si vas a usar una licencia que ya tienes para tu imagen, consulta Usar licencias adquiridas por el usuario.

Si aún no lo has hecho, configura la autenticación. La autenticación verifica tu identidad para acceder a Google Cloud servicios y APIs. Para ejecutar código o ejemplos desde un entorno de desarrollo local, puedes autenticarte en Compute Engine seleccionando una de las siguientes opciones:
Select the tab for how you plan to use the samples on this page:
Console

When you use the Google Cloud console to access Google Cloud services and APIs, you don't need to set up authentication.
gcloud
1. Instala Google Cloud CLI. Después de la instalación, inicializa la CLI de Google Cloud ejecutando el siguiente comando:
  gcloud init
  Si utilizas un proveedor de identidades (IdP) externo, primero debes iniciar sesión en la CLI de gcloud con tu identidad federada.
  
  Nota: Si ya has instalado la CLI de gcloud, asegúrate de que tienes la versión más reciente ejecutando gcloud components update.
2. Set a default region and zone.
REST

Para usar las muestras de la API REST de esta página en un entorno de desarrollo local, debes usar las credenciales que proporciones a la CLI de gcloud.
Para obtener más información, consulta el artículo Autenticarse para usar REST de la documentación sobre autenticación de Google Cloud .

Roles obligatorios

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

Este rol predefinido contiene el permiso compute.instances.create , que es necesario para crear una instancia a partir de una imagen pública.

También puedes obtener este permiso con roles personalizados u otros roles predefinidos.

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

Antes de crear una instancia con una imagen pública, consulta la lista de imágenes públicas disponibles en Compute Engine.

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

Consola

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

Ir a Imágenes

gcloud

Ejecuta el siguiente comando:
```
gcloud compute images list
```
Anota el nombre de la imagen o de la familia de imágenes y el nombre del proyecto que contiene la imagen.
Opcional: Para determinar si la imagen admite las funciones de VM blindada, ejecuta el siguiente comando:
```
gcloud compute images describe IMAGE_NAME \
    --project=IMAGE_PROJECT
```
Haz los cambios siguientes:
- IMAGE_NAME: nombre de la imagen para comprobar si admite las funciones de VM blindada
- IMAGE_PROJECT: proyecto que contiene la imagen
Si la imagen admite las funciones de VM blindada, aparecerá la siguiente línea en el resultado: type: UEFI_COMPATIBLE.

C#

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

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


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

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

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

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

Go

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

import (
	"context"
	"fmt"
	"io"

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

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

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

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

Java

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


import com.google.cloud.compute.v1.Image;
import com.google.cloud.compute.v1.ImagesClient;
import com.google.cloud.compute.v1.ImagesClient.ListPage;
import com.google.cloud.compute.v1.ListImagesRequest;
import java.io.IOException;
  // Prints a list of all non-deprecated image names available in given project.
  public static void listImages(String project) throws IOException {
    // Initialize client that will be used to send requests. This client only needs to be created
    // once, and can be reused for multiple requests. After completing all of your requests, call
    // the `instancesClient.close()` method on the client to
    // safely clean up any remaining background resources.
    try (ImagesClient imagesClient = ImagesClient.create()) {

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

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

Node.js

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

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

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

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

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

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

listImages();

PHP

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

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

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

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

Python

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

import google.cloud.compute_v1 as compute_v1

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

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

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

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

Ruby

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


require "google/cloud/compute/v1"

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

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

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

REST

Ejecuta el siguiente comando:

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

Anota el nombre de la imagen o de la familia de imágenes y el nombre del proyecto que contiene la imagen.
Opcional: Para determinar si la imagen admite las funciones de VM blindada, ejecuta el siguiente comando:
```
GET https://compute.googleapis.com/compute/v1/projects/IMAGE_PROJECT/global/images/IMAGE_NAME
```
Haz los cambios siguientes:
- IMAGE_PROJECT: proyecto que contiene la imagen
- IMAGE_NAME: nombre de la imagen para comprobar si admite las funciones de VM blindada
Si la imagen admite las funciones de VM blindada, aparecerá la siguiente línea en el resultado: type: UEFI_COMPATIBLE.

Crear 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. De forma predeterminada, todos los Google Cloud proyectos pueden crear VMs a partir de imágenes de SO públicas. Sin embargo, si tu proyecto tiene una lista definida de imágenes de confianza, solo puedes usar las imágenes de esa lista para crear una VM. Google Cloud

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

Consola

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

Ir a Crear una instancia

Si se te solicita, selecciona tu proyecto y haz clic en Continuar. Aparecerá la página Crear una instancia y se mostrará el panel Configuración de la máquina.
En el panel Configuración de la máquina, haz lo siguiente:
1. En el campo Nombre, especifica un nombre para la máquina virtual. Para obtener más información, consulta el artículo Convenciones para asignar nombres de recursos.
2. Opcional: En el campo Zona, selecciona una zona para esta VM.
  
  La selección predeterminada es Cualquiera. Si no cambias esta selección predeterminada, Google elegirá automáticamente una zona en función del tipo de máquina y la disponibilidad.
3. Selecciona la familia de máquinas de tu VM. La consola Google Cloud muestra las series de máquinas disponibles para la familia de máquinas que hayas seleccionado. Estas son las opciones de familia de máquinas disponibles:
  - Uso general
  - Optimizada para la computación
  - Con memoria optimizada
  - Almacenamiento optimizado
  - GPUs
4. En la columna Serie, selecciona la serie de máquinas de tu VM.
  
  Si has seleccionado GPUs como familia de máquinas en el paso anterior, selecciona el tipo de GPU que quieras. La serie de máquinas se selecciona automáticamente para el tipo de GPU seleccionado.
5. En la sección Tipo de máquina, selecciona el tipo de máquina de tu VM.
En el menú de navegación, haz clic en SO y almacenamiento. En el panel Sistema operativo y almacenamiento que aparece, configura el disco de arranque haciendo lo siguiente:
1. Haz clic en Cambiar. Aparece el panel Disco de arranque y se muestra la pestaña Imágenes públicas.
2. En la lista Sistema operativo, selecciona el tipo de SO.
3. En la lista Versión, selecciona la versión del SO.
4. En la lista Tipo de disco de arranque, selecciona el tipo de disco de arranque.
5. En el campo Tamaño (GB), especifica el tamaño del disco de arranque.
6. Opcional: En el caso de los discos de arranque Hyperdisk Balanced, especifica valores en los campos IOPS aprovisionadas y Rendimiento aprovisionado.
7. Opcional: Para ver las opciones de configuración avanzada, despliega la sección Mostrar configuraciones avanzadas.
8. Para confirmar las opciones del disco de arranque y volver al panel Sistema operativo y almacenamiento, haz clic en Seleccionar.
Nota: A menos que elijas explícitamente otro disco de arranque, si el nombre de la nueva VM coincide con el de un disco, este se adjuntará automáticamente a la nueva VM como disco de arranque.
En el menú de navegación, haga clic en Redes. En el panel Redes que aparece, haz lo siguiente:
1. Ve a la sección Cortafuegos.
2. Para permitir el tráfico HTTP o HTTPS a la VM, selecciona Permitir el tráfico HTTP o Permitir el tráfico HTTPS.
  
  Compute Engine añade una etiqueta de red a tu VM y crea la regla de cortafuegos de entrada correspondiente que permite todo el tráfico entrante en tcp:80 (HTTP) o tcp:443 (HTTPS). La etiqueta de red asocia la regla de cortafuegos a la VM. Para obtener más información, consulta el resumen de las reglas de cortafuegos en la documentación de Cloud Next Generation Firewall.
Opcional: Si has elegido una imagen de SO que admite las funciones de VM blindada, puedes modificar los ajustes de VM blindada.

Para ello, en el menú de navegación, haga clic en Seguridad. En el panel Seguridad que aparece, puedes configurar lo siguiente:
- Para activar Arranque seguro, marca la casilla Activar Arranque seguro. El arranque seguro está inhabilitado de forma predeterminada.
- Para desactivar vTPM, desmarca la casilla Activa el vTPM. El vTPM está habilitado de forma predeterminada. Si inhabilitas el vTPM, también se inhabilitará la monitorización de integridad, ya que esta función se basa en los datos recogidos por Arranque medido.
- Para desactivar la monitorización de integridad, desmarca la casilla Activar monitorización de integridad. La supervisión de integridad está habilitada de forma predeterminada.
Opcional: Especifica otras opciones de configuración. Para obtener más información, consulta Opciones de configuración durante la creación de instancias.
Para crear e iniciar la VM, haz clic en Crear.

gcloud

Selecciona una imagen pública. Anota el nombre de la imagen o de la familia de imágenes y el nombre del proyecto que contiene la imagen.
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 VM blindada habilitadas:
Una vez que Compute Engine haya iniciado tu VM, debes detenerla para modificar las opciones de VM blindada.
```
gcloud compute instances create VM_NAME \
    --zone=ZONE \
    [--image=IMAGE | --image-family=IMAGE_FAMILY] \
    --image-project=IMAGE_PROJECT
    IMAGE_FLAG \
    --machine-type=MACHINE_TYPE
```
Haz los cambios siguientes:
- VM_NAME: Nombre de la nueva VM
- ZONE: zona en la que se creará la instancia
- IMAGE_PROJECT: el proyecto que contiene la imagen
- IMAGE_FLAG: especifica una de las siguientes opciones:
  - Usa la marca --image IMAGE_NAME para especificar una versión concreta de una imagen pública.
    
    Por ejemplo, --image debian-12-bookworm-v20241112.
  - Usa la marca --image-family IMAGE_FAMILY_NAME para especificar una familia de imágenes.
    
    De esta forma, se crea la VM a partir de la imagen de SO más reciente y no obsoleta de la familia de imágenes. Por ejemplo, si especificas --image-family debian-12, Compute Engine usa la versión más reciente de la imagen del SO en la familia de imágenes de Debian 12.
- MACHINE_TYPE: tipo de máquina de la nueva VM, que puede ser un tipo de máquina predefinido o un tipo de máquina personalizado.
  
  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.
Comprueba que Compute Engine haya creado la VM:
```
gcloud compute instances describe VM_NAME
```
Sustituye VM_NAME por el nombre de la VM.

Terraform

Para crear una VM, puedes usar el google_compute_instance recurso.


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

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

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

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

Para saber cómo aplicar o quitar una configuración de Terraform, consulta Comandos básicos de Terraform.

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

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

C#


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

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

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

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

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

Go

import (
	"context"
	"fmt"
	"io"

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

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

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

	req := &computepb.InsertInstanceRequest{
		Project: projectID,
		Zone:    zone,
		InstanceResource: &computepb.Instance{
			Name: proto.String(instanceName),
			Disks: []*computepb.AttachedDisk{
				{
					InitializeParams: &computepb.AttachedDiskInitializeParams{
						DiskSizeGb:  proto.Int64(10),
						SourceImage: proto.String(sourceImage),
					},
					AutoDelete: proto.Bool(true),
					Boot:       proto.Bool(true),
					Type:       proto.String(computepb.AttachedDisk_PERSISTENT.String()),
				},
			},
			MachineType: proto.String(fmt.Sprintf("zones/%s/machineTypes/%s", zone, machineType)),
			NetworkInterfaces: []*computepb.NetworkInterface{
				{
					Name: proto.String(networkName),
				},
			},
		},
	}

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

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

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

	return nil
}

Java


import com.google.api.gax.longrunning.OperationFuture;
import com.google.cloud.compute.v1.AttachedDisk;
import com.google.cloud.compute.v1.AttachedDisk.Type;
import com.google.cloud.compute.v1.AttachedDiskInitializeParams;
import com.google.cloud.compute.v1.InsertInstanceRequest;
import com.google.cloud.compute.v1.Instance;
import com.google.cloud.compute.v1.InstancesClient;
import com.google.cloud.compute.v1.NetworkInterface;
import com.google.cloud.compute.v1.Operation;
import java.io.IOException;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.TimeoutException;

public class CreateInstance {

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


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

    // Initialize client that will be used to send requests. This client only needs to be created
    // once, and can be reused for multiple requests. After completing all of your requests, call
    // the `instancesClient.close()` method on the client to safely
    // clean up any remaining background resources.
    try (InstancesClient instancesClient = InstancesClient.create()) {
      // Instance creation requires at least one persistent disk and one network interface.
      AttachedDisk disk =
          AttachedDisk.newBuilder()
              .setBoot(true)
              .setAutoDelete(true)
              .setType(Type.PERSISTENT.toString())
              .setDeviceName("disk-1")
              .setInitializeParams(
                  AttachedDiskInitializeParams.newBuilder()
                      .setSourceImage(sourceImage)
                      .setDiskSizeGb(diskSizeGb)
                      .build())
              .build();

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

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

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

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

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

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

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

Node.js

/**
 * TODO(developer): Uncomment and replace these variables before running the sample.
 */
// const projectId = 'YOUR_PROJECT_ID';
// const zone = 'europe-central2-b'
// const instanceName = 'YOUR_INSTANCE_NAME'
// const machineType = 'n1-standard-1';
// const sourceImage = 'projects/debian-cloud/global/images/family/debian-11';
// const networkName = 'global/networks/default';

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

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

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

  const [response] = await instancesClient.insert({
    instanceResource: {
      name: instanceName,
      disks: [
        {
          // Describe the size and source image of the boot disk to attach to the instance.
          initializeParams: {
            diskSizeGb: '10',
            sourceImage,
          },
          autoDelete: true,
          boot: true,
          type: 'PERSISTENT',
        },
      ],
      machineType: `zones/${zone}/machineTypes/${machineType}`,
      networkInterfaces: [
        {
          // Use the network interface provided in the networkName argument.
          name: networkName,
        },
      ],
    },
    project: projectId,
    zone,
  });
  let operation = response.latestResponse;
  const operationsClient = new compute.ZoneOperationsClient();

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

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

createInstance();

PHP

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

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

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

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

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

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

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

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

Python

from __future__ import annotations

import re
import sys
from typing import Any
import warnings

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


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

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

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


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

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

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


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

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

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

    Returns:
        Whatever the operation.result() returns.

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

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

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

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

    return result


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

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

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

    if internal_ip:
        network_interface.network_i_p = internal_ip

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

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

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

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

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

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

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

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

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

    operation = instance_client.insert(request=request)

    wait_for_extended_operation(operation, "instance creation")

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

Ruby


require "google/cloud/compute/v1"

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

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

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

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

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

REST

Selecciona una imagen pública. Anota el nombre de la imagen o de la familia de imágenes y el nombre del proyecto que contiene la imagen.
Usa el método instances.insert para crear una VM a partir de una familia de imágenes o de una versión específica de una imagen de SO:
```
POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/zones/ZONE/instances

{
   "machineType":"zones/MACHINE_TYPE_ZONE/machineTypes/MACHINE_TYPE",
   "name":"VM_NAME",
   
   "disks":[
      {
         "initializeParams":{
            "sourceImage":"projects/IMAGE_PROJECT/global/images/IMAGE"
         },
         "boot":true
      }
   ],
   
   
   "networkInterfaces":[
      {
         "network":"global/networks/NETWORK_NAME"
      }
   ],
   
  
   "shieldedInstanceConfig":{
      "enableSecureBoot":"ENABLE_SECURE_BOOT"
   }
}
```
Haz los cambios siguientes:
- PROJECT_ID: ID del proyecto en el que se creará la VM.
- ZONE: zona en la que se creará la VM
- MACHINE_TYPE_ZONE: zona que contiene el tipo de máquina que se va a usar en la nueva VM.
- MACHINE_TYPE: tipo de máquina, predefinido o personalizado, para la nueva VM
- VM_NAME: nombre de la nueva VM
- IMAGE_PROJECT: proyecto que contiene la imagen
  Por ejemplo, si especificas debian-10 como familia de imágenes, especifica debian-cloud como proyecto de imagen.
- IMAGE: especifica una de las siguientes opciones:
  - IMAGE: una versión específica de una imagen pública
    
    Por ejemplo: "sourceImage": "projects/debian-cloud/global/images/debian-10-buster-v20200309"
  - IMAGE_FAMILY: una familia de imágenes
    
    De esta forma, se crea la VM a partir de la imagen del SO más reciente que no esté obsoleta. Por ejemplo, si especificas "sourceImage": "projects/debian-cloud/global/images/family/debian-10", Compute Engine crea una VM a partir de la versión más reciente de la imagen del SO de la familia de imágenes Debian 10.
- NETWORK_NAME: la red de VPC que quieres usar en la VM. Puedes especificar default para usar tu red predeterminada.
- ENABLE_SECURE_BOOT: Opcional: Si has elegido una imagen que admite las funciones de VM blindada, Compute Engine habilita de forma predeterminada el módulo de plataforma segura virtual (vTPM) y la monitorización de la integridad. En Compute Engine, Arranque seguro no está habilitado de forma predeterminada.
  
  Si especificas true en enableSecureBoot, Compute Engine crea una VM con las tres funciones de VM blindada habilitadas. Una vez que Compute Engine inicie tu VM, para modificar las opciones de VM blindada, debes detenerla.

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

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

Consola

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

Ir a Crear una instancia

Si se te solicita, selecciona tu proyecto y haz clic en Continuar. Aparecerá la página Crear una instancia y se mostrará el panel Configuración de la máquina.
En el panel Configuración de la máquina, haz lo siguiente:
1. En el campo Nombre, especifica un nombre para la instancia. Para obtener más información, consulta el artículo Convenciones para asignar nombres de recursos.
2. Opcional: En el campo Zona, selecciona una zona para esta instancia. Si eliges una zona que no tiene ningún servidor bare metal disponible, se te pedirá que elijas otra.
  
  La selección predeterminada es Cualquiera. Si no cambias esta selección predeterminada, Google elegirá automáticamente una zona en función del tipo de máquina y la disponibilidad.
3. Selecciona la familia y la serie de tu máquina de una de las siguientes formas:
  - En el caso de la serie de metal desnudo C3, selecciona Uso general como familia de máquinas y, a continuación, en la columna Serie, selecciona C3.
  - En el caso de las series de hardware desnudo X4, selecciona Optimizado para memoria como familia de máquinas y, a continuación, en la columna Serie, selecciona X4.
4. En la sección Tipo de máquina, haz clic en la lista. En el menú de filtros, escriba metal y, a continuación, seleccione uno de los tipos de máquina disponibles.
En el menú de navegación, haz clic en SO y almacenamiento. En el panel Sistema operativo y almacenamiento que aparece, configura el disco de arranque haciendo lo siguiente:
1. Haz clic en Cambiar. Aparece el panel Disco de arranque y se muestra la pestaña Imágenes públicas.
2. En la lista Sistema operativo, selecciona el tipo de SO.
3. En la lista Versión, selecciona la versión del SO.
4. En la lista Tipo de disco de arranque, selecciona el tipo de disco de arranque.
5. En el campo Tamaño (GB), especifica el tamaño del disco de arranque.
6. Opcional: En el caso de los discos de arranque Hyperdisk Balanced, especifica valores en los campos IOPS aprovisionadas y Rendimiento aprovisionado.
7. Opcional: Para ver las opciones de configuración avanzada, despliega la sección Mostrar configuraciones avanzadas.
8. Para confirmar las opciones del disco de arranque y volver al panel Sistema operativo y almacenamiento, haz clic en Seleccionar.
  
  Nota: A menos que elijas explícitamente otro disco de arranque, si el nombre de la nueva instancia coincide con el de un disco, este se adjuntará automáticamente a la nueva instancia como disco de arranque.
En el menú de navegación, haga clic en Redes. En el panel Redes que aparece, haz lo siguiente:
1. Ve a la sección Cortafuegos.
2. Para permitir el tráfico HTTP o HTTPS a la instancia, selecciona Permitir el tráfico HTTP o Permitir el tráfico HTTPS.
  
  Compute Engine añade una etiqueta de red a tu instancia y crea la regla de cortafuegos de entrada correspondiente que permite todo el tráfico entrante en tcp:80 (HTTP) o tcp:443 (HTTPS). La etiqueta de red asocia la regla de cortafuegos con la instancia. Para obtener más información, consulta el resumen de las reglas de cortafuegos en la documentación de Cloud Next Generation Firewall.
3. En la sección Configuración del rendimiento de la red, comprueba que el campo Tarjeta de interfaz de red esté definido como IDPF.
En el menú de navegación, haz clic en Opciones avanzadas. En el panel Avanzado que aparece, haz lo siguiente:
1. Despliega la sección Configuración avanzada del modelo de aprovisionamiento de la VM. Comprueba que el campo Mantenimiento del host esté configurado como Terminate instance.
Opcional. Especifique cualquier otro parámetro de configuración que quiera. Para obtener más información sobre las opciones de configuración personalizadas, consulta Crear e iniciar una instancia.
Para crear e iniciar la instancia de hardware desnudo, haz clic en Crear.

gcloud

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

REST

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

Siguientes pasos

Consulta más información sobre las imágenes.
Consulta cómo comprobar el estado de una instancia para saber cuándo está lista para usarse.
Consulta cómo conectarte a tu instancia.

Crear una instancia a partir de una imagen pública Organízate con las colecciones Guarda y clasifica el contenido según tus preferencias.

Antes de empezar

Console

gcloud

REST

Roles obligatorios

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

Consola

gcloud

C#

Go

Java

Node.js

PHP

Python

Ruby

REST

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

Consola

gcloud

Terraform

C#

C#

Go

Go

Java

Node.js

PHP

Python

Ruby

REST

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

Consola

gcloud

REST

Siguientes pasos

Crear una instancia a partir de una imagen pública