Questa pagina è stata tradotta dall'API Cloud Translation.

Creare immagini Windows Server personalizzate

Windows

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 uguali a quelli delle 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:

Creare una VM da un'immagine pubblica o personalizzata. Per farlo, scopri come creare una nuova istanza Windows.
Pianificare un backup dei dischi permanenti. Per farlo, scopri di più sugli snapshot dei dischi permanenti.
Importare sistemi Windows Server o SQL Server. Per farlo, utilizza il servizio VM Migration.

Prima di iniziare

Se non l'hai ancora fatto, configura l'autenticazione. L'autenticazione verifica la tua identità per l'accesso a Google Cloud servizi e 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
1. Installa Google Cloud CLI. Dopo l'installazione, inizializza Google Cloud CLI eseguendo il seguente comando:
  gcloud init
  Se utilizzi un provider di identità (IdP) esterno, devi prima accedere a gcloud CLI con la tua identità federata.
  
  Nota:se hai installato gcloud CLI in precedenza, assicurati di avere l'ultima versione eseguendo gcloud components update.
2. Set a default region and zone.
Vai

Per utilizzare gli esempi di Go questa pagina in un ambiente di sviluppo locale, installa e inizializza gcloud CLI, quindi configura le credenziali predefinite dell'applicazione con le tue credenziali utente.
Per ulteriori informazioni, vedi Set up authentication for a local development environment.
Java

Per utilizzare gli esempi di Java questa pagina in un ambiente di sviluppo locale, installa e inizializza gcloud CLI, quindi configura le credenziali predefinite dell'applicazione con le tue credenziali utente.
Per ulteriori informazioni, vedi Set up authentication for a local development environment.
Node.js

Per utilizzare gli esempi di Node.js questa pagina in un ambiente di sviluppo locale, installa e inizializza gcloud CLI, quindi configura le credenziali predefinite dell'applicazione con le tue credenziali utente.
Per ulteriori informazioni, vedi Set up authentication for a local development environment.
Python

Per utilizzare gli esempi di Python questa pagina in un ambiente di sviluppo locale, installa e inizializza gcloud CLI, quindi configura le credenziali predefinite dell'applicazione con le tue credenziali utente.
Per ulteriori informazioni, vedi Set up authentication for a local development environment.
REST

Per utilizzare gli esempi di API REST in questa pagina in un ambiente di sviluppo locale, utilizza le credenziali che fornisci a gcloud CLI.
Per saperne di più, consulta Autenticarsi per l'utilizzo di REST nella documentazione sull'autenticazione di Google Cloud .

Preparativi per creare un'immagine Windows Server

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

GCESysprep prepara un'istanza che diventa un'immagine Compute Engine seguendo questi 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 dei dischi permanenti.
Attiva le regole firewall RDP e WinRM.
Disabilita il servizio Google OS Config.
Arresta l'istanza.

Le operazioni di GCESysprep vengono registrate nel log eventi di Windows e nella porta seriale 1. Sysprep scrive all'interno di vari file di log.

Ecco come creare un'immagine Compute Engine utilizzando GCESysprep:

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

Specifica la località dell'immagine

Quando crei un'immagine personalizzata, puoi specificare la località in Cloud Storage dell'immagine, escluse quelle a due regioni. Specificando la località di archiviazione delle immagini, puoi soddisfare i requisiti normativi e di conformità per la localizzazione dei dati, nonché quelli per le esigenze di alta affidabilità, così da garantire la ridondanza tra regioni.

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

Tutte le immagini esistenti prima del lancio di questa funzionalità rimarranno dove si trovano. L'unica differenza è che puoi visualizzare la località di tutte le immagini. Se vuoi spostare un'immagine esistente, devi ricrearla nella località selezionata.

Crea un'immagine Windows

Puoi creare immagini dei dischi dalle seguenti origini:

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

Console

Nella Google Cloud console, vai alla pagina Crea una nuova immagine.
Crea una nuova immagine
Specifica il Nome dell'immagine.
Scegli un disco di Origine con un sistema operativo Windows dal quale creare un'immagine.
Specifica la Località in cui archiviare l'immagine. Scegli una località dell'immagine dal menu a discesa Basata sulla posizione del disco di origine (impostazione predefinita). Ad esempio, specifica us per archiviare l'immagine nella località multiregionale us oppure us-central1 per archiviarla nella regione us-central1. Se non effettui una selezione, Compute Engine archivia l'immagine nella multi-regione più vicina alla località di origine dell'immagine.
Specifica le proprietà dell'immagine. Ad esempio, puoi specificare un nome per la famiglia di immagini in modo da organizzare l'immagine all'interno di una famiglia di immagini.
Fai clic su Crea.

gcloud

Utilizza gcloud compute con images create e specifica il disco permanente di origine dal quale creare un'immagine. Se vuoi, 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]

Sostituisci quanto segue:

DISK_NAME: il nome del disco di origine da cui creare l'immagine.
ZONE: la zona del disco.
LOCATION: un flag facoltativo che consente di designare la regione o la multi-regione in cui verrà archiviata l'immagine. Ad esempio, specifica us per archiviare l'immagine nella località multiregionale us oppure us-central1 per archiviarla nella regione us-central1. Se non effettui una selezione, Compute Engine archivia l'immagine nella multi-regione più vicina alla località di origine dell'immagine.
--force: un flag facoltativo che crea l'immagine anche se il disco è collegato a un'istanza 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 in base al disco permanente che hai specificato e la aggiunge alla tua raccolta. Per verificare se l'immagine sia stata creata, esegui:

gcloud compute images list

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 saperne di più, 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"
	"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 nella guida rapida di Compute Engine per l'utilizzo delle librerie client. Per saperne di più, 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.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 nella guida rapida di Compute Engine per l'utilizzo delle librerie client. Per saperne di più, 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 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 nella guida rapida di Compute Engine per l'utilizzo delle librerie client. Per saperne di più, consulta la documentazione di riferimento dell'API Compute Engine per Python.

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

Sostituisci quanto segue:

PROJECT_ID: l'ID progetto per questa richiesta.
FORCE_OPTION: un flag facoltativo 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 la località di archiviazione regionale o multiregionale dell'immagine. Ad esempio, specifica us per archiviare l'immagine nella località multiregionale us oppure us-central1 per archiviarla nella regione us-central1. Se non effettui una selezione, Compute Engine archivia l'immagine nella multi-regione più vicina alla località di origine dell'immagine.

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

Aggiorna gli agenti e gli script di Windows

Di tanto in tanto, Compute Engine rilascia nuove immagini Windows con gli agenti e gli script più recenti. Questi elementi aiutano le istanze Windows nelle procedure di avvio e arresto e nelle attività di gestione degli account e degli indirizzi.

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

Creare immagini Windows Server personalizzate

Prima di iniziare

Console

gcloud

Vai

Java

Node.js

Python

REST

Preparativi per creare un'immagine Windows Server

Specifica la località dell'immagine

Crea un'immagine Windows

Console

gcloud

Go

Java

Node.js

Node.js

Python

Python

REST

Aggiorna gli agenti e gli script di Windows

Passaggi successivi