使用預留項目

本文說明如何在 Compute Engine 中使用預留項目。如要瞭解如何在支援預訂的其他 Google Cloud產品中使用預訂，請參閱下列文件：

建立預留項目後，或 Compute Engine 自動建立預留項目，以履行未來預留項目或日曆模式中的未來預留項目後，Compute Engine 會為您的專案和共用預留項目的任何專案保留預留資源。建立符合預留項目屬性的 Compute Engine 執行個體時，您會「使用」預留項目，也就是使用預留資源建立運算執行個體，而非使用運算執行個體可用區中的可用資源。在完全用完預訂項目之前，您都可以使用預訂項目建立運算執行個體。

限制

您無法使用預留項目建立下列 Compute Engine 資源：

  • 彈性啟動型 VM

  • Spot VM 或先占執行個體

  • 單一租戶節點

事前準備

  • 如果尚未設定驗證，請先完成設定。驗證程序會確認您的身分，以便授予 Google Cloud 服務和 API 的存取權。如要從本機開發環境執行程式碼或範例，您可以選取下列其中一個選項，向 Compute Engine 進行驗證：

    請根據您打算如何使用本頁範例，選取對應的分頁標籤：

    控制台

    使用 Google Cloud 控制台存取 Google Cloud 服務和 API 時，您不需要設定驗證機制。

    gcloud

    1. 安裝 Google Cloud CLI。 安裝完成後，請執行下列指令，初始化 Google Cloud CLI：

      gcloud init

      若您採用的是外部識別資訊提供者 (IdP)，請先 使用聯合身分登入 gcloud CLI。

  • 設定預設區域和可用區。

    • Go

    如要在本機開發環境中使用本頁的 Go 範例，請安裝並初始化 gcloud CLI，然後使用使用者憑證設定應用程式預設憑證。

    1. 安裝 Google Cloud CLI。

    2. 若您採用的是外部識別資訊提供者 (IdP)，請先 使用聯合身分登入 gcloud CLI。

    3. 如果您使用的是本機殼層，請為使用者帳戶建立本機驗證憑證： 

      gcloud auth application-default login

      如果您使用的是 Cloud Shell，則不必執行這項操作。

      如果系統傳回驗證錯誤，且您使用的是外部識別資訊提供者 (IdP)，請確認您已 使用聯合身分登入 gcloud CLI。

    詳情請參閱「 設定本機開發環境的驗證機制」。

    Java

    如要在本機開發環境中使用本頁的 Java 範例，請安裝並初始化 gcloud CLI，然後使用使用者憑證設定應用程式預設憑證。

    1. 安裝 Google Cloud CLI。

    2. 若您採用的是外部識別資訊提供者 (IdP)，請先 使用聯合身分登入 gcloud CLI。

    3. 如果您使用的是本機殼層，請為使用者帳戶建立本機驗證憑證： 

      gcloud auth application-default login

      如果您使用 Cloud Shell，則不需要執行這項操作。

      如果系統傳回驗證錯誤，且您使用外部識別資訊提供者 (IdP)，請確認您已 使用聯合身分登入 gcloud CLI。

    詳情請參閱「 設定本機開發環境的驗證機制」。

    Node.js

    如要在本機開發環境中使用本頁的 Node.js 範例，請安裝並初始化 gcloud CLI，然後使用使用者憑證設定應用程式預設憑證。

    1. 安裝 Google Cloud CLI。

    2. 若您採用的是外部識別資訊提供者 (IdP)，請先 使用聯合身分登入 gcloud CLI。

    3. 如果您使用的是本機殼層，請為使用者帳戶建立本機驗證憑證： 

      gcloud auth application-default login

      如果您使用 Cloud Shell，則不需要執行這項操作。

      如果系統傳回驗證錯誤，且您使用的是外部識別資訊提供者 (IdP)，請確認您已 使用聯合身分登入 gcloud CLI。

    詳情請參閱「 為本機開發環境設定驗證機制」。

    Python

    如要在本機開發環境中使用本頁的 Python 範例，請安裝並初始化 gcloud CLI，然後使用使用者憑證設定應用程式預設憑證。

    1. 安裝 Google Cloud CLI。

    2. 如果您使用外部識別資訊提供者 (IdP)，請先 使用聯合身分登入 gcloud CLI。

    3. 如果您使用本機殼層，請為使用者帳戶建立本機驗證憑證： 

      gcloud auth application-default login

      如果您使用的是 Cloud Shell，則不必執行這項操作。

      如果系統傳回驗證錯誤，且您使用的是外部識別資訊提供者 (IdP)，請確認您已 使用聯合身分登入 gcloud CLI。

    詳情請參閱「 為本機開發環境設定驗證機制」。

    REST

    如要在本機開發環境中使用本頁的 REST API 範例，請使用您提供給 gcloud CLI 的憑證。

      安裝 Google Cloud CLI。

      若您採用的是外部識別資訊提供者 (IdP)，請先 使用聯合身分登入 gcloud CLI。

    詳情請參閱 Google Cloud 驗證說明文件中的「使用 REST 進行驗證」一節。

必要的角色

如要取得使用預留資源所需的權限，請要求管理員授予您下列 IAM 角色：

如要進一步瞭解如何授予角色，請參閱「管理專案、資料夾和組織的存取權」。

這些預先定義的角色具備使用預留項目所需的權限。如要查看確切的必要權限，請展開「Required permissions」(必要權限) 部分：

所需權限

必須具備下列權限，才能使用預留項目：

  • 如要建立預留項目： compute.reservations.create 專案
  • 如要建立運算執行個體，請按照下列步驟操作：
    • 專案的 compute.instances.create 權限
    • 如要使用自訂映像檔建立 VM，請在映像檔上執行 compute.images.useReadOnly
    • 如要使用快照建立 VM，請在快照上compute.snapshots.useReadOnly
    • 如要使用執行個體範本建立 VM，請按一下執行個體範本上的 compute.instanceTemplates.useReadOnly
    • 如要將舊版網路指派給 VM，請在專案中執行 compute.networks.use
    • 如要為 VM 指定靜態 IP 位址，請在專案中執行下列步驟：compute.addresses.use
    • 使用舊版網路時，將外部 IP 位址指派給 VM：compute.networks.useExternalIp 專案
    • 如要為 VM 指定子網路，請在專案或所選子網路上執行 compute.subnetworks.use
    • 使用虛擬私有雲網路時，將外部 IP 位址指派給 VM：compute.subnetworks.useExternalIp 在專案或所選子網路上
    • 如要為專案中的 VM compute.instances.setMetadata 設定 VM 執行個體中繼資料，請按照下列步驟操作：
    • 如要為 VM 設定標記，請在 VM 上執行下列步驟：compute.instances.setTags
    • 如要設定 VM 的標籤，請在 VM 上執行 compute.instances.setLabels
    • 如要設定 VM 使用的服務帳戶，請在 VM 上執行 compute.instances.setServiceAccount
    • 為 VM 建立新磁碟：在專案中按一下 compute.disks.create
    • 如要以唯讀或讀寫模式掛接現有磁碟，請按一下磁碟上的 compute.disks.use
    • 如要以唯讀模式連接現有磁碟：在磁碟上compute.disks.useReadOnly
  • 如要建立執行個體範本，請在專案中執行 compute.instanceTemplates.create

您或許還可透過自訂角色或其他預先定義的角色取得這些權限。

使用預留項目

以下各節的範例說明如何建立單一運算執行個體，藉此使用預留項目。您也可以使用其他部署選項，建立符合預留項目屬性的運算執行個體，或更新現有運算執行個體的屬性，使其符合自動使用的預留項目，藉此使用預留項目。

如要使用預留項目，請採取下列其中一種方法：

  • 如要建立運算執行個體，並耗用您建立的自動預留項目，或 Compute Engine 為滿足未來預留項目而自動建立的預留項目，請參閱「耗用自動耗用的預留項目」。

  • 如要建立耗用您建立的特定預留項目，或 Compute Engine 自動建立的預留項目 (用於滿足未來預留項目要求) 的運算執行個體，請參閱「耗用明確指定的預留項目」。

  • 如要建立運算執行個體，以使用 Compute Engine 自動建立的特定預留項目，滿足日曆模式中的未來預留項目，請參閱「使用日曆模式中自動建立的要求預留項目」。

使用自動耗用的預留項目

如果預留項目可自動使用，任何符合預留項目屬性的運算執行個體都能自動使用。這項消耗行為適用於新的和現有執行中的運算執行個體。建立隨需預留項目時，或 Compute Engine 自動建立預留項目來滿足未來預留項目要求時，系統會預設使用這類預留項目。

如果單一專案自動預留項目和共用自動預留項目的屬性相符，專案中的運算執行個體會先使用單一專案預留項目，再使用共用預留項目。詳情請參閱「預留項目的用量順序」。

