crea immagini Windows Server personalizzate

Puoi creare immagini Windows Server personalizzate da immagini Windows Server di Compute Engine esistenti. Utilizza queste immagini personalizzate per creare istanze con dischi di avvio identici alle istanze esistenti.

Queste immagini personalizzate sono utili per salvare la configurazione del sistema operativo delle istanze esistenti e riutilizzare la stessa configurazione per creare altre istanze.

Le seguenti attività non sono trattate in questa sezione:

Crea una VM da un'immagine pubblica o personalizzata; consulta invece Creazione di una nuova istanza Windows.
Pianifica un backup dei tuoi dischi permanenti; consulta invece la pagina relativa agli snapshot dei dischi permanenti.
Importa sistemi Windows Server o SQL Server. Utilizza invece il servizio di migrazione delle VM.

Prima di iniziare

Se non l'hai ancora fatto, configura l'autenticazione. L'autenticazione è il processo mediante il quale viene verificata l'identità per l'accesso ai servizi e alle API Google Cloud. Per eseguire codice o esempi da un ambiente di sviluppo locale, puoi autenticarti in Compute Engine nel seguente modo.

Seleziona la scheda relativa a come prevedi di utilizzare gli esempi in questa pagina:
Console

Quando utilizzi la console Google Cloud per accedere ai servizi e alle API di Google Cloud, non devi configurare l'autenticazione.
gcloud
1. Installa Google Cloud CLI, quindi initialize eseguendo questo comando:
```
gcloud init
```
  Nota: se hai già installato gcloud CLI in precedenza, assicurati di disporre della versione più recente eseguendo gcloud components update.
2. Imposta una regione e una zona predefinite.
Go

Per utilizzare gli esempi Go in questa pagina da un ambiente di sviluppo locale, installa e inizializza gcloud CLI, quindi configura Credenziali predefinite dell'applicazione con le tue credenziali utente.
1. Installa Google Cloud CLI.
2. Per initialize gcloud CLI, esegui questo comando:
```
gcloud init
```
3. Crea credenziali di autenticazione locali per il tuo Account Google:
```
gcloud auth application-default login
```
Per ulteriori informazioni, consulta Configura l'autenticazione per un ambiente di sviluppo locale.
Java

Per utilizzare gli esempi Java in questa pagina da un ambiente di sviluppo locale, installa e inizializza gcloud CLI, quindi configura Credenziali predefinite dell'applicazione con le tue credenziali utente.
1. Installa Google Cloud CLI.
2. Per initialize gcloud CLI, esegui questo comando:
```
gcloud init
```
3. Crea credenziali di autenticazione locali per il tuo Account Google:
```
gcloud auth application-default login
```
Per ulteriori informazioni, consulta Configura l'autenticazione per un ambiente di sviluppo locale.
Node.js

Per utilizzare gli esempi Node.js in questa pagina da un ambiente di sviluppo locale, installa e inizializza gcloud CLI, quindi configura Credenziali predefinite dell'applicazione con le tue credenziali utente.
1. Installa Google Cloud CLI.
2. Per initialize gcloud CLI, esegui questo comando:
```
gcloud init
```
3. Crea credenziali di autenticazione locali per il tuo Account Google:
```
gcloud auth application-default login
```
Per ulteriori informazioni, consulta Configura l'autenticazione per un ambiente di sviluppo locale.
Python

Per utilizzare gli esempi Python in questa pagina da un ambiente di sviluppo locale, installa e inizializza gcloud CLI, quindi configura Credenziali predefinite dell'applicazione con le tue credenziali utente.
1. Installa Google Cloud CLI.
2. Per initialize gcloud CLI, esegui questo comando:
```
gcloud init
```
3. Crea credenziali di autenticazione locali per il tuo Account Google:
```
gcloud auth application-default login
```
Per ulteriori informazioni, consulta Configura l'autenticazione per un ambiente di sviluppo locale.
REST

Per utilizzare gli esempi di API REST in questa pagina in un ambiente di sviluppo locale, devi utilizzare le credenziali che fornisci a gcloud CLI.

