Crea e avvia un'istanza VM

---

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

Durante la creazione della VM, puoi creare uno o più dischi. Puoi anche aggiungere altri dischi alla VM dopo la sua creazione. Compute Engine avvia automaticamente l'istanza VM dopo averla creata.

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

Se stai creando una VM per la prima volta, consulta il post Avvio rapido con una VM Linux o Avvio rapido con una VM Windows Server.

Per una creazione di VM più specifica o complessa, consulta le risorse seguenti:

• Creazione di istanze Windows Server
• Creazione di istanze SQL Server
• Creazione di istanze su nodi single-tenant
• Creazione di un'istanza VM con un nome host personalizzato
• Prenotazione delle istanze e utilizzo di istanze prenotate
• Creazione di istanze VM che utilizzano l'interfaccia di rete gVNIC
• Creazione e avvio di un'istanza VM Arm
• Configurazione di un'istanza VM con larghezza di banda superiore
• Creazione di un'istanza VM con GPU collegate
• Creazione di un'istanza VM con un'immagine HPC (computing ad alte prestazioni)
• Utilizzo dell'API dell'istanza collettiva
• Creazione di un'istanza VM con una pianificazione di istanze collegata
• Creazione di un gruppo di istanze gestite

Se hai una licenza esistente, consulta Portare la tua licenza con i nodi single-tenant.

Prima di iniziare

• Se vuoi utilizzare gli esempi a riga di comando in questa guida:
  1. Installa o aggiorna la versione più recente di Google Cloud CLI.
  2. Imposta una regione e una zona predefinite.
• Se vuoi utilizzare gli esempi di API in questa guida, configura l'accesso all'API.
• Quando crei VM da immagini o dischi utilizzando Google Cloud CLI o l'API Compute Engine, è previsto un limite di 20 istanze VM al secondo. Se devi creare un numero di VM al secondo più elevato, richiedi un limite di quota più alto per la risorsa Immagini.

Crea un'istanza VM da un'immagine

Questa sezione spiega come creare una VM da un'immagine pubblica del sistema operativo o da un'immagine personalizzata. Una VM contiene un bootloader, un file system di avvio e un'immagine del sistema operativo.

Visualizza un elenco di immagini pubbliche disponibili su Compute Engine

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

Per ulteriori informazioni sulle funzionalità disponibili in ogni immagine pubblica, consulta la pagina Assistenza per funzionalità in base al sistema operativo.

Console

1. Nella console Google Cloud, vai alla pagina Immagini.

   Vai a Google Immagini

gcloud

1. Esegui questo comando:

   gcloud compute images list

2. Prendi nota del nome dell'immagine o della famiglia di immagini e del nome del progetto che contiene l'immagine.

3. (Facoltativo) Per determinare se l'immagine supporta le funzionalità VM schermate, esegui il comando seguente:

   gcloud compute images describe IMAGE_NAME \
       --project=IMAGE_PROJECT
   

   Sostituisci quanto segue:

   • IMAGE_NAME: nome dell'immagine per verificare il supporto delle funzionalità della VM schermata
   • IMAGE_PROJECT: progetto contenente l'immagine

   Se l'immagine supporta le funzionalità Shielded VM, nell'output viene visualizzata la seguente riga: type: UEFI_COMPATIBLE.

API

1. Esegui questo comando:

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

2. Prendi nota del nome dell'immagine o della famiglia di immagini e del nome del progetto che contiene l'immagine.

3. (Facoltativo) Per determinare se l'immagine supporta le funzionalità VM schermate, esegui il comando seguente:

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

   Sostituisci quanto segue:

   • IMAGE_PROJECT: progetto contenente l'immagine
   • IMAGE_NAME: nome dell'immagine per verificare il supporto delle funzionalità della VM schermata

   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 per la configurazione di C# nella guida rapida di Compute Engine mediante librerie client. Per ulteriori informazioni, consulta la documentazione di riferimento dell'API C# di Compute Engine.

Visualizza su GitHub Feedback

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

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

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

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

Go

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

Visualizza su GitHub Feedback

