创建自定义 Windows Server 映像

Windows

您可以通过现有 Compute Engine Windows Server 映像创建自定义 Windows Server 映像。使用这些自定义映像可创建与现有实例具有相同启动磁盘的实例。

这些自定义映像十分实用，可用于保存现有实例的操作系统配置，并重复使用相同的配置来创建其他实例。

本部分未介绍以下任务：

通过公共映像或自定义映像创建虚拟机：请改为参阅创建新的 Windows 实例。
安排永久性磁盘的备份：请改为参阅永久性磁盘快照。
导入 Windows Server 或 SQL Server 系统；请改为使用虚拟机迁移服务。

准备工作

设置身份验证（如果尚未设置）。身份验证是通过其进行身份验证以访问 Google Cloud 服务和 API 的过程。如需从本地开发环境运行代码或示例，您可以按如下方式向 Compute Engine 进行身份验证。

选择标签页以了解您打算如何使用本页面上的示例：
控制台

当您使用 Google Cloud 控制台访问 Google Cloud 服务和 API 时，无需设置身份验证。
gcloud
1. 安装 Google Cloud CLI，然后通过运行以下命令初始化 Google Cloud CLI：
```
gcloud init
```
  注意：如果您之前安装了 gcloud CLI，请确保通过运行 gcloud components update 获得最新版本。
2. 设置默认区域和可用区。
Go

如需从本地开发环境使用本页面上的 Go 示例，请安装并初始化 gcloud CLI，然后使用用户凭据设置应用默认凭据。
1. 安装 Google Cloud CLI。
2. 如需初始化 gcloud CLI，请运行以下命令：
```
gcloud init
```
3. 为您的 Google 账号创建本地身份验证凭据：
```
gcloud auth application-default login
```
如需了解详情，请参阅为本地开发环境设置身份验证。
Java

如需从本地开发环境使用本页面上的 Java 示例，请安装并初始化 gcloud CLI，然后使用用户凭据设置应用默认凭据。
1. 安装 Google Cloud CLI。
2. 如需初始化 gcloud CLI，请运行以下命令：
```
gcloud init
```
3. 为您的 Google 账号创建本地身份验证凭据：
```
gcloud auth application-default login
```
如需了解详情，请参阅为本地开发环境设置身份验证。
Node.js

如需从本地开发环境使用本页面上的 Node.js 示例，请安装并初始化 gcloud CLI，然后使用用户凭据设置应用默认凭据。
1. 安装 Google Cloud CLI。
2. 如需初始化 gcloud CLI，请运行以下命令：
```
gcloud init
```
3. 为您的 Google 账号创建本地身份验证凭据：
```
gcloud auth application-default login
```
如需了解详情，请参阅为本地开发环境设置身份验证。
Python

如需从本地开发环境使用本页面上的 Python 示例，请安装并初始化 gcloud CLI，然后使用用户凭据设置应用默认凭据。
1. 安装 Google Cloud CLI。
2. 如需初始化 gcloud CLI，请运行以下命令：
```
gcloud init
```
3. 为您的 Google 账号创建本地身份验证凭据：
```
gcloud auth application-default login
```
如需了解详情，请参阅为本地开发环境设置身份验证。
REST

如需在本地开发环境中使用本页面上的 REST API 示例，请使用您提供给 gcloud CLI 的凭据。

准备创建 Windows Server 映像

在创建映像之前，请先在实例上运行 GCESysprep，以便为映像创建过程做好准备。

GCESysprep 通过完成以下步骤准备实例成为 Compute Engine 映像：

停用 GCEStartup 计划任务。
删除临时文件夹位置中的所有文件。
清除所有 Windows 事件日志。
运行 sysprep.exe /generalize /oobe /quit /unattend
将 instance_setup.ps1 配置为在首次启动虚拟机实例时运行。
删除 RDP 证书。
移除永久性磁盘的存储列表。
启用 RDP 和 WinRM 防火墙规则。
停用 Google OS Config 服务。
关停实例。

GCESysprep 操作会记录到 Windows 事件日志和串行端口 1。 Sysprep 写入多个日志文件。

如何使用 GCESysprep 创建 Compute Engine 映像：

以管理权限运行 GCESysprep。
```
GCESysprep
```
创建映像。

指定映像位置

创建自定义映像时，您可以为该映像指定除了双区域位置之外的 Cloud Storage 位置。指定映像存储位置后，您可以通过确保跨区域实现冗余来满足数据存储区域的法规和合规性要求以及高可用性需求。

存储位置功能是可选的。如果您未选择位置，Compute Engine 会将映像存储在最靠近映像源的多区域位置。您可以根据源磁盘、映像、快照或存储在 Cloud Storage 中的映像创建自定义映像。您可以使用这些映像创建新的虚拟机实例。

此功能发布之前的所有现有映像都保留在原来的位置。唯一的变化是您可以查看所有映像的位置。如果要移动现有映像，您必须在目标位置重新创建该映像。

创建 Windows 映像

您可从以下来源创建磁盘映像：

永久性磁盘，即使该磁盘已连接到实例。
永久性磁盘的快照
您项目中的另一个映像
通过另一个项目共享的映像
存储在 Cloud Storage 中的导入的映像