Preparati a creare un'immagine Windows Server

Prima di creare l'immagine, esegui GCESysprep sull'istanza per prepararla al processo di creazione dell'immagine.

GCESysprep prepara un'istanza per diventare un'immagine Compute Engine completando i seguenti passaggi:

Disattiva l'attività pianificata GCEStartup.
Elimina tutti i file dalla posizione della cartella temporanea.
Cancella tutti i log eventi di Windows.
Esegue sysprep.exe /generalize /oobe /quit /unattend
Configura instance_setup.ps1 in modo che venga eseguito al primo avvio dell'istanza VM.
Elimina il certificato RDP.
Rimuove l'elenco archiviato di dischi permanenti.
Abilita le regole firewall RDP e WinRM.
Disabilita il servizio Google OS Config.
Arresta l'istanza.

Le operazioni di GCESysprep vengono registrate nel log eventi e nella porta seriale 1 di Windows. Sysprep scrive su più file di log.

Creare un'immagine Compute Engine utilizzando GCESysprep:

Esegui GCESysprep con diritti amministrativi.
```
GCESysprep
```
Crea l'immagine.

Specifica la posizione di un'immagine

Quando crei un'immagine personalizzata, puoi specificare la località Cloud Storage dell'immagine, escluse le località a due regioni. Se specifichi la località di archiviazione delle immagini, puoi soddisfare i requisiti normativi e di conformità per la località dei dati, nonché le tue esigenze di alta disponibilità garantendo la ridondanza tra regioni.

La funzionalità relativa alla posizione di archiviazione è facoltativa. Se non selezioni una località, Compute Engine archivierà l'immagine nella multiregione più vicina all'origine dell'immagine. Puoi creare immagini personalizzate da dischi di origine, immagini, snapshot o immagini archiviate in Cloud Storage. Puoi usare queste immagini per creare nuove istanze VM.

Tutte le immagini esistenti prima del lancio di questa funzionalità rimarranno dove sono. L'unico cambiamento è che puoi visualizzare la posizione di tutte le tue immagini. Se disponi già di un'immagine che desideri spostare, devi ricrearla nella posizione desiderata.

Crea un'immagine Windows

Puoi creare immagini disco dalle seguenti origini:

Un disco permanente, anche quando è collegato a un'istanza
Uno snapshot di un disco permanente
Un'altra immagine nel tuo progetto
Un'immagine condivisa da un altro progetto
Un'immagine importata archiviata in Cloud Storage

Console

Nella console Google Cloud, vai alla pagina Crea una nuova immagine.
Creare una nuova immagine
Specifica il nome dell'immagine.
Scegli un disco di origine con un sistema operativo Windows da cui vuoi creare un'immagine.
Specifica la Località in cui archiviare l'immagine. Scegli la posizione di un'immagine dal menu a discesa In base alla posizione del disco di origine (impostazione predefinita). Ad esempio, specifica us per archiviare l'immagine nella località multiregionale us oppure us-central1 per archiviare l'immagine nella regione us-central1. Se non effettui una selezione, Compute Engine archivierà l'immagine nella multiregione più vicina alla località di origine dell'immagine.
Specifica le proprietà dell'immagine. Ad esempio, puoi specificare un nome di famiglia di immagini per l'immagine per organizzarla come parte di una famiglia di immagini.
Fai clic su Crea.

gcloud

Utilizza gcloud compute con images create e fornisci il disco permanente di origine da cui vuoi creare un'immagine. Facoltativamente, includi il flag --force per creare l'immagine anche se è collegata a un'istanza in esecuzione.

gcloud compute images create example-image --source-disk [DISK_NAME] \
    --source-disk-zone [ZONE] \
    --storage-location [LOCATION] \
    [--force]

