単一プロジェクトの予約を作成する

このドキュメントでは、単一プロジェクトの予約を作成する方法について説明します。予約は、同じプロジェクト内の仮想マシン（VM）インスタンスでのみ使用できます。予約の詳細については、Compute Engine ゾーンリソースの予約をご覧ください。

予約を作成するその他の方法については、次のページをご覧ください。

現在のプロジェクトに 1 年間または 3 年間のコミットメントがある場合、予約したリソースには該当する確約利用割引が自動的に適用されます。コミットメントの購入時に、予約を作成してコミットメントに関連付けることもできます。詳細については、予約をコミットメントに関連付けるをご覧ください。
複数のプロジェクトで使用できる予約を作成するには、共有予約を作成するをご覧ください。

始める前に

予約に関する要件と制限事項を確認します。
まだ設定していない場合は、認証を設定します。認証とは、Google Cloud サービスと API にアクセスするために ID を確認するプロセスです。ローカル開発環境からコードまたはサンプルを実行するには、次のように 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
  Note: If you installed the gcloud CLI previously, make sure you have the latest version by running gcloud components update.
2. Set a default region and zone.

必要なロール

単一プロジェクトの予約の作成に必要な権限を取得するために、プロジェクトに対する Compute 管理者（roles/compute.admin）の IAM ロールの付与を管理者に依頼してください。ロールの付与については、プロジェクト、フォルダ、組織へのアクセス権の管理をご覧ください。

この事前定義ロールには、単一プロジェクトの予約の作成に必要な権限が含まれています。必要とされる正確な権限については、「必要な権限」セクションを開いてご確認ください。

必要な権限

単一プロジェクトの予約を作成するには、次の権限が必要です。

プロジェクトに対する compute.reservations.create
インスタンステンプレートを指定するには: インスタンステンプレートに対する compute.instanceTemplates.useReadOnly

カスタムロールや他の事前定義ロールを使用して、これらの権限を取得することもできます。

単一プロジェクトの予約を作成する

予約を使用するには、VM がその予約と完全に一致するプロパティを持っている必要があります。予約する VM のプロパティを指定するには、このドキュメントの次のいずれかのセクションを選択します。

推奨: インスタンステンプレートを指定する

このセクションでは、インスタンステンプレートを使用して予約のプロパティを定義する方法について説明します。インスタンステンプレートを使用することで、予約のプロパティとその予約を使用できる VM を同じ場所で定義できます。
既存の VM を指定する

このセクションでは、既存の VM を使用して予約のプロパティを定義する方法について説明します。既存の VM のプロパティを使用して、その参照用 VM と一致するプロパティを持つ VM を作成することで、予約を使用できます。
プロパティを直接指定する

このセクションでは、予約のプロパティを直接定義する方法について説明します。この方法では、VM と予約のプロパティが完全に一致していることを手動で確認する必要があります。プロパティが一致しない場合、予約は使用できません。

デフォルトでは、一致するプロパティを持つすべての VM が予約を自動的に使用できます。予約の使用を制御する場合は、次のいずれかを行います。

このドキュメントの次のセクションで説明するように、予約を作成して、その特定の予約をターゲットとする VM のみが使用できるようにします。次に、その特定の予約を使用するように VM を構成します。
予約を使用できない VM を構成します。

また、単一プロジェクトの予約を作成するときにコンパクトプレースメントポリシーを指定できます。コンパクトプレースメントポリシーでは、ネットワークレイテンシを短縮するために、VM を相互にできるだけ近づけることを指定します。

インスタンステンプレートを指定する

インスタンステンプレートを指定して予約を作成するときにエラーが発生しないようにするには、次の点を確認してください。

インスタンステンプレート内のリソースと同じリージョンとゾーンに予約を作成します。インスタンステンプレートで指定されているリージョンリソースやゾーンリソース（マシンタイプや Persistent Disk ボリュームなど）によって、テンプレートの使用はそれらのリソースが存在するロケーションに限定されます。たとえば、インスタンステンプレートでゾーン us-central1-a の既存の Persistent Disk ボリュームを指定した場合、同じゾーンでのみ予約を作成できます。既存のテンプレートに、特定のリージョンまたはゾーンにテンプレートをバインドするリソースが指定されているかどうかを確認するには、インスタンステンプレートについての情報を確認し、その中のリージョンリソースまたはゾーンリソースへの参照を探します。
インスタンステンプレートでコンパクトプレースメントポリシーを指定する場合は、コンパクトプレースメントポリシーにサポートされているマシンタイプもテンプレートで指定するようにしてください。この条件を満たしていない場合、予約の作成は失敗します。

