コンピューティング インスタンスが予約を使用しないようにする

---

このドキュメントでは、Compute Engine インスタンスが予約を使用しないようにする方法について説明します。予約の詳細については、Compute Engine ゾーンリソースの予約をご覧ください。

自動的に使用される予約を使用すると、予約に一致するプロパティを持つインスタンスが予約を自動的に使用できます。インスタンスが予約を使用しないようにするには、次のいずれかを行います。

• このドキュメントの説明に従って、予約を使用しないインスタンスを構成します。

• 予約と一致しないプロパティを持つインスタンスを作成または更新します。

テスト、デバッグ、分離されたデプロイなどのタスクにインスタンスを使用する場合は、予約を使用しないようにできます。

制限事項

予約を使用しないように既存のインスタンスを更新できるのは、インスタンスが一致する予約を自動的に使用するように構成されている場合のみです。

始める前に

• まだ設定していない場合は、認証を設定します。認証とは、サービスと API にアクセスするために ID を確認するプロセスです。 Google Cloud ローカル開発環境からコードまたはサンプルを実行するには、次のいずれかのオプションを選択して 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.

  Go

  ローカル開発環境でこのページの Go サンプルを使用するには、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 をご覧ください。

  Java

  ローカル開発環境でこのページの Java サンプルを使用するには、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 をご覧ください。

  Node.js

  ローカル開発環境でこのページの Node.js サンプルを使用するには、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 をご覧ください。

  Python

  ローカル開発環境でこのページの Python サンプルを使用するには、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 インスタンス管理者（v1） （roles/compute.instanceAdmin.v1）IAM ロールを付与するよう管理者に依頼します。ロールの付与については、プロジェクト、フォルダ、組織へのアクセスを管理するをご覧ください。

この事前定義ロールには、コンピューティング インスタンスが予約を使用しないようにするために必要な権限が含まれています。必要とされる正確な権限については、「必要な権限」セクションを開いてご確認ください。

必要な権限

コンピューティング インスタンスが予約を使用しないようにするには、次の権限が必要です。

• 予約を作成する権限: プロジェクトに対する compute.reservations.create
• インスタンスを作成するには:
  • プロジェクトに対する compute.instances.create
  • カスタム イメージを使用して VM を作成する: イメージに対する compute.images.useReadOnly
  • スナップショットを使用して VM を作成する: スナップショットに対する compute.snapshots.useReadOnly
  • インスタンス テンプレートを使用して VM を作成する: インスタンス テンプレートに対する compute.instanceTemplates.useReadOnly
  • レガシー ネットワークを VM に割り当てる: プロジェクトに対する compute.networks.use
  • VM の静的 IP アドレスを指定する: プロジェクトに対する compute.addresses.use
  • レガシー ネットワークの使用時に VM に外部 IP アドレスを割り当てる: プロジェクトに対する compute.networks.useExternalIp
  • VM のサブネットを指定する: プロジェクトまたは選択したサブネットに対する compute.subnetworks.use
  • VPC ネットワークの使用時に VM に外部 IP アドレスを割り当てる: プロジェクトまたは選択したサブネットに対する compute.subnetworks.useExternalIp
  • VM の VM インスタンス メタデータを設定する: プロジェクトに対する compute.instances.setMetadata
  • VM にタグを設定する: VM に対する compute.instances.setTags
  • VM にラベルを設定する: VM に対する compute.instances.setLabels
  • VM が使用するサービス アカウントを設定する: VM に対する compute.instances.setServiceAccount
  • VM に新しいディスクを作成する: プロジェクトに対する compute.disks.create
  • 既存のディスクを読み取り専用モードまたは読み取り / 書き込みモードでアタッチする: ディスクに対する compute.disks.use
  • 既存のディスクを読み取り専用モードでアタッチする: ディスクに対する compute.disks.useReadOnly
• インスタンス テンプレートを作成する: プロジェクトに対する compute.instanceTemplates.create

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

予約の使用を防ぐ

コンピューティング インスタンスが予約を使用しないようにするには、予約アフィニティ（reservationAffinity）プロパティを予約を使用しないように設定します。このプロパティは、インスタンスが一致する予約、特定の予約、または予約をまったく使用できないかどうかを制御します。

