为单个项目创建预留


本文档介绍如何创建只能由同一项目中的虚拟机 (VM) 实例使用的单项目预留。如需了解预留,请参阅 Compute Engine 可用区级资源的预留

如需了解创建预留的其他方法,请参阅以下页面:

  • 如果您在当前项目中具有任何 1 年期或 3 年期承诺,则您的预留资源会自动获得任何适用的承诺使用折扣。您还可以在购买承诺时创建预留并将其附加到该承诺。如需了解详情,请参阅将预留附加到承诺

  • 如需创建可供多个项目使用的预留,请参阅创建共享预留

准备工作

  • 查看预留的要求限制
  • 如果您尚未设置身份验证,请进行设置。身份验证是通过其进行身份验证以访问 Google Cloud 服务和 API 的过程。如需从本地开发环境运行代码或示例,您可以选择以下任一选项向 Compute Engine 进行身份验证:

    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
    2. Set a default region and zone.
    3. Terraform

      如需在本地开发环境中使用本页面上的 Terraform 示例,请安装并初始化 gcloud CLI,然后使用您的用户凭据设置应用默认凭据。

      1. Install the Google Cloud CLI.
      2. To initialize the gcloud CLI, run the following command:

        gcloud init
      3. If you're using a local shell, then create local authentication credentials for your user account:

        gcloud auth application-default login

        You don't need to do this if you're using Cloud Shell.

      如需了解详情,请参阅 Set up authentication for a local development environment

      REST

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

        Install the Google Cloud CLI, then initialize it by running the following command:

        gcloud init

      如需了解详情,请参阅 Google Cloud 身份验证文档中的使用 REST 时进行身份验证

所需的角色

如需获得创建单项目预留所需的权限,请让您的管理员向您授予项目的 Compute Admin (roles/compute.admin) IAM 角色。如需详细了解如何授予角色,请参阅管理对项目、文件夹和组织的访问权限

此预定义角色包含创建单项目预留所需的权限。如需查看所需的确切权限,请展开所需权限部分:

所需权限

创建单项目预留需要以下权限:

  • 项目的 compute.reservations.create 权限
  • 如需指定实例模板:实例模板的 compute.instanceTemplates.useReadOnly 权限

您也可以使用自定义角色或其他预定义角色来获取这些权限。

创建单项目预留

如需使用预留,虚拟机必须具有与该预留完全匹配的属性。如需指定要预留的虚拟机的属性,请选择本文档中的以下部分之一:

  • 推荐:指定实例模板

    本部分介绍如何使用实例模板定义预留的属性。通过使用实例模板,您可以在同一位置定义预留的属性和可以使用预留的虚拟机。

  • 指定现有虚拟机

    本部分介绍了如何使用现有虚拟机来定义预留的属性。通过使用现有虚拟机的属性,您可以通过创建其属性与参考虚拟机匹配的虚拟机来使用该预留。

  • 直接指定属性

    本部分介绍如何直接定义预留的属性。此方法要求您手动确保虚拟机和预留的属性完全匹配,任何不匹配的属性都会阻止使用。

默认情况下,具有与预留相匹配的属性的虚拟机可以自动使用该预留。如果您想要控制预留的使用,请执行以下一项或多项操作:

此外,您可以在创建单项目预留时指定紧凑布置政策。紧凑布置政策指定虚拟机尽可能彼此靠近,以缩短网络延迟时间。

指定实例模板

为避免通过指定实例模板创建预留时出错,请确保以下各项:

  • 在实例模板中的资源所在的区域和可用区中创建预留。在实例模板中指定的任何区域级资源可用区级资源(例如机器类型或永久性磁盘卷)会将模板的使用限制在存在这些资源的位置。例如,如果您的实例模板指定了可用区 us-central1-a 中的现有 Persistent Disk 卷,则您只能在同一可用区中创建预留。如需检查现有模板是否指定了任何将模板绑定到特定区域或可用区的资源,请查看实例模板的详细信息,并查找对其中的区域级资源或可用区级资源的引用。

  • 如果实例模板指定了紧凑布置政策,请确保该模板还指定紧凑布置政策支持的机器类型。否则,创建预留将失败。

如需通过指定实例模板创建单项目预留,请选择以下选项之一:

控制台

  1. 在 Google Cloud 控制台中,转到预留页面。

    转到“预留”

  2. 按需预留标签页(默认)上,点击 创建预留

    此时会打开创建预留页面。

  3. 名称部分,输入预留的名称。

  4. 区域可用区部分,选择您要预留资源的位置。

  5. 共享类型部分中,选择本地(如果尚未选择)。

  6. 可选:如需允许 GPU 虚拟机的预留供 Vertex AI 中的自定义训练作业预测作业使用,请在 Google Cloud 服务部分中选择共享预留

  7. 搭配虚拟机实例使用部分中,选择以下选项之一:

    • 如需允许匹配的虚拟机自动使用此预留,请选择自动使用预留(如果尚未选择)。

    • 如需只有在创建通过名称明确指向此预留的匹配虚拟机时使用此预留的资源,请选择选择特定预留

  8. 虚拟机实例数量部分,输入要预留的虚拟机数量。

  9. 机器配置部分中,执行以下操作:

    1. 如需根据现有实例模板指定虚拟机的属性,请选择使用实例模板

    2. 实例模板字段中,选择所需的实例模板。 如果您选择区域级实例模板,则只能在实例模板所在的区域内预留资源。

  10. 自动删除部分中,您可以启用自动删除选项,以让 Compute Engine 在特定日期和时间自动删除预留。当您停止使用预留时,自动删除预留有助于避免产生不必要的费用。

  11. 要创建预留,请点击创建

    此时会打开预留页面。创建单项目预留可能需要一分钟时间才能完成。

gcloud

如需创建单项目预留,请使用 gcloud compute reservations create 命令

如需通过指定实例模板而不添加任何可选标志来创建单项目预留,请运行以下命令:

gcloud compute reservations create RESERVATION_NAME \
    --source-instance-template=projects/PROJECT_ID/LOCATION/instanceTemplates/INSTANCE_TEMPLATE_NAME \
    --vm-count=NUMBER_OF_VMS \
    --zone=ZONE

替换以下内容:

  • RESERVATION_NAME:要创建的预留的名称。

  • PROJECT_ID:要在其中预留资源以及实例模板所在的项目的 ID。

  • LOCATION:实例模板的位置。 请指定以下某个值:

    • 对于全球实例模板:global

    • 对于区域级实例模板:regions/REGION。 将 REGION 替换为实例模板所在的区域。如果您指定区域级实例模板,则只能预留与模板区域相同的区域内的虚拟机。

  • INSTANCE_TEMPLATE_NAME:现有实例模板的名称。如果实例模板指定了 A3 机器类型或紧凑布置政策,则必须添加 --require-specific-reservation 标志。这表示只有明确指向预留的虚拟机才能使用它。如需了解详情,请参阅使用特定预留中的虚拟机

  • NUMBER_OF_VMS:要预留的虚拟机数量。

  • ZONE:预留资源的可用区。