[DISK_NAME] è il nome del disco di origine da cui creare l'immagine.
[ZONE] è la zona del disco.
[LOCATION] è un flag facoltativo che ti consente di indicare una o più regioni in cui verrà archiviata l'immagine. Ad esempio, specifica us per archiviare l'immagine nella località multiregionale us oppure us-central1 per archiviare l'immagine nella regione us-central1. Se non effettui una selezione, Compute Engine archivierà l'immagine nella multiregione più vicina alla località di origine dell'immagine.
--force è un flag facoltativo che crea l'immagine anche se il disco è collegato a un'istanza ancora in esecuzione. Questa opzione potrebbe compromettere l'integrità dell'immagine. Se possibile, arresta l'istanza prima di creare l'immagine.

Quando esegui questo comando, gcloud compute crea una nuova immagine basata sul disco permanente che hai fornito e la aggiunge alla tua raccolta. Puoi confermare che l'immagine è stata creata correttamente eseguendo:

gcloud compute images list

Go

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

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

import (
	"context"
	"fmt"
	"io"
	"strings"

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

// createWindowsOSImage creates a new Windows image from the specified source disk.
func createWindowsOSImage(
	w io.Writer,
	projectID, zone, sourceDiskName, imageName, storageLocation string,
	forceCreate bool,
) error {
	// projectID := "your_project_id"
	// zone := "europe-central2-b"
	// sourceDiskName := "your_source_disk_name"
	// imageName := "your_image_name"
	// storageLocation := "eu"
	// forceCreate := false

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

	// Getting instances where source disk is attached
	diskRequest := &computepb.GetDiskRequest{
		Project: projectID,
		Zone:    zone,
		Disk:    sourceDiskName,
	}

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

	// Сhecking whether the instances is stopped
	for _, fullInstanceName := range sourceDisk.GetUsers() {
		parsedName := strings.Split(fullInstanceName, "/")
		l := len(parsedName)
		if l < 5 {
			return fmt.Errorf(
				"API returned instance name with unexpected format",
			)
		}
		instanceReq := &computepb.GetInstanceRequest{
			Project:  parsedName[l-5],
			Zone:     parsedName[l-3],
			Instance: parsedName[l-1],
		}
		instance, err := instancesClient.Get(ctx, instanceReq)
		if err != nil {
			return fmt.Errorf("unable to get instance: %w", err)
		}

		if instance.GetStatus() != "TERMINATED" && instance.GetStatus() != "STOPPED" {
			if !forceCreate {
				return fmt.Errorf("instance %s should be stopped. "+
					"Please stop the instance using "+
					"GCESysprep command or set forceCreate parameter to true "+
					"(not recommended). More information here: "+
					"https://cloud.google.com/compute/docs/instances/windows/creating-windows-os-image#api",
					parsedName[l-1],
				)
			}
		}
	}

	if forceCreate {
		fmt.Fprintf(w, "Warning: ForceCreate option compromise the integrity of your image. "+
			"Stop the instance before you create the image if possible.",
		)
	}

	req := &computepb.InsertImageRequest{
		Project:     projectID,
		ForceCreate: &forceCreate,
		ImageResource: &computepb.Image{
			Name:             proto.String(imageName),
			SourceDisk:       proto.String(fmt.Sprintf("zones/%s/disks/%s", zone, sourceDiskName)),
			StorageLocations: []string{storageLocation},
		},
	}

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

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

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

	return nil
}

Java

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


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

}

Node.js

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

/**
 * TODO(developer): Uncomment and replace these variables before running the sample.
 */
// const projectId = 'YOUR_PROJECT_ID';
// const zone = 'europe-central2-b';
// const sourceDiskName = 'YOUR_SOURCE_DISK_NAME';
// const imageName = 'YOUR_IMAGE_NAME';
// const storageLocation = 'eu';
// const forceCreate = false;

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

function parseInstanceName(name) {
  const parsedName = name.split('/');
  const l = parsedName.length;

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

  return [parsedName[l - 1], parsedName[l - 3], parsedName[l - 5]];
}