如要建立及使用範例自動預留項目，請選取下列任一選項：

控制台

以下範例說明如何在可用區 us-central1-a 中，為三個具有 32 個 vCPU 的 N2 執行個體建立自動預留項目，並將 Intel Cascade Lake 設為最低 CPU 平台。以及如何建立單一運算執行個體來使用預留項目。

如要建立範例自動預留項目並使用，請按照下列步驟操作：

  1. 如要建立範例預留項目，請完成下列步驟：

    1. 前往 Google Cloud 控制台的「Reservations」(預留項目) 頁面。

      前往「Reservations」(預留項目) 頁面

      其餘步驟會自動顯示在Google Cloud 控制台。

    2. 在「On-demand reservation」(隨需預留項目) 分頁，按一下 「Create reservation」(建立預留項目)。「Create a reservation」(建立預留項目) 頁面隨即顯示。

    3. 在「Name」(名稱) 欄位，輸入預留項目的名稱，例如：reservation-01。

    4. 選取要預留資源的「Region」(區域) 和「Zone」(可用區)。例如，分別選取「us-central1」和「us-central1-a」。

    5. 在「Share type」(共用類型) 部分，執行下列其中一項操作：

      • 如要建立單一專案預留項目，請選取「本機」。

      • 如要建立共用預留項目，請選取「Shared」(共用)，然後指定要共用預留項目的專案。

    6. 在「Use with VM instance」(用於 VM 執行個體) 區段中，選取「Use reservation automatically」(自動使用預留項目) (若尚未選取)。

    7. 在「Number of VM instances」(VM 執行個體數量) 欄位，輸入 3。

    8. 在「一般用途」分頁中，選取「N2」。

    9. 在「Machine type」(機型) 區段的「Preset」(預設) 分頁 (預設) 中，選取「n2-standard-32」。

    10. 展開「CPU platform and GPU」(CPU 平台和 GPU)，然後在「CPU platform」(CPU 平台) 欄位中選取「Intel Cascade Lake or later」(Intel Cascade Lake 以上版本)。

    11. 點選「建立」。

  2. 如要建立使用範例預留項目的運算執行個體，請完成下列步驟：

    1. 前往 Google Cloud 控制台的「建立執行個體」頁面。

      前往「Create an instance」(建立執行個體)

      「建立執行個體」頁面隨即顯示，並顯示「機器設定」窗格。

    2. 在「機器設定」窗格中，執行下列操作：

      1. 在「Name」(名稱) 欄位中，輸入運算執行個體的名稱。在本例中，請輸入 instance-01。

      2. 指定要預留資源的「Region」(區域) 和「Zone」(可用區)。在本範例中，請分別選取「us-central1」和「us-central1-a」。

      3. 在「一般用途」分頁中，選取「N2」。

      4. 在「機型」部分，選取「預設」分頁 (預設)，然後選取「n2-standard-32」。

      5. 展開「進階選項」部分，然後在「CPU 平台」欄位中選取「Intel Cascade Lake 以上版本」。

    3. 選用：預設設定是自動使用相符的預留項目。不過，如要指定這項設定，請按照下列步驟操作：

      1. 在導覽選單中，按一下「Advanced」(進階)。系統隨即會顯示「Advanced」(進階) 窗格。

      2. 在「Reservations」(預留項目) 部分，選取「Use automatic selection」(使用自動選取功能)。

    4. 點選「建立」。

gcloud

以下範例說明如何在區域 us-central1-a 中，為三個具有 32 個 vCPU 的 N2 執行個體建立自動預留項目，並將 Intel Cascade Lake 設為最低 CPU 平台。以及如何建立單一運算執行個體來使用預留項目。

如要建立範例自動預留項目並使用，請按照下列步驟操作：

  1. 如要建立範例預留項目，請使用 gcloud compute reservations create 指令：

    gcloud compute reservations create reservation-01 \
    --machine-type=n2-standard-32 \
    --min-cpu-platform="Intel Cascade Lake" \
    --vm-count=3 \
    --zone=us-central1-a

  2. 如要建立使用範例預留項目的運算執行個體，請使用 gcloud compute instances create 指令，並將 --reservation-affinity 旗標設為 any。由於 any 是預設設定，因此您也可以省略這個標記。

    gcloud compute instances create instance-01 \
    --machine-type=n2-standard-32 \
    --min-cpu-platform="Intel Cascade Lake" \
    --reservation-affinity=any \
    --zone=us-central1-a

Go

如要使用執行個體範本建立範例自動預留項目，並使用相同範本建立要使用預留項目的執行個體，請使用下列程式碼範例：

import (
	"context"
	"fmt"
	"io"

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

// consumeAnyReservation creates instance, consuming any available reservation
func consumeAnyReservation(w io.Writer, projectID, zone, instanceName, sourceTemplate string) error {
	// projectID := "your_project_id"
	// zone := "us-west3-a"
	// instanceName := "your_instance_name"
	// sourceTemplate: existing template path. Following formats are allowed:
	//  	- projects/{project_id}/global/instanceTemplates/{template_name}
	//  	- projects/{project_id}/regions/{region}/instanceTemplates/{template_name}
	//  	- https://www.googleapis.com/compute/v1/projects/{project_id}/global/instanceTemplates/instanceTemplate
	//  	- https://www.googleapis.com/compute/v1/projects/{project_id}/regions/{region}/instanceTemplates/instanceTemplate

	ctx := context.Background()

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

	req := &computepb.InsertInstanceRequest{
		Project:                projectID,
		Zone:                   zone,
		SourceInstanceTemplate: proto.String(sourceTemplate),
		InstanceResource: &computepb.Instance{
			Name: proto.String(instanceName),
			// specifies that any matching reservation should be consumed
			ReservationAffinity: &computepb.ReservationAffinity{
				ConsumeReservationType: proto.String("ANY_RESERVATION"),
			},
		},
	}

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

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

	return nil
}

Java

以下範例說明如何建立 N1 執行個體，其中包含四個 vCPU，並以 Intel Skylake 做為可用區 us-central1-a 的最低 CPU 平台。執行個體會自動耗用相符的預留項目。

如要建立範例執行個體，請使用下列程式碼範例：

import static com.google.cloud.compute.v1.ReservationAffinity.ConsumeReservationType.ANY_RESERVATION;

import com.google.api.gax.longrunning.OperationFuture;
import com.google.cloud.compute.v1.AttachedDisk;
import com.google.cloud.compute.v1.AttachedDiskInitializeParams;
import com.google.cloud.compute.v1.InsertInstanceRequest;
import com.google.cloud.compute.v1.Instance;
import com.google.cloud.compute.v1.InstancesClient;
import com.google.cloud.compute.v1.NetworkInterface;
import com.google.cloud.compute.v1.Operation;
import com.google.cloud.compute.v1.ReservationAffinity;
import java.io.IOException;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.TimeoutException;

public class ConsumeAnyMatchingReservation {

  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 want to use.
    String projectId = "YOUR_PROJECT_ID";
    // Zone where the VM instance will be created.
    String zone = "us-central1-a";
    // Name of the VM instance you want to query.
    String instanceName = "YOUR_INSTANCE_NAME";
    // machineType: machine type of the VM being created.
    // *   For a list of machine types, see https://cloud.google.com/compute/docs/machine-types
    String machineTypeName = "n1-standard-4";
    // sourceImage: path to the operating system image to mount.
    // *   For details about images you can mount, see https://cloud.google.com/compute/docs/images
    String sourceImage = "projects/debian-cloud/global/images/family/debian-13";
    // diskSizeGb: storage size of the boot disk to attach to the instance.
    long diskSizeGb = 10L;
    // networkName: network interface to associate with the instance.
    String networkName = "default";
    // Minimum CPU platform of the instances.
    String minCpuPlatform = "Intel Skylake";

    createInstanceAsync(projectId, zone, instanceName, machineTypeName, sourceImage,
        diskSizeGb, networkName, minCpuPlatform);
  }

  // Create a virtual machine targeted with the reserveAffinity field.
  // In this consumption model, existing and new VMs automatically consume a reservation
  // if their properties match the VM properties specified in the reservation.
  public static Instance createInstanceAsync(String projectId, String zone,
      String instanceName, String machineTypeName, String sourceImage,
      long diskSizeGb, String networkName, String minCpuPlatform)
      throws IOException, InterruptedException, ExecutionException, TimeoutException {
    String machineType = String.format("zones/%s/machineTypes/%s", zone, machineTypeName);
    // Initialize client that will be used to send requests. This client only needs to be created
    // once, and can be reused for multiple requests.
    try (InstancesClient instancesClient = InstancesClient.create()) {
      AttachedDisk disk =
          AttachedDisk.newBuilder()
              .setBoot(true)
              .setAutoDelete(true)
              .setType(AttachedDisk.Type.PERSISTENT.toString())
              .setDeviceName("disk-1")
              .setInitializeParams(
                  AttachedDiskInitializeParams.newBuilder()
                      .setSourceImage(sourceImage)
                      .setDiskSizeGb(diskSizeGb)
                      .build())
              .build();

      NetworkInterface networkInterface = NetworkInterface.newBuilder()
          .setName(networkName)
          .build();

      ReservationAffinity reservationAffinity =
          ReservationAffinity.newBuilder()
              .setConsumeReservationType(ANY_RESERVATION.toString())
              .build();

      Instance instanceResource =
          Instance.newBuilder()
              .setName(instanceName)
              .setMachineType(machineType)
              .addDisks(disk)
              .addNetworkInterfaces(networkInterface)
              .setMinCpuPlatform(minCpuPlatform)
              .setReservationAffinity(reservationAffinity)
              .build();

      InsertInstanceRequest insertInstanceRequest = InsertInstanceRequest.newBuilder()
          .setProject(projectId)
          .setZone(zone)
          .setInstanceResource(instanceResource)
          .build();

      OperationFuture<Operation, Operation> operation = instancesClient.insertAsync(
          insertInstanceRequest);

      Operation response = operation.get(3, TimeUnit.MINUTES);

      if (response.hasError()) {
        return null;
      }
      return instancesClient.get(projectId, zone, instanceName);
    }
  }
}