import (
	"context"
	"fmt"
	"io"

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

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

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

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

Java

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

Visualizza su GitHub Feedback

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 per la configurazione di Node.js nella guida rapida di Compute Engine mediante librerie client. Per ulteriori informazioni, consulta la documentazione di riferimento dell'API Node.js di Compute Engine.

Visualizza su GitHub Feedback

/**
 * 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 per la configurazione di PHP nella guida rapida di Compute Engine mediante librerie client. Per ulteriori informazioni, consulta la documentazione di riferimento dell'API PHP di Compute Engine.

Visualizza su GitHub Feedback

use Google\Cloud\Compute\V1\ImagesClient;

/**
 * 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.
     */
    $pagedResponse = $imagesClient->list($projectId, $optionalArgs);
    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 per la configurazione di Python nella guida rapida di Compute Engine mediante librerie client. Per ulteriori informazioni, consulta la documentazione di riferimento dell'API Python di Compute Engine.

Visualizza su GitHub Feedback

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 per la configurazione di Ruby nella guida rapida di Compute Engine mediante librerie client. Per ulteriori informazioni, consulta la documentazione di riferimento dell'API Ruby di Compute Engine.

Visualizza su GitHub Feedback

require "google/cloud/compute/v1"

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

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

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

Crea un'istanza VM da un'immagine pubblica

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

Se crei un'immagine VM schermata con un SSD locale, non puoi schermare i dati con il monitoraggio dell'integrità o il modulo Virtual Platform Trusted (vTPM).

Autorizzazioni richieste per questa attività

Per eseguire questa attività, devi disporre delle seguenti autorizzazioni:

• compute.instances.create nel progetto
• compute.instances.updateShieldedVmConfig se prevedi di creare un'istanza VM schermata e vuoi poter modificare qualsiasi impostazione della VM schermata
• compute.networks.use sul progetto se utilizzi una rete legacy
• compute.subnetworks.use sull'intero progetto o sulla subnet scelta (reti VPC)
• compute.networks.useExternalIp nel progetto se devi assegnare un indirizzo IP esterno (temporaneo o statico) all'istanza utilizzando una rete legacy
• compute.subnetworks.useExternalIp sull'intero progetto o sulla subnet scelta se devi assegnare un indirizzo IP esterno (temporaneo o statico) all'istanza utilizzando una rete VPC
• compute.addresses.use sul progetto se specifichi un indirizzo statico nel progetto
• compute.instances.setMetadata se imposti i metadati
• compute.instances.setTags sull'istanza se imposti i tag
• compute.instances.setLabels sull'istanza se imposti le etichette
• compute.instances.setServiceAccount sull'istanza se imposti l'account di servizio
• compute.images.useReadOnly sull'immagine se crei un nuovo disco permanente radice
• compute.disks.create nel progetto se crei un nuovo disco permanente radice con questa istanza
• compute.disks.useReadOnly sul disco se colleghi un disco permanente esistente in modalità di sola lettura
• compute.disks.use sul disco se colleghi un disco esistente in modalità di lettura/scrittura
• compute.disks.setLabels sul disco se imposti etichette
• compute.snapshots.create nel progetto per creare un nuovo snapshot se viene creata un'istanza da uno snapshot
• compute.snapshots.useReadOnly sullo snapshot se crei un'istanza da uno snapshot
• compute.instanceTemplates.useReadOnly sul modello di istanza se crei l'istanza dal modello di istanza

Console

1. Nella console Google Cloud, vai alla pagina Istanze VM.

   Vai a Istanze VM

2. Seleziona il progetto e fai clic su Continua.

3. Fai clic su Crea istanza.

4. Specifica un nome per la VM. Per ulteriori informazioni, consulta la convenzione di denominazione delle risorse.

5. (Facoltativo) Modifica la zona per questa VM. Compute Engine randomizza l'elenco delle zone all'interno di ciascuna regione per incoraggiarne l'utilizzo in più zone.

6. Seleziona una configurazione delle macchine per la tua VM.

7. Nella sezione Disco di avvio, fai clic su Cambia, quindi procedi nel seguente modo:

   1. Nella scheda Immagini pubbliche, scegli quanto segue:
      • Sistema operativo
      • Versione OS
      • Tipo di disco di avvio
      • Dimensione del disco di avvio
   2. (Facoltativo) Per le opzioni di configurazione avanzate, fai clic su Mostra configurazione avanzata.
   3. Per confermare le opzioni del disco di avvio, fai clic su Seleziona.
   Nota: a meno che 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 automaticamente collegato alla nuova VM come disco di avvio.

8. Nella sezione Firewall, per consentire il traffico HTTP o HTTPS verso la 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 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).

9. (Facoltativo) Se hai scelto un'immagine sistema operativo che supporti le funzionalità Shielded VM, puoi modificare le impostazioni di Shielded VM. Per modificare le impostazioni della Shielded VM, espandi la sezione Sicurezza nella sezione Networking, dischi, sicurezza, gestione, single tenancy ed esegui le seguenti operazioni, come richiesto:

   • Per attivare Avvio protetto, seleziona Attiva Avvio protetto. Avvio protetto è disattivato per impostazione predefinita.

   • Per disattivare vTPM, deseleziona la casella di controllo Attiva vTPM. vTPM è abilitato per impostazione predefinita. La disabilitazione di vTPM disattiva anche il monitoraggio dell'integrità perché il monitoraggio dell'integrità si basa sui dati raccolti dall'avvio con misurazioni.

   • Per disattivare il monitoraggio dell'integrità, deseleziona la casella di controllo Attiva il monitoraggio dell'integrità. Il monitoraggio dell'integrità è attivato per impostazione predefinita.

10. Per creare e avviare la VM, fai clic su Crea.

gcloud

1. Seleziona un'immagine pubblica. Prendi nota del nome dell'immagine o della famiglia di immagini e del nome del progetto che contiene l'immagine.

