Questa pagina è stata tradotta dall'API Cloud Translation.

Creare immagini personalizzate

Linux

Puoi creare immagini personalizzate da dischi di origine, immagini, snapshot o immagini archiviate in Cloud Storage e utilizzarle per creare istanze di macchine virtuali (VM). Le immagini personalizzate sono ideali per le situazioni in cui hai creato e modificato un disco di avvio permanente o un'immagine specifica in un determinato stato e devi salvare questo stato per creare VM.

In alternativa, puoi utilizzare lo strumento di importazione dei dischi virtuali per importare le immagini del disco di avvio in Compute Engine dai tuoi sistemi esistenti e aggiungerle all'elenco delle immagini personalizzate.

Prima di iniziare

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

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

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

Creare un'immagine personalizzata

Questa sezione descrive come creare un'immagine personalizzata su una VM Linux. Per informazioni sulla creazione di un'immagine Windows, consulta Creare un'immagine Windows.

Seleziona una posizione di archiviazione delle immagini

Quando crei un'immagine personalizzata, puoi specificare la posizione di Cloud Storage dell'immagine, escluse le posizioni con due regioni. Specificando la posizione di archiviazione delle immagini, puoi soddisfare i requisiti normativi e di conformità per la località dei dati, nonché le tue esigenze di elevata disponibilità, garantendo la ridondanza tra le regioni. Per creare, modificare ed eliminare le immagini archiviate in Cloud Storage, devi disporre del ruolo roles/compute.storageAdmin.

La funzionalità di posizione di archiviazione è facoltativa. Se non selezioni una località, Compute Engine archivia l'immagine nella regione a più aree geografiche più vicina all'origine dell'immagine. Ad esempio, quando crei un'immagine da un disco di origine situato in us-central1 e non specifichi una posizione per l'immagine personalizzata, Compute Engine la archivia nella multi-regione us.

Se l'immagine non è disponibile in una regione in cui stai creando una VM, Compute Engine la memorizza nella cache in quella regione la prima volta che crei una VM.

Per visualizzare la posizione in cui è archiviata un'immagine, utilizza il comando images describe da gcloud compute:

gcloud compute images describe IMAGE_NAME \
    --project=PROJECT_ID

Sostituisci quanto segue:

IMAGE_NAME: il nome dell'immagine.
PROJECT_ID: l'ID progetto a cui appartiene l'immagine.

Tutte le immagini esistenti prima del lancio di questa funzionalità rimangono invariate, l'unica differenza è che ora puoi visualizzare la posizione di tutte le immagini. Se hai un'immagine esistente che vuoi spostare, devi ricrearla nella nuova posizione.

Preparare la VM per un'immagine

Puoi creare un'immagine da un disco anche se è collegato a una VM in esecuzione. Tuttavia, l'immagine è più affidabile se metti la VM in uno stato più facile da acquisire. Questa sezione descrive come preparare il disco di avvio per l'immagine.

Riduci al minimo la scrittura dei dati sul disco permanente

Utilizza una delle seguenti procedure per ridurre le scritture sul disco:

Interrompi la VM in modo che possa arrestarsi e interrompere la scrittura di dati sul disco permanente.
Se non riesci ad arrestare la VM prima di creare l'immagine, riduci al minimo la quantità di scrittura sul disco e sincronizza il file system. Per ridurre al minimo la scrittura sul disco permanente:
1. Metti in pausa le app o i processi del sistema operativo che scrivono dati su quel disco permanente.
2. Se necessario, esegui un aggiornamento dell'app sul disco. Ad esempio, MySQL ha una dichiarazione FLUSH. Altre app potrebbero avere procedure simili.
3. Impedisci alle app di scrivere sul disco permanente.
4. Esegui sudo sync.

Disattiva l'opzione di eliminazione automatica per il disco

Per impostazione predefinita, l'opzione di eliminazione automatica è attivata sui dischi di avvio. Prima di creare un'immagine da un disco, disattiva l'eliminazione automatica per assicurarti che il disco non venga eliminato automaticamente quando elimini la VM.

Utilizza uno dei seguenti metodi per disattivare l'eliminazione automatica del disco.

Console

Nella console Google Cloud, vai alla pagina Istanze VM.

Vai alla pagina Istanze VM
Fai clic sul nome della VM che utilizzi come origine per creare un'immagine.

Viene visualizzata la pagina Dettagli dell'istanza VM.
Fai clic su Modifica.
Nella sezione Disco di avvio, per la Regola di eliminazione, assicurati che sia selezionata l'opzione Conserva il disco.
Fai clic su Salva.

gcloud

In Google Cloud CLI, utilizza il comando gcloud compute instances set-disk-auto-delete per disattivare l'opzione di eliminazione automatica per il disco.

gcloud compute instances set-disk-auto-delete VM_NAME \
    --no-auto-delete \
    --disk=SOURCE_DISK

Sostituisci quanto segue:

VM_NAME: il nome dell'istanza VM.
SOURCE_DISK: il nome del disco da cui vuoi creare l'immagine.

Vai

Go

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

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

import (
	"context"
	"fmt"
	"io"

	compute "cloud.google.com/go/compute/apiv1"
	computepb "cloud.google.com/go/compute/apiv1/computepb"
)

// setDiskAutodelete sets the autodelete flag of a disk to given value.
func setDiskAutoDelete(
	w io.Writer,
	projectID, zone, instanceName, diskName string, autoDelete bool,
) error {
	// projectID := "your_project_id"
	// zone := "us-west3-b"
	// instanceName := "your_instance_name"
	// diskName := "your_disk_name"
	// autoDelete := true

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

	getInstanceReq := &computepb.GetInstanceRequest{
		Project:  projectID,
		Zone:     zone,
		Instance: instanceName,
	}

	instance, err := instancesClient.Get(ctx, getInstanceReq)
	if err != nil {
		return fmt.Errorf("unable to get instance: %w", err)
	}

	diskExists := false

	for _, disk := range instance.GetDisks() {
		if disk.GetDeviceName() == diskName {
			diskExists = true
			break
		}
	}

	if !diskExists {
		return fmt.Errorf(
			"instance %s doesn't have a disk named %s attached",
			instanceName,
			diskName,
		)
	}

	req := &computepb.SetDiskAutoDeleteInstanceRequest{
		Project:    projectID,
		Zone:       zone,
		Instance:   instanceName,
		DeviceName: diskName,
		AutoDelete: autoDelete,
	}

	op, err := instancesClient.SetDiskAutoDelete(ctx, req)
	if err != nil {
		return fmt.Errorf("unable to set disk autodelete field: %w", err)
	}

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

	fmt.Fprintf(w, "disk autoDelete field updated.\n")

	return nil
}

Java

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

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


import com.google.cloud.compute.v1.Instance;
import com.google.cloud.compute.v1.InstancesClient;
import com.google.cloud.compute.v1.Operation;
import com.google.cloud.compute.v1.SetDiskAutoDeleteInstanceRequest;
import java.io.IOException;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.TimeoutException;

public class SetDiskAutodelete {

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

    // The zone of the disk that you want to modify.
    String zone = "europe-central2-b";

    // Name of the instance the disk is attached to.
    String instanceName = "YOUR_INSTANCE_NAME";

    // The name of the disk for which you want to modify the autodelete flag.
    String diskName = "YOUR_DISK_NAME";

    // The new value of the autodelete flag.
    boolean autoDelete = true;

