Menggunakan pemesanan


Dokumen ini menjelaskan cara menggunakan Compute Engine untuk melakukan hal berikut:

  • Menggunakan instance virtual machine (VM) yang direservasi.

  • Memverifikasi pemakaian reservasi.

  • Melihat laporan penggunaan reservasi.

Untuk informasi selengkapnya tentang menggunakan reservasi di produk Google Cloud lainnya yang menggunakan VM, lihat dokumentasi reservasi untuk produk berikut:

Sebelum memulai

  • Tinjau persyaratan dan batasan untuk pemesanan.
  • Jika Anda belum melakukannya, siapkan autentikasi. Autentikasi adalah proses verifikasi identitas Anda untuk mengakses layanan dan API Google Cloud. Untuk menjalankan kode atau contoh dari lingkungan pengembangan lokal, Anda dapat mengautentikasi ke Compute Engine dengan memilih salah satu opsi berikut:

    Select the tab for how you plan to use the samples on this page:

    Console

    When you use the Google Cloud console to access Google Cloud services and APIs, you don't need to set up authentication.

    gcloud

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

      gcloud init
    2. Set a default region and zone.
    3. Go

      Untuk menggunakan contoh Go di halaman ini dalam lingkungan pengembangan lokal, instal dan lakukan inisialisasi gcloud CLI, lalu siapkan Kredensial Default Aplikasi dengan kredensial pengguna Anda.

      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.

      Untuk informasi selengkapnya, lihat Set up authentication for a local development environment.

      Java

      Untuk menggunakan contoh Java di halaman ini dalam lingkungan pengembangan lokal, instal dan lakukan inisialisasi gcloud CLI, lalu siapkan Kredensial Default Aplikasi dengan kredensial pengguna Anda.

      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.

      Untuk informasi selengkapnya, lihat Set up authentication for a local development environment.

      Node.js

      Untuk menggunakan contoh Node.js di halaman ini dalam lingkungan pengembangan lokal, instal dan lakukan inisialisasi gcloud CLI, lalu siapkan Kredensial Default Aplikasi dengan kredensial pengguna Anda.

      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.

      Untuk informasi selengkapnya, lihat Set up authentication for a local development environment.

      Python

      Untuk menggunakan contoh Python di halaman ini dalam lingkungan pengembangan lokal, instal dan lakukan inisialisasi gcloud CLI, lalu siapkan Kredensial Default Aplikasi dengan kredensial pengguna Anda.

      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.

      Untuk informasi selengkapnya, lihat Set up authentication for a local development environment.

      REST

      Untuk menggunakan contoh REST API di halaman ini dalam lingkungan pengembangan lokal, gunakan kredensial yang Anda berikan ke gcloud CLI.

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

        gcloud init

      Untuk informasi selengkapnya, lihat Melakukan autentikasi untuk menggunakan REST dalam dokumentasi autentikasi Google Cloud.

Peran yang diperlukan

Untuk mendapatkan izin yang diperlukan guna menggunakan reservasi, minta administrator untuk memberi Anda peran IAM Compute Instance Admin (v1) (roles/compute.instanceAdmin.v1) di project. Untuk mengetahui informasi selengkapnya tentang cara memberikan peran, lihat Mengelola akses ke project, folder, dan organisasi.

Peran yang telah ditentukan ini berisi izin yang diperlukan untuk menggunakan reservasi. Untuk melihat izin yang benar-benar diperlukan, luaskan bagian Izin yang diperlukan:

Izin yang diperlukan

Izin berikut diperlukan untuk menggunakan reservasi:

  • Untuk membuat pemesanan: compute.reservations.create pada project
  • Untuk membuat VM:
    • compute.instances.create pada project
    • Untuk menggunakan image kustom guna membuat VM: compute.images.useReadOnly pada image
    • Untuk menggunakan snapshot guna membuat VM: compute.snapshots.useReadOnly pada snapshot
    • Untuk menggunakan template instance guna membuat VM: compute.instanceTemplates.useReadOnly di template instance
    • Untuk menetapkan jaringan lama ke VM: compute.networks.use di project
    • Untuk menentukan alamat IP statis untuk VM: compute.addresses.use pada project
    • Untuk menetapkan alamat IP eksternal ke VM saat menggunakan jaringan lama: compute.networks.useExternalIp di project
    • Untuk menentukan subnet bagi VM: compute.subnetworks.use di project atau di subnet yang dipilih
    • Untuk menetapkan alamat IP eksternal ke VM saat menggunakan jaringan VPC: compute.subnetworks.useExternalIp di project atau di subnet yang dipilih
    • Untuk menetapkan metadata instance VM untuk VM: compute.instances.setMetadata pada project
    • Untuk menetapkan tag untuk VM: compute.instances.setTags di VM
    • Untuk menetapkan label untuk VM: compute.instances.setLabels di VM
    • Untuk menetapkan akun layanan yang akan digunakan VM: compute.instances.setServiceAccount di VM
    • Untuk membuat disk baru bagi VM: compute.disks.create pada project
    • Untuk memasang disk yang ada dalam mode hanya baca atau baca-tulis: compute.disks.use pada disk
    • Untuk memasang disk yang ada dalam mode hanya baca: compute.disks.useReadOnly pada disk
  • Untuk membuat template instance: compute.instanceTemplates.create pada project

Anda mungkin juga bisa mendapatkan izin ini dengan peran khusus atau peran bawaan lainnya.

Menggunakan VM yang direservasi

Saat Anda membuat instance virtual machine (VM), VM mulai memakai reservasi hanya jika properti untuk VM dan reservasi cocok. Selain itu, Anda harus menetapkan properti afinitas reservasi VM ke salah satu opsi berikut:

  • Memakai reservasi yang cocok—VM dapat otomatis memakai reservasi apa pun dengan properti yang cocok (default).

    Opsi ini berguna jika Anda membuat dan menghapus banyak VM, serta Anda ingin menggunakan reservasi jika memungkinkan. Dalam skenario ini, VM dapat dibuat, baik propertinya cocok dengan reservasi maupun tidak. Jika properti tersebut cocok, VM akan mulai menggunakan reservasi, bergantung pada urutan pemakaian reservasi.

  • Memakai reservasi tertentu—VM hanya dapat memakai reservasi tertentu. Reservasi tidak dapat digunakan secara otomatis.

    Opsi ini berguna jika, misalnya, Anda ingin menyimpan jumlah kapasitas tertentu sebagai cadangan untuk acara khusus. Dalam skenario ini, VM hanya dapat dibuat jika propertinya dan properti reservasi tertentu cocok.

  • Tidak dapat memakai reservasi apa pun—VM tidak dapat memakai reservasi apa pun.

    Opsi ini berguna jika, misalnya, Anda membuat VM sementara yang tidak Anda kehendaki untuk memakai resource yang direservasi.