2. Usa il comando gcloud compute instances create per creare una VM da una famiglia di immagini o da una versione specifica di un'immagine sistema operativo.

   Se specifichi il flag facoltativo --shielded-secure-boot, Compute Engine crea una VM con tutte e tre le funzionalità VM schermate abilitate:

   • Virtual Trusted Platform Module (vTPM)
   • Monitoraggio dell'integrità
   • Avvio protetto

   Dopo che Compute Engine avvia la tua VM, devi arrestarla per modificare le opzioni della Shielded VM.

   gcloud compute instances create VM_NAME \
       [--image=IMAGE | --image-family=IMAGE_FAMILY] \
       --image-project=IMAGE_PROJECT
       --machine-type=MACHINE_TYPE

   Sostituisci quanto segue:

   • VM_NAME: nome della nuova 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.

       Questa operazione crea la VM dall'immagine del sistema operativo più recente e non deprecata. Ad esempio, se specifichi --image-family=debian-10, Compute Engine crea una VM dall'ultima versione dell'immagine sistema operativo nella famiglia di immagini Debian 10.

   • IMAGE_PROJECT: progetto contenente l'immagine

   • MACHINE_TYPE: tipo di macchina, predefinita o personalizzata, per la nuova VM

     Per ottenere un elenco dei tipi di macchina disponibili in una zona, utilizza il comando gcloud compute machine-types list con il flag --zones.

3. 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 risorsa google_compute_instance.

compute/basic_vm/main.tf

Visualizza su GitHub Feedback

# 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, vedi Comandi Terraform di base.

API

1. Seleziona un'immagine pubblica. Prendi nota del nome dell'immagine o della famiglia di immagini e del nome del progetto che contiene l'immagine.

2. Usa il metodo instances.insert per creare una VM da una famiglia di immagini o da una versione specifica di un'immagine 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: 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, predefinita o personalizzata, per la nuova VM
   • VM_NAME: nome della nuova VM
   • IMAGE_PROJECT: progetto contenente l'immagine
     Ad esempio, se specifichi debian-10 come famiglia di immagini, specifica debian-cloud come progetto immagine.
   • 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
       In questo modo la VM viene creata dall'immagine del sistema operativo più recente e non deprecata. Ad esempio, se specifichi "sourceImage": "projects/debian-cloud/global/images/family/debian-10", Compute Engine crea una VM dall'ultima versione 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 in modo che utilizzi la rete predefinita.
   • ENABLE_SECURE_BOOT: (facoltativo) se scegli un'immagine che supporta le funzionalità VM schermate, Compute Engine, per impostazione predefinita, abilita il modulo Virtual Trusted Platform Platform (vTPM) e il monitoraggio dell'integrità. Compute Engine non abilita 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 avvia la tua VM, per modificare le opzioni della Shielded VM devi arrestarla.

C#

C#

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

Visualizza su GitHub Feedback

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

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

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

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

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

Go

Go

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

Visualizza su GitHub Feedback

import (
	"context"
	"fmt"
	"io"

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

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

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

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

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

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

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

	return nil
}

Java

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

Visualizza su GitHub Feedback

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

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

Visualizza su GitHub Feedback

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

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

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

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

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

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

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

createInstance();

PHP

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

Visualizza su GitHub Feedback

use Google\Cloud\Compute\V1\InstancesClient;
use Google\Cloud\Compute\V1\AttachedDisk;
use Google\Cloud\Compute\V1\AttachedDiskInitializeParams;
use Google\Cloud\Compute\V1\Instance;
use Google\Cloud\Compute\V1\NetworkInterface;

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

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

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

Python

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

Visualizza su GitHub Feedback

import re
import sys
from typing import Any, List
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.name = 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}"

    if accelerators:
        instance.guest_accelerators = accelerators

    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 = compute_v1.Scheduling()
        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

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

Visualizza su GitHub Feedback

require "google/cloud/compute/v1"

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

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

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

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

    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

Crea una VM da un'immagine personalizzata

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

Nota: devi avere accesso all'immagine personalizzata per utilizzarla quando crei una VM. Per impostazione predefinita, hai accesso a tutte le immagini personalizzate nel tuo progetto. Tuttavia, se il progetto ha un elenco definito di immagini attendibili, puoi utilizzare solo le immagini presenti in quell'elenco per creare una VM.

Autorizzazioni richieste per questa attività

Per eseguire questa attività, devi disporre delle seguenti autorizzazioni:

• compute.instances.create nel progetto
• compute.instances.updateShieldedVmConfig se prevedi di creare un'istanza VM schermata e vuoi poter modificare qualsiasi impostazione della VM schermata
• compute.networks.use sul progetto se utilizzi una rete legacy
• compute.subnetworks.use sull'intero progetto o sulla subnet scelta (reti VPC)
• compute.networks.useExternalIp nel progetto se devi assegnare un indirizzo IP esterno (temporaneo o statico) all'istanza utilizzando una rete legacy
• compute.subnetworks.useExternalIp sull'intero progetto o sulla subnet scelta se devi assegnare un indirizzo IP esterno (temporaneo o statico) all'istanza utilizzando una rete VPC
• compute.addresses.use sul progetto se specifichi un indirizzo statico nel progetto
• compute.instances.setMetadata se imposti i metadati
• compute.instances.setTags sull'istanza se imposti i tag
• compute.instances.setLabels sull'istanza se imposti le etichette
• compute.instances.setServiceAccount sull'istanza se imposti l'account di servizio
• compute.images.useReadOnly sull'immagine se crei un nuovo disco permanente radice
• compute.disks.create nel progetto se crei un nuovo disco permanente radice con questa istanza
• compute.disks.useReadOnly sul disco se colleghi un disco permanente esistente in modalità di sola lettura
• compute.disks.use sul disco se colleghi un disco esistente in modalità di lettura/scrittura
• compute.disks.setLabels sul disco se imposti etichette
• compute.snapshots.create nel progetto per creare un nuovo snapshot se viene creata un'istanza da uno snapshot
• compute.snapshots.useReadOnly sullo snapshot se crei un'istanza da uno snapshot
• compute.instanceTemplates.useReadOnly sul modello di istanza se crei l'istanza dal modello di istanza

