Questa pagina è stata tradotta dall'API Cloud Translation.

Esegui il ripristino da uno snapshot

Un disco è un disco di avvio utilizzato per avviare ed eseguire il sistema operativo su un'istanza di calcolo o un disco non di avvio che un'istanza utilizza solo per l'archiviazione dei dati.

Puoi utilizzare gli snapshot per eseguire il backup e il ripristino dei dati del disco nei seguenti modi:

Dopo aver creato uno snapshot di un disco di avvio o non di avvio, crea un nuovo disco basato sullo snapshot.
Dopo aver creato uno snapshot di un disco di avvio, crea una nuova istanza basata sullo snapshot del disco di avvio.
Dopo aver creato uno snapshot di un disco non di avvio, crea una nuova istanza con un nuovo disco non di avvio basato sullo snapshot.

Prima di iniziare

Se non l'hai ancora fatto, configura l'autenticazione. L'autenticazione è il processo mediante il quale la tua identità viene verificata per l'accesso ai Google Cloud servizi e alle API. Per eseguire codice o esempi da un ambiente di sviluppo locale, puoi autenticarti su Compute Engine selezionando una delle seguenti opzioni:

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

When you use the Google Cloud console to access Google Cloud services and APIs, you don't need to set up authentication.
gcloud

Ruoli obbligatori

Per ottenere le autorizzazioni necessarie per il ripristino da uno snapshot, chiedi all'amministratore di concederti il ruolo IAM Compute Instance Admin (v1) (roles/compute.instanceAdmin.v1) nel progetto. Per saperne di più sulla concessione dei ruoli, consulta Gestisci l'accesso a progetti, cartelle e organizzazioni.

Questo ruolo predefinito contiene le autorizzazioni necessarie per il ripristino da uno snapshot. Per vedere quali sono esattamente le autorizzazioni richieste, espandi la sezione Autorizzazioni obbligatorie:

Autorizzazioni obbligatorie

Per eseguire il ripristino da uno snapshot sono necessarie le seguenti autorizzazioni:

Per creare un disco da uno snapshot con ambito globale (impostazione predefinita):
- compute.disks.create sul progetto
- compute.instances.attachDisk sull'istanza
- compute.disks.use sul disco da collegare
- compute.snapshots.useReadOnly, compute.snapshots.create o compute.disks.createSnapshot sul progetto
(Anteprima) Per creare un disco da uno snapshot con ambito regionale:
- compute.disks.create sul progetto
- compute.instances.attachDisk sull'istanza
- compute.disks.use sul disco da collegare
- compute.snapshots.useReadOnly sul progetto
Per creare un'istanza da uno snapshot del disco di avvio e del disco non di avvio, devi disporre almeno delle seguenti autorizzazioni:
- compute.instances.create sul progetto
- compute.snapshots.useReadOnly nello snapshot
- compute.disks.create sul progetto
- compute.disks.use nel disco
- compute.instances.attachDisk sull'istanza

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

Limitazioni

Il nuovo disco deve avere almeno le stesse dimensioni del disco di origine originale per lo snapshot. Se crei un disco più grande del disco di origine originale per lo snapshot, devi ridimensionare il file system su quel disco per includere lo spazio su disco aggiuntivo. A seconda del sistema operativo e del tipo di file system, potresti dover utilizzare uno strumento di ridimensionamento del file system diverso. Per saperne di più, consulta la documentazione del sistema operativo.
Puoi creare un nuovo disco zonale o regionale da un determinato snapshot al massimo una volta ogni dieci minuti. Se vuoi inviare un burst di richieste per creare snapshot dei tuoi dischi, puoi inviare al massimo 6 richieste in 60 minuti. Questo limite non si applica quando crei dischi regionali da uno snapshot. Per saperne di più, consulta la sezione Limiti di frequenza degli snapshot.

Crea un disco da uno snapshot e, se vuoi, collegalo a un'istanza

Se hai eseguito il backup di un disco di avvio o non di avvio con uno snapshot, puoi creare un nuovo disco basato sullo snapshot.

Console

Nella console Google Cloud vai alla pagina Snapshot.

Vai a Snapshot
Trova il nome dello snapshot da ripristinare.
Vai alla pagina Dischi.

Vai alla pagina Dischi
Fai clic su Crea nuovo disco.
Specifica i seguenti parametri di configurazione:
- Un nome per il disco.
- Un tipo per il disco.
- Se vuoi, puoi ignorare la selezione predefinita di regione e zona. Puoi selezionare qualsiasi regione e zona, indipendentemente dalla posizione di archiviazione dello snapshot di origine.
In Tipo di origine, fai clic su Snapshot.
Seleziona il nome dello snapshot da ripristinare.
Seleziona le dimensioni del nuovo disco, in gigabyte. Questo numero deve essere uguale o maggiore del disco di origine originale dello snapshot.
Fai clic su Crea per creare il disco.

Se vuoi, puoi collegare un disco non di avvio a un'istanza.

gcloud