Node.js

以下範例說明如何建立 N1 執行個體，並在可用區 us-central1-a 中使用四個 vCPU 和 Intel Skylake 做為最低 CPU 平台。執行個體會自動耗用相符的預留項目。

如要建立範例執行個體，請使用下列程式碼範例：

// Import the Compute library
const computeLib = require('@google-cloud/compute');
const compute = computeLib.protos.google.cloud.compute.v1;

// Instantiate a reservationsClient
const instancesClient = new computeLib.InstancesClient();
// Instantiate a zoneOperationsClient
const zoneOperationsClient = new computeLib.ZoneOperationsClient();

/**
 * TODO(developer): Update/uncomment these variables before running the sample.
 */
// The ID of the project where you want to create instance.
const projectId = await instancesClient.getProjectId();
// The zone in which to create instance.
const zone = 'us-central1-a';
// The name of the instance to create.
// const instanceName = 'instance-01';
// Machine type to use for VM.
const machineType = 'n1-standard-4';

// Create instance to consume reservation if their properties match the VM properties
async function callCreateInstanceToConsumeAnyReservation() {
  // Describe the size and source image of the boot disk to attach to the instance.
  const disk = new compute.Disk({
    boot: true,
    autoDelete: true,
    type: 'PERSISTENT',
    initializeParams: {
      diskSizeGb: '10',
      sourceImage: 'projects/debian-cloud/global/images/family/debian-12',
    },
  });

  //  Define networkInterface
  const networkInterface = new compute.NetworkInterface({
    name: 'global/networks/default',
  });

  // Define reservationAffinity
  const reservationAffinity = new compute.ReservationAffinity({
    consumeReservationType: 'ANY_RESERVATION',
  });

  // Create an instance
  const instance = new compute.Instance({
    name: instanceName,
    machineType: `zones/${zone}/machineTypes/${machineType}`,
    minCpuPlatform: 'Intel Skylake',
    disks: [disk],
    networkInterfaces: [networkInterface],
    reservationAffinity,
  });

  const [response] = await instancesClient.insert({
    project: projectId,
    instanceResource: instance,
    zone,
  });

  let operation = response.latestResponse;

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

  console.log(`Instance ${instanceName} created.`);
}

await callCreateInstanceToConsumeAnyReservation();

Python

以下範例說明如何在可用區 us-central1-a 中建立自動預留項目，用於三個 N1 執行個體，每個執行個體有一個 vCPU，並以 Intel Ivy 做為最低 CPU 平台。以及如何建立單一執行個體來使用預留項目。

如要建立範例自動預留項目並使用，請按照下列步驟操作：

from __future__ import annotations

import sys
from typing import Any

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


def consume_any_project_reservation(
    project_id: str,
    zone: str,
    reservation_name: str,
    instance_name: str,
    machine_type: str = "n1-standard-1",
    min_cpu_platform: str = "Intel Ivy Bridge",
) -> compute_v1.Instance:
    """
    Creates a specific reservation in a single project and launches a VM
    that consumes the newly created reservation.
    Args:
        project_id (str): The ID of the Google Cloud project.
        zone (str): The zone to create the reservation.
        reservation_name (str): The name of the reservation to create.
        instance_name (str): The name of the instance to create.
        machine_type (str): The machine type for the instance.
        min_cpu_platform (str): The minimum CPU platform for the instance.
    """
    instance_properties = (
        compute_v1.AllocationSpecificSKUAllocationReservedInstanceProperties(
            machine_type=machine_type,
            min_cpu_platform=min_cpu_platform,
        )
    )

    reservation = compute_v1.Reservation(
        name=reservation_name,
        specific_reservation=compute_v1.AllocationSpecificSKUReservation(
            count=3,
            instance_properties=instance_properties,
        ),
    )

    # Create a reservation client
    client = compute_v1.ReservationsClient()
    operation = client.insert(
        project=project_id,
        zone=zone,
        reservation_resource=reservation,
    )
    wait_for_extended_operation(operation, "Reservation creation")

    instance = compute_v1.Instance()
    instance.name = instance_name
    instance.machine_type = f"zones/{zone}/machineTypes/{machine_type}"
    instance.min_cpu_platform = min_cpu_platform
    instance.zone = zone

    # Set the reservation affinity to target any matching reservation
    instance.reservation_affinity = compute_v1.ReservationAffinity(
        consume_reservation_type="ANY_RESERVATION",  # Type of reservation to consume
    )
    # Define the disks for the instance
    instance.disks = [
        compute_v1.AttachedDisk(
            boot=True,  # Indicates that this is a boot disk
            auto_delete=True,  # The disk will be deleted when the instance is deleted
            initialize_params=compute_v1.AttachedDiskInitializeParams(
                source_image="projects/debian-cloud/global/images/family/debian-13",
                disk_size_gb=10,
            ),
        )
    ]
    instance.network_interfaces = [
        compute_v1.NetworkInterface(
            network="global/networks/default",  # The network to use
            access_configs=[
                compute_v1.AccessConfig(
                    name="External NAT",  # Name of the access configuration
                    type="ONE_TO_ONE_NAT",  # Type of access configuration
                )
            ],
        )
    ]
    # Create a request to insert the instance
    request = compute_v1.InsertInstanceRequest()
    request.zone = zone
    request.project = project_id
    request.instance_resource = instance

    vm_client = compute_v1.InstancesClient()
    operation = vm_client.insert(request)
    wait_for_extended_operation(operation, "instance creation")
    print(f"Instance {instance_name} that targets any open reservation created.")

    return vm_client.get(project=project_id, zone=zone, instance=instance_name)

REST

以下範例說明如何在區域 us-central1-a 中，為三個具有 32 個 vCPU 的 N2 執行個體建立自動預留項目，並將 Intel Cascade Lake 設為最低 CPU 平台。此外，也會說明如何建立單一執行個體來使用預留項目。

如要建立範例自動預留項目並使用，請按照下列步驟操作：

  1. 如要建立範例預留項目，請向 reservations.insert 方法發出 POST 要求：

    POST https://compute.googleapis.com/compute/v1/projects/example-project/zones/us-central1-a/reservations

{
  "name": "reservation-01",
  "specificReservation": {
    "count": "3",
    "instanceProperties": {
      "machineType": "n2-standard-32",
      "minCpuPlatform": "Intel Cascade Lake",
    }
  }
}

  2. 如要建立使用範例預留項目的執行個體，請向 instances.insert 方法發出 POST 要求。在要求主體中，加入設為 ANY_RESERVATION 的 consumeReservationType 欄位。不過，由於 ANY_RESERVATION 是預設設定，您也可以省略這個欄位。

    POST https://compute.googleapis.com/compute/v1/projects/example-project/zones/us-central1-a/instances

{
  "name": "instance-01",
  "machineType": "zones/us-central1-a/machineTypes/n2-standard-32",
  "minCpuPlatform": "Intel Cascade Lake",
  "disks": [
    {
      "boot": true,
      "initializeParams": {
        "sourceImage": "projects/debian-cloud/global/images/family/debian-12"
      }
    }
  ],
  "networkInterfaces": [
    {
      "network": "global/networks/default"
    }
  ],
  "reservationAffinity": {
    "consumeReservationType": "ANY_RESERVATION"
  }
}

使用明確指定的預留項目

明確指定的預留項目允許符合預留項目屬性，且指定預留項目的新運算執行個體耗用該項目。只有在屬性與預留項目屬性相符時，才能成功建立運算執行個體。否則建立要求會失敗。