Console

1. Nella console Google Cloud, vai alla pagina Istanze VM.

   Vai a Istanze VM

2. Seleziona il progetto e fai clic su Continua.

3. Fai clic su Crea istanza.

4. Specifica un nome per la VM. Per ulteriori informazioni, consulta la convenzione di denominazione delle risorse.

5. (Facoltativo) Modifica la zona per questa VM. Compute Engine randomizza l'elenco delle zone all'interno di ciascuna regione per incoraggiarne l'utilizzo in più zone.

6. Seleziona una configurazione delle macchine per la tua VM.

7. Nella sezione Disco di avvio, fai clic su Cambia, quindi procedi nel seguente modo:

   1. Seleziona la scheda Immagini personalizzate.
   2. Per selezionare il progetto immagine, fai clic su Seleziona un progetto e poi procedi nel seguente modo:
      1. Seleziona il progetto che contiene l'immagine.
      2. Fai clic su Apri.
   3. Nell'elenco Immagine, fai clic sull'immagine da importare.
   4. Seleziona il tipo e la dimensione del disco di avvio.
   5. (Facoltativo) Per le opzioni di configurazione avanzate, fai clic su Mostra configurazione avanzata.
   6. Per confermare le opzioni del disco di avvio, fai clic su Seleziona.

8. Nella sezione Firewall, per consentire il traffico HTTP o HTTPS verso la VM, seleziona Consenti traffico HTTP o Consenti traffico HTTPS.

   La console Google Cloud aggiunge un tag di rete alla tua VM e crea la regola firewall in entrata corrispondente 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 Virtual Private Cloud.

9. Per creare e avviare la VM, fai clic su Crea.

gcloud

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: nome della VM
• IMAGE_PROJECT: nome del 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 immagini personalizzate nell'ambito di una famiglia di immagini personalizzate, specifica tale famiglia.

    In questo modo la VM viene creata dalla versione del sistema operativo 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 sistema operativo più recente nella tua famiglia di immagini my-debian-family personalizzata.

  Nota: Compute Engine utilizza la famiglia di immagini e il progetto predefiniti se non specifichi un'immagine. La famiglia di immagini e il progetto predefiniti sono rispettivamente debian-10 e debian-cloud.

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

API

Il processo di creazione di una VM con un'immagine personalizzata nell'API è lo stesso di 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: 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, predefinita o personalizzata, per la nuova VM
• VM_NAME: nome della nuova VM
• IMAGE_PROJECT: nome del progetto contenente l'immagine personalizzata
• IMAGE o IMAGE_FAMILY: specifica una delle seguenti opzioni:
  • IMAGE: nome dell'immagine personalizzata. Ad esempio: "sourceImage": "projects/my-project-1234/global/images/my-debian-image-v2".
  • IMAGE_FAMILY: se hai creato immagini personalizzate nell'ambito di una famiglia di immagini personalizzate, specifica tale famiglia.

    In questo modo la VM viene creata dall'immagine del sistema operativo più recente e non deprecata nella tua famiglia di immagini personalizzate. Ad esempio, se specifichi "sourceImage": "projects/my-project-1234/global/images/family/my-debian-family", Compute Engine crea una VM dall'ultima versione dell'immagine del sistema operativo nella famiglia di immagini my-debian-family personalizzate.

• NETWORK_NAME: la rete VPC che vuoi utilizzare per la VM. Puoi specificare default in modo che utilizzi la rete predefinita.
• ENABLE_SECURE_BOOT: (facoltativo) se scegli un'immagine che supporta le funzionalità VM schermate, Compute Engine, per impostazione predefinita, abilita il modulo Virtual Trusted Platform Platform (vTPM) e il monitoraggio dell'integrità. Compute Engine non abilita 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 avvia la tua VM, per modificare le opzioni della Shielded VM devi arrestarla.

Go

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

Visualizza su GitHub Feedback