インスタンステンプレートを指定して単一プロジェクトの予約を作成するには、次のいずれかの方法を選択します。

コンソール

Google Cloud コンソールの [予約] ページに移動します。

[予約] に移動
[オンデマンド予約] タブ（デフォルト）で、[ 予約を作成] をクリックします。

[予約の作成] ページが開きます。
[名前] に、予約の名前を入力します。
[リージョン] と [ゾーン] で、リソースを予約する場所を選択します。
[共有タイプ] セクションで、[ローカル] を選択します（まだ選択されていない場合）。
省略可: Vertex AI のカスタムトレーニングジョブまたは予測ジョブで A2 または A3 VM の予約を使用できるようにするには、[Google Cloud サービス] セクションで [予約を共有] を選択します。
[VM インスタンスでの使用] セクションで、次のオプションのいずれかを選択します。
- 一致する VM がこの予約を自動的に使用できるようにするには、[予約を自動的に使用する] を選択します（まだ選択されていない場合）。
- 一致する VM の作成時に、この予約が名前で明示的にターゲットとして指定された場合にのみ、この予約のリソースが使用されるようにするには、[特定の予約を選択する] を選択します。
  
  注: インスタンステンプレートで A3 マシンタイプまたはコンパクトプレースメントポリシーを指定する場合は、[特定の予約を選択する] を選択する必要があります。そうしないと、エラーが発生します。
[VM インスタンスの数] に、予約する VM の数を入力します。
[マシンの構成] セクションで、次の操作を行います。
1. 既存のインスタンステンプレートから VM のプロパティを指定するには、[インスタンステンプレートを使用] を選択します。
2. [インスタンステンプレート] フィールドで、任意のインスタンステンプレートを選択します。リージョンインスタンステンプレートを選択した場合は、インスタンステンプレートのリージョン内のリソースのみを予約できます。
[自動削除] セクションで自動削除オプションを有効にすると、この予約が特定の日時に自動的に削除されます。予約の自動削除を設定しておくと、予約の使用を停止したときに不要な料金が発生しません。
予約を作成するには、[作成] をクリックします。

[予約] ページが開きます。単一プロジェクトの予約の作成が完了するまでに、最長 1 分かかることがあります。

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 は、インスタンステンプレートが配置されているリージョンに置き換えます。リージョンインスタンステンプレートを指定する場合は、テンプレートのリージョンと同じリージョン内の VM のみを予約できます。
INSTANCE_TEMPLATE_NAME: 既存のインスタンステンプレートの名前。インスタンステンプレートで A3 マシンタイプまたはコンパクトプレースメントポリシーを指定する場合は、--require-specific-reservation フラグを含める必要があります。これは、この予約を明示的にターゲットとする VM のみがこの予約を使用できることを意味します。詳細については、特定の予約から VM を使用するをご覧ください。
NUMBER_OF_VMS: 予約する VM の数。
ZONE: リソースを予約するゾーン。

たとえば、グローバルインスタンステンプレートを指定してゾーン us-central1-a で 10 個の VM の予約を作成するには、次のコマンドを実行します。

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

必要に応じて、以下の 1 つ以上の操作を行うことができます。

この予約を明示的にターゲットとする VM のみがこの予約を使用できることを指定するには、--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

Vertex AI のカスタムトレーニングジョブまたは予測ジョブで A2 または A3 VM の予約を使用できるようにするには、gcloud beta compute reservations create コマンドで --reservation-sharing-policy=ALLOW_ALL フラグを指定します。

プレビュー — The --reservation-sharing-policy flag