Menggunakan VM dari reservasi yang cocok

Dalam model pemakaian ini, VM lama dan baru akan otomatis memakai reservasi jika propertinya sesuai dengan properti VM yang ditentukan di reservasi.

Saat menggunakan model pemakaian ini, VM dalam project saat ini memakai semua reservasi satu project terlebih dahulu sebelum memakai reservasi bersama. Untuk mengetahui informasi selengkapnya tentang cara reservasi digunakan secara otomatis, lihat urutan pemakaian.

Saat Anda membuat reservasi, ini adalah model pemakaian default, selama Anda tidak menggunakan tanda atau opsi yang menunjukkan bahwa reservasi tertentu diperlukan.

Konsol

  1. Untuk membuat reservasi dengan resource yang dapat digunakan oleh VM dengan properti afinitas reservasi yang dikonfigurasi untuk menggunakan reservasi apa pun (default), ikuti langkah-langkah berikut:

    1. Pilih jenis reservasi yang ingin dibuat:

      • Untuk membuat reservasi mandiri, lakukan langkah berikut:

        1. Di Konsol Google Cloud, buka halaman Reservations.

          Buka Pemesanan

        2. Di tab Pemesanan sesuai permintaan (default), klik Buat pemesanan.

          Halaman Create a reservation akan terbuka.

      • Untuk membuat reservasi yang terkait dengan komitmen, lakukan tindakan berikut:

        1. Di Konsol Google Cloud, buka halaman Committed use discounts.

          Buka halaman Committed use discounts

          Halaman Daftar komitmen akan terbuka.

        2. Klik Purchase commitment.

          Halaman Purchase a committed use discount akan terbuka.

        3. Tentukan properti komitmen. Lalu, di bagian Reservations, klik Add an item.

          Halaman Add a new reservation akan muncul.

          Untuk mengetahui informasi lebih lanjut cara membeli komitmen dengan reservasi terlampir, lihat Membeli reservasi dengan reservasi terlampir.

    2. Di kolom Name, masukkan nama reservasi Anda. Untuk contoh ini, masukkan reservation-01.

    3. Pilih Region dan Zone tempat Anda ingin mereservasi resource. Untuk contoh ini, pilih us-central1 sebagai region dan us-central1-a sebagai zona.

    4. Pilih Share type yang Anda inginkan:

      • Untuk membuat reservasi bagi satu project, pilih Local.
      • Untuk membuat pemesanan yang dibagikan dengan banyak project, pilih Dibagikan. Untuk membagikan pemesanan ini dengan project lain, klik Tambahkan project, lalu pilih project yang diinginkan dari organisasi project saat ini.
    5. Di bagian Use with VM instance, pilih Use reservation automatically, sehingga setiap VM yang cocok dapat otomatis menggunakan reservasi ini.

    6. Di kolom Jumlah instance VM, masukkan jumlah VM yang ingin Anda pesan. Untuk contoh ini, masukkan 2.

    7. Tentukan resource yang ingin Anda pesan untuk setiap VM:

      • Jika Anda ingin memesan VM yang cocok dengan template instance yang ada, pilih Gunakan template instance dan klik salah satu template instance dari daftar.
      • Jika tidak, pilih Tentukan jenis mesin dan tentukan properti berikut:
        1. Di kolom Kelompok mesin, Seri, dan Jenis mesin, pilih kelompok mesin, seri, dan jenis mesin.
        2. Opsional: Tentukan platform CPU dan/atau GPU minimum:
          1. Untuk meluaskan bagian CPU Platform and GPU, klik panah perluas .
          2. Opsional: Untuk menentukan platform CPU minimum, dalam daftar CPU Platform, pilih salah satu opsi.
          3. Opsional: Untuk menambahkan GPU, klik Add GPU. Kemudian, di kolom Jenis GPU dan Jumlah GPU, pilih jenis dan jumlah GPU untuk setiap VM.
        3. Opsional: Tambahkan SSD lokal:
          1. Di kolom Jumlah disk, pilih jumlah SSD lokal untuk setiap VM.
          2. Di kolom Interface type, pilih antarmuka untuk SSD lokal.

      Untuk contoh ini, pilih Specify machine type. Kemudian, pilih jenis mesin n2-standard-32 untuk kelompok mesin General-purpose dan seri N2, lalu pilih platform CPU minimum Intel Cascade Lake.

    8. Selesaikan pembuatan reservasi:

      • Jika Anda membuat reservasi mandiri, klik Create.

      • Jika Anda membuat reservasi yang terkait dengan komitmen:

        1. Untuk menyelesaikan penentuan properti reservasi ini, klik Done.
        2. Untuk menyelesaikan pembuatan komitmen dan reservasi terlampir, klik Purchase.
  2. Dalam project yang sama atau project yang reservasinya digunakan bersama, buat VM yang menargetkan semua reservasi yang terbuka.

    Pastikan properti VM sesuai dengan properti VM di reservation-01, termasuk zona, jenis mesin (kelompok mesin, vCPU, dan memori), platform CPU minimum, jumlah dan jenis GPU, serta antarmuka dan ukuran SSD lokal.

    Untuk mengetahui informasi selengkapnya tentang cara membuat VM, lihat Membuat dan memulai VM

    1. Di konsol Google Cloud, buka halaman Create an instance.

      Buka halaman Buat instance

      Halaman Create an instance akan terbuka.

    2. Tentukan nama untuk VM Anda.

    3. Di bagian berikut, pilih konfigurasi yang sama persis dengan semua properti reservasi Anda, termasuk properti opsional apa pun. Untuk contoh ini, Anda harus mencocokkan properti VM berikut dengan reservation-01:

      • Region: us-central1
      • Zone: us-central1-a
      • Machine type: n2-standard-32
      • CPU platform minimum: Intel Cascade Lake
      • GPUs: tidak ada
      • Local SSDs: tidak ada
    4. Luaskan bagian Advanced options, lalu luaskan bagian Management. Dalam daftar Reservations, pilih Automatically use created reservation.

    5. Untuk membuat VM, klik Create.

gcloud

  1. Buat reservasi terbuka bernama reservation-01.

    gcloud compute reservations create reservation-01 \
        --vm-count=2 \
        --machine-type=n2-standard-32 \
        --min-cpu-platform="Intel Cascade Lake" \
        --zone=us-central1-a
    
  2. Buat VM yang menargetkan semua reservasi terbuka dan yang cocok dengan properti VM di reservation-01, termasuk zona, jenis mesin (kelompok mesin, vCPU, dan memori), platform CPU minimum, jumlah dan jenis GPU, serta jumlah dan antarmuka SSD lokal.

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

Go

import (
	"context"
	"fmt"
	"io"

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

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

	ctx := context.Background()

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

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

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

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

	return nil
}

Java

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

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

public class ConsumeAnyMatchingReservation {