Utilizza il comando gcloud compute snapshots list per trovare il nome dello snapshot da ripristinare:
```
gcloud compute snapshots list
```
Utilizza il comando gcloud compute snapshots describe per trovare le dimensioni dello snapshot da ripristinare:
```
gcloud compute snapshots describe SNAPSHOT_NAME
```
Sostituisci SNAPSHOT_NAME con il nome dello snapshot da ripristinare.
Utilizza il comando gcloud compute disks create per creare un nuovo disco regionale o di zona dallo snapshot. Puoi includere il flag --type per specificare il tipo di disco da creare.
- Per creare un disco di zona da uno snapshot con ambito globale:
```
gcloud compute disks create DISK_NAME \
    --zone=ZONE \
    --size=DISK_SIZE \
    --source-snapshot=SNAPSHOT_NAME \
    --type=DISK_TYPE
```
- (Anteprima) Per creare un disco di zona da uno snapshot con ambito regionale:
```
gcloud beta compute disks create DISK_NAME \
    --zone=ZONE \
    --source-snapshot=SNAPSHOT_NAME \
    --source-snapshot-region=SOURCE_REGION \
    --type=DISK_TYPE
```
- Per creare un disco regionale da uno snapshot con ambito globale:
```
gcloud beta compute disks create DISK_NAME \
    --size=DISK_SIZE \
    --source-snapshot=SNAPSHOT_NAME \
    --type=DISK_TYPE \
    --region=REGION \
    --replica-zones=ZONE1,ZONE2
```
- (Anteprima) Per creare un disco regionale da uno snapshot con ambito regionale:
```
gcloud beta compute disks create DISK_NAME \
    --size=DISK_SIZE \
    --source-snapshot=SNAPSHOT_NAME \
    --source-snapshot-region=SOURCE_REGION \
    --type=DISK_TYPE \
    --region=REGION \
    --replica-zones=ZONE1,ZONE2
```
Sostituisci quanto segue:
- DISK_NAME: il nome del nuovo disco
- DISK_SIZE: le dimensioni del nuovo disco, in gibibyte (GiB). Questo numero deve essere uguale o maggiore del disco di origine originale per lo snapshot.
- SNAPSHOT_NAME: il nome dello snapshot da ripristinare
- DISK_TYPE: il tipo di disco, ad esempio, pd-ssd, hyperdisk-throughput o hyperdisk-balanced-high-availability
- REGION: la regione in cui deve risiedere il disco regionale, ad esempio: europe-west1
- SOURCE_REGION: la regione a cui è applicato lo snapshot di origine.
- ZONE: la zona in cui si troverà il nuovo disco
- ZONE1,ZONE2: le zone all'interno della regione in cui si trovano le due repliche del disco, ad esempio europe-west1-b e europe-west1-c
(Facoltativo) Collega il nuovo disco a un'istanza esistente utilizzando il comando gcloud compute instances attach-disk:
```
gcloud compute instances attach-disk INSTANCE_NAME \
    --disk DISK_NAME
```
Sostituisci quanto segue:
- INSTANCE_NAME: il nome dell'istanza
- DISK_NAME: il nome del disco creato dallo snapshot

Vai

Go

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

Per effettuare l'autenticazione in Compute Engine, configura le Credenziali predefinite dell'applicazione. Per ulteriori informazioni, consulta Configura l'autenticazione per un ambiente di sviluppo locale.