import (
	"context"
	"fmt"
	"io"

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

// 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: %v", err)
	}
	defer instancesClient.Close()

	req := &computepb.InsertInstanceRequest{
		Project: projectID,
		Zone:    zone,
		InstanceResource: &computepb.Instance{
			Name: proto.String(instanceName),
			Disks: []*computepb.AttachedDisk{
				{
					InitializeParams: &computepb.AttachedDiskInitializeParams{
						DiskSizeGb:  proto.Int64(10),
						SourceImage: proto.String(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: %v", err)
	}

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

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

	return nil
}

Java

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

Visualizza su GitHub Feedback

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

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

Visualizza su GitHub Feedback

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

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

Visualizza su GitHub Feedback

import re
import sys
from typing import Any, List
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.name = 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}"

    if accelerators:
        instance.guest_accelerators = accelerators

    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 = compute_v1.Scheduling()
        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

Crea un'istanza VM con dischi non di avvio aggiuntivi

Console

1. Nella console Google Cloud, vai alla pagina Istanze VM.

   Vai a Istanze VM

2. Seleziona il progetto e fai clic su Continua.

3. Fai clic su Crea istanza.

4. Specifica un nome per la VM. Per ulteriori informazioni, consulta la convenzione di denominazione delle risorse.

5. (Facoltativo) Modifica la zona per questa VM. Compute Engine randomizza l'elenco delle zone all'interno di ciascuna regione per incoraggiarne l'utilizzo in più zone.

6. Seleziona una configurazione delle macchine per la tua VM.

7. Nella sezione Disco di avvio, fai clic su Cambia, quindi procedi nel seguente modo:

   1. Nella scheda Immagini pubbliche, scegli quanto segue:
      • Sistema operativo
      • Versione OS
      • Tipo di disco di avvio
      • Dimensione del disco di avvio
   2. (Facoltativo) Per le opzioni di configurazione avanzate, 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 automaticamente collegato alla nuova VM come disco di avvio.

8. Nella sezione Firewall, per consentire il traffico HTTP o HTTPS verso la VM, seleziona Consenti traffico HTTP o Consenti traffico HTTPS. Quando selezioni una di queste opzioni, Compute Engine aggiunge un tag di rete alla tua VM, che associa la regola firewall alla VM. 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).

9. Per aggiungere dischi non di avvio alla VM, espandi la sezione Networking, dischi, sicurezza, gestione, single tenancy, quindi segui questi passaggi:

   1. Espandi la sezione Dischi.
   2. Fai clic su Aggiungi nuovo disco, quindi procedi nel seguente modo:
      1. Specifica un Nome, un Tipo, un Tipo di origine e una Dimensione per il disco.
      2. Nella sezione Impostazioni allegati, seleziona Modalità dell'allegato del disco e Regola di eliminazione. Per saperne di più sull'aggiunta di nuovi dischi, consulta la pagina Aggiungere un disco permanente alla VM.
      3. Fai clic su Salva.

10. Per creare e avviare la VM, fai clic su Crea.

gcloud

Esegui il comando gcloud compute instances create per creare una VM con altri dischi non di avvio.

Puoi aggiungere fino a 128 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 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à. Facoltativamente, puoi includere proprietà per il disco size e type.

gcloud compute instances create VM_NAME \
    [--image=IMAGE | --image-family=IMAGE_FAMILY] \
    --image-project=IMAGE_PROJECT \
    --create-disk [image=DISK_IMAGE | image-family=DISK_IMAGE_FAMILY ],image-project=DISK_IMAGE_PROJECT,size=SIZE_GB,type=DISK_TYPE

Sostituisci quanto segue:

• VM_NAME: nome della nuova 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

    Questa operazione crea la VM dall'immagine del sistema operativo più recente e non deprecata. Ad esempio, se specifichi --image-family=debian-10, Compute Engine crea una VM dall'ultima versione dell'immagine del sistema operativo nella famiglia di immagini Debian 10.

• IMAGE_PROJECT: progetto contenente l'immagine

• Per i dischi aggiuntivi, sostituisci quanto segue:

  • DISK_IMAGE oppure DISK_IMAGE_FAMILY: specifica una delle seguenti opzioni:
    • DISK_IMAGE: 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 immagine a cui appartiene l'immagine del disco
  • SIZE_GB: (facoltativo) dimensioni 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 disco disponibili, esegui il comando gcloud compute disk-types list.

  Per i dischi vuoti, non specificare i parametri DISK_IMAGE, DISK_IMAGE_FAMILY o DISK_IMAGE_PROJECT.

API

Puoi creare fino a 128 dischi non di avvio nel momento in cui crei 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.

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

   "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: 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, predefinita o personalizzata, per la nuova VM
• VM_NAME: nome della nuova VM
• IMAGE_PROJECT: progetto contenente l'immagine
  Ad esempio, se specifichi debian-10 come famiglia di immagini, specifica debian-cloud come progetto immagine.
• 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
    In questo modo la VM viene creata dall'immagine del sistema operativo più recente e non deprecata. Ad esempio, se specifichi "sourceImage": "projects/debian-cloud/global/images/family/debian-10", Compute Engine crea una VM dall'ultima versione dell'immagine del sistema operativo nella famiglia di immagini Debian 10.
• Per i dischi aggiuntivi, sostituisci quanto segue:
  • SIZE_GB: dimensione disco
  • DISK_IMAGE oppure
  • DISK_IMAGE_FAMILY: specifica un'immagine di origine o una famiglia di immagini per il disco non di avvio:
    • DISK_IMAGE: 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 per il tipo del disco permanente. Ad esempio: https://www.googleapis.com/compute/v1/projects/PROJECT_ID/zones/ZONE/diskTypes/pd-ssd.
  Per i dischi vuoti, non specificare i parametri DISK_IMAGE, DISK_IMAGE_FAMILY o DISK_IMAGE_PROJECT.
• NETWORK_NAME: la rete VPC che vuoi utilizzare per la VM. Puoi specificare default in modo che utilizzi la rete predefinita.
• ENABLE_SECURE_BOOT: (facoltativo) se scegli un'immagine che supporta le funzionalità VM schermate, Compute Engine, per impostazione predefinita, abilita il modulo Virtual Trusted Platform Platform (vTPM) e il monitoraggio dell'integrità. Compute Engine non abilita 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 avvia la tua VM, per modificare le opzioni della Shielded VM devi arrestarla.

Go

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

Visualizza su GitHub Feedback

import (
	"context"
	"fmt"
	"io"

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

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

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

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

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

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

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

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

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

	return nil
}

Java

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

Visualizza su GitHub Feedback

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 10 operating system and a 11 GB additional empty disk.
   *
   * @param project project ID or project number of the Cloud project you want to use.
   * @param zone name of the zone to create the instance in. For example: "us-west3-b"
   * @param instanceName name of the new virtual machine (VM) instance.
   * @return Instance object.
   */
  public static Instance createWithAdditionalDisk(String project, String zone, String instanceName)
      throws IOException, InterruptedException, ExecutionException, 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-10");
      String diskType = String.format("zones/%s/diskTypes/pd-standard", zone);
      Vector<AttachedDisk> disks = new Vector<>();
      disks.add(diskFromImage(diskType, 10, true, image.getSelfLink()));
      disks.add(emptyDisk(diskType, 11));
      return createWithDisks(project, zone, instanceName, disks, "n1-standard-1",
          "global/networks/default", null);
    }
  }

