Diese Seite wurde von der Cloud Translation API übersetzt.

Benutzerdefinierte Windows Server-Images erstellen

Windows

Sie können benutzerdefinierte Windows Server-Images aus vorhandenen Compute Engine Windows Server-Images erstellen. Erstellen Sie aus diesen benutzerdefinierten Images Instanzen mit Bootlaufwerken, die Ihren vorhandenen Instanzen entsprechen.

Diese benutzerdefinierten Images unterstützen Sie dabei, die Betriebssystemkonfiguration Ihrer vorhandenen Instanzen zu speichern und dieselbe Konfiguration zum Erstellen anderer Instanzen wiederzuverwenden.

Die folgenden Aufgaben werden in diesem Abschnitt nicht behandelt:

VM aus einem öffentlichen Image oder einem benutzerdefinierten Image erstellen. Weitere Informationen dazu finden Sie unter Neue Windows-Instanz erstellen.
Planen Sie eine Sicherung Ihrer nichtflüchtigen Speicher. Weitere Informationen finden Sie unter Snapshots von nichtflüchtigem Speicher.
Importieren Sie Windows Server- oder SQL Server-Systeme; Verwenden Sie stattdessen den VM-Migrationsdienst.

Hinweise

Richten Sie die Authentifizierung ein, falls Sie dies noch nicht getan haben. Bei der Authentifizierung wird Ihre Identität für den Zugriff auf Google Cloud-Dienste und APIs überprüft. Zur Ausführung von Code oder Beispielen aus einer lokalen Entwicklungsumgebung können Sie sich bei Compute Engine authentifizieren. Wählen Sie dazu eine der folgenden Optionen aus:

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.

Erstellen von Windows Server-Image vorbereiten

Führen Sie GCESysprep für die Instanz aus, um sie für die Erstellung des Images vorzubereiten, bevor Sie das Image erstellen.

GCESysprep bereitet eine Instanz so vor, dass sie ein Compute Engine-Image wird. Dazu werden die folgenden Schritte ausgeführt:

Deaktiviert die geplante Aufgabe GCEStartup.
Löscht alle Dateien aus dem temporären Speicherort.
Löscht alle Windows-Ereignislogs.
Führt sysprep.exe /generalize /oobe /quit /unattend aus
Konfiguriert instance_setup.ps1 für die Ausführung beim ersten Start der VM-Instanz.
Löscht das RDP-Zertifikat.
Entfernt die gespeicherte Liste der nichtflüchtigen Speicher.
Aktiviert RDP- und WinRM-Firewallregeln.
Deaktiviert den Google OS Config-Dienst.
Die Instanz wird heruntergefahren.

GCESysprep-Vorgänge werden im Windows-Ereignislog und im seriellen Port 1 protokolliert. Sysprep schreibt in mehrere Logdateien.

So erstellen Sie ein Compute Engine-Image mit GCESysprep:

Führen Sie GCESysprep mit Administratorrechten aus.
```
GCESysprep
```
Erstellen Sie das Image.

Image-Speicherort angeben

Beim Erstellen eines benutzerdefinierten Images können Sie dessen Speicherort in Cloud Storage angeben, sofern es sich nicht um Standorte mit zwei Regionen handelt. Die Angabe des Image-Speicherorts ermöglicht Ihnen, geltende Vorschriften und Compliance-Anforderungen hinsichtlich der Datenlokalität einzuhalten. Außerdem können Sie Ihre hohen Verfügbarkeitsanforderungen erfüllen, da Sie für regionsübergreifende Redundanz sorgen.

Die Angabe des Speicherorts ist optional. Wenn Sie keinen Speicherort auswählen, speichert Compute Engine das Image an dem multiregionalen Standort, der der Image-Quelle am nächsten liegt. Sie haben die Möglichkeit, benutzerdefinierte Images aus Quelllaufwerken, Images, Snapshots oder in Cloud Storage gespeicherten Images zu erstellen. Diese Images können Sie als Basis für neue VM-Instanzen verwenden.

Alle Images, die Sie vor der Einführung dieses Features erstellt haben, bleiben an ihrem bisherigen Speicherort. Die einzige Änderung besteht darin, dass Sie jetzt den Image-Speicherort all Ihrer Images einsehen können. Wenn Sie ein vorhandenes Image verschieben möchten, müssen Sie es am gewünschten Speicherort neu erstellen.

Windows-Image erstellen

Sie können folgende Quellen verwenden, um Laufwerk-Images zu erstellen:

einen nichtflüchtigen Speicher, auch wenn dieser mit einer Instanz verknüpft ist
einen Snapshot eines nichtflüchtigen Speichers
ein anderes Image in Ihrem Projekt
ein Image, das von einem anderen Projekt freigegeben wird
ein in Cloud Storage gespeichertes importiertes Image

Console

Rufen Sie in der Google Cloud Console die Seite Neues Image erstellen auf.
Neues Image erstellen
Geben Sie den Namen des Images an.
Wählen Sie ein Quelllaufwerk mit einem Windows-Betriebssystem, aus dem Sie ein Image erstellen möchten.
Geben Sie den Speicherort zum Speichern des Images an. Wählen Sie im Drop-down-Menü Basierend auf dem Standort des Quelllaufwerks (Standard) einen Image-Speicherort aus. Geben Sie beispielsweise us an, um das Image an dem multiregionalen Standort us zu speichern, oder us-central1, um es in der Region us-central1 zu speichern. Wenn Sie keine Auswahl treffen, wird das Image von Compute Engine an dem multiregionalen Standort gespeichert, der dem Quellspeicherort des Images am nächsten liegt.
Legen Sie die gewünschten Attribute des Images fest. Sie können zum Beispiel einen Image-Familiennamen für Ihr Image angeben, um dieses Image als Teil einer Image-Familie zu organisieren.
Klicken Sie auf Erstellen.