この機能には、サービス固有の利用規約の「一般的なサービス規約」の「pre-GA サービス規約」が適用されます。 pre-GA の機能は「現状有姿」で利用できますが、サポートが制限される場合があります。詳しくは、リリースステージの説明をご覧ください。
```
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 で予約を自動的に削除できるようにするには、次のいずれかのメソッドを選択します。

プレビュー — The --delete-at-time and --delete-after-duration flags

この機能には、サービス固有の利用規約の「一般的なサービス規約」の「pre-GA サービス規約」が適用されます。 pre-GA の機能は「現状有姿」で利用できますが、サポートが制限される場合があります。詳しくは、リリースステージの説明をご覧ください。
- 特定の日時に予約を削除するには、--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: 24 時間制の 2 桁の時間、2 桁の分、2 桁の秒をコロン（:）で区切った時刻。
  - 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 は、期間（日、時、分、秒）に置き換えます。たとえば、30 分の場合は 30m を指定し、1 日、2 時間、3 分、4 秒の場合は 1d2h3m4s を指定します。

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 void 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()) {

      // Create the reservation.
      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();

      // Wait for the create reservation operation to complete.
      Operation response =
          reservationsClient.insertAsync(projectId, zone, reservation).get(3, TimeUnit.MINUTES);

      if (response.hasError()) {
        System.out.println("Reservation creation failed!" + response);
        return;
      }
      System.out.println("Reservation created. Operation Status: " + response.getStatus());
    }
  }
}

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: 予約する VM の数。
LOCATION: インスタンステンプレートのロケーション。次のいずれかの値を指定します。
- グローバルインスタンステンプレートの場合: global
- リージョンインスタンステンプレートの場合: regions/REGION。REGION は、インスタンステンプレートが配置されているリージョンに置き換えます。リージョンインスタンステンプレートを指定する場合は、テンプレートのリージョンと同じリージョン内の VM のみを予約できます。
INSTANCE_TEMPLATE_NAME: 既存のインスタンステンプレートの名前。インスタンステンプレートで A3 マシンタイプまたはコンパクトプレースメントポリシーを指定する場合は、リクエスト本文に specificReservationRequired フィールドを含め、このフィールドを true に設定する必要があります。これは、この予約を明示的にターゲットとする VM のみがこの予約を使用できることを意味します。詳細については、特定の予約から VM を使用するをご覧ください。

たとえば、グローバルインスタンステンプレートを指定してゾーン us-central1-a で 10 個の VM の予約を作成するには、次の 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"
  }
}

必要に応じて、以下の 1 つ以上の操作を行うことができます。

この予約を明示的にターゲットとする VM のみがこの予約を使用できることを指定するには、リクエスト本文に 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
}

Vertex AI のカスタムトレーニングジョブまたは予測ジョブで A2 または A3 VM の予約を使用できるようにするには、beta.reservations.insert メソッドに POST リクエストを送信します。リクエスト本文に serviceShareType フィールドを追加し、値を ALLOW_ALL に設定します。

プレビュー — The reservationSharingPolicy field

この機能には、サービス固有の利用規約の「一般的なサービス規約」の「pre-GA サービス規約」が適用されます。 pre-GA の機能は「現状有姿」で利用できますが、サポートが制限される場合があります。詳しくは、リリースステージの説明をご覧ください。
```
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 で予約を自動的に削除できるようにするには、次のいずれかのメソッドを選択します。

プレビュー — The deleteAtTime and deleteAfterDuration fields

この機能には、サービス固有の利用規約の「一般的なサービス規約」の「pre-GA サービス規約」が適用されます。 pre-GA の機能は「現状有姿」で利用できますが、サポートが制限される場合があります。詳しくは、リリースステージの説明をご覧ください。
- 特定の日時の予約を削除するには、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: 24 時間制の 2 桁の時間、2 桁の分、2 桁の秒をコロン（:）で区切った時刻。
  - 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 は期間（秒単位）に置き換えます。たとえば、86,400 秒（1 日）の場合は 86400 を指定します。

既存の VM を指定する

既存の VM に基づく予約は、その VM と同じゾーン内にのみ作成できます。

予約を作成した後、参照用 VM と一致するプロパティを持つ VM を作成することで、その予約を使用できます。そのためには、次のいずれかを行います。

次のようにインスタンステンプレートを作成して使用します。
1. 参照用 VM のプロパティをオーバーライドせずに、参照用 VM に基づいてインスタンステンプレートを作成します。
2. 次のいずれかまたは両方を行うと、新しく作成されたテンプレートを使用して VM を作成できます。
  - 単一の VM を作成する
  - ゾーンマネージドインスタンスグループ（MIG）を作成する
参照用 VM に基づいて VM を作成し、新しい VM と参照用 VM のプロパティを完全に一致させます。

