Questa pagina è stata tradotta dall'API Cloud Translation.

Crea e avvia un'istanza Compute Engine

Questo documento spiega come creare un'istanza di macchina virtuale (VM) o bare metal utilizzando un'immagine disco di avvio, uno snapshot del disco di avvio o un'immagine container. Alcune immagini supportano le funzionalità delle VM schermate, che offrono funzionalità di sicurezza come firmware compatibile con UEFI, avvio protetto e avvio con misurazioni protetto da vTPM. Nelle VM schermate, vTPM e il monitoraggio dell'integrità sono abilitati per impostazione predefinita.

Durante la creazione dell'istanza di calcolo, puoi creare uno o più dischi. Puoi anche aggiungere altri dischi all'istanza dopo la sua creazione. Compute Engine avvia automaticamente l'istanza dopo la creazione.

Durante la creazione di un'istanza di calcolo, puoi anche aggiungere più interfacce di rete. Per ridurre l'esposizione dell'istanza alle minacce su internet, puoi omettere l'indirizzo IP esterno quando aggiungi un'interfaccia di rete all'istanza. In questi casi, l'istanza è accessibile solo da altre istanze di calcolo nella stessa rete VPC o in una rete collegata, a meno che non configuri Cloud NAT.

Se stai creando un'istanza di calcolo per la prima volta, consulta la guida rapida all'utilizzo di una VM Linux o la guida rapida all'utilizzo di una VM Windows Server.

Per la creazione di istanze Compute Engine più specifiche o complesse, consulta le seguenti risorse:

Se utilizzi una licenza esistente, consulta Utilizzo del modello Bring Your Own License.

Prima di iniziare

Quando crei istanze di calcolo da immagini o dischi utilizzando Google Cloud CLI o REST, esiste un limite di 20 istanze al secondo. Se devi creare un numero maggiore di istanze al secondo, richiedi un limite di quota più alto per la risorsa Immagini.
Se non l'hai ancora fatto, configura l'autenticazione. L'autenticazione è la procedura mediante la quale la tua identità viene verificata per l'accesso alle API e ai servizi Google Cloud. Per eseguire codice o esempi da un ambiente di sviluppo locale, puoi autenticarti su Compute Engine selezionando una delle seguenti opzioni:

Select the tab for how you plan to use the samples on this page:
Console

When you use the Google Cloud console to access Google Cloud services and APIs, you don't need to set up authentication.
gcloud
1. Install the Google Cloud CLI, then initialize it by running the following command:
  gcloud init
  Note: If you installed the gcloud CLI previously, make sure you have the latest version by running gcloud components update.
2. Set a default region and zone.

Ruoli obbligatori

Per ottenere le autorizzazioni necessarie per creare VM, chiedi all'amministratore di concederti il ruolo IAM Amministratore istanze Compute (v1) (roles/compute.instanceAdmin.v1) nel progetto. Per saperne di più sulla concessione dei ruoli, consulta Gestire l'accesso a progetti, cartelle e organizzazioni.

Questo ruolo predefinito contiene le autorizzazioni necessarie per creare VM. Per visualizzare le autorizzazioni esatte richieste, espandi la sezione Autorizzazioni richieste:

Autorizzazioni obbligatorie

Per creare VM sono necessarie le seguenti autorizzazioni:

compute.instances.create sul progetto
Per utilizzare un'immagine personalizzata per creare la VM: compute.images.useReadOnly sull'immagine
Per utilizzare uno snapshot per creare la VM: compute.snapshots.useReadOnly sullo snapshot
Per utilizzare un modello di istanza per creare la VM: compute.instanceTemplates.useReadOnly nel modello di istanza
Per assegnare una rete legacy alla VM: compute.networks.use nel progetto
Per specificare un indirizzo IP statico per la VM: compute.addresses.use nel progetto
Per assegnare un indirizzo IP esterno alla VM quando utilizzi una rete legacy: compute.networks.useExternalIp nel progetto
Per specificare una subnet per la VM: compute.subnetworks.use nel progetto o nella subnet scelta
Per assegnare un indirizzo IP esterno alla VM quando utilizzi una rete VPC: compute.subnetworks.useExternalIp nel progetto o nella subnet scelta
Per impostare i metadati dell'istanza VM per la VM: compute.instances.setMetadata nel progetto
Per impostare i tag per la VM: compute.instances.setTags sulla VM
Per impostare le etichette per la VM: compute.instances.setLabels sulla VM
Per impostare un account di servizio da utilizzare per la VM: compute.instances.setServiceAccount sulla VM
Per creare un nuovo disco per la VM: compute.disks.create nel progetto
Per collegare un disco esistente in modalità di sola lettura o di lettura e scrittura: compute.disks.use sul disco
Per collegare un disco esistente in modalità di sola lettura: compute.disks.useReadOnly sul disco

Potresti anche ottenere queste autorizzazioni con ruoli personalizzati o altri ruoli predefiniti.

Creare un'istanza VM da un'immagine

Questa sezione spiega come creare una VM da un'immagine del sistema operativo pubblico o da un'immagine personalizzata. Una VM contiene un bootloader, un file system di avvio e un'immagine del sistema operativo. Se stai creando una VM Arm, scegli un'immagine del sistema operativo compatibile con Arm.

Visualizzare un elenco di immagini pubbliche disponibili su Compute Engine

Prima di creare una VM utilizzando un'immagine pubblica, controlla l'elenco delle immagini pubbliche disponibili su Compute Engine.

Per saperne di più sulle funzionalità disponibili con ogni immagine pubblica, consulta Supporto delle funzionalità in base al sistema operativo.

Console

Nella console Google Cloud, vai alla pagina Immagini.

Vai a Immagini

gcloud

Esegui questo comando:
```
gcloud compute images list
```
Prendi nota del nome dell'immagine o della famiglia di immagini e del nome del progetto contenente l'immagine.
(Facoltativo) Per determinare se l'immagine supporta le funzionalità della VM protetta, esegui il seguente comando:
```
gcloud compute images describe IMAGE_NAME \
    --project=IMAGE_PROJECT
```
Sostituisci quanto segue:
- IMAGE_NAME: il nome dell'immagine per verificare il supporto delle funzionalità delle Shielded VM
- IMAGE_PROJECT: project contenente l'immagine
Se l'immagine supporta le funzionalità Shielded VM, nell'output viene visualizzata la seguente riga: type: UEFI_COMPATIBLE.

C#

Prima di provare questo esempio, segui le istruzioni di configurazione di C# nella guida rapida di Compute Engine che utilizza le librerie client. Per ulteriori informazioni, consulta la documentazione di riferimento dell'API Compute Engine C#.

Per autenticarti a Compute Engine, configura le Credenziali predefinite dell'applicazione. Per ulteriori informazioni, consulta Configurare l'autenticazione per un ambiente di sviluppo locale.


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

Vai

Prima di provare questo esempio, segui le istruzioni di configurazione di Go nella guida rapida di Compute Engine che utilizza le librerie client. Per ulteriori informazioni, consulta la documentazione di riferimento dell'API Compute Engine Go.

Per autenticarti a Compute Engine, configura le Credenziali predefinite dell'applicazione. Per ulteriori informazioni, consulta Configurare l'autenticazione per un ambiente di sviluppo locale.

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

Prima di provare questo esempio, segui le istruzioni di configurazione di Java nella guida rapida di Compute Engine che utilizza le librerie client. Per ulteriori informazioni, consulta la documentazione di riferimento dell'API Compute Engine Java.

Per autenticarti a Compute Engine, configura le Credenziali predefinite dell'applicazione. Per ulteriori informazioni, consulta Configurare l'autenticazione per un ambiente di sviluppo locale.


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

Prima di provare questo esempio, segui le istruzioni di configurazione di Node.js nella guida rapida di Compute Engine che utilizza le librerie client. Per ulteriori informazioni, consulta la documentazione di riferimento dell'API Compute Engine Node.js.

Per autenticarti a Compute Engine, configura le Credenziali predefinite dell'applicazione. Per ulteriori informazioni, consulta Configurare l'autenticazione per un ambiente di sviluppo locale.

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

Prima di provare questo esempio, segui le istruzioni di configurazione di PHP nella guida rapida di Compute Engine che utilizza le librerie client. Per ulteriori informazioni, consulta la documentazione di riferimento dell'API Compute Engine PHP.

Per autenticarti a Compute Engine, configura le Credenziali predefinite dell'applicazione. Per ulteriori informazioni, consulta Configurare l'autenticazione per un ambiente di sviluppo locale.

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

Prima di provare questo esempio, segui le istruzioni di configurazione di Python nella guida rapida di Compute Engine che utilizza le librerie client. Per ulteriori informazioni, consulta la documentazione di riferimento dell'API Compute Engine Python.