控制台

在 Google Cloud 控制台中，转到创建新映像页面。
创建新映像
指定映像名称。
选择含有 Windows 操作系统并且您希望根据其创建映像的源磁盘。
指定用于存储映像的位置。从基于来源磁盘位置（默认）(Based on source disk location (default)) 下拉菜单中选择映像位置。例如，指定 us 可将映像存储在 us 多区域中，或指定 us-central1 可将其存储在 us-central1 区域中。如果您未选择位置，Compute Engine 会将映像存储在最靠近映像源位置的多区域中。
指定您的映像的属性。例如，您可以为映像指定映像系列名称，以将此映像纳入映像系列中。
点击创建。

gcloud

可将 gcloud compute 与 images create 搭配使用，并提供您希望在其中创建映像的源永久性磁盘。（可选）添加 --force 标志，可以在即使磁盘挂接到正在运行的实例的情况下，继续创建映像。

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

[DISK_NAME] 是要在其中创建映像的源磁盘的名称。
[ZONE] 是磁盘的地区。
[LOCATION] 是一个可选标志，允许您指定要存储映像的区域或多区域。例如，指定 us 可将映像存储在 us 多区域中，或指定 us-central1 可将其存储在 us-central1 区域中。如果您未选择位置，Compute Engine 会将映像存储在最靠近映像来源位置的多区域中。
--force 是一个可选标志，即使在磁盘已挂接到仍在运行的实例的情况下，也会创建映像。但这一选项可能会损害映像的完整性。如果可能，请在创建映像前停止实例。

运行此命令时，gcloud compute 会根据您提供的永久性磁盘创建新映像，并将其添加到您的集合中。您可以通过运行以下命令来确认您的映像已成功创建：

gcloud compute images list

Go

试用此示例之前，请按照《Compute Engine 快速入门：使用客户端库》中的 Go 设置说明进行操作。如需了解详情，请参阅 Compute Engine Go API 参考文档。

如需向 Compute Engine 进行身份验证，请设置应用默认凭据。如需了解详情，请参阅为本地开发环境设置身份验证。

在 GitHub 上查看反馈

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

	compute "cloud.google.com/go/compute/apiv1"
	computepb "google.golang.org/genproto/googleapis/cloud/compute/v1"
	"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

试用此示例之前，请按照《Compute Engine 快速入门：使用客户端库》中的 Java 设置说明进行操作。如需了解详情，请参阅 Compute Engine Java API 参考文档。

如需向 Compute Engine 进行身份验证，请设置应用默认凭据。如需了解详情，请参阅为本地开发环境设置身份验证。

在 GitHub 上查看反馈


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

试用此示例之前，请按照《Compute Engine 快速入门：使用客户端库》中的 Node.js 设置说明进行操作。如需了解详情，请参阅 Compute Engine Node.js API 参考文档。

如需向 Compute Engine 进行身份验证，请设置应用默认凭据。如需了解详情，请参阅为本地开发环境设置身份验证。

在 GitHub 上查看反馈

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

试用此示例之前，请按照《Compute Engine 快速入门：使用客户端库》中的 Python 设置说明进行操作。如需了解详情，请参阅 Compute Engine Python API 参考文档。

如需向 Compute Engine 进行身份验证，请设置应用默认凭据。如需了解详情，请参阅为本地开发环境设置身份验证。

在 GitHub 上查看反馈

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

向 images().insert 方法发出 POST 请求，并在请求正文中添加 sourceDisk 网址。

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

其中：

[PROJECT_ID] 是此请求的项目 ID。
[FORCE_OPTION] 是一个选项，如果使用该选项，那么即使来源磁盘已挂接到正在运行的实例，也会创建映像。请在 POST 行的末尾指定 forceCreate=true 来设置此选项。但这一选项可能会损害映像的完整性。如果可能，请在创建映像前停止实例。
[IMAGE_NAME] 是为此映像指定的名称。
[ZONE] 是根据其创建映像的来源磁盘的地区。
[DISK_NAME] 是来源磁盘的名称。
[LOCATION] 是一个可选参数，可让您选择映像的多区域或区域存储位置。例如，指定 us 可将映像存储在 us 多区域中，或指定 us-central1 可将其存储在 us-central1 区域中。如果您未选择位置，Compute Engine 会将映像存储在最靠近映像源位置的多区域中。

有关添加映像的更多信息，请参阅映像参考。

更新 Windows 代理和脚本

Compute Engine 会不定期发布含有最新代理和脚本的新 Windows 映像。这些代理和脚本可以在启动和关停过程、账号管理和地址管理方面为 Windows 实例提供帮助。

从 Windows 映像版本 v20160112 开始，Windows 代理将通过上游版本自行更新。您可以通过将 disable-agent-updates 实例元数据键设置为 true 来停用这些代理更新。如果您的实例基于较早映像版本，则可以为这些实例手动更新 Windows 代理。

创建自定义 Windows Server 映像

准备工作

控制台

gcloud

Go

Java

Node.js

Python

REST

准备创建 Windows Server 映像

指定映像位置

创建 Windows 映像

控制台

gcloud

Go

Java

Node.js

Node.js

Python

Python

REST

更新 Windows 代理和脚本

后续步骤