Membuat template instance

---

Halaman ini menjelaskan cara membuat dan mengelola template instance. Dengan template instance, Anda dapat menentukan jenis mesin, boot disk image, jaringan, dan properti VM lainnya yang ingin digunakan saat membuat instance virtual machine (VM).

Anda dapat menggunakan template instance untuk melakukan hal berikut:

• Buat VM individual.
• Buat VM dalam grup instance terkelola (MIG).
• Buat reservasi untuk VM.
• Buat reservasi mendatang untuk VM.

Sebelum memulai

• Baca kapan dan alasan untuk membuat template instance deterministik.
• Baca tentang template instance regional dan global.
• Jika Anda belum melakukannya, siapkan autentikasi. Autentikasi adalah proses yang digunakan untuk memverifikasi identitas Anda agar dapat mengakses Google Cloud layanan dan API. 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

     Note: If you installed the gcloud CLI previously, make sure you have the latest version by running gcloud components update.
  2. Set a default region and zone.

  Terraform

  Untuk menggunakan contoh Terraform 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.

  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 Mengautentikasi untuk menggunakan REST dalam Google Cloud dokumentasi autentikasi.

Batasan

• VPC bersama pada antarmuka selain nic0 untuk template instance didukung di gcloud CLI dan REST, tetapi tidak di Konsol Google Cloud.
• Anda tidak dapat memperbarui template instance yang ada atau mengubah template instance setelah dibuat. Jika template instance sudah tidak berlaku atau Anda perlu mengubah konfigurasi, buat template instance baru.
• Jika ingin menentukan kelompok image dalam template instance, Anda tidak dapat menggunakan konsol Google Cloud. Sebagai gantinya, Anda dapat menggunakan Google Cloud CLI atau REST.
• Jika ingin menentukan disk regional, bukan disk zonal, dalam template instance, Anda tidak dapat menggunakan konsol Google Cloud. Sebagai gantinya, Anda dapat menggunakan Google Cloud CLI atau REST.
• Anda dapat menggunakan template instance untuk membuat VM dengan disk booting Hyperdisk Balanced yang berada di storage pool, jika storage pool berada di zona yang sama dengan tempat VM dibuat. Anda tidak dapat menggunakan template instance global untuk membuat VM dengan disk non-boot yang ada dalam kumpulan penyimpanan.

Membuat template instance

Sebagian besar properti VM yang dapat Anda tentukan dalam permintaan untuk membuat instance VM individual juga dapat ditentukan untuk template instance, termasuk metadata VM, skrip startup, persistent disk, dan akun layanan. Anda harus menentukan jenis mesin, boot disk, dan jaringan.

Buat template instance regional atau global melalui Konsol Google Cloud, Google Cloud CLI, atau API. Untuk membuat template instance global, Anda juga dapat menggunakan Terraform atau Library Klien Cloud.

Izin yang diperlukan untuk langkah ini

Untuk melakukan tugas ini, Anda harus memiliki izin berikut:

• Semua izin yang diperlukan untuk memanggil metode instanceTemplates.insert.

Konsol

1. Di konsol Google Cloud, buka halaman Instance templates.

   Buka Instance templates

   Langkah-langkah lainnya akan muncul di konsol Google Cloud.

2. Klik Create instance template.
3. Pilih Lokasi sebagai berikut:
1. Jika Anda ingin menggunakan template instance di seluruh region, pilih Global.
2. Jika Anda ingin mengurangi dependensi lintas region, pilih Regional.
4. Jika Anda memilih regional, pilih Region tempat Anda ingin membuat template instance.

5. Untuk kolom berikut, terima nilai default atau ubah sesuai kebutuhan. Nilai default berubah berdasarkan kelompok mesin yang Anda pilih.

   • Pilih Jenis mesin.
   • Untuk memperbarui image atau jenis boot disk, di bagian Boot disk, klik Ubah.
   • Untuk memperbarui antarmuka jaringan atau setelan alamat IP, klik Opsi lanjutan, klik Networking, lalu klik antarmuka jaringan yang ingin Anda edit.

6. Opsional: Jika Anda memilih image yang mendukung Shielded VM, ubah setelan Shielded VM instance:

   1. Klik Opsi lanjutan, lalu klik tab Keamanan.
   2. Jika Anda ingin menonaktifkan Booting Aman, hapus centang pada kotak Aktifkan Booting Aman. Booting Aman membantu melindungi instance VM Anda dari malware dan rootkit level booting dan level kernel. Untuk informasi selengkapnya, lihat Booting aman.

   3. Jika Anda ingin menonaktifkan virtual trusted platform module (vTPM), hapus centang pada kotak Aktifkan vTPM. vTPM mengaktifkan Booting terukur, yang memvalidasi integritas pra-booting dan booting VM. Untuk mengetahui informasi selengkapnya, lihat Virtual Trusted Platform Module (vTPM).

      Penting: Menonaktifkan vTPM juga menonaktifkan pemantauan integritas karena pemantauan integritas mengandalkan data yang dikumpulkan oleh Booting terukur.

   4. Jika Anda ingin menonaktifkan pemantauan integritas, hapus centang pada kotak Aktifkan Pemantauan Integritas. Dengan pemantauan integritas, Anda dapat memantau integritas booting instance Shielded VM menggunakan Cloud Monitoring. Untuk mengetahui informasi selengkapnya, lihat Pemantauan integritas.

7. Opsional: Pada bagian Opsi lanjutan, klik tab untuk menyesuaikan template lebih lanjut. Misalnya, Anda dapat menambahkan hingga 15 disk non-boot sekunder.

8. Opsional: Klik Equivalent REST untuk melihat isi permintaan REST, yang menyertakan representasi JSON dari template instance Anda.

9. Klik Buat untuk membuat template.

gcloud

Untuk membuat template instance regional atau global, gunakan perintah instance-templates create. Untuk template instance regional, Anda harus menggunakan flag --instance-template-region untuk menetapkan region template.

Buat template instance regional menggunakan perintah berikut.

gcloud compute instance-templates create INSTANCE_TEMPLATE_NAME \
    --instance-template-region=REGION

Ganti REGION dengan region tempat Anda ingin membuat template instance regional.

Buat template instance global menggunakan perintah berikut:

gcloud compute instance-templates create INSTANCE_TEMPLATE_NAME

Jika Anda tidak menyediakan setelan template eksplisit, gcloud compute akan menggunakan nilai default berikut:

• Jenis mesin: jenis mesin—misalnya, n1-standard-1
• Image: image Debian terbaru
• Boot disk: boot disk standar baru yang diberi nama berdasarkan VM
• Jaringan: jaringan VPC default
• Alamat IP: alamat IPv4 eksternal sementara
• Jenis stack: IPV4_ONLY

Anda juga dapat secara eksplisit menyediakan setelan konfigurasi ini. Contoh:

gcloud compute instance-templates create example-template-custom \
    --machine-type=e2-standard-4 \
    --image-family=debian-12 \
    --image-project=debian-cloud \
    --boot-disk-size=250GB

Anda dapat menambahkan hingga 15 disk non-boot sekunder. Tentukan flag --create-disk untuk setiap disk sekunder yang Anda buat. Untuk membuat disk sekunder dari image publik atau kustom, tentukan properti image dan image-project untuk setiap disk dalam flag --create-disk. Untuk membuat disk kosong, jangan sertakan properti ini. Secara opsional, sertakan properti untuk disk size dan type. Untuk menentukan disk regional, gunakan properti replica-zones.

gcloud compute instance-templates create INSTANCE_TEMPLATE_NAME \
    --machine-type=MACHINE_TYPE \
    --create-disk=image-family=DISK_IMAGE_FAMILY,image-project=DISK_IMAGE_PROJECT,size=SIZE_GB_DISK1 \
    --create-disk=device-name=DISK_NAME,type=DISK_TYPE,size=SIZE_GB_DISK2,replica-zones=^:^ZONE:REMOTE_ZONE,boot=false

Tips: Saat menentukan parameter replica-zones disk, karakter ^:^ menentukan bahwa karakter pemisahan di antara nilai adalah titik dua (:) bukan koma yang diharapkan (,).

Ganti kode berikut:

• INSTANCE_TEMPLATE_NAME: nama untuk template
• MACHINE_TYPE: jenis mesin VM

• DISK_IMAGE_FAMILY: kelompok image untuk digunakan sebagai disk non-boot

  Untuk mengetahui informasi selengkapnya tentang kelompok image, lihat praktik terbaik saat menggunakan kelompok image di Compute Engine.

  Sebagai gantinya, Anda dapat menggunakan flag --image=IMAGE untuk menentukan versi image tertentu.

  Untuk disk kosong, jangan tentukan properti image-family atau image.

• DISK_IMAGE_PROJECT: project image yang berisi image

  Untuk disk yang kosong, jangan tentukan properti image-project. Untuk mengetahui informasi selengkapnya tentang image publik, lihat Image publik.

• SIZE_GB_DISK1 dan SIZE_GB_DISK2: ukuran setiap disk sekunder

• DISK_NAME: Opsional: nama disk yang ditampilkan ke OS tamu setelah VM dibuat.

• DISK_TYPE: Opsional: jenis disk yang akan dibuat. Jika tidak ditentukan, jenis disk default yang digunakan bergantung pada nilai flag --machine-type.

• ZONE dan REMOTE_ZONE: zona untuk membuat disk regional dan zona untuk mereplikasinya.

  Untuk disk zona, jangan sertakan properti replica-zones.

Jika memilih image yang mendukung Shielded VM, Anda juga dapat mengubah setelan Shielded VM instance menggunakan salah satu flag berikut:

• --no-shielded-secure-boot: menonaktifkan Booting Aman

  Booting Aman membantu melindungi instance VM Anda dari malware dan rootkit level booting dan level kernel. Untuk informasi selengkapnya, lihat Booting Aman.

• --no-shielded-vtpm: menonaktifkan virtual trusted platform module (vTPM)

  vTPM mengaktifkan Booting Terukur, yang memvalidasi integritas pra-booting dan booting VM. Untuk mengetahui informasi selengkapnya, lihat Virtual Trusted Platform Module (vTPM).

  Penting: Menonaktifkan vTPM juga menonaktifkan pemantauan integritas karena pemantauan integritas mengandalkan data yang dikumpulkan oleh Booting Terukur.

• --no-shielded-integrity-monitoring: menonaktifkan pemantauan integritas

  Dengan pemantauan integritas, Anda dapat memantau integritas booting instance Shielded VM menggunakan Cloud Monitoring. Untuk mengetahui informasi selengkapnya, lihat Pemantauan integritas.

Untuk mengetahui daftar semua subperintah dan flag yang tersedia, lihat referensi instance-templates.

Template dengan setelan konfigurasi default mungkin terlihat seperti berikut:

gcloud compute instance-templates describe example-template

creationTimestamp: '2019-09-10T16:18:32.042-07:00'
description: ''
id: '6057583701980539406'
kind: compute#instanceTemplate
name: example-template
properties:
  canIpForward: false
  disks:
  - autoDelete: true
    boot: true
    initializeParams:
      sourceImage: https://compute.googleapis.com/compute/v1/projects/debian-cloud/global/images/family/debian-12
    kind: compute#attachedDisk
    mode: READ_WRITE
    type: PERSISTENT
  machineType: c3-standard-4
  networkInterfaces:
  - accessConfigs:
    - kind: compute#accessConfig
      name: external-nat
      type: ONE_TO_ONE_NAT
    network: https://compute.googleapis.com/compute/v1/projects/myproject/global/networks/default
  scheduling:
    automaticRestart: true
    onHostMaintenance: MIGRATE
  serviceAccounts:
  - email: default
    scopes:
    - https://www.googleapis.com/auth/devstorage.read_only
selfLink: https://compute.googleapis.com/compute/v1/projects/myproject/global/instanceTemplates/example-template

Terraform

Untuk membuat template instance, Anda dapat menggunakan resource google_compute_instance_template.

Contoh Terraform berikut mirip dengan perintah gcloud CLI berikut:

gcloud compute instance-templates create my-instance-template \
    --machine-type=c3-standard-4 \
    --image-family=debian-12 \
    --image-project=debian-cloud \
    --boot-disk-size=250GB

resource "google_compute_instance_template" "foobar" {
  name         = "my-instance-template"
  machine_type = "e2-standard-4"

  disk {
    source_image = "debian-cloud/debian-11"
    disk_size_gb = 250
  }

  network_interface {
    network = "default"

    # default access config, defining external IP configuration
    access_config {
      network_tier = "PREMIUM"
    }
  }

  # To avoid embedding secret keys or user credentials in the instances, Google recommends that you use custom service accounts with the following access scopes.
  service_account {
    scopes = [
      "https://www.googleapis.com/auth/cloud-platform"
    ]
  }
}

Untuk mempelajari cara menerapkan atau menghapus konfigurasi Terraform, lihat Perintah dasar Terraform.

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

// createTemplate creates a new instance template with the provided name and a specific instance configuration.
func createTemplate(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()),
							},
						},
					},
				},
			},
		},
	}

	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 com.google.cloud.compute.v1.AccessConfig;
import com.google.cloud.compute.v1.AccessConfig.NetworkTier;
import com.google.cloud.compute.v1.AttachedDisk;
import com.google.cloud.compute.v1.AttachedDiskInitializeParams;
import com.google.cloud.compute.v1.GlobalOperationsClient;
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 java.io.IOException;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.TimeoutException;

public class CreateInstanceTemplate {

  public static void main(String[] args)
      throws IOException, ExecutionException, InterruptedException, TimeoutException {
    // TODO(developer): Replace these variables before running the sample.
    // projectId: project ID or project number of the Cloud project you use.
    // templateName: name of the new template to create.
    String projectId = "your-project-id";
    String templateName = "template-name";
    createInstanceTemplate(projectId, templateName);
  }

  /*
    Create a new instance template with the provided name and a specific
    instance configuration.
   */
  public static void createInstanceTemplate(String projectId, String templateName)
      throws IOException, ExecutionException, InterruptedException, TimeoutException {
    try (InstanceTemplatesClient instanceTemplatesClient = InstanceTemplatesClient.create()) {

      String machineType = "e2-standard-4";
      String sourceImage = "projects/debian-cloud/global/images/family/debian-11";

      // The template describes the size and source image of the boot disk
      // to attach to the instance.
      AttachedDisk attachedDisk = AttachedDisk.newBuilder()
          .setInitializeParams(AttachedDiskInitializeParams.newBuilder()
              .setSourceImage(sourceImage)
              .setDiskType("pd-balanced")
              .setDiskSizeGb(250).build())
          .setAutoDelete(true)
          .setBoot(true).build();

      // The template connects the instance to the `default` network,
      // without specifying a subnetwork.
      NetworkInterface networkInterface = NetworkInterface.newBuilder()
          .setName("global/networks/default")
          // The template lets the instance use an external IP address.
          .addAccessConfigs(AccessConfig.newBuilder()
              .setName("External NAT")
              .setType(AccessConfig.Type.ONE_TO_ONE_NAT.toString())
              .setNetworkTier(NetworkTier.PREMIUM.toString()).build()).build();

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

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

      // Create the Instance Template.
      Operation response = instanceTemplatesClient.insertAsync(insertInstanceTemplateRequest)
          .get(3, TimeUnit.MINUTES);

      if (response.hasError()) {
        System.out.println("Instance Template creation failed ! ! " + response);
        return;
      }
      System.out
          .printf("Instance Template Operation Status %s: %s", templateName, response.getStatus());
    }
  }