Per autenticarti a Compute Engine, configura le Credenziali predefinite dell'applicazione. Per ulteriori informazioni, consulta Configurare l'autenticazione per un ambiente di sviluppo locale.

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

Prima di provare questo esempio, segui le istruzioni di configurazione di Ruby nella guida rapida di Compute Engine che utilizza le librerie client. Per ulteriori informazioni, consulta la documentazione di riferimento dell'API Compute Engine Ruby.

Per autenticarti a Compute Engine, configura le Credenziali predefinite dell'applicazione. Per ulteriori informazioni, consulta Configurare l'autenticazione per un ambiente di sviluppo locale.


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

Esegui questo comando:

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

Prendi nota del nome dell'immagine o della famiglia di immagini e del nome del progetto contenente l'immagine.
(Facoltativo) Per determinare se l'immagine supporta le funzionalità della VM protetta, esegui il seguente comando:
```
GET https://compute.googleapis.com/compute/v1/projects/IMAGE_PROJECT/global/images/IMAGE_NAME
```
Sostituisci quanto segue:
- IMAGE_PROJECT: project contenente l'immagine
- IMAGE_NAME: il nome dell'immagine per verificare il supporto delle funzionalità delle Shielded VM
Se l'immagine supporta le funzionalità Shielded VM, nell'output viene visualizzata la seguente riga: type: UEFI_COMPATIBLE.

Creare un'istanza VM da un'immagine pubblica

Google, le community open source e i fornitori di terze parti forniscono e gestiscono immagini del sistema operativo pubblico. Per impostazione predefinita, tutti i progetti Google Cloud possono creare VM da immagini del sistema operativo pubblico. Tuttavia, se il tuo progetto Google Cloud ha un elenco definito di immagini attendibili, puoi utilizzare solo le immagini presenti nell'elenco per creare una VM.

Se crei un'immagine Shielded VM con un'unità SSD locale, non puoi proteggere i dati con il monitoraggio dell'integrità o con il modulo della piattaforma attendibile virtuale (vTPM).

Console

Nella console Google Cloud, vai alla pagina Istanze VM.

Vai a Istanze VM
Seleziona il progetto e fai clic su Continua.
Fai clic su Crea istanza.
Specifica un nome per la VM. Per ulteriori informazioni, consulta la convenzione di denominazione delle risorse.
(Facoltativo) Modifica la Zona per questa VM. Se selezioni Qualsiasi, Google sceglie automaticamente una zona in base al tipo di macchina e alla disponibilità.
Seleziona una configurazione della macchina per la VM.
Nella sezione Disco di avvio, fai clic su Cambia e poi:
1. Nella scheda Immagini pubbliche, scegli quanto segue:
  - Sistema operativo
  - Versione sistema operativo
  - Tipo di disco di avvio
  - Dimensione del disco di avvio
2. (Facoltativo) Per le opzioni di configurazione avanzata, fai clic su Mostra configurazione avanzata.
3. Per confermare le opzioni del disco di avvio, fai clic su Seleziona.
Nota: a meno che tu non scelga esplicitamente un disco di avvio diverso, se il nome della nuova VM corrisponde al nome di un disco permanente esistente, il disco permanente esistente viene collegato automaticamente alla nuova VM come disco di avvio.
Nella sezione Firewall, per consentire il traffico HTTP o HTTPS alla VM, seleziona Consenti traffico HTTP o Consenti traffico HTTPS. Quando selezioni una di queste opzioni, Compute Engine aggiunge un tag di rete alla VM, che associa la regola del firewall alla VM. Quindi, Compute Engine crea la corrispondente regola del firewall in entrata che consente tutto il traffico entrante su tcp:80 (HTTP) o tcp:443 (HTTPS).
(Facoltativo) Se hai scelto un'immagine del sistema operativo che supporta le funzionalità di Shielded VM, puoi modificare le impostazioni di Shielded VM. Per modificare le impostazioni Shielded VM, espandi la sezione Sicurezza nella sezione Opzioni avanzate, quindi procedi come segue, a seconda dei casi:
- Per attivare l'avvio protetto, seleziona Attiva Avvio protetto. L'avvio protetto è disattivato per impostazione predefinita.
- Per disattivare il vTPM, deseleziona la casella di controllo Attiva vTPM. Il vTPM è abilitato per impostazione predefinita. La disattivazione di vTPM disattiva anche il monitoraggio dell'integrità perché si basa sui dati raccolti da Avvio con misurazioni.
- Per disattivare il monitoraggio dell'integrità, deseleziona la casella di controllo Attiva il monitoraggio dell'integrità. Il monitoraggio dell'integrità è abilitato per impostazione predefinita.
Per creare e avviare la VM, fai clic su Crea.

gcloud

Seleziona un'immagine pubblica. Prendi nota del nome dell'immagine o della famiglia di immagini e del nome del progetto contenente l'immagine.
Utilizza il comando gcloud compute instances create per creare una VM da una famiglia di immagini o da una versione specifica di un'immagine del sistema operativo.

Se specifichi il flag facoltativo --shielded-secure-boot, Compute Engine crea una VM con tutte e tre le funzionalità di VM protetta attivate:
Dopo che Compute Engine ha avviato la VM, devi arrestarla per modificare le opzioni della VM protetta.
```
gcloud compute instances create VM_NAME \
    --zone=ZONE \
    [--image=IMAGE | --image-family=IMAGE_FAMILY] \
    --image-project=IMAGE_PROJECT \
    --machine-type=MACHINE_TYPE
```
Sostituisci quanto segue:
- VM_NAME: nome della nuova VM
- ZONE: la zona in cui creare l'istanza
- IMAGE o IMAGE_FAMILY: specifica una delle seguenti opzioni:
  - IMAGE: una versione specifica di un'immagine pubblica
    
    Ad esempio, --image=debian-10-buster-v20200309.
  - IMAGE_FAMILY: una famiglia di immagini.
    
    In questo modo viene creata la VM dall'immagine del sistema operativo più recente e non ritirata. Ad esempio, se specifichi --image-family=debian-10, Compute Engine crea una VM dalla versione più recente dell'immagine del sistema operativo nella famiglia di immagini Debian 10.
- IMAGE_PROJECT: project contenente l'immagine
- MACHINE_TYPE: tipo di macchina, predefinito o personalizzato, per la nuova VM
  
  Per ottenere un elenco dei tipi di macchine disponibili in una zona, utilizza il comando gcloud compute machine-types list con il flag --zones.
Verifica che Compute Engine abbia creato la VM:
```
gcloud compute instances describe VM_NAME
```
Sostituisci VM_NAME con il nome della VM.

Terraform

Per creare una VM, puoi utilizzare la google_compute_instance risorsa.


# 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 {}
  }
}

Per scoprire come applicare o rimuovere una configurazione Terraform, consulta Comandi Terraform di base.

Per generare il codice Terraform, puoi utilizzare il componente Codice equivalente nella console Google Cloud.

Nella console Google Cloud, vai alla pagina Istanze VM.
Vai a Istanze VM
Fai clic su Crea istanza.
Specifica i parametri che preferisci.
Nella parte superiore o inferiore della pagina, fai clic su Codice equivalente e poi sulla scheda Terraform per visualizzare il codice Terraform.

C#

Per autenticarti a Compute Engine, configura le Credenziali predefinite dell'applicazione. Per ulteriori informazioni, consulta Configurare l'autenticazione per un ambiente di sviluppo locale.


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

Vai

Go

Per autenticarti a Compute Engine, configura le Credenziali predefinite dell'applicazione. Per ulteriori informazioni, consulta Configurare l'autenticazione per un ambiente di sviluppo locale.

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

Per autenticarti a Compute Engine, configura le Credenziali predefinite dell'applicazione. Per ulteriori informazioni, consulta Configurare l'autenticazione per un ambiente di sviluppo locale.


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

Per autenticarti a Compute Engine, configura le Credenziali predefinite dell'applicazione. Per ulteriori informazioni, consulta Configurare l'autenticazione per un ambiente di sviluppo locale.

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

Per autenticarti a Compute Engine, configura le Credenziali predefinite dell'applicazione. Per ulteriori informazioni, consulta Configurare l'autenticazione per un ambiente di sviluppo locale.

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

Per autenticarti a Compute Engine, configura le Credenziali predefinite dell'applicazione. Per ulteriori informazioni, consulta Configurare l'autenticazione per un ambiente di sviluppo locale.

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

Per autenticarti a Compute Engine, configura le Credenziali predefinite dell'applicazione. Per ulteriori informazioni, consulta Configurare l'autenticazione per un ambiente di sviluppo locale.


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

