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:

Sebelum memulai

  • Baca kapan dan alasan untuk membuat template instance deterministik.
  • Baca tentang template instance regional dan global.
  • Siapkan autentikasi, jika Anda belum melakukannya. Autentikasi adalah proses verifikasi identitas Anda untuk akses ke layanan dan API Google Cloud. Untuk menjalankan kode atau contoh dari lingkungan pengembangan lokal, Anda dapat melakukan autentikasi ke Compute Engine sebagai berikut.

    Pilih tab untuk melihat bagaimana Anda berencana menggunakan contoh di halaman ini:

    Konsol

    Saat menggunakan Konsol Google Cloud untuk mengakses API dan layanan Google Cloud, Anda tidak perlu menyiapkan autentikasi.

    gcloud

    1. Instal Google Cloud CLI, lalu initialize dengan menjalankan perintah berikut: 

      gcloud init
    2. Menetapkan region dan zona default.

    Terraform

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

    1. Menginstal Google Cloud CLI.

    2. Untuk initialize gcloud CLI, jalankan perintah berikut: 

      gcloud init

    3. Buat kredensial autentikasi lokal untuk Akun Google Anda: 

      gcloud auth application-default login

    Untuk informasi selengkapnya, lihat Siapkan autentikasi untuk lingkungan pengembangan lokal.

    Go

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

    1. Menginstal Google Cloud CLI.

    2. Untuk initialize gcloud CLI, jalankan perintah berikut: 

      gcloud init

    3. Buat kredensial autentikasi lokal untuk Akun Google Anda: 

      gcloud auth application-default login

    Untuk informasi selengkapnya, lihat Siapkan autentikasi untuk lingkungan pengembangan lokal.

    Java

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

    1. Menginstal Google Cloud CLI.

    2. Untuk initialize gcloud CLI, jalankan perintah berikut: 

      gcloud init

    3. Buat kredensial autentikasi lokal untuk Akun Google Anda: 

      gcloud auth application-default login

    Untuk informasi selengkapnya, lihat Siapkan autentikasi untuk lingkungan pengembangan lokal.

    Node.js

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

    1. Menginstal Google Cloud CLI.

    2. Untuk initialize gcloud CLI, jalankan perintah berikut: 

      gcloud init

    3. Buat kredensial autentikasi lokal untuk Akun Google Anda: 

      gcloud auth application-default login

    Untuk informasi selengkapnya, lihat Siapkan autentikasi untuk lingkungan pengembangan lokal.

    Python

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

    1. Menginstal Google Cloud CLI.

    2. Untuk initialize gcloud CLI, jalankan perintah berikut: 

      gcloud init

    3. Buat kredensial autentikasi lokal untuk Akun Google Anda: 

      gcloud auth application-default login

    Untuk informasi selengkapnya, lihat Siapkan autentikasi untuk lingkungan pengembangan lokal.

    REST

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

      Instal Google Cloud CLI, lalu initialize dengan menjalankan perintah berikut: 

      gcloud init

Batasan

  • VPC Bersama pada antarmuka selain nic0 untuk template instance didukung di gcloud CLI dan REST, tetapi tidak di Google Cloud Console.
  • 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. Anda dapat menggunakan Google Cloud CLI atau REST sebagai gantinya.
  • Jika ingin menentukan Persistent Disk regional dalam template instance, Anda tidak dapat menggunakan Konsol Google Cloud. Sebagai gantinya, Anda dapat menggunakan Google Cloud CLI atau REST.

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, akun layanan, dan seterusnya. 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.

Konsol

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

    Buka Template instance

    Langkah-langkah selanjutnya akan muncul secara otomatis di konsol Google Cloud.

  2. Klik Buat template instance.
  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).

    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

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 IP eksternal sementara

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-10 \
    --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 persistent disk regional, gunakan properti replica-zones.

gcloud compute instance-templates create INSTANCE_TEMPLATE_NAME \
    --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

Ganti kode berikut:

  • INSTANCE_TEMPLATE_NAME: nama untuk template
  • REGION: region tempat Anda ingin membuat template instance regional

  • 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, defaultnya adalah pd-standard atau pd-balanced, bergantung pada jenis mesinnya.

  • ZONE dan REMOTE_ZONE: zona untuk membuat Persistent 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).

  • --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-10
    kind: compute#attachedDisk
    mode: READ_WRITE
    type: PERSISTENT
  machineType: e2-standard-2
  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=e2-standard-4 \
    --image-family=debian-9 \
    --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/devstorage.read_only",
      "https://www.googleapis.com/auth/logging.write",
      "https://www.googleapis.com/auth/monitoring.write",
      "https://www.googleapis.com/auth/pubsub",
      "https://www.googleapis.com/auth/service.management.readonly",
      "https://www.googleapis.com/auth/servicecontrol",
      "https://www.googleapis.com/auth/trace.append",
    ]
  }
}

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-10").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 persistent 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

      Misalnya, "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 persistent boot disk untuk setiap instance. Anda dapat menambahkan hingga 15 disk non-boot sekunder menggunakan properti initializeParams untuk setiap disk tambahan. Anda dapat membuat disk menggunakan image publik atau kustom (atau kelompok image) di sourceImage seperti yang ditunjukkan pada contoh sebelumnya. Untuk menambahkan disk kosong, jangan tentukan sourceImage.

  • Tentukan source untuk memasang persistent 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).

  • 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.

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.
  • REGION adalah region tempat Anda ingin membuat template instance regional.
  • 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 boot dan disk baca/tulis persisten 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 berlaku untuk persistent disk non-boot dan SSD lokal). Jika ditentukan, saat template digunakan untuk membuat instance baru, disk akan dibuat tanpa format. 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 otomatis dihapus 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 baca/tulis persistent 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:

      --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 berlaku untuk persistent disk non-boot dan SSD lokal). Jika ditentukan, saat template digunakan untuk membuat instance baru, disk akan dibuat tanpa format. 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 Instance templates

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

  3. Klik Buat yang serupa.

  4. Perbarui konfigurasi di template baru.

  5. Klik Create.

Membuat template instance untuk VM GPU

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

Konsol

Untuk membuat template instance untuk VM GPU, lakukan hal berikut:

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

    Buka Instance templates

  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 beban kerja grafis yang intensif, pilih Enable Virtual Workstation (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 boot disk.

  7. Klik Create.

gcloud

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

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

gcloud compute instance-templates create INSTANCE_TEMPLATE_NAME \
    --machine-type=MACHINE_TYPE \
    --maintenance-policy=TERMINATE

Ganti kode berikut:

  • INSTANCE_TEMPLATE_NAME: nama template instance.

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

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

  • Jenis mesin N1 yang telah ditetapkan 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 yang telah ditetapkan sebelumnya dengan 2 vCPU dan satu GPU NVIDIA T4 terpasang, gunakan resource 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 gambar yang berisi gambar; misalnya, debian-cloud. Untuk informasi selengkapnya tentang project gambar yang didukung, lihat Gambar publik.

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

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

    • IMAGE_FAMILY: kelompok image. Tindakan ini menentukan image OS 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 gambar, lihat Praktik terbaik kelompok gambar.

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

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

  • Jenis mesin N1 yang telah ditetapkan 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/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 artikel 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 Instance templates

  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.

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 \
  --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

  • INSTANCE_TEMPLATE_REGION: region tempat Anda ingin membuat template instance. Nama 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

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 dan memungkinkan Anda mengupdate aplikasi serta setelan dalam instance dengan lebih mudah.

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.

Langkah selanjutnya