根據您要使用的建立方法，建立特定預留項目和指定這些預留項目的運算執行個體，如下所示：

建立方式 建立預留項目時 建立要使用預留項目的運算執行個體時
Google Cloud 控制台 在「Use with VM instance」(用於 VM 執行個體) 區段中，選取「Select specific reservation」(選取特定預留項目)。 在「Advanced」(進階) 窗格的「Reservations」(預留項目) 部分，選取「Choose a reservation」(選取預留項目)。然後按照提示選取預留項目。
Google Cloud CLI 加上 --require-specific-reservation 旗標。 加入下列旗標：
  • --reservation-affinity 旗標設為 specific。
  • --reservation 旗標設為預留項目的資源路徑，格式為 projects/OWNER_PROJECT_ID/reservations/RESERVATION_NAME。
Go 加入設為 true 的 SpecificReservationRequired 欄位。 在 ReservationAffinity 欄位中，加入下列欄位：
  • ConsumeReservationType 欄位設為 SPECIFIC_RESERVATION。
  • Key 欄位設為 compute.googleapis.com/reservation-name。
  • Values 欄位設為預訂資源路徑，格式為 projects/OWNER_PROJECT_ID/reservations/RESERVATION_NAME。
Java 加入設為 true 的 setSpecificReservationRequired 欄位。 在 ReservationAffinity 欄位中，加入下列欄位：
  • setConsumeReservationType 欄位設為 SPECIFIC_RESERVATION。
  • setKey 欄位設為 compute.googleapis.com/reservation-name。
  • addValues 欄位設為預訂資源路徑，格式為 projects/OWNER_PROJECT_ID/reservations/RESERVATION_NAME。
Node.js 和 REST API 加入設為 true 的 specificReservationRequired 欄位。 在 reservationAffinity 欄位中，加入下列欄位：
  • consumeReservationType 欄位設為 SPECIFIC_RESERVATION。
  • key 欄位設為 compute.googleapis.com/reservation-name。
  • values 欄位設為包含單一項目的清單，其中包含預留項目的資源路徑，格式為 projects/OWNER_PROJECT_ID/reservations/RESERVATION_NAME。
Python 加入設為 true 的 specific_reservation_required 欄位。 在 reservation_affinity 欄位中，加入下列欄位：
  • consume_reservation_type 欄位設為 SPECIFIC_RESERVATION。
  • key 欄位設為 compute.googleapis.com/reservation-name。
  • values 欄位設為預留項目的資源路徑，格式為 projects/OWNER_PROJECT_ID/reservations/RESERVATION_NAME。
Terraform 加入設為 true 的 specific_reservation_required 欄位。 在 reservation_affinity 欄位中，加入下列欄位：
  • type 欄位設為 SPECIFIC_RESERVATION。
  • specific_reservation 欄位，包含下列欄位：
    • key 欄位設為 compute.googleapis.com/reservation-name。
    • values 欄位設為包含單一項目的清單，其中包含預留項目的資源路徑，格式為 projects/OWNER_PROJECT_ID/reservations/RESERVATION_NAME。

如要建立範例特定預留項目和運算執行個體來耗用該項目，請選取下列其中一個選項：

控制台

以下範例說明如何在可用區 us-central1-a 中，為三個具有 32 個 vCPU 的 N2 執行個體建立特定預留項目，並將 Intel Cascade Lake 設為最低 CPU 平台。以及如何建立單一運算執行個體來使用預留項目。

如要建立並使用範例特定預留項目，請按照下列步驟操作：

  1. 如要建立範例預留項目，請完成下列步驟：

    1. 前往 Google Cloud 控制台的「Reservations」(預留項目) 頁面。

      前往「Reservations」(預留項目) 頁面

      其餘步驟會自動顯示在Google Cloud 控制台。

    2. 在「隨需預留項目」分頁 (預設)，按一下 「建立預留項目」。 「Create a reservation」(建立預留項目) 頁面隨即顯示。

    3. 在「Name」(名稱) 欄位，輸入預留項目的名稱，例如：reservation-02。

    4. 指定要預留資源的「Region」(區域) 和「Zone」(可用區)。在本範例中，請分別選取「us-central1」和「us-central1-a」。

    5. 在「分享類型」部分，執行下列其中一項操作：

      • 如要建立單一專案預留項目，請選取「本機」。

      • 如要建立共用預留項目，請選取「Shared」(共用)，然後指定要共用預留項目的專案。

    6. 在「Use with VM instance」(用於 VM 執行個體) 區段中，選取「Select specific reservation」(選取特定預留項目)。

    7. 在「Number of VM instances」(VM 執行個體數量) 欄位，輸入 3。

    8. 在「一般用途」分頁中，選取「N2」。

    9. 在「Machine type」(機型) 區段的「Preset」(預設) 分頁 (預設) 中，選取「n2-standard-32」。

    10. 展開「CPU platform and GPU」(CPU 平台和 GPU)，然後在「CPU platform」(CPU 平台) 欄位中選取「Intel Cascade Lake or later」(Intel Cascade Lake 以上版本)。

    11. 點選「建立」。

  2. 如要建立使用範例預留項目的運算執行個體，請完成下列步驟：

    1. 前往 Google Cloud 控制台的「Create an instance」(建立執行個體) 頁面。

      前往「Create an instance」(建立執行個體)

      「建立執行個體」頁面隨即顯示，並顯示「機器設定」窗格。

    2. 在「機器設定」窗格中，執行下列操作：

      1. 在「Name」(名稱) 欄位中，輸入運算執行個體的名稱。在本例中，請輸入 instance-02。

      2. 指定要預留資源的「Region」(區域) 和「Zone」(可用區)。在本範例中，請分別選取「us-central1」和「us-central1-a」。

      3. 在「一般用途」分頁中，選取「N2」。

      4. 在「機型」部分，選取「預設」分頁 (預設)，然後選取「n2-standard-32」。

      5. 展開「Advanced options」(進階選項) 區段，然後在「CPU platform」(CPU 平台) 欄位中選取「Intel Cascade Lake or later」(Intel Cascade Lake 以上版本)。

    3. 在導覽選單中，按一下「進階」。系統會顯示「Advanced」(進階) 窗格。

    4. 在「Reservations」(預留項目) 部分，選取「Choose a reservation」(選取預留項目)，然後點選「Choose reservation」(選取預留項目)。

    5. 在隨即顯示的「Choose a reservation」(選擇預留項目) 窗格中，執行下列操作：

      1. 選取您在前述步驟中建立的特定預留項目。如要使用其他專案中的共用預留項目，請在「Project」(專案) 清單中選取預留項目所在的專案。

      2. 按一下「選擇」。

    6. 點選「建立」。

gcloud

以下範例說明如何在可用區 us-central1-a 中，為三個 N2 執行個體建立特定預留項目，這些執行個體有 32 個 vCPU，且最低 CPU 平台為 Intel Cascade Lake。此外，也說明如何建立單一運算執行個體來使用預留項目。

如要建立並使用範例特定預留項目，請按照下列步驟操作：

  1. 如要建立範例預留項目，請使用 gcloud compute reservations create 指令和 --require-specific-reservation 旗標：

    gcloud compute reservations create reservation-02 \
    --machine-type=n2-standard-32 \
    --min-cpu-platform="Intel Cascade Lake" \
    --require-specific-reservation \
    --vm-count=3 \
    --zone=us-central1-a

  2. 如要建立使用範例預留項目的運算執行個體，請使用 gcloud compute instances create 指令，並加上 --reservation 和 --reservation-affinity=specific 旗標：

    gcloud compute instances create instance-02 \
    --machine-type=n2-standard-32 \
    --min-cpu-platform="Intel Cascade Lake" \
    --reservation-affinity=specific \
    --reservation=RESERVATION_URL \
    --zone=us-central1-a

    將 RESERVATION_URL 替換為預留項目的網址。請指定下列其中一個值：

    • 如果您在同一個專案中建立預留項目： reservation-02

    • 如果預留項目位於其他專案： projects/PROJECT_ID/reservations/reservation-02

Go