1 つ以上のインスタンスが予約を使用しないようにするには、次のいずれかの方法を使用します。

• 既存のインスタンスでの使用を防止する

• インスタンスの作成中に使用を防止する

• インスタンスの一括作成中に使用を防止する

• インスタンス テンプレートの作成中に使用を防止する

既存のインスタンスでの使用を防止する

実行中のインスタンスを更新して、予約が自動的に消費されないようにすることができます。変更を有効にするには、このセクションで説明するようにインスタンスを再起動する必要があります。

既存のインスタンスが予約を使用しないようにするには、次のいずれかのオプションを選択します。

gcloud

1. 空の YAML ファイルを作成します。

2. 作成したばかりの YAML ファイルにインスタンスのプロパティをエクスポートするには、gcloud compute instances export コマンドを使用します。

   gcloud compute instances export INSTANCE_NAME \
       --destination=YAML_FILE \
       --zone=ZONE
   

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

   • INSTANCE_NAME: インスタンスの名前。

   • YAML_FILE: 前の手順で作成した空の YAML ファイルのパス。

   • ZONE: インスタンスが存在するゾーン。

3. YAML 構成ファイルで、consumeReservationType を NO_RESERVATION に設定します。

   reservationAffinity:
     consumeReservationType: NO_RESERVATION
   

4. インスタンスを更新して再起動するには、--most-disruptive-allowed-action フラグを RESTART に設定して gcloud compute instances update-from-file コマンドを使用します。

   gcloud compute instances update-from-file INSTANCE_NAME \
       --most-disruptive-allowed-action=RESTART \
       --source=YAML_FILE \
       --zone=ZONE
   

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

   • INSTANCE_NAME: インスタンスの名前。

   • YAML_FILE: 前の手順で変更した構成データを含む YAML ファイルのパス。

   • ZONE: インスタンスが存在するゾーン。

REST

1. 既存のインスタンスの属性を表示するには、instances.get メソッドに GET リクエストを送信します。

   GET https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/zones/ZONE/instances/INSTANCE_NAME
   

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

   • PROJECT_ID: インスタンスが作成されたプロジェクトの ID。

   • ZONE: インスタンスが存在するゾーン。

   • INSTANCE_NAME: インスタンスの名前。

2. GET リクエストの出力をファイルまたはテキスト エディタに保存します。コピーした出力を変更して、consumeReservationType フィールドを NO_RESERVATION に変更します。

   {
     ...
     "reservationAffinity": {
       "consumeReservationType": "NO_RESERVATION"
     },
     ...
   }
   

3. インスタンスを更新して再起動するには、instances.update メソッドに PUT リクエストを送信します。リクエストで、次の操作を行います。

   • リクエスト URL に、RESTART に設定された mostDisruptiveAllowedAction クエリ パラメータを含めます。

   • リクエスト本文には、前の手順で編集した GET リクエストの出力を使用します。

   リクエストは次の例のようになります。

   PUT https://compute.googleapis.com/compute/v1/projects/example-project/zones/us-central-1/instances/instance-01?mostDisruptiveAllowedAction=RESTART
   
   {
     ...
     "reservationAffinity": {
       "consumeReservationType": "NO_RESERVATION"
     },
     ...
   }
   

インスタンスの更新の詳細については、インスタンス プロパティを更新するをご覧ください。

インスタンスの作成中に使用を防止する

予約を使用できないコンピューティング インスタンスを作成するには、次のいずれかのオプションを選択します。

コンソール

1. Google Cloud コンソールで、[インスタンスの作成] ページに移動します。

   [インスタンスの作成] に移動

2. [名前] フィールドに、インスタンスの名前を入力します。

3. [リージョン] リストと [ゾーン] リストで、インスタンスを作成するリージョンとゾーンを選択します。

4. インスタンスに使用するマシンタイプを指定します。

5. ナビゲーション メニューで [詳細設定] をクリックします。

6. [予約] セクションで、[予約を使用しない] を選択します。

7. [作成] をクリックします。

gcloud

予約を使用できないインスタンスを作成するには、--reservation-affinity フラグを none に設定して gcloud compute instances create コマンドを使用します。

