Membuat instance dengan non-boot disk tambahan

Dokumen ini menjelaskan cara membuat dan melampirkan disk non-boot tambahan ke instance Compute Engine saat Anda membuat instance.

Informasi dalam dokumen ini berlaku untuk membuat instance komputasi dengan disk zonal yang tidak berada di kumpulan Hyperdisk. Daftar berikut menjelaskan tugas terkait dan dokumentasi yang relevan.

Sebelum memulai

  • Siapkan autentikasi jika Anda belum melakukannya. Autentikasi memverifikasi identitas Anda untuk mengakses layanan Google Cloud dan API. Untuk menjalankan kode atau sampel dari lingkungan pengembangan lokal, Anda dapat melakukan autentikasi ke Compute Engine dengan memilih salah satu opsi berikut:

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

    Konsol

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

    gcloud

    1. Instal Google Cloud CLI. Setelah penginstalan, inisialisasi Google Cloud CLI dengan menjalankan perintah berikut: 

      gcloud init

      Jika Anda menggunakan penyedia identitas (IdP) eksternal, Anda harus login ke gcloud CLI dengan identitas gabungan Anda terlebih dahulu.

  • Tetapkan region dan zona default.

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

      Jika Anda menggunakan penyedia identitas (IdP) eksternal, Anda harus login ke gcloud CLI dengan identitas gabungan Anda terlebih dahulu.

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

Peran yang diperlukan

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

Peran bawaan ini berisi izin yang diperlukan untuk membuat instance dengan disk non-boot yang ditambahkan. Untuk melihat izin yang benar-benar diperlukan, perluas bagian Izin yang diperlukan:

Izin yang diperlukan

Izin berikut diperlukan untuk membuat instance dengan non-boot disk tambahan:

  • compute.instances.create di project
  • Untuk membuat disk untuk instance: compute.disks.create pada project
  • Untuk membuat disk dari image: compute.images.useReadOnly pada image sumber
  • Untuk membuat disk dari snapshot standar atau arsip: compute.snapshots.useReadOnly pada snapshot sumber
  • Untuk membuat disk dari snapshot instan, jika disk sumber snapshot instan adalah boot disk instance yang memiliki akun layanan terlampir: iam.serviceAccounts.actAs di akun layanan instance
  • Untuk membuat disk dari snapshot instan: compute.instantSnapshots.useReadOnly pada snapshot instan sumber
  • Untuk membuat disk dari disk yang ada: compute.disks.useReadOnly pada disk sumber

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

Batasan

Jumlah, total ukuran gabungan, dan jenis disk yang dapat Anda pasang ke instance bergantung pada jenis mesin instance.

Misalnya, instance C4 tidak mendukung Persistent Disk. Selain itu, ukuran gabungan semua disk yang terpasang ke instance c4-standard-2 tidak boleh melebihi 257 TiB, tetapi untuk instance c4-standard-192, batasnya adalah 512 TiB.

Batas mendetail untuk setiap seri mesin ada di bagian Jenis disk yang didukung dalam dokumentasi seri mesin. Untuk melihat batas seri mesin instance baru, lihat link yang sesuai dalam tabel berikut.

Jenis mesin tujuan umum
 Jenis mesin yang dioptimalkan untuk komputasi
 Jenis mesin yang dioptimalkan untuk memori
 Jenis mesin yang dioptimalkan untuk akselerator
 Jenis mesin yang dioptimalkan untuk penyimpanan

Batas ukuran disk dan nama referensi

Ukuran yang Anda tentukan untuk disk regional harus berada dalam rentang yang tercantum dalam tabel berikut.

Saat membuat disk dengan Google Cloud CLI, REST, atau Cloud Client Libraries untuk Compute Engine, Anda menentukan jenis disk yang akan dibuat dengan nilai yang sesuai dari kolom Nama referensi dalam tabel berikut.

Jenis disk Nama referensi Ukuran minimum Ukuran maksimum Ukuran default
Hyperdisk Balanced hyperdisk-balanced 4 GiB 64 TiB1 100 GiB
Hyperdisk Balanced High Availability hyperdisk-balanced-high-availability 4 GiB 64 TiB 100 GiB
Ekstrem Hyperdisk hyperdisk-extreme 64 GiB 64 TiB 1 TiB
Hyperdisk Throughput hyperdisk-throughput 2 TiB 32 TiB 2 TiB
Hyperdisk ML hyperdisk-ml 4 GiB 64 TiB 100 GiB
Persistent Disk Seimbang pd-balanced Zona: 10 GiB
Regional: 10 GiB		 64 TiB 100 GiB
Persistent Disk Performa (SSD) pd-ssd Zona: 10 GiB
Regional: 10 GiB		 64 TiB 100 GiB
Standard Persistent Disk pd-standard Zona: 10 GiB
Regional: 200 GiB		 64 TiB 500 GiB
Persistent disk ekstrem pd-extreme 500 GiB 64 TiB 1 TiB
1 Pratinjau: C4 mendukung ukuran disk maksimum 128 TiB. Untuk mendapatkan akses ke fitur ini, hubungi hyperdisk-questions@google.com.

Membuat instance dengan non-boot disk tambahan baru

Untuk membuat instance yang memiliki non-boot disk tambahan yang dibuat dan dilampirkan, ikuti langkah-langkah berikut:

Konsol

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

    Buka halaman Buat instance

    Jika diminta, pilih project Anda, lalu klik Lanjutkan.

    Halaman Create an instance akan muncul dan menampilkan panel Machine configuration.

  2. Di panel Machine configuration, lakukan hal berikut:

    1. Di kolom Name, tentukan nama untuk instance Anda. Untuk mengetahui informasi selengkapnya, lihat Konvensi penamaan resource.
    2. Di kolom Region, tentukan region tempat Anda ingin instance berada.

    3. Opsional: Di kolom Zone, pilih zona untuk instance ini.

      Pilihan defaultnya adalah Semua. Jika Anda tidak mengubah pilihan default ini, Google akan otomatis memilih zona untuk Anda berdasarkan jenis dan ketersediaan mesin.

    4. Pilih kelompok mesin untuk instance Anda. Konsol Google Cloud kemudian menampilkan seri mesin yang tersedia untuk kelompok mesin yang Anda pilih. Opsi kelompok mesin berikut tersedia:

      • Tujuan umum
      • Dioptimalkan untuk komputasi
      • Dioptimalkan untuk memori
      • Dioptimalkan untuk penyimpanan
      • GPU

    5. Di kolom Series, pilih seri mesin untuk instance Anda.

      Jika Anda memilih GPU sebagai kelompok mesin pada langkah sebelumnya, pilih GPU type yang Anda inginkan. Seri mesin kemudian dipilih secara otomatis untuk jenis GPU yang dipilih.

    6. Di bagian Machine type, pilih jenis mesin untuk instance Anda.

  3. Di menu navigasi, klik OS dan penyimpanan. Panel Sistem operasi dan penyimpanan akan muncul.

  4. Untuk mengonfigurasi boot disk, klik Change. Panel Boot disk akan muncul dan menampilkan tab Public images.

  5. Konfigurasi sumber data untuk disk boot dengan salah satu cara berikut:

    • Untuk memilih image publik sebagai sumber data untuk disk boot Anda, di tab Public images, tentukan hal berikut:

      1. Dalam daftar Operating system, pilih jenis OS.
      2. Dalam daftar Versi, pilih versi OS.
      3. Pada daftar Boot disk type, pilih jenis boot disk.
      4. Di kolom Size (GB), tentukan ukuran boot disk.

    • Untuk memilih image kustom sebagai sumber data untuk boot disk, klik Custom images, lalu di tab Custom images yang muncul, tentukan hal berikut:

      1. Untuk memilih project image, klik Ubah, lalu pilih project yang berisi image tersebut.
      2. Di dalam daftar Image, pilih gambar yang ingin Anda impor.
      3. Pada daftar Boot disk type, pilih jenis boot disk.
      4. Di kolom Size (GB), tentukan ukuran boot disk.

    • Untuk memilih snapshot standar sebagai sumber data untuk disk booting Anda, klik Snapshot, lalu di tab Snapshot yang muncul, tentukan hal berikut:

      1. Dalam daftar Snapshot, pilih snapshot.
      2. Pada daftar Boot disk type, pilih jenis boot disk.
      3. Di kolom Size (GB), tentukan ukuran boot disk.

    • Untuk memilih snapshot arsip sebagai sumber data untuk disk booting Anda, klik Snapshot arsip, lalu di tab Snapshot arsip yang muncul, tentukan hal berikut:

      1. Dalam daftar Archive snapshot, pilih snapshot arsip.
      2. Pada daftar Boot disk type, pilih jenis boot disk.
      3. Di kolom Size (GB), tentukan ukuran boot disk.

    • Untuk memilih disk yang ada sebagai boot disk, klik Existing disks. Kemudian, di tab Existing disks yang muncul, pilih volume Persistent Disk regional atau Hyperdisk Balanced High Availability yang ada dalam daftar Disk.

  6. Opsional: Jika boot disk adalah volume Hyperdisk Seimbang, Anda dapat menetapkan batas performa untuk disk baru. Nilai yang Anda tentukan harus berada dalam rentang nilai yang didukung.

  7. Opsional: Untuk opsi konfigurasi lanjutan, luaskan bagian Tampilkan konfigurasi lanjutan.

    • Pilih mode pemasangan disk di kolom Mode.
    • Pilih untuk menyimpan atau menghapus disk saat instance dihapus dengan memilih opsi di kolom Aturan penghapusan.
    • Untuk mempermudah identifikasi disk dari dalam OS tamu, tentukan nama perangkat kustom. Di bagian judul Nama perangkat, pilih opsi Gunakan nama perangkat kustom. Di kolom Nama perangkat, masukkan string yang akan digunakan sebagai symlink untuk disk.

  8. Untuk mengonfirmasi opsi boot disk dan kembali ke panel OS and storage, klik Select.

  9. Untuk membuat disk non-boot baru dan memasangnya ke instance, ikuti langkah-langkah berikut untuk setiap disk yang ingin Anda tambahkan.

    1. Di bagian Additional disks, klik Add new disk. Panel Add new disk akan muncul.

    2. Di bagian Konfigurasi disk, di kolom Nama, tentukan nama untuk disk non-boot.

    3. Opsional: di kolom Description, tentukan deskripsi untuk disk.

    4. Pilih sumber data untuk disk baru:

      • Untuk membuat disk kosong yang tidak diformat, di daftar Disk source type, pilih Blank disk.
      • Untuk membuat salinan data yang ada, pilih jenis sumber untuk disk non-boot.

    5. Dalam daftar Disk type, pilih jenis untuk disk non-boot. Jenis mesin harus mendukung jenis disk.

    6. Di kolom Size, tentukan ukuran non-boot disk.

    7. Opsional: Jika disk baru adalah volume Hyperdisk, Anda dapat menetapkan batas performa untuk disk baru. Nilai yang Anda tentukan harus berada dalam rentang nilai yang didukung, dan bergantung pada jenis Hyperdisk, sebagai berikut:

      • Hyperdisk Balanced. Anda dapat mengubah Ukuran, IOPS yang Disediakan, dan Throughput yang Disediakan disk
      • Hyperdisk Ekstrem. Anda dapat mengubah Ukuran dan IOPS yang Disediakan disk.
      • Hyperdisk ML. Anda dapat mengubah Ukuran dan Throughput yang Disediakan disk.
      • Hyperdisk Throughput.Anda dapat mengubah Ukuran dan Throughput yang Disediakan disk.

    8. Opsional: Untuk opsi konfigurasi lanjutan, luaskan bagian Tampilkan konfigurasi lanjutan.

      • Pilih mode pemasangan disk di kolom Mode.
      • Pilih untuk menyimpan atau menghapus disk saat instance dihapus dengan memilih opsi di kolom Aturan penghapusan.
      • Untuk mempermudah identifikasi disk dari dalam OS tamu, tentukan nama perangkat kustom. Di bagian judul Nama perangkat, pilih opsi Gunakan nama perangkat kustom. Di kolom Nama perangkat, masukkan string yang akan digunakan sebagai symlink untuk disk.

    9. Untuk mengonfirmasi opsi Anda dan kembali ke panel OS and storage, klik Simpan.

    Ulangi langkah ini untuk setiap disk non-boot yang ingin Anda buat dan pasang ke instance Anda.

  10. Opsional: tentukan opsi pencadangan dan replikasi untuk instance komputasi Anda. Di menu navigasi, klik Perlindungan data. Di panel Perlindungan data yang muncul, tentukan cara Anda ingin mencadangkan dan mereplikasi data untuk instance komputasi dengan melakukan hal berikut.

    1. Untuk menentukan cara mencadangkan data, pilih opsi untuk Cadangkan data Anda.

    2. Untuk menentukan cara mereplikasi data, lakukan hal berikut:

      1. Jika Anda ingin disk baru untuk instance direplikasi secara sinkron di zona kedua menggunakan jenis disk regional, centang kotak Disk regional.
      1. Jika Anda ingin disk untuk instance direplikasi di region kedua menggunakan Replikasi Asinkron, centang kotak Replikasi asinkron.

    3. Untuk menggunakan opsi perlindungan data yang ditentukan hanya pada disk non-boot, centang kotak Kecualikan disk boot.

  11. Di menu navigasi, klik Networking. Di panel Networking yang muncul, lakukan hal berikut:

    1. Buka bagian Firewall.

    2. Untuk mengizinkan traffic HTTP atau HTTPS ke instance, pilih Allow HTTP traffic atau Allow HTTPS traffic.

      Compute Engine menambahkan tag jaringan ke instance Anda dan membuat aturan firewall masuk yang sesuai, yang mengizinkan semua traffic masuk di tcp:80 (HTTP) atau tcp:443 (HTTPS). Tag jaringan mengaitkan aturan firewall dengan instance. Untuk mengetahui informasi selengkapnya, lihat Ringkasan aturan firewall dalam dokumentasi Cloud Next Generation Firewall.

  12. Opsional: Tentukan opsi konfigurasi lainnya. Untuk mengetahui informasi selengkapnya, lihat Opsi konfigurasi selama pembuatan instance.

  13. Untuk membuat dan memulai instance, klik Create.