Node.js

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

Visualizza su GitHub Feedback

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

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

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

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

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

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

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

createWithAdditionalDisk();

Python

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

Visualizza su GitHub Feedback

import re
import sys
from typing import Any, List
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.name = 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}"

    if accelerators:
        instance.guest_accelerators = accelerators

    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 = compute_v1.Scheduling()
        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-10")
    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

Formatta e monta i dischi prima di utilizzarli.

Crea un'istanza VM da un'immagine condivisa

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

Autorizzazioni richieste per questa attività

Per eseguire questa attività, devi disporre delle seguenti autorizzazioni:

• compute.instances.create nel progetto
• compute.instances.updateShieldedVmConfig se prevedi di creare un'istanza VM schermata e vuoi poter modificare qualsiasi impostazione della VM schermata
• compute.networks.use sul progetto se utilizzi una rete legacy
• compute.subnetworks.use sull'intero progetto o sulla subnet scelta (reti VPC)
• compute.networks.useExternalIp nel progetto se devi assegnare un indirizzo IP esterno (temporaneo o statico) all'istanza utilizzando una rete legacy
• compute.subnetworks.useExternalIp sull'intero progetto o sulla subnet scelta se devi assegnare un indirizzo IP esterno (temporaneo o statico) all'istanza utilizzando una rete VPC
• compute.addresses.use sul progetto se specifichi un indirizzo statico nel progetto
• compute.instances.setMetadata se imposti i metadati
• compute.instances.setTags sull'istanza se imposti i tag
• compute.instances.setLabels sull'istanza se imposti le etichette
• compute.instances.setServiceAccount sull'istanza se imposti l'account di servizio
• compute.images.useReadOnly sull'immagine se crei un nuovo disco permanente radice
• compute.disks.create nel progetto se crei un nuovo disco permanente radice con questa istanza
• compute.disks.useReadOnly sul disco se colleghi un disco permanente esistente in modalità di sola lettura
• compute.disks.use sul disco se colleghi un disco esistente in modalità di lettura/scrittura
• compute.disks.setLabels sul disco se imposti etichette
• compute.snapshots.create nel progetto per creare un nuovo snapshot se viene creata un'istanza da uno snapshot
• compute.snapshots.useReadOnly sullo snapshot se crei un'istanza da uno snapshot
• compute.instanceTemplates.useReadOnly sul modello di istanza se crei l'istanza dal modello di istanza

Console

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

   Vai a Crea un'istanza

2. Specifica un nome per la VM. Per saperne di più, vedi Convenzione di denominazione delle risorse.
3. (Facoltativo) Modifica la zona per questa VM. Compute Engine randomizza l'elenco delle zone di ciascuna regione per incoraggiarne l'utilizzo in più zone.
4. Seleziona una configurazione delle macchine per la tua VM.
5. Nella sezione Disco di avvio, fai clic su Cambia per configurare il disco di avvio, quindi procedi nel seguente modo:
1. Seleziona la scheda Immagini personalizzate.
2. Per selezionare il progetto immagine, fai clic su Seleziona un progetto e poi procedi nel seguente modo:
   1. Seleziona il progetto che contiene l'immagine.
   2. Fai clic su Apri.
3. Nell'elenco Immagine, fai clic sull'immagine da importare.
4. Seleziona il tipo e la dimensione del disco di avvio.
5. Per confermare le opzioni del disco di avvio, fai clic su Seleziona.

6. Per consentire il traffico HTTP o HTTPS verso la 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 regola firewall in entrata corrispondente 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 saperne di più, consulta la panoramica delle regole firewall nella documentazione di Virtual Private Cloud.

7. Per avviare e creare una VM, fai clic su Crea.

gcloud

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

 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

API

Il processo di creazione di una VM con un'immagine condivisa nell'API è lo stesso di 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: 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, predefinita o personalizzata, per la nuova VM
• VM_NAME: nome della nuova VM
• IMAGE_PROJECT: nome del progetto contenente l'immagine condivisa
• IMAGE o IMAGE_FAMILY: specifica una delle seguenti opzioni:
  • IMAGE: 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 come parte di una famiglia di immagini personalizzate, specifica tale famiglia.

    In questo modo la VM viene creata dall'immagine del sistema operativo più recente e non deprecata nella tua famiglia di immagini personalizzate. Ad esempio, se specifichi "sourceImage": "projects/finance-project-1234/global/images/family/finance-debian-family", Compute Engine crea una VM dall'ultima versione dell'immagine del sistema operativo nella famiglia di immagini finance-debian-family personalizzate.