    setDiskAutodelete(projectId, zone, instanceName, diskName, autoDelete);
  }

  // Sets the autodelete flag of a disk to given value.
  public static void setDiskAutodelete(String projectId, String zone, String instanceName,
      String diskName, boolean autoDelete)
      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()) {

      // Retrieve the instance given by the instanceName.
      Instance instance = instancesClient.get(projectId, zone, instanceName);

      // Check if the instance contains a disk that matches the given diskName.
      boolean diskNameMatch = instance.getDisksList()
          .stream()
          .anyMatch(disk -> disk.getDeviceName().equals(diskName));

      if (!diskNameMatch) {
        throw new Error(
            String.format("Instance %s doesn't have a disk named %s attached", instanceName,
                diskName));
      }

      // Create the request object.
      SetDiskAutoDeleteInstanceRequest request = SetDiskAutoDeleteInstanceRequest.newBuilder()
          .setProject(projectId)
          .setZone(zone)
          .setInstance(instanceName)
          .setDeviceName(diskName)
          // Update the autodelete property.
          .setAutoDelete(autoDelete)
          .build();

      // Wait for the update instance operation to complete.
      Operation response = instancesClient.setDiskAutoDeleteAsync(request)
          .get(3, TimeUnit.MINUTES);

      if (response.hasError()) {
        System.out.println("Failed to update Disk autodelete field!" + response);
        return;
      }
      System.out.println(
          "Disk autodelete field updated. 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 che utilizza le librerie client. Per ulteriori informazioni, consulta la documentazione di riferimento dell'API Compute Engine Node.js.

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

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

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

async function setDiskAutodelete() {
  const instancesClient = new compute.InstancesClient();

  const [instance] = await instancesClient.get({
    project: projectId,
    zone,
    instance: instanceName,
  });

  if (!instance.disks.some(disk => disk.deviceName === diskName)) {
    throw new Error(
      `Instance ${instanceName} doesn't have a disk named ${diskName} attached.`
    );
  }

  const [response] = await instancesClient.setDiskAutoDelete({
    project: projectId,
    zone,
    instance: instanceName,
    deviceName: diskName,
    autoDelete,
  });
  let operation = response.latestResponse;
  const operationsClient = new compute.ZoneOperationsClient();

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

  console.log('Disk autoDelete field updated.');
}

setDiskAutodelete();

Python

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

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

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 set_disk_autodelete(
    project_id: str, zone: str, instance_name: str, disk_name: str, autodelete: bool
) -> None:
    """
    Set the autodelete flag of a disk to given value.

    Args:
        project_id: project ID or project number of the Cloud project you want to use.
        zone: name of the zone in which is the disk you want to modify.
        instance_name: name of the instance the disk is attached to.
        disk_name: the name of the disk which flag you want to modify.
        autodelete: the new value of the autodelete flag.
    """
    instance_client = compute_v1.InstancesClient()
    instance = instance_client.get(
        project=project_id, zone=zone, instance=instance_name
    )

    for disk in instance.disks:
        if disk.device_name == disk_name:
            break
    else:
        raise RuntimeError(
            f"Instance {instance_name} doesn't have a disk named {disk_name} attached."
        )

    disk.auto_delete = autodelete

    operation = instance_client.update(
        project=project_id,
        zone=zone,
        instance=instance_name,
        instance_resource=instance,
    )

    wait_for_extended_operation(operation, "disk update")

REST

Per impostare l'opzione di eliminazione automatica di un disco, invia una richiesta POST al metodo instances.setDiskAutoDelete.

POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/zones/ZONE/instances/VM_NAME/setDiskAutoDelete?autoDelete=false&deviceName=SOURCE_DISK

Sostituisci quanto segue:

PROJECT_ID: l'ID progetto a cui appartiene la VM di origine.
ZONE: la zona in cui si trova la VM di origine.
VM_NAME: il nome della VM di origine.
SOURCE_DISK: il nome del dispositivo del disco da cui vuoi creare l'immagine.

Dopo aver preparato la VM, crea l'immagine.

Crea l'immagine

Puoi creare immagini dei dischi dalle seguenti origini:

Un disco permanente, anche se è collegato a una VM
Uno snapshot di un disco permanente
Un'altra immagine nel progetto
Un'immagine condivisa da un altro progetto
Un'immagine RAW compressa in Cloud Storage

Puoi creare un'immagine disco ogni 10 minuti. Se vuoi inviare un burst di richieste per creare un'immagine disco, puoi inviare al massimo 6 richieste in 60 minuti. Per ulteriori informazioni, consulta Limiti di frequenza degli snapshot.

Console

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

Vai a Crea un'immagine
Specifica il nome dell'immagine.
Specifica l'origine da cui vuoi creare un'immagine. Può essere un disco permanente, uno snapshot, un'altra immagine o un file disk.raw in Cloud Storage.
Se stai creando un'immagine da un disco collegato a una VM in esecuzione, seleziona Mantieni l'istanza in esecuzione per confermare che vuoi creare l'immagine mentre la VM è in esecuzione. Puoi preparare la VM prima di creare l'immagine.
Nell'elenco a discesa In base alla posizione del disco di origine (predefinita), specifica la posizione in cui archiviare l'immagine. Ad esempio, specifica us per archiviare l'immagine nella località con più regioni us o us-central1 per archiviarla nella regione us-central1. Se non effettui una selezione, Compute Engine archivia l'immagine nella regione più vicina alla posizione di origine dell'immagine.
(Facoltativo) Specifica le proprietà dell'immagine.
- Famiglia: la famiglia di immagini a cui appartiene questa nuova immagine.
- Descrizione: una descrizione dell'immagine personalizzata.
- Etichetta: un'etichetta per raggruppare le risorse.
Specifica la chiave di crittografia. Puoi scegliere tra una chiave di proprietà di Google e gestita da Google, una chiave Cloud Key Management Service (Cloud KMS) o una chiave di crittografia fornita dal cliente (CSEK). Se non viene specificata alcuna chiave di crittografia, le immagini vengono criptate con una chiave di proprietà di Google e gestita da Google.
Fai clic su Crea per creare l'immagine.

gcloud

In Google Cloud CLI, utilizza il comando gcloud compute images create per creare un'immagine personalizzata.

Crea un'immagine da un disco di origine:

Il flag --force è un flag facoltativo che ti consente di creare l'immagine da un'istanza in esecuzione. Per impostazione predefinita, non puoi creare immagini dalle istanze in esecuzione. Specifica questo flag solo se hai la certezza di voler creare l'immagine mentre l'istanza è in esecuzione.

gcloud compute images create IMAGE_NAME \
    --source-disk=SOURCE_DISK \
    --source-disk-zone=ZONE \
    [--family=IMAGE_FAMILY] \
    [--storage-location=LOCATION] \
    [--force]

Sostituisci quanto segue:

IMAGE_NAME: un nome per la nuova immagine
SOURCE_DISK: il disco da cui vuoi creare l'immagine
ZONE: la zona in cui si trova il disco
IMAGE_FAMILY: facoltativo, un flag che specifica a quale famiglia di immagini appartiene questa immagine.
LOCATION: facoltativo, un flag che consente di designare la regione o la regione multipla in cui è archiviata l'immagine. Ad esempio, specifica us per archiviare l'immagine nella regione con più aree geografiche us o us-central1 per archiviarla nella regione us-central1. Se non effettui una selezione, Compute Engine archivia l'immagine nella regione multipla più vicina alla posizione di origine dell'immagine.

Per creare un'immagine da un'immagine di origine:

gcloud compute images create IMAGE_NAME \
  --source-image=SOURCE_IMAGE \
  [--source-image-project=IMAGE_PROJECT] \
  [--family=IMAGE_FAMILY] \
  [--storage-location=LOCATION]

Sostituisci quanto segue:

IMAGE_NAME: un nome per la nuova immagine.
SOURCE_IMAGE: l'immagine da cui vuoi creare la nuova immagine.
IMAGE_PROJECT: facoltativo, il progetto in cui si trova l'immagine di origine. Utilizza questo parametro se vuoi copiare un'immagine da un altro progetto.
IMAGE_FAMILY: facoltativo, la famiglia di immagini a cui appartiene questa nuova immagine.
LOCATION: facoltativo. Consente di designare la regione o più regioni in cui è archiviata l'immagine. Ad esempio, specifica us per memorizzare l'immagine nella località con più regioni us o us-central1 per memorizzarla nella regione us-central1. Se non effettui una selezione, Compute Engine archivia l'immagine nella regione più vicina alla posizione di origine dell'immagine.

Crea un'immagine da uno snapshot:

gcloud compute images create IMAGE_NAME \
    --source-snapshot=SOURCE_SNAPSHOT \
    [--storage-location=LOCATION]

Sostituisci quanto segue:

IMAGE_NAME: un nome per la nuova immagine
SOURCE_SNAPSHOT: lo snapshot da cui vuoi creare l'immagine
LOCATION: facoltativo, un flag che consente di designare la regione o la regione multipla in cui è archiviata l'immagine. Ad esempio, specifica us per archiviare l'immagine nella regione con più aree geografiche us o us-central1 per archiviarla nella regione us-central1. Se non effettui una selezione, Compute Engine archivia l'immagine nella regione multipla più vicina alla posizione di origine dell'immagine.

Visualizzare la posizione di un'immagine:

Utilizza il comando gcloud compute images describe per visualizzare la posizione di un'immagine.

gcloud compute images describe IMAGE_NAME

Sostituisci IMAGE_NAME con il nome dell'immagine che vuoi esaminare.

Vai

Go

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

import (
	"context"
	"fmt"
	"io"

	compute "cloud.google.com/go/compute/apiv1"
	computepb "cloud.google.com/go/compute/apiv1/computepb"
)

// Creates a disk image from an existing disk
func createImageFromDisk(
	w io.Writer,
	projectID, zone, sourceDiskName, imageName string,
	storageLocations []string,
	forceCreate bool,
) error {
	// projectID := "your_project_id"
	// zone := "us-central1-a"
	// sourceDiskName := "your_disk_name"
	// imageName := "my_image"
	// // If storageLocations empty, automatically selects the closest one to the source
	// storageLocations = []string{}
	// // If forceCreate is set to `true`, proceeds even if the disk is attached to
	// // a running instance. This may compromise integrity of the image!
	// forceCreate = false

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

	// Get the source disk
	source_req := &computepb.GetDiskRequest{
		Disk:    sourceDiskName,
		Project: projectID,
		Zone:    zone,
	}

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

	// Create the image
	req := computepb.InsertImageRequest{
		ForceCreate: &forceCreate,
		ImageResource: &computepb.Image{
			Name:             &imageName,
			SourceDisk:       disk.SelfLink,
			StorageLocations: storageLocations,
		},
		Project: projectID,
	}

	op, err := imagesClient.Insert(ctx, &req)

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

	fmt.Fprintf(w, "Disk image %s created\n", imageName)

	return nil
}

Java

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


import com.google.cloud.compute.v1.Disk;
import com.google.cloud.compute.v1.DisksClient;
import com.google.cloud.compute.v1.Image;
import com.google.cloud.compute.v1.ImagesClient;
import com.google.cloud.compute.v1.InsertImageRequest;
import com.google.cloud.compute.v1.Instance;
import com.google.cloud.compute.v1.InstancesClient;
import com.google.cloud.compute.v1.Operation;
import java.io.IOException;
import java.util.Arrays;
import java.util.HashMap;
import java.util.Map;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.TimeoutException;

public class CreateImage {

  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 use.
    String project = "your-project-id";
    // Zone of the disk you copy from.
    String zone = "europe-central2-b";
    // Name of the source disk you copy from.
    String sourceDiskName = "source-disk-name";
    // Name of the image you want to create.
    String imageName = "your-image-name";
    // Storage location for the image. If the value is undefined,
    // function will store the image in the multi-region closest to your image's source location.
    String storageLocation = "eu";
    // Create the image even if the source disk is attached to a running instance.
    boolean forceCreate = false;

    createImage(project, zone, sourceDiskName, imageName, storageLocation, forceCreate);
  }

  // Creates a new disk image from the specified source disk.
  public static void createImage(String project, String zone, String sourceDiskName,
      String imageName, String storageLocation, boolean forceCreate)
      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 `client.close()` method on the client to safely
    // clean up any remaining background resources.
    try (ImagesClient imagesClient = ImagesClient.create();
        InstancesClient instancesClient = InstancesClient.create();
        DisksClient disksClient = DisksClient.create()) {

      Disk disk = disksClient.get(project, zone, sourceDiskName);

      // Getting instances where source disk is attached.
      for (String fullInstanceName : disk.getUsersList()) {
        Map<String, String> instanceInfo = parseInstanceName(fullInstanceName);
        Instance instance = instancesClient.get(instanceInfo.get("instanceProjectId"),
            instanceInfo.get("instanceZone"), instanceInfo.get("instanceName"));

        // Сheck whether the instances are stopped.
        if (!Arrays.asList("TERMINATED", "STOPPED").contains(instance.getStatus())
            && !forceCreate) {
          throw new IllegalStateException(
              String.format(
                  "Instance %s should be stopped. For Windows instances please stop the instance "
                      + "using GCESysprep command. For Linux instances just shut it down normally."
                      + " You can suppress this error and create an image of the disk by setting "
                      + "'forceCreate' parameter to true (not recommended). "
                      + "More information here: "
                      + "* https://cloud.google.com/compute/docs/instances/windows/creating-windows-os-image#api"
                      + "* https://cloud.google.com/compute/docs/images/create-delete-deprecate-private-images#prepare_instance_for_image",
                  instanceInfo.get("instanceName")));
        }
      }

      if (forceCreate) {
        System.out.println(
            "Warning: forceCreate option compromise the integrity of your image. "
                + "Stop the instance before you create the image if possible.");
      }

      // Create Image.
      Image image = Image.newBuilder()
          .setName(imageName)
          .setSourceDisk(String.format("/zones/%s/disks/%s", zone, sourceDiskName))
          .addStorageLocations(storageLocation.isEmpty() ? "" : storageLocation)
          .build();

      InsertImageRequest insertImageRequest = InsertImageRequest.newBuilder()
          .setProject(project)
          .setForceCreate(forceCreate)
          .setImageResource(image)
          .build();

      Operation response = imagesClient.insertAsync(insertImageRequest).get(5, TimeUnit.MINUTES);

      if (response.hasError()) {
        System.out.println("Image creation failed ! ! " + response);
        return;
      }

      System.out.println("Image created.");
    }
  }


  public static Map<String, String> parseInstanceName(String name) {
    String[] parsedName = name.split("/");
    int splitLength = parsedName.length;

    if (splitLength < 5) {
      throw new IllegalArgumentException(
          "Provide correct instance name in the following format: "
              + "https://www.googleapis.com/compute/v1/projects/PROJECT/zones/ZONE/instances/INSTANCE_NAME");
    }

    return new HashMap<>() {
      {
        put("instanceName", parsedName[splitLength - 1]);
        put("instanceZone", parsedName[splitLength - 3]);
        put("instanceProjectId", parsedName[splitLength - 5]);
      }
    };
  }

}