gcloud

  1. Di konsol Google Cloud , aktifkan Cloud Shell.

    Aktifkan Cloud Shell

    Di bagian bawah konsol Google Cloud , sesi Cloud Shell akan dimulai dan menampilkan perintah command line. Cloud Shell adalah lingkungan shell dengan Google Cloud CLI yang sudah terinstal, dan dengan nilai yang sudah ditetapkan untuk project Anda saat ini. Diperlukan waktu beberapa detik untuk melakukan inisialisasi pada sesi.

  2. Jalankan perintah gcloud compute instances create untuk membuat instance dengan non-boot disk tambahan.

    Anda dapat menambahkan hingga 127 disk non-boot saat Anda sedang membuat instance. Tentukan flag --create-disk untuk setiap non-boot disk yang Anda buat.

    Untuk membuat non-boot disk dari image publik atau stok, tentukan properti image atau image-family, dan image-project dengan flag --create-disk. Untuk membuat disk kosong, jangan sertakan properti ini.

    Anda dapat secara opsional menyertakan nilai untuk properti berikut:

    • Ukuran disk: gunakan properti --size.
    • Jenis disk: gunakan properti --type.
    • Disk regional: sertakan properti replica-zones.
    gcloud compute instances create INSTANCE_NAME \
    --zone=ZONE \
    --machine-type=MACHINE_TYPE \
    --image-project=BOOT_DISK_IMAGE_PROJECT \
    BOOT_DISK_IMAGE_FLAG \
    --create-disk name=DISK_NAME,device-name=DISK_DEVICE_NAME,size=SIZE_GB,type=DISK_TYPE,image=DISK_IMAGE,image-project=DISK_IMAGE_PROJECT,replica-zones=^:^ZONE:REMOTE_ZONE,boot=false

    Ganti kode berikut:

    • INSTANCE_NAME: name instance baru.
    • ZONE: zona tempat instance dibuat.
    • MACHINE_TYPE: jenis mesin untuk instance. Contoh, c3-standard-4.
    • BOOT_DISK_IMAGE_PROJECT: project yang berisi gambar. Misalnya, untuk Debian, debian-cloud. Untuk menemukan project image bagi image publik, buka halaman Detail sistem operasi. Di bagian Versi GA untuk OS Anda, project image dicantumkan di kolom Project image pada tab Informasi umum.

    • BOOT_DISK_IMAGE_FLAG: tentukan salah satu dari berikut ini:

      • Gunakan flag --image IMAGE_NAME untuk menentukan versi tertentu dari image publik atau kustom. Contoh, --image debian-12-bookworm-v20241112.

      • Gunakan flag --image-family IMAGE_FAMILY_NAME untuk menentukan kelompok image. Tindakan ini akan membuat instance yang menggunakan OS image terbaru yang masih digunakan dalam kelompok image. Misalnya, jika Anda menentukan --image-family debian-12, Compute Engine akan menggunakan versi OS image terbaru dalam kelompok image Debian 12 saat membuat instance.

    • Untuk disk tambahan, ganti opsi berikut ini:

      • DISK_NAME: opsional: nama disk non-boot.
      • SIZE_GB: opsional: ukuran non-boot disk.
      • DISK_TYPE: jenis disk. Misalnya, hyperdisk-balanced. Jenis mesin harus mendukung jenis disk.
      • DISK_DEVICE_NAME: opsional: nama untuk disk yang ditampilkan ke OS tamu setelah instance dibuat.
      • DISK_IMAGE: opsional: Untuk membuat disk dari image yang ada, tentukan salah satu hal berikut:
        • image=DISK_IMAGE_NAME: nama image yang ingin Anda gunakan untuk membuat non-boot disk, misalnya, debian-12-bookworm-v20260210.
        • image-family=DISK_IMAGE_FAMILY: kelompok image yang akan digunakan saat membuat non-boot disk, misalnya, debian-12.
      • DISK_IMAGE_PROJECT: opsional: untuk membuat disk non-boot dari image yang ada, tentukan project image yang berisi image tersebut.
      • REMOTE_ZONE: opsional: jika membuat disk regional, tentukan zona tempat disk harus direplikasi, misalnya, us-central1-b.

      Untuk disk kosong, jangan tentukan parameter image, image-project, atau image-family.

      Untuk disk zonal, jangan tentukan properti disk replica-zones.