  public static void createInstanceTemplateWithDiskType(String projectId, String templateName)
      throws IOException, ExecutionException, InterruptedException, TimeoutException {
    try (InstanceTemplatesClient instanceTemplatesClient = InstanceTemplatesClient.create();
        GlobalOperationsClient globalOperationsClient = GlobalOperationsClient.create()) {

      AttachedDisk disk = AttachedDisk.newBuilder()
          .setInitializeParams(AttachedDiskInitializeParams.newBuilder()
              .setDiskSizeGb(10)
              .setDiskType("pd-balanced")
              .setSourceImage("projects/debian-cloud/global/images/family/debian-11").build())
          .setAutoDelete(true)
          .setBoot(true)
          .setType(AttachedDisk.Type.PERSISTENT.toString()).build();

      InstanceTemplate instanceTemplate = InstanceTemplate.newBuilder()
          .setName(templateName)
          .setProperties(InstanceProperties.newBuilder()
              .setMachineType("n1-standard-1")
              .addDisks(disk)
              .addNetworkInterfaces(NetworkInterface.newBuilder()
                  .setName("global/networks/default").build()).build()).build();

      InsertInstanceTemplateRequest insertInstanceTemplateRequest = InsertInstanceTemplateRequest
          .newBuilder()
          .setProject(projectId)
          .setInstanceTemplateResource(instanceTemplate).build();

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

      if (response.hasError()) {
        System.out.println("Instance Template creation failed ! ! " + response);
        return;
      }
      System.out
          .printf("Instance Template Operation Status %s: %s", templateName, response.getStatus());
    }
  }
}

Node.js

/**
 * TODO(developer): Uncomment and replace these variables before running the sample.
 */
// const projectId = 'YOUR_PROJECT_ID';
// const templateName = 'your_template_name';

const compute = require('@google-cloud/compute');

// Create a new instance template with the provided name and a specific instance configuration.
async function createTemplate() {
  const instanceTemplatesClient = new compute.InstanceTemplatesClient();

  const [response] = await instanceTemplatesClient.insert({
    project: projectId,
    instanceTemplateResource: {
      name: templateName,
      properties: {
        disks: [
          {
            // The template describes the size and source image of the boot disk
            // to attach to the instance.
            initializeParams: {
              diskSizeGb: '250',
              sourceImage:
                'projects/debian-cloud/global/images/family/debian-11',
            },
            autoDelete: true,
            boot: true,
          },
        ],
        machineType: 'e2-standard-4',
        // The template connects the instance to the `default` network,
        // without specifying a subnetwork.
        networkInterfaces: [
          {
            // Use the network interface provided in the networkName argument.
            name: 'global/networks/default',
            // The template lets the instance use an external IP address.
            accessConfigs: [
              {
                name: 'External NAT',
                type: 'ONE_TO_ONE_NAT',
                networkTier: 'PREMIUM',
              },
            ],
          },
        ],
      },
    },
  });
  let operation = response.latestResponse;
  const operationsClient = new compute.GlobalOperationsClient();

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

  console.log('Instance template created.');
}

createTemplate();

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_template(project_id: str, template_name: str) -> compute_v1.InstanceTemplate:
    """
    Create a new instance template with the provided name and a specific
    instance configuration.

    Args:
        project_id: project ID or project number of the Cloud project you use.
        template_name: name of the new template to create.

    Returns:
        InstanceTemplate object that represents the new instance template.
    """
    # The template describes the size and source image of the boot disk
    # to attach to the instance.
    disk = compute_v1.AttachedDisk()
    initialize_params = compute_v1.AttachedDiskInitializeParams()
    initialize_params.source_image = (
        "projects/debian-cloud/global/images/family/debian-11"
    )
    initialize_params.disk_size_gb = 250
    disk.initialize_params = initialize_params
    disk.auto_delete = True
    disk.boot = True

    # The template connects the instance to the `default` network,
    # without specifying a subnetwork.
    network_interface = compute_v1.NetworkInterface()
    network_interface.name = "global/networks/default"

    # The template lets the instance use an external IP address.
    access_config = compute_v1.AccessConfig()
    access_config.name = "External NAT"
    access_config.type_ = "ONE_TO_ONE_NAT"
    access_config.network_tier = "PREMIUM"
    network_interface.access_configs = [access_config]

    template = compute_v1.InstanceTemplate()
    template.name = template_name
    template.properties.disks = [disk]
    template.properties.machine_type = "e2-standard-4"
    template.properties.network_interfaces = [network_interface]

    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 regional, buat permintaan POST ke metode regionInstanceTemplates.insert seperti berikut:

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

Untuk membuat template instance global, buat permintaan POST ke metode instanceTemplates.insert:

POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/global/instanceTemplates

Anda dapat menambahkan hingga 15 disk non-boot sekunder menggunakan properti disks, dengan kolom untuk setiap disk tambahan. Untuk setiap disk tambahan, Anda dapat melakukan hal berikut:

• Buat disk tambahan dengan image publik atau kustom.
• Untuk menambahkan disk kosong, tentukan entri initializeParams tanpa nilai sourceImage.
• Untuk membuat disk regional, tentukan entri initializeParams dengan properti replicaZones.

Dalam isi permintaan, berikan properti template:

{
  "name": "INSTANCE_TEMPLATE_NAME",
  "properties": {
    "machineType": "MACHINE_TYPE",
    "networkInterfaces": [
      {
        "network": "global/networks/default",
        "accessConfigs":
        [
          {
            "name": "external-IP",
            "type": "ONE_TO_ONE_NAT"
          }
        ]
      }
    ],
    "disks":
    [
      {
        "type": "PERSISTENT",
        "boot": true,
        "mode": "READ_WRITE",
        "initializeParams":
        {
          "sourceImage": "projects/IMAGE_PROJECT/global/images/IMAGE"
        }
      },
      {
        "type": "PERSISTENT",
        "boot": false,
        "deviceName": "DISK_NAME",
        "initializeParams":
        {
          "replicaZones": [
              "projects/PROJECT_NAME/zones/ZONE",
              "projects/PROJECT_NAME/zones/REMOTE_ZONE"
          ]
        }
      }
    ]
  }
}

Ganti kode berikut:

• PROJECT_ID: project id Anda
• REGION: region tempat Anda ingin membuat template instance regional
• INSTANCE_TEMPLATE_NAME: nama template instance
• ZONE: zona tempat VM berada

• MACHINE_TYPE: jenis mesin VM

• IMAGE_PROJECT: project image yang berisi image

  Untuk informasi selengkapnya tentang image publik, lihat Image publik.

• IMAGE atau IMAGE_FAMILY: tentukan salah satu dari hal berikut:
  • IMAGE: versi gambar tertentu

    Contoh, "sourceImage": "projects/debian-cloud/global/images/debian-10-buster-v20200309"

  • IMAGE_FAMILY: kelompok image

    Ini akan membuat VM dari OS image terbaru yang masih digunakan. Misalnya, jika Anda menentukan "sourceImage": "projects/debian-cloud/global/images/family/debian-10", Compute Engine akan membuat VM dari versi image OS terbaru dalam kelompok image Debian 10.

    Untuk mengetahui informasi selengkapnya tentang kelompok image, lihat praktik terbaik saat menggunakan kelompok image di Compute Engine.

• DISK_NAME: Opsional: nama disk yang ditampilkan ke OS tamu setelah VM dibuat.

• PROJECT_NAME: project yang terkait dengan VM

• REMOTE_ZONE: zona tempat disk regional harus direplikasi

Anda dapat menentukan salah satu opsi berikut untuk properti disks:

• Tentukan initializeParams untuk membuat boot disk untuk setiap instance. Anda dapat membuat disk menggunakan image publik atau kustom (atau kelompok image) menggunakan properti sourceImage, seperti yang ditunjukkan pada contoh sebelumnya. Untuk menambahkan disk kosong, jangan tentukan sourceImage. Anda juga dapat menambahkan hingga 15 disk non-boot sekunder menggunakan properti initializeParams untuk setiap disk tambahan.

• Tentukan source untuk memasang boot disk yang ada. Jika memasang boot disk yang sudah ada, Anda hanya dapat membuat satu instance dari template.

Secara opsional, Anda dapat menentukan properti diskSizeGb, diskType, dan labels untuk initializeParams dan properti diskSizeGb untuk source.

Jika memilih image yang mendukung Shielded VM, Anda juga dapat mengubah setelan Shielded VM instance dengan menggunakan item isi permintaan Boolean berikut:

• enableSecureBoot: mengaktifkan atau menonaktifkan Booting Aman

  Booting Aman membantu melindungi instance VM Anda dari malware dan rootkit level booting dan level kernel. Untuk informasi selengkapnya, lihat Booting Aman.