例如,如需通过指定全局实例模板为可用区 us-central1-a 中的 10 个虚拟机创建预留,请运行以下命令:

gcloud compute reservations create my-reservation \
    --source-instance-template=projects/example-project/global/example-instance-template \
    --vm-count=10 \
    --zone=us-central1-a

您可以选择执行以下一项或多项操作:

  • 如需指定只有明确指向此预留的虚拟机才能使用它,请添加 --require-specific-reservation 标志。

    gcloud compute reservations create RESERVATION_NAME \
        --source-instance-template=projects/PROJECT_ID/LOCATION/instanceTemplates/INSTANCE_TEMPLATE_NAME \
        --require-specific-reservation \
        --vm-count=NUMBER_OF_VMS \
        --zone=ZONE
    
  • 如需允许 GPU 虚拟机的预留供 Vertex AI 中的自定义训练作业预测作业使用,请将 gcloud beta compute reservations create 命令--reservation-sharing-policy=ALLOW_ALL 标志结合使用。

    gcloud beta compute reservations create RESERVATION_NAME \
        --source-instance-template=projects/PROJECT_ID/LOCATION/instanceTemplates/INSTANCE_TEMPLATE_NAME \
        --reservation-sharing-policy=ALLOW_ALL \
        --vm-count=NUMBER_OF_VMS \
        --zone=ZONE
    
  • 如需让 Compute Engine 自动删除预留,请选择以下方法之一:

    • 如需在特定日期和时间删除预留,请使用带有 --delete-at-time 标志的 gcloud beta compute reservations create 命令

      gcloud beta compute reservations create RESERVATION_NAME \
          --delete-at-time=DELETE_AT_TIME \
          --source-instance-template=projects/PROJECT_ID/LOCATION/instanceTemplates/INSTANCE_TEMPLATE_NAME \
          --vm-count=NUMBER_OF_VMS \
          --zone=ZONE
      

      DELETE_AT_TIME 替换为采用 RFC 3339 时间戳格式的日期和时间,必须如下所示:none YYYY-MM-DDTHH:MM:SSOFFSET

      替换以下内容:

      • YYYY-MM-DD:格式为 4 位数年份、2 位数月份和 2 位数日期而且相互之间以连字符 (-) 分隔的日期。

      • HH:MM:SS:格式为 2 位数小时、2 位数分钟和 2 位数秒而且相互之间以冒号 (:) 分隔的采用 24 小时制的时间。

      • OFFSET:采用世界协调时间 (UTC) 的偏移量格式的时区。例如,要使用太平洋标准时间 (PST),请指定 -08:00。或者,如果不使用偏移量,请指定 Z

    • 如需在特定时间段后删除预留,请使用带有 --delete-after-duration 标志的 gcloud beta compute reservations create 命令

      gcloud beta compute reservations create RESERVATION_NAME \
          --delete-after-duration=DELETE_AFTER_DURATION \
          --source-instance-template=projects/PROJECT_ID/LOCATION/instanceTemplates/INSTANCE_TEMPLATE_NAME \
          --vm-count=NUMBER_OF_VMS \
          --zone=ZONE
      

      DELETE_AFTER_DURATION 替换为以天、小时、分钟或秒为单位的时长。例如,指定 30m 表示 30 分钟,或指定 1d2h3m4s 表示 1 天 2 小时 3 分钟 4 秒。

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"
)

// Creates the reservation from given template in particular zone
func createReservation(w io.Writer, projectID, zone, reservationName, sourceTemplate string) error {
	// projectID := "your_project_id"
	// zone := "us-west3-a"
	// reservationName := "your_reservation_name"
	// template: 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()
	reservationsClient, err := compute.NewReservationsRESTClient(ctx)
	if err != nil {
		return err
	}
	defer reservationsClient.Close()

	req := &computepb.InsertReservationRequest{
		Project: projectID,
		ReservationResource: &computepb.Reservation{
			Name: proto.String(reservationName),
			Zone: proto.String(zone),
			SpecificReservation: &computepb.AllocationSpecificSKUReservation{
				Count:                  proto.Int64(2),
				SourceInstanceTemplate: proto.String(sourceTemplate),
			},
		},
		Zone: zone,
	}

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

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

	fmt.Fprintf(w, "Reservation created\n")

	return nil
}

Java

import com.google.cloud.compute.v1.AllocationSpecificSKUReservation;
import com.google.cloud.compute.v1.Operation;
import com.google.cloud.compute.v1.Reservation;
import com.google.cloud.compute.v1.ReservationsClient;
import java.io.IOException;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.TimeoutException;

public class CreateReservationForInstanceTemplate {

  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 in which you want to create the reservation.
    String zone = "us-central1-a";
    // Name of the reservation you want to create.
    String reservationName = "YOUR_RESERVATION_NAME";
    // The number of virtual machines you want to create.
    int numberOfVms = 3;
    // The URI of the instance template with GLOBAL location
    // to be used for creating the reservation.
    String instanceTemplateUri =
        "projects/YOUR_PROJECT_ID/global/instanceTemplates/YOUR_INSTANCE_TEMPLATE_NAME";
    // The URI of the instance template with REGIONAL location
    // to be used for creating the reservation. For us-central1 region in this case.
    // String instanceTemplateUri =
    // "projects/YOUR_PROJECT_ID/regions/us-central1/instanceTemplates/YOUR_INSTANCE_TEMPLATE_NAME"

    createReservationForInstanceTemplate(
        projectId, reservationName, instanceTemplateUri, numberOfVms, zone);
  }

  // Creates a reservation in a project for the instance template.
  public static Reservation createReservationForInstanceTemplate(
      String projectId, String reservationName, String instanceTemplateUri,
      int numberOfVms, String zone)
      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.
    try (ReservationsClient reservationsClient = ReservationsClient.create()) {
      Reservation reservation =
          Reservation.newBuilder()
              .setName(reservationName)
              .setZone(zone)
              .setSpecificReservation(
                  AllocationSpecificSKUReservation.newBuilder()
                      // Set the number of instances
                      .setCount(numberOfVms)
                      // Set the instance template to be used for creating the reservation.
                      .setSourceInstanceTemplate(instanceTemplateUri)
                      .build())
              .build();

      Operation response =
          reservationsClient.insertAsync(projectId, zone, reservation).get(3, TimeUnit.MINUTES);

      if (response.hasError()) {
        return null;
      }
      return reservationsClient.get(projectId, zone, reservationName);
    }
  }
}