既存の VM のプロパティを使用する単一プロジェクトの予約を作成するには、次の操作を行います。

Google Cloud コンソールの [予約] ページに移動します。

[予約] に移動
[予約を作成] をクリックします。

[予約の作成] ページが開きます。
[名前] に、予約の名前を入力します。
[リージョン] と [ゾーン] で、リソースを予約する場所を選択します。
[共有タイプ] セクションで、[ローカル] をクリックします（まだ選択されていない場合）。
[VM インスタンスでの使用] セクションで、次のオプションのいずれかを選択します。
- 一致する VM がこの予約を自動的に使用できるようにするには、[予約を自動的に使用する] を選択します（まだ選択されていない場合）。
- 一致する VM の作成時に、この予約が名前で明示的にターゲットとして指定された場合にのみ、この予約のリソースが使用されるようにするには、[特定の予約を選択する] を選択します。
  
  注: 予約で A3 マシンタイプまたはコンパクトプレースメントポリシーを指定する場合は、[特定の予約を選択する] を選択する必要があります。そうしないと、エラーが発生します。
[VM インスタンスの数] に、予約する VM の数を入力します。
[マシンの構成] セクションで、次の操作を行います。
1. [既存の VM を使用] を選択します。
2. [既存の VM] で、予約の作成に使用するプロパティを持つ VM を選択します。
省略可: 要件を満たす予約に対するコンパクトプレースメントポリシーを指定するには、[グループプレースメントポリシー] セクションで [グループプレースメントポリシーを選択または作成します] リストをクリックしてから、次のいずれかの操作を行います。
- この予約で指定するコンパクトプレースメントポリシーを作成するには、次の操作を行います。
  
  重要: この方法で作成できるのは、最大距離値が指定されていないコンパクトプレースメントポリシーのみです。最大距離値が 3 または 2 の新しいコンパクトプレースメントポリシーを指定する場合は、個別のコンパクトプレースメントポリシーを作成し、その既存のコンパクトプレースメントポリシーを選択する必要があります。
  1. [グループプレースメントポリシーを作成] をクリックします。
    
    [グループプレースメントポリシーを作成] ペインが表示されます。
  2. [ポリシー名] に、ポリシーの名前を入力します。
  3. [作成] をクリックします。
    
    コンパクトプレースメントポリシーの作成には数秒かかることがあります。
- それ以外の場合は、既存のコンパクトプレースメントポリシーを選択します。
[自動削除] セクションで自動削除オプションを有効にすると、この予約が特定の日時に自動的に削除されます。予約の自動削除を設定しておくと、予約の使用を停止したときに不要な料金が発生しません。
予約を作成するには、[作成] をクリックします。

[予約] ページが開きます。予約の作成が完了するまでに、最大 1 分かかることがあります。

プロパティを直接指定する

プロパティを直接指定して単一プロジェクトの予約を作成するには、次のいずれかの方法を選択します。

コンソール

Google Cloud コンソールの [予約] ページに移動します。

[予約] に移動
[オンデマンド予約] タブ（デフォルト）で、[ 予約を作成] をクリックします。

[予約の作成] ページが開きます。
[名前] に、予約の名前を入力します。
[リージョン] と [ゾーン] で、リソースを予約する場所を選択します。
[共有タイプ] セクションで、[ローカル] をクリックします（まだ選択されていない場合）。
省略可: Vertex AI のカスタムトレーニングジョブまたは予測ジョブで A2 または A3 VM の予約を使用できるようにするには、[Google Cloud サービス] セクションで [予約を共有] を選択します。
[VM インスタンスでの使用] セクションで、次のオプションのいずれかを選択します。
- 一致する VM がこの予約を自動的に使用できるようにするには、[予約を自動的に使用する] を選択します（まだ選択されていない場合）。
- 一致する VM の作成時に、この予約が名前で明示的にターゲットとして指定された場合にのみ、この予約のリソースが使用されるようにするには、[特定の予約を選択する] を選択します。
  
  注: 予約で A3 マシンタイプまたはコンパクトプレースメントポリシーを指定する場合は、[特定の予約を選択する] を選択する必要があります。そうしないと、エラーが発生します。