gcloud

Verwenden Sie den Befehl gcloud compute mit images create und geben Sie den nichtflüchtigen Quellspeicher an, aus dem Sie ein Image erstellen möchten. Fügen Sie optional das Flag --force hinzu, um das Image auch dann zu erstellen, wenn eine Verbindung mit einer momentan ausgeführten Instanz besteht.

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

[DISK_NAME] ist der Name des Quelllaufwerks, von dem ein Image erstellt werden soll.
[ZONE] ist die Zone des Laufwerks.
[LOCATION] ist ein optionales Flag, mit dem Sie die Region oder den multiregionalen Standort zum Speichern des Images festlegen können. Geben Sie beispielsweise us an, um das Image an dem multiregionalen Standort us zu speichern, oder us-central1, um es in der Region us-central1 zu speichern. Wenn Sie keine Auswahl treffen, wird das Image von Compute Engine an dem multiregionalen Standort gespeichert, der dem Quellspeicherort des Images am nächsten liegt.
--force ist ein optionales Flag, mit dem das Image auch dann erstellt wird, wenn das Laufwerk mit einer noch ausgeführten Instanz verbunden ist. Diese Option kann die Integrität des Images beeinträchtigen. Beenden Sie die Instanz nach Möglichkeit, bevor Sie das Image erstellen.

Wenn Sie diesen Befehl ausführen, erstellt gcloud compute auf Grundlage des nichtflüchtigen Speichers, den Sie angegeben haben, ein neues Image und fügt es Ihrer Sammlung hinzu. Mit dem folgenden Befehl prüfen Sie, ob das Image erfolgreich erstellt wurde:

gcloud compute images list

Go

Bevor Sie dieses Beispiel anwenden, folgen Sie den Schritten zur Einrichtung von Go in der Compute Engine-Kurzanleitung zur Verwendung von Clientbibliotheken. Weitere Informationen finden Sie in der Referenzdokumentation zur Compute Engine Go API.

Richten Sie die Standardanmeldedaten für Anwendungen ein, um sich bei Compute Engine zu authentifizieren. Weitere Informationen finden Sie unter Authentifizierung für eine lokale Entwicklungsumgebung einrichten.

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

Bevor Sie dieses Beispiel anwenden, folgen Sie den Schritten zur Einrichtung von Java in der Compute Engine-Kurzanleitung zur Verwendung von Clientbibliotheken. Weitere Informationen finden Sie in der Referenzdokumentation zur Compute Engine Java API.


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

Bevor Sie dieses Beispiel anwenden, folgen Sie den Schritten zur Einrichtung von Node.js in der Compute Engine-Kurzanleitung zur Verwendung von Clientbibliotheken. Weitere Informationen finden Sie in der Referenzdokumentation zur Compute Engine Node.js API.

/**
 * 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

Bevor Sie dieses Beispiel anwenden, folgen Sie den Schritten zur Einrichtung von Python in der Compute Engine-Kurzanleitung zur Verwendung von Clientbibliotheken. Weitere Informationen finden Sie in der Referenzdokumentation zur Compute Engine Python API.

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

Stellen Sie eine POST-Anfrage an die Methode images().insert. Fügen Sie in den Anfragetext eine sourceDisk-URL ein.

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

Dabei gilt:

[PROJECT_ID] ist die Projekt-ID für diese Anfrage.
[FORCE_OPTION] ist eine Option, mit der das Image auch dann erstellt wird, wenn das Quelllaufwerk mit einer momentan ausgeführten Instanz verbunden ist. Geben Sie am Ende der POST-Zeile forceCreate=true an, um diese Option festzulegen. Diese Option kann die Integrität des Images beeinträchtigen. Beenden Sie die Instanz nach Möglichkeit, bevor Sie das Image erstellen.
[IMAGE_NAME] ist der Name, der dem Image gegeben wurde.
[ZONE] ist die Zone des Quelllaufwerks, von dem ein Image erstellt werden soll.
[DISK_NAME] ist der Name des Quelllaufwerks.
[LOCATION] ist ein optionaler Parameter, mit dem Sie den Speicherort des Images in einer Region oder an einem multiregionalen Standort auswählen können. Geben Sie beispielsweise us an, um das Image an dem multiregionalen Standort us zu speichern, oder us-central1, um es in der Region us-central1 zu speichern. Wenn Sie keine Auswahl treffen, wird das Image von Compute Engine an dem multiregionalen Standort gespeichert, der dem Quellspeicherort des Images am nächsten liegt.

Weitere Informationen zum Hinzufügen von Images finden Sie in der Image-Referenz.

Windows-Agents und -Scripts aktualisieren

Compute Engine gibt von Zeit zu Zeit neue Windows-Images mit den neuesten Agents und Skripts heraus. Diese Objekte helfen Windows-Instanzen beim Starten und Herunterfahren, der Kontoverwaltung und der Adressverwaltung.

Seit der Image-Version v20160112 von Windows aktualisiert sich der Windows-Agent bei vorgeschalteten Releases selbst. Wenn Sie den Metadatenschlüssel disable-agent-updates der Instanz auf true setzen, können Sie die Aktualisierung der Agents deaktivieren. Bei Instanzen, die auf älteren Image-Releases basieren, können Sie den Windows-Agent dieser Instanzen manuell aktualisieren.

Benutzerdefinierte Windows Server-Images erstellen

Hinweise

Console

gcloud

Go

Java

Node.js

Python

REST

Erstellen von Windows Server-Image vorbereiten

Image-Speicherort angeben

Windows-Image erstellen

Console

gcloud

Go

Java

Node.js

Node.js

Python

Python

REST

Windows-Agents und -Scripts aktualisieren

Nächste Schritte