Seleziona un'immagine pubblica. Prendi nota del nome dell'immagine o della famiglia di immagini e del nome del progetto contenente l'immagine.
Utilizza il metodo instances.insert per creare una VM da una famiglia di immagini o da una versione specifica di un'immagine del sistema operativo:
```
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"
   }
}
```
Sostituisci quanto segue:
- PROJECT_ID: ID del progetto in cui creare la VM
- ZONE: la zona in cui creare la VM
- MACHINE_TYPE_ZONE: zona contenente il tipo di macchina da utilizzare per la nuova VM
- MACHINE_TYPE: tipo di macchina, predefinito o personalizzato, per la nuova VM
- VM_NAME: nome della nuova VM
- IMAGE_PROJECT: project contenente l'immagine
  Ad esempio, se specifichi debian-10 come famiglia di immagini, specifica debian-cloud come progetto di immagini.
- IMAGE or IMAGE_FAMILY: specifica una delle seguenti opzioni:
  - IMAGE: una versione specifica di un'immagine pubblica
    Ad esempio, "sourceImage": "projects/debian-cloud/global/images/debian-10-buster-v20200309"
  - IMAGE_FAMILY: una famiglia di immagini
    . Viene creata la VM dall'immagine del sistema operativo più recente e non ritirata. Ad esempio, se specifichi "sourceImage": "projects/debian-cloud/global/images/family/debian-10", Compute Engine crea una VM dalla versione più recente dell'immagine del sistema operativo nella famiglia di immagini Debian 10.
- NETWORK_NAME: la rete VPC che vuoi utilizzare per la VM. Puoi specificare default per utilizzare la rete predefinita.
- ENABLE_SECURE_BOOT: facoltativo: se hai scelto un'immagine che supporta le funzionalità di VM schermate, Compute Engine attiva per impostazione predefinita il Trusted Platform Module virtuale (vTPM) e il monitoraggio dell'integrità. Compute Engine non abilita l'Avvio protetto per impostazione predefinita.
  
  Se specifichi true per enableSecureBoot, Compute Engine crea una VM con tutte e tre le funzionalità Shielded VM abilitate. Dopo che Compute Engine ha avviato la VM, per modificare le opzioni della VM protetta, devi arrestarla.

Creare un'istanza bare metal da un'immagine pubblica

Google, le community open source e i fornitori di terze parti forniscono e gestiscono immagini del sistema operativo pubblico. Per impostazione predefinita, tutti i progetti Google Cloud possono creare istanze bare metal utilizzando le immagini del sistema operativo pubblico supportate. Tuttavia, se il tuo progetto Google Cloud ha un elenco definito di immagini attendibili, puoi utilizzare solo le immagini in questo elenco per creare un'istanza bare metal.

Console

Nella console Google Cloud, vai alla pagina Istanze VM.

Vai a Istanze VM
Seleziona il progetto e fai clic su Continua.
Fai clic su Crea istanza.
Specifica un nome per l'istanza. Per ulteriori informazioni, consulta la convenzione di denominazione delle risorse.
(Facoltativo) Modifica la Zona per questa istanza. Se scegli una zona in cui non sono disponibili server bare metal, ti viene chiesto di scegliere un'altra zona.
Nella sezione Configurazione macchina, esegui una delle seguenti operazioni:
- Fai clic sulla scheda Uso generico e seleziona C3.
- Fai clic sulla scheda Ottimizzata per la memoria e seleziona X4.
Per Tipo di macchina, fai clic sull'elenco. Nella casella del filtro, digita metal e seleziona uno dei tipi disponibili.
Nella sezione Criteri di disponibilità, fai clic su Impostazioni avanzate del modello di provisioning delle VM per espandere la sezione. Assicurati che il valore di Host in manutenzione sia Terminate instance.
Nella sezione Disco di avvio, fai clic su Cambia e poi:
1. Nella scheda Immagini pubbliche, scegli quanto segue:
  - Sistema operativo
  - Versione sistema operativo
  - Tipo di disco di avvio
  - Dimensione del disco di avvio
  - (Facoltativo) Per i dischi di avvio Hyperdisk bilanciati, scegli le impostazioni IOPS sottoposte a provisioning e Throughput riservato per il disco.
2. (Facoltativo) Per ulteriori opzioni di configurazione del disco, fai clic su Mostra configurazione avanzata.
3. Per confermare le opzioni del disco di avvio, fai clic su Seleziona.
  
  Nota: a meno che tu non scelga esplicitamente un disco di avvio diverso, se il nome della nuova istanza corrisponde al nome di un disco esistente, il disco esistente viene collegato automaticamente alla nuova istanza come disco di avvio.
Nella sezione Firewall, per consentire il traffico HTTP o HTTPS all'istanza bare metal, seleziona Consenti traffico HTTP o Consenti traffico HTTPS. Quando selezioni una di queste opzioni, Compute Engine aggiunge un tag di rete all'istanza, che associa la regola del firewall all'istanza. Quindi, Compute Engine crea la regola firewall in entrata corrispondente che consente tutto il traffico in entrata su tcp:80 (HTTP) o tcp:443 (HTTPS).
Espandi la sezione Opzioni avanzate e poi la sezione Networking. Assicurati che la scheda di interfaccia di rete sia impostata su IDPF.
Per creare e avviare l'istanza bare metal, fai clic su Crea.

gcloud

Seleziona un'immagine pubblica che supporti le istanze bare metal. Prendi nota del nome dell'immagine o della famiglia di immagini e del nome del progetto contenente l'immagine.
Utilizza il comando gcloud compute instances create per creare un'istanza bare metal da una famiglia di immagini o da una versione specifica di un'immagine del sistema operativo.
```
gcloud compute instances create INSTANCE_NAME \
    --zone=ZONE \
    --machine-type=MACHINE_TYPE \
    --network-interface=nic-type=IDPF \
    --maintenance-policy=TERMINATE \
    --create-disk=boot=yes,image=projects/IMAGE_PROJECT/global/images/IMAGE,provisioned-iops=IOPS,provisioned-throughput=THROUGHPUT,size=SIZE,type=hyperdisk-balanced \
    --no-shielded-secure-boot
```
Sostituisci quanto segue:
- INSTANCE_NAME: un nome per la nuova istanza bare metal
- ZONE: la zona in cui creare l'istanza bare metal
- MACHINE_TYPE: il tipo di macchina bare metal da utilizzare per l'istanza. Il nome del tipo di macchina deve terminare con -metal.
  
  Per ottenere un elenco dei tipi di macchine disponibili in una zona, utilizza il comando gcloud compute machine-types list con il flag --zones.
- IMAGE_PROJECT: il progetto di immagini che contiene l'immagine
- IMAGE: specifica una delle seguenti opzioni:
  - Una versione specifica dell'immagine del sistema operativo, ad esempio sles-15-sp4-sap-v20240208-x86-6.
  - Una famiglia di immagini, che deve essere formattata come family/IMAGE_FAMILY. In questo modo viene creata l'istanza dall'immagine del sistema operativo più recente e non deprecata. Ad esempio, se specifichi family/sles-15-sp4-sap, Compute Engine crea un'istanza bare metal dalla versione più recente dell'immagine del sistema operativo nella famiglia di immagini SUSE Linux Enterprise Server 15 SP4. Per maggiori informazioni sull'utilizzo delle famiglie di immagini, consulta le best practice per le famiglie di immagini.
- IOPS: facoltativo: il numero più elevato di operazioni di I/O al secondo (IOPS) che il disco può gestire.
- THROUGHPUT: facoltativo, un numero intero che rappresenta la velocità effettiva massima, misurata in MiB al secondo, che il disco può gestire.
- SIZE: facoltativo, le dimensioni del nuovo disco. Il valore deve essere un numero intero. L'unità di misura predefinita è GiB.
Verifica che Compute Engine abbia creato l'istanza:
```
gcloud compute instances describe INSTANCE_NAME
```
Sostituisci INSTANCE_NAME con il nome della nuova istanza.

REST