下列範例說明如何在可用區 us-central1-a 建立 N2 執行個體，並指定 32 個 vCPU 和 Intel Cascade Lake 做為最低 CPU 平台，以使用特定相符預留項目：

  • 如要建立範例運算執行個體，以使用單一專案的特定預留項目，請使用下列程式碼範例：

    import (
	"context"
	"fmt"
	"io"

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

// consumeSpecificReservation creates instance, consuming specific reservation
// Note: respective reservation should have SpecificReservationRequired: true
func consumeSpecificReservation(w io.Writer, projectID, zone, instanceName, reservationName string) error {
	// projectID := "your_project_id"
	// zone := "us-west3-a"
	// reservationName := "your_reservation_name"
	// instanceName := "your_instance_name"

	ctx := context.Background()
	machineType := fmt.Sprintf("zones/%s/machineTypes/%s", zone, "n2-standard-32")
	sourceImage := "projects/debian-cloud/global/images/family/debian-12"

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

	req := &computepb.InsertInstanceRequest{
		Project: projectID,
		Zone:    zone,
		InstanceResource: &computepb.Instance{
			Disks: []*computepb.AttachedDisk{
				{
					InitializeParams: &computepb.AttachedDiskInitializeParams{
						DiskSizeGb:  proto.Int64(10),
						SourceImage: proto.String(sourceImage),
					},
					AutoDelete: proto.Bool(true),
					Boot:       proto.Bool(true),
					Type:       proto.String(computepb.AttachedDisk_PERSISTENT.String()),
				},
			},
			MachineType:    proto.String(machineType),
			MinCpuPlatform: proto.String("Intel Cascade Lake"),
			Name:           proto.String(instanceName),
			NetworkInterfaces: []*computepb.NetworkInterface{
				{
					Network: proto.String("global/networks/default"),
				},
			},
			// specifies particular reservation, which should be consumed
			ReservationAffinity: &computepb.ReservationAffinity{
				ConsumeReservationType: proto.String("SPECIFIC_RESERVATION"),
				Key:                    proto.String("compute.googleapis.com/reservation-name"),
				Values:                 []string{reservationName},
			},
		},
	}

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

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

	return nil
}

  • 如要建立範例運算執行個體，以使用共用的特定預留項目，請使用下列程式碼範例：

    import (
	"context"
	"fmt"
	"io"

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

// consumeSpecificSharedReservation consumes specific shared reservation in particular zone
func consumeSpecificSharedReservation(w io.Writer, client InstanceClientInterface, projectID, baseProjectId, zone, instanceName, reservationName string) error {
	// client, err := compute.NewInstancesRESTClient(ctx)
	// projectID := "your_project_id". Project where reservation is created.
	// baseProjectId := "shared_project_id". Project where instance will be consumed and created.
	// zone := "us-west3-a"
	// reservationName := "your_reservation_name"
	// instanceName := "your_instance_name"

	ctx := context.Background()
	machineType := fmt.Sprintf("zones/%s/machineTypes/%s", zone, "n2-standard-32")
	sourceImage := "projects/debian-cloud/global/images/family/debian-12"
	sharedReservation := fmt.Sprintf("projects/%s/reservations/%s", baseProjectId, reservationName)

	req := &computepb.InsertInstanceRequest{
		Project: projectID,
		Zone:    zone,
		InstanceResource: &computepb.Instance{
			Disks: []*computepb.AttachedDisk{
				{
					InitializeParams: &computepb.AttachedDiskInitializeParams{
						DiskSizeGb:  proto.Int64(10),
						SourceImage: proto.String(sourceImage),
					},
					AutoDelete: proto.Bool(true),
					Boot:       proto.Bool(true),
					Type:       proto.String(computepb.AttachedDisk_PERSISTENT.String()),
				},
			},
			MachineType:    proto.String(machineType),
			MinCpuPlatform: proto.String("Intel Cascade Lake"),
			Name:           proto.String(instanceName),
			NetworkInterfaces: []*computepb.NetworkInterface{
				{
					Network: proto.String("global/networks/default"),
				},
			},
			// specifies particular reservation, which should be consumed
			ReservationAffinity: &computepb.ReservationAffinity{
				ConsumeReservationType: proto.String("SPECIFIC_RESERVATION"),
				Key:                    proto.String("compute.googleapis.com/reservation-name"),
				Values:                 []string{sharedReservation},
			},
		},
	}

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

	if op != nil {
		if err = op.Wait(ctx); err != nil {
			return fmt.Errorf("unable to wait for the operation: %w", err)
		}
	}
	fmt.Fprintf(w, "Instance created from shared reservation\n")

	return nil
}

Java

以下範例說明如何在 us-central1-a 區域中建立 N1 執行個體，並使用四個虛擬 CPU 和 Intel Skylake 做為最低 CPU 平台，以使用相符的特定預訂：

  • 如要建立範例預留項目做為單一專案預留項目，並建立運算執行個體來使用該項目，請使用下列程式碼範例：

    import static com.google.cloud.compute.v1.ReservationAffinity.ConsumeReservationType.SPECIFIC_RESERVATION;

import com.google.api.gax.longrunning.OperationFuture;
import com.google.cloud.compute.v1.AttachedDisk;
import com.google.cloud.compute.v1.AttachedDiskInitializeParams;
import com.google.cloud.compute.v1.InsertInstanceRequest;
import com.google.cloud.compute.v1.Instance;
import com.google.cloud.compute.v1.InstancesClient;
import com.google.cloud.compute.v1.NetworkInterface;
import com.google.cloud.compute.v1.Operation;
import com.google.cloud.compute.v1.ReservationAffinity;
import java.io.IOException;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.TimeoutException;

public class ConsumeSingleProjectReservation {
  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 want to use.
    String projectId = "YOUR_PROJECT_ID";
    // Name of the zone where the reservation is located.
    String zone = "us-central1-a";
    // Name of the reservation you want to query.
    String reservationName = "YOUR_RESERVATION_NAME";
    // Name of the VM instance you want to query.
    String instanceName = "YOUR_INSTANCE_NAME";
    // machineType: machine type of the VM being created.
    // *   For a list of machine types, see https://cloud.google.com/compute/docs/machine-types
    String machineTypeName = "n1-standard-4";
    // sourceImage: path to the operating system image to mount.
    // *   For details about images you can mount, see https://cloud.google.com/compute/docs/images
    String sourceImage = "projects/debian-cloud/global/images/family/debian-13";
    // diskSizeGb: storage size of the boot disk to attach to the instance.
    long diskSizeGb = 10L;
    // networkName: network interface to associate with the instance.
    String networkName = "default";
    // Minimum CPU platform of the instances.
    String minCpuPlatform = "Intel Skylake";

    createInstanceAsync(projectId, zone, instanceName, reservationName, machineTypeName,
        sourceImage, diskSizeGb, networkName, minCpuPlatform);
  }

  // Create a virtual machine targeted with the reserveAffinity field.
  // Ensure that the VM's properties match the reservation's VM properties.
  public static Instance createInstanceAsync(String projectId, String zone, String instanceName,
      String reservationName, String machineTypeName, String sourceImage, long diskSizeGb,
      String networkName, String minCpuPlatform)
      throws IOException, InterruptedException, ExecutionException, TimeoutException {
    String machineType = String.format("zones/%s/machineTypes/%s", zone, machineTypeName);
    // Initialize client that will be used to send requests. This client only needs to be created
    // once, and can be reused for multiple requests.
    try (InstancesClient instancesClient = InstancesClient.create()) {
      AttachedDisk disk =
          AttachedDisk.newBuilder()
              .setBoot(true)
              .setAutoDelete(true)
              .setType(AttachedDisk.Type.PERSISTENT.toString())
              .setDeviceName("disk-1")
              .setInitializeParams(
                  AttachedDiskInitializeParams.newBuilder()
                      .setSourceImage(sourceImage)
                      .setDiskSizeGb(diskSizeGb)
                      .build())
              .build();

      NetworkInterface networkInterface = NetworkInterface.newBuilder()
          .setName(networkName)
          .build();

      ReservationAffinity reservationAffinity =
          ReservationAffinity.newBuilder()
              .setConsumeReservationType(SPECIFIC_RESERVATION.toString())
              .setKey("compute.googleapis.com/reservation-name")
              // Set specific reservation
              .addValues(reservationName)
              .build();

      Instance instanceResource =
          Instance.newBuilder()
              .setName(instanceName)
              .setMachineType(machineType)
              .addDisks(disk)
              .addNetworkInterfaces(networkInterface)
              .setMinCpuPlatform(minCpuPlatform)
              .setReservationAffinity(reservationAffinity)
              .build();

      InsertInstanceRequest insertInstanceRequest = InsertInstanceRequest.newBuilder()
          .setProject(projectId)
          .setZone(zone)
          .setInstanceResource(instanceResource)
          .build();

      OperationFuture<Operation, Operation> operation = instancesClient.insertAsync(
          insertInstanceRequest);
      Operation response = operation.get(3, TimeUnit.MINUTES);

      if (response.hasError()) {
        return null;
      }
      return instancesClient.get(projectId, zone, instanceName);
    }
  }
}

  • 如要建立範例預留項目做為共用預留項目，並建立運算執行個體來使用該預留項目，請使用下列程式碼範例：

    import static com.google.cloud.compute.v1.ReservationAffinity.ConsumeReservationType.SPECIFIC_RESERVATION;

import com.google.api.gax.longrunning.OperationFuture;
import com.google.cloud.compute.v1.AttachedDisk;
import com.google.cloud.compute.v1.AttachedDiskInitializeParams;
import com.google.cloud.compute.v1.InsertInstanceRequest;
import com.google.cloud.compute.v1.Instance;
import com.google.cloud.compute.v1.InstancesClient;
import com.google.cloud.compute.v1.NetworkInterface;
import com.google.cloud.compute.v1.Operation;
import com.google.cloud.compute.v1.ReservationAffinity;
import java.io.IOException;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.TimeoutException;

public class ConsumeSpecificSharedReservation {
  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 want to use.
    String projectId = "YOUR_PROJECT_ID";
    // Name of the zone the reservation is located.
    String zone = "us-central1-a";
    // Name of the reservation you want to query.
    String reservationName = "YOUR_RESERVATION_NAME";
    // Name of the VM instance you want to query.
    String instanceName = "YOUR_INSTANCE_NAME";
    // machineType: machine type of the VM being created.
    // *   For a list of machine types, see https://cloud.google.com/compute/docs/machine-types
    String machineTypeName = "n1-standard-4";
    // sourceImage: path to the operating system image to mount.
    // *   For details about images you can mount, see https://cloud.google.com/compute/docs/images
    String sourceImage = "projects/debian-cloud/global/images/family/debian-13";
    // diskSizeGb: storage size of the boot disk to attach to the instance.
    long diskSizeGb = 10L;
    // networkName: network interface to associate with the instance.
    String networkName = "default";
    // Minimum CPU platform of the instances.
    String minCpuPlatform = "Intel Skylake";

    createInstanceAsync(projectId, zone, instanceName, reservationName, machineTypeName,
        sourceImage, diskSizeGb, networkName, minCpuPlatform);
  }

  // Create a virtual machine targeted with the reserveAffinity field.
  // Ensure that the VM's properties match the reservation's VM properties.
  public static Instance createInstanceAsync(String projectId, String zone, String instanceName,
      String reservationName, String machineTypeName, String sourceImage, long diskSizeGb,
      String networkName, String minCpuPlatform)
      throws IOException, InterruptedException, ExecutionException, TimeoutException {
    String machineType = String.format("zones/%s/machineTypes/%s", zone, machineTypeName);
    // To consume this reservation from any consumer projects that this reservation is shared with,
    // you must also specify the owner project of the reservation - the path to the reservation.
    String reservationPath =
        String.format("projects/%s/reservations/%s", projectId, reservationName);
    // Initialize client that will be used to send requests. This client only needs to be created
    // once, and can be reused for multiple requests.
    try (InstancesClient instancesClient = InstancesClient.create()) {
      AttachedDisk disk =
          AttachedDisk.newBuilder()
              .setBoot(true)
              .setAutoDelete(true)
              .setType(AttachedDisk.Type.PERSISTENT.toString())
              .setDeviceName("disk-1")
              .setInitializeParams(
                  AttachedDiskInitializeParams.newBuilder()
                      .setSourceImage(sourceImage)
                      .setDiskSizeGb(diskSizeGb)
                      .build())
              .build();

      NetworkInterface networkInterface = NetworkInterface.newBuilder()
          .setName(networkName)
          .build();

      ReservationAffinity reservationAffinity =
          ReservationAffinity.newBuilder()
              .setConsumeReservationType(SPECIFIC_RESERVATION.toString())
              .setKey("compute.googleapis.com/reservation-name")
              // Set specific reservation
              .addValues(reservationPath)
              .build();

      Instance instanceResource =
          Instance.newBuilder()
              .setName(instanceName)
              .setMachineType(machineType)
              .addDisks(disk)
              .addNetworkInterfaces(networkInterface)
              .setMinCpuPlatform(minCpuPlatform)
              .setReservationAffinity(reservationAffinity)
              .build();

      InsertInstanceRequest insertInstanceRequest = InsertInstanceRequest.newBuilder()
          .setProject(projectId)
          .setZone(zone)
          .setInstanceResource(instanceResource)
          .build();

      OperationFuture<Operation, Operation> operation = instancesClient.insertAsync(
          insertInstanceRequest);
      Operation response = operation.get(3, TimeUnit.MINUTES);

      if (response.hasError()) {
        return null;
      }
      return instancesClient.get(projectId, zone, instanceName);
    }
  }
}