Python

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

from __future__ import annotations

import sys
from typing import Any
import warnings

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


STOPPED_MACHINE_STATUS = (
    compute_v1.Instance.Status.TERMINATED.name,
    compute_v1.Instance.Status.STOPPED.name,
)


def create_image_from_disk(
    project_id: str,
    zone: str,
    source_disk_name: str,
    image_name: str,
    storage_location: str | None = None,
    force_create: bool = False,
) -> compute_v1.Image:
    """
    Creates a new disk image.

    Args:
        project_id: project ID or project number of the Cloud project you use.
        zone: zone of the disk you copy from.
        source_disk_name: name of the source disk you copy from.
        image_name: name of the image you want to create.
        storage_location: storage location for the image. If the value is undefined,
            function will store the image in the multi-region closest to your image's
            source location.
        force_create: create the image even if the source disk is attached to a
            running instance.

    Returns:
        An Image object.
    """
    image_client = compute_v1.ImagesClient()
    disk_client = compute_v1.DisksClient()
    instance_client = compute_v1.InstancesClient()

    # Get source disk
    disk = disk_client.get(project=project_id, zone=zone, disk=source_disk_name)

    for disk_user in disk.users:
        instance_name = disk_user.split("/")[-1]
        instance = instance_client.get(
            project=project_id, zone=zone, instance=instance_name
        )
        if instance.status in STOPPED_MACHINE_STATUS:
            continue
        if not force_create:
            raise RuntimeError(
                f"Instance {disk_user} should be stopped. For Windows instances please "
                f"stop the instance using `GCESysprep` command. For Linux instances just "
                f"shut it down normally. You can supress this error and create an image of"
                f"the disk by setting `force_create` parameter to true (not recommended). \n"
                f"More information here: \n"
                f" * https://cloud.google.com/compute/docs/instances/windows/creating-windows-os-image#api \n"
                f" * https://cloud.google.com/compute/docs/images/create-delete-deprecate-private-images#prepare_instance_for_image"
            )
        else:
            warnings.warn(
                f"Warning: The `force_create` option may compromise the integrity of your image. "
                f"Stop the {disk_user} instance before you create the image if possible."
            )

    # Create image
    image = compute_v1.Image()
    image.source_disk = disk.self_link
    image.name = image_name
    if storage_location:
        image.storage_locations = [storage_location]

    operation = image_client.insert(project=project_id, image_resource=image)

    wait_for_extended_operation(operation, "image creation from disk")

    return image_client.get(project=project_id, image=image_name)