Terraform

Untuk membuat kode Terraform, Anda dapat menggunakan komponen Kode yang setara di konsol Google Cloud .
  1. Di konsol Google Cloud , buka halaman VM instances.

    Buka Instance VM

  2. Klik Create instance.
  3. Tentukan parameter yang Anda inginkan.
  4. Di bagian atas atau bawah halaman, klik Kode yang setara, lalu klik tab Terraform untuk melihat kode Terraform.

Go

Sebelum mencoba contoh ini, ikuti petunjuk penyiapan Go di panduan memulai Compute Engine menggunakan library klien. Untuk informasi selengkapnya, lihat dokumentasi referensi API Go Compute Engine.

Untuk melakukan autentikasi ke Compute Engine, siapkan Kredensial Default Aplikasi. Untuk mengetahui informasi selengkapnya, lihat Menyiapkan autentikasi untuk library klien. 

import (
	"context"
	"fmt"
	"io"

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

// createWithAdditionalDisk create a new VM instance with Debian 10 operating system and a 11 GB additional empty disk.
func createWithAdditionalDisk(w io.Writer, projectID, zone, instanceName string) error {
	// projectID := "your_project_id"
	// zone := "europe-central2-b"
	// instanceName := "your_instance_name"

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

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

	// List of public operating system (OS) images: https://cloud.google.com/compute/docs/images/os-details.
	newestDebianReq := &computepb.GetFromFamilyImageRequest{
		Project: "debian-cloud",
		Family:  "debian-12",
	}
	newestDebian, err := imagesClient.GetFromFamily(ctx, newestDebianReq)
	if err != nil {
		return fmt.Errorf("unable to get image from family: %w", err)
	}

	req := &computepb.InsertInstanceRequest{
		Project: projectID,
		Zone:    zone,
		InstanceResource: &computepb.Instance{
			Name: proto.String(instanceName),
			Disks: []*computepb.AttachedDisk{
				{
					InitializeParams: &computepb.AttachedDiskInitializeParams{
						DiskSizeGb:  proto.Int64(10),
						SourceImage: newestDebian.SelfLink,
						DiskType:    proto.String(fmt.Sprintf("zones/%s/diskTypes/pd-standard", zone)),
					},
					AutoDelete: proto.Bool(true),
					Boot:       proto.Bool(true),
					Type:       proto.String(computepb.AttachedDisk_PERSISTENT.String()),
				},
				{
					InitializeParams: &computepb.AttachedDiskInitializeParams{
						DiskSizeGb: proto.Int64(11),
						DiskType:   proto.String(fmt.Sprintf("zones/%s/diskTypes/pd-standard", zone)),
					},
					AutoDelete: proto.Bool(true),
					Boot:       proto.Bool(false),
					Type:       proto.String(computepb.AttachedDisk_PERSISTENT.String()),
				},
			},
			MachineType: proto.String(fmt.Sprintf("zones/%s/machineTypes/n1-standard-1", zone)),
			NetworkInterfaces: []*computepb.NetworkInterface{
				{
					Name: proto.String("global/networks/default"),
				},
			},
		},
	}

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

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

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

	return nil
}

Java

Sebelum mencoba contoh ini, ikuti petunjuk penyiapan Java di panduan memulai Compute Engine menggunakan library klien. Untuk informasi selengkapnya, lihat dokumentasi referensi API Java Compute Engine.

Untuk melakukan autentikasi ke Compute Engine, siapkan Kredensial Default Aplikasi. Untuk mengetahui informasi selengkapnya, lihat Menyiapkan autentikasi untuk library klien. 


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

public class CreateInstancesAdvanced {

  /**
   * Create an AttachedDisk object to be used in VM instance creation. Uses an image as the source
   * for the new disk.
   *
   * @param diskType the type of disk you want to create. This value uses the following format:
   * "zones/{zone}/diskTypes/(pd-standard|pd-ssd|pd-balanced|pd-extreme)". For example:
   * "zones/us-west3-b/diskTypes/pd-ssd"
   * @param diskSizeGb size of the new disk in gigabytes
   * @param boot boolean flag indicating whether this disk should be used as a boot disk of an
   * instance
   * @param sourceImage source image to use when creating this disk. You must have read access to
   * this disk. This can be one of the publicly available images or an image from one of your
   * projects. This value uses the following format:
   * "projects/{project_name}/global/images/{image_name}"
   * @return AttachedDisk object configured to be created using the specified image.
   */
  private static AttachedDisk diskFromImage(String diskType, int diskSizeGb, boolean boot,
      String sourceImage) {
    AttachedDisk disk =
        AttachedDisk.newBuilder()
            .setBoot(boot)
            // Remember to set auto_delete to True if you want the disk to be deleted when
            // you delete your VM instance.
            .setAutoDelete(true)
            .setType(Type.PERSISTENT.toString())
            .setInitializeParams(
                AttachedDiskInitializeParams.newBuilder()
                    .setSourceImage(sourceImage)
                    .setDiskSizeGb(diskSizeGb)
                    .setDiskType(diskType)
                    .build())
            .build();
    return disk;
  }


  /**
   * Create an AttachedDisk object to be used in VM instance creation. The created disk contains no
   * data and requires formatting before it can be used.
   *
   * @param diskType the type of disk you want to create. This value uses the following format:
   * "zones/{zone}/diskTypes/(pd-standard|pd-ssd|pd-balanced|pd-extreme)". For example:
   * "zones/us-west3-b/diskTypes/pd-ssd"
   * @param diskSizeGb size of the new disk in gigabytes
   * @return AttachedDisk object configured to be created as an empty disk.
   */
  private static AttachedDisk emptyDisk(String diskType, int diskSizeGb) {
    AttachedDisk disk =
        AttachedDisk.newBuilder()
            .setBoot(false)
            // Remember to set auto_delete to True if you want the disk to be deleted when
            // you delete your VM instance.
            .setAutoDelete(true)
            .setType(Type.PERSISTENT.toString())
            .setInitializeParams(
                AttachedDiskInitializeParams.newBuilder()
                    .setDiskSizeGb(diskSizeGb)
                    .setDiskType(diskType)
                    .build())
            .build();
    return disk;
  }

  /**
   * Send an instance creation request to the Compute Engine API and wait for it to complete.
   *
   * @param project project ID or project number of the Cloud project you want to use.
   * @param zone name of the zone to create the instance in. For example: "us-west3-b"
   * @param instanceName name of the new virtual machine (VM) instance.
   * @param disks a list of compute_v1.AttachedDisk objects describing the disks you want to attach
   * to your new instance.
   * @param machineType machine type of the VM being created. This value uses the following format:
   * "zones/{zone}/machineTypes/{type_name}".
   * For example: "zones/europe-west3-c/machineTypes/f1-micro"
   * @param network name of the network you want the new instance to use. For example:
   * "global/networks/default" represents the network named "default", which is created
   * automatically for each project.
   * @param subnetwork name of the subnetwork you want the new instance to use. This value uses the
   * following format: "regions/{region}/subnetworks/{subnetwork_name}"
   * @return Instance object.
   */
  private static Instance createWithDisks(String project, String zone, String instanceName,
      Vector<AttachedDisk> disks, String machineType, String network, String subnetwork)
      throws IOException, InterruptedException, ExecutionException, TimeoutException {
    try (InstancesClient instancesClient = InstancesClient.create()) {
      // Use the network interface provided in the networkName argument.
      NetworkInterface networkInterface;
      if (subnetwork != null) {
        networkInterface = NetworkInterface.newBuilder()
            .setName(network).setSubnetwork(subnetwork)
            .build();
      } else {
        networkInterface = NetworkInterface.newBuilder()
            .setName(network).build();
      }

      machineType = String.format("zones/%s/machineTypes/%s", zone, machineType);

      // Bind `instanceName`, `machineType`, `disk`, and `networkInterface` to an instance.
      Instance instanceResource =
          Instance.newBuilder()
              .setName(instanceName)
              .setMachineType(machineType)
              .addAllDisks(disks)
              .addNetworkInterfaces(networkInterface)
              .build();

      System.out.printf("Creating instance: %s at %s ", instanceName, zone);

      // Insert the instance in the specified project and zone.
      InsertInstanceRequest insertInstanceRequest = InsertInstanceRequest.newBuilder()
          .setProject(project)
          .setZone(zone)
          .setInstanceResource(instanceResource).build();

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

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

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

      return instancesClient.get(project, zone, instanceName);
    }
  }

  /**
   * Create a new VM instance with Debian 11 operating system and a 11 GB additional empty disk.
   *
   * @param project project ID or project number of the Cloud project you want to use.
   * @param zone name of the zone to create the instance in. For example: "us-west3-b"
   * @param instanceName name of the new virtual machine (VM) instance.
   * @return Instance object.
   */
  public static Instance createWithAdditionalDisk(String project, String zone, String instanceName)
      throws IOException, InterruptedException, ExecutionException, TimeoutException {
    try (ImagesClient imagesClient = ImagesClient.create()) {
      // List of public operating system (OS) images: https://cloud.google.com/compute/docs/images/os-details
      Image image = imagesClient.getFromFamily("debian-cloud", "debian-11");
      String diskType = String.format("zones/%s/diskTypes/pd-standard", zone);
      Vector<AttachedDisk> disks = new Vector<>();
      disks.add(diskFromImage(diskType, 10, true, image.getSelfLink()));
      disks.add(emptyDisk(diskType, 11));
      return createWithDisks(project, zone, instanceName, disks, "n1-standard-1",
          "global/networks/default", null);
    }
  }

Node.js

Sebelum mencoba contoh ini, ikuti petunjuk penyiapan Node.js di panduan memulai Compute Engine menggunakan library klien. Untuk informasi selengkapnya, lihat dokumentasi referensi API Node.js Compute Engine.

Untuk melakukan autentikasi ke Compute Engine, siapkan Kredensial Default Aplikasi. Untuk mengetahui informasi selengkapnya, lihat Menyiapkan autentikasi untuk library klien. 

/**
 * TODO(developer): Uncomment and replace these variables before running the sample.
 */
// const projectId = 'YOUR_PROJECT_ID';
// const zone = 'europe-central2-b';
// const instanceName = 'YOUR_INSTANCE_NAME';

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

// Create a new VM instance with Debian 10 operating system and a 11 GB additional empty disk.
async function createWithAdditionalDisk() {
  const instancesClient = new compute.InstancesClient();
  const imagesClient = new compute.ImagesClient();

  // List of public operating system (OS) images: https://cloud.google.com/compute/docs/images/os-details.
  const [newestDebian] = await imagesClient.getFromFamily({
    project: 'debian-cloud',
    family: 'debian-11',
  });

  const [response] = await instancesClient.insert({
    project: projectId,
    zone,
    instanceResource: {
      name: instanceName,
      disks: [
        {
          initializeParams: {
            diskSizeGb: '10',
            sourceImage: newestDebian.selfLink,
            diskType: `zones/${zone}/diskTypes/pd-standard`,
          },
          autoDelete: true,
          boot: true,
          type: 'PERSISTENT',
        },
        {
          initializeParams: {
            diskSizeGb: '11',
            diskType: `zones/${zone}/diskTypes/pd-standard`,
          },
          autoDelete: true,
          boot: false,
          type: 'PERSISTENT',
        },
      ],
      machineType: `zones/${zone}/machineTypes/n1-standard-1`,
      networkInterfaces: [
        {
          name: 'global/networks/default',
        },
      ],
    },
  });
  let operation = response.latestResponse;
  const operationsClient = new compute.ZoneOperationsClient();

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

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

createWithAdditionalDisk();

Python

Sebelum mencoba contoh ini, ikuti petunjuk penyiapan Python di panduan memulai Compute Engine menggunakan library klien. Untuk informasi selengkapnya, lihat dokumentasi referensi API Python Compute Engine.

Untuk melakukan autentikasi ke Compute Engine, siapkan Kredensial Default Aplikasi. Untuk mengetahui informasi selengkapnya, lihat Menyiapkan autentikasi untuk library klien. 

from __future__ import annotations

import re
import sys
from typing import Any
import warnings

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


def get_image_from_family(project: str, family: str) -> compute_v1.Image:
    """
    Retrieve the newest image that is part of a given family in a project.

    Args:
        project: project ID or project number of the Cloud project you want to get image from.
        family: name of the image family you want to get image from.

    Returns:
        An Image object.
    """
    image_client = compute_v1.ImagesClient()
    # List of public operating system (OS) images: https://cloud.google.com/compute/docs/images/os-details
    newest_image = image_client.get_from_family(project=project, family=family)
    return newest_image


def disk_from_image(
    disk_type: str,
    disk_size_gb: int,
    boot: bool,
    source_image: str,
    auto_delete: bool = True,
) -> compute_v1.AttachedDisk:
    """
    Create an AttachedDisk object to be used in VM instance creation. Uses an image as the
    source for the new disk.

    Args:
         disk_type: the type of disk you want to create. This value uses the following format:
            "zones/{zone}/diskTypes/(pd-standard|pd-ssd|pd-balanced|pd-extreme)".
            For example: "zones/us-west3-b/diskTypes/pd-ssd"
        disk_size_gb: size of the new disk in gigabytes
        boot: boolean flag indicating whether this disk should be used as a boot disk of an instance
        source_image: source image to use when creating this disk. You must have read access to this disk. This can be one
            of the publicly available images or an image from one of your projects.
            This value uses the following format: "projects/{project_name}/global/images/{image_name}"
        auto_delete: boolean flag indicating whether this disk should be deleted with the VM that uses it

    Returns:
        AttachedDisk object configured to be created using the specified image.
    """
    boot_disk = compute_v1.AttachedDisk()
    initialize_params = compute_v1.AttachedDiskInitializeParams()
    initialize_params.source_image = source_image
    initialize_params.disk_size_gb = disk_size_gb
    initialize_params.disk_type = disk_type
    boot_disk.initialize_params = initialize_params
    # Remember to set auto_delete to True if you want the disk to be deleted when you delete
    # your VM instance.
    boot_disk.auto_delete = auto_delete
    boot_disk.boot = boot
    return boot_disk


def empty_disk(
    disk_type: str, disk_size_gb: int, boot: bool = False, auto_delete: bool = True
) -> compute_v1.AttachedDisk():
    """
    Create an AttachedDisk object to be used in VM instance creation. The created disk contains
    no data and requires formatting before it can be used.

    Args:
         disk_type: the type of disk you want to create. This value uses the following format:
            "zones/{zone}/diskTypes/(pd-standard|pd-ssd|pd-balanced|pd-extreme)".
            For example: "zones/us-west3-b/diskTypes/pd-ssd"
        disk_size_gb: size of the new disk in gigabytes
        boot: boolean flag indicating whether this disk should be used as a boot disk of an instance
        auto_delete: boolean flag indicating whether this disk should be deleted with the VM that uses it

    Returns:
        AttachedDisk object configured to be created as an empty disk.
    """
    disk = compute_v1.AttachedDisk()
    initialize_params = compute_v1.AttachedDiskInitializeParams()
    initialize_params.disk_type = disk_type
    initialize_params.disk_size_gb = disk_size_gb
    disk.initialize_params = initialize_params
    # Remember to set auto_delete to True if you want the disk to be deleted when you delete
    # your VM instance.
    disk.auto_delete = auto_delete
    disk.boot = boot
    return disk


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

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

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

    Returns:
        Whatever the operation.result() returns.

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

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

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

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

    return result


def create_instance(
    project_id: str,
    zone: str,
    instance_name: str,
    disks: list[compute_v1.AttachedDisk],
    machine_type: str = "n1-standard-1",
    network_link: str = "global/networks/default",
    subnetwork_link: str = None,
    internal_ip: str = None,
    external_access: bool = False,
    external_ipv4: str = None,
    accelerators: list[compute_v1.AcceleratorConfig] = None,
    preemptible: bool = False,
    spot: bool = False,
    instance_termination_action: str = "STOP",
    custom_hostname: str = None,
    delete_protection: bool = False,
) -> compute_v1.Instance:
    """
    Send an instance creation request to the Compute Engine API and wait for it to complete.

    Args:
        project_id: project ID or project number of the Cloud project you want to use.
        zone: name of the zone to create the instance in. For example: "us-west3-b"
        instance_name: name of the new virtual machine (VM) instance.
        disks: a list of compute_v1.AttachedDisk objects describing the disks
            you want to attach to your new instance.
        machine_type: machine type of the VM being created. This value uses the
            following format: "zones/{zone}/machineTypes/{type_name}".
            For example: "zones/europe-west3-c/machineTypes/f1-micro"
        network_link: name of the network you want the new instance to use.
            For example: "global/networks/default" represents the network
            named "default", which is created automatically for each project.
        subnetwork_link: name of the subnetwork you want the new instance to use.
            This value uses the following format:
            "regions/{region}/subnetworks/{subnetwork_name}"
        internal_ip: internal IP address you want to assign to the new instance.
            By default, a free address from the pool of available internal IP addresses of
            used subnet will be used.
        external_access: boolean flag indicating if the instance should have an external IPv4
            address assigned.
        external_ipv4: external IPv4 address to be assigned to this instance. If you specify
            an external IP address, it must live in the same region as the zone of the instance.
            This setting requires `external_access` to be set to True to work.
        accelerators: a list of AcceleratorConfig objects describing the accelerators that will
            be attached to the new instance.
        preemptible: boolean value indicating if the new instance should be preemptible
            or not. Preemptible VMs have been deprecated and you should now use Spot VMs.
        spot: boolean value indicating if the new instance should be a Spot VM or not.
        instance_termination_action: What action should be taken once a Spot VM is terminated.
            Possible values: "STOP", "DELETE"
        custom_hostname: Custom hostname of the new VM instance.
            Custom hostnames must conform to RFC 1035 requirements for valid hostnames.
        delete_protection: boolean value indicating if the new virtual machine should be
            protected against deletion or not.
    Returns:
        Instance object.
    """
    instance_client = compute_v1.InstancesClient()

    # Use the network interface provided in the network_link argument.
    network_interface = compute_v1.NetworkInterface()
    network_interface.network = network_link
    if subnetwork_link:
        network_interface.subnetwork = subnetwork_link

    if internal_ip:
        network_interface.network_i_p = internal_ip

    if external_access:
        access = compute_v1.AccessConfig()
        access.type_ = compute_v1.AccessConfig.Type.ONE_TO_ONE_NAT.name
        access.name = "External NAT"
        access.network_tier = access.NetworkTier.PREMIUM.name
        if external_ipv4:
            access.nat_i_p = external_ipv4
        network_interface.access_configs = [access]

    # Collect information into the Instance object.
    instance = compute_v1.Instance()
    instance.network_interfaces = [network_interface]
    instance.name = instance_name
    instance.disks = disks
    if re.match(r"^zones/[a-z\d\-]+/machineTypes/[a-z\d\-]+$", machine_type):
        instance.machine_type = machine_type
    else:
        instance.machine_type = f"zones/{zone}/machineTypes/{machine_type}"

    instance.scheduling = compute_v1.Scheduling()
    if accelerators:
        instance.guest_accelerators = accelerators
        instance.scheduling.on_host_maintenance = (
            compute_v1.Scheduling.OnHostMaintenance.TERMINATE.name
        )

    if preemptible:
        # Set the preemptible setting
        warnings.warn(
            "Preemptible VMs are being replaced by Spot VMs.", DeprecationWarning
        )
        instance.scheduling = compute_v1.Scheduling()
        instance.scheduling.preemptible = True

    if spot:
        # Set the Spot VM setting
        instance.scheduling.provisioning_model = (
            compute_v1.Scheduling.ProvisioningModel.SPOT.name
        )
        instance.scheduling.instance_termination_action = instance_termination_action

    if custom_hostname is not None:
        # Set the custom hostname for the instance
        instance.hostname = custom_hostname

    if delete_protection:
        # Set the delete protection bit
        instance.deletion_protection = True

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

    # Wait for the create operation to complete.
    print(f"Creating the {instance_name} instance in {zone}...")

    operation = instance_client.insert(request=request)

    wait_for_extended_operation(operation, "instance creation")

    print(f"Instance {instance_name} created.")
    return instance_client.get(project=project_id, zone=zone, instance=instance_name)


def create_with_additional_disk(
    project_id: str, zone: str, instance_name: str
) -> compute_v1.Instance:
    """
    Create a new VM instance with Debian 10 operating system on a 20 GB disk
    and a 25 GB additional empty disk.

    Args:
        project_id: project ID or project number of the Cloud project you want to use.
        zone: name of the zone to create the instance in. For example: "us-west3-b"
        instance_name: name of the new virtual machine (VM) instance.

    Returns:
        Instance object.
    """
    newest_debian = get_image_from_family(project="debian-cloud", family="debian-12")
    disk_type = f"zones/{zone}/diskTypes/pd-standard"
    disks = [
        disk_from_image(disk_type, 20, True, newest_debian.self_link),
        empty_disk(disk_type, 25),
    ]
    instance = create_instance(project_id, zone, instance_name, disks)
    return instance

REST

Anda dapat membuat hingga 127 disk non-boot pada saat membuat instance dengan menggunakan properti initializeParams untuk setiap disk tambahan. Buat disk tambahan dengan image publik atau pribadi. Untuk menambahkan disk yang kosong, tentukan entri initializeParams tanpa nilai sourceImage. Sertakan properti disk replicaZones untuk membuat disk regional, bukan disk zonal.

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

{
   "machineType":"zones/MACHINE_TYPE_ZONE/machineTypes/MACHINE_TYPE",
   "name":"VM_NAME",
   
   "disks":[
      {
         "initializeParams":{
            "sourceImage":"projects/IMAGE_PROJECT/global/images/IMAGE"
         },
         "boot":true
      },
      {
         "initializeParams":{
            "diskSizeGb":"SIZE_GB",
            "sourceImage":"projects/DISK_IMAGE_PROJECT/global/images/DISK_IMAGE",
            "diskType":"DISK_TYPE"
         }
      },
      {
         "initializeParams":{
            "diskSizeGb":"SIZE_GB",
            "diskType":"DISK_TYPE"
         },
      },
      {
         "boot": false,
         "deviceName":"DISK_NAME",
         "initializeParams": {
            "diskType": "DISK_TYPE",
            "replicaZones": [
               "projects/PROJECT_ID/zones/ZONE",
               "projects/PROJECT_ID/zones/REMOTE_ZONE"
            ]
         }
      }
   ],
   
   
   "networkInterfaces":[
      {
         "network":"global/networks/NETWORK_NAME"
      }
   ],
   
  
   "shieldedInstanceConfig":{
      "enableSecureBoot":"ENABLE_SECURE_BOOT"
   }
}

Ganti kode berikut:

  • PROJECT_ID: ID project tempat VM akan dibuat
  • ZONE: zone tempat VM akan dibuat
  • MACHINE_TYPE_ZONE: zona yang berisi jenis mesin yang akan digunakan untuk VM baru
  • MACHINE_TYPE: jenis mesin, telah ditetapkan atau kustom, untuk VM baru
  • VM_NAME: nama VM baru
  • IMAGE_PROJECT: project yang berisi image
    Misalnya, jika Anda menentukan debian-10 sebagai kelompok image, tentukan debian-cloud sebagai project image tersebut.
  • IMAGE: tentukan salah satu dari berikut ini:

    • IMAGE: versi tertentu dari image publik

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

    • IMAGE_FAMILY: kelompok image

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

  • Untuk disk tambahan, ganti opsi berikut ini:

    • SIZE_GB: ukuran disk
    • DISK_IMAGE atau
    • DISK_IMAGE_FAMILY: Tentukan image sumber atau kelompok image untuk non-boot disk:
      • DISK_IMAGE: nama image yang ingin Anda gunakan sebagai non-boot disk. Misalnya, "sourceImage": "projects/DISK_IMAGE_PROJECT/global/images/DISK_IMAGE".
      • DISK_IMAGE_FAMILY: kelompok image yang akan digunakan sebagai non-boot disk. Contoh, "sourceImage": "projects/DISK_IMAGE_PROJECT/global/images/family/DISK_IMAGE_FAMILY".
    • DISK_TYPE: URL lengkap atau sebagian untuk jenis jenis disk. Misalnya, https://www.googleapis.com/compute/v1/projects/PROJECT_ID/zones/ZONE/diskTypes/hyperdisk-balanced. Jenis mesin harus mendukung jenis disk.
    • DISK_NAME: Opsional. Nama disk yang ditampilkan ke OS tamu setelah VM dibuat.

    • REMOTE_ZONE: zone untuk mereplikasi disk regional untuk

    Untuk disk yang kosong, jangan tentukan properti sourceImage.

    Untuk disk zonal, jangan tentukan properti replicaZones.

  • NETWORK_NAME: jaringan VPC yang ingin Anda gunakan untuk VM. Anda dapat menentukan default untuk menggunakan jaringan default Anda.

  • ENABLE_SECURE_BOOT: Jika Anda memilih image yang mendukung fitur Shielded VM, Compute Engine, secara default, akan mengaktifkan virtual trusted platform module (vTPM) dan integrity monitoring. Compute Engine tidak mengaktifkan Booting Aman secara default.

    Jika Anda menentukan true untuk enableSecureBoot, Compute Engine akan membuat VM dengan ketiga fitur Shielded VM diaktifkan. Setelah Compute Engine memulai VM Anda, untuk mengubah opsi Shielded VM, Anda harus menghentikan VM tersebut.

Setelah membuat instance, Anda harus memformat disk kosong dan memasang semua disk. sebelum dapat menggunakannya.