Seleziona un'immagine pubblica che supporti le istanze bare metal. Prendi nota del nome dell'immagine o della famiglia di immagini e del nome del progetto contenente l'immagine.
Utilizza il metodo instances.insert per creare un'istanza bare metal da una famiglia di immagini o da una versione specifica di un'immagine del sistema operativo:
```
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"
 }
}
```
Sostituisci quanto segue:
- PROJECT_ID: ID del progetto in cui creare l'istanza bare metal
- ZONE: la zona in cui creare l'istanza bare metal
- MACHINE_TYPE_ZONE: la zona contenente il tipo di macchina da utilizzare per la nuova istanza bare metal
- MACHINE_TYPE: il tipo di macchina da usare per l'istanza. Il nome del tipo di macchina deve terminare con -metal.
- INSTANCE_NAME: nome della nuova istanza
- DISK_SIZE: dimensioni del disco in GiB
- IOPS_LIMIT: il numero di operazioni di I/O al secondo che vuoi eseguire il provisioning per il disco.
- THROUGHPUT_LIMIT: un numero intero che rappresenta il throughput, misurato in MB al secondo, che vuoi eseguire il provisioning per il disco.
- IMAGE_PROJECT: il progetto di immagini che contiene l'immagine
- IMAGE: specifica una delle seguenti opzioni:
  - Una versione specifica dell'immagine del sistema operativo, ad esempio sles-15-sp4-sap-v20240208-x86-6.
  - Una famiglia di immagini, che deve essere formattata come family/IMAGE_FAMILY. In questo modo viene creata l'istanza dall'immagine del sistema operativo più recente e non deprecata. Ad esempio, se specifichi family/sles-15-sp4-sap, Compute Engine crea un'istanza bare metal dalla versione più recente dell'immagine del sistema operativo nella famiglia di immagini SUSE Linux Enterprise Server 15 SP4. Per maggiori informazioni sull'utilizzo delle famiglie di immagini, consulta le best practice per le famiglie di immagini.

Creare una VM da un'immagine personalizzata

Un'immagine personalizzata appartiene solo al tuo progetto. Per creare una VM con un'immagine personalizzata, devi prima crearla se non ne hai già una.

Console

Nella console Google Cloud, vai alla pagina Istanze VM.

Vai a Istanze VM
Seleziona il progetto e fai clic su Continua.
Fai clic su Crea istanza.
Specifica un nome per la VM. Per ulteriori informazioni, consulta la convenzione di denominazione delle risorse.
(Facoltativo) Modifica la Zona per questa VM. Se selezioni Qualsiasi, Google sceglie automaticamente una zona in base al tipo di macchina e alla disponibilità.
Seleziona una configurazione della macchina per la VM.
Nella sezione Disco di avvio, fai clic su Cambia e poi:
1. Seleziona la scheda Immagini personalizzate.
2. Per selezionare il progetto di immagini, fai clic su Seleziona un progetto, quindi svolgi i seguenti passaggi:
  1. Seleziona il progetto che contiene l'immagine.
  2. Fai clic su Apri.
3. Nell'elenco Immagine, fai clic sull'immagine che vuoi importare.
4. Seleziona il tipo e le dimensioni del disco di avvio.
5. (Facoltativo) Per le opzioni di configurazione avanzata, fai clic su Mostra configurazione avanzata.
6. Per confermare le opzioni del disco di avvio, fai clic su Seleziona.
Nella sezione Firewall, per consentire il traffico HTTP o HTTPS alla VM, seleziona Consenti traffico HTTP o Consenti traffico HTTPS.

La console Google Cloud aggiunge un tag di rete alla VM e crea la regola del firewall di ingresso corrispondente che consente tutto il traffico in entrata su tcp:80 (HTTP) o tcp:443 (HTTPS). Il tag network associa la regola firewall alla VM. Per ulteriori informazioni, consulta la Panoramica delle regole firewall nella documentazione di Cloud Next Generation Firewall.
Per creare e avviare la VM, fai clic su Crea.

gcloud

In the Google Cloud console, activate Cloud Shell.

Activate Cloud Shell

At the bottom of the Google Cloud console, a Cloud Shell session starts and displays a command-line prompt. Cloud Shell is a shell environment with the Google Cloud CLI already installed and with values already set for your current project. It can take a few seconds for the session to initialize.
Esegui il comando gcloud compute instances create per creare una VM con un'immagine personalizzata:
```
gcloud compute instances create VM_NAME \
    --image-project IMAGE_PROJECT \
    [--image IMAGE | --image-family IMAGE_FAMILY]
    --subnet SUBNET
```
Sostituisci quanto segue:
- VM_NAME: il nome della VM
- IMAGE_PROJECT: l'ID progetto che contiene l'immagine
- IMAGE o IMAGE_FAMILY: specifica una delle seguenti opzioni:
  - IMAGE: nome dell'immagine personalizzata
    Ad esempio, --image=my-debian-image-v2.
  - IMAGE_FAMILY: se hai creato le immagini personalizzate all'interno di una famiglia di immagini personalizzate, specifica questa famiglia di immagini personalizzate.
    In questo modo viene creata la VM dall'immagine e dalla versione del sistema operativo più recenti e non deprecate nella famiglia di immagini personalizzate. Ad esempio, se specifichi --image-family=my-debian-family, Compute Engine crea una VM dall'immagine del sistema operativo più recente nella famiglia di immagini personalizzate my-debian-family.
  Nota: se non specifichi un'immagine, Compute Engine utilizza la famiglia di immagini e il progetto predefiniti. La famiglia di immagini e il progetto predefiniti sono debian-10 e debian-cloud, rispettivamente.
- SUBNET: se la subnet e l'istanza si trovano nello stesso progetto, sostituisci SUBNET con il nome di una subnet che si trova nella stessa regione dell'istanza.

Terraform

Per generare il codice Terraform, puoi utilizzare il componente Codice equivalente nella console Google Cloud.

Nella console Google Cloud, vai alla pagina Istanze VM.
Vai a Istanze VM
Fai clic su Crea istanza.
Specifica i parametri che preferisci.
Nella parte superiore o inferiore della pagina, fai clic su Codice equivalente e poi sulla scheda Terraform per visualizzare il codice Terraform.

Vai

Per autenticarti a Compute Engine, configura le Credenziali predefinite dell'applicazione. Per ulteriori informazioni, consulta Configurare l'autenticazione per un ambiente di sviluppo locale.

import (
	"context"
	"fmt"
	"io"

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

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

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

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

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

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

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

	return nil
}

Java

Per autenticarti a Compute Engine, configura le Credenziali predefinite dell'applicazione. Per ulteriori informazioni, consulta Configurare l'autenticazione per un ambiente di sviluppo locale.


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

public class CreateInstancesAdvanced {

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


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

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

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

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

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

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

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

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

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

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

Node.js

Per autenticarti a Compute Engine, configura le Credenziali predefinite dell'applicazione. Per ulteriori informazioni, consulta Configurare l'autenticazione per un ambiente di sviluppo locale.

/**
 * TODO(developer): Uncomment and replace these variables before running the sample.
 */
// const projectId = 'YOUR_PROJECT_ID';
// const zone = 'europe-central2-b';
// const instanceName = 'YOUR_INSTANCE_NAME';
// const customImageLink = 'projects/YOUR_PROJECT/global/images/YOUR_IMAGE_NAME';

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

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

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

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

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

createInstanceFromCustomImage();

Python

Per autenticarti a Compute Engine, configura le Credenziali predefinite dell'applicazione. Per ulteriori informazioni, consulta Configurare l'autenticazione per un ambiente di sviluppo locale.

from __future__ import annotations

import re
import sys
from typing import Any
import warnings

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


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

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

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


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

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

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


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

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

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

    Returns:
        Whatever the operation.result() returns.

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

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

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

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

    return result


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

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

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

    if internal_ip:
        network_interface.network_i_p = internal_ip

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

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

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

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

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

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

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

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

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

    operation = instance_client.insert(request=request)