REST

Invia una richiesta POST al metodo images().insert, un URL nel corpo della richiesta che rimandi all'oggetto di origine da cui vuoi creare l'immagine. Specifica gli URL delle risorse utilizzando il tuo ID progetto e i nomi delle risorse.

Per creare un'immagine da un disco permanente:

POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/global/images

{
  "name": "IMAGE_NAME",
  "sourceDisk": "/zones/ZONE/disks/SOURCE_DISK",
  ("storageLocations": "LOCATION",)
  ("forceCreate": "TRUE")
}

Sostituisci quanto segue:

PROJECT_ID: l'ID progetto a cui appartiene l'immagine.
IMAGE_NAME: un nome per la nuova immagine che vuoi creare.
ZONE: la zona in cui si trova il disco di origine.
SOURCE_DISK: il disco da cui vuoi creare l'immagine.
LOCATION: facoltativo, la posizione di archiviazione dell'immagine. Ad esempio, specifica us per archiviare l'immagine nella località con più regioni us o us-central1 per archiviarla nella regione us-central1. Se non effettui una selezione, Compute Engine archivia l'immagine nella località multiregionale più vicina alla posizione di origine dell'immagine.

Il parametro facoltativo forceCreate ti consente di creare l'immagine da una VM in esecuzione. Specifica TRUE solo se hai la certezza di voler creare l'immagine da una VM in esecuzione. L'impostazione predefinita di forceCreate è FALSE.