• enableVtpm: mengaktifkan atau menonaktifkan virtual trusted platform module (vTPM)

  vTPM mengaktifkan Booting Terukur, yang memvalidasi integritas pra-booting dan booting VM. Untuk mengetahui informasi selengkapnya, lihat Virtual Trusted Platform Module (vTPM).

  Penting: Menonaktifkan vTPM juga menonaktifkan pemantauan integritas karena pemantauan integritas mengandalkan data yang dikumpulkan oleh Booting Terukur.

• enableIntegrityMonitoring: mengaktifkan atau menonaktifkan pemantauan integritas

  Dengan pemantauan integritas, Anda dapat memantau dan memverifikasi integritas booting runtime dari instance Shielded VM menggunakan laporan Cloud Monitoring. Untuk mengetahui informasi selengkapnya, lihat Pemantauan integritas.

Untuk mempelajari parameter permintaan lebih lanjut, lihat metode instanceTemplates.insert.

Membuat template instance berdasarkan instance yang ada

Anda dapat menggunakan REST atau gcloud CLI untuk menyimpan konfigurasi instance VM yang ada sebagai template instance. Anda dapat memilih untuk mengganti cara disk sumber ditentukan dalam template.

Jika Anda perlu mengganti properti lain, buat template instance terlebih dahulu berdasarkan instance yang ada, lalu buat template serupa dengan penggantian tambahan.

Peringatan: Jika instance yang ada berisi alamat IP eksternal statis, alamat tersebut akan disalin ke dalam template instance dan mungkin membatasi penggunaan template tersebut.

Izin yang diperlukan untuk langkah ini

Untuk melakukan tugas ini, Anda harus memiliki izin berikut:

• Semua izin yang diperlukan untuk memanggil metode instanceTemplates.insert.

gcloud

Gunakan perintah gcloud compute instance-templates create dengan flag --source-instance dan --source-instance-zone. Jika ingin membuat template instance regional, Anda juga harus menggunakan flag --instance-template-region untuk menentukan region dari template instance.

Untuk membuat template instance regional, gunakan perintah berikut:

 gcloud compute instance-templates create INSTANCE_TEMPLATE_NAME \
     --source-instance=SOURCE_INSTANCE \
     --source-instance-zone=SOURCE_INSTANCE_ZONE \
     --instance-template-region=REGION

Untuk membuat template instance global, gunakan perintah berikut:

gcloud compute instance-templates create INSTANCE_TEMPLATE_NAME \
    --source-instance=SOURCE_INSTANCE \
    --source-instance-zone=SOURCE_INSTANCE_ZONE

Untuk mengganti cara penentuan disk instance sumber, tambahkan satu atau beberapa flag --configure-disk.

Contoh berikut membuat template instance global dari instance yang ada dan mengganti disk instance sumber dengan spesifikasi yang Anda berikan.

  gcloud compute instance-templates create INSTANCE_TEMPLATE_NAME \
      --source-instance=SOURCE_INSTANCE \
      --source-instance-zone=SOURCE_INSTANCE_ZONE \
      --configure-disk= \
      device-name=SOURCE_DISK, \
      instantiate-from=INSTANTIATE_OPTIONS, \
      auto-delete=AUTO_DELETE

Ganti kode berikut:

• INSTANCE_TEMPLATE_NAME adalah nama template yang akan dibuat.
• SOURCE_INSTANCE adalah nama instance yang akan digunakan sebagai model untuk template baru.
• SOURCE_INSTANCE_ZONE adalah zona yang berisi instance sumber.
• SOURCE_DISK adalah nama disk instance sumber yang ingin Anda ganti dalam template.

• INSTANTIATE_OPTIONS menentukan apakah akan menyertakan disk dan image yang akan digunakan. Nilai yang valid bergantung pada jenis disk:

  • source-image atau source-image-family (hanya valid untuk disk boot dan baca-tulis persistent lainnya). Tentukan opsi ini jika Anda ingin menggunakan image sumber atau kelompok image sumber yang sama dengan yang digunakan untuk membuat disk di instance VM sumber.

  • custom-image (hanya valid untuk disk boot dan baca-tulis persistent lainnya). Jika ingin mempertahankan aplikasi dan setelan dari VM sumber di template instance, Anda dapat membuat image kustom, lalu menentukannya saat membuat template. Jika ditentukan, berikan jalur atau URL untuk image kustom, seperti yang ditunjukkan pada contoh berikut. Atau, Anda dapat menentukan kelompok image menggunakan format berikut:

    --configure-disk=device-name=DATA_DISK_NAME,instantiate-from=custom-image, \
    custom-image=projects/PROJECT_ID/global/images/family/IMAGE_FAMILY_NAME
    

  • attach-read-only (hanya valid untuk disk khusus baca).

  • blank (hanya valid untuk persistent disk non-boot dan SSD lokal). Jika ditentukan, saat template digunakan untuk membuat instance baru, disk akan dibuat tanpa diformat. Anda harus memformat dan memasang disk dalam skrip startup sebelum dapat menggunakannya dalam penyiapan yang skalabel.

  • do-not-include (hanya valid untuk persistent disk non-boot dan disk khusus baca).

• AUTO_DELETE menentukan apakah disk akan dihapus otomatis saat instance dihapus. Nilai yang valid adalah: false, no, true, dan yes.

Misalnya, perintah berikut membuat template instance berdasarkan my-source-instance, dengan opsi untuk menggunakan image asli dari data-disk-a, tetapi menyetel hapus otomatis ke true dan mengganti data-disk-b dengan image kustom.

 gcloud compute instance-templates create my-instance-template  \
     --source-instance=my-source-instance \
     --configure-disk=device-name=data-disk-a,instantiate-from=source-image,auto-delete=true \
     --configure-disk=device-name=data-disk-b,instantiate-from=custom-image,custom-image=projects/cps-cloud/global/images/cos-89-16108-403-15

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

// createTemplateFromInstance creates a new instance template based on an existing instance.
// This new template specifies a different boot disk.
func createTemplateFromInstance(w io.Writer, projectID, instance, templateName string) error {
	// projectID := "your_project_id"
	// instance := "projects/project/zones/zone/instances/instance"
	// 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),
			SourceInstance: proto.String(instance),
			SourceInstanceParams: &computepb.SourceInstanceParams{
				DiskConfigs: []*computepb.DiskInstantiationConfig{
					{
						// Device name must match the name of a disk attached to the instance
						// your template is based on.
						DeviceName: proto.String("disk-1"),
						// Replace the original boot disk image used in your instance with a Rocky Linux image.
						InstantiateFrom: proto.String(computepb.DiskInstantiationConfig_CUSTOM_IMAGE.String()),
						CustomImage:     proto.String("projects/rocky-linux-cloud/global/images/family/rocky-linux-8"),
						// Override the auto_delete setting.
						AutoDelete: proto.Bool(true),
					},
				},
			},
		},
	}

	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 com.google.cloud.compute.v1.DiskInstantiationConfig;
import com.google.cloud.compute.v1.DiskInstantiationConfig.InstantiateFrom;
import com.google.cloud.compute.v1.GlobalOperationsClient;
import com.google.cloud.compute.v1.InsertInstanceTemplateRequest;
import com.google.cloud.compute.v1.InstanceTemplate;
import com.google.cloud.compute.v1.InstanceTemplatesClient;
import com.google.cloud.compute.v1.Operation;
import com.google.cloud.compute.v1.SourceInstanceParams;
import java.io.IOException;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.TimeoutException;

public class CreateTemplateFromInstance {

  public static void main(String[] args)
      throws IOException, ExecutionException, InterruptedException, TimeoutException {
    // TODO(developer): Replace these variables before running the sample.
    // projectId: project ID or project number of the Cloud project you use.
    // instance: the instance to base the new template on. This value uses the following format:
    // **NOTE**: "projects/{project}/zones/{zone}/instances/{instance_name}"
    // templateName: name of the new template to create.
    String projectId = "your-project-id";
    String templateName = "template-name";
    String instance = String.format("projects/%s/zones/%s/instances/%s", projectId, "zone",
        "instanceName");
    createTemplateFromInstance(projectId, templateName, instance);
  }