  public static void main(String[] args)
      throws IOException, ExecutionException, InterruptedException, TimeoutException {
    // TODO(developer): Replace these variables before running the sample.
    // Project ID or project number of the Cloud project you want to use.
    String projectId = "YOUR_PROJECT_ID";
    // Zone where the VM instance will be created.
    String zone = "us-central1-a";
    // Name of the VM instance you want to query.
    String instanceName = "YOUR_INSTANCE_NAME";
    // machineType: machine type of the VM being created.
    // *   For a list of machine types, see https://cloud.google.com/compute/docs/machine-types
    String machineTypeName = "n1-standard-4";
    // sourceImage: path to the operating system image to mount.
    // *   For details about images you can mount, see https://cloud.google.com/compute/docs/images
    String sourceImage = "projects/debian-cloud/global/images/family/debian-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";
    // Minimum CPU platform of the instances.
    String minCpuPlatform = "Intel Skylake";

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

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

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

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

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

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

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

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

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

Node.js

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

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

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

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

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

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

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

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

  let operation = response.latestResponse;

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

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

await callCreateInstanceToConsumeAnyReservation();

Python

from __future__ import annotations

import sys
from typing import Any

from google.api_core.extended_operation import ExtendedOperation
from google.cloud import compute_v1


def wait_for_extended_operation(
    operation: ExtendedOperation, verbose_name: str = "operation", timeout: int = 300
) -> Any:
    """
    Waits for the extended (long-running) operation to complete.

    If the operation is successful, it will return its result.
    If the operation ends with an error, an exception will be raised.
    If there were any warnings during the execution of the operation
    they will be printed to sys.stderr.

    Args:
        operation: a long-running operation you want to wait on.
        verbose_name: (optional) a more verbose name of the operation,
            used only during error and warning reporting.
        timeout: how long (in seconds) to wait for operation to finish.
            If None, wait indefinitely.

    Returns:
        Whatever the operation.result() returns.

    Raises:
        This method will raise the exception received from `operation.exception()`
        or RuntimeError if there is no exception set, but there is an `error_code`
        set for the `operation`.

        In case of an operation taking longer than `timeout` seconds to complete,
        a `concurrent.futures.TimeoutError` will be raised.
    """
    result = operation.result(timeout=timeout)

    if operation.error_code:
        print(
            f"Error during {verbose_name}: [Code: {operation.error_code}]: {operation.error_message}",
            file=sys.stderr,
            flush=True,
        )
        print(f"Operation ID: {operation.name}", file=sys.stderr, flush=True)
        raise operation.exception() or RuntimeError(operation.error_message)

    if operation.warnings:
        print(f"Warnings during {verbose_name}:\n", file=sys.stderr, flush=True)
        for warning in operation.warnings:
            print(f" - {warning.code}: {warning.message}", file=sys.stderr, flush=True)

    return result


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

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

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

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

    # Set the reservation affinity to target any matching reservation
    instance.reservation_affinity = compute_v1.ReservationAffinity(
        consume_reservation_type="ANY_RESERVATION",  # Type of reservation to consume
    )
    # Define the disks for the instance
    instance.disks = [
        compute_v1.AttachedDisk(
            boot=True,  # Indicates that this is a boot disk
            auto_delete=True,  # The disk will be deleted when the instance is deleted
            initialize_params=compute_v1.AttachedDiskInitializeParams(
                source_image="projects/debian-cloud/global/images/family/debian-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
                )
            ],
        )
    ]
    # Create a request to insert the instance
    request = compute_v1.InsertInstanceRequest()
    request.zone = zone
    request.project = project_id
    request.instance_resource = instance

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

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

REST

  1. Buat reservasi terbuka bernama reservation-01.

    POST https://compute.googleapis.com/compute/v1/projects/my-project/zones/us-central1-a/reservations
    
    {
      "name": "reservation-01",
      "specificReservation": {
        "count": "2",
        "instanceProperties": {
          "machineType": "n2-standard-32",
          "minCpuPlatform": "Intel Cascade Lake",
        }
      }
    }
    
  2. Buat VM yang menargetkan semua reservasi terbuka dan yang cocok dengan properti VM di reservation-01, termasuk zona, jenis mesin (kelompok mesin, vCPU, dan memori), platform CPU minimum, jumlah dan jenis GPU, serta jumlah dan antarmuka SSD lokal.

    POST https://compute.googleapis.com/compute/v1/projects/my-project/zones/us-central1-a/instances
    
    {
      "name": "instance-1",
      "machineType": "zones/us-central1-a/machineTypes/n2-standard-32",
      "minCpuPlatform": "Intel Cascade Lake",
      "disks": [
        {
          "boot": true,
          "initializeParams": {
            "sourceImage": "projects/debian-cloud/global/images/family/debian-12"
          }
        }
      ],
      "networkInterfaces": [
        {
          "network": "global/networks/default"
        }
      ],
      "reservationAffinity": {
        "consumeReservationType": "ANY_RESERVATION"
      }
    }
    

Menggunakan VM dari reservasi tertentu

Dalam model pemakaian ini, hanya VM baru yang menargetkan reservasi tertentu berdasarkan nama yang dapat memakai reservasi tersebut, dan reservasi otomatis tidak digunakan.

Saat membuat reservasi, tentukan bahwa VM diwajibkan untuk menargetkan reservasi tertentu memakai salah satu metode berikut:

  • Di Konsol Google Cloud, centang kotak Select specific reservation.
  • Di gcloud CLI, sertakan flag --require-specific-reservation.
  • Di Compute Engine API, tetapkan kolom specificReservationRequired ke true.
  • Di Terraform, tetapkan kolom specific_reservation_required ke true.

Lalu, buat VM yang secara khusus menargetkan reservasi tersebut. Anda hanya dapat membuat VM yang menargetkan reservasi tertentu jika properti VM dan properti reservasi cocok. Jika tidak, pembuatan VM akan gagal.

Jika Anda menggunakan template instance untuk membuat VM di grup instance terkelola regional, buat reservasi yang identik dengan nama yang sama di setiap zona yang berlaku. Kemudian, targetkan reservasi berdasarkan nama di template instance grup.

Misalnya, buat reservasi spesifik bernama reservation-02, lalu buat VM yang cocok yang menargetkan reservasi tersebut dan yang cocok dengan properti VM reservasi.

Bergantung pada jenis VM yang ingin Anda pakai, ikuti langkah-langkah untuk Memakai reservasi project tunggal tertentu atau Memakai reservasi bersama tertentu.

Memakai reservasi satu project tertentu

Untuk menggunakan reservasi satu project tertentu, pilih salah satu opsi berikut:

Konsol

  1. Untuk membuat reservasi dengan resource yang hanya dapat digunakan oleh VM yang secara khusus menargetkan reservasi berdasarkan nama, ikuti langkah-langkah berikut:

    1. Pilih salah satu opsi berikut:

      • Untuk membuat reservasi mandiri, lakukan langkah berikut:

        1. Di Konsol Google Cloud, buka halaman Reservations.

          Buka Pemesanan

        2. Di tab Pemesanan sesuai permintaan (default), klik Buat pemesanan.

          Halaman Create a reservation akan terbuka.

      • Untuk membuat reservasi yang terkait dengan komitmen, lakukan tindakan berikut:

        1. Di Konsol Google Cloud, buka halaman Committed use discounts.

          Buka halaman Committed use discounts

        2. Klik Purchase commitment.

          Halaman Purchase a committed use discount akan terbuka.

        3. Tentukan properti komitmen. Lalu, di bagian Reservations, klik Add an item.

          Halaman Add a new reservation akan muncul.

          Untuk mengetahui informasi lebih lanjut cara membeli komitmen dengan reservasi terlampir, lihat Membeli reservasi dengan reservasi terlampir.

    2. Di kolom Name, masukkan nama reservasi Anda. Untuk contoh ini, masukkan reservation-02.

    3. Pilih Region dan Zone tempat Anda ingin mereservasi resource. Untuk contoh ini, pilih us-central1 sebagai region dan us-central1-a sebagai zona.

    4. Untuk menentukan bahwa reservasi Anda akan menjadi reservasi satu project, pilih Local sebagai Share type.

    5. Di bagian Use with VM instance, pilih Select specific reservation, sehingga hanya VM yang cocok yang secara khusus menargetkan reservasi ini berdasarkan nama yang dapat menggunakan reservasi ini.

    6. Di kolom Jumlah instance VM, masukkan jumlah VM yang ingin Anda pesan. Untuk contoh ini, masukkan 10.

    7. Tentukan resource yang ingin Anda pesan untuk setiap VM:

      • Jika Anda ingin memesan VM yang cocok dengan template instance yang ada, pilih Gunakan template instance dan klik salah satu template instance dari daftar.
      • Jika tidak, pilih Tentukan jenis mesin dan tentukan properti berikut:
        1. Di kolom Kelompok mesin, Seri, dan Jenis mesin, pilih kelompok mesin, seri, dan jenis mesin.
        2. Opsional: Tentukan platform CPU dan/atau GPU minimum:
          1. Untuk meluaskan bagian CPU Platform and GPU, klik panah perluas .
          2. Opsional: Untuk menentukan platform CPU minimum, dalam daftar CPU Platform, pilih salah satu opsi.
          3. Opsional: Untuk menambahkan GPU, klik Add GPU. Kemudian, di kolom Jenis GPU dan Jumlah GPU, pilih jenis dan jumlah GPU untuk setiap VM.
        3. Opsional: Tambahkan SSD lokal:
          1. Di kolom Jumlah disk, pilih jumlah SSD lokal untuk setiap VM.
          2. Di kolom Interface type, pilih antarmuka untuk SSD lokal.

      Untuk contoh ini, pilih Specify machine type. Kemudian, pilih jenis mesin n2-standard-32 untuk kelompok mesin General-purpose dan seri N2, lalu pilih platform CPU minimum Intel Cascade Lake.

    8. Selesaikan pembuatan reservasi:

      • Jika Anda membuat reservasi mandiri, klik Create.

      • Jika Anda membuat reservasi yang terkait dengan komitmen:

        1. Untuk menyelesaikan penentuan properti reservasi ini, klik Done.
        2. Untuk menyelesaikan pembuatan komitmen dan reservasi terlampir, klik Purchase.
  2. Dalam project yang sama, buat VM yang menargetkan reservasi spesifik tersebut berdasarkan nama.

    Pastikan properti VM sesuai dengan properti VM dari reservasi tertentu tersebut, termasuk zona, jenis mesin (kelompok mesin, vCPU, dan memori), platform CPU minimum, jumlah dan jenis GPU, serta antarmuka dan ukuran SSD lokal.

    Untuk mengetahui informasi selengkapnya tentang cara membuat VM, lihat Membuat dan memulai VM.

    1. Di konsol Google Cloud, buka halaman Create an instance.

      Buka halaman Buat instance

    2. Di kolom Nama, masukkan nama untuk VM.

    3. Di bagian berikut, pilih konfigurasi yang sama persis dengan semua properti reservasi Anda, termasuk properti opsional apa pun. Untuk contoh ini, Anda harus mencocokkan properti VM berikut dengan reservation-02:

      • Region: us-central1
      • Zone: us-central1-a
      • Machine type: n2-standard-32
      • CPU platform minimum: Intel Cascade Lake
      • GPUs: tidak ada
      • Local SSDs: tidak ada
    4. Luaskan bagian Advanced options, lalu lakukan hal berikut:

      1. Luaskan bagian Management.

      2. Di bagian Reservations, dalam daftar Application policy, pilih Select specific reservation.

      3. Pilih reservasi dengan properti VM yang cocok yang Anda inginkan untuk digunakan VM. Untuk contoh ini, pilih reservation-02.

    5. Untuk membuat VM, klik Create.

gcloud

  1. Buat reservasi bernama reservation-02 dengan flag --require-specific-reservation. Resource yang direservasi ini hanya dapat digunakan oleh VM yang secara khusus menargetkan reservasi ini berdasarkan nama.

    gcloud compute reservations create reservation-02 \
        --machine-type=n2-standard-32 \
        --min-cpu-platform="Intel Cascade Lake" \
        --vm-count=10 \
        --zone=us-central1-a \
        --require-specific-reservation
    
  2. Buat VM yang menargetkan reservation-02 berdasarkan nama menggunakan flag --reservation-affinity dan --reservation.

    Pastikan properti VM sesuai dengan properti VM reservasi, termasuk zona, jenis mesin (kelompok mesin, vCPU, dan memori), platform CPU minimum, jumlah dan jenis GPU, serta antarmuka dan ukuran SSD lokal.

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

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

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

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

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

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

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

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

	return nil
}

Java

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

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