gcloud compute instances create INSTANCE_NAME \
    --machine-type=MACHINE_TYPE \
    --reservation-affinity=none \
    --zone=ZONE

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

• INSTANCE_NAME: インスタンスの名前。

• MACHINE_TYPE: インスタンスに使用するマシンタイプ。

• ZONE: インスタンスを作成するゾーン。

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

// createInstanceNotConsumeReservation creates VM, without consuming reservation
func createInstanceNotConsumeReservation(w io.Writer, projectID, zone, instanceName string) error {
	ctx := context.Background()
	machineType := fmt.Sprintf("zones/%s/machineTypes/%s", zone, "n2-standard-32")
	sourceImage := "projects/debian-cloud/global/images/family/debian-12"

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

	req := &computepb.InsertInstanceRequest{
		Project: projectID,
		Zone:    zone,
		InstanceResource: &computepb.Instance{
			Disks: []*computepb.AttachedDisk{
				{
					InitializeParams: &computepb.AttachedDiskInitializeParams{
						DiskSizeGb:  proto.Int64(10),
						SourceImage: proto.String(sourceImage),
					},
					AutoDelete: proto.Bool(true),
					Boot:       proto.Bool(true),
					Type:       proto.String(computepb.AttachedDisk_PERSISTENT.String()),
				},
			},
			MachineType:    proto.String(machineType),
			MinCpuPlatform: proto.String("Intel Cascade Lake"),
			Name:           proto.String(instanceName),
			NetworkInterfaces: []*computepb.NetworkInterface{
				{
					Name: proto.String("global/networks/default"),
				},
			},
			ReservationAffinity: &computepb.ReservationAffinity{
				ConsumeReservationType: proto.String("NO_RESERVATION"),
			},
		},
	}

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

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

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

	return nil
}

Java

予約を使用できないインスタンスを作成するには、次のコードサンプルを使用します。

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

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

public class CreateInstanceWithoutConsumingReservation {
  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 you want to use.
    String zone = "us-central1-a";
    // Name of the VM instance you want to query.
    String instanceName = "YOUR_INSTANCE_NAME";
    // machineType: machine type of the VM being created.
    // *   This value uses the format zones/{zone}/machineTypes/{type_name}.
    // *   For a list of machine types, see https://cloud.google.com/compute/docs/machine-types
    String machineTypeName = "n1-standard-1";
    // sourceImage: path to the operating system image to mount.
    // *   For details about images you can mount, see https://cloud.google.com/compute/docs/images
    String sourceImage = "projects/debian-cloud/global/images/family/debian-11";
    // diskSizeGb: storage size of the boot disk to attach to the instance.
    long diskSizeGb = 10L;
    // networkName: network interface to associate with the instance.
    String networkName = "default";

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