  // Create a new instance template based on an existing instance.
  // This new template specifies a different boot disk.
  public static void createTemplateFromInstance(String projectId, String templateName,
      String instance)
      throws IOException, ExecutionException, InterruptedException, TimeoutException {
    try (InstanceTemplatesClient instanceTemplatesClient = InstanceTemplatesClient.create();
        GlobalOperationsClient globalOperationsClient = GlobalOperationsClient.create()) {

      SourceInstanceParams sourceInstanceParams = SourceInstanceParams.newBuilder()
          .addDiskConfigs(DiskInstantiationConfig.newBuilder()
              // Device name must match the name of a disk attached to the instance you are
              // basing your template on.
              .setDeviceName("disk-1")
              // Replace the original boot disk image used in your instance
              // with a Rocky Linux image.
              .setInstantiateFrom(InstantiateFrom.CUSTOM_IMAGE.toString())
              .setCustomImage(
                  String.format("projects/%s/global/images/family/%s", "rocky-linux-cloud",
                      "rocky-linux-8"))
              // Override the AutoDelete setting.
              .setAutoDelete(true).build())
          .build();

      InstanceTemplate instanceTemplate = InstanceTemplate.newBuilder()
          .setName(templateName)
          .setSourceInstance(instance)
          .setSourceInstanceParams(sourceInstanceParams)
          .build();

      InsertInstanceTemplateRequest insertInstanceTemplateRequest = InsertInstanceTemplateRequest
          .newBuilder()
          .setProject(projectId)
          .setInstanceTemplateResource(instanceTemplate)
          .build();

      Operation operation = instanceTemplatesClient.insertCallable()
          .futureCall(insertInstanceTemplateRequest).get(3, TimeUnit.MINUTES);

      Operation response = globalOperationsClient.wait(projectId, operation.getName());

      if (response.hasError()) {
        System.out.println("Instance Template creation failed ! ! " + response);
        return;
      }
      System.out.printf("Instance Template creation operation status %s: %s", templateName,
          response.getStatus());
    }
  }
}

Node.js

/**
 * TODO(developer): Uncomment and replace these variables before running the sample.
 */
// const projectId = 'YOUR_PROJECT_ID';
// const instance = 'projects/project/zones/zone/instances/instance';
// const templateName = 'your_template_name';

const compute = require('@google-cloud/compute');

// Create a new instance template based on an existing instance.
// This new template specifies a different boot disk.
async function createTemplateFromInstance() {
  const instanceTemplatesClient = new compute.InstanceTemplatesClient();

  const [response] = await instanceTemplatesClient.insert({
    project: projectId,
    instanceTemplateResource: {
      name: templateName,
      sourceInstance: instance,
      sourceInstanceParams: {
        diskConfigs: [
          {
            // Device name must match the name of a disk attached to the instance
            // your template is based on.
            deviceName: 'disk-1',
            // Replace the original boot disk image used in your instance with a Rocky Linux image.
            instantiateFrom: 'CUSTOM_IMAGE',
            customImage:
              'projects/rocky-linux-cloud/global/images/family/rocky-linux-8',
            // Override the auto_delete setting.
            autoDelete: true,
          },
        ],
      },
    },
  });
  let operation = response.latestResponse;
  const operationsClient = new compute.GlobalOperationsClient();

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

  console.log('Instance template created.');
}

createTemplateFromInstance();

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_template_from_instance(
    project_id: str, instance: str, template_name: str
) -> compute_v1.InstanceTemplate:
    """
    Create a new instance template based on an existing instance.
    This new template specifies a different boot disk.

    Args:
        project_id: project ID or project number of the Cloud project you use.
        instance: the instance to base the new template on. This value uses
            the following format: "projects/{project}/zones/{zone}/instances/{instance_name}"
        template_name: name of the new template to create.

    Returns:
        InstanceTemplate object that represents the new instance template.
    """
    disk = compute_v1.DiskInstantiationConfig()
    # Device name must match the name of a disk attached to the instance you are
    # basing your template on.
    disk.device_name = "disk-1"
    # Replace the original boot disk image used in your instance with a Rocky Linux image.
    disk.instantiate_from = "CUSTOM_IMAGE"
    disk.custom_image = "projects/rocky-linux-cloud/global/images/family/rocky-linux-8"
    # Override the auto_delete setting.
    disk.auto_delete = True

    template = compute_v1.InstanceTemplate()
    template.name = template_name
    template.source_instance = instance
    template.source_instance_params = compute_v1.SourceInstanceParams()
    template.source_instance_params.disk_configs = [disk]

    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 regional, gunakan metode regionInstanceTemplates.insert, atau gunakan metode instanceTemplates.insert untuk membuat template instance global.

Dalam permintaan, Anda harus menentukan kolom sourceInstance. Untuk mengganti cara penentuan disk instance sumber, tambahkan satu atau beberapa kolom diskConfigs.

Misalnya, buat panggilan berikut untuk membuat template instance global dari instance yang ada.

POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/global/instanceTemplates

{
  "name": "INSTANCE_TEMPLATE_NAME",
  "sourceInstance": "zones/SOURCE_INSTANCE_ZONE/instances/SOURCE_INSTANCE",
  "sourceInstanceParams": {
    "diskConfigs": [
      {
        "deviceName": "SOURCE_DISK",
        "instantiateFrom": "INSTANTIATE_OPTIONS",
        "autoDelete": false
      }
    ]
  }
}

Ganti kode berikut:

• PROJECT_ID: project id Anda
• INSTANCE_TEMPLATE_NAME: nama untuk template baru
• SOURCE_INSTANCE_ZONE: zona instance sumber
• SOURCE_INSTANCE: nama instance sumber yang akan digunakan sebagai model untuk template instance ini
• SOURCE_DISK: nama disk instance sumber yang ingin diganti dalam template

• INSTANTIATE_OPTIONS: menentukan apakah akan menyertakan disk dan image yang akan digunakan

  Nilai yang valid bergantung pada jenis disk:

  • source-image atau source-image-family (hanya valid untuk disk boot dan persistent disk baca-tulis lainnya).

  • custom-image (hanya valid untuk disk boot dan baca-tulis persistent lainnya). Jika ingin mempertahankan aplikasi dan setelan dari VM sumber di template instance, Anda dapat membuat image kustom, lalu menentukannya saat membuat template. Jika ditentukan, berikan jalur atau URL untuk image kustom, seperti yang ditunjukkan pada contoh berikut. Atau, Anda dapat menentukan kelompok image menggunakan format berikut:

      "diskConfigs": [
        {
          "deviceName": DATA_DISK_NAME,
          "instantiateFrom": custom-image,
          "customImage": "projects/PROJECT_ID/global/images/family/IMAGE_FAMILY_NAME"
        }
      ]
    

  • attach-read-only (hanya valid untuk disk khusus baca).

  • blank (hanya valid untuk persistent disk non-boot dan SSD lokal). Jika ditentukan, saat template digunakan untuk membuat instance baru, disk akan dibuat tanpa diformat. Anda harus memformat dan memasang disk dalam skrip startup sebelum dapat menggunakannya dalam penyiapan yang skalabel.

  • do-not-include (hanya valid untuk persistent disk non-boot dan disk khusus baca).

Contoh berikut membuat template instance baru berdasarkan my-source-instance. Dalam template instance, image untuk data-disk-a diganti dengan projects/cos-cloud/global/images/cos-89-16108-403-15.

POST https://compute.googleapis.com/compute/v1/projects/my_project/global/instanceTemplates

{
  "name": "my-instance-template",
  "sourceInstance": "zones/us-central1-a/instances/my-source-instance",
  "sourceInstanceParams":
  {
    "diskConfigs":
    [
      {
        "deviceName": "data-disk-a",
        "instantiateFrom": "custom-image",
        "customImage": "projects/cos-cloud/global/images/cos-89-16108-403-15"
      }
    ]
  }
}

Tabel berikut menunjukkan cara menentukan opsi untuk mengganti disk di template.