async function createWindowsOSImage() {
  const imagesClient = new compute.ImagesClient();
  const instancesClient = new compute.InstancesClient();
  const disksClient = new compute.DisksClient();

  // Getting instances where source disk is attached
  const [sourceDisk] = await disksClient.get({
    project: projectId,
    zone,
    disk: sourceDiskName,
  });

  // Сhecking whether the instances is stopped
  for (const fullInstanceName of sourceDisk.users) {
    const [instanceName, instanceZone, instanceProjectId] =
      parseInstanceName(fullInstanceName);
    const [instance] = await instancesClient.get({
      project: instanceProjectId,
      zone: instanceZone,
      instance: instanceName,
    });

    if (
      !['TERMINATED', 'STOPPED'].includes(instance.status) &&
      !forceCreate
    ) {
      throw new Error(
        `Instance ${instanceName} should be stopped. Please stop the instance using GCESysprep command or set forceCreate parameter to true (not recommended). More information here: https://cloud.google.com/compute/docs/instances/windows/creating-windows-os-image#api.`
      );
    }
  }

  if (forceCreate) {
    console.warn(
      'Warning: forceCreate option compromise the integrity of your image. Stop the instance before you create the image if possible.'
    );
  }

  const [response] = await imagesClient.insert({
    project: projectId,
    forceCreate,
    imageResource: {
      name: imageName,
      sourceDisk: `/zones/${zone}/disks/${sourceDiskName}`,
      storageLocations: storageLocation ? [storageLocation] : [],
    },
  });
  let operation = response.latestResponse;
  const operationsClient = new compute.GlobalOperationsClient();

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

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

createWindowsOSImage();

Python

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

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

Effettua una richiesta POST al metodo images().insert con un URL sourceDisk nel corpo della richiesta.

POST https://compute.googleapis.com/compute/v1/projects/[PROJECT_ID]/global/images?[FORCE_OPTION]

{
  "name": "[IMAGE_NAME]",
  "sourceDisk": "zones/[ZONE]/disks/[DISK_NAME]",
  "storageLocations": "[LOCATION]",
}

dove:

[PROJECT_ID] è l'ID progetto per questa richiesta.
[FORCE_OPTION] è un'opzione per creare l'immagine anche se il disco di origine è collegato a un'istanza in esecuzione. Specifica forceCreate=true alla fine della riga POST per impostare questa opzione. Questa opzione potrebbe compromettere l'integrità dell'immagine. Se possibile, arresta l'istanza prima di creare l'immagine.
[IMAGE_NAME] è il nome da assegnare a questa immagine.
[ZONE] è la zona del disco di origine da cui creare un'immagine.
[DISK_NAME] è il nome del disco di origine.
[LOCATION] è un parametro facoltativo che consente di selezionare una località di archiviazione dell'immagine a livello di più regioni o di una sola regione. Ad esempio, specifica us per archiviare l'immagine nella località multiregionale us oppure us-central1 per archiviare l'immagine nella regione us-central1. Se non effettui una selezione, Compute Engine archivierà l'immagine nella multiregione più vicina alla località di origine dell'immagine.

Per ulteriori informazioni sull'aggiunta di immagini, consulta la pagina di riferimento sulle immagini.

Aggiorna agenti e script Windows

Occasionalmente, Compute Engine rilascia nuove immagini Windows con gli agenti e gli script più recenti. Questi elementi assistono le istanze Windows con i processi di avvio e arresto, nonché la gestione degli account e degli indirizzi.

A partire dalla versione dell'immagine Windows v20160112, l'agente Windows si aggiorna automaticamente con le release upstream. Puoi disabilitare questi aggiornamenti dell'agente impostando la chiave dei metadati dell'istanza disable-agent-updates su true. Se disponi di istanze basate su release di immagini precedenti, puoi aggiornare manualmente l'agente Windows di queste istanze.

crea immagini Windows Server personalizzate

Prima di iniziare

Console

gcloud

Go

Java

Node.js

Python

REST

Preparati a creare un'immagine Windows Server

Specifica la posizione di un'immagine

Crea un'immagine Windows

Console

gcloud

Go

Java

Node.js

Node.js

Python

Python

REST

Aggiorna agenti e script Windows

Passaggi successivi