import (
	"context"
	"fmt"
	"io"

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

// createDiskFromSnapshot creates a new disk in a project in given zone.
func createDiskFromSnapshot(
	w io.Writer,
	projectID, zone, diskName, diskType, snapshotLink string,
	diskSizeGb int64,
) error {
	// projectID := "your_project_id"
	// zone := "us-west3-b" // should match diskType below
	// diskName := "your_disk_name"
	// diskType := "zones/us-west3-b/diskTypes/pd-ssd"
	// snapshotLink := "projects/your_project_id/global/snapshots/snapshot_name"
	// diskSizeGb := 120

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

	req := &computepb.InsertDiskRequest{
		Project: projectID,
		Zone:    zone,
		DiskResource: &computepb.Disk{
			Name:           proto.String(diskName),
			Zone:           proto.String(zone),
			Type:           proto.String(diskType),
			SourceSnapshot: proto.String(snapshotLink),
			SizeGb:         proto.Int64(diskSizeGb),
		},
	}

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

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

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

	return nil
}

Java

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


import com.google.cloud.compute.v1.Disk;
import com.google.cloud.compute.v1.DisksClient;
import com.google.cloud.compute.v1.InsertDiskRequest;
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 CreateDiskFromSnapshot {

  public static void main(String[] args)
      throws IOException, ExecutionException, InterruptedException, TimeoutException {
    // TODO(developer): Replace these variables before running the sample.

    // Project ID or project number of the Cloud project you want to use.
    String projectId = "YOUR_PROJECT_ID";

    // Name of the zone in which you want to create the disk.
    String zone = "europe-central2-b";

    // Name of the disk you want to create.
    String diskName = "YOUR_DISK_NAME";

    // 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"
    String diskType = String.format("zones/%s/diskTypes/pd-ssd", zone);

    // Size of the new disk in gigabytes.
    long diskSizeGb = 10;

    // The full path and name of the snapshot that you want to use as the source for the new disk.
    // This value uses the following format:
    // "projects/{projectName}/global/snapshots/{snapshotName}"
    String snapshotLink = String.format("projects/%s/global/snapshots/%s", projectId,
        "SNAPSHOT_NAME");

    createDiskFromSnapshot(projectId, zone, diskName, diskType, diskSizeGb, snapshotLink);
  }

  // Creates a new disk in a project in given zone, using a snapshot.
  public static void createDiskFromSnapshot(String projectId, String zone, String diskName,
      String diskType, long diskSizeGb, String snapshotLink)
      throws IOException, ExecutionException, InterruptedException, TimeoutException {

    // 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 `disksClient.close()` method on the client to safely
    // clean up any remaining background resources.
    try (DisksClient disksClient = DisksClient.create()) {

      // Set the disk properties and the source snapshot.
      Disk disk = Disk.newBuilder()
          .setName(diskName)
          .setZone(zone)
          .setSizeGb(diskSizeGb)
          .setType(diskType)
          .setSourceSnapshot(snapshotLink)
          .build();

      // Create the insert disk request.
      InsertDiskRequest insertDiskRequest = InsertDiskRequest.newBuilder()
          .setProject(projectId)
          .setZone(zone)
          .setDiskResource(disk)
          .build();

      // Wait for the create disk operation to complete.
      Operation response = disksClient.insertAsync(insertDiskRequest)
          .get(3, TimeUnit.MINUTES);

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

Node.js

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

/**
 * TODO(developer): Uncomment and replace these variables before running the sample.
 */
// const projectId = 'YOUR_PROJECT_ID';
// const zone = 'europe-central2-b';
// const diskName = 'YOUR_DISK_NAME';
// const diskType = 'zones/us-west3-b/diskTypes/pd-ssd';
// const diskSizeGb = 10;
// const snapshotLink = 'projects/project_name/global/snapshots/snapshot_name';

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

async function createDiskFromSnapshot() {
  const disksClient = new compute.DisksClient();

  const [response] = await disksClient.insert({
    project: projectId,
    zone,
    diskResource: {
      sizeGb: diskSizeGb,
      name: diskName,
      zone,
      type: diskType,
      sourceSnapshot: snapshotLink,
    },
  });
  let operation = response.latestResponse;
  const operationsClient = new compute.ZoneOperationsClient();

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

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

createDiskFromSnapshot();

Python

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

from __future__ import annotations

import sys
from typing import Any

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


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_disk_from_snapshot(
    project_id: str,
    zone: str,
    disk_name: str,
    disk_type: str,
    disk_size_gb: int,
    snapshot_link: str,
) -> compute_v1.Disk:
    """
    Creates a new disk in a project in given zone.

    Args:
        project_id: project ID or project number of the Cloud project you want to use.
        zone: name of the zone in which you want to create the disk.
        disk_name: name of the disk you want to create.
        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
        snapshot_link: a link to the snapshot you want to use as a source for the new disk.
            This value uses the following format: "projects/{project_name}/global/snapshots/{snapshot_name}"

    Returns:
        An unattached Disk instance.
    """
    disk_client = compute_v1.DisksClient()
    disk = compute_v1.Disk()
    disk.zone = zone
    disk.size_gb = disk_size_gb
    disk.source_snapshot = snapshot_link
    disk.type_ = disk_type
    disk.name = disk_name
    operation = disk_client.insert(project=project_id, zone=zone, disk_resource=disk)

    wait_for_extended_operation(operation, "disk creation")

    return disk_client.get(project=project_id, zone=zone, disk=disk_name)

REST

Crea una richiesta GET di snapshots.list per visualizzare l'elenco degli snapshot nel tuo progetto.
```
GET https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/global/snapshots
```
Sostituisci PROJECT_ID con l'ID progetto.
Crea una richiesta POST per creare un disco di zona o un disco regionale utilizzando il rispettivo metodo disks.insert:
- Per i dischi zonali: disks.insert
- Per i dischi regionali: regionDisks.insert
Includi le proprietà name, sizeGb e type. Per ripristinare un disco utilizzando uno snapshot, devi includere la proprietà sourceSnapshot.
- Per creare un disco di zona da uno snapshot con ambito globale:
```
POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/zones/ZONE/disks
{
  "name": "DISK_NAME",
  "sourceSnapshot": "SNAPSHOT_NAME",
  "sizeGb": "DISK_SIZE",
  "type": "zones/ZONE/diskTypes/DISK_TYPE"
}
```
- (Anteprima) Per creare un disco di zona da uno snapshot con ambito regionale:
```
POST https://compute.googleapis.com/compute/beta/projects/PROJECT_ID/zones/ZONE/disks
{
  "name": "DISK_NAME",
  "sourceSnapshot": "projects/PROJECT_ID/regions/SOURCE_REGION/snapshots/SNAPSHOT_NAME",
  "sizeGb": "DISK_SIZE",
  "type": "projects/PROJECT_ID/zones/ZONE/diskTypes/DISK_TYPE",
  "zone": "projects/PROJECT_ID/zones/ZONE"
}
```
- Per creare un disco regionale da uno snapshot con ambito globale:
```
POST https://compute.googleapis.com/compute/beta/projects/PROJECT_ID/regions/REGION/disks
{
  "name": "DISK_NAME",
  "sourceSnapshot": "SNAPSHOT_NAME",
  "region": "projects/PROJECT_ID/regions/REGION",
  "replicaZones": [
     "projects/PROJECT_ID/zones/ZONE1",
     "projects/PROJECT_ID/zones/ZONE2"
  ],
  "sizeGb": "DISK_SIZE",
  "type": "zones/ZONE/diskTypes/DISK_TYPE"
}
```
- (Anteprima) Per creare un disco regionale da uno snapshot con ambito regionale:
```
POST https://compute.googleapis.com/compute/beta/projects/PROJECT_ID/regions/REGION/disks
{
  "name": "DISK_NAME",
  "sourceSnapshot": "projects/PROJECT_ID/regions/SOURCE_REGION/snapshots/SNAPSHOT_NAME",
  "replicaZones": [
     "projects/PROJECT_ID/zones/ZONE1",
     "projects/PROJECT_ID/zones/ZONE2"
  ],
  "sizeGb": "DISK_SIZE",
  "type": "projects/PROJECT_ID/regions/REGION/diskTypes/DISK_TYPE"
}
```
Sostituisci quanto segue:
- PROJECT_ID: il tuo ID progetto
- ZONE: la zona in cui si trovano l'istanza e il nuovo disco
- DISK_NAME: il nome del nuovo disco
- SNAPSHOT_NAME: lo snapshot di origine del disco che stai ripristinando
- REGION: la regione in cui deve risiedere il disco regionale, ad esempio: europe-west1
- SOURCE_REGION: la regione a cui è applicato lo snapshot di origine.
- ZONE1, ZONE2: le zone in cui devono trovarsi le repliche del nuovo disco
- DISK_SIZE: le dimensioni del nuovo disco, in gibibyte (GiB). Questo numero deve essere uguale o maggiore del disco di origine originale per lo snapshot.
- DISK_TYPE: URL completo o parziale del tipo di disco, ad esempio, PROJECT_ID/zones/ZONE/diskTypes/pd-ssd, PROJECT_ID/zones/ZONE/diskTypes/hyperdisk-balanced o PROJECT_ID/zones/ZONE/diskTypes/hyperdisk-balanced-high-availability
Facoltativo. Collega il nuovo disco a un'istanza esistente.

Crea una richiesta POST al metodo instances.attachDisk e includi l'URL del disco appena creato dallo snapshot.

Per i dischi zonali:
```
POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/zones/ZONE/instances/INSTANCE_NAME/attachDisk
{
  "source": "/compute/v1/projects/PROJECT_ID/zones/ZONE/disks/DISK_NAME"
}
```
Per i dischi regionali:
```
POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/zones/ZONE/instances/INSTANCE_NAME/attachDisk
{
  "source": "/compute/v1/projects/PROJECT_ID/regions/REGION/disks/DISK_NAME"
}
```
Sostituisci quanto segue:
- PROJECT_ID: il tuo ID progetto
- ZONE: la zona in cui si trovano l'istanza e il nuovo disco
- REGION: la regione in cui si trova il disco regionale. Deve essere la stessa regione in cui si trova l'istanza di Compute.
- INSTANCE_NAME: il nome dell'istanza a cui stai aggiungendo il nuovo disco
- DISK_NAME: il nome del nuovo disco

Dopo aver creato e collegato un nuovo disco a un'istanza, devi montare il disco in modo che il sistema operativo possa utilizzare lo spazio di archiviazione disponibile.

Crea un'istanza da dischi esistenti

Puoi creare dischi di avvio e dischi dati dagli snapshot e poi collegarli a una nuova istanza di Compute.

Vai

Go

import (
	"context"
	"fmt"
	"io"

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

// createWithExistingDisks create a new VM instance using selected disks.
// The first disk in diskNames will be used as boot disk.
func createWithExistingDisks(
	w io.Writer,
	projectID, zone, instanceName string,
	diskNames []string,
) error {
	// projectID := "your_project_id"
	// zone := "europe-central2-b"
	// instanceName := "your_instance_name"
	// diskNames := []string{"boot_disk", "disk1", "disk2"}

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

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

	disks := [](*computepb.Disk){}

	for _, diskName := range diskNames {
		reqDisk := &computepb.GetDiskRequest{
			Project: projectID,
			Zone:    zone,
			Disk:    diskName,
		}

		disk, err := disksClient.Get(ctx, reqDisk)
		if err != nil {
			return fmt.Errorf("unable to get disk: %w", err)
		}

		disks = append(disks, disk)
	}

	attachedDisks := [](*computepb.AttachedDisk){}

	for _, disk := range disks {
		attachedDisk := &computepb.AttachedDisk{
			Source: proto.String(disk.GetSelfLink()),
		}
		attachedDisks = append(attachedDisks, attachedDisk)
	}

	attachedDisks[0].Boot = proto.Bool(true)

	instanceResource := &computepb.Instance{
		Name:        proto.String(instanceName),
		Disks:       attachedDisks,
		MachineType: proto.String(fmt.Sprintf("zones/%s/machineTypes/n1-standard-1", zone)),
		NetworkInterfaces: []*computepb.NetworkInterface{
			{
				Name: proto.String("global/networks/default"),
			},
		},
	}

	req := &computepb.InsertInstanceRequest{
		Project:          projectID,
		Zone:             zone,
		InstanceResource: instanceResource,
	}

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

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

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

	return nil
}

Java


import com.google.cloud.compute.v1.AttachedDisk;
import com.google.cloud.compute.v1.Disk;
import com.google.cloud.compute.v1.DisksClient;
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.ArrayList;
import java.util.List;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.TimeoutException;

public class CreateInstanceWithExistingDisks {

  public static void main(String[] args)
      throws IOException, ExecutionException, InterruptedException, TimeoutException {
    // TODO(developer): Replace these variables before running the sample.

    // Project ID or project number of the Cloud project you want to use.
    String projectId = "YOUR_PROJECT_ID";

    // Name of the zone to create the instance in. For example: "us-west3-b"
    String zone = "europe-central2-b";

    // Name of the new virtual machine (VM) instance.
    String instanceName = "YOUR_INSTANCE_NAME";

    // Array of disk names to be attached to the new virtual machine.
    // First disk in this list will be used as the boot disk.
    List<String> diskNames = List.of("your-boot-disk", "another-disk1", "another-disk2");

    createInstanceWithExistingDisks(projectId, zone, instanceName, diskNames);
  }

  // Create a new VM instance using the selected disks.
  // The first disk in diskNames will be used as the boot disk.
  public static void createInstanceWithExistingDisks(String projectId, String zone,
      String instanceName, List<String> diskNames)
      throws IOException, ExecutionException, InterruptedException, TimeoutException {

    // 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();
        DisksClient disksClient = DisksClient.create()) {

      if (diskNames.size() == 0) {
        throw new Error("At least one disk should be provided");
      }

      // Create the list of attached disks to be used in instance creation.
      List<AttachedDisk> attachedDisks = new ArrayList<>();
      for (int i = 0; i < diskNames.size(); i++) {
        String diskName = diskNames.get(i);
        Disk disk = disksClient.get(projectId, zone, diskName);
        AttachedDisk attDisk = null;

        if (i == 0) {
          // Make the first disk in the list as the boot disk.
          attDisk = AttachedDisk.newBuilder()
              .setSource(disk.getSelfLink())
              .setBoot(true)
              .build();
        } else {
          attDisk = AttachedDisk.newBuilder()
              .setSource(disk.getSelfLink())
              .build();
        }
        attachedDisks.add(attDisk);
      }

      // Create the instance.
      Instance instance = Instance.newBuilder()
          .setName(instanceName)
          // Add the attached disks to the instance.
          .addAllDisks(attachedDisks)
          .setMachineType(String.format("zones/%s/machineTypes/n1-standard-1", zone))
          .addNetworkInterfaces(
              NetworkInterface.newBuilder().setName("global/networks/default").build())
          .build();

      // Create the insert instance request.
      InsertInstanceRequest insertInstanceRequest = InsertInstanceRequest.newBuilder()
          .setProject(projectId)
          .setZone(zone)
          .setInstanceResource(instance)
          .build();

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

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

    }
  }
}

Node.js

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

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

async function createWithExistingDisks() {
  const instancesClient = new compute.InstancesClient();
  const disksClient = new compute.DisksClient();

  if (diskNames.length < 1) {
    throw new Error('At least one disk should be provided');
  }

  const disks = [];
  for (const diskName of diskNames) {
    const [disk] = await disksClient.get({
      project: projectId,
      zone,
      disk: diskName,
    });
    disks.push(disk);
  }

  const attachedDisks = [];

  for (const disk of disks) {
    attachedDisks.push({
      source: disk.selfLink,
    });
  }

  attachedDisks[0].boot = true;

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

createWithExistingDisks();

Python

from __future__ import annotations

import re
import sys
from typing import Any
import warnings

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


def get_disk(project_id: str, zone: str, disk_name: str) -> compute_v1.Disk:
    """
    Gets a disk from a project.

    Args:
        project_id: project ID or project number of the Cloud project you want to use.
        zone: name of the zone where the disk exists.
        disk_name: name of the disk you want to retrieve.
    """
    disk_client = compute_v1.DisksClient()
    return disk_client.get(project=project_id, zone=zone, disk=disk_name)


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

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

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

    Returns:
        Whatever the operation.result() returns.

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

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

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

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

    return result


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

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

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

    if internal_ip:
        network_interface.network_i_p = internal_ip

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

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

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

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

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

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

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

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

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

    operation = instance_client.insert(request=request)

    wait_for_extended_operation(operation, "instance creation")

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


def create_with_existing_disks(
    project_id: str, zone: str, instance_name: str, disk_names: list[str]
) -> compute_v1.Instance:
    """
    Create a new VM instance using selected disks. The first disk in disk_names will
    be used as 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.
        disk_names: list of disk names to be attached to the new virtual machine.
            First disk in this list will be used as the boot device.

    Returns:
        Instance object.
    """
    assert len(disk_names) >= 1
    disks = [get_disk(project_id, zone, disk_name) for disk_name in disk_names]
    attached_disks = []
    for disk in disks:
        adisk = compute_v1.AttachedDisk()
        adisk.source = disk.self_link
        attached_disks.append(adisk)
    attached_disks[0].boot = True
    instance = create_instance(project_id, zone, instance_name, attached_disks)
    return instance

Crea un'istanza da uno snapshot del disco di avvio

Se hai creato uno snapshot del disco di avvio di un'istanza di computing,puoi utilizzarlo per creare una nuova istanza.

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

Per creare un'istanza di Compute con un disco di avvio regionale creato da uno snapshot, utilizza Google Cloud CLI o REST.

Console

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

Vai a Crea un'istanza

Se richiesto, seleziona il progetto e fai clic su Continua. Viene visualizzata la pagina Crea un'istanza, che mostra il riquadro Configurazione macchina.
Nel riquadro Configurazione macchina, segui questi passaggi:
1. Nel campo Nome, specifica un nome per l'istanza. Per ulteriori informazioni, consulta le convenzioni per la denominazione delle risorse.
2. (Facoltativo) Nel campo Zona, seleziona una zona per l'istanza.
  
  La selezione predefinita è Qualsiasi. Se non modifichi questa selezione predefinita, Google sceglie automaticamente una zona in base al tipo di macchina e alla disponibilità.
3. Seleziona la famiglia di macchine per l'istanza. La console Google Cloud mostra le serie di macchine disponibili per la famiglia di macchine selezionata. Sono disponibili le seguenti opzioni per la famiglia di macchine:
  - Per uso generico
  - Ottimizzata per il calcolo
  - Ottimizzata per la memoria
  - Ottimizzata per l'archiviazione
  - GPU
4. Nella colonna Serie, seleziona la serie di macchine per la tua istanza.
  
  Se nel passaggio precedente hai selezionato GPU come famiglia di macchine, seleziona il tipo di GPU che preferisci. La serie di macchine viene quindi selezionata automaticamente per il tipo di GPU selezionato.
5. Nella sezione Tipo di macchina, seleziona il tipo di macchina per la tua istanza.
Nel menu di navigazione, fai clic su Sistema operativo e spazio di archiviazione. Nel riquadro Sistema operativo e spazio di archiviazione visualizzato, configura il disco di avvio seguendo questi passaggi:
1. Fai clic su Cambia. Viene visualizzato il riquadro Disco di avvio con la scheda Immagini pubbliche.
2. Fai clic su Snapshot. Viene visualizzata la scheda Snapshot.
3. Nell'elenco Snapshot, seleziona lo snapshot da utilizzare.
4. Nell'elenco Tipo di disco di avvio, seleziona il tipo di disco di avvio.
5. Nel campo Dimensioni (GB), specifica le dimensioni del disco di avvio.
6. (Facoltativo) Per le opzioni di configurazione avanzata, espandi la sezione Mostra configurazioni avanzate.
7. Per confermare le opzioni del disco di avvio e tornare al riquadro Sistema operativo e spazio di archiviazione, fai clic su Seleziona.
Nel menu di navigazione, fai clic su Networking. Nel riquadro Networking visualizzato, segui questi passaggi:
1. Vai alla sezione Firewall.
2. Per consentire il traffico HTTP o HTTPS all'istanza, seleziona Consenti traffico HTTP o Consenti traffico HTTPS.
La console Google Cloud aggiunge un tag di rete all'istanza 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 all'istanza. Per ulteriori informazioni, consulta la Panoramica delle regole firewall nella documentazione di Virtual Private Cloud.
(Facoltativo) Specifica altre opzioni di configurazione. Per ulteriori informazioni, consulta Opzioni di configurazione durante la creazione dell'istanza.
Per creare e avviare l'istanza, fai clic su Crea.

gcloud

Disco di avvio a livello di zona

Utilizza il comando gcloud compute instances create e includi il flag --source-snapshot.

   gcloud compute instances create INSTANCE_NAME  

       --source-snapshot=BOOT_SNAPSHOT_NAME  

       --boot-disk-size=BOOT_DISK_SIZE  

       --boot-disk-type=BOOT_DISK_TYPE  

       --boot-disk-device-name=BOOT_DISK_NAME

Sostituisci quanto segue:

INSTANCE_NAME: nome della nuova istanza
BOOT_SNAPSHOT_NAME: il nome dello snapshot del disco di avvio che vuoi ripristinare nel disco di avvio della nuova istanza
BOOT_DISK_SIZE: (Facoltativo) le dimensioni, in GiB, del nuovo disco di avvio

che devono essere uguali o maggiori delle dimensioni del disco di origine da cui è stato creato lo snapshot.
BOOT_DISK_TYPE: (facoltativo) il tipo del disco di avvio, ad esempio PROJECT_ID/zones/ZONE/diskTypes/pd-ssd o PROJECT_ID/zones/ZONE/diskTypes/hyperdisk-balanced
BOOT_DISK_NAME: il nome del nuovo disco di avvio per questa istanza

Disco di avvio regionale

Utilizza il comando gcloud compute instances create e includi il flag --create-disk con le proprietà source-snapshot, replica-zones e boot.

  gcloud compute instances create INSTANCE_NAME 

      --zone=ZONE 

      --create-disk=^:^name=DISK_NAME:source-snapshot=BOOT_SNAPSHOT_NAME:boot=true:type=BOOT_DISK_TYPE:replica-zones=ZONE,REMOTE_ZONE

I caratteri ^:^ specificano che i due punti : vengono utilizzati come separatore tra ciascuna delle proprietà del disco. Questo è necessario per poter utilizzare una virgola , quando specifichi le zone per replica-zones.

Sostituisci quanto segue:

INSTANCE_NAME: il nome della nuova istanza
ZONE: la zona in cui creare l'istanza
DISK_NAME: (Facoltativo) un nome per il disco.
BOOT_SNAPSHOT_NAME: il nome dello snapshot del disco di avvio che vuoi ripristinare nel disco di avvio della nuova istanza.
BOOT_DISK_TYPE: (facoltativo) tipo del disco di avvio, ad esempio pd-ssd o hyperdisk-balanced-high-availability
REMOTE_ZONE: la regione in cui viene replicato il disco di avvio. La proprietà replica-zones richiede due zone separate da una virgola e una delle zone deve essere uguale a quella dell'istanza.

Vai

Go

import (
	"context"
	"fmt"
	"io"

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

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

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

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

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

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

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

	return nil
}

Java


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

public class CreateInstancesAdvanced {

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


  /**
   * Send an instance creation request to the Compute Engine API and wait for it to complete.
   *
   * @param project project ID or project number of the Cloud project you want to use.
   * @param zone name of the zone to create the instance in. For example: "us-west3-b"
   * @param instanceName name of the new virtual machine (VM) instance.
   * @param disks a list of compute_v1.AttachedDisk objects describing the disks you want to attach
   * to your new instance.
   * @param machineType machine type of the VM being created. This value uses the following format:
   * "zones/{zone}/machineTypes/{type_name}".
   * For example: "zones/europe-west3-c/machineTypes/f1-micro"
   * @param network name of the network you want the new instance to use. For example:
   * "global/networks/default" represents the network named "default", which is created
   * automatically for each project.
   * @param subnetwork name of the subnetwork you want the new instance to use. This value uses the
   * following format: "regions/{region}/subnetworks/{subnetwork_name}"
   * @return Instance object.
   */
  private static Instance createWithDisks(String project, String zone, String instanceName,
      Vector<AttachedDisk> disks, String machineType, String network, String subnetwork)
      throws IOException, InterruptedException, ExecutionException, 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 boot disk created from a snapshot.
   *
   * @param project project ID or project number of the Cloud project you want to use.
   * @param zone name of the zone to create the instance in. For example: "us-west3-b"
   * @param instanceName name of the new virtual machine (VM) instance.
   * @param snapshotName link to the snapshot you want to use as the source of your boot disk in the
   * form of: "projects/{project_name}/global/snapshots/{snapshot_name}"
   * @return Instance object.
   */
  public static Instance createFromSnapshot(String project, String zone, String instanceName,
      String snapshotName)
      throws IOException, InterruptedException, ExecutionException, TimeoutException {
    String diskType = String.format("zones/%s/diskTypes/pd-standard", zone);
    Vector<AttachedDisk> disks = new Vector<>();
    disks.add(diskFromSnapshot(diskType, 11, true, snapshotName));
    return createWithDisks(project, zone, instanceName, disks, "n1-standard-1",
        "global/networks/default", null);
  }

Node.js

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

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

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

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

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

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

createInstanceFromSnapshot();

Python

from __future__ import annotations

import re
import sys
from typing import Any
import warnings

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


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

    Args:
         disk_type: the type of disk you want to create. This value uses the following format:
            "zones/{zone}/diskTypes/(pd-standard|pd-ssd|pd-balanced|pd-extreme)".
            For example: "zones/us-west3-b/diskTypes/pd-ssd"
        disk_size_gb: size of the new disk in gigabytes
        boot: boolean flag indicating whether this disk should be used as a boot disk of an instance
        source_snapshot: disk snapshot to use when creating this disk. You must have read access to this disk.
            This value uses the following format: "projects/{project_name}/global/snapshots/{snapshot_name}"
        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 snapshot.
    """
    disk = compute_v1.AttachedDisk()
    initialize_params = compute_v1.AttachedDiskInitializeParams()
    initialize_params.source_snapshot = source_snapshot
    initialize_params.disk_type = disk_type
    initialize_params.disk_size_gb = disk_size_gb
    disk.initialize_params = initialize_params
    # Remember to set auto_delete to True if you want the disk to be deleted when you delete
    # your VM instance.
    disk.auto_delete = auto_delete
    disk.boot = boot
    return disk


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

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

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

    Returns:
        Whatever the operation.result() returns.

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

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

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

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

    return result


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

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

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

    if internal_ip:
        network_interface.network_i_p = internal_ip

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

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

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

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

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

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

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

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

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

    operation = instance_client.insert(request=request)

    wait_for_extended_operation(operation, "instance creation")

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


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

    Args:
        project_id: project ID or project number of the Cloud project you want to use.
        zone: name of the zone to create the instance in. For example: "us-west3-b"
        instance_name: name of the new virtual machine (VM) instance.
        snapshot_link: link to the snapshot you want to use as the source of your
            boot disk in the form of: "projects/{project_name}/global/snapshots/{snapshot_name}"

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

REST

Quando utilizzi l'API per creare un'istanza da uno snapshot, si applicano le seguenti limitazioni:

Solo un disco può essere utilizzato come disco di avvio.
Devi collegare il disco di avvio come primo disco per l'istanza.
Se specifichi la proprietà source, non puoi specificare anche la proprietà initializeParams. Se fornisci un source, significa che il disco di avvio esiste già, ma la proprietà initializeParams indica che Compute Engine deve creare un nuovo disco di avvio.

Disco di avvio a livello di zona

Per creare un'istanza da uno snapshot del disco di avvio, utilizza il metodo instances.insert e specifica il campo sourceSnapshot nella proprietà disks. Puoi specificare facoltativamente le proprietà diskSizeGb e diskType per il nuovo disco di avvio.

POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/zones/ZONE/instances
{
  "name": "INSTANCE_NAME",
  "machineType": "machineTypes/MACHINE_TYPE",
  "disks": [{
     "boot": true,
     "initializeParams": {
       "sourceSnapshot": "global/snapshots/BOOT_SNAPSHOT_NAME",
       "diskSizeGb": "BOOT_DISK_SIZE",
       "diskType": "BOOT_DISK_TYPE"
      }
   }],
  "networkInterfaces": [
    {
       "nicType": "GVNIC"
    }
  ]
}

Sostituisci quanto segue:

PROJECT_ID: il tuo ID progetto
ZONE: la zona in cui vuoi creare la nuova istanza
INSTANCE_NAME: name dell'istanza a cui vuoi ripristinare uno snapshot
MACHINE_TYPE: tipo di macchina dell'istanza
BOOT_SNAPSHOT_NAME: il nome dello snapshot che vuoi utilizzare per creare il disco di avvio della nuova istanza
BOOT_DISK_SIZE: (Facoltativo) le dimensioni, in gibibyte (GiB), del nuovo disco di avvio

che devono essere uguali o maggiori delle dimensioni del disco di origine da cui è stato creato lo snapshot.
BOOT_DISK_TYPE: (facoltativo) tipo del disco di avvio, ad esempio PROJECT_ID/zones/ZONE/diskTypes/pd-ssd o PROJECT_ID/zones/ZONE/diskTypes/hyperdisk-balanced

Disco di avvio regionale

Per creare un'istanza di Compute con un disco di avvio regionale utilizzando uno snapshot del disco di avvio come origine, utilizza il metodo instances.insert e specifica i campi sourceSnapshot e replicaZones nella proprietà disks.

   POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/zones/ZONE/instances
   {
     "name": "INSTANCE_NAME",
     "disks": [
       {
         "boot": true,
         "initializeParams": {
            "sourceSnapshot": "global/snapshots/BOOT_SNAPSHOT_NAME",
            "replicaZones": [
                "projects/PROJECT_ID/zones/ZONE",
                "projects/PROJECT_ID/zones/REMOTE_ZONE"
              ],
            "diskType": "BOOT_DISK_TYPE"
         }
       }
     ],
     "networkInterfaces": [
       {
         "nicType": "GVNIC"
       }
     ]
   }

Sostituisci quanto segue:

PROJECT_ID: il tuo ID progetto
ZONE: il nome della zona in cui vuoi creare l'istanza
INSTANCE_NAME: un nome per l'istanza
BOOT_SNAPSHOT_NAME: il nome dello snapshot del disco di avvio
REMOTE_ZONE: la zona remota per il disco regionale
BOOT_DISK_TYPE: (facoltativo) type del disco di avvio, ad esempio PROJECT_ID/zones/ZONE/diskTypes/pd-ssd o PROJECT_ID/zones/ZONE/diskTypes/hyperdisk-balanced-high-availability

Crea un'istanza di calcolo da uno snapshot di un disco non di avvio

Se hai eseguito il backup di un disco non di avvio con uno snapshot, puoi creare un'istanza con un disco non di avvio aggiuntivo basato sullo snapshot.

Console

Quando ripristini snapshot non di avvio in una nuova istanza dalla console, crea prima un disco da ogni snapshot. Poi, collega i nuovi dischi quando crei l'istanza.

Ripristina ogni snapshot non di avvio su un nuovo disco.
1. Nella console Google Cloud vai alla pagina Dischi.
  
  Vai a Dischi
2. Fai clic su Crea disco.
3. Specifica un nome per il disco. Per ulteriori informazioni, consulta le convenzioni per la denominazione delle risorse.
4. Seleziona la regione e la zona per questo disco. Il disco e l'istanza devono trovarsi nella stessa zona per i dischi a livello di zona o nella stessa regione per i dischi a livello di regione.
5. Seleziona un Tipo di disco.
6. In Tipo di origine, seleziona Snapshot.
7. Nel nuovo campo Snapshot di origine, seleziona uno snapshot non di avvio che vuoi ripristinare sul nuovo disco.
8. Per creare il disco, fai clic su Crea.
Ripeti questi passaggi per creare un disco da ogni snapshot che vuoi ripristinare.
Nella console Google Cloud , vai alla pagina Istanze VM.

Vai a Istanze VM
Seleziona il progetto e fai clic su Continua.
Fai clic su Crea istanza.
Specifica un Nome per l'istanza. Per ulteriori informazioni, consulta le convenzioni per la denominazione delle risorse.
Seleziona la regione e la zona per questa istanza. Il disco e l'istanza devono trovarsi nella stessa zona per i dischi a livello di zona o nella stessa regione per i dischi a livello di regione.
Seleziona un tipo di macchina per l'istanza.
Se vuoi consentire il traffico esterno in entrata, modifica le regole Firewall per l'istanza.
Per collegare dischi all'istanza, espandi la sezione Opzioni avanzate e poi segui questi passaggi:
1. Espandi la sezione Dischi.
2. Fai clic su Collega disco esistente.
3. Nell'elenco Disco, seleziona un disco da collegare a questa istanza.
4. Nella sezione Impostazione allegato, seleziona la modalità di collegamento del disco e la regola di eliminazione. Per saperne di più sull'aggiunta di nuovi dischi, consulta Aggiungi un Persistent Disk o Aggiungi Hyperdisk.
5. Fai clic su Salva.
Ripeti questi passaggi per ogni disco che vuoi collegare.
Per creare e avviare l'istanza, fai clic su Crea.

gcloud

Crea un'istanza utilizzando il comando gcloud compute instances create. Per ogni snapshot non di avvio da ripristinare, includi il flag --create-disk e specifica un source-snapshot.

Ad esempio, per ripristinare due snapshot di dischi non di avvio in una nuova istanza, utilizza il seguente comando:

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

Sostituisci quanto segue:

INSTANCE_NAME: il nome della nuova istanza
SNAPSHOT_1_NAME e SNAPSHOT_2_NAME: i nomi degli snapshot del disco non di avvio che vuoi ripristinare
DISK_1_NAME e DISK_2_NAME: i nomi dei nuovi dischi non di avvio da creare per questa istanza
DISK_1_SIZE e DISK_2_SIZE: (facoltativo) le dimensioni, in gibibyte (GiB), di ogni nuovo disco non di avvio

Le dimensioni devono essere uguali o maggiori delle dimensioni dei dischi di origine da cui è stato creato lo snapshot.
DISK_1_TYPE e DISK_2_TYPE: (facoltativo) i tipi di disco da creare, ad esempio pd-ssd o hyperdisk-balanced

REST

Quando utilizzi REST per ripristinare uno snapshot non di avvio in una nuova istanza, si applicano le seguenti limitazioni:

Solo un disco può essere il disco di avvio.
Devi collegare il disco di avvio come primo disco per l'istanza.
Se specifichi la proprietà source, non puoi specificare anche la proprietà initializeParams. Se fornisci un source, significa che il disco di avvio esiste già, ma la proprietà initializeParams indica che Compute Engine deve creare un nuovo disco di avvio.

Crea una richiesta POST al metodo instances.insert e specifica il campo sourceSnapshot nella proprietà initializeParams. Puoi aggiungere più dischi non di avvio ripetendo la proprietà initializeParams per ogni disco non di avvio che vuoi creare. Puoi specificare facoltativamente le proprietà diskSizeGb e diskType per uno qualsiasi dei dischi che crei.

Ad esempio, per ripristinare due snapshot di dischi non di avvio in una nuova istanza, effettua la seguente richiesta:

POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/zones/ZONE/instances
{
  "name": "INSTANCE_NAME",
  "machineType": "machineTypes/MACHINE_TYPE",
  "networkInterfaces": [
    {
      "nicType": "GVNIC"
    }
  ],
  "disks": [
    {
      "autoDelete": "true",
      "boot": "true",
      "diskSizeGb": "BOOT_DISK_SIZE",
      "diskType": "BOOT_DISK_TYPE",
      "initializeParams": {
         "sourceImage": "projects/IMAGE_PROJECT/global/images/family/IMAGE_FAMILY"
      }
    },
    {
      "deviceName": "DEVICE_1_NAME",
      "initializeParams": {
         "sourceSnapshot": "global/snapshots/SNAPSHOT_1_NAME",
         "diskSizeGb": "DISK_1_SIZE",
         "diskType": "DISK_1_TYPE"
      }
    },
    {
      "deviceName": "DEVICE_2_NAME",
      "initializeParams": {
         "sourceSnapshot": "global/snapshots/SNAPSHOT_2_NAME",
         "diskSizeGb": "DISK_2_SIZE",
         "diskType": "DISK_2_TYPE"
      }
    }
  ]
}

Sostituisci quanto segue:

PROJECT_ID: il tuo ID progetto
ZONE: la zona in cui vuoi creare l'istanza
INSTANCE_NAME: un nome per la nuova istanza
MACHINE_TYPE: tipo di macchina dell'istanza
DISK_SIZE: (Facoltativo) le dimensioni, in gibibyte (GiB), del disco corrispondente

Se fornita, questa proprietà deve essere uguale o maggiore delle dimensioni del disco di origine da cui è stato creato lo snapshot.
DISK_TYPE: (Facoltativo) URL completo o parziale del tipo del disco corrispondente, ad esempio, PROJECT_ID/zones/ZONE/diskTypes/pd-ssd o , PROJECT_ID/zones/ZONE/diskTypes/hyperdisk-balanced
IMAGE_PROJECT: il progetto contenente l'immagine. Ad esempio, debian-cloud
IMAGE_FAMILY: una famiglia di immagini. In questo modo, l'istanza viene creata dall'immagine sistema operativo più recente e non deprecata della famiglia. Ad esempio, se specifichi "sourceImage": "projects/debian-cloud/global/images/family/debian-11", Compute Engine crea un'istanza utilizzando l'ultima versione dell'immagine sistema operativo nella famiglia di immagini Debian 11.
DEVICE_NAME: Facoltativo: il nome del dispositivo visualizzato nel sistema operativo guest dell'istanza
SNAPSHOT_NAME: i nomi degli snapshot del disco non di avvio corrispondenti che vuoi ripristinare su nuovi dischi nell'istanza

Esegui il ripristino da uno snapshot Mantieni tutto organizzato con le raccolte Salva e classifica i contenuti in base alle tue preferenze.

Prima di iniziare

Console

gcloud

Vai

Java

Node.js

Python

REST

Ruoli obbligatori

Autorizzazioni obbligatorie

Limitazioni

Crea un disco da uno snapshot e, se vuoi, collegalo a un'istanza

Console

gcloud

Vai

Go

Java

Java

Node.js

Node.js

Python

Python

REST

Crea un'istanza da dischi esistenti

Vai

Go

Java

Java

Node.js

Node.js

Python

Python

Crea un'istanza da uno snapshot del disco di avvio

Console

gcloud

Disco di avvio a livello di zona

Disco di avvio regionale

Vai

Go

Java

Java

Node.js

Node.js

Python

Python

REST

Disco di avvio a livello di zona

Disco di avvio regionale

Crea un'istanza di calcolo da uno snapshot di un disco non di avvio

Console

gcloud

REST

Esegui il ripristino da uno snapshot