Per creare un'immagine da un'altra:

POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/global/images

{
  "name": "IMAGE_NAME",
  "sourceImage": "/global/images/SOURCE_IMAGE",
  ("storageLocations": "LOCATION")
}

Sostituisci quanto segue:

PROJECT_ID: il progetto a cui appartiene l'immagine.
IMAGE_NAME: un nome per la nuova immagine che vuoi creare.
SOURCE_IMAGE: l'immagine da cui vuoi creare l'immagine.
LOCATION: facoltativo, la posizione di archiviazione dell'immagine. Ad esempio, specifica us per archiviare l'immagine nella località con più regioni us o us-central1 per archiviarla nella regione us-central1. Se non effettui una selezione, Compute Engine archivia l'immagine nella regione multipla più vicina alla posizione di origine dell'immagine.

Crea un'immagine da uno snapshot:

POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/global/images
{
  "name": "IMAGE_NAME",
  "sourceSnapshot": "(/SOURCE_PROJECT_ID)/global/snapshots/SOURCE_SNAPSHOT",
  ("storageLocations": "LOCATION")
}

Sostituisci quanto segue:

PROJECT_ID: il progetto a cui appartiene l'immagine.
IMAGE_NAME: un nome per la nuova immagine che vuoi creare.
SOURCE_PROJECT_ID: facoltativo, il progetto in cui si trova lo snapshot. Devi disporre dell'autorizzazione per accedere alla risorsa snapshot nel progetto.
SOURCE_SNAPSHOT: lo snapshot da cui vuoi creare l'immagine.
LOCATION: facoltativo, la posizione di archiviazione dell'immagine. Ad esempio, specifica us per archiviare l'immagine nella località con più regioni us o us-central1 per archiviarla nella regione us-central1. Se non effettui una selezione, Compute Engine archivia l'immagine nella località multiregionale più vicina alla posizione di origine dell'immagine.

Per saperne di più sull'aggiunta di immagini, consulta la documentazione di riferimento sulle immagini.

Condividere l'immagine

Dopo aver creato un'immagine personalizzata, puoi condividerla tra i progetti. Se consenti agli utenti di un altro progetto di utilizzare le tue immagini personalizzate, possono accedere a queste immagini specificando il progetto di immagini nella loro richiesta.

Attivare le funzionalità del sistema operativo guest

Utilizza le funzionalità del sistema operativo guest per configurare le seguenti opzioni di rete, sicurezza, archiviazione e sistema operativo nelle immagini personalizzate. Le immagini personalizzate con queste funzionalità configurate vengono utilizzate come dischi di avvio.

gcloud

Utilizza il comando gcloud compute images create con il --guest-os-features flag per creare una nuova immagine personalizzata da un'immagine personalizzata esistente.