Jenis disk	Opsi
Boot disk	[Default] Gunakan image sumber atau kelompok image yang sama dengan yang digunakan untuk membuat boot disk di instance sumber. Gunakan URL image apa pun (kustom atau publik) seperti yang dijelaskan dalam contoh sebelumnya atau tentukan kelompok image menggunakan format berikut: projects/exampleproject/global/images/family/IMAGE_FAMILY_NAME
Persistent disk baca/tulis lainnya	[Default] Gunakan image sumber/kelompok image sumber yang sama dengan yang digunakan untuk membuat disk di instance sumber. Catatan: Jika disk instance sumber tidak memiliki properti image sumber/kelompok image sumber, disk tersebut akan disertakan dalam template sebagai disk kosong. Gunakan URL image apa pun (kustom atau publik) seperti yang dijelaskan dalam contoh sebelumnya atau tentukan kelompok image menggunakan format berikut: projects/exampleproject/global/images/family/IMAGE_FAMILY_NAME Sebagai gantinya, gunakan disk kosong di template. Jika template digunakan untuk membuat instance baru, disk ini akan dibuat tanpa format. Anda harus memformat dan memasang disk dalam skrip startup sebelum dapat menggunakannya dalam penyiapan yang skalabel. Jangan sertakan disk.
Disk khusus baca	[Default] Sertakan disk dalam mode khusus baca. Jangan sertakan disk.
SSD Lokal	[Default] Sertakan SSD lokal kosong. Jika template digunakan untuk membuat instance baru, disk ini akan dibuat tanpa diformat. Anda harus memformat dan memasang disk dalam skrip startup sebelum dapat menggunakannya dalam penyiapan yang skalabel.

Untuk setiap disk, Anda juga dapat mengganti atribut auto-delete untuk menentukan apakah disk harus dihapus saat instance terkaitnya dihapus.

Secara default, jika tidak ada opsi penggantian yang ditentukan, konfigurasi disk di template akan cocok dengan instance sumber.

Membuat template instance berdasarkan template yang sudah ada

Anda tidak dapat memperbarui template instance yang sudah ada. Namun, jika template instance sudah usang atau jika Anda perlu membuat perubahan, Anda dapat membuat template lain dengan properti serupa menggunakan konsol.

1. Buka halaman Template instance.

   Buka halaman Template instance

2. Klik template instance yang ingin Anda salin dan perbarui.

3. Klik Buat yang serupa.

4. Perbarui konfigurasi di template baru.

5. Klik Buat.

Membuat template instance untuk VM GPU

Saat membuat template instance, Anda dapat mengonfigurasinya untuk membuat VM yang telah memasang GPU dengan menentukan hal berikut:

• Jenis mesin yang mendukung jenis GPU yang Anda inginkan. Jika Anda ingin membuat template instance regional, jenis GPU yang Anda tentukan dalam template harus tersedia di setidaknya satu zona di region.

• Kebijakan pemeliharaan yang menghentikan VM selama peristiwa pemeliharaan host.

Catatan: Jika Anda ingin menjalankan beban kerja data science atau machine learning, pertimbangkan untuk menggunakan Deep Learning VM Image saat membuat template instance. Deep Learning VM Image adalah kumpulan image VM yang dikemas sebelumnya yang dilengkapi dengan framework machine learning dan alat penting. Untuk mengetahui informasi selengkapnya tentang image ini, lihat Memilih image dalam dokumentasi Deep Learning VM Image.

Izin yang diperlukan untuk langkah ini

Untuk melakukan tugas ini, Anda harus memiliki izin berikut:

• Semua izin yang diperlukan untuk memanggil metode instanceTemplates.insert.

Konsol

Untuk membuat template instance untuk VM GPU, lakukan langkah-langkah berikut:

1. Di konsol Google Cloud, buka halaman Instance templates.

   Buka halaman Template instance

2. Klik Create instance template.

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

4. Di bagian Lokasi, pilih salah satu opsi berikut:

   • Untuk membuat template instance global, pilih Global (default).

   • Untuk membuat template instance regional, pilih Regional, lalu pilih region tempat Anda ingin membuat template instance.

5. Di bagian Machine configuration, lakukan hal berikut:

   1. Klik tab GPU.

   2. Di menu GPU type, pilih jenis GPU.

   3. Di menu Number of GPU, pilih jumlah GPU.

   4. Opsional: Jika model GPU Anda mendukung NVIDIA RTX Virtual Workstations (vWS) untuk workload grafis, dan Anda berencana menjalankan workload yang intensif grafis, pilih Aktifkan Workstation Virtual (NVIDIA GRID).

   5. Di bagian Machine type, pilih jenis mesin.

6. Opsional: Untuk mengubah jenis atau image boot disk nilai default, di bagian Boot disk, klik Change. Kemudian, ikuti petunjuk untuk mengubah disk booting.

7. Klik Buat.

gcloud

Untuk membuat template instance bagi VM GPU, gunakan perintah instance-templates create dengan flag --maintenance-policy yang ditetapkan ke TERMINATE.

Misalnya, untuk membuat template instance global bagi VM GPU, gunakan perintah berikut:

gcloud compute instance-templates create INSTANCE_TEMPLATE_NAME \
    --image-project=IMAGE_PROJECT \
    --image-family=IMAGE_FAMILY \
    --machine-type=MACHINE_TYPE \
    --maintenance-policy=TERMINATE

Ganti kode berikut:

• INSTANCE_TEMPLATE_NAME: nama template instance.

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

• IMAGE_FAMILY atau IMAGE: tentukan salah satu dari hal berikut:

  • IMAGE_FAMILY: kelompok image. Tindakan ini menentukan OS image terbaru yang masih digunakan. Misalnya, jika Anda menentukan debian-10, versi terbaru dalam kelompok image Debian 10 akan digunakan. Untuk mengetahui informasi selengkapnya tentang penggunaan kelompok image, lihat Praktik terbaik kelompok image.

  • IMAGE: versi tertentu dari image OS; misalnya, debian-10-buster-v20200309. Jika memilih untuk menentukan versi image OS tertentu, Anda harus mengganti flag --image-family dengan flag --image.

• MACHINE_TYPE: jenis mesin VM. Jika Anda menentukan jenis mesin N1, sertakan flag --accelerator untuk menentukan jumlah dan jenis GPU yang akan dilampirkan ke VM Anda.

Misalnya, asumsikan Anda ingin membuat template instance global untuk VM GPU yang menentukan properti berikut:

• Jenis mesin standar N1 dengan 2 vCPU.

• Satu GPU NVIDIA T4 untuk dipasang ke VM.

• Debian sebagai project image.

• Debian 10 sebagai kelompok image.

Untuk membuat contoh template instance, gunakan perintah berikut:

gcloud compute instance-templates create instance-template-gpu \
    --accelerator=count=1,type=nvidia-tesla-t4 \
    --machine-type=n1-standard-2 \
    --image-family=debian-10 \
    --image-project=debian-cloud \
    --maintenance-policy=TERMINATE

Terraform

Untuk membuat template instance untuk VM GPU, gunakan resource google_compute_region_instance_template.

Misalnya, untuk membuat template instance global, yang menentukan jenis mesin standar N1 dengan 2 vCPU dan satu GPU NVIDIA T4 yang terpasang, gunakan referensi berikut:

resource "google_compute_instance_template" "default" {
  name         = "gpu-template"
  machine_type = "n1-standard-2"

  disk {
    source_image = "debian-cloud/debian-11"
  }

  network_interface {
    network = "default"
  }

  guest_accelerator {
    type  = "nvidia-tesla-t4"
    count = 1
  }

  scheduling {
    on_host_maintenance = "TERMINATE"
  }
}

Untuk mempelajari cara menerapkan atau menghapus konfigurasi Terraform, lihat Perintah dasar Terraform.

REST

Untuk membuat template instance untuk VM GPU, buat permintaan POST ke metode instanceTemplates.insert. Dalam isi permintaan, sertakan kolom onHostMaintenance dan tetapkan ke TERMINATE.

Misalnya, untuk membuat template instance global untuk VM GPU, buat permintaan POST sebagai berikut:

POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/global/instanceTemplates