public class ConsumeSingleProjectReservation {
  public static void main(String[] args)
      throws IOException, ExecutionException, InterruptedException, TimeoutException {
    // TODO(developer): Replace these variables before running the sample.
    // Project ID or project number of the Cloud project you want to use.
    String projectId = "YOUR_PROJECT_ID";
    // Name of the zone where the reservation is located.
    String zone = "us-central1-a";
    // Name of the reservation you want to query.
    String reservationName = "YOUR_RESERVATION_NAME";
    // Name of the VM instance you want to query.
    String instanceName = "YOUR_INSTANCE_NAME";
    // machineType: machine type of the VM being created.
    // *   For a list of machine types, see https://cloud.google.com/compute/docs/machine-types
    String machineTypeName = "n1-standard-4";
    // sourceImage: path to the operating system image to mount.
    // *   For details about images you can mount, see https://cloud.google.com/compute/docs/images
    String sourceImage = "projects/debian-cloud/global/images/family/debian-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";
    // Minimum CPU platform of the instances.
    String minCpuPlatform = "Intel Skylake";

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

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

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

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

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

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

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

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

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';
// The name of the reservation to consume.
// Ensure that the specificReservationRequired field in reservation properties is set to true.
// const reservationName = 'reservation-01';
// Machine type to use for VM.
const machineType = 'n1-standard-4';

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

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

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

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

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

  let operation = response.latestResponse;

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

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

await callCreateInstanceToConsumeSingleProjectReservation();

Python

from __future__ import annotations

import sys
from typing import Any

from google.api_core.extended_operation import ExtendedOperation
from google.cloud import compute_v1


def wait_for_extended_operation(
    operation: ExtendedOperation, verbose_name: str = "operation", timeout: int = 300
) -> Any:
    """
    Waits for the extended (long-running) operation to complete.

    If the operation is successful, it will return its result.
    If the operation ends with an error, an exception will be raised.
    If there were any warnings during the execution of the operation
    they will be printed to sys.stderr.

    Args:
        operation: a long-running operation you want to wait on.
        verbose_name: (optional) a more verbose name of the operation,
            used only during error and warning reporting.
        timeout: how long (in seconds) to wait for operation to finish.
            If None, wait indefinitely.

    Returns:
        Whatever the operation.result() returns.

    Raises:
        This method will raise the exception received from `operation.exception()`
        or RuntimeError if there is no exception set, but there is an `error_code`
        set for the `operation`.

        In case of an operation taking longer than `timeout` seconds to complete,
        a `concurrent.futures.TimeoutError` will be raised.
    """
    result = operation.result(timeout=timeout)

    if operation.error_code:
        print(
            f"Error during {verbose_name}: [Code: {operation.error_code}]: {operation.error_message}",
            file=sys.stderr,
            flush=True,
        )
        print(f"Operation ID: {operation.name}", file=sys.stderr, flush=True)
        raise operation.exception() or RuntimeError(operation.error_message)

    if operation.warnings:
        print(f"Warnings during {verbose_name}:\n", file=sys.stderr, flush=True)
        for warning in operation.warnings:
            print(f" - {warning.code}: {warning.message}", file=sys.stderr, flush=True)

    return result


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

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

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

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

    # Set the reservation affinity to target the specific reservation
    instance.reservation_affinity = compute_v1.ReservationAffinity(
        consume_reservation_type="SPECIFIC_RESERVATION",  # Type of reservation to consume
        key="compute.googleapis.com/reservation-name",  # Key for the reservation
        values=[reservation_name],  # Reservation name to consume
    )
    # Define the disks for the instance
    instance.disks = [
        compute_v1.AttachedDisk(
            boot=True,  # Indicates that this is a boot disk
            auto_delete=True,  # The disk will be deleted when the instance is deleted
            initialize_params=compute_v1.AttachedDiskInitializeParams(
                source_image="projects/debian-cloud/global/images/family/debian-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
                )
            ],
        )
    ]
    # Create a request to insert the instance
    request = compute_v1.InsertInstanceRequest()
    request.zone = zone
    request.project = project_id
    request.instance_resource = instance

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

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

REST

  1. Buat reservasi bernama reservation-02 dengan kolom specificReservationRequired ditetapkan ke true.

    POST https://compute.googleapis.com/compute/v1/projects/my-project/zones/us-central1-a/reservations
    
    {
      "name":"reservation-02",
      "specificReservation":{
        "count":"10",
        "instanceProperties":{
          "machineType":"n2-standard-32",
          "minCpuPlatform": "Intel Cascade Lake",
        }
      },
      "specificReservationRequired": true
    }
    
  2. Buat VM yang menargetkan reservation-02 berdasarkan nama menggunakan kolom reservationAffinity.

    Pastikan properti VM sesuai dengan properti VM reservasi, termasuk zona, jenis mesin (kelompok mesin, vCPU, dan memori), platform CPU minimum, jumlah dan jenis GPU, serta antarmuka dan ukuran SSD lokal.

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

Memakai reservasi bersama tertentu

Untuk menggunakan reservasi bersama tertentu, pilih salah satu opsi berikut:

Konsol

  1. Untuk membuat reservasi bersama menggunakan resource yang hanya dapat digunakan oleh VM yang secara khusus menargetkan reservasi ini berdasarkan nama, ikuti langkah-langkah berikut:

    1. Pilih salah satu opsi berikut:

      • Untuk membuat reservasi mandiri, lakukan langkah berikut:

        1. Di Konsol Google Cloud, buka halaman Reservations.

          Buka Pemesanan

        2. Di tab Pemesanan sesuai permintaan (default), klik Buat pemesanan.

          Halaman Create a reservation akan terbuka.

      • Untuk membuat reservasi yang terkait dengan komitmen, lakukan tindakan berikut:

        1. Di Konsol Google Cloud, buka halaman Committed use discounts.

          Buka halaman Committed use discounts

        2. Klik Purchase commitment.

          Halaman Purchase a committed use discount akan terbuka.

        3. Tentukan properti komitmen. Lalu, di bagian Reservations, klik Add an item.

          Halaman Add a new reservation akan muncul.

          Untuk mengetahui informasi lebih lanjut cara membeli komitmen dengan reservasi terlampir, lihat Membeli reservasi dengan reservasi terlampir.

    2. Di kolom Name, masukkan nama reservasi Anda. Untuk contoh ini, masukkan reservation-02.

    3. Pilih Region dan Zone tempat Anda ingin mereservasi resource. Untuk contoh ini, pilih us-central1 sebagai region dan us-central1-a sebagai zona.

    4. Untuk menentukan bahwa reservasi Anda adalah reservasi bersama, pilih Shared sebagai Share type.

    5. Klik Add projects, lalu pilih project dari organisasi project saat ini yang ingin diajak berbagi reservasi.

    6. Di bagian Use with VM instance, pilih Select specific reservation, sehingga hanya VM yang cocok yang secara khusus menargetkan reservasi ini berdasarkan nama yang dapat menggunakan reservasi ini.

    7. Di kolom Jumlah instance VM, masukkan jumlah VM yang ingin Anda pesan. Untuk contoh ini, masukkan 10.

    8. Tentukan resource yang ingin Anda pesan untuk setiap VM:

      • Jika Anda ingin memesan VM yang cocok dengan template instance yang ada, pilih Gunakan template instance dan klik salah satu template instance dari daftar.
      • Jika tidak, pilih Tentukan jenis mesin dan tentukan properti berikut:
        1. Di kolom Kelompok mesin, Seri, dan Jenis mesin, pilih kelompok mesin, seri, dan jenis mesin.
        2. Opsional: Tentukan platform CPU dan/atau GPU minimum:
          1. Untuk meluaskan bagian CPU Platform and GPU, klik panah perluas .
          2. Opsional: Untuk menentukan platform CPU minimum, dalam daftar CPU Platform, pilih salah satu opsi.
          3. Opsional: Untuk menambahkan GPU, klik Add GPU. Kemudian, di kolom Jenis GPU dan Jumlah GPU, pilih jenis dan jumlah GPU untuk setiap VM.
        3. Opsional: Tambahkan SSD lokal:
          1. Di kolom Jumlah disk, pilih jumlah SSD lokal untuk setiap VM.
          2. Di kolom Interface type, pilih antarmuka untuk SSD lokal.

      Untuk contoh ini, pilih Specify machine type. Kemudian, pilih jenis mesin n2-standard-32 untuk kelompok mesin General-purpose dan seri N2, lalu pilih platform CPU minimum Intel Cascade Lake. 1. Selesaikan pembuatan reservasi:

      • Jika Anda membuat reservasi mandiri, klik Create.

      • Jika Anda membuat reservasi yang terkait dengan komitmen:

        1. Untuk menyelesaikan penentuan properti reservasi ini, klik Done.
        2. Untuk menyelesaikan pembuatan komitmen dan reservasi terlampir, klik Purchase.
  2. Dalam project yang sama atau project yang reservasinya digunakan bersama, buat VM yang menargetkan reservasi spesifik tersebut berdasarkan nama.

    Pastikan properti VM sesuai dengan properti VM dari reservasi tertentu tersebut, termasuk zona, jenis mesin (kelompok mesin, vCPU, dan memori), platform CPU minimum, jumlah dan jenis GPU, serta antarmuka dan ukuran SSD lokal.

    1. Di konsol Google Cloud, buka halaman Create an instance.

      Buka halaman Buat instance

      Halaman Create an instance akan terbuka.

    2. Tentukan Name untuk VM Anda.

    3. Di bagian berikut, pilih konfigurasi yang sama persis dengan semua properti reservasi Anda, termasuk properti opsional apa pun. Untuk contoh ini, Anda harus mencocokkan properti VM berikut dengan reservation-02:

      • Region: us-central1
      • Zone: us-central1-a
      • Machine type: n2-standard-32
      • CPU platform minimum: Intel Cascade Lake
      • GPUs: tidak ada
      • Local SSDs: tidak ada
    4. Luaskan bagian Advanced options, lalu luaskan bagian Management. Dalam daftar Reservations, pilih Select specific reservation, lalu lakukan hal berikut:

      1. Pilih Reservation project yang memiliki reservasi yang dibagikan dengan project Anda saat ini. Untuk contoh ini, pilih project yang Anda gunakan untuk membuat reservation-02.
      2. Pilih Reservation name untuk reservasi bersama yang Anda inginkan untuk dipakai oleh instance VM ini. Untuk contoh ini, pilih reservation-02.
    5. Untuk membuat VM, klik Create.

gcloud

  1. Buat reservasi bernama reservation-02 dengan flag --require-specific-reservation. Resource yang direservasi ini hanya dapat digunakan oleh VM yang secara khusus menargetkan reservasi ini berdasarkan nama.

    gcloud compute reservations create reservation-02 \
        --machine-type=n2-standard-32 \
        --min-cpu-platform="Intel Cascade Lake" \
        --vm-count=10 \
        --zone=us-central1-a \
        --project=my-owner-project \
        --share-setting=projects \
        --share-with=project-1,project-2 \
        --require-specific-reservation
    
  2. Buat VM yang menargetkan reservation-02 berdasarkan nama menggunakan flag --reservation-affinity dan --reservation. Untuk memakai reservasi ini dari project konsumen yang juga memakai reservasi bersama ini, Anda juga harus menentukan project yang membuat reservasi, my-owner-project.

    Pastikan properti VM sesuai dengan properti VM reservasi, termasuk zona, jenis mesin (kelompok mesin, vCPU, dan memori), platform CPU minimum, jumlah dan jenis GPU, serta antarmuka dan ukuran SSD lokal.

    gcloud compute instances create instance-2 \
        --machine-type=n2-standard-32 \
        --min-cpu-platform="Intel Cascade Lake" \
        --zone=us-central1-a \
        --reservation-affinity=specific \
        --reservation=projects/my-owner-project/reservations/reservation-02
    

Go

import (
	"context"
	"fmt"
	"io"

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

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

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

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

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

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

	return nil
}

Java

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

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

public class ConsumeSpecificSharedReservation {
  public static void main(String[] args)
      throws IOException, ExecutionException, InterruptedException, TimeoutException {
    // TODO(developer): Replace these variables before running the sample.
    // Project ID or project number of the Cloud project you want to use.
    String projectId = "YOUR_PROJECT_ID";
    // Name of the zone the reservation is located.
    String zone = "us-central1-a";
    // Name of the reservation you want to query.
    String reservationName = "YOUR_RESERVATION_NAME";
    // Name of the VM instance you want to query.
    String instanceName = "YOUR_INSTANCE_NAME";
    // machineType: machine type of the VM being created.
    // *   For a list of machine types, see https://cloud.google.com/compute/docs/machine-types
    String machineTypeName = "n1-standard-4";
    // sourceImage: path to the operating system image to mount.
    // *   For details about images you can mount, see https://cloud.google.com/compute/docs/images
    String sourceImage = "projects/debian-cloud/global/images/family/debian-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";
    // Minimum CPU platform of the instances.
    String minCpuPlatform = "Intel Skylake";

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

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

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

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

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

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

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

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

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

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

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

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

    # Set the reservation affinity to target the specific reservation
    instance.reservation_affinity = compute_v1.ReservationAffinity(
        consume_reservation_type="SPECIFIC_RESERVATION",  # Type of reservation to consume
        key="compute.googleapis.com/reservation-name",
        # To consume this reservation from any consumer projects, specify the owner project of the reservation
        values=[f"projects/{owner_project_id}/reservations/{reservation_name}"],
    )
    # Define the disks for the instance
    instance.disks = [
        compute_v1.AttachedDisk(
            boot=True,  # Indicates that this is a boot disk
            auto_delete=True,  # The disk will be deleted when the instance is deleted
            initialize_params=compute_v1.AttachedDiskInitializeParams(
                source_image="projects/debian-cloud/global/images/family/debian-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
                )
            ],
        )
    ]
    # Create a request to insert the instance
    request = compute_v1.InsertInstanceRequest()
    request.zone = zone
    # The instance will be created in the shared project
    request.project = shared_project_id
    request.instance_resource = instance

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

REST

  1. Buat reservasi bernama reservation-02 dengan kolom specificReservationRequired ditetapkan ke true.