gcloud compute images create IMAGE_NAME \
    --source-image=SOURCE_IMAGE \
    [--source-image-project=IMAGE_PROJECT] \
    --guest-os-features="FEATURES,..." \
    [--storage-location=LOCATION]

Sostituisci quanto segue:

IMAGE_NAME: il nome della nuova immagine
SOURCE_IMAGE: un'immagine su cui basare la nuova immagine
IMAGE_PROJECT: (Facoltativo) il progetto contenente l'immagine di origine

Utilizza questo parametro per copiare un'immagine da un altro progetto.
FEATURES: tag del sistema operativo guest per attivare le funzionalità per le VM che crei dalle immagini

Per aggiungere più valori, utilizza le virgole per separarli. Imposta uno o più dei seguenti valori:
- VIRTIO_SCSI_MULTIQUEUE. Da utilizzare su dispositivi SSD locali come alternativa a NVMe. Per ulteriori informazioni sulle immagini che supportano SCSI, consulta Scegliere un'interfaccia.
  
  Per le immagini Linux, puoi attivare SCSI multi-queue sui dispositivi SSD locali nelle immagini con kernel versioni 3.17 o successive. Per le immagini Windows, puoi attivare SCSI multi-coda sui dispositivi SSD locali sulle immagini con il driver Windows di Compute Engine versione 1.2.
- WINDOWS. Tagga le immagini di avvio personalizzate di Windows Server come immagini Windows.
- MULTI_IP_SUBNET. Configura le interfacce con una maschera di rete diversa da /32. Per ulteriori informazioni sulle interfacce di rete multiple e sul loro funzionamento, consulta Panoramica ed esempi di più interfacce di rete.
- UEFI_COMPATIBLE. Avvio con firmware UEFI e le seguenti funzionalità Shielded VM:
  - Avvio protetto: disabilitato per impostazione predefinita
  - Virtual Trusted Platform Module (vTPM): abilitato per impostazione predefinita
  - Monitoraggio dell'integrità: attivo per impostazione predefinita
- GVNIC. Supporta larghezze di banda di rete più elevate fino a velocità da 50 Gbps a 100 Gbps. Per maggiori informazioni, consulta Utilizzare Google Virtual NIC.
- IDPF. Supporta le interfacce di rete della funzione di percorso dei dati dell'infrastruttura Intel (IDPF).
- SEV_CAPABLE o SEV_SNP_CAPABLE. Utilizza questi tag se vuoi usare la tua immagine su un'istanza Confidential VM con il supporto di AMD Secure Encrypted Virtualization (SEV) o AMD SEV-Secure Nested Paging (SEV-SNP). Per verificare se il tuo kernel supporta AMD SEV o AMD SEV-SNP, consulta Dettagli del kernel Linux.
- SEV_LIVE_MIGRATABLE_V2. Utilizza questo tag se vuoi utilizzare l'immagine su un'istanza Confidential VM che supporta la migrazione live su AMD SEV. Per verificare se il tuo kernel supporta migrazione live, consulta Dettagli del kernel Linux.
- TDX_CAPABLE. Utilizza questo tag se vuoi utilizzare l'immagine in un'istanza Confidential VM con il supporto di Intel Trust Domain Extensions (TDX). Per verificare se il kernel supporta Intel TDX, consulta Dettagli del kernel Linux.
- SUSPEND_RESUME_COMPATIBLE. Supporta la sospensione e la ripresa su una VM. Per ulteriori informazioni, consulta la sezione Compatibilità del sistema operativo.
LOCATION: facoltativo: regione o più regioni in cui memorizzare l'immagine

Ad esempio, specifica us per archiviare l'immagine nella località con più regioni us o us-central1 per archiviarla nella regione us-central1. Se non effettui una selezione, Compute Engine archivia l'immagine nella regione più vicina alla posizione di origine dell'immagine.

REST

Utilizza il metodo images().insert con il flag guestOsFeatures per creare una nuova immagine personalizzata da un'immagine personalizzata esistente.


POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/global/images

{
 "name": "IMAGE_NAME",
 "sourceImage": "(projects/IMAGE_PROJECT)/global/images/SOURCE_IMAGE",
 ("storageLocations": "LOCATION",)
 "guestOsFeatures": [
  {
   "type": "FEATURES"
  }
 ]
}

Sostituisci quanto segue:

PROJECT_ID: l'ID del progetto in cui creare la nuova immagine
IMAGE_NAME: un nome per la nuova immagine
IMAGE_PROJECT: (Facoltativo) il progetto contenente l'immagine di origine

Utilizza questo parametro per copiare un'immagine da un altro progetto.
SOURCE_IMAGE: l'immagine su cui basare la nuova immagine
LOCATION: facoltativo, una regione o più regioni in cui memorizzare l'immagine