{
  "name": "INSTANCE_TEMPLATE_NAME",
  "properties": {
    "disks": [
      {
        "type": "PERSISTENT",
        "boot": true,
        "mode": "READ_WRITE",
        "initializeParams": {
          "sourceImage": "projects/IMAGE_PROJECT/global/images/IMAGE"
        }
      }
    ],
    "machineType": "MACHINE_TYPE",
    "networkInterfaces": [
      {
        "accessConfigs": [
          {
            "name": "external-IP",
            "type": "ONE_TO_ONE_NAT"
          }
        ],
        "network": "global/networks/default"
      }
    ],
    "scheduling": {
      "onHostMaintenance": "TERMINATE"
    }
  }
}

Ganti kode berikut:

• PROJECT_ID: ID project tempat Anda ingin membuat template instance.

• INSTANCE_TEMPLATE_NAME: nama template instance.

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

• IMAGE atau IMAGE_FAMILY: tentukan salah satu dari hal berikut:

  • IMAGE: versi tertentu dari image OS; misalnya, debian-10-buster-v20200309.

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

• MACHINE_TYPE: jenis mesin VM. Jika Anda menentukan jenis mesin N1, sertakan kolom guestAccelerators untuk menentukan jumlah dan jenis GPU yang akan dilampirkan ke VM Anda.

Misalnya, asumsikan Anda ingin membuat template instance global untuk VM GPU yang menentukan properti berikut:

• Jenis mesin standar N1 dengan 2 vCPU.

• Satu GPU NVIDIA T4 untuk dipasang ke VM.

• Debian sebagai project image.

• Debian 10 sebagai kelompok image.

Untuk membuat contoh template instance, buat permintaan POST sebagai berikut:

POST https://compute.googleapis.com/compute/v1/projects/example-project/global/instanceTemplates

{
  "name": "instance-template-gpu",
  "properties": {
    "disks": [
      {
        "type": "PERSISTENT",
        "boot": true,
        "mode": "READ_WRITE",
        "initializeParams": {
          "sourceImage": "projects/debian-cloud/global/images/family/debian-10"
        }
      }
    ],
    "guestAccelerators": [
      {
        "acceleratorType": "nvidia-tesla-t4",
        "acceleratorCount": 1
      }
    ],
    "machineType": "n1-standard-2",
    "networkInterfaces": [
      {
        "accessConfigs": [
          {
            "name": "external-IP",
            "type": "ONE_TO_ONE_NAT"
          }
        ],
        "network": "global/networks/default"
      }
    ],
    "scheduling": {
      "onHostMaintenance": "TERMINATE"
    }
  }
}

Untuk opsi konfigurasi lainnya saat membuat template instance, lihat Membuat template instance dalam dokumen ini.

Membuat template instance dengan image container

Anda dapat menentukan image container di template instance. Secara default, Compute Engine juga menyertakan Image Container-Optimized OS dalam template dengan Docker terinstal. Saat Anda menggunakan template untuk membuat instance baru, container akan diluncurkan secara otomatis saat instance dimulai.

Konsol

1. Buka halaman Template instance.

   Buka halaman Template instance

2. Klik Buat template instance.

3. Di bagian Container, klik Deploy Container.

4. Dalam dialog Configure container, tentukan Container image yang akan digunakan.

   • Anda dapat menentukan image dari Container Registry atau Artifact Registry. Contoh:
     • gcr.io/cloud-marketplace/google/nginx1:TAG, dengan TAG adalah tag yang ditentukan untuk versi tertentu dari image container NGINX yang tersedia di Google Cloud Marketplace.
     • us-docker.pkg.dev/google-samples/containers/gke/hello-app:1.0 memilih sampel image hello-app yang disimpan di Artifact Registry.
   • Jika Anda menggunakan image container dari Docker Hub, selalu tentukan nama lengkap image Docker. Misalnya, tentukan nama image berikut untuk men-deploy image container Apache: docker.io/httpd:2.4.

5. Secara opsional, klik Opsi container lanjutan. Untuk informasi selengkapnya, lihat Mengonfigurasi opsi untuk menjalankan Container.

6. Klik Buat.

gcloud

Gunakan perintah gcloud compute instance-templates create-with-container:

 gcloud compute instance-templates create-with-container INSTANCE_TEMPLATE_NAME \
     --container-image=CONTAINER_IMAGE

Ganti kode berikut:

• INSTANCE_TEMPLATE_NAME: Nama template yang akan dibuat.
• CONTAINER_IMAGE: Nama lengkap image container yang akan digunakan.

Misalnya, perintah berikut membuat template instance baru bernama nginx-vm. Instance VM yang dibuat dari template ini akan diluncurkan dan menjalankan image container, gcr.io/cloud-marketplace/google/nginx1:TAG, saat VM dimulai.

 gcloud compute instance-templates create-with-container nginx-vm \
     --container-image=gcr.io/cloud-marketplace/google/nginx1:TAG

Ganti TAG dengan tag yang ditentukan untuk versi tertentu dari image container NGINX yang tersedia di Google Cloud Marketplace.

Anda juga dapat mengonfigurasi opsi untuk menjalankan container.

Perhatian: Container Registry tidak digunakan lagi dan dijadwalkan untuk dihentikan. Organisasi yang belum menggunakan Container Registry sebelum 8 Januari 2024 memiliki repositori gcr.io baru yang dihosting di Artifact Registry secara default. Mulai 15 Mei 2024, Google Cloud project yang sebelumnya tidak menggunakan Container Registry hanya akan mendukung hosting dan pengelolaan image untuk domain gcr.io di Artifact Registry.

Container Registry dijadwalkan untuk dihentikan pada 18 Maret 2025. Untuk mengetahui detail penghentian penggunaan, lihat Penghentian penggunaan Container Registry.

Membuat template instance yang menentukan subnet

gcloud

Untuk membuat template instance regional atau global, gunakan perintah instance-templates create. Gunakan flag --subnet untuk menempatkan instance yang dibuat dari template ke dalam subnet pilihan Anda. Flag --subnet memerlukan flag --region.

Jika ingin membuat template instance regional, Anda harus menggunakan flag --instance-template-region untuk menetapkan region template. Pastikan Anda menggunakan subnet dari region yang sama dengan tempat Anda ingin membuat template instance regional.

gcloud compute instance-templates create INSTANCE_TEMPLATE_NAME \
    --region=REGION \
    --subnet=SUBNET_NAME_OR_URL \
    --stack-type=STACK_TYPE \
    --instance-template-region=INSTANCE_TEMPLATE_REGION

Ganti kode berikut:

• INSTANCE_TEMPLATE_NAME: nama untuk template instance
• REGION: region subnet

• SUBNET_NAME_OR_URL: nama subnet atau URL-nya

  Catatan: Jika Anda menggunakan nama subnet, Google akan menemukan subnet tersebut di region target (asalkan subnet tersebut ada di sana). Namun, jika Anda menggunakan URL subnet, template instance hanya dapat digunakan untuk membuat instance di region tertentu yang terkait dengan URL subnet.

• STACK_TYPE: Opsional: apakah IPv6 diaktifkan di antarmuka jaringan default. Nilai berikut dapat digunakan: IPV4_ONLY, IPV4_IPV6, atau IPV6_ONLY (Pratinjau). Jika Anda tidak menyertakan flag ini, nilai defaultnya adalah IPV4_ONLY.

• INSTANCE_TEMPLATE_REGION: region tempat Anda ingin membuat template instance. Region ini harus sama dengan REGION.

Contoh berikut membuat template bernama template-qa yang hanya membuat instance dalam subnet subnet-us-qa.

gcloud compute instance-templates create template-qa \
    --region=us-central1 \
    --subnet=subnet-us-qa

Outputnya mirip dengan hal berikut ini:

Created [https://compute.googleapis.com/compute/latest/projects/PROJECT_ID/global/instanceTemplates/template-qa].
NAME        MACHINE_TYPE        PREEMPTIBLE CREATION_TIMESTAMP
template-qa e2-standard-2       2019-12-23T20:34:00.791-07:00

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

// createTemplateWithSubnet creates an instance template that uses a provided subnet.
func createTemplateWithSubnet(w io.Writer, projectID, network, subnetwork, templateName string) error {
	// projectID := "your_project_id"
	// network := "projects/project/global/networks/network"
	// subnetwork := "projects/project/regions/region/subnetworks/subnetwork"
	// 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 specified network and subnetwork.
				NetworkInterfaces: []*computepb.NetworkInterface{
					{
						Network:    proto.String(network),
						Subnetwork: proto.String(subnetwork),
					},
				},
			},
		},
	}

	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 com.google.cloud.compute.v1.AttachedDisk;
