Questa pagina è stata tradotta dall'API Cloud Translation.

Crea immagini Windows Server personalizzate

Finestre .

Puoi creare immagini Windows Server personalizzate da Compute Engine esistente Immagini Windows Server. Utilizza queste immagini personalizzate per creare istanze con avvio che corrispondono a quelle delle istanze esistenti.

Queste immagini personalizzate sono utili per salvare la configurazione del sistema operativo delle tue 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 Creare una nuova istanza Windows.
Pianificare un backup dei dischi permanenti. vedi invece snapshot di dischi permanenti.
importare sistemi Windows Server o SQL Server; utilizza invece Servizio di migrazione delle VM.

Prima di iniziare

Se non l'hai già fatto, configura l'autenticazione. Autenticazione è Il processo di verifica dell'identità per l'accesso ai servizi e alle API di Google Cloud. Per eseguire codice o esempi da un ambiente di sviluppo locale, puoi eseguire l'autenticazione Compute Engine come segue.

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.

Preparati a creare un'immagine Windows Server

Prima di creare l'immagine, esegui GCESysprep sull'istanza per prepararla per il processo di creazione delle immagini.

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 dei 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 sulla porta seriale 1 di Windows. Sysprep scrive su più file file di log.

Come creare un'immagine Compute Engine utilizzando GCESysprep:

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

Specifica una posizione per l'immagine

Quando crei un'immagine personalizzata, puoi specificare Località Cloud Storage, ad eccezione località a due regioni. Specificando il percorso di archiviazione delle immagini, può soddisfare i requisiti normativi e di conformità anche per la località dei dati per soddisfare le tue esigenze di alta disponibilità, garantendo la ridondanza tra regioni.

La funzionalità della posizione di archiviazione è facoltativa. Se non selezioni una località, Compute Engine archivierà l'immagine nella località multiregionale più vicina al 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 di nuove istanze VM.

Tutte le immagini esistenti prima del lancio di questa funzionalità rimarranno dove si trovano. L'unica modifica è che puoi visualizzare la posizione di tutte le tue immagini. Se desideri spostare un'immagine esistente, devi ricrearla nel 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 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 Posizione in cui archiviare l'immagine. Scegli una posizione dell'immagine dal menu a discesa In base alla posizione del disco di origine (predefinita). Ad esempio, specifica us per archiviare l'immagine nell'elemento us più regioni o us-central1 per archiviarlo nella regione us-central1. Se non effettui una selezione, Compute Engine archivierà nell'area multiregionale più vicina alla posizione di origine dell'immagine.
Specifica le proprietà dell'immagine. Ad esempio, puoi specifica un nome di famiglia di immagini per la tua immagine per organizzare questa immagine come che fanno parte di una famiglia di immagini.
Fai clic su Crea.

gcloud

Usa gcloud compute con images create e fornire il disco permanente di origine da cui vuoi creare un'immagine. (Facoltativo) Includi il flag --force per creare l'immagine anche se è 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 designare la regione o le regioni in cui verrà archiviata l'immagine. Ad esempio, specifica us per archiviare l'immagine nell'elemento us più regioni o us-central1 per archiviarlo nella regione us-central1. Se non effettui una selezione, Compute Engine archivierà nell'area multiregionale più vicina alla posizione di origine dell'immagine.
--force è un flag facoltativo che crea l'immagine anche se il disco a un'istanza ancora in esecuzione. Questa opzione potrebbe compromettere l'integrità dell'immagine. Arresta l'istanza prima di se possibile.

Quando esegui questo comando, gcloud compute crea una nuova immagine basata su il disco permanente che hai fornito e lo aggiunge alla tua raccolta. Puoi conferma che l'immagine sia stata creata eseguendo:

gcloud compute images list

Vai

Prima di provare questo esempio, segui le istruzioni per la configurazione di Go nel Guida rapida di Compute Engine con librerie client. Per ulteriori informazioni, consulta API Go Compute Engine documentazione di riferimento.

Per eseguire l'autenticazione su Compute Engine, configura Credenziali predefinite dell'applicazione. Per ulteriori informazioni, vedi 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 per la configurazione di Java nel Guida rapida di Compute Engine con librerie client. Per ulteriori informazioni, consulta API Java Compute Engine documentazione di riferimento.

Per eseguire l'autenticazione su Compute Engine, configura Credenziali predefinite dell'applicazione. Per ulteriori 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]);
      }
    };
  }

}

Node.js

Prima di provare questo esempio, segui le istruzioni per la configurazione di Node.js nel Guida rapida di Compute Engine con librerie client. Per ulteriori informazioni, consulta API Node.js Compute Engine documentazione di riferimento.

Per eseguire l'autenticazione su Compute Engine, configura Credenziali predefinite dell'applicazione. Per ulteriori informazioni, vedi Configura 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 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 per la configurazione di Python nel Guida rapida di Compute Engine con librerie client. Per ulteriori informazioni, consulta API Python Compute Engine documentazione di riferimento.

Per eseguire l'autenticazione su Compute Engine, configura Credenziali predefinite dell'applicazione. Per ulteriori informazioni, vedi Configura 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 a 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 l'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. Arresta l'istanza prima di se possibile.
[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 ti consente di selezionare la località di archiviazione multiregionale o a livello di regione della tua immagine. Ad esempio, specifica us per archiviare l'immagine nell'elemento us più regioni o us-central1 per archiviarlo nella regione us-central1. Se non effettui una selezione, Compute Engine archivierà nell'area multiregionale più vicina alla posizione di origine dell'immagine.

Per ulteriori informazioni sull'aggiunta di immagini, consulta riferimento alle immagini.

Aggiorna agenti e script Windows

Compute Engine a volte rilascia nuove immagini Windows con con agenti e script più recenti. Questi elementi aiutano le istanze Windows nell'avvio processi di chiusura, gestione degli account e gestione degli indirizzi.

A partire dalla versione dell'immagine Windows v20160112, l'agente Windows si aggiorna automaticamente con delle release upstream. Puoi disabilitare gli aggiornamenti dell'agente impostando Chiave dei metadati dell'istanza disable-agent-updates in true. Se hai 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

Vai

Java

Node.js

Python

REST

Preparati a creare un'immagine Windows Server

Specifica una posizione per l'immagine

Crea un'immagine Windows

Console

gcloud

Vai

Java

Node.js

Node.js

Python

Python

REST

Aggiorna agenti e script Windows

Passaggi successivi