Ad esempio, specifica us per archiviare l'immagine nella regione con più aree geografiche us o us-central1 per archiviarla nella regione us-central1. Se non effettui una selezione, Compute Engine archivia l'immagine nella regione multipla più vicina alla posizione di origine dell'immagine.
FEATURES: tag del sistema operativo guest per attivare le funzionalità per le VM che crei dalle immagini

Per aggiungere più valori, utilizza le virgole per separarli. Imposta uno o più dei seguenti valori:
- VIRTIO_SCSI_MULTIQUEUE. Da utilizzare su dispositivi SSD locali come alternativa a NVMe. Per ulteriori informazioni sulle immagini che supportano SCSI, consulta Scegliere un'interfaccia.
  
  Per le immagini Linux, puoi attivare SCSI multi-queue sui dispositivi SSD locali nelle immagini con kernel versioni 3.17 o successive. Per le immagini Windows, puoi attivare SCSI multi-coda sui dispositivi SSD locali sulle immagini con il driver Windows di Compute Engine versione 1.2.
- WINDOWS. Tagga le immagini di avvio personalizzate di Windows Server come immagini Windows.
- MULTI_IP_SUBNET. Configura le interfacce con una maschera di rete diversa da /32. Per ulteriori informazioni sulle interfacce di rete multiple e sul loro funzionamento, consulta Panoramica ed esempi di più interfacce di rete.
- UEFI_COMPATIBLE. Avvio con firmware UEFI e le seguenti funzionalità Shielded VM:
  - Avvio protetto: disabilitato per impostazione predefinita
  - Virtual Trusted Platform Module (vTPM): abilitato per impostazione predefinita
  - Monitoraggio dell'integrità: attivo per impostazione predefinita
- GVNIC. Supporta larghezze di banda di rete più elevate fino a velocità da 50 Gbps a 100 Gbps. Per maggiori informazioni, consulta Utilizzare Google Virtual NIC.
- IDPF. Supporta le interfacce di rete della funzione di percorso dei dati dell'infrastruttura Intel (IDPF).
- SEV_CAPABLE o SEV_SNP_CAPABLE. Utilizza questi tag se vuoi usare la tua immagine su un'istanza Confidential VM con il supporto di AMD Secure Encrypted Virtualization (SEV) o AMD SEV-Secure Nested Paging (SEV-SNP). Per verificare se il tuo kernel supporta AMD SEV o AMD SEV-SNP, consulta Dettagli del kernel Linux.
- SEV_LIVE_MIGRATABLE_V2. Utilizza questo tag se vuoi utilizzare l'immagine su un'istanza Confidential VM che supporta la migrazione live su AMD SEV. Per verificare se il tuo kernel supporta migrazione live, consulta Dettagli del kernel Linux.
- TDX_CAPABLE. Utilizza questo tag se vuoi utilizzare l'immagine su un'istanza Confidential VM con il supporto di Intel Trust Domain Extensions (TDX). Per verificare se il tuo kernel supporta Intel TDX, consulta Dettagli del kernel Linux.
- SUSPEND_RESUME_COMPATIBLE. Supporta la sospensione e la ripresa su una VM. Per ulteriori informazioni, consulta la sezione Compatibilità del sistema operativo.

Evitare informazioni sensibili nelle variabili UEFI

Le variabili Unified Extensible Firmware Interface (UEFI) sono variabili di coppia chiave-valore utilizzate dal firmware UEFI durante l'avvio per avviare il sistema operativo di una VM. A differenza delle macchine fisiche, in cui le variabili vengono memorizzate su un chip hardware, Compute Engine virtualizza lo spazio di archiviazione di queste variabili. Di conseguenza, in molti sistemi operativi, tutte le applicazioni e tutti gli utenti possono raggiungere queste variabili e accedere a queste informazioni.

Per questo motivo, Google consiglia vivamente di non scrivere o memorizzare informazioni sensibili o che consentono l'identificazione personale, come password o chiavi private, nelle variabili UEFI.

Considerazioni per le immagini Arm

Google offre le serie di macchine C4A e Tau T2A, che funzionano su piattaforme CPU Arm. Puoi avviare una VM con una di queste serie di macchine e poi utilizzare la VM di origine per creare un'immagine ARM. La procedura per creare un'immagine Arm personalizzata è identica a quella per creare un'immagine x86.

Per aiutare gli utenti a distinguere le immagini ARM da quelle x86, le immagini ARM avranno un campo architecture impostato su ARM64. I valori possibili per questo campo sono:

ARCHITECTURE_UNSPECIFIED
X86_64
ARM64

Gli utenti delle immagini possono quindi filtrare in base a questo campo per trovare immagini x86 o basate su Arm.

Passaggi successivi

Condividi la tua immagine privata con altri progetti.
Scopri come importare dischi, immagini e istanze VM.
Scopri come esportare un'immagine in Cloud Storage.
Scopri come avviare una VM da un'immagine personalizzata.
Scopri come impostare la versione dell'immagine in una famiglia di immagini.
Scopri come ritirare un'immagine personalizzata.
Scopri come eliminare un'immagine personalizzata.