[VM インスタンスの数] に、予約する VM の数を入力します。
[マシンの構成] セクションで、[マシンタイプを指定] を選択し、次の項目を指定します。
1. [マシンファミリー]、[シリーズ]、[マシンタイプ] で、マシンファミリー、シリーズ、マシンタイプを選択します。
2. 省略可: 最小 CPU プラットフォームを指定するか、GPU を N1 VM に接続するには、次の操作を行います。
  1. [CPU プラットフォームと GPU] セクションを展開するには、展開矢印をクリックします。
  2. 省略可: 最小 CPU プラットフォームを指定するには、[CPU プラットフォーム] でいずれかのオプションを選択します。
  3. 省略可: N1 VM に GPU を接続するには、[GPU を追加] をクリックします。次に、[GPU タイプ] と [GPU の数] で、各 N1 VM に接続する GPU のタイプと数を選択します。
3. 省略可: ローカル SSD ディスクを追加するには、次の操作を行います。
  1. [ディスク数] で、各 VM のローカル SSD ディスクの数を選択します。
  2. [インターフェースタイプ] で、ローカル SSD ディスクのインターフェースを選択します。
4. 省略可: 要件を満たす予約のコンパクトプレースメントポリシーを指定するには、[グループプレースメントポリシーを選択または作成します] リストをクリックして、次のいずれかの操作を行います。
  - コンパクトプレースメントポリシーを作成してこの予約で指定するには、次の操作を行います。
    
    重要: この方法を使用すると、指定されていない max-distance を含むコンパクトプレースメントポリシーのみを作成できます。max-distance の値が 3 または 2 の新しいコンパクトプレースメントポリシーを指定する場合は、個別のコンパクトプレースメントポリシーを作成し、既存のコンパクトプレースメントポリシーを選択する必要があります。
    1. [グループプレースメントポリシーを作成] をクリックします。
      
      [グループプレースメントポリシーを作成] ペインが表示されます。
    2. [ポリシー名] に、ポリシーの名前を入力します。
    3. [作成] をクリックします。
      
      コンパクトプレースメントポリシーの作成には数秒かかることがあります。
  - それ以外の場合は、既存のコンパクトプレースメントポリシーを選択します。
省略可: 要件を満たす予約に対するコンパクトプレースメントポリシーを指定するには、[グループプレースメントポリシー] セクションで [グループプレースメントポリシーを選択または作成します] リストをクリックしてから、次のいずれかの操作を行います。
- この予約で指定するコンパクトプレースメントポリシーを作成するには、次の操作を行います。
  
  重要: この方法で作成できるのは、最大距離値が指定されていないコンパクトプレースメントポリシーのみです。最大距離値が 3 または 2 の新しいコンパクトプレースメントポリシーを指定する場合は、個別のコンパクトプレースメントポリシーを作成し、その既存のコンパクトプレースメントポリシーを選択する必要があります。
  1. [グループプレースメントポリシーを作成] をクリックします。
    
    [グループプレースメントポリシーを作成] ペインが表示されます。
  2. [ポリシー名] に、ポリシーの名前を入力します。
  3. [作成] をクリックします。
    
    コンパクトプレースメントポリシーの作成には数秒かかることがあります。
- それ以外の場合は、既存のコンパクトプレースメントポリシーを選択します。
[自動削除] セクションで自動削除オプションを有効にすると、この予約が特定の日時に自動的に削除されます。予約の自動削除を設定しておくと、予約の使用を停止したときに不要な料金が発生しません。
予約を作成するには、[作成] をクリックします。

[予約] ページが開きます。単一プロジェクトの予約の作成が完了するまでに、最長 1 分かかることがあります。

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: 各 VM に使用するマシンタイプ。A3 マシンタイプを指定する場合は、--require-specific-reservation フラグを含める必要があります。これは、この予約を明示的にターゲットとする VM のみがこの予約を使用できることを意味します。詳細については、特定の予約から VM を使用するをご覧ください。
NUMBER_OF_VMS: 予約する VM の数。
ZONE: リソースを予約するゾーン。

たとえば、ゾーン us-central1-a で 10 個の VM（各 VM は、4 つの vCPU を備えた事前定義されたマシンタイプ N2 を使用）の予約を作成するには、次のコマンドを実行します。

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

必要に応じて、以下の 1 つ以上の操作を行うことができます。

予約済みの N1 VM に GPU を接続するには、--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
```
次のように置き換えます。
- NUMBER_OF_ACCELERATORS: 追加する GPU の数（予約済み VM あたり）。
- ACCELERATOR_TYPE: N1 VM でサポートされている GPU モデル。リソースを予約するゾーンで GPU モデルを使用できることを確認します。この条件を満たしていない場合、予約の作成は失敗します。
予約する各 VM に 1 つ以上のローカル SSD ディスクを追加するには、1 つ以上の --local-ssd フラグを指定します。ローカル SSD ディスクは 24 個まで指定できます。各ローカル SSD ディスクは 375 GB です。

たとえば、予約の作成時に 2 つのローカル SSD を指定するには、次のように 2 つの --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_1 と INTERFACE_2 は、各ローカル SSD ディスクで使用するインターフェースのタイプに置き換えます。次のいずれかの値を指定します。
- NVME ディスクインターフェース: nvme
- SCSI ディスクインターフェース: scsi
予約済み VM に指定したマシンタイプが、選択したディスクインターフェースをサポートしていることを確認します。この条件を満たしていない場合、予約の作成は失敗します。詳細については、ディスクインターフェースの選択方法をご覧ください。
予約する VM でゾーンのデフォルトの 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 プラットフォームを表示します。
この予約を明示的にターゲットとする VM のみがこの予約を使用できることを指定するには、--require-specific-reservation フラグを指定します。
```
gcloud compute reservations create RESERVATION_NAME \
    --machine-type=MACHINE_TYPE \
    --require-specific-reservation \
    --vm-count=NUMBER_OF_VMS \
    --zone=ZONE
```
VM 間のネットワークレイテンシを短縮するためにコンパクトプレースメントポリシーを指定するには、--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 は、既存のコンパクトプレースメントポリシーの名前に置き換えます。また、コンパクトプレースメントポリシーを指定する単一プロジェクト予約を作成するときにエラーを回避するため、次の項目を指定します。
- コンパクトプレースメントポリシーでサポートされているマシンタイプと VM の最大数。
- コンパクトプレースメントポリシーが配置されているリージョン内のゾーン。
- --require-specific-reservation フラグ。これは、この予約を明示的にターゲットとする VM のみがこの予約を使用できることを意味します。
Vertex AI のカスタムトレーニングジョブまたは予測ジョブで A2 または A3 VM の予約を使用できるようにするには、gcloud beta compute reservations create コマンドで --reservation-sharing-policy=ALLOW_ALL フラグを指定します。

プレビュー — The --reservation-sharing-policy flag

この機能には、サービス固有の利用規約の「一般的なサービス規約」の「pre-GA サービス規約」が適用されます。 pre-GA の機能は「現状有姿」で利用できますが、サポートが制限される場合があります。詳しくは、リリースステージの説明をご覧ください。
```
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 で予約を自動的に削除できるようにするには、次のいずれかのメソッドを選択します。

プレビュー — The --delete-at-time and --delete-after-duration flags

この機能には、サービス固有の利用規約の「一般的なサービス規約」の「pre-GA サービス規約」が適用されます。 pre-GA の機能は「現状有姿」で利用できますが、サポートが制限される場合があります。詳しくは、リリースステージの説明をご覧ください。
- 特定の日時に予約を削除するには、--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: 24 時間制の 2 桁の時間、2 桁の分、2 桁の秒をコロン（:）で区切った時刻。
  - 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 は、期間（日、時、分、秒）に置き換えます。たとえば、30 分の場合は 30m を指定し、1 日、2 時間、3 分、4 秒の場合は 1d2h3m4s を指定します。

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

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 void createReservation(
      String projectId, String reservationName, 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()) {

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

      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();

      // Wait for the create reservation operation to complete.
      Operation response =
          reservationsClient.insertAsync(projectId, zone, reservation).get(7, TimeUnit.MINUTES);

      if (response.hasError()) {
        System.out.println("Reservation creation failed!" + response);
        return;
      }
      System.out.println("Reservation created. Operation Status: " + response.getStatus());
    }
  }
}

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,
        ),
        specific_reservation_required=True,
    )

    # 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 を備えた 1 つの 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 の使用方法の詳細については、Google Cloud で Terraform を使用するをご覧ください。

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: 予約する VM の数。
MACHINE_TYPE: 各 VM に使用するマシンタイプ。A3 マシンタイプを指定する場合は、リクエスト本文に specificReservationRequired フィールドを含め、フィールドを true に設定する必要があります。これは、この予約を明示的にターゲットとする VM のみがこの予約を使用できることを意味します。詳細については、特定の予約から VM を使用するをご覧ください。