Node.js

以下範例說明如何在 us-central1-a 地區建立具有 4 個虛擬 CPU 的 N1 執行個體，並將 Intel Skylake 設為最低 CPU 平台，以使用相符的特定預訂：

// Import the Compute library
const computeLib = require('@google-cloud/compute');
const compute = computeLib.protos.google.cloud.compute.v1;

// Instantiate a reservationsClient
const instancesClient = new computeLib.InstancesClient();
// Instantiate a zoneOperationsClient
const zoneOperationsClient = new computeLib.ZoneOperationsClient();

/**
 * TODO(developer): Update/uncomment these variables before running the sample.
 */
// The ID of the project where you want to create instance.
const projectId = await instancesClient.getProjectId();
// The zone in which to create instance.
const zone = 'us-central1-a';
// The name of the instance to create.
// const instanceName = 'instance-01';
// The name of the reservation to consume.
// Ensure that the specificReservationRequired field in reservation properties is set to true.
// const reservationName = 'reservation-01';
// Machine type to use for VM.
const machineType = 'n1-standard-4';

// Create instance to consume a specific single-project reservation
async function callCreateInstanceToConsumeSingleProjectReservation() {
  // Describe the size and source image of the boot disk to attach to the instance.
  // Ensure that the VM's properties match the reservation's VM properties,
  // including the zone, machine type (machine family, vCPUs, and memory),
  // minimum CPU platform, GPU amount and type, and local SSD interface and size
  const disk = new compute.Disk({
    boot: true,
    autoDelete: true,
    type: 'PERSISTENT',
    initializeParams: {
      diskSizeGb: '10',
      sourceImage: 'projects/debian-cloud/global/images/family/debian-12',
    },
  });

  //  Define networkInterface
  const networkInterface = new compute.NetworkInterface({
    name: 'global/networks/default',
  });

  // Define reservationAffinity
  const reservationAffinity = new compute.ReservationAffinity({
    consumeReservationType: 'SPECIFIC_RESERVATION',
    key: 'compute.googleapis.com/reservation-name',
    values: [reservationName],
  });

  // Create an instance
  const instance = new compute.Instance({
    name: instanceName,
    machineType: `zones/${zone}/machineTypes/${machineType}`,
    minCpuPlatform: 'Intel Skylake',
    disks: [disk],
    networkInterfaces: [networkInterface],
    reservationAffinity,
  });

  const [response] = await instancesClient.insert({
    project: projectId,
    instanceResource: instance,
    zone,
  });

  let operation = response.latestResponse;

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

  console.log(`Instance ${instanceName} created.`);
}

await callCreateInstanceToConsumeSingleProjectReservation();

Python

下列範例說明如何在區域 us-central1-a 中建立 N2 執行個體，並將 Intel Cascade Lake 設為最低 CPU 平台，以使用相符的特定預留項目：

如要建立並使用範例專屬預留項目，請按照下列步驟操作：

  • 如要建立並使用範例預留項目做為單一專案預留項目，請使用下列程式碼範例：

    from __future__ import annotations

import sys
from typing import Any

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


def consume_specific_single_project_reservation(
    project_id: str,
    zone: str,
    reservation_name: str,
    instance_name: str,
    machine_type: str = "n1-standard-1",
    min_cpu_platform: str = "Intel Ivy Bridge",
) -> compute_v1.Instance:
    """
    Creates a specific reservation in a single project and launches a VM
    that consumes the newly created reservation.
    Args:
        project_id (str): The ID of the Google Cloud project.
        zone (str): The zone to create the reservation.
        reservation_name (str): The name of the reservation to create.
        instance_name (str): The name of the instance to create.
        machine_type (str): The machine type for the instance.
        min_cpu_platform (str): The minimum CPU platform for the instance.
    """
    instance_properties = (
        compute_v1.AllocationSpecificSKUAllocationReservedInstanceProperties(
            machine_type=machine_type,
            min_cpu_platform=min_cpu_platform,
        )
    )

    reservation = compute_v1.Reservation(
        name=reservation_name,
        specific_reservation=compute_v1.AllocationSpecificSKUReservation(
            count=3,
            instance_properties=instance_properties,
        ),
        # Only VMs that target the reservation by name can consume from this reservation
        specific_reservation_required=True,
    )

    # Create a reservation client
    client = compute_v1.ReservationsClient()
    operation = client.insert(
        project=project_id,
        zone=zone,
        reservation_resource=reservation,
    )
    wait_for_extended_operation(operation, "Reservation creation")

    instance = compute_v1.Instance()
    instance.name = instance_name
    instance.machine_type = f"zones/{zone}/machineTypes/{machine_type}"
    instance.min_cpu_platform = min_cpu_platform
    instance.zone = zone

    # Set the reservation affinity to target the specific reservation
    instance.reservation_affinity = compute_v1.ReservationAffinity(
        consume_reservation_type="SPECIFIC_RESERVATION",  # Type of reservation to consume
        key="compute.googleapis.com/reservation-name",  # Key for the reservation
        values=[reservation_name],  # Reservation name to consume
    )
    # Define the disks for the instance
    instance.disks = [
        compute_v1.AttachedDisk(
            boot=True,  # Indicates that this is a boot disk
            auto_delete=True,  # The disk will be deleted when the instance is deleted
            initialize_params=compute_v1.AttachedDiskInitializeParams(
                source_image="projects/debian-cloud/global/images/family/debian-13",
                disk_size_gb=10,
            ),
        )
    ]
    instance.network_interfaces = [
        compute_v1.NetworkInterface(
            network="global/networks/default",  # The network to use
            access_configs=[
                compute_v1.AccessConfig(
                    name="External NAT",  # Name of the access configuration
                    type="ONE_TO_ONE_NAT",  # Type of access configuration
                )
            ],
        )
    ]
    # Create a request to insert the instance
    request = compute_v1.InsertInstanceRequest()
    request.zone = zone
    request.project = project_id
    request.instance_resource = instance

    vm_client = compute_v1.InstancesClient()
    operation = vm_client.insert(request)
    wait_for_extended_operation(operation, "instance creation")
    print(f"Instance {instance_name} with specific reservation created successfully.")

    return vm_client.get(project=project_id, zone=zone, instance=instance_name)

  • 如要建立並使用範例預留項目做為共用預留項目，請使用下列程式碼範例：

    from __future__ import annotations