    POST https://compute.googleapis.com/compute/v1/projects/my-owner-project/zones/us-central1-a/reservations
    
    {
      "name":"reservation-02",
      "specificReservation":{
        "count":"10",
        "instanceProperties":{
          "machineType":"n2-standard-32",
          "minCpuPlatform": "Intel Cascade Lake"
        }
      },
      "shareSettings": {
        "shareType": "SPECIFIC_PROJECTS",
        "projectMap": {
          "project-1": {
            "projectId": "project-1"
          },
          "project-2": {
            "projectId": "project-2"
          }
        }
      },
      "specificReservationRequired": true
    }
    
  2. Buat VM yang menargetkan reservation-02 berdasarkan nama menggunakan kolom reservationAffinity. Untuk memakai reservasi ini dari project konsumen yang memakai reservasi bersama ini, Anda juga harus menentukan project pemilik reservasi, my-owner-project.

    Pastikan properti VM sesuai dengan properti VM reservasi, termasuk zona, jenis mesin (kelompok mesin, vCPU, dan memori), platform CPU minimum, jumlah dan jenis GPU, serta antarmuka dan ukuran SSD lokal.

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

Membuat VM tanpa memakai reservasi

Jika Anda membuat reservasi yang digunakan secara otomatis, VM apa pun yang berjalan dengan properti yang cocok di project Anda dapat menggunakan reservasi. Untuk mencegah satu atau beberapa VM Anda menggunakan pemesanan, lakukan tindakan berikut:

  • Tetapkan properti afinitas reservasi VM agar secara eksplisit tidak menggunakan reservasi apa pun seperti yang dijelaskan di bagian ini.

  • Pastikan VM Anda tidak cocok dengan properti VM reservasi.

Untuk membuat VM yang secara eksplisit tidak menggunakan reservasi, pilih salah satu metode berikut:

Membuat VM agar tidak menggunakan reservasi

Untuk membuat VM yang secara eksplisit tidak menggunakan reservasi, pilih salah satu opsi berikut:

Konsol

  1. Di konsol Google Cloud, buka halaman Create an instance.

    Buka halaman Buat instance

  2. Di kolom Nama, masukkan nama untuk VM.

  3. Di daftar Region dan Zone, pilih region dan zona tempat VM akan dibuat.

  4. Di bagian Machine configuration, tentukan jenis mesin yang akan digunakan untuk VM.

  5. Luaskan bagian Opsi lanjutan, lalu lakukan hal berikut:

    1. Luaskan bagian Management.

    2. Di bagian Reservations, dalam daftar Application policy, pilih Don't use.

  6. Klik Create.

gcloud

Untuk membuat VM yang secara eksplisit tidak menggunakan reservasi, gunakan perintah gcloud compute instances create dengan flag --reservation-affinity=none.

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

Ganti kode berikut:

  • VM_NAME: nama VM.

  • MACHINE_TYPE: jenis mesin yang akan digunakan untuk VM.

  • ZONE: zona tempat untuk membuat VM.

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

Untuk membuat VM yang secara eksplisit tidak menggunakan reservasi, buat permintaan POST ke metode instances.insert. Dalam isi permintaan, sertakan kolom consumeReservationType yang ditetapkan ke NO_RESERVATION.

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

{
  "name": "VM_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"
  }
}

Ganti kode berikut:

  • PROJECT_ID: ID project tempat VM akan dibuat.

  • ZONE: zona tempat untuk membuat VM.

  • VM_NAME: nama VM.

  • MACHINE_TYPE: jenis mesin yang akan digunakan untuk VM.

  • IMAGE_PROJECT: project image yang berisi image OS, misalnya, debian-cloud. Untuk informasi selengkapnya tentang project image yang didukung, lihat Image publik.

  • IMAGE: tentukan salah satu dari hal berikut:

    • Versi tertentu dari image OS—misalnya, debian-12-bookworm-v20240617.

    • Kelompok image, yang harus diformat sebagai family/IMAGE_FAMILY. Tindakan ini menentukan image OS terbaru yang masih digunakan. Misalnya, jika Anda menentukan family/debian-12, versi terbaru dalam kelompok image Debian 12 akan digunakan. Untuk mengetahui informasi selengkapnya tentang penggunaan kelompok image, lihat Praktik terbaik kelompok image.

Untuk mengetahui informasi selengkapnya tentang cara membuat VM, lihat Membuat dan memulai instance Compute Engine.

Membuat template instance agar tidak menggunakan reservasi

Untuk membuat template instance yang membuat VM yang tidak secara eksplisit menggunakan reservasi, pilih salah satu opsi berikut:

Konsol

  1. Di konsol Google Cloud, buka halaman Create an instance template.

    Buka Create an instance template

  2. Di kolom Name, masukkan nama untuk template instance.

  3. Di bagian Location, tentukan apakah Anda ingin membuat template instance regional (default) atau global.

  4. Di bagian Machine configuration, tentukan jenis mesin yang akan digunakan untuk VM yang dibuat menggunakan template.

  5. Luaskan bagian Opsi lanjutan, lalu lakukan hal berikut:

    1. Luaskan bagian Management.

    2. Di bagian Reservations, dalam daftar Application policy, pilih Don't use.

  6. Klik Create.

gcloud

Untuk membuat template instance yang membuat VM yang tidak secara eksplisit menggunakan pemesanan, gunakan perintah gcloud compute instances-templates create dengan flag --reservation-affinity=none.

Misalnya, untuk membuat template instance global yang membuat VM yang tidak secara eksplisit menggunakan reservasi, jalankan perintah berikut:

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

Ganti kode berikut:

  • INSTANCE_TEMPLATE_NAME: nama template instance.

  • MACHINE_TYPE: jenis mesin yang akan digunakan untuk VM yang dibuat menggunakan template instance.

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

Untuk membuat template instance yang membuat VM yang tidak secara eksplisit menggunakan reservasi, buat permintaan POST ke salah satu metode berikut:

Dalam isi permintaan, sertakan kolom consumeReservationType dan tetapkan ke NO_RESERVATION.

Misalnya, untuk membuat template instance global yang membuat VM yang tidak secara eksplisit menggunakan reservasi, buat permintaan sebagai berikut:

POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/global/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"
    }
  }
}

Ganti kode berikut:

  • PROJECT_ID: ID project tempat membuat template instance.

  • INSTANCE_TEMPLATE_NAME: nama template instance.

  • MACHINE_TYPE: jenis mesin yang akan digunakan untuk VM yang dibuat menggunakan template instance.

  • IMAGE_PROJECT: project image yang berisi image OS, misalnya, debian-cloud. Untuk informasi selengkapnya tentang project image yang didukung, lihat Image publik.

  • IMAGE: tentukan salah satu dari hal berikut:

    • Versi tertentu dari image OS—misalnya, debian-12-bookworm-v20240617.

    • Kelompok image, yang harus diformat sebagai family/IMAGE_FAMILY. Tindakan ini menentukan image OS terbaru yang masih digunakan. Misalnya, jika Anda menentukan family/debian-12, versi terbaru dalam kelompok image Debian 12 akan digunakan. Untuk mengetahui informasi selengkapnya tentang penggunaan kelompok image, lihat Praktik terbaik kelompok image.