• NETWORK_NAME: la rete VPC che vuoi utilizzare per la VM. Puoi specificare default in modo che utilizzi la rete predefinita.
• ENABLE_SECURE_BOOT: (facoltativo) se scegli un'immagine che supporta le funzionalità VM schermate, Compute Engine, per impostazione predefinita, abilita il modulo Virtual Trusted Platform Platform (vTPM) e il monitoraggio dell'integrità. Compute Engine non abilita 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 avvia la tua VM, per modificare le opzioni della Shielded VM 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 di una 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 le istruzioni, consulta Ripristino di uno snapshot del disco di avvio su una nuova VM.

• Ripristino di un disco non di avvio: se hai eseguito il backup di un disco non di avvio con snapshot, puoi ripristinare lo snapshot su un nuovo disco non di avvio quando crei una VM. Per le istruzioni, consulta Creazione di una VM con un disco non di avvio basato su uno snapshot.

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

Crea un'istanza VM da un'immagine container

Per eseguire il deployment e avviare un container su una VM di Compute Engine, specifica il nome dell'immagine container e i parametri di configurazione facoltativi quando crei la VM. Compute Engine crea la VM utilizzando la versione più recente dell'immagine pubblica del sistema operativo ottimizzata per i container, con Docker installato. Quindi, Compute Engine avvia il container all'avvio della VM. Per saperne di più, consulta Deployment di container sulle VM.

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

Autorizzazioni richieste per questa attività

Per eseguire questa attività, devi disporre delle seguenti autorizzazioni:

• compute.instances.create nel progetto
• compute.instances.updateShieldedVmConfig se prevedi di creare un'istanza VM schermata e vuoi poter modificare qualsiasi impostazione della VM schermata
• compute.networks.use sul progetto se utilizzi una rete legacy
• compute.subnetworks.use sull'intero progetto o sulla subnet scelta (reti VPC)
• compute.networks.useExternalIp nel progetto se devi assegnare un indirizzo IP esterno (temporaneo o statico) all'istanza utilizzando una rete legacy
• compute.subnetworks.useExternalIp sull'intero progetto o sulla subnet scelta se devi assegnare un indirizzo IP esterno (temporaneo o statico) all'istanza utilizzando una rete VPC
• compute.addresses.use sul progetto se specifichi un indirizzo statico nel progetto
• compute.instances.setMetadata se imposti i metadati
• compute.instances.setTags sull'istanza se imposti i tag
• compute.instances.setLabels sull'istanza se imposti le etichette
• compute.instances.setServiceAccount sull'istanza se imposti l'account di servizio
• compute.images.useReadOnly sull'immagine se crei un nuovo disco permanente radice
• compute.disks.create nel progetto se crei un nuovo disco permanente radice con questa istanza
• compute.disks.useReadOnly sul disco se colleghi un disco permanente esistente in modalità di sola lettura
• compute.disks.use sul disco se colleghi un disco esistente in modalità di lettura/scrittura
• compute.disks.setLabels sul disco se imposti etichette
• compute.snapshots.create nel progetto per creare un nuovo snapshot se viene creata un'istanza da uno snapshot
• compute.snapshots.useReadOnly sullo snapshot se crei un'istanza da uno snapshot
• compute.instanceTemplates.useReadOnly sul modello di istanza se crei l'istanza dal modello di istanza

Console

1. Nella console Google Cloud, vai alla pagina Istanze VM.

   Vai a Istanze VM

2. Seleziona il progetto e fai clic su Continua.

3. Fai clic su Crea istanza.

4. Specifica un nome per la VM. Per ulteriori informazioni, consulta la convenzione di denominazione delle risorse.

5. Nella sezione Container, fai clic su Esegui il deployment del container.

   1. Specifica l'immagine 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 avanzate per i contenitori. Per ulteriori informazioni, consulta Configurare le opzioni per eseguire il container.

6. Per creare la VM, avviarla e avviare il container, fai clic su Crea.

gcloud

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: nome dell'immagine container.

Ad esempio, il comando seguente crea una VM denominata nginx-vm, che avvia ed esegue l'immagine container:

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 con accesso ad altri servizi Google Cloud

Se prevedi di eseguire un'applicazione sulla tua VM che deve accedere ad altri servizi Google Cloud, crea un account di servizio prima di creare la VM, quindi configura la VM per l'esecuzione come account di servizio. Un account di servizio è un account speciale le cui credenziali puoi utilizzare nel codice dell'applicazione per accedere ad altri servizi Google Cloud.

Per ulteriori informazioni, consulta Account di servizio.

Crea un'istanza VM in una subnet specifica

Autorizzazioni richieste per questa attività

Per eseguire questa attività, devi disporre delle seguenti autorizzazioni:

• compute.instances.create nel progetto
• compute.instances.updateShieldedVmConfig se prevedi di creare un'istanza VM schermata e vuoi poter modificare qualsiasi impostazione della VM schermata
• compute.networks.use sul progetto se utilizzi una rete legacy
• compute.subnetworks.use sull'intero progetto o sulla subnet scelta (reti VPC)
• compute.networks.useExternalIp nel progetto se devi assegnare un indirizzo IP esterno (temporaneo o statico) all'istanza utilizzando una rete legacy
• compute.subnetworks.useExternalIp sull'intero progetto o sulla subnet scelta se devi assegnare un indirizzo IP esterno (temporaneo o statico) all'istanza utilizzando una rete VPC
• compute.addresses.use sul progetto se specifichi un indirizzo statico nel progetto
• compute.instances.setMetadata se imposti i metadati
• compute.instances.setTags sull'istanza se imposti i tag
• compute.instances.setLabels sull'istanza se imposti le etichette
• compute.instances.setServiceAccount sull'istanza se imposti l'account di servizio
• compute.images.useReadOnly sull'immagine se crei un nuovo disco permanente radice
• compute.disks.create nel progetto se crei un nuovo disco permanente radice con questa istanza
• compute.disks.useReadOnly sul disco se colleghi un disco permanente esistente in modalità di sola lettura
• compute.disks.use sul disco se colleghi un disco esistente in modalità di lettura/scrittura
• compute.disks.setLabels sul disco se imposti etichette
• compute.snapshots.create nel progetto per creare un nuovo snapshot se viene creata un'istanza da uno snapshot
• compute.snapshots.useReadOnly sullo snapshot se crei un'istanza da uno snapshot
• compute.instanceTemplates.useReadOnly sul modello di istanza se crei l'istanza dal modello di istanza

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 quando crei la 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 trovano nella stessa regione della VM.
• Se non specifichi una rete, Compute Engine deduce la rete dalla subnet specificata.
• Se specifichi una rete, devi specificare una subnet che deve appartenere alla stessa rete. In caso contrario, la creazione della VM non riesce.

Nota: prima di creare la VM devi creare la subnet che vuoi utilizzare. Per ulteriori informazioni, consulta la pagina Aggiungere una nuova subnet a una rete VPC esistente.

Console

1. Nella console Google Cloud, vai alla pagina Istanze VM.

   Vai a Istanze VM

2. Seleziona il progetto e fai clic su Continua.

3. Fai clic su Crea istanza.

4. Specifica un nome per la VM. Per ulteriori informazioni, consulta la convenzione di denominazione delle risorse.

5. (Facoltativo) Modifica la zona per questa VM. Compute Engine randomizza l'elenco delle zone all'interno di ciascuna regione per incoraggiarne l'utilizzo in più zone.

6. 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 tua VM e crea la regola firewall in entrata corrispondente 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 Virtual Private Cloud.

7. Espandi la sezione Networking, dischi, sicurezza, gestione, single tenancy.

   1. Espandi la sezione Networking.
   2. Per Interfacce di rete, specifica i dettagli della rete:
      1. Nel campo Rete, seleziona la rete VPC che contiene la subnet che hai creato.
      2. Nel campo Subnet, seleziona la subnet da utilizzare per la VM.
      3. Fai clic su Fine.

8. Per creare e avviare la VM, fai clic su Crea.

gcloud

Utilizzando Google Cloud CLI, segui le stesse istruzioni per creare una VM da un'immagine o una istantanea e aggiungere 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: nome della VM
• (Facoltativo) NETWORK_NAME: nome della rete

• SUBNET_NAME: nome della subnet

  Per visualizzare un elenco di subnet nella rete, utilizza il comando gcloud compute networks subnets list.

• ZONE: 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 risorsa google_compute_instance.

compute/basic_vm/main.tf

Visualizza su GitHub Feedback

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

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

API

Segui le istruzioni dell'API per creare una VM da un'immagine o da uno snapshot, ma specifica il campo subnet nel corpo della richiesta. Per aggiungere dischi vuoti, non aggiungere un'immagine di origine. Facoltativamente, 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: 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, predefinita o personalizzata, per la nuova VM
• VM_NAME: nome della nuova VM
• IMAGE_PROJECT: progetto contenente l'immagine
  Ad esempio, se specifichi debian-10 come famiglia di immagini, specifica debian-cloud come progetto immagine.
• 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
    In questo modo la VM viene creata dall'immagine del sistema operativo più recente e non deprecata. Ad esempio, se specifichi "sourceImage": "projects/debian-cloud/global/images/family/debian-10", Compute Engine crea una VM dall'ultima versione 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 in modo che utilizzi la rete predefinita.
• REGION: regione in cui esiste la subnet specificata
• SUBNET_NAME: nome della subnet
• ENABLE_SECURE_BOOT: (facoltativo) se scegli un'immagine che supporta le funzionalità VM schermate, Compute Engine, per impostazione predefinita, abilita il modulo Virtual Trusted Platform Platform (vTPM) e il monitoraggio dell'integrità. Compute Engine non abilita 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 avvia la tua VM, per modificare le opzioni della Shielded VM devi arrestarla.

Go

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

Visualizza su GitHub Feedback

import (
	"context"
	"fmt"
	"io"

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

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

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

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

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

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

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

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

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

	return nil
}

Java

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

Visualizza su GitHub Feedback

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

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

Visualizza su GitHub Feedback

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

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

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

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

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

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

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

createInstanceWithSubnet();

Python

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

Visualizza su GitHub Feedback

import re
import sys
from typing import Any, List
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=sy