import sys
from typing import Any

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


def consume_specific_shared_project_reservation(
    owner_project_id: str,
    shared_project_id: str,
    zone: str,
    reservation_name: str,
    instance_name: str,
    machine_type: str = "n1-standard-1",
    min_cpu_platform: str = "Intel Ivy Bridge",
) -> compute_v1.Instance:
    """
    Creates a specific reservation in a single project and launches a VM
    that consumes the newly created reservation.
    Args:
        owner_project_id (str): The ID of the Google Cloud project.
        shared_project_id: The ID of the owner project of the reservation in the same zone.
        zone (str): The zone to create the reservation.
        reservation_name (str): The name of the reservation to create.
        instance_name (str): The name of the instance to create.
        machine_type (str): The machine type for the instance.
        min_cpu_platform (str): The minimum CPU platform for the instance.
    """
    instance_properties = (
        compute_v1.AllocationSpecificSKUAllocationReservedInstanceProperties(
            machine_type=machine_type,
            min_cpu_platform=min_cpu_platform,
        )
    )

    reservation = compute_v1.Reservation(
        name=reservation_name,
        specific_reservation=compute_v1.AllocationSpecificSKUReservation(
            count=3,
            instance_properties=instance_properties,
        ),
        # Only VMs that target the reservation by name can consume from this reservation
        specific_reservation_required=True,
        share_settings=compute_v1.ShareSettings(
            share_type="SPECIFIC_PROJECTS",
            project_map={
                shared_project_id: compute_v1.ShareSettingsProjectConfig(
                    project_id=shared_project_id
                )
            },
        ),
    )

    # Create a reservation client
    client = compute_v1.ReservationsClient()
    operation = client.insert(
        project=owner_project_id,
        zone=zone,
        reservation_resource=reservation,
    )
    wait_for_extended_operation(operation, "Reservation creation")

    instance = compute_v1.Instance()
    instance.name = instance_name
    instance.machine_type = f"zones/{zone}/machineTypes/{machine_type}"
    instance.min_cpu_platform = min_cpu_platform
    instance.zone = zone

    # Set the reservation affinity to target the specific reservation
    instance.reservation_affinity = compute_v1.ReservationAffinity(
        consume_reservation_type="SPECIFIC_RESERVATION",  # Type of reservation to consume
        key="compute.googleapis.com/reservation-name",
        # To consume this reservation from any consumer projects, specify the owner project of the reservation
        values=[f"projects/{owner_project_id}/reservations/{reservation_name}"],
    )
    # Define the disks for the instance
    instance.disks = [
        compute_v1.AttachedDisk(
            boot=True,  # Indicates that this is a boot disk
            auto_delete=True,  # The disk will be deleted when the instance is deleted
            initialize_params=compute_v1.AttachedDiskInitializeParams(
                source_image="projects/debian-cloud/global/images/family/debian-13",
                disk_size_gb=10,
            ),
        )
    ]
    instance.network_interfaces = [
        compute_v1.NetworkInterface(
            network="global/networks/default",  # The network to use
            access_configs=[
                compute_v1.AccessConfig(
                    name="External NAT",  # Name of the access configuration
                    type="ONE_TO_ONE_NAT",  # Type of access configuration
                )
            ],
        )
    ]
    # Create a request to insert the instance
    request = compute_v1.InsertInstanceRequest()
    request.zone = zone
    # The instance will be created in the shared project
    request.project = shared_project_id
    request.instance_resource = instance

    vm_client = compute_v1.InstancesClient()
    operation = vm_client.insert(request)
    wait_for_extended_operation(operation, "instance creation")
    print(f"Instance {instance_name} from project {owner_project_id} created.")
    # The instance is created in the shared project, so we return it from there.
    return vm_client.get(project=shared_project_id, zone=zone, instance=instance_name)

REST

以下範例說明如何在可用區 us-central1-a 中，為三個 N2 執行個體建立特定預留項目，這些執行個體有 32 個 vCPU，且最低 CPU 平台為 Intel Cascade Lake。此外，也會說明如何建立單一執行個體來使用預留項目。

如要建立並使用範例專屬預留項目，請按照下列步驟操作：

  1. 如要建立範例預留項目，請向 instances.insert 方法發出 POST 要求。在要求主體中，加入設為 true 的 specificReservationRequired 欄位：

    POST https://compute.googleapis.com/compute/v1/projects/example-project/zones/us-central1-a/reservations

{
  "name": "reservation-02",
  "specificReservation": {
    "count": "3",
    "instanceProperties": {
      "machineType": "n2-standard-32",
      "minCpuPlatform": "Intel Cascade Lake",
    }
  },
  "specificReservationRequired": true
}

  2. 如要建立使用範例預留項目的運算執行個體，請對 instances.insert 方法發出 POST 要求。在要求主體的 reservationAffinity 欄位中，加入下列內容：

    • consumeReservationType 欄位設為 SPECIFIC_RESERVATION。

    • key 欄位設為 compute.googleapis.com/reservation-name。

    • 「values」欄位設為預訂網址。

    要求大致如下：

    POST https://compute.googleapis.com/compute/v1/projects/example-project/zones/us-central1-a/instances

{
  "name": "instance-02",
  "machineType": "zones/us-central1-a/machineTypes/n2-standard-32",
  "minCpuPlatform": "Intel Cascade Lake",
  "disks": [
    {
      "boot": true,
      "initializeParams": {
        "sourceImage": "projects/debian-cloud/global/images/family/debian-12"
      }
    }
  ],
  "networkInterfaces": [
    {
      "network": "global/networks/default"
    }
  ],
  "reservationAffinity": {
    "consumeReservationType": "SPECIFIC_RESERVATION",
    "key": "compute.googleapis.com/reservation-name",
    "values": [
      "RESERVATION_URL"
    ]
  }
}

    將 RESERVATION_URL 替換為預訂的網址。請指定下列其中一個值：

    • 如果您在同一個專案中建立預留項目： reservation-02

    • 如果預留項目位於其他專案： projects/PROJECT_ID/reservations/reservation-02

在日曆模式中，針對要求耗用自動建立的預留項目

這類預留項目可供新的運算執行個體耗用，而 Compute Engine 會自動建立預留項目，以滿足日曆模式中的未來預留項目。

如要使用這類預留項目，您必須按照下列步驟建立運算執行個體：

  • 運算執行個體必須明確指定預留項目。

  • 運算執行個體必須在預留項目結束時間停止或刪除。

  • 運算執行個體必須使用取決於預留項目佈建模式。建立運算執行個體時，您可以按照下列方式指定這個模型：

    • 在 Google Cloud 控制台中，如果您在日曆模式中為未來預留項目指定支援的機器類型，系統會自動選取與預留項目綁定的模型。

    • 在 gcloud CLI 中，加入設為 reservation-bound 的 --provisioning-model 旗標。

    • 在 REST API 中，加入設為 RESERVATION_BOUND 的 provisioningModel 欄位。

以下範例會在日曆模式中，為 A3 Ultra 執行個體建立未來預留項目要求。這個範例也顯示建立獨立 A3 Ultra 執行個體時要指定的欄位，以便使用系統為要求自動建立的預留項目。

如要使用範例自動建立的預留項目，請選取下列其中一個選項：