    wait_for_extended_operation(operation, "instance creation")

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


def create_from_custom_image(
    project_id: str, zone: str, instance_name: str, custom_image_link: str
) -> compute_v1.Instance:
    """
    Create a new VM instance with custom image used as its boot disk.

    Args:
        project_id: project ID or project number of the Cloud project you want to use.
        zone: name of the zone to create the instance in. For example: "us-west3-b"
        instance_name: name of the new virtual machine (VM) instance.
        custom_image_link: link to the custom image you want to use in the form of:
            "projects/{project_name}/global/images/{image_name}"

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

REST

La procedura per creare una VM con un'immagine personalizzata nell'API è la stessa che se si creasse una VM con un'immagine disponibile pubblicamente.

Per creare la VM da un'immagine personalizzata, utilizza il metodo instances.insert.

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

{
   "machineType":"zones/MACHINE_TYPE_ZONE/machineTypes/MACHINE_TYPE",
   "name":"VM_NAME",
   
   "disks":[
      {
         "initializeParams":{
            "sourceImage":"projects/IMAGE_PROJECT/global/images/IMAGE"
         },
         "boot":true
      }
   ],
   
   
   "networkInterfaces":[
      {
         "network":"global/networks/NETWORK_NAME"
      }
   ],
   
  
   "shieldedInstanceConfig":{
      "enableSecureBoot":"ENABLE_SECURE_BOOT"
   }
}

Sostituisci quanto segue:

PROJECT_ID: ID del progetto in cui creare la VM
ZONE: la zona in cui creare la VM
MACHINE_TYPE_ZONE: zona contenente il tipo di macchina da utilizzare per la nuova VM
MACHINE_TYPE: tipo di macchina, predefinito o personalizzato, per la nuova VM
VM_NAME: nome della nuova VM
IMAGE_PROJECT: il nome del progetto che contiene l'immagine personalizzata
IMAGE o IMAGE_FAMILY: specifica una delle seguenti opzioni:
- IMAGE: il nome dell'immagine personalizzata. Ad esempio, "sourceImage": "projects/my-project-1234/global/images/my-debian-image-v2".
- IMAGE_FAMILY: se hai creato le immagini personalizzate all'interno di una famiglia di immagini personalizzate, specifica questa famiglia di immagini personalizzate.
  In questo modo viene creata la VM dall'immagine del sistema operativo più recente e non deprecata nella famiglia di immagini personalizzate. Ad esempio, se specifichi "sourceImage": "projects/my-project-1234/global/images/family/my-debian-family", Compute Engine crea una VM dalla versione più recente dell'immagine del sistema operativo nella famiglia di immagini personalizzata my-debian-family.
NETWORK_NAME: la rete VPC che vuoi utilizzare per la VM. Puoi specificare default per utilizzare la rete predefinita.
ENABLE_SECURE_BOOT: facoltativo: se hai scelto un'immagine che supporta le funzionalità di VM schermate, Compute Engine attiva per impostazione predefinita il Trusted Platform Module virtuale (vTPM) e il monitoraggio dell'integrità. Compute Engine non abilita l'Avvio protetto per impostazione predefinita.

Se specifichi true per enableSecureBoot, Compute Engine crea una VM con tutte e tre le funzionalità Shielded VM abilitate. Dopo che Compute Engine ha avviato la VM, per modificare le opzioni della VM protetta, devi arrestarla.

Crea un'istanza VM con dischi non di avvio aggiuntivi

Quando crei una VM, puoi anche creare e collegare contemporaneamente altri dischi non di avvio alla VM.

Tuttavia, se vuoi creare un disco in modalità multi-autore, non puoi crearlo contemporaneamente alla VM. Devi prima creare il disco, quindi puoi collegarlo alla VM.

Console

Nella console Google Cloud, vai alla pagina Istanze VM.

Vai a Istanze VM
Seleziona il progetto e fai clic su Continua.
Fai clic su Crea istanza.
Specifica un nome per la VM. Per ulteriori informazioni, consulta la convenzione di denominazione delle risorse.
(Facoltativo) Modifica la Zona per questa VM. Se selezioni Qualsiasi, Google sceglie automaticamente una zona in base al tipo di macchina e alla disponibilità.
Seleziona una configurazione della macchina per la VM.
Nella sezione Disco di avvio, fai clic su Cambia e poi:
1. Nella scheda Immagini pubbliche, scegli quanto segue:
  - Sistema operativo
  - Versione sistema operativo
  - Tipo di disco di avvio
  - Dimensione del disco di avvio
2. (Facoltativo) Per le opzioni di configurazione avanzata, fai clic su Mostra configurazione avanzata.
3. Per confermare le opzioni del disco di avvio, fai clic su Seleziona.
Nota: a meno che tu non scelga esplicitamente un disco di avvio diverso, se il nome della nuova VM corrisponde al nome di un disco permanente esistente, il disco permanente esistente viene collegato automaticamente alla nuova VM come disco di avvio.
Nella sezione Firewall, per consentire il traffico HTTP o HTTPS alla VM, seleziona Consenti traffico HTTP o Consenti traffico HTTPS. Quando ne selezioni una, Compute Engine aggiunge un tag di rete alla VM, che associa la regola del firewall alla VM. Quindi, Compute Engine crea la corrispondente regola firewall in entrata che consente tutto il traffico in entrata su tcp:80 (HTTP) o tcp:443 (HTTPS).
Per aggiungere dischi non di avvio alla VM, espandi la sezione Opzioni avanzate e segui questi passaggi:
1. Espandi la sezione Dischi.
2. Fai clic su Aggiungi nuovo disco e poi procedi nel seguente modo:
  1. Specifica il Nome, il Tipo, il Tipo di origine e le Dimensioni del disco.
  2. Nella sezione Impostazioni di attacco, seleziona la Modalità di attacco del disco e la Regola di eliminazione. Per ulteriori informazioni sull'aggiunte di nuovi dischi, consulta Aggiungere un disco permanente alla VM.
  3. Fai clic su Salva.
Per creare e avviare la VM, fai clic su Crea.

gcloud

In the Google Cloud console, activate Cloud Shell.

Activate Cloud Shell

At the bottom of the Google Cloud console, a Cloud Shell session starts and displays a command-line prompt. Cloud Shell is a shell environment with the Google Cloud CLI already installed and with values already set for your current project. It can take a few seconds for the session to initialize.
Esegui il comando gcloud compute instances create per creare una VM con dischi non di avvio aggiuntivi.

Puoi aggiungere fino a 127 dischi non di avvio durante la creazione della VM. Specifica il flag --create-disk per ogni disco non di avvio che crei.

Per creare dischi non di avvio da un'immagine pubblica o di stock, specifica le proprietà image o image-family e image-project con il flag --create-disk. Per creare un disco vuoto, non includere queste proprietà. Se vuoi, puoi includere le proprietà per i dischi size e type. Includi la proprietà replica-zones per creare dischi permanenti a livello di regione.
```
gcloud compute instances create VM_NAME \
  --zone=ZONE \
  [--image=IMAGE | --image-family=IMAGE_FAMILY] \
  --image-project=IMAGE_PROJECT \
  --create-disk [image=DISK_IMAGE | image-family=DISK_IMAGE_FAMILY ], \
    image-project=DISK_IMAGE_PROJECT,size=SIZE_GB,type=DISK_TYPE \
  --create-disk device-name=DISK_NAME, \
    replica-zones=^:^ZONE:REMOTE-ZONE,boot=false
```
Sostituisci quanto segue:
- VM_NAME: nome della nuova VM
- ZONE: la zona in cui creare la VM
- IMAGE o IMAGE_FAMILY. Specifica una delle seguenti opzioni:
  - IMAGE: una versione specifica di un'immagine pubblica
    
    Ad esempio, --image=debian-10-buster-v20200309.
  - IMAGE_FAMILY: una famiglia di immagini
    
    In questo modo viene creata la VM dall'immagine del sistema operativo più recente e non ritirata. Ad esempio, se specifichi --image-family=debian-10, Compute Engine crea una VM dalla versione più recente dell'immagine del sistema operativo nella famiglia di immagini Debian 10.
- IMAGE_PROJECT: project contenente l'immagine
- Per altri dischi, sostituisci quanto segue:
  - DISK_IMAGE o DISK_IMAGE_FAMILY: specifica una delle seguenti opzioni:
    - DISK_IMAGE: il nome dell'immagine che vuoi utilizzare come disco non di avvio
    - DISK_IMAGE_FAMILY: una famiglia di immagini da utilizzare come disco non di avvio
  - DISK_IMAGE_PROJECT: un progetto di immagini a cui appartiene l'immagine del disco
  - SIZE_GB: facoltativo, dimensione del disco non di avvio
  - DISK_TYPE: facoltativo: URL completo o parziale per il tipo del disco permanente
    
    Ad esempio, https://www.googleapis.com/compute/v1/projects/PROJECT_ID/zones/ZONE/diskTypes/pd-ssd. Per visualizzare i tipi di dischi disponibili, esegui il comando gcloud compute disk-types list.
  - DISK_NAME: facoltativo, il nome del disco visualizzato all'OS guest dopo la creazione della VM.
  - REMOTE_ZONE: la zona in cui deve essere eseguito il mirroring del disco
  Per i dischi vuoti, non specificare i parametri DISK_IMAGE, DISK_IMAGE_FAMILY o DISK_IMAGE_PROJECT.
  
  Per i dischi zonali, non specificare la proprietà del disco replica-zones.

Terraform

Per generare il codice Terraform, puoi utilizzare il componente Codice equivalente nella console Google Cloud.

Nella console Google Cloud, vai alla pagina Istanze VM.
Vai a Istanze VM
Fai clic su Crea istanza.
Specifica i parametri che preferisci.
Nella parte superiore o inferiore della pagina, fai clic su Codice equivalente e poi sulla scheda Terraform per visualizzare il codice Terraform.

Vai

Per autenticarti a Compute Engine, configura le Credenziali predefinite dell'applicazione. Per ulteriori informazioni, consulta Configurare l'autenticazione per un ambiente di sviluppo locale.

import (
	"context"
	"fmt"
	"io"

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

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

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

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

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

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

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

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

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

	return nil
}

Java

Per autenticarti a Compute Engine, configura le Credenziali predefinite dell'applicazione. Per ulteriori informazioni, consulta Configurare l'autenticazione per un ambiente di sviluppo locale.


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

public class CreateInstancesAdvanced {

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


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

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

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

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

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

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

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

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

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

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

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

Node.js

Per autenticarti a Compute Engine, configura le Credenziali predefinite dell'applicazione. Per ulteriori informazioni, consulta Configurare l'autenticazione per un ambiente di sviluppo locale.

/**
 * TODO(developer): Uncomment and replace these variables before running the sample.
 */
// const projectId = 'YOUR_PROJECT_ID';
// const zone = 'europe-central2-b';
// const instanceName = 'YOUR_INSTANCE_NAME';

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

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

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

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

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

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

createWithAdditionalDisk();

Python

Per autenticarti a Compute Engine, configura le Credenziali predefinite dell'applicazione. Per ulteriori informazioni, consulta Configurare l'autenticazione per un ambiente di sviluppo locale.

from __future__ import annotations

import re
import sys
from typing import Any
import warnings

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


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

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

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


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

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

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


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

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

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


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

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

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

    Returns:
        Whatever the operation.result() returns.

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

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

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

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

    return result


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

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

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

    if internal_ip:
        network_interface.network_i_p = internal_ip

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

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

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

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

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

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

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

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

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

    operation = instance_client.insert(request=request)

    wait_for_extended_operation(operation, "instance creation")

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


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

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

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

REST

Puoi creare fino a 127 dischi non di avvio al momento della creazione di una VM utilizzando la proprietà initializeParams per ogni disco aggiuntivo. Crea dischi aggiuntivi con un'immagine pubblica o privata. Per aggiungere un disco vuoto, definisci la voce initializeParams senza valore sourceImage. Includi la proprietà del disco replicaZones per creare dischi permanenti a livello di regione.

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

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

Sostituisci quanto segue:

PROJECT_ID: ID del progetto in cui creare la VM
ZONE: la zona in cui creare la VM
MACHINE_TYPE_ZONE: zona contenente il tipo di macchina da utilizzare per la nuova VM
MACHINE_TYPE: tipo di macchina, predefinito o personalizzato, per la nuova VM
VM_NAME: nome della nuova VM
IMAGE_PROJECT: project contenente l'immagine
Ad esempio, se specifichi debian-10 come famiglia di immagini, specifica debian-cloud come progetto di immagini.
IMAGE or IMAGE_FAMILY: specifica una delle seguenti opzioni:
- IMAGE: una versione specifica di un'immagine pubblica
  Ad esempio, "sourceImage": "projects/debian-cloud/global/images/debian-10-buster-v20200309"
- IMAGE_FAMILY: una famiglia di immagini
  . Viene creata la VM dall'immagine del sistema operativo più recente e non ritirata. Ad esempio, se specifichi "sourceImage": "projects/debian-cloud/global/images/family/debian-10", Compute Engine crea una VM dalla versione più recente dell'immagine del sistema operativo nella famiglia di immagini Debian 10.
Per altri dischi, sostituisci quanto segue:
- SIZE_GB: dimensione del disco
- DISK_IMAGE o
- DISK_IMAGE_FAMILY: specifica un'immagine di origine o una famiglia di immagini per il disco non di avvio:
  - DISK_IMAGE: il nome dell'immagine che vuoi utilizzare come disco non di avvio. Ad esempio, "sourceImage": "projects/DISK_IMAGE_PROJECT/global/images/DISK_IMAGE".
  - DISK_IMAGE_FAMILY: una famiglia di immagini da utilizzare come disco non di avvio. Ad esempio, "sourceImage": "projects/DISK_IMAGE_PROJECT/global/images/family/DISK_IMAGE_FAMILY".
- DISK_TYPE: URL completo o parziale del tipo del disco permanente. Ad esempio: https://www.googleapis.com/compute/v1/projects/PROJECT_ID/zones/ZONE/diskTypes/pd-ssd.
- DISK_NAME: facoltativo. Il nome del disco visualizzato nel sistema operativo guest dopo la creazione della VM.
- REMOTE_ZONE: la zona in cui replicare il disco a livello di regione
NETWORK_NAME: la rete VPC che vuoi utilizzare per la VM. Puoi specificare default per utilizzare la rete predefinita.
ENABLE_SECURE_BOOT: facoltativo: se hai scelto un'immagine che supporta le funzionalità di VM schermate, Compute Engine attiva per impostazione predefinita il Trusted Platform Module virtuale (vTPM) e il monitoraggio dell'integrità. Compute Engine non abilita l'Avvio protetto per impostazione predefinita.

Se specifichi true per enableSecureBoot, Compute Engine crea una VM con tutte e tre le funzionalità Shielded VM abilitate. Dopo che Compute Engine ha avviato la VM, per modificare le opzioni della VM protetta, devi arrestarla.

Formatta e monta i dischi prima di utilizzarli.

Creare un'istanza VM da un'immagine condivisa

Se un altro utente ha condiviso un'immagine con te, puoi utilizzarla per creare una VM.

Console

Nella console Google Cloud, vai alla pagina Crea un'istanza.

Vai a Crea un'istanza
Specifica un nome per la VM. Per ulteriori informazioni, consulta la convenzione di denominazione delle risorse.
(Facoltativo) Modifica la Zona per questa VM. Se selezioni Qualsiasi, Google sceglie automaticamente una zona in base al tipo di macchina e alla disponibilità.
Seleziona una configurazione della macchina per la VM.
Nella sezione Disco di avvio, fai clic su Cambia per configurare il disco di avvio e poi:

Seleziona la scheda Immagini personalizzate.
Per selezionare il progetto di immagini, fai clic su Seleziona un progetto, quindi procedi nel seguente modo:
1. Seleziona il progetto che contiene l'immagine.
2. Fai clic su Apri.
Nell'elenco Immagine, fai clic sull'immagine che vuoi importare.
Seleziona il tipo e le dimensioni del disco di avvio.
Per confermare le opzioni del disco di avvio, fai clic su Seleziona.

Per consentire il traffico HTTP o HTTPS alla VM, nella sezione Firewall, seleziona Consenti traffico HTTP o Consenti traffico HTTPS.

La console Google Cloud aggiunge un tag di rete alla VM e crea la corrispondente regola firewall di ingresso che consente tutto il traffico in entrata su tcp:80 (HTTP) o tcp:443 (HTTPS). Il tag di rete associa la regola firewall alla VM. Per ulteriori informazioni, consulta la Panoramica delle regole firewall nella documentazione di Cloud Next Generation Firewall.
Per avviare e creare una VM, fai clic su Crea.

gcloud

In the Google Cloud console, activate Cloud Shell.

Activate Cloud Shell

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

Crea una VM utilizzando gcloud compute instances create command e i flag --image e --image-project per specificare il nome dell'immagine e il progetto in cui si trova:

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

Sostituisci quanto segue:

VM_NAME: nome della nuova VM
IMAGE: nome dell'immagine
IMAGE_PROJECT: progetto a cui appartiene l'immagine

Se il comando ha esito positivo, gcloud risponde con le proprietà della nuova VM:

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

Terraform

La procedura per creare una VM con un'immagine condivisa in Terraform è la stessa che se stessi creando una VM con un'immagine disponibile pubblicamente.

Nella console Google Cloud, vai alla pagina Istanze VM.
Vai a Istanze VM
Fai clic su Crea istanza.
Specifica i parametri che preferisci.
Nella parte superiore o inferiore della pagina, fai clic su Codice equivalente e poi sulla scheda Terraform per visualizzare il codice Terraform.

REST

La procedura per creare una VM con un'immagine condivisa nell'API è la stessa che se stessi creando una VM con un'immagine disponibile pubblicamente. Per creare la VM da un'immagine condivisa, utilizza il metodo instances.insert.

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

{
   "machineType":"zones/MACHINE_TYPE_ZONE/machineTypes/MACHINE_TYPE",
   "name":"VM_NAME",
   
   "disks":[
      {
         "initializeParams":{
            "sourceImage":"projects/IMAGE_PROJECT/global/images/IMAGE"
         },
         "boot":true
      }
   ],
   
   
   "networkInterfaces":[
      {
         "network":"global/networks/NETWORK_NAME"
      }
   ],
   
  
   "shieldedInstanceConfig":{
      "enableSecureBoot":"ENABLE_SECURE_BOOT"
   }
}

Sostituisci quanto segue:

PROJECT_ID: ID del progetto in cui creare la VM
ZONE: la zona in cui creare la VM
MACHINE_TYPE_ZONE: zona contenente il tipo di macchina da utilizzare per la nuova VM
MACHINE_TYPE: tipo di macchina, predefinito o personalizzato, per la nuova VM
VM_NAME: nome della nuova VM
IMAGE_PROJECT: il nome del progetto che contiene l'immagine condivisa
IMAGE o IMAGE_FAMILY: specifica una delle seguenti opzioni:
- IMAGE: il nome dell'immagine condivisa. Ad esempio, "sourceImage": "projects/finance-project-1234/global/images/finance-debian-image-v2".
- IMAGE_FAMILY: se l'immagine condivisa viene creata all'interno di una famiglia di immagini personalizzate, specifica questa famiglia di immagini personalizzate.
  In questo modo viene creata la VM dall'immagine del sistema operativo più recente e non deprecata nella famiglia di immagini personalizzate. Ad esempio, se specifichi "sourceImage": "projects/finance-project-1234/global/images/family/finance-debian-family", Compute Engine crea una VM dalla versione più recente dell'immagine del sistema operativo nella famiglia di immagini personalizzata finance-debian-family.
NETWORK_NAME: la rete VPC che vuoi utilizzare per la VM. Puoi specificare default per utilizzare la rete predefinita.
ENABLE_SECURE_BOOT: facoltativo: se hai scelto un'immagine che supporta le funzionalità di VM schermate, Compute Engine attiva per impostazione predefinita il Trusted Platform Module virtuale (vTPM) e il monitoraggio dell'integrità. Compute Engine non abilita l'Avvio protetto per impostazione predefinita.

Se specifichi true per enableSecureBoot, Compute Engine crea una VM con tutte e tre le funzionalità Shielded VM abilitate. Dopo che Compute Engine ha avviato la VM, per modificare le opzioni della VM protetta, devi arrestarla.

Crea una VM da uno snapshot

Puoi creare una nuova VM da uno snapshot nei seguenti modi:

Ripristino di un disco di avvio della VM: se hai eseguito il backup del disco di avvio di una VM con uno snapshot, puoi utilizzare lo snapshot per creare una nuova VM. Per istruzioni, consulta Ripristinare uno snapshot del disco di avvio in una nuova VM.
Ripristino di un disco non di avvio:se hai eseguito il backup di un disco non di avvio con uno snapshot, puoi ripristinare lo snapshot su un nuovo disco non di avvio quando crei una VM. Per istruzioni, vedi Creare una VM con un disco non di avvio basato su uno snapshot.

Per creare rapidamente più di una VM con lo stesso disco di avvio, crea un'immagine personalizzata, quindi crea le VM da quell'immagine anziché utilizzare uno snapshot.

Creare un'istanza VM da un'immagine contenitore

Per eseguire il deployment e avviare un contenitore su una VM Compute Engine, specifica un nome dell'immagine del contenitore e parametri di configurazione facoltativi quando crei la VM. Compute Engine crea la VM utilizzando la versione più recente dell'immagine pubblica Container-Optimized OS, su cui è installato Docker. Poi, Compute Engine avvia il contenitore all'avvio della VM. Per ulteriori informazioni, consulta la sezione Eseguire il deployment dei contenitori sulle VM.

Per creare una VM da un'immagine contenitore, devi utilizzare la console Google Cloud o gcloud.

Console

Nella console Google Cloud, vai alla pagina Istanze VM.

Vai a Istanze VM
Seleziona il progetto e fai clic su Continua.
Fai clic su Crea istanza.
Specifica un nome per la VM. Per ulteriori informazioni, consulta la convenzione di denominazione delle risorse.
Nella sezione Contenitore, fai clic su Esegui il deployment del contenitore.
1. Specifica l'immagine del container da utilizzare. Ad esempio:
  - Per selezionare un'immagine container NGINX 1.12 da Cloud Launcher:
    
    gcr.io/cloud-marketplace/google/nginx1:1.12
  - Per eseguire il deployment di un'immagine container Apache da Docker Hub, specifica sempre il nome completo dell'immagine Docker:
    
    docker.io/httpd:2.4
2. (Facoltativo) Fai clic su Opzioni container avanzate. Per ulteriori informazioni, consulta la sezione Configurare le opzioni per l'esecuzione del container.
Per creare la VM, avviarla e lanciare il contenitore, fai clic su Crea.

gcloud

In the Google Cloud console, activate Cloud Shell.

Activate Cloud Shell

At the bottom of the Google Cloud console, a Cloud Shell session starts and displays a command-line prompt. Cloud Shell is a shell environment with the Google Cloud CLI already installed and with values already set for your current project. It can take a few seconds for the session to initialize.
Esegui il comando gcloud compute instances create-with-container:
```
gcloud compute instances create-with-container VM_NAME \
  --container-image=CONTAINER_IMAGE
```
Sostituisci quanto segue:
- VM_NAME: nome della nuova VM.
- CONTAINER_IMAGE: il nome dell'immagine del contenitore.
Ad esempio, il seguente comando crea una VM denominata nginx-vm, che avvia ed esegue l'immagine del contenitore:

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
```
Per eseguire il deployment di un'immagine container Apache da Docker Hub, specifica sempre il nome completo dell'immagine Docker:

docker.io/httpd:2.4.

Creare un'istanza VM in una subnet specifica

Per impostazione predefinita, Google Cloud crea una rete VPC in modalità automatica denominata default per ogni progetto. Per utilizzare una rete diversa o una subnet creata manualmente in una rete VPC in modalità automatica o personalizzata, devi specificare la subnet al momento della creazione della VM.

Durante la creazione di una VM in una subnet, tieni presente queste regole:

Se non specifichi una rete o una subnet, Compute Engine utilizza la rete VPC predefinita e la subnet automatica che si trova nella stessa regione della VM.
Se non specifichi una rete, Compute Engine la deducono dalla subnet specificata.
Se specifichi una rete, devi specificare una subnet e deve appartenere alla stessa rete. In caso contrario, la creazione della VM non riesce.

Console

Nella console Google Cloud, vai alla pagina Istanze VM.

Vai a Istanze VM
Seleziona il progetto e fai clic su Continua.
Fai clic su Crea istanza.
Specifica un nome per la VM. Per ulteriori informazioni, consulta la convenzione di denominazione delle risorse.
(Facoltativo) Modifica la Zona per questa VM. Se selezioni Qualsiasi, Google sceglie automaticamente una zona in base al tipo di macchina e alla disponibilità.
Nella sezione Firewall, per consentire il traffico HTTP o HTTPS alla VM, seleziona Consenti traffico HTTP o Consenti traffico HTTPS.

La console Google Cloud aggiunge un tag di rete alla VM e crea la regola del firewall di ingresso corrispondente che consente tutto il traffico in entrata su tcp:80 (HTTP) o tcp:443 (HTTPS). Il tag network associa la regola firewall alla VM. Per ulteriori informazioni, consulta la Panoramica delle regole firewall nella documentazione di Cloud NGFW.
Espandi la sezione Opzioni avanzate.
1. Espandi la sezione Networking.
2. In Interfacce di rete, specifica i dettagli della rete:
  1. Nel campo Rete, seleziona la rete VPC contenente la subnet che hai creato.
  2. Nel campo Subnet, seleziona la subnet da utilizzare per la VM.
  3. Fai clic su Fine.
Per creare e avviare la VM, fai clic su Crea.

gcloud

In the Google Cloud console, activate Cloud Shell.

Activate Cloud Shell

At the bottom of the Google Cloud console, a Cloud Shell session starts and displays a command-line prompt. Cloud Shell is a shell environment with the Google Cloud CLI already installed and with values already set for your current project. It can take a few seconds for the session to initialize.
Utilizzando Google Cloud CLI, segui le stesse istruzioni per creare una VM da un'immagine o da uno snapshot e aggiungi i flag --subnet=SUBNET_NAME e --zone=ZONE quando esegui il comando gcloud compute instances create:
```
gcloud compute instances create VM_NAME \
  --network=NETWORK_NAME \
  --subnet=SUBNET_NAME \
  --zone=ZONE
```
Sostituisci quanto segue:
- VM_NAME: name della VM
- NETWORK_NAME: facoltativo, nome della rete
- SUBNET_NAME: il nome della subnet
  
  Per visualizzare un elenco di sottoreti nella rete, utilizza il comando gcloud compute networks subnets list.
- ZONE: la zona in cui viene creata la VM, ad esempio europe-west1-b
  
  La regione della VM viene dedotta dalla zona.

Terraform

Per creare una VM in una subnet specifica, puoi utilizzare la google_compute_instance risorsa.


# Create a VM in a custom VPC network and subnet

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

Per scoprire come applicare o rimuovere una configurazione Terraform, consulta Comandi Terraform di base.

La procedura per creare una VM con un'immagine condivisa in Terraform è la stessa che se stessi creando una VM con un'immagine disponibile pubblicamente.

Nella console Google Cloud, vai alla pagina Istanze VM.
Vai a Istanze VM
Fai clic su Crea istanza.
Specifica i parametri che preferisci.
Nella parte superiore o inferiore della pagina, fai clic su Codice equivalente e poi sulla scheda Terraform per visualizzare il codice Terraform.

Vai

Per autenticarti a Compute Engine, configura le Credenziali predefinite dell'applicazione. Per ulteriori informazioni, consulta Configurare l'autenticazione per un ambiente di sviluppo locale.

import (
	"context"
	"fmt"
	"io"

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

// createInstanceWithSubnet creates a new VM instance with Debian 10 operating system in specified network and subnetwork.
func createInstanceWithSubnet(w io.Writer, projectID, zone, instanceName, networkLink, subnetworkLink string) error {
	// projectID := "your_project_id"
	// zone := "europe-central2-b"
	// instanceName := "your_instance_name"
	// networkLink := "global/networks/default"
	// subnetworkLink := "regions/region/subnetworks/subnetwork_name"

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

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

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

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

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

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

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

	return nil
}

Java

Per autenticarti a Compute Engine, configura le Credenziali predefinite dell'applicazione. Per ulteriori informazioni, consulta Configurare l'autenticazione per un ambiente di sviluppo locale.


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

public class CreateInstancesAdvanced {

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


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

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

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

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

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

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

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

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

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

Node.js

Per autenticarti a Compute Engine, configura le Credenziali predefinite dell'applicazione. Per ulteriori informazioni, consulta Configurare l'autenticazione per un ambiente di sviluppo locale.

/**
 * TODO(developer): Uncomment and replace these variables before running the sample.
 */
// const projectId = 'YOUR_PROJECT_ID';
// const zone = 'europe-central2-b';
// const instanceName = 'YOUR_INSTANCE_NAME';
// const networkLink = 'global/networks/default';
// const subnetworkLink = 'regions/europe-central2/subnetworks/default';

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

// Creates a new VM instance with Debian 10 operating system in specified network and subnetwork.
async function createInstanceWithSubnet() {
  const instancesClient = new compute.InstancesClient();
  const imagesClient = new compute.ImagesClient();

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

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

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

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

createInstanceWithSubnet();

Python

Per autenticarti a Compute Engine, configura le Credenziali predefinite dell'applicazione. Per ulteriori informazioni, consulta Configurare l'autenticazione per un ambiente di sviluppo locale.

from __future__ import annotations

import re
import sys
from typing import Any
import warnings

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


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

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

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


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

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

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


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

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

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

    Returns:
        Whatever the operation.result() returns.

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

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

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

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

    return result


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

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

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

    if internal_ip:
        network_interface.network_i_p = internal_ip

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

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

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

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

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

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

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

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

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

    operation = instance_client.insert(request=request)

    wait_for_extended_operation(operation, "instance creation")

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


def create_with_subnet(
    project_id: str, zone: str, instance_name: str, network_link: str, subnet_link: str
) -> compute_v1.Instance:
    """
    Create a new VM instance with Debian 10 operating system in specified network and subnetwork.