Untuk mengetahui informasi selengkapnya tentang cara membuat template instance, baca Membuat template instance.

Menguji apakah properti VM cocok dengan reservasi

Untuk menguji apakah VM dapat memakai reservasi secara otomatis, Anda dapat membuat salinan reservasi sebagai reservasi tertentu, lalu melihat apakah VM yang akan Anda buat dapat memakai reservasi tersebut. Jika berhasil membuat VM, berarti Anda telah memverifikasi bahwa VM dapat memakai reservasi yang cocok dengan benar. Jika tidak, pembuatan VM akan gagal karena properti tidak cocok atau ada resource yang dipesan tidak tersedia. Setelah pengujian, Anda dapat melakukan satu atau beberapa hal berikut:

Memverifikasi pemakaian reservasi

Untuk memastikan VM menggunakan reservasi secara efektif, Anda dapat memverifikasi penggunaannya menggunakan metode berikut:

  • Melihat detail pemesanan

    Jika jumlah VM yang menggunakan reservasi meningkat sebesar 1 setelah Anda membuat atau mengupdate VM, tindakan Anda mungkin menyebabkan VM mulai menggunakan reservasi. Ini adalah cara tercepat untuk memeriksa apakah pemesanan sedang digunakan. Namun, metode ini mungkin tidak berfungsi dengan baik untuk memverifikasi VM mana yang memakai reservasi.

  • Membuat VM untuk menargetkan reservasi tertentu

    Jika Anda berhasil membuat VM yang menargetkan reservasi tertentu, VM akan memakai reservasi. Ini adalah metode yang paling andal untuk memverifikasi bahwa VM tertentu memakai reservasi dan properti VM cocok dengan properti reservasi.

  • Memantau pemakaian reservasi Anda

    Dengan menggunakan Cloud Monitoring, Anda dapat mengakses dan melihat informasi yang terkait dengan pemakaian reservasi yang dibuat dalam project Anda. Monitoring memperbarui data konsumsi pemesanan Anda setidaknya sekali setiap 30 menit. Metode ini berguna untuk memverifikasi tren pemakaian dari satu atau beberapa reservasi dalam project, serta menerima notifikasi untuk reservasi yang jarang digunakan atau tidak digunakan.

  • Melihat histori penggunaan reservasi Anda

    Dengan menggunakan Capacity Planner (Pratinjau), Anda dapat mengakses dan melihat histori penggunaan reservasi dari pembuatan hingga penghapusannya. Capacity Planner memperbarui data konsumsi pemesanan setiap 24 jam. Metode ini berguna untuk memverifikasi penggunaan pemesanan Anda sebelumnya dalam project, folder, atau organisasi, serta membantu Anda merencanakan kebutuhan kapasitas di masa mendatang.

Jika Anda melihat bahwa VM tidak menggunakan reservasi setelah memverifikasi bahwa afinitas reservasi VM dapat menggunakan reservasi, reservasi tidak digunakan sepenuhnya, dan VM serta properti reservasi cocok, lihat Ketersediaan resource.

Melihat laporan penggunaan reservasi

Ekspor laporan mendetail tentang penggunaan Compute Engine ke bucket Cloud Storage menggunakan fitur ekspor penggunaan. Untuk mengetahui petunjuknya, lihat Melihat laporan penggunaan.

Laporan penggunaan menunjukkan hal berikut:

  • Resource yang direservasi sedang digunakan. Entri ini muncul sebagai vCPU, memori, GPU, dan resource SSD lokal normal.
  • Resource yang direservasi tidak sedang digunakan. Entri ini memiliki nama SKU normal dan URI resource reservasi.
  • Total resource yang direservasi. Entri ini memiliki nama SKU reservasi dan URI resource reservasi. Tidak ada biaya yang terkait dengan entri ini. Gunakan entri ini untuk menghitung jumlah reservasi yang Anda gunakan.
Pengukuran Format MeasurementId Format Resource URI
Resource yang direservasi sedang digunakan com.google.cloud/services/compute-engine/SKU_NAME https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/zones/ZONE/RESOURCE_TYPE/RESOURCE_NAME.

Misalnya, https://compute.googleapis.com/compute/v1/projects/my-project/zones/us-central1-a/instances/my-instance
Resource yang direservasi sedang tidak digunakan com.google.cloud/services/compute-engine/SKU_NAME https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/zones/ZONE/reservations/RESERVATION_NAME.

Misalnya, https://compute.googleapis.com/compute/v1/projects/my-project/zones/europe-west1-b/reservations/my-reservation
Total resource yang direservasi com.google.cloud/services/compute-engine/ReservationSKU_NAME https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/zones/ZONE/reservations/RESERVATION_NAME.

Misalnya, https://compute.googleapis.com/compute/v1/projects/my-project/zones/europe-west1-b/reservations/my-reservation

Misalnya, dalam cuplikan berikut dari laporan penggunaan untuk reservasi bernama my-reservation:

  • Baris 1 menunjukkan RAM yang direservasi saat ini sedang digunakan. Baris ResourceId menunjukkan bahwa RAM ini digunakan oleh VM bernama my-instance.
  • Baris 2 menunjukkan RAM yang direservasi sedang tidak digunakan. Baris ResourceId menunjukkan bahwa RAM yang direservasi ini dipegang oleh my-reservation; belum digunakan oleh VM mana pun.
  • Baris 3 menunjukkan total RAM yang direservasi untuk reservasi.
Report Date,MeasurementId,Quantity,Unit,Resource URI,ResourceId,Location
2019-06-06,com.google.cloud/services/compute-engine/VmimageN2StandardRam,166970074857472,byte-seconds,https://compute.googleapis.com/compute/v1/projects/my-project/zones/us-central2-a/instances/my-instance,1775485842510981624,us-central2-a
2019-06-06,com.google.cloud/services/compute-engine/VmimageN2StandardRam,166970074857472,byte-seconds,https://compute.googleapis.com/compute/v1/projects/my-project/zones/us-central2-a/reservations/my-reservation,7.58809E+17,us-central2-a
2019-06-06,com.google.cloud/services/compute-engine/ReservationN2StandardRam,333940149714944,byte-seconds,https://compute.googleapis.com/compute/v1/projects/my-project/zones/us-central2-a/reservations/my-reservation,7.58809E+17,us-central2-a
...

Memecahkan masalah

Pelajari cara memecahkan masalah terkait pemakaian reservasi.

Langkah selanjutnya