Node.js

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

// Instantiate a reservationsClient
const reservationsClient = new computeLib.ReservationsClient();
// 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 reserve resources and where the instance template exists.
const projectId = await reservationsClient.getProjectId();
// The zone in which to reserve resources.
const zone = 'us-central1-a';
// The name of the reservation to create.
// reservationName = 'reservation-01';
// The number of VMs to reserve.
const vmsNumber = 3;

/**
 * The name of an existing instance template.
 * TODO(developer): Uncomment and update instanceTemplateName before running the sample.
 */
// const instanceTemplateName = 'pernament-region-template-name';

/**
 * // The location of the instance template.
 * TODO(developer): Uncomment the `location` variable depending on which template you want to use.
 */

// The location for a regional instance template: regions/{region}. Replace region with the region where the instance template is located.
// If you specify a regional instance template, then you can only reserve VMs within the same region as the template's region.
// const location = `regions/${zone.slice(0, -2)}`;

// The location for a global instance template.
// const location = 'global';

async function callCreateComputeReservationInstanceTemplate() {
  // Create reservation for 3 VMs in zone us-central1-a by specifying a instance template.
  const specificReservation = new compute.AllocationSpecificSKUReservation({
    count: vmsNumber,
    sourceInstanceTemplate: `projects/${projectId}/${location}/instanceTemplates/${instanceTemplateName}`,
  });

  // Create a reservation.
  const reservation = new compute.Reservation({
    name: reservationName,
    specificReservation,
    // To specify that only VMs that specifically target this reservation can consume it,
    // set specificReservationRequired field to true.
    specificReservationRequired: true,
  });

  const [response] = await reservationsClient.insert({
    project: projectId,
    reservationResource: reservation,
    zone,
  });

  let operation = response.latestResponse;

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

  console.log(`Reservation: ${reservationName} created.`);
}

await callCreateComputeReservationInstanceTemplate();

Python

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 create_reservation_from_template(
    project_id: str, reservation_name: str, template: str
) -> compute_v1.Reservation:
    """
    Create a new reservation based on an existing template.

    Args:
        project_id: project ID or project number of the Cloud project you use.
        reservation_name: the name of new reservation.
        template: 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

    Returns:
        Reservation object that represents the new reservation.
    """

    reservations_client = compute_v1.ReservationsClient()
    request = compute_v1.InsertReservationRequest()
    request.project = project_id
    request.zone = "us-central1-a"

    specific_reservation = compute_v1.AllocationSpecificSKUReservation()
    specific_reservation.count = 1
    specific_reservation.source_instance_template = template

    reservation = compute_v1.Reservation()
    reservation.name = reservation_name
    reservation.specific_reservation = specific_reservation

    request.reservation_resource = reservation
    operation = reservations_client.insert(request)
    wait_for_extended_operation(operation, "Reservation creation")

    return reservations_client.get(
        project=project_id, zone="us-central1-a", reservation=reservation_name
    )

REST

如需创建单项目预留,请向 reservations.insert 方法发出 POST 请求。

如需通过指定实例模板而不添加任何可选标志来创建单项目预留,请发出以下 POST 请求:

POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/zones/ZONE/reservations

{
  "name": "RESERVATION_NAME",
  "specificReservation": {
    "count": "NUMBER_OF_VMS",
    "sourceInstanceTemplate": "projects/PROJECT_ID/LOCATION/instanceTemplates/INSTANCE_TEMPLATE_NAME"
  }
}

替换以下内容:

  • PROJECT_ID:要在其中预留资源以及实例模板所在的项目的 ID。

  • ZONE:预留资源的可用区。

  • RESERVATION_NAME:要创建的预留的名称。

  • NUMBER_OF_VMS:要预留的虚拟机数量。

  • LOCATION:实例模板的位置。 请指定以下某个值:

    • 对于全球实例模板:global

    • 对于区域级实例模板:regions/REGION。 将 REGION 替换为实例模板所在的区域。如果您指定区域级实例模板,则只能预留与模板区域相同的区域内的虚拟机。

  • INSTANCE_TEMPLATE_NAME:现有实例模板的名称。如果实例模板指定了 A3 机器类型或紧凑布置政策,则必须在请求正文中添加 specificReservationRequired 字段,并将该字段设置为 true。这表示只有明确指向此预留的虚拟机才能使用它。如需了解详情,请参阅使用特定预留中的虚拟机

例如,如需通过指定全局实例模板为可用区 us-central1-a 中的 10 个虚拟机创建预留,请发出以下 POST 请求:

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

{
  "name": "my-reservation",
  "specificReservation": {
    "count": "10",
    "sourceInstanceTemplate": "projects/example-project/global/instanceTemplates/example-instance-template"
  }
}

您可以选择执行以下一项或多项操作:

  • 如需指定只有明确指向此预留的虚拟机才能使用它,请在请求正文中添加 specificReservationRequired 字段,并将该字段设置为 true

    POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/zones/ZONE/reservations
    
    {
      "name": "RESERVATION_NAME",
      "specificReservation": {
        "count": "NUMBER_OF_VMS",
        "sourceInstanceTemplate": "projects/PROJECT_ID/LOCATION/instanceTemplates/INSTANCE_TEMPLATE_NAME"
      },
      "specificReservationRequired": true
    }
    
  • 如需允许 GPU 虚拟机的预留供 Vertex AI 中的自定义训练作业预测作业使用,请向 beta.reservations.insert 方法发出 POST 请求。在请求正文中,添加 serviceShareType 字段并将其设置为 ALLOW_ALL

    POST https://compute.googleapis.com/compute/beta/projects/PROJECT_ID/zones/ZONE/reservations
    
    {
      "name": "RESERVATION_NAME",
      "reservationSharingPolicy": {
        "serviceShareType": "ALLOW_ALL"
      },
      "specificReservation": {
        "count": "NUMBER_OF_VMS",
        "sourceInstanceTemplate": "projects/PROJECT_ID/LOCATION/instanceTemplates/INSTANCE_TEMPLATE_NAME"
      }
    }
    
  • 如需让 Compute Engine 自动删除预留,请选择以下方法之一:

    • 如需在特定日期和时间删除预留,请向 beta.reservations.insert 方法发出 POST 请求。在请求正文中,包含 deleteAtTime 字段。

      POST https://compute.googleapis.com/compute/beta/projects/PROJECT_ID/zones/ZONE/reservations
      
      {
        "deleteAtTime": "DELETE_AT_TIME",
        "name": "RESERVATION_NAME",
        "specificReservation": {
          "count": "NUMBER_OF_VMS",
          "sourceInstanceTemplate": "projects/PROJECT_ID/LOCATION/instanceTemplates/INSTANCE_TEMPLATE_NAME"
        }
      }
      

      DELETE_AT_TIME 替换为格式为 RFC 3339 时间戳(时间戳必须如下所示)的日期和时间:

      YYYY-MM-DDTHH:MM:SSOFFSET
      

      替换以下内容:

      • YYYY-MM-DD:格式为 4 位数年份、2 位数月份和 2 位数日期而且相互之间以连字符 (-) 分隔的日期。

      • HH:MM:SS:格式为 2 位数小时、2 位数分钟和 2 位数秒而且相互之间以冒号 (:) 分隔的采用 24 小时制的时间。

      • OFFSET:采用世界协调时间 (UTC) 的偏移量格式的时区。例如,要使用太平洋标准时间 (PST),请指定 -08:00。或者,如果不使用偏移量,请指定 Z

    • 如需在特定时间段后删除预留,请向 beta.reservations.insert 方法发出 POST 请求。在请求正文中,包含 deleteAfterDuration 字段。

      POST https://compute.googleapis.com/compute/beta/projects/PROJECT_ID/zones/ZONE/reservations
      
      {
        "deleteAfterDuration": {
          "seconds": "DELETE_AFTER_DURATION"
        },
        "name": "RESERVATION_NAME",
        "specificReservation": {
          "count": "NUMBER_OF_VMS",
          "sourceInstanceTemplate": "projects/PROJECT_ID/LOCATION/instanceTemplates/INSTANCE_TEMPLATE_NAME"
        }
      }
      

      DELETE_AFTER_DURATION 替换为持续时间,以秒为单位。例如,指定 86400 标识 86400 秒(1 天)。

指定现有虚拟机

您只能根据现有虚拟机在与该虚拟机相同的可用区中创建预留。

创建预留后,您可以通过创建其属性与参考虚拟机匹配的虚拟机来使用该预留。为此,您可以执行以下操作之一:

如需创建使用现有虚拟机的属性的单项目预留,请执行以下操作:

  1. 在 Google Cloud 控制台中,转到预留页面。

    转到“预留”

  2. 点击 创建预留

    此时会打开创建预留页面。

  3. 名称部分,输入预留的名称。

  4. 区域可用区部分,选择您要预留资源的位置。

  5. 共享类型部分中,点击本地(如果尚未选择)。

  6. 搭配虚拟机实例使用部分中,选择以下选项之一:

    • 如需允许匹配的虚拟机自动使用此预留,请选择自动使用预留(如果尚未选择)。

    • 如需只有在创建通过名称明确指向此预留的匹配虚拟机时使用此预留的资源,请选择选择特定预留

  7. 虚拟机实例数量部分,输入要预留的虚拟机数量。

  8. 机器配置部分中,执行以下操作:

    1. 选择使用现有虚拟机

    2. 现有虚拟机部分,选择要使用其属性创建预留的虚拟机。

  9. 可选:如需为符合要求的预留指定紧凑布置政策,请在组布置政策部分中,点击选择或创建组布置政策列表,然后执行以下操作之一:

    • 如需创建要在此预留中指定的紧凑布置政策,请执行以下操作:

      1. 点击创建组布置政策

        系统会显示创建组布置政策窗格。

      2. 政策名称中,输入政策的名称。

      3. 点击创建

        创建紧凑布置政策可能需要几秒钟才能完成。

    • 否则,请选择现有的紧凑布置政策。

  10. 自动删除部分中,您可以启用自动删除选项,以便让 Compute Engine 在特定日期和时间自动删除预留。当您停止使用预留时,自动删除预留有助于避免产生不必要的费用。

  11. 要创建预留,请点击创建

    此时会打开预留页面。创建预留最长可能需要一分钟才能完成。

直接指定属性

如需通过直接指定属性来创建单项目预留,请选择以下选项之一:

控制台

  1. 在 Google Cloud 控制台中,转到预留页面。

    转到“预留”

  2. 按需预留标签页(默认)上,点击 创建预留

    此时会打开创建预留页面。

  3. 名称部分,输入预留的名称。

  4. 区域可用区部分,选择您要预留资源的位置。

  5. 共享类型部分中,点击本地(如果尚未选择)。

  6. 可选:如需允许 GPU 虚拟机的预留供 Vertex AI 中的自定义训练作业预测作业使用,请在 Google Cloud 服务部分中选择共享预留

  7. 搭配虚拟机实例使用部分中,选择以下选项之一:

    • 如需允许匹配的虚拟机自动使用此预留,请选择自动使用预留(如果尚未选择)。

    • 如需只有在创建通过名称明确指向此预留的匹配虚拟机时使用此预留的资源,请选择选择特定预留

  8. 虚拟机实例数量部分,输入要预留的虚拟机数量。

  9. 机器配置部分中,选择指定机器类型,然后指定以下内容:

    1. 机器家族系列机器类型部分,选择机器家族、系列和机器类型。

    2. 可选:如需指定满足最低要求的 CPU 平台或将 GPU 挂接到 N1 虚拟机,请执行以下操作:

      1. 如需展开 CPU 平台和 GPU 部分,请点击 展开箭头。

      2. 可选:如需指定满足最低要求的 CPU 平台,请在 CPU 平台中选择一个选项。

      3. 可选:如需将 GPU 附加到 N1 虚拟机,请点击 添加 GPU。然后,在 GPU 类型GPU 数量部分,选择要挂接到每个 N1 虚拟机的 GPU 的类型和数量。

    3. 可选:如需添加本地 SSD 磁盘,请执行以下操作:

      1. 磁盘数量部分,选择每个虚拟机的本地 SSD 磁盘数量。

      2. 接口类型部分,选择本地 SSD 磁盘的接口。

    4. 可选:如需为符合要求的预留指定紧凑布置政策,请点击选择或创建组布置政策列表,然后执行以下操作之一:

      • 如需创建要在此预留中指定的紧凑布置政策,请按照以下步骤操作:

        1. 点击创建组布置政策

          系统会显示创建组布置政策窗格。

        2. 政策名称中,输入政策的名称。

        3. 点击创建

          创建紧凑布置政策可能需要几秒钟才能完成。

      • 否则,请选择现有的紧凑布置政策。

  10. 可选:如需为符合要求的预留指定紧凑布置政策,请在组布置政策部分中,点击选择或创建组布置政策列表,然后执行以下操作之一:

    • 如需创建要在此预留中指定的紧凑布置政策,请执行以下操作:

      1. 点击创建组布置政策

        系统会显示创建组布置政策窗格。

      2. 政策名称中,输入政策的名称。

      3. 点击创建

        创建紧凑布置政策可能需要几秒钟才能完成。

    • 否则,请选择现有的紧凑布置政策。

  11. 自动删除部分中,您可以启用自动删除选项,以便让 Compute Engine 在特定日期和时间自动删除预留。当您停止使用预留时,自动删除预留有助于避免产生不必要的费用。

  12. 要创建预留,请点击创建

    此时会打开预留页面。创建单项目预留可能需要一分钟时间才能完成。

gcloud

如需创建单项目预留,请使用 gcloud compute reservations create 命令

如需通过直接指定属性而不添加任何可选标志来创建单项目预留,请运行以下命令:

gcloud compute reservations create RESERVATION_NAME \
    --machine-type=MACHINE_TYPE \
    --vm-count=NUMBER_OF_VMS \
    --zone=ZONE

替换以下内容:

  • RESERVATION_NAME:要创建的预留的名称。

  • MACHINE_TYPE:要用于每个虚拟机的机器类型。如果您指定 A3 机器类型,则必须添加 --require-specific-reservation 标志。这表示只有明确指向预留的虚拟机才能使用它。如需了解详情,请参阅使用特定预留中的虚拟机

  • NUMBER_OF_VMS:要预留的虚拟机数量。

  • ZONE:预留资源的可用区。

例如,如需在 us-central1-a 可用区中为 10 个虚拟机创建预留,每个虚拟机使用具有 4 个 vCPU 的 N2 预定义机器类型,请运行以下命令:

gcloud compute reservations create my-reservation \
    --machine-type=n2-standard-4 \
    --vm-count=10 \
    --zone=us-central1-a

您可以选择执行以下一项或多项操作:

  • 如需将 GPU 附加到预留的 N1 虚拟机,请添加 --accelerator 标志。

    gcloud compute reservations create RESERVATION_NAME \
        --accelerator=count=NUMBER_OF_ACCELERATORS,type=ACCELERATOR_TYPE
        --machine-type=MACHINE_TYPE \
        --vm-count=NUMBER_OF_VMS \
        --zone=ZONE
    

    替换以下内容:

  • 如需向每个预留的虚拟机添加一个或多个本地 SSD 磁盘,请添加一个或多个 --local-ssd 标志。您最多可以指定 24 个本地 SSD 磁盘。每个本地 SSD 磁盘为 375 GB。

    例如,如需在创建预留时指定两个本地 SSD 磁盘,请添加两个 --local-ssd 标志,如下所示:

    gcloud compute reservations create RESERVATION_NAME \
        --local-ssd=size=375,interface=INTERFACE_1 \
        --local-ssd=size=375,interface=INTERFACE_2 \
        --machine-type=MACHINE_TYPE \
        --vm-count=NUMBER_OF_VMS \
        --zone=ZONE
    

    INTERFACE_1INTERFACE_2 替换为您希望每个本地 SSD 磁盘使用的接口类型。请指定以下某个值:

    • NVME 磁盘接口:nvme

    • SCSI 磁盘接口:scsi

    确保您为已预留虚拟机指定的机器类型支持所选的磁盘接口。否则,创建预留将失败。 如需了解详情,请参阅如何选择磁盘接口

  • 如需让预留的虚拟机使用特定的满足最低要求的 CPU 平台(而不是该可用区的默认 CPU 平台),请添加 --min-cpu-platform 标志。

    gcloud compute reservations create RESERVATION_NAME \
        --machine-type=MACHINE_TYPE \
        --min-cpu-platform="MIN_CPU_PLATFORM" \
        --vm-count=NUMBER_OF_VMS \
        --zone=ZONE
    

    MIN_CPU_PLATFORM 替换为满足最低要求的 CPU 平台。为确保 CPU 平台在要预留资源的可用区可用,请按可用区查看可用的 CPU 平台

  • 如需指定只有明确指向此预留的虚拟机才能使用它,请添加 --require-specific-reservation 标志。

    gcloud compute reservations create RESERVATION_NAME \
        --machine-type=MACHINE_TYPE \
        --require-specific-reservation \
        --vm-count=NUMBER_OF_VMS \
        --zone=ZONE
    
  • 如需指定紧凑布置政策以降低虚拟机之间的网络延迟时间,请添加 --resource-policies=policy 标志。

    gcloud compute reservations create RESERVATION_NAME \
        --machine-type=MACHINE_TYPE \
        --resource-policies=policy=COMPACT_PLACEMENT_POLICY_NAME \
        --require-specific-reservation \
        --vm-count=NUMBER_OF_VMS \
        --zone=ZONE
    

    COMPACT_PLACEMENT_POLICY_NAME 替换为现有紧凑布置政策的名称。此外,为了避免在创建指定紧凑布置政策的单项目预留时发生错误,请务必指定以下内容:

    • 紧凑布置政策支持的机器类型和虚拟机数上限

    • 紧凑布置政策所在区域内的可用区。

    • --require-specific-reservation 标志。 这表示只有明确指向预留的虚拟机才能使用它。

  • 如需允许 GPU 虚拟机的预留供 Vertex AI 中的自定义训练作业预测作业使用,请将 gcloud beta compute reservations create 命令--reservation-sharing-policy=ALLOW_ALL 标志结合使用。

    gcloud beta compute reservations create RESERVATION_NAME \
        --machine-type=MACHINE_TYPE \
        --reservation-sharing-policy=ALLOW_ALL \
        --vm-count=NUMBER_OF_VMS \
        --zone=ZONE
    
  • 如需让 Compute Engine 自动删除预留,请选择以下方法之一:

    • 如需在特定日期和时间删除预留,请使用带有 --delete-at-time 标志的 gcloud beta compute reservations create 命令

      gcloud beta compute reservations create RESERVATION_NAME \
          --delete-at-time=DELETE_AT_TIME \
          --machine-type=MACHINE_TYPE \
          --vm-count=NUMBER_OF_VMS \
          --zone=ZONE
      

      DELETE_AT_TIME 替换为格式为 RFC 3339 时间戳(时间戳必须如下所示)的日期和时间:

      YYYY-MM-DDTHH:MM:SSOFFSET
      

      替换以下内容:

      • YYYY-MM-DD:格式为 4 位数年份、2 位数月份和 2 位数日期而且相互之间以连字符 (-) 分隔的日期。

      • HH:MM:SS:格式为 2 位数小时、2 位数分钟和 2 位数秒而且相互之间以冒号 (:) 分隔的采用 24 小时制的时间。

      • OFFSET:采用世界协调时间 (UTC) 的偏移量格式的时区。例如,要使用太平洋标准时间 (PST),请指定 -08:00。或者,如果不使用偏移量,请指定 Z

    • 如需在特定时间段后删除预留,请使用带有 --delete-after-duration 标志的 gcloud beta compute reservations create 命令

      gcloud beta compute reservations create RESERVATION_NAME \
          --delete-after-duration=DELETE_AFTER_DURATION \
          --machine-type=MACHINE_TYPE \
          --vm-count=NUMBER_OF_VMS \
          --zone=ZONE
      

      DELETE_AFTER_DURATION 替换为以天、小时、分钟或秒为单位的时长。例如,指定 30m 表示 30 分钟,或指定 1d2h3m4s 表示 1 天 2 小时 3 分钟 4 秒。

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"
)

// Creates the reservation with accelerated image
func createBaseReservation(w io.Writer, projectID, zone, reservationName string) error {
	// projectID := "your_project_id"
	// zone := "us-west3-a"
	// reservationName := "your_reservation_name"

	ctx := context.Background()
	reservationsClient, err := compute.NewReservationsRESTClient(ctx)
	if err != nil {
		return err
	}
	defer reservationsClient.Close()

	// Creating reservation based on direct properties
	req := &computepb.InsertReservationRequest{
		Project: projectID,
		ReservationResource: &computepb.Reservation{
			Name: proto.String(reservationName),
			Zone: proto.String(zone),
			SpecificReservation: &computepb.AllocationSpecificSKUReservation{
				Count: proto.Int64(2),
				// Properties, which allows customising instances
				InstanceProperties: &computepb.AllocationSpecificSKUAllocationReservedInstanceProperties{
					// Attaching GPUs to the reserved VMs
					// Read more: https://cloud.google.com/compute/docs/gpus#n1-gpus
					GuestAccelerators: []*computepb.AcceleratorConfig{
						{
							AcceleratorCount: proto.Int32(1),
							AcceleratorType:  proto.String("nvidia-tesla-t4"),
						},
					},
					// Including local SSD disks
					LocalSsds: []*computepb.AllocationSpecificSKUAllocationAllocatedInstancePropertiesReservedDisk{
						{
							DiskSizeGb: proto.Int64(375),
							Interface:  proto.String("NVME"),
						},
					},
					MachineType: proto.String("n1-standard-2"),
					// Specifying minimum CPU platform
					// Read more: https://cloud.google.com/compute/docs/instances/specify-min-cpu-platform
					MinCpuPlatform: proto.String("Intel Skylake"),
				},
			},
		},
		Zone: zone,
	}

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

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

	fmt.Fprintf(w, "Reservation created\n")

	return nil
}

Java

import com.google.cloud.compute.v1.AcceleratorConfig;
import com.google.cloud.compute.v1.AllocationSpecificSKUAllocationAllocatedInstancePropertiesReservedDisk;
import com.google.cloud.compute.v1.AllocationSpecificSKUAllocationReservedInstanceProperties;
import com.google.cloud.compute.v1.AllocationSpecificSKUReservation;
import com.google.cloud.compute.v1.Operation;
import com.google.cloud.compute.v1.Reservation;
import com.google.cloud.compute.v1.ReservationsClient;
import java.io.IOException;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.TimeoutException;

public class CreateReservation {

  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 in which you want to create the disk.
    String zone = "us-central1-a";
    // Name of the reservation you want to create.
    String reservationName = "YOUR_RESERVATION_NAME";
    // Number of instances in the reservation.
    int numberOfVms = 3;

    createReservation(projectId, reservationName, numberOfVms, zone);
  }

  // Creates reservation with optional flags
  public static Reservation createReservation(
      String projectId, String reservationName, int numberOfVms, String zone)
      throws IOException, ExecutionException, InterruptedException, TimeoutException {
    // Create the reservation with optional properties:
    // Machine type of the instances in the reservation.
    String machineType = "n1-standard-2";
    // Number of accelerators to be attached to the instances in the reservation.
    int numberOfAccelerators = 1;
    // Accelerator type to be attached to the instances in the reservation.
    String acceleratorType = "nvidia-tesla-t4";
    // Minimum CPU platform to be attached to the instances in the reservation.
    String minCpuPlatform = "Intel Skylake";
    // Local SSD size in GB to be attached to the instances in the reservation.
    int localSsdSize = 375;
    // Local SSD interfaces to be attached to the instances in the reservation.
    String localSsdInterface1 = "NVME";
    String localSsdInterface2 = "SCSI";
    boolean specificReservationRequired = true;
    // 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 (ReservationsClient reservationsClient = ReservationsClient.create()) {
      Reservation reservation =
          Reservation.newBuilder()
              .setName(reservationName)
              .setZone(zone)
              .setSpecificReservationRequired(specificReservationRequired)
              .setSpecificReservation(
                  AllocationSpecificSKUReservation.newBuilder()
                      // Set the number of instances
                      .setCount(numberOfVms)
                      // Set instance properties
                      .setInstanceProperties(
                          AllocationSpecificSKUAllocationReservedInstanceProperties.newBuilder()
                              .setMachineType(machineType)
                              .setMinCpuPlatform(minCpuPlatform)
                              .addGuestAccelerators(
                                  AcceleratorConfig.newBuilder()
                                      .setAcceleratorCount(numberOfAccelerators)
                                      .setAcceleratorType(acceleratorType)
                                      .build())
                              .addLocalSsds(
                            AllocationSpecificSKUAllocationAllocatedInstancePropertiesReservedDisk
                                      .newBuilder()
                                      .setDiskSizeGb(localSsdSize)
                                      .setInterface(localSsdInterface1)
                                      .build())
                              .addLocalSsds(
                            AllocationSpecificSKUAllocationAllocatedInstancePropertiesReservedDisk
                                      .newBuilder()
                                      .setDiskSizeGb(localSsdSize)
                                      .setInterface(localSsdInterface2)
                                      .build())
                              .build())
                      .build())
              .build();

      Operation response =
          reservationsClient.insertAsync(projectId, zone, reservation).get(7, TimeUnit.MINUTES);

      if (response.hasError()) {
        return null;
      }
      return reservationsClient.get(projectId, zone, reservationName);
    }
  }
}

Node.js

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

// Instantiate a reservationsClient
const reservationsClient = new computeLib.ReservationsClient();
// 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 reserve resources.
const projectId = await reservationsClient.getProjectId();
// The zone in which to reserve resources.
const zone = 'us-central1-a';
// The name of the reservation to create.
// reservationName = 'reservation-01';
// The number of VMs to reserve.
const vmsNumber = 3;
// Machine type to use for each VM.
const machineType = 'n1-standard-4';

async function callCreateComputeReservationFromProperties() {
  // Create specific reservation for 3 VMs that each use an N1 predefined machine type with 4 vCPUs.
  const specificReservation = new compute.AllocationSpecificSKUReservation({
    count: vmsNumber,
    instanceProperties: {
      machineType,
      // To have the reserved VMs use a specific minimum CPU platform instead of the zone's default CPU platform.
      minCpuPlatform: 'Intel Skylake',
      // If you want to attach GPUs to your reserved N1 VMs, update and uncomment guestAccelerators if needed.
      // guestAccelerators: [
      //   {
      //     // The number of GPUs to add per reserved VM.
      //     acceleratorCount: 1,
      //     // Supported GPU model for N1 VMs. Ensure that your chosen GPU model is available in the zone,
      //     // where you want to reserve resources.
      //     acceleratorType: 'nvidia-tesla-t4',
      //   },
      // ],
      // If you want to add local SSD disks to each reserved VM, update and uncomment localSsds if needed.
      // You can specify up to 24 Local SSD disks. Each Local SSD disk is 375 GB.
      // localSsds: [
      //   {
      //     diskSizeGb: 375,
      //     // The type of interface you want each Local SSD disk to use. Specify one of the following values: NVME or SCSI.
      //     // Make sure that the machine type you specify for the reserved VMs supports the chosen disk interfaces.
      //     interface: 'NVME',
      //   },
      // ],
    },
  });

  // Create a reservation.
  const reservation = new compute.Reservation({
    name: reservationName,
    zone,
    specificReservation,
    // To specify that only VMs that specifically target this reservation can consume it,
    // set specificReservationRequired field to true.
    specificReservationRequired: true,
  });

  const [response] = await reservationsClient.insert({
    project: projectId,
    reservationResource: reservation,
    zone,
  });

  let operation = response.latestResponse;

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

  console.log(`Reservation: ${reservationName} created.`);
}

await callCreateComputeReservationFromProperties();

Python

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 create_compute_reservation(
    project_id: str,
    zone: str = "us-central1-a",
    reservation_name="your-reservation-name",
) -> compute_v1.Reservation:
    """Creates a compute reservation in GCP.
    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.
    Returns:
        Reservation object that represents the new reservation.
    """

    instance_properties = compute_v1.AllocationSpecificSKUAllocationReservedInstanceProperties(
        machine_type="n1-standard-1",
        # Optional. Specifies the minimum CPU platform for the VM instance.
        min_cpu_platform="Intel Ivy Bridge",
        # Optional. Specifies amount of local ssd to reserve with each instance.
        local_ssds=[
            compute_v1.AllocationSpecificSKUAllocationAllocatedInstancePropertiesReservedDisk(
                disk_size_gb=375, interface="NVME"
            ),
            compute_v1.AllocationSpecificSKUAllocationAllocatedInstancePropertiesReservedDisk(
                disk_size_gb=375, interface="SCSI"
            ),
        ],
        # Optional. Specifies the GPUs allocated to each instance.
        # guest_accelerators=[
        #     compute_v1.AcceleratorConfig(
        #         accelerator_count=1, accelerator_type="nvidia-tesla-t4"
        #     )
        # ],
    )

    reservation = compute_v1.Reservation(
        name=reservation_name,
        specific_reservation=compute_v1.AllocationSpecificSKUReservation(
            count=3,  # Number of resources that are allocated.
            # If you use source_instance_template, you must exclude the instance_properties field.
            # It can be a full or partial URL.
            # source_instance_template="projects/[PROJECT_ID]/global/instanceTemplates/my-instance-template",
            instance_properties=instance_properties,
        ),
    )

    # Create a client
    client = compute_v1.ReservationsClient()

    operation = client.insert(
        project=project_id,
        zone=zone,
        reservation_resource=reservation,
    )
    wait_for_extended_operation(operation, "Reservation creation")

    reservation = client.get(
        project=project_id, zone=zone, reservation=reservation_name
    )

    print("Name: ", reservation.name)
    print("STATUS: ", reservation.status)
    print(reservation.specific_reservation)
    # Example response:
    # Name:  your-reservation-name
    # STATUS:  READY
    # count: 3
    # instance_properties {
    #   machine_type: "n1-standard-1"
    #   local_ssds {
    #     disk_size_gb: 375
    #     interface: "NVME"
    #   }
    # ...

    return reservation

Terraform

如需创建单项目预留,请使用 google_compute_reservation Terraform 资源

例如,如需为一个具有 2 个 vCPU 的 N2 预定义机器类型创建单项目预留,请使用以下资源:


resource "google_compute_reservation" "default" {
  name = "gce-reservation-local"
  zone = "us-central1-a"

  /**
   * To specify a single-project reservation, omit the share_settings block
   * (default) or set the share_type field to LOCAL.
   */
  share_settings {
    share_type = "LOCAL"
  }

  specific_reservation {
    count = 1
    instance_properties {
      machine_type = "n2-standard-2"
    }
  }

  /**
   * To let VMs with affinity for any reservation consume this reservation, omit
   * the specific_reservation_required field (default) or set it to false.
   */
  specific_reservation_required = false
}

如需详细了解如何使用 Terraform,请参阅将 Terraform 与 Google Cloud 搭配使用

REST

如需创建单项目预留,请向 reservations.insert 方法发出 POST 请求。

如需通过直接指定属性且不添加任何可选字段来创建单项目预留,请发出以下 POST 请求:

POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/zones/ZONE/reservations

{
  "name": "RESERVATION_NAME",
  "specificReservation": {
    "count": "NUMBER_OF_VMS",
    "instanceProperties": {
      "machineType": "MACHINE_TYPE"
    }
  }
}

替换以下内容:

  • PROJECT_ID:您要在其中预留资源的项目的 ID。

  • ZONE:预留资源的可用区。

  • RESERVATION_NAME:要创建的预留的名称。

  • NUMBER_OF_VMS:要预留的虚拟机数量。

  • MACHINE_TYPE:要用于每个虚拟机的机器类型。如果您指定 A3 机器类型,则必须在请求正文中添加 specificReservationRequired 字段,并将该字段设置为 true。这表示只有明确指向预留的虚拟机才能使用它。 如需了解详情,请参阅使用特定预留中的虚拟机

例如,如需在 us-central1-a 可用区中为 10 个虚拟机创建预留,每个虚拟机使用具有 4 个 vCPU 的 N2 预定义机器类型,请发出以下 POST 请求:

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

{
  "name": "my-reservation",
  "specificReservation": {
    "count": "10",
    "instanceProperties": {
      "machineType": "n2-standard-4",
    }
  }
}

您可以选择执行以下一项或多项操作:

  • 如需将 GPU 附加到预留的 N1 虚拟机,请在请求正文中添加 guestAccelerators 字段。

    POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/zones/ZONE/reservations
    
    {
      "name": "RESERVATION_NAME",
      "specificReservation": {
        "count": "NUMBER_OF_VMS",
        "instanceProperties": {
          "guestAccelerators": [
            {
              "acceleratorCount": NUMBER_OF_ACCELERATORS,
              "acceleratorType": "ACCELERATOR_TYPE"
            }
          ],
          "machineType": "MACHINE_TYPE"
        }
      }
    }
    

    替换以下内容:

  • 如需向每个预留的虚拟机添加一个或多个本地 SSD 磁盘,请在请求正文中添加 localSsds 字段。您最多可以指定 24 个本地 SSD 磁盘。每个本地 SSD 磁盘为 375 GB。

    例如,如需在创建预留时指定两个本地 SSD 磁盘,请发出如下请求:

    POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/zones/ZONE/reservations
    
    {
      "name": "RESERVATION_NAME",
      "specificReservation": {
        "count": "NUMBER_OF_VMS",
        "instanceProperties": {
          "localSsds": [
            {
              "diskSizeGb": "375",
              "interface": "INTERFACE_1"
            },
            {
              "diskSizeGb": "375",
              "interface": "INTERFACE_2"
            }
          ],
          "machineType": "MACHINE_TYPE"
        }
      }
    }
    

    INTERFACE_1INTERFACE_2 替换为您希望每个本地 SSD 磁盘使用的接口类型。请指定以下某个值:

    • NVME 磁盘接口:NVME

    • SCSI 磁盘接口:SCSI

    确保您为已预留虚拟机指定的机器类型支持所选的磁盘接口。否则,创建预留将失败。 如需了解详情,请参阅如何选择磁盘接口

  • 如需让预留的虚拟机使用特定的满足最低要求的 CPU 平台(而不是可用区的默认 CPU 平台),请在请求正文中添加 minCpuPlatform 字段。

    POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/zones/ZONE/reservations
    
    {
      "name": "RESERVATION_NAME",
      "specificReservation": {
        "count": "NUMBER_OF_VMS",
        "instanceProperties": {
          "machineType": "MACHINE_TYPE",
          "minCpuPlatform": "MIN_CPU_PLATFORM"
        }
      }
    }
    

    MIN_CPU_PLATFORM 替换为满足最低要求的 CPU 平台。为确保 CPU 平台在要预留资源的可用区可用,请按可用区查看可用的 CPU 平台

  • 如需指定紧凑布置政策以缩短预留虚拟机之间的网络延迟时间,请在请求正文中添加 resourcePolicies 字段。

    POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/zones/ZONE/reservations
    
    {
      "name": "RESERVATION_NAME",
      "resourcePolicies": {
        "policy" : "projects/example-project/regions/REGION/resourcePolicies/COMPACT_PLACEMENT_POLICY_NAME"
      },
      "specificReservation": {
        "count": "NUMBER_OF_VMS",
        "instanceProperties": {
          "machineType": "MACHINE_TYPE"
        }
      },
      "specificReservationRequired": true
    }
    

    替换以下内容:

    • REGION:紧凑布置政策所在的区域。您只能在布置政策所在的区域内创建预留。

    • COMPACT_PLACEMENT_POLICY_NAME:现有紧凑布置政策的名称。

    此外,为了避免在创建指定紧凑布置政策的单项目预留时发生错误,请务必指定以下内容:

  • 如需指定只有明确指向此预留的虚拟机才能使用它,请在请求正文中添加 specificReservationRequired 字段,并将该字段设置为 true

    POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/zones/ZONE/reservations
    
    {
      "name": "RESERVATION_NAME",
      "specificReservation": {
        "count": "NUMBER_OF_VMS",
        "instanceProperties": {
          "machineType": "MACHINE_TYPE"
        }
      },
      "specificReservationRequired": true
    }
    
  • 如需允许 GPU 虚拟机的预留供 Vertex AI 中的自定义训练作业预测作业使用,请向 beta.reservations.insert 方法发出 POST 请求。在请求正文中,添加 serviceShareType 字段并将其设置为 ALLOW_ALL

    POST https://compute.googleapis.com/compute/beta/projects/PROJECT_ID/zones/ZONE/reservations
    
    {
      "name": "RESERVATION_NAME",
      "reservationSharingPolicy": {
        "serviceShareType": "ALLOW_ALL"
      },
      "specificReservation": {
        "count": "NUMBER_OF_VMS",
        "instanceProperties": {
          "machineType": "MACHINE_TYPE"
        }
      }
    }
    
  • 如需让 Compute Engine 自动删除预留,请选择以下方法之一:

    • 如需在特定日期和时间删除预留,请向 beta.reservations.insert 方法发出 POST 请求。在请求正文中,包含 deleteAtTime 字段。

      POST https://compute.googleapis.com/compute/beta/projects/PROJECT_ID/zones/ZONE/reservations
      
      {
        "deleteAtTime": "DELETE_AT_TIME",
        "name": "RESERVATION_NAME",
        "specificReservation": {
          "count": "NUMBER_OF_VMS",
          "instanceProperties": {
            "machineType": "MACHINE_TYPE"
          }
        }
      }
      

      DELETE_AT_TIME 替换为格式为 RFC 3339 时间戳(时间戳必须如下所示)的日期和时间:

      YYYY-MM-DDTHH:MM:SSOFFSET
      

      替换以下内容:

      • YYYY-MM-DD:格式为 4 位数年份、2 位数月份和 2 位数日期而且相互之间以连字符 (-) 分隔的日期。

      • HH:MM:SS:格式为 2 位数小时、2 位数分钟和 2 位数秒而且相互之间以冒号 (:) 分隔的采用 24 小时制的时间。

      • OFFSET:采用世界协调时间 (UTC) 的偏移量格式的时区。例如,要使用太平洋标准时间 (PST),请指定 -08:00。或者,如果不使用偏移量,请指定 Z

    • 如需在特定时间段后删除预留,请向 beta.reservations.insert 方法发出 POST 请求。在请求正文中,包含 deleteAfterDuration 字段。

      POST https://compute.googleapis.com/compute/beta/projects/PROJECT_ID/zones/ZONE/reservations
      
      {
        "deleteAfterDuration": {
          "seconds": "DELETE_AFTER_DURATION"
        },
        "name": "RESERVATION_NAME",
        "specificReservation": {
          "count": "NUMBER_OF_VMS",
          "instanceProperties": {
            "machineType": "MACHINE_TYPE"
          }
        }
      }
      

      DELETE_AFTER_DURATION 替换为持续时间,以秒为单位。例如,指定 86400 标识 86400 秒(1 天)。

问题排查

了解如何排查预留创建问题

后续步骤