    Args:
        project_id: project ID or project number of the Cloud project you want to use.
        zone: name of the zone to create the instance in. For example: "us-west3-b"
        instance_name: name of the new virtual machine (VM) instance.
        network_link: name of the network you want the new instance to use.
            For example: "global/networks/default" represents the network
            named "default", which is created automatically for each project.
        subnetwork_link: name of the subnetwork you want the new instance to use.
            This value uses the following format:
            "regions/{region}/subnetworks/{subnetwork_name}"

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

REST

Segui le istruzioni dell'API per creare una VM da un'immagine o da un snapshot, ma specifica il campo subnet nel corpo della richiesta. Per aggiungere dischi vuoti, non aggiungere un'immagine di origine. Se vuoi, puoi specificare le proprietà diskSizeGb, diskType e labels.

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

{
   "machineType":"zones/MACHINE_TYPE_ZONE/machineTypes/MACHINE_TYPE",
   "name":"VM_NAME",
   
   "disks":[
      {
         "initializeParams":{
            "sourceImage":"projects/IMAGE_PROJECT/global/images/IMAGE"
         },
         "boot":true
      }
   ],
   
   
   "networkInterfaces":[
      {
         "network":"global/networks/NETWORK_NAME",
         "subnetwork":"regions/REGION/subnetworks/SUBNET_NAME",
         "accessConfigs":{
            "name":"External NAT",
            "type":"ONE_TO_ONE_NAT"
         }
      }
   ],
   
  
   "shieldedInstanceConfig":{
      "enableSecureBoot":"ENABLE_SECURE_BOOT"
   }
}

Sostituisci quanto segue:

PROJECT_ID: ID del progetto in cui creare la VM
ZONE: la zona in cui creare la VM
MACHINE_TYPE_ZONE: zona contenente il tipo di macchina da utilizzare per la nuova VM
MACHINE_TYPE: tipo di macchina, predefinito o personalizzato, per la nuova VM
VM_NAME: nome della nuova VM
IMAGE_PROJECT: project contenente l'immagine
Ad esempio, se specifichi debian-10 come famiglia di immagini, specifica debian-cloud come progetto di immagini.
IMAGE or IMAGE_FAMILY: specifica una delle seguenti opzioni:
- IMAGE: una versione specifica di un'immagine pubblica
  Ad esempio, "sourceImage": "projects/debian-cloud/global/images/debian-10-buster-v20200309"
- IMAGE_FAMILY: una famiglia di immagini
  . Viene creata la VM dall'immagine del sistema operativo più recente e non ritirata. Ad esempio, se specifichi "sourceImage": "projects/debian-cloud/global/images/family/debian-10", Compute Engine crea una VM dalla versione più recente dell'immagine del sistema operativo nella famiglia di immagini Debian 10.
NETWORK_NAME: la rete VPC che vuoi utilizzare per la VM. Puoi specificare default per utilizzare la rete predefinita.
REGION: regione in cui esiste la subnet specificata
SUBNET_NAME: il nome della subnet
ENABLE_SECURE_BOOT: facoltativo: se hai scelto un'immagine che supporta le funzionalità di VM schermate, Compute Engine attiva per impostazione predefinita il Trusted Platform Module virtuale (vTPM) e il monitoraggio dell'integrità. Compute Engine non abilita l'Avvio protetto per impostazione predefinita.

Se specifichi true per enableSecureBoot, Compute Engine crea una VM con tutte e tre le funzionalità Shielded VM abilitate. Dopo che Compute Engine ha avviato la VM, per modificare le opzioni della VM protetta, devi arrestarla.

Crea una VM configurata per il monitoraggio e il logging di Ops Agent

Ops Agent raccoglie i dati di telemetria per le VM che puoi poi utilizzare per la risoluzione dei problemi e l'ottimizzazione delle prestazioni. Puoi installare Ops Agent durante la creazione di una VM o su VM esistenti come descritto nei seguenti argomenti:

Installa Ops Agent quando crei una VM utilizzando la console Google Cloud: attiva l'installazione automatica di Ops Agent selezionando la casella di controllo Installa Ops Agent per il monitoraggio e il logging nella pagina Crea un'istanza. Questa opzione attiva VM Manager in modalità di funzionalità limitata e crea un'assegnazione del criterio del sistema operativo per l'installazione di Ops Agent sulla VM. Per ulteriori informazioni, consulta Installare Ops Agent durante la creazione della VM.
Installa l'Ops Agent sulle VM esistenti:utilizza la console Google Cloud, l'gcloud CLI o uno strumento di automazione per installare l'Ops Agent su un parco risorse di VM o su singole VM. Per istruzioni, vedi Installare l'agente operativo.
Nota: se installi Ops Agent, è possibile che ti vengano addebitati dei costi per le metriche e i log inviati dall'agente al progetto Google Cloud. Per ulteriori informazioni, consulta la pagina Prezzi di Google Cloud Observability.

Risoluzione dei problemi

Per trovare metodi per risolvere gli errori comuni di creazione delle VM, consulta Risoluzione dei problemi di creazione delle VM.

Passaggi successivi
- Controlla lo stato della VM per vedere quando è pronta per l'uso.
- Scopri come utilizzare gli snapshot per eseguire il backup dei dischi permanenti.
- Scopri come creare e collegare un disco di archiviazione non di avvio alla tua VM per archiviare i dati separatamente dal disco di avvio.
- Scopri come connetterti alla VM.
- Scopri come eseguire lo scaling out della VM in un gruppo di VM.
Provalo

Se non conosci Google Cloud, crea un account per valutare le prestazioni di Compute Engine in scenari reali. I nuovi clienti ricevono anche 300 $ di crediti gratuiti per l'esecuzione, il test e il deployment dei carichi di lavoro.
Prova Compute Engine gratuitamente