import com.google.cloud.compute.v1.AttachedDiskInitializeParams;
import com.google.cloud.compute.v1.GlobalOperationsClient;
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 java.io.IOException;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.TimeoutException;

public class CreateTemplateWithSubnet {

  public static void main(String[] args)
      throws IOException, ExecutionException, InterruptedException, TimeoutException {
    /*
    TODO(developer): Replace these variables before running the sample.
    projectId: project ID or project number of the Cloud project you use.
    network: the network to be used in the new template. This value uses
        the following format: "projects/{project}/global/networks/{network}"
    subnetwork: the subnetwork to be used in the new template. This value
        uses the following format: "projects/{project}/regions/{region}/subnetworks/{subnetwork}"
    templateName: name of the new template to create.
    */
    String projectId = "your-project-id";
    String network = String.format("projects/%s/global/networks/%s", projectId, "network");
    String subnetwork = String.format("projects/%s/regions/%s/subnetworks/%s", projectId, "region",
        "subnetwork");
    String templateName = "template-name";
    createTemplateWithSubnet(projectId, network, subnetwork, templateName);
  }

  // Create an instance template that uses a provided subnet.
  public static void createTemplateWithSubnet(String projectId, String network, String subnetwork,
      String templateName)
      throws IOException, ExecutionException, InterruptedException, TimeoutException {
    try (InstanceTemplatesClient instanceTemplatesClient = InstanceTemplatesClient.create();
        GlobalOperationsClient globalOperationsClient = GlobalOperationsClient.create()) {

      AttachedDisk disk = AttachedDisk.newBuilder()
          .setInitializeParams(AttachedDiskInitializeParams.newBuilder()
              .setSourceImage(
                  String.format("projects/%s/global/images/family/%s", "debian-cloud", "debian-11"))
              .setDiskSizeGb(250).build())
          .setAutoDelete(true)
          .setBoot(true)
          .build();

      InstanceProperties instanceProperties = InstanceProperties.newBuilder()
          .addDisks(disk)
          .setMachineType("e2-standard-4")
          .addNetworkInterfaces(NetworkInterface.newBuilder()
              .setNetwork(network)
              .setSubnetwork(subnetwork).build())
          .build();

      InstanceTemplate instanceTemplate = InstanceTemplate.newBuilder()
          .setName(templateName)
          .setProperties(instanceProperties)
          .build();

      InsertInstanceTemplateRequest insertInstanceTemplateRequest = InsertInstanceTemplateRequest
          .newBuilder()
          .setProject(projectId)
          .setInstanceTemplateResource(instanceTemplate)
          .build();

      Operation operation = instanceTemplatesClient.insertCallable()
          .futureCall(insertInstanceTemplateRequest).get(3, TimeUnit.MINUTES);

      Operation response = globalOperationsClient.wait(projectId, operation.getName());

      if (response.hasError()) {
        System.out.println("Template creation from subnet failed ! ! " + response);
        return;
      }
      System.out.printf("Template creation from subnet operation status %s: %s", templateName,
          response.getStatus());
    }
  }
}

Node.js

/**
 * TODO(developer): Uncomment and replace these variables before running the sample.
 */
// const projectId = 'YOUR_PROJECT_ID';
// const network = 'projects/project/global/networks/network';
// const subnetwork = 'projects/project/regions/region/subnetworks/subnetwork';
// const templateName = 'your_template_name';

const compute = require('@google-cloud/compute');

// Create an instance template that uses a provided subnet.
async function createTemplateWithSubnet() {
  const instanceTemplatesClient = new compute.InstanceTemplatesClient();

  const [response] = await instanceTemplatesClient.insert({
    project: projectId,
    instanceTemplateResource: {
      name: templateName,
      properties: {
        // The template describes the size and source image of the boot disk
        // to attach to the instance.
        disks: [
          {
            // The template describes the size and source image of the boot disk
            // to attach to the instance.
            initializeParams: {
              diskSizeGb: '250',
              sourceImage:
                'projects/debian-cloud/global/images/family/debian-11',
            },
            autoDelete: true,
            boot: true,
          },
        ],
        machineType: 'e2-standard-4',
        // The template connects the instance to the specified network and subnetwork.
        networkInterfaces: [
          {
            network,
            subnetwork,
          },
        ],
      },
    },
  });
  let operation = response.latestResponse;
  const operationsClient = new compute.GlobalOperationsClient();

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

  console.log('Instance template created.');
}

createTemplateWithSubnet();

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_template_with_subnet(
    project_id: str, network: str, subnetwork: str, template_name: str
) -> compute_v1.InstanceTemplate:
    """
    Create an instance template that uses a provided subnet.

    Args:
        project_id: project ID or project number of the Cloud project you use.
        network: the network to be used in the new template. This value uses
            the following format: "projects/{project}/global/networks/{network}"
        subnetwork: the subnetwork to be used in the new template. This value
            uses the following format: "projects/{project}/regions/{region}/subnetworks/{subnetwork}"
        template_name: name of the new template to create.

    Returns:
        InstanceTemplate object that represents the new instance template.
    """
    # The template describes the size and source image of the book disk to
    # attach to the instance.
    disk = compute_v1.AttachedDisk()
    initialize_params = compute_v1.AttachedDiskInitializeParams()
    initialize_params.source_image = (
        "projects/debian-cloud/global/images/family/debian-11"
    )
    initialize_params.disk_size_gb = 250
    disk.initialize_params = initialize_params
    disk.auto_delete = True
    disk.boot = True

    template = compute_v1.InstanceTemplate()
    template.name = template_name
    template.properties = compute_v1.InstanceProperties()
    template.properties.disks = [disk]
    template.properties.machine_type = "e2-standard-4"

    # The template connects the instance to the specified network and subnetwork.
    network_interface = compute_v1.NetworkInterface()
    network_interface.network = network
    network_interface.subnetwork = subnetwork
    template.properties.network_interfaces = [network_interface]

    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)

Menggunakan template ini guna membuat instance untuk MIG (dengan atau tanpa penskalaan otomatis) akan otomatis membuat instance di region dan subnet yang ditentukan. Dengan begitu, Anda dapat mengontrol subnet instance baru yang dibuat untuk load balancing.

Menggunakan image kustom atau image publik di template instance

Anda dapat menggunakan image kustom atau image publik untuk template instance:

• Image kustom. Karena MIG didesain untuk sering menambahkan dan menghapus instance, sebaiknya buat image kustom dan tentukan di template instance. Anda dapat menyiapkan image dengan aplikasi dan setelan yang diperlukan VM, sehingga Anda tidak perlu mengonfigurasi item tersebut secara manual pada setiap VM di MIG.

• Image publik. Anda dapat membuat template instance yang menggunakan image publik dan skrip startup untuk menyiapkan instance setelah mulai berjalan.

Image kustom lebih deterministik dan dimulai lebih cepat daripada VM dengan skrip startup. Namun, skrip startup lebih fleksibel, yang membantu Anda mengupdate aplikasi dan setelan dalam instance.

Jika mengelola image menggunakan kelompok image, Anda dapat menentukan nama kelompok image kustom atau publik dalam template instance. Untuk mengetahui informasi selengkapnya tentang kelompok image, lihat praktik terbaik saat menggunakan kelompok image di Compute Engine.

Catatan: Jika image yang ingin digunakan milik project lain, Anda masih dapat menggunakan image tersebut di template instance, asalkan pemilik project tersebut memberikan akses MIG ke image tersebut. Untuk mengetahui informasi selengkapnya, lihat Memberikan akses MIG ke image.

Langkah berikutnya

• Membuat VM dari template instance.
• Membuat grup instance terkelola zona (MIG).
• Membuat MIG regional.
• Mengupdate VM di MIG yang ada untuk menggunakan konfigurasi dari template baru.
• Membuat pemesanan untuk VM.