控制台

  1. 建立五個 A3 Ultra 執行個體的要求範例，並提交審查：

    1. 前往 Google Cloud 控制台的「Reservations」(預留項目) 頁面。

      前往「Reservations」(預留項目) 頁面

    2. 點選「Future reservations」(未來預留項目) 分頁標籤。

    3. 按一下 「Create future reservation」(建立未來預留項目)。「Create a future reservation」(建立未來預留項目) 頁面隨即顯示。

    4. 按一下「GPU」分頁標籤，然後在「GPU type」(GPU 類型) 清單中選取「NVIDIA H200 141GB」。這項操作會指定 A3 Ultra 執行個體。

    5. 在「Total capacity needed」(所需總容量) 欄位中輸入 5。

    6. 在「Reservation period」(預留期間) 部分，指定預留期間的開始時間和時間長度。

    7. 按一下「搜尋容量」，然後在「可用容量」部分，選取其中一部可用機器。

    8. 點選「建立」。

  2. 在要求開始時間，如要建立 A3 Ultra 執行個體來耗用範例自動建立的預留項目，請按照下列步驟操作：

    1. 前往 Google Cloud 控制台的「Create an instance」(建立執行個體) 頁面。

      前往「建立執行個體」

    2. 在「Name」(名稱) 欄位中，輸入運算執行個體的名稱。在本範例中，請輸入 example-instance。

    3. 指定自動建立預留資源的「Region」(區域) 和「Zone」(可用區)。在本例中，請分別選取「us-central1」和「us-central1-b」。

    4. 按一下「GPU」分頁標籤，然後在「GPU type」(GPU 類型) 清單中選取「NVIDIA H200 141GB」。這項動作會指定 A3 Ultra 執行個體，並將佈建模式設為「取決於預留項目」。

    5. 按一下導覽選單中的「進階」。

    6. 在「Reservations」(預留項目) 部分，選取「Choose a reservation」(選取預留項目)，然後點選「Choose a reservation」(選取預留項目)。

    7. 在「選擇預留項目」窗格中，執行下列操作：

      1. 選取自動建立的範例預留項目。

      2. 按一下「選擇」。

    8. 在「Provisioning model」(佈建模式) 部分，展開「VM provisioning model advanced settings」(VM 佈建模式進階設定) 部分。

    9. 在「On VM termination」(在 VM 終止時) 清單中，選取「Stop」(停止) (預設) 或「Delete」(刪除)。

    10. 點選「建立」。

gcloud

  1. 如要建立五個 A3 Ultra VM 的範例要求並提交審查，請使用 gcloud compute future-reservations create 指令：

    gcloud compute future-reservations create example-fr \
    --auto-delete-auto-created-reservations \
    --deployment-type=DENSE \
    --planning-status=SUBMITTED \
    --require-specific-reservation \
    --reservation-mode=CALENDAR \
    --reservation-name=example-reservation \
    --share-setting=local \
    --start-time=2026-03-05T00:00:00Z \
    --end-time=2026-03-19T00:00:00Z \
    --machine-type=a3-ultragpu-8g \
    --total-count=5 \
    --zone=us-central1-b

    假設 Google Cloud 核准要求，且 Compute Engine 自動建立空白預留項目。在要求開始時間 (2026 年 3 月 5 日)，Compute Engine 會增加預留項目中預留的 GPU VM 數量。接著即可使用預留項目。

  2. 在要求開始時間，如要建立 A3 Ultra 執行個體來使用自動建立的範例預留項目，請使用 gcloud compute instances create 指令搭配下列旗標：

    • --instance-termination-action 標記。

    • --provisioning-model 旗標設為 RESERVATION_BOUND。

    • --reservation 標記。

    • --reservation-affinity 旗標設為 specific。

    指令大致如下。如要瞭解建立 A3 Ultra 執行個體的完整規定，請參閱「建立 A3 Ultra 或 A4 執行個體」。

    gcloud compute instance create example-a3ultra-instance  \
    --machine-type=a3-ultragpu-8g \
    --instance-termination-action=TERMINATION_ACTION \
    --provisioning-model=RESERVATION_BOUND \
    --reservation-affinity=specific \
    --reservation=RESERVATION_URL \
    --zone=us-central1-b \
    ...

    指令包含下列值：

    • TERMINATION_ACTION：Compute Engine 是否會在預留期限結束時停止 (STOP) 或刪除 (DELETE) VM。

    • RESERVATION_URL：預訂網址，格式如下：

      • 如果專案中已有自動建立的預留項目： example-reservation。

      • 如果自動建立的預留項目位於其他專案： projects/PROJECT_ID/reservations/example-reservation。

REST

  1. 如要建立五個 A3 Ultra 執行個體的範例要求，並提交審查，請向 futureReservations.insert 方法提出 POST 要求：

    POST https://compute.googleapis.com/compute/v1/projects/example-project/zones/us-central1-b/futureReservations

{
  "name": "example-request-calendar-mode",
  "autoDeleteAutoCreatedReservations": true,
  "deploymentType": "DENSE",
  "planningStatus": "SUBMITTED",
  "reservationMode": "CALENDAR",
  "reservationName": "example-reservation",
  "shareSettings": {
    "shareType": "LOCAL"
  },
  "specificReservationRequired": true,
  "specificSkuProperties": {
    "machineType": "a3-ultragpu-8g",
    "totalCount": 5
  },
  "timeWindow": {
    "startTime": "2026-03-05T00:00:00Z",
    "endTime": "2026-03-19T00:00:00Z"
  }
}

    假設 Google Cloud 核准要求，Compute Engine 會自動建立空白預留項目。在 2026 年 3 月 5 日的請求開始時間，Compute Engine 會增加預留項目中的預留 GPU VM 數量。接著即可使用預留項目。

  2. 在要求開始時間，如要建立 A3 Ultra 執行個體，以使用範例自動建立的預留項目，請向 instances.insert 方法提出 POST 要求。在要求主體中，加入下列欄位：

    • reservationAffinity.consumeReservationType 欄位設為 SPECIFIC_RESERVATION。

    • reservationAffinity.key 欄位設為 compute.googleapis.com/reservation-name。

    • 「reservationAffinity.values」欄位設為預訂的網址。

    • scheduling.instanceTerminationAction 欄位。

    • scheduling.provisioningModel 欄位設為 RESERVATION_BOUND。

    要求大致如下。如要瞭解建立 A3 Ultra 執行個體的完整規定，請參閱「建立 A3 Ultra 或 A4 執行個體」。

    POST https://compute.googleapis.com/compute/v1/projects/example-project/zones/us-central1-b/

{
  {
    "machineType": "projects/example-project/zones/us-central1-b/machineTypes/a3-ultragpu-8g",
    "name": "example-a3ultra-instance",
    "reservationAffinity": {
      "consumeReservationType": "SPECIFIC_RESERVATION",
      "key": "compute.googleapis.com/reservation-name",
      "values":[
        "RESERVATION_URL"
      ],
    },
    "scheduling": {
      "instanceTerminationAction": "TERMINATION_ACTION",
      "provisioningModel": "RESERVATION_BOUND"
    },
    ...
  }
}

    要求主體包含下列值：

    • RESERVATION_URL：預留項目的網址，格式如下：

      • 如果專案中已有自動建立的預留項目： example-reservation。

      • 如果自動建立的預留項目位於其他專案：projects/PROJECT_ID/reservations/example-reservation。

    • TERMINATION_ACTION：預訂期結束時，Compute Engine 是要停止 (STOP) 還是刪除 (DELETE) VM。

測試運算執行個體屬性是否與自動耗用的預留項目相符

與指定目標預留項目不同，如果運算執行個體屬性不符，自動使用的預留項目不會傳回錯誤。而是 Compute Engine 嘗試使用隨選容量建立運算執行個體。啟動工作負載前，如要確認運算執行個體屬性與自動使用的預留項目相符，請針對具有相同屬性的測試專用預留項目測試屬性。

如要測試運算執行個體的屬性是否與自動使用的預訂項目相符，請完成下列步驟：

  1. 建立測試預留項目：建立明確指定的預留項目，其運算執行個體屬性與要測試的自動耗用預留項目相同。將預留運算執行個體數量設為 1。

  2. 建立測試運算執行個體：嘗試指定測試預留項目，建立運算執行個體。這個步驟的結果會是下列其中一項：

    • 如果成功建立運算執行個體，代表運算執行個體和測試預留項目的屬性相符。

    • 如果無法建立運算執行個體並收到錯誤訊息，可能是因為屬性不符。如要排解錯誤，請參閱「排解預留項目消耗問題」。

  3. 清除資源：如果您成功建立運算執行個體，並指定測試預留項目，請刪除測試資源，以免產生不必要的費用：

確認預留項目使用情形

如要確認預留項目使用情形，請採用下列其中一種方法：

後續步驟