  // Create a virtual machine that explicitly doesn't consume reservations
  public static Instance createInstanceWithoutConsumingReservationAsync(
      String project, String zone, String instanceName,
      String machineTypeName, String sourceImage, long diskSizeGb, String networkName)
      throws IOException, InterruptedException, ExecutionException, TimeoutException {
    String machineType = String.format("zones/%s/machineTypes/%s", zone, machineTypeName);

    // Initialize client that will be used to send requests. This client only needs to be created
    // once, and can be reused for multiple requests.
    try (InstancesClient instancesClient = InstancesClient.create()) {
      AttachedDisk disk =
          AttachedDisk.newBuilder()
              .setBoot(true)
              .setAutoDelete(true)
              .setType(AttachedDisk.Type.PERSISTENT.toString())
              .setDeviceName("disk-1")
              .setInitializeParams(
                  AttachedDiskInitializeParams.newBuilder()
                      .setSourceImage(sourceImage)
                      .setDiskSizeGb(diskSizeGb)
                      .build())
              .build();

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

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

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

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

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

      // Wait for the operation to complete.
      Operation response = operation.get(3, TimeUnit.MINUTES);

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

Node.js

予約を使用できないインスタンスを作成するには、次のコードサンプルを使用します。

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

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

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

// Create a VM that explicitly doesn't consume reservations
async function callCreateInstanceToNotConsumeReservation() {
  // Describe the size and source image of the boot disk to attach to the instance.
  const disk = new compute.Disk({
    boot: true,
    autoDelete: true,
    type: 'PERSISTENT',
    initializeParams: {
      diskSizeGb: '10',
      sourceImage: 'projects/debian-cloud/global/images/family/debian-12',
    },
  });

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

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

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

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

  let operation = response.latestResponse;

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

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

await callCreateInstanceToNotConsumeReservation();

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_vm_not_consume_reservation(
    project_id: str, zone: str, instance_name: str, machine_type: str = "n2-standard-2"
) -> compute_v1.Instance:
    """Creates a VM that explicitly doesn't consume reservations
    Args:
        project_id (str): The ID of the Google Cloud project.
        zone (str): The zone where the VM will be created.
        instance_name (str): The name of the instance to create.
        machine_type (str, optional): The machine type for the instance.
    Returns:
        compute_v1.Instance: The created instance.
    """
    instance = compute_v1.Instance()
    instance.name = instance_name
    instance.machine_type = f"zones/{zone}/machineTypes/{machine_type}"
    instance.zone = zone

    instance.disks = [
        compute_v1.AttachedDisk(
            boot=True,  # Indicates that this is a boot disk
            auto_delete=True,  # The disk will be deleted when the instance is deleted
            initialize_params=compute_v1.AttachedDiskInitializeParams(
                source_image="projects/debian-cloud/global/images/family/debian-11",
                disk_size_gb=10,
            ),
        )
    ]

    instance.network_interfaces = [
        compute_v1.NetworkInterface(
            network="global/networks/default",  # The network to use
            access_configs=[
                compute_v1.AccessConfig(
                    name="External NAT",  # Name of the access configuration
                    type="ONE_TO_ONE_NAT",  # Type of access configuration
                )
            ],
        )
    ]

    # Set the reservation affinity to not consume any reservation
    instance.reservation_affinity = compute_v1.ReservationAffinity(
        consume_reservation_type="NO_RESERVATION",  # Prevents the instance from consuming reservations
    )

    # Create a request to insert the instance
    request = compute_v1.InsertInstanceRequest()
    request.zone = zone
    request.project = project_id
    request.instance_resource = instance

    vm_client = compute_v1.InstancesClient()
    operation = vm_client.insert(request)
    wait_for_extended_operation(operation, "Instance creation")

    print(f"Creating the {instance_name} instance in {zone}...")

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

REST

予約を消費できないインスタンスを作成するには、instances.insert メソッドに POST リクエストを送信します。リクエストの本文に、NO_RESERVATION に設定された consumeReservationType フィールドを含めます。

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

{
  "name": "INSTANCE_NAME",
  "machineType": "zones/ZONE/machineTypes/MACHINE_TYPE",
  "disks": [
    {
      "boot": true,
      "initializeParams": {
        "sourceImage": "projects/IMAGE_PROJECT/global/images/IMAGE"
      }
    }
  ],
  "networkInterfaces": [
    {
      "network": "global/networks/default"
    }
  ],
  "reservationAffinity": {
    "consumeReservationType": "NO_RESERVATION"
  }
}

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

• PROJECT_ID: インスタンスを作成するプロジェクトの ID。

• ZONE: インスタンスを作成するゾーン。

• INSTANCE_NAME: インスタンスの名前。

• MACHINE_TYPE: インスタンスに使用するマシンタイプ。

• IMAGE_PROJECT: OS イメージを含むイメージ プロジェクト（例: debian-cloud）。サポートされているイメージ プロジェクトの詳細については、公開イメージをご覧ください。

• IMAGE: 次のいずれかを指定します。

  • OS イメージの特定のバージョン。例: debian-12-bookworm-v20240617。

  • イメージ ファミリー。family/IMAGE_FAMILY の形式にする必要があります。これにより、非推奨ではない最新の OS イメージが指定されます。たとえば、family/debian-12 を指定すると、Debian 12 イメージ ファミリーの最新バージョンが使用されます。イメージ ファミリーの使用の詳細については、イメージ ファミリーのベスト プラクティスをご覧ください。

インスタンスの作成の詳細については、Compute Engine インスタンスの作成と開始をご覧ください。

インスタンスの一括作成中に使用を防止する

予約を使用できないコンピューティング インスタンスを一括作成するには、次のいずれかのオプションを選択します。

gcloud

予約を使用できないインスタンスを一括で作成するには、--reservation-affinity フラグを none に設定して gcloud compute instances bulk create コマンドを使用します。

たとえば、単一のゾーンでインスタンスを一括作成し、名前パターンを指定するには、次のコマンドを実行します。

gcloud compute instances bulk create \
    --count=COUNT \
    --machine-type=MACHINE_TYPE \
    --name-pattern="NAME_PATTERN" \
    --reservation-affinity=none \
    --zone=ZONE

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

• COUNT: 作成するインスタンスの数。

• MACHINE_TYPE: インスタンスに使用するマシンタイプ。

• NAME_PATTERN: インスタンスの名前パターン。インスタンス名の一連の数字を置き換えるには、一連のハッシュ（#）文字を使用します。たとえば、名前パターンに instance-# を使用すると、instance-1、instance-2 で始まり、COUNT で指定されたインスタンスの数まで続く名前のインスタンスが生成されます。

• ZONE: インスタンスを一括作成するゾーン。

REST

予約を消費できないインスタンスを一括作成するには、instances.bulkInsert メソッドに POST リクエストを送信します。リクエストの本文に、NO_RESERVATION に設定された consumeReservationType フィールドを含めます。

たとえば、単一のゾーンでインスタンスを一括作成し、名前パターンを指定するには、次のようにリクエストを送信します。

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

{
  "count": COUNT,
  "namePattern": "NAME_PATTERN",
  "instanceProperties": {
    "machineType": "MACHINE_TYPE",
    "disks": [
      {
        "boot": true,
        "initializeParams": {
          "sourceImage": "projects/IMAGE_PROJECT/global/images/IMAGE"
        }
      }
    ],
    "networkInterfaces": [
      {
        "network": "global/networks/default"
      }
    ],
    "reservationAffinity": {
      "consumeReservationType": "NO_RESERVATION"
    }
  }
}

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

• PROJECT_ID: インスタンスを一括作成するプロジェクトの ID。

• ZONE: インスタンスを一括作成するゾーン。

• COUNT: 作成するインスタンスの数。

• NAME_PATTERN: インスタンスの名前パターン。インスタンス名の一連の数字を置き換えるには、一連のハッシュ（#）文字を使用します。たとえば、名前パターンに instance-# を使用すると、instance-1、instance-2 で始まり、COUNT で指定されたインスタンスの数まで続く名前のインスタンスが生成されます。

• MACHINE_TYPE: インスタンスに使用するマシンタイプ。

• IMAGE_PROJECT: OS イメージを含むイメージ プロジェクト（例: debian-cloud）。サポートされているイメージ プロジェクトの詳細については、公開イメージをご覧ください。

• IMAGE: 次のいずれかを指定します。

  • OS イメージの特定のバージョン。例: debian-12-bookworm-v20240617。

  • イメージ ファミリー。family/IMAGE_FAMILY の形式にする必要があります。これにより、非推奨ではない最新の OS イメージが指定されます。たとえば、family/debian-12 を指定すると、Debian 12 イメージ ファミリーの最新バージョンが使用されます。イメージ ファミリーの使用の詳細については、イメージ ファミリーのベスト プラクティスをご覧ください。

インスタンスを一括作成する方法の詳細については、VM を一括作成するをご覧ください。

インスタンス テンプレートの作成中に使用を防止する

予約を使用しないようにインスタンスを構成するインスタンス テンプレートを作成すると、そのテンプレートを使用して次のことができます。

• 次の操作を行うときに、マネージド インスタンス グループ（MIG）のコンピューティング インスタンスが予約を使用しないようにします。

  • MIG を作成する

  • MIG で新しいインスタンス構成を適用する

• 予約を使用しないインスタンスを作成する

予約を使用しないインスタンスを構成するインスタンス テンプレートを作成するには、次のいずれかのオプションを選択します。

コンソール

1. Google Cloud コンソールで、[インスタンス テンプレートの作成] ページに移動します。

   [インスタンス テンプレートの作成] に移動

2. [名前] フィールドに、インスタンス テンプレートの名前を入力します。

3. [ロケーション] セクションで、リージョン（デフォルト）またはグローバルのインスタンス テンプレートを作成するかどうかを指定します。

4. [マシンの構成] セクションで、テンプレートを使用して作成するインスタンスに使用するマシンタイプを指定します。

5. [詳細オプション] セクションを開き、次の操作を行います。

   1. [管理] セクションを開きます。

   2. [予約] セクションで、[予約を使用しない] を選択します。

6. [作成] をクリックします。

gcloud

予約を使用しないようにインスタンスを構成するインスタンス テンプレートを作成するには、--reservation-affinity フラグを none に設定して gcloud compute instances-templates create コマンドを使用します。

予約を使用しないようにインスタンスを構成するリージョン インスタンス テンプレートを作成するには、次のコマンドを実行します。グローバル インスタンス テンプレートを作成する場合は、--instance-template-region フラグを使用せずに同じコマンドを使用します。

gcloud compute instance-templates create INSTANCE_TEMPLATE_NAME \
    --instance-template-region=REGION \
    --machine-type=MACHINE_TYPE \
    --reservation-affinity=none

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

• INSTANCE_TEMPLATE_NAME: インスタンス テンプレートの名前。

• REGION: インスタンス テンプレートを作成するリージョン。

• MACHINE_TYPE: インスタンス テンプレートを使用して作成されたインスタンスに使用するマシンタイプ。

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

// createInstanceNotConsumeReservation creates a new instance template, which won't consume reservations
func createTemplateNotConsumeReservation(w io.Writer, projectID, templateName string) error {
	// projectID := "your_project_id"
	// templateName := "your_template_name"

	ctx := context.Background()
	instanceTemplatesClient, err := compute.NewInstanceTemplatesRESTClient(ctx)
	if err != nil {
		return fmt.Errorf("NewInstanceTemplatesRESTClient: %w", err)
	}
	defer instanceTemplatesClient.Close()

	req := &computepb.InsertInstanceTemplateRequest{
		Project: projectID,
		InstanceTemplateResource: &computepb.InstanceTemplate{
			Name: proto.String(templateName),
			Properties: &computepb.InstanceProperties{
				// The template describes the size and source image of the boot disk
				// to attach to the instance.
				Disks: []*computepb.AttachedDisk{
					{
						InitializeParams: &computepb.AttachedDiskInitializeParams{
							DiskSizeGb:  proto.Int64(250),
							SourceImage: proto.String("projects/debian-cloud/global/images/family/debian-11"),
						},
						AutoDelete: proto.Bool(true),
						Boot:       proto.Bool(true),
					},
				},
				MachineType: proto.String("e2-standard-4"),
				// The template connects the instance to the `default` network,
				// without specifying a subnetwork.
				NetworkInterfaces: []*computepb.NetworkInterface{
					{
						Name: proto.String("global/networks/default"),
						// The template lets the instance use an external IP address.
						AccessConfigs: []*computepb.AccessConfig{
							{
								Name:        proto.String("External NAT"),
								Type:        proto.String(computepb.AccessConfig_ONE_TO_ONE_NAT.String()),
								NetworkTier: proto.String(computepb.AccessConfig_PREMIUM.String()),
							},
						},
					},
				},
				ReservationAffinity: &computepb.ReservationAffinity{
					ConsumeReservationType: proto.String("NO_RESERVATION"),
				},
			},
		},
	}

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

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

	fmt.Fprintf(w, "Instance template created\n")

	return nil
}

Java

予約を使用しないインスタンスを構成するインスタンス テンプレートを作成するには、次のコードサンプルを使用します。

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

import com.google.cloud.compute.v1.AccessConfig;
import com.google.cloud.compute.v1.AttachedDisk;
import com.google.cloud.compute.v1.AttachedDiskInitializeParams;
import com.google.cloud.compute.v1.InsertInstanceTemplateRequest;
import com.google.cloud.compute.v1.InstanceProperties;
import com.google.cloud.compute.v1.InstanceTemplate;
import com.google.cloud.compute.v1.InstanceTemplatesClient;
import com.google.cloud.compute.v1.NetworkInterface;
import com.google.cloud.compute.v1.Operation;
import com.google.cloud.compute.v1.ReservationAffinity;
import java.io.IOException;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.TimeoutException;

public class CreateTemplateWithoutConsumingReservation {
  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 template you want to query.
    String templateName = "YOUR_INSTANCE_TEMPLATE_NAME";
    String machineType = "e2-standard-4";
    String sourceImage = "projects/debian-cloud/global/images/family/debian-11";

    createTemplateWithoutConsumingReservationAsync(
        projectId, templateName, machineType, sourceImage);
  }


  // Create a template that explicitly doesn't consume any reservations.
  public static InstanceTemplate createTemplateWithoutConsumingReservationAsync(
      String projectId, String templateName, String machineType, String sourceImage)
      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 (InstanceTemplatesClient instanceTemplatesClient = InstanceTemplatesClient.create()) {
      AttachedDisk attachedDisk = AttachedDisk.newBuilder()
          .setInitializeParams(AttachedDiskInitializeParams.newBuilder()
              .setSourceImage(sourceImage)
              .setDiskType("pd-balanced")
              .setDiskSizeGb(250)
              .build())
          .setAutoDelete(true)
          .setBoot(true)
          .build();

      NetworkInterface networkInterface = NetworkInterface.newBuilder()
          .setName("global/networks/default")
          .addAccessConfigs(AccessConfig.newBuilder()
              .setName("External NAT")
              .setType(AccessConfig.Type.ONE_TO_ONE_NAT.toString())
              .setNetworkTier(AccessConfig.NetworkTier.PREMIUM.toString())
              .build())
          .build();

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

      InstanceProperties instanceProperties = InstanceProperties.newBuilder()
          .addDisks(attachedDisk)
          .setMachineType(machineType)
          .setReservationAffinity(reservationAffinity)
          .addNetworkInterfaces(networkInterface)
          .build();

      InsertInstanceTemplateRequest insertInstanceTemplateRequest = InsertInstanceTemplateRequest
          .newBuilder()
          .setProject(projectId)
          .setInstanceTemplateResource(InstanceTemplate.newBuilder()
              .setName(templateName)
              .setProperties(instanceProperties)
              .build())
          .build();

      Operation response = instanceTemplatesClient.insertAsync(insertInstanceTemplateRequest)
          .get(3, TimeUnit.MINUTES);

      if (response.hasError()) {
        return null;
      }
      return instanceTemplatesClient.get(projectId, templateName);
    }
  }
}

Node.js

予約を使用しないインスタンスを構成するインスタンス テンプレートを作成するには、次のコードサンプルを使用します。

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

// Instantiate an instanceTemplatesClient
const instanceTemplatesClient = new computeLib.InstanceTemplatesClient();
// Instantiate a globalOperationsClient
const globalOperationsClient = new computeLib.GlobalOperationsClient();

/**
 * TODO(developer): Update/uncomment these variables before running the sample.
 */
// The ID of the project where you want to create template.
const projectId = await instanceTemplatesClient.getProjectId();
// The name of the template to create.
// const templateName = 'instance-01';

// Create an instance template that creates VMs that don't explicitly consume reservations
async function callCreateTemplateToNotConsumeReservation() {
  // Define the boot disk for the instance template
  const disk = new compute.AttachedDisk({
    initializeParams: new compute.AttachedDiskInitializeParams({
      sourceImage:
        'projects/debian-cloud/global/images/debian-12-bookworm-v20240815',
      diskSizeGb: '100',
      diskType: 'pd-balanced',
    }),
    autoDelete: true,
    boot: true,
    type: 'PERSISTENT',
  });

  // Define the network interface for the instance template
  const network = new compute.NetworkInterface({
    network: `projects/${projectId}/global/networks/default`,
  });

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

  // Define instance template
  const instanceTemplate = new compute.InstanceTemplate({
    name: templateName,
    properties: {
      disks: [disk],
      machineType: 'e2-medium',
      // The template connects the instance to the `default` network,
      // without specifying a subnetwork.
      networkInterfaces: [network],
      reservationAffinity,
    },
  });

  const [response] = await instanceTemplatesClient.insert({
    project: projectId,
    instanceTemplateResource: instanceTemplate,
  });

  let operation = response.latestResponse;

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

  console.log(`Template ${templateName} created.`);
}

await callCreateTemplateToNotConsumeReservation();

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_instance_template_not_consume_reservation(
    project_id: str,
    template_name: str,
    machine_type: str = "n1-standard-1",
) -> compute_v1.InstanceTemplate:
    """
    Creates an instance template that creates VMs that don't explicitly consume reservations

    Args:
        project_id: project ID or project number of the Cloud project you use.
        template_name: name of the new template to create.
        machine_type: machine type for the instance.
    Returns:
        InstanceTemplate object that represents the new instance template.
    """

    template = compute_v1.InstanceTemplate()
    template.name = template_name
    template.properties.machine_type = machine_type
    # The template describes the size and source image of the boot disk
    # to attach to the instance.
    template.properties.disks = [
        compute_v1.AttachedDisk(
            boot=True,
            auto_delete=True,  # The disk will be deleted when the instance is deleted
            initialize_params=compute_v1.AttachedDiskInitializeParams(
                source_image="projects/debian-cloud/global/images/family/debian-11",
                disk_size_gb=10,
            ),
        )
    ]
    # The template connects the instance to the `default` network,
    template.properties.network_interfaces = [
        compute_v1.NetworkInterface(
            network="global/networks/default",
            access_configs=[
                compute_v1.AccessConfig(
                    name="External NAT",
                    type="ONE_TO_ONE_NAT",
                )
            ],
        )
    ]
    # The template doesn't explicitly consume reservations
    template.properties.reservation_affinity = compute_v1.ReservationAffinity(
        consume_reservation_type="NO_RESERVATION"
    )

    template_client = compute_v1.InstanceTemplatesClient()
    operation = template_client.insert(
        project=project_id, instance_template_resource=template
    )

    wait_for_extended_operation(operation, "instance template creation")

    return template_client.get(project=project_id, instance_template=template_name)

REST

予約を使用しないインスタンスを構成するインスタンス テンプレートを作成するには、次のいずれかのメソッドに POST リクエストを送信します。

• グローバル インスタンス テンプレートを作成するには: instanceTemplates.insert メソッド。

• リージョン インスタンス テンプレートを作成するには: regionInstanceTemplates.insert メソッド。

リクエスト本文に consumeReservationType フィールドを追加し、値を NO_RESERVATION に設定します。

たとえば、リージョン インスタンス テンプレートを作成し、予約を使用しないように指定するには、次のようにリクエストを送信します。

POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/regions/REGION/InstanceTemplates

{
  "name": "INSTANCE_TEMPLATE_NAME",
  "properties": {
    "machineType": "MACHINE_TYPE",
    "disks": [
      {
        "boot": true,
        "initializeParams": {
          "sourceImage": "projects/IMAGE_PROJECT/global/images/IMAGE"
        }
      }
    ],
    "networkInterfaces": [
      {
        "network": "global/networks/default"
      }
    ],
    "reservationAffinity": {
      "consumeReservationType": "NO_RESERVATION"
    }
  }
}

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

• PROJECT_ID: インスタンス テンプレートを作成するプロジェクトの ID。

• INSTANCE_TEMPLATE_NAME: インスタンス テンプレートの名前。

• MACHINE_TYPE: インスタンス テンプレートを使用して作成されたインスタンスに使用するマシンタイプ。

• IMAGE_PROJECT: OS イメージを含むイメージ プロジェクト（例: debian-cloud）。サポートされているイメージ プロジェクトの詳細については、公開イメージをご覧ください。

• IMAGE: 次のいずれかを指定します。

  • OS イメージの特定のバージョン。例: debian-12-bookworm-v20240617。

  • イメージ ファミリー。family/IMAGE_FAMILY の形式にする必要があります。これにより、非推奨ではない最新の OS イメージが指定されます。たとえば、family/debian-12 を指定すると、Debian 12 イメージ ファミリーの最新バージョンが使用されます。イメージ ファミリーの使用の詳細については、イメージ ファミリーのベスト プラクティスをご覧ください。

インスタンス テンプレート作成の詳細については、インスタンス テンプレートを作成するをご覧ください。

次のステップ

• 予約を変更する

• 予約を削除する