たとえば、ゾーン us-central1-a で 10 個の VM（各 VM は、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",
    }
  }
}

必要に応じて、以下の 1 つ以上の操作を行うことができます。

予約済みの N1 VM に GPU を接続するには、リクエスト本文に 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"
    }
  }
}

次のように置き換えます。

NUMBER_OF_ACCELERATORS: 追加する GPU の数（予約済み VM あたり）。
ACCELERATOR_TYPE: N1 VM でサポートされている GPU モデル。リソースを予約するゾーンで GPU モデルを使用できることを確認します。この条件を満たしていない場合、予約の作成は失敗します。

予約する各 VM に 1 つ以上のローカル SSD ディスクを追加するには、リクエスト本文に localSsds フィールドを含めます。ローカル SSD ディスクは 24 個まで指定できます。各ローカル SSD ディスクは 375 GB です。

たとえば、予約の作成時に 2 つのローカル 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_1 と INTERFACE_2 は、各ローカル SSD ディスクで使用するインターフェースのタイプに置き換えます。次のいずれかの値を指定します。
- NVME ディスクインターフェース: NVME
- SCSI ディスクインターフェース: SCSI
予約済み VM に指定したマシンタイプが、選択したディスクインターフェースをサポートしていることを確認します。この条件を満たしていない場合、予約の作成は失敗します。詳細については、ディスクインターフェースの選択方法をご覧ください。
予約する VM でゾーンのデフォルトの 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 プラットフォームを表示します。
予約する VM 間のネットワークレイテンシを短縮するためにコンパクトプレースメントポリシーを指定するには、リクエスト本文に 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: 既存のコンパクトプレースメントポリシーの名前。
また、コンパクトプレースメントポリシーを指定する単一プロジェクト予約を作成するときにエラーを回避するため、次の項目を指定します。
- コンパクトプレースメントポリシーでサポートされているマシンタイプ。
- true に設定されている specificReservationRequired フィールド。これは、この予約を明示的にターゲットとする VM のみがこの予約を使用できることを意味します。

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
}

Vertex AI のカスタムトレーニングジョブまたは予測ジョブで A2 または A3 VM の予約を使用できるようにするには、beta.reservations.insert メソッドに POST リクエストを送信します。リクエスト本文に serviceShareType フィールドを追加し、値を ALLOW_ALL に設定します。

プレビュー — The reservationSharingPolicy field

この機能には、サービス固有の利用規約の「一般的なサービス規約」の「pre-GA サービス規約」が適用されます。 pre-GA の機能は「現状有姿」で利用できますが、サポートが制限される場合があります。詳しくは、リリースステージの説明をご覧ください。
```
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 で予約を自動的に削除できるようにするには、次のいずれかのメソッドを選択します。

プレビュー — The deleteAtTime and deleteAfterDuration fields

この機能には、サービス固有の利用規約の「一般的なサービス規約」の「pre-GA サービス規約」が適用されます。 pre-GA の機能は「現状有姿」で利用できますが、サポートが制限される場合があります。詳しくは、リリースステージの説明をご覧ください。
- 特定の日時の予約を削除するには、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: 24 時間制の 2 桁の時間、2 桁の分、2 桁の秒をコロン（:）で区切った時刻。
  - 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 は期間（秒単位）に置き換えます。たとえば、86,400 秒（1 日）の場合は 86400 を指定します。

トラブルシューティング

予約の作成に関するトラブルシューティング方法を確認してください。

次のステップ

予約を表示する方法を確認する。
コミットメントに予約を関連付ける方法を学習する。
予約を使用する方法を学習する。
予約の使用量をモニタリングする方法を確認する。

単一プロジェクトの予約を作成する

始める前に

Console

gcloud

Terraform

REST

必要なロール

必要な権限

単一プロジェクトの予約を作成する

インスタンス テンプレートを指定する

コンソール

gcloud

Go

Java

Node.js

Python

REST

既存の VM を指定する

プロパティを直接指定する

コンソール

gcloud

Go

Java

Node.js

Python

Terraform

REST

トラブルシューティング

次のステップ

インスタンステンプレートを指定する