Halaman ini diterjemahkan oleh Cloud Translation API.

Membuat dan memulai instance Compute Engine

Dokumen ini menjelaskan cara membuat instance virtual machine (VM) atau bare metal menggunakan image disk booting, snapshot disk booting, atau image container. Beberapa image mendukung fitur Shielded VM, yang menawarkan fitur keamanan seperti firmware yang mematuhi UEFI, Booting Aman, dan Booting Terukur yang dilindungi vTPM. Pada Shielded VM, vTPM dan pemantauan integritas diaktifkan secara default.

Saat membuat instance komputasi, Anda dapat membuat satu atau beberapa disk untuknya. Anda juga dapat menambahkan lebih banyak disk ke instance setelah instance tersebut dibuat. Compute Engine akan otomatis memulai instance setelah Anda membuatnya. Untuk membuat instance dengan disk booting yang direplikasi secara sinkron di dua zona, lihat Membuat VM baru dengan disk booting regional.

Saat membuat instance komputasi, Anda juga dapat menambahkan beberapa antarmuka jaringan. Untuk mengurangi eksposur instance Anda terhadap ancaman di internet, Anda dapat menghapus alamat IP eksternal saat menambahkan antarmuka jaringan ke instance. Dalam kasus tersebut, instance hanya dapat diakses dari instance komputasi lain di jaringan VPC yang sama atau jaringan tertaut, kecuali jika Anda mengonfigurasi Cloud NAT.

Jika Anda membuat instance komputasi untuk pertama kalinya, lihat Panduan memulai menggunakan VM Linux atau Panduan memulai menggunakan VM Windows Server.

Untuk pembuatan instance Compute Engine yang lebih spesifik atau rumit, lihat referensi berikut:

Jika Anda membawa lisensi yang ada, lihat Membawa lisensi Anda sendiri.

Sebelum memulai

Saat membuat instance komputasi dari image atau disk menggunakan Google Cloud CLI atau REST, ada batas 20 instance per detik. Jika Anda perlu membuat jumlah instance per detik yang lebih tinggi, minta batas kuota yang lebih tinggi untuk resource Image.
Jika Anda belum melakukannya, siapkan autentikasi. Autentikasi adalah proses verifikasi identitas Anda untuk mengakses layanan dan API Google Cloud. Untuk menjalankan kode atau contoh dari lingkungan pengembangan lokal, Anda dapat mengautentikasi ke Compute Engine dengan memilih salah satu opsi berikut:

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

When you use the Google Cloud console to access Google Cloud services and APIs, you don't need to set up authentication.
gcloud
1. Install the Google Cloud CLI, then initialize it by running the following command:
  gcloud init
  Note: If you installed the gcloud CLI previously, make sure you have the latest version by running gcloud components update.
2. Set a default region and zone.

Peran yang diperlukan

Untuk mendapatkan izin yang diperlukan guna membuat VM, 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 VM. Untuk melihat izin yang benar-benar diperlukan, luaskan bagian Izin yang diperlukan:

Izin yang diperlukan

Izin berikut diperlukan untuk membuat VM:

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

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

Membuat VM instance dari image

Bagian ini menjelaskan cara untuk membuat VM dari OS image publik, atau image kustom. Sebuah VM berisi bootloader, sistem file boot, dan OS image. Jika Anda membuat VM Arm, pilih image OS yang kompatibel dengan Arm.

Melihat daftar image publik yang tersedia di Compute Engine

Sebelum Anda membuat VM dengan menggunakan image publik, tinjau daftar image publik yang tersedia di Compute Engine.

Untuk mengetahui informasi selengkapnya tentang fitur yang tersedia di dalam setiap image publik, lihat Dukungan fitur menurut sistem operasi.

Konsol

Di Konsol Google Cloud, buka halaman Images.

Buka Image

gcloud

Jalankan perintah berikut:
```
gcloud compute images list
```
Catat nama image, atau kelompok image dan nama project yang berisi image tersebut.
Opsional: Untuk menentukan apakah image mendukung fitur Shielded VM, jalankan perintah berikut ini:
```
gcloud compute images describe IMAGE_NAME \
    --project=IMAGE_PROJECT
```
Ganti kode berikut:
- IMAGE_NAME: nama image untuk memeriksa dukungan fitur Shielded VM
- IMAGE_PROJECT: project yang berisi image tersebut
Jika image mendukung fitur Shielded VM, baris berikut ini akan muncul di dalam output: type: UEFI_COMPATIBLE.

C#

Sebelum mencoba contoh ini, ikuti petunjuk penyiapan C# yang berada di dalam Panduan memulai Compute Engine menggunakan library klien. Untuk informasi selengkapnya, lihat dokumentasi referensi API C# Compute Engine.

Untuk melakukan autentikasi ke Compute Engine, siapkan Kredensial Default Aplikasi. Untuk mengetahui informasi selengkapnya, lihat Menyiapkan autentikasi untuk lingkungan pengembangan lokal.


using Google.Cloud.Compute.V1;
using System;
using System.Threading.Tasks;

public class ListImagesAsyncSample
{
    public async Task ListImagesAsync(
        // TODO(developer): Set your own default values for these parameters or pass different values when calling this method.
        string projectId = "your-project-id")
    {
        // Initialize client that will be used to send requests. This client only needs to be created
        // once, and can be reused for multiple requests.
        ImagesClient client = await ImagesClient.CreateAsync();

        // Make the request to list all non-deprecated images in a project.
        ListImagesRequest request = new ListImagesRequest
        {
            Project = projectId,
            // Listing only non-deprecated images to reduce the size of the reply.
            Filter = "deprecated.state != DEPRECATED",
            // MaxResults indicates the maximum number of items that will be returned per page.
            MaxResults = 100
        };

        // Although the MaxResults parameter is specified in the request, the sequence returned
        // by the ListAsync() method hides the pagination mechanic. The library makes multiple
        // requests to the API for you, so you can simply iterate over all the images.
        await foreach (var image in client.ListAsync(request))
        {
            // The result is an Image collection.
            Console.WriteLine($"Image: {image.Name}");
        }
    }
}

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 lingkungan pengembangan lokal.

import (
	"context"
	"fmt"
	"io"

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

// printImagesList prints a list of all non-deprecated image names available in given project.
func printImagesList(w io.Writer, projectID string) error {
	// projectID := "your_project_id"
	ctx := context.Background()
	imagesClient, err := compute.NewImagesRESTClient(ctx)
	if err != nil {
		return fmt.Errorf("NewImagesRESTClient: %w", err)
	}
	defer imagesClient.Close()

	// Listing only non-deprecated images to reduce the size of the reply.
	req := &computepb.ListImagesRequest{
		Project:    projectID,
		MaxResults: proto.Uint32(3),
		Filter:     proto.String("deprecated.state != DEPRECATED"),
	}

	// Although the `MaxResults` parameter is specified in the request, the iterator returned
	// by the `list()` method hides the pagination mechanic. The library makes multiple
	// requests to the API for you, so you can simply iterate over all the images.
	it := imagesClient.List(ctx, req)
	for {
		image, err := it.Next()
		if err == iterator.Done {
			break
		}
		if err != nil {
			return err
		}
		fmt.Fprintf(w, "- %s\n", image.GetName())
	}
	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 lingkungan pengembangan lokal.


import com.google.cloud.compute.v1.Image;
import com.google.cloud.compute.v1.ImagesClient;
import com.google.cloud.compute.v1.ImagesClient.ListPage;
import com.google.cloud.compute.v1.ListImagesRequest;
import java.io.IOException;
  // Prints a list of all non-deprecated image names available in given project.
  public static void listImages(String project) throws IOException {
    // Initialize client that will be used to send requests. This client only needs to be created
    // once, and can be reused for multiple requests. After completing all of your requests, call
    // the `instancesClient.close()` method on the client to
    // safely clean up any remaining background resources.
    try (ImagesClient imagesClient = ImagesClient.create()) {

      // Listing only non-deprecated images to reduce the size of the reply.
      ListImagesRequest imagesRequest = ListImagesRequest.newBuilder()
          .setProject(project)
          .setMaxResults(100)
          .setFilter("deprecated.state != DEPRECATED")
          .build();

      // Although the `setMaxResults` parameter is specified in the request, the iterable returned
      // by the `list()` method hides the pagination mechanic. The library makes multiple
      // requests to the API for you, so you can simply iterate over all the images.
      int imageCount = 0;
      for (Image image : imagesClient.list(imagesRequest).iterateAll()) {
        imageCount++;
        System.out.println(image.getName());
      }
      System.out.printf("Image count in %s is: %s", project, imageCount);
    }
  }

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 lingkungan pengembangan lokal.

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

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

async function listImages() {
  const imagesClient = new compute.ImagesClient();

  // Listing only non-deprecated images to reduce the size of the reply.
  const images = imagesClient.listAsync({
    project: projectId,
    maxResults: 3,
    filter: 'deprecated.state != DEPRECATED',
  });

  // Although the `maxResults` parameter is specified in the request, the iterable returned
  // by the `listAsync()` method hides the pagination mechanic. The library makes multiple
  // requests to the API for you, so you can simply iterate over all the images.
  for await (const image of images) {
    console.log(` - ${image.name}`);
  }
}

listImages();

PHP

Sebelum mencoba contoh ini, ikuti petunjuk penyiapan PHP yang berada di dalam Panduan memulai Compute Engine menggunakan library klien. Untuk informasi selengkapnya, lihat dokumentasi referensi API PHP Compute Engine.

Untuk melakukan autentikasi ke Compute Engine, siapkan Kredensial Default Aplikasi. Untuk mengetahui informasi selengkapnya, lihat Menyiapkan autentikasi untuk lingkungan pengembangan lokal.

use Google\Cloud\Compute\V1\Client\ImagesClient;
use Google\Cloud\Compute\V1\ListImagesRequest;

/**
 * Prints a list of all non-deprecated image names available in given project.
 *
 * @param string $projectId Project ID or project number of the Cloud project you want to list images from.
 *
 * @throws \Google\ApiCore\ApiException if the remote call fails.
 */
function list_all_images(string $projectId)
{
    $imagesClient = new ImagesClient();
    // Listing only non-deprecated images to reduce the size of the reply.
    $optionalArgs = ['maxResults' => 100, 'filter' => 'deprecated.state != DEPRECATED'];

    /**
     * Although the maxResults parameter is specified in the request, the iterateAllElements() method
     * hides the pagination mechanic. The library makes multiple requests to the API for you,
     * so you can simply iterate over all the images.
     */
    $request = (new ListImagesRequest())
        ->setProject($projectId)
        ->setMaxResults($optionalArgs['maxResults'])
        ->setFilter($optionalArgs['filter']);
    $pagedResponse = $imagesClient->list($request);
    print('=================== Flat list of images ===================' . PHP_EOL);
    foreach ($pagedResponse->iterateAllElements() as $element) {
        printf(' - %s' . PHP_EOL, $element->getName());
    }
}

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 lingkungan pengembangan lokal.

import google.cloud.compute_v1 as compute_v1

def print_images_list(project: str) -> str:
    """
    Prints a list of all non-deprecated image names available in given project.

    Args:
        project: project ID or project number of the Cloud project you want to list images from.

    Returns:
        The output as a string.
    """
    images_client = compute_v1.ImagesClient()
    # Listing only non-deprecated images to reduce the size of the reply.
    images_list_request = compute_v1.ListImagesRequest(
        project=project, max_results=100, filter="deprecated.state != DEPRECATED"
    )
    output = []

    # Although the `max_results` parameter is specified in the request, the iterable returned
    # by the `list()` method hides the pagination mechanic. The library makes multiple
    # requests to the API for you, so you can simply iterate over all the images.
    for img in images_client.list(request=images_list_request):
        print(f" -  {img.name}")
        output.append(f" -  {img.name}")
    return "\n".join(output)

Ruby

Sebelum mencoba contoh ini, ikuti petunjuk penyiapan Ruby yang berada di dalam Panduan memulai Compute Engine menggunakan library klien. Untuk informasi selengkapnya, lihat dokumentasi referensi API Ruby Compute Engine.

Untuk melakukan autentikasi ke Compute Engine, siapkan Kredensial Default Aplikasi. Untuk mengetahui informasi selengkapnya, lihat Menyiapkan autentikasi untuk lingkungan pengembangan lokal.


require "google/cloud/compute/v1"

# Prints a list of all non-deprecated image names available in given project.
#
# @param [String] project project ID or project number of the Cloud project you want to list images from.
def print_images_list project:
  client = ::Google::Cloud::Compute::V1::Images::Rest::Client.new

  # Make the request to list all non-deprecated images in a project.
  request = {
    project: project,
    # max_results indicates the maximum number of items that will be returned per page.
    max_results: 100,
    # Listing only non-deprecated images to reduce the size of the reply.
    filter: "deprecated.state != DEPRECATED"
  }

  # Although the `max_results` parameter is specified in the request, the iterable returned
  # by the `list` method hides the pagination mechanic. The library makes multiple
  # requests to the API for you, so you can simply iterate over all the images.
  client.list(request).each do |image|
    puts " - #{image.name}"
  end
end

REST

Jalankan perintah berikut:

GET https://compute.googleapis.com/compute/v1/projects/IMAGE_PROJECT/global/images/

Catat nama image, atau kelompok image dan nama project yang berisi image tersebut.
Opsional: Untuk menentukan apakah image mendukung fitur Shielded VM, jalankan perintah berikut ini:
```
GET https://compute.googleapis.com/compute/v1/projects/IMAGE_PROJECT/global/images/IMAGE_NAME
```
Ganti kode berikut:
- IMAGE_PROJECT: project yang berisi image tersebut
- IMAGE_NAME: nama image untuk memeriksa dukungan fitur Shielded VM
Jika image mendukung fitur Shielded VM, baris berikut ini akan muncul di dalam output: type: UEFI_COMPATIBLE.

Membuat VM instance dari image publik

Google, komunitas open source, dan vendor pihak ketiga menyediakan dan mengelola OS image publik. Secara default, semua project Google Cloud dapat membuat VM dari OS image publik. Namun, jika project Google Cloud Anda memiliki daftar image tepercaya yang telah ditentukan, Anda hanya dapat menggunakan image yang berada di dalam daftar tersebut untuk membuat VM.

Jika Anda membuat image Shielded VM dengan SSD lokal, Anda tidak dapat melindungi data dengan integrity monitoring, atau virtual platform trusted module (vTPM).

Konsol

Di konsol Google Cloud, buka halaman Instance VM.

Buka halaman VM instances
Pilih project Anda, lalu klik Continue.
Klik Create instance.
Tentukan Name untuk VM Anda. Untuk informasi selengkapnya, lihat Konvensi penamaan resource.
Opsional: Ubah Zone untuk VM ini. Jika Anda memilih Any, Google akan otomatis memilih zona untuk Anda berdasarkan jenis dan ketersediaan mesin.
Pilih Machine configuration untuk VM Anda.
Di bagian Boot disk, klik Change, lalu lakukan tindakan berikut ini:
1. Pada tab Image publik, pilih pilihan berikut ini:
  - Sistem operasi
  - Versi OS
  - Jenis boot disk
  - Ukuran boot disk
2. Opsional: Untuk opsi konfigurasi lanjutan Show advanced configuration.
3. Untuk mengonfirmasi opsi boot disk, klik Select.
Catatan: Kecuali Anda secara eksplisit memilih boot disk lain, jika nama VM yang baru sama dengan nama persistent disk yang ada persistent disk yang ada akan secara otomatis dipasang ke VM yang baru sebagai boot disk.
Di bagian Firewall, untuk mengizinkan traffic HTTP atau HTTPS ke VM, pilih Allow HTTP traffic atau Allow HTTPS traffic. Saat Anda memilih salah satu opsi tersebut, Compute Engine menambahkan tag jaringan ke VM Anda, yang mengaitkan aturan firewall dengan VM tersebut. Kemudian, Compute Engine membuat aturan firewall masuk yang sesuai, yang mengizinkan semua traffic masuk di tcp:80 (HTTP) atau tcp:443 (HTTPS).
Opsional: Jika memilih OS image yang mendukung fitur Shielded VM, Anda dapat mengubah setelan Shielded VM. Untuk mengubah setelan Shielded VM, luaskan bagian Security di bagian Advanced options, lalu lakukan hal berikut sesuai kebutuhan:
- Untuk mengaktifkan Secure Boot, pilih Turn on Secure Boot. Secure Boot secara default dinonaktifkan.
- Untuk menonaktifkan vTPM, hapus kotak centang Turn on vTPM. vTPM secara default diaktifkan. Menonaktifkan vTPM juga akan menonaktifkan integrity monitoring, karena integrity monitoring bergantung pada data yang telah dikumpulkan oleh Booting Terukur.
- Untuk menonaktifkan pemantauan integritas, hapus kotak centang Turn on Integrity Monitoring. Pemantauan integritas secara default diaktifkan.
Untuk membuat dan memulai VM, klik Create.

gcloud

Pilih image publik. Catat nama image atau kelompok image dan nama project yang berisi image tersebut.
Gunakan perintah gcloud compute instances create untuk membuat VM dari kelompok image, atau dari versi spesifik OS image.

Jika Anda menentukan flag --shielded-secure-boot opsional, Compute Engine akan membuat VM dengan ketiga fitur Shielded VM yang diaktifkan:
Setelah Compute Engine memulai VM, Anda harus menghentikan VM untuk mengubah opsi Shielded VM.
```
gcloud compute instances create VM_NAME \
    --zone=ZONE \
    [--image=IMAGE | --image-family=IMAGE_FAMILY] \
    --image-project=IMAGE_PROJECT \
    --machine-type=MACHINE_TYPE
```
Ganti kode berikut:
- VM_NAME: nama VM yang baru
- ZONE: zona tempat instance dibuat
- IMAGE atau IMAGE_FAMILY: menentukan salah satu dari hal berikut ini:
  - IMAGE: versi image publik tertentu
    
    Misalnya, --image=debian-10-buster-v20200309.
  - IMAGE_FAMILY: sebuah kelompok image.
    
    Ini akan membuat VM dari OS image terbaru yang masih digunakan. Misalnya, jika Anda menentukan --image-family=debian-10, Compute Engine akan membuat VM dari OS image versi terbaru di dalam kelompok image Debian 10.
- IMAGE_PROJECT: project yang berisi image tersebut
- MACHINE_TYPE: jenis mesin, bawaan atau kustom, untuk VM yang baru
  
  Untuk mendapatkan daftar jenis mesin yang tersedia di dalam zone, gunakan perintah gcloud compute machine-types list dengan flag --zones.
Pastikan bahwa Compute Engine telah membuat VM ini:
```
gcloud compute instances describe VM_NAME
```
Ganti VM_NAME dengan nama VM.

Terraform

Untuk membuat VM, Anda dapat menggunakan resource google_compute_instance.


# Create a VM instance from a public image
# in the `default` VPC network and subnet

resource "google_compute_instance" "default" {
  name         = "my-vm"
  machine_type = "n1-standard-1"
  zone         = "us-central1-a"

  boot_disk {
    initialize_params {
      image = "ubuntu-minimal-2210-kinetic-amd64-v20230126"
    }
  }

  network_interface {
    network = "default"
    access_config {}
  }
}

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

Untuk membuat kode Terraform, Anda dapat menggunakan komponen Kode yang setara di konsol Google Cloud.

Di Konsol Google Cloud, buka halaman Instance VM.
Buka Instance VM
Klik Create instance.
Tentukan parameter yang Anda inginkan.
Di bagian atas atau bawah halaman, klik Kode yang setara, lalu klik tab Terraform untuk melihat kode Terraform.

C#

Untuk melakukan autentikasi ke Compute Engine, siapkan Kredensial Default Aplikasi. Untuk mengetahui informasi selengkapnya, lihat Menyiapkan autentikasi untuk lingkungan pengembangan lokal.


using Google.Cloud.Compute.V1;
using System.Threading.Tasks;

public class CreateInstanceAsyncSample
{
    public async Task CreateInstanceAsync(
        // TODO(developer): Set your own default values for these parameters or pass different values when calling this method.
        string projectId = "your-project-id",
        string zone = "us-central1-a",
        string machineName = "test-machine",
        string machineType = "n1-standard-1",
        string diskImage = "projects/debian-cloud/global/images/family/debian-12",
        long diskSizeGb = 10,
        string networkName = "default")
    {
        Instance instance = new Instance
        {
            Name = machineName,
            // See https://cloud.google.com/compute/docs/machine-types for more information on machine types.
            MachineType = $"zones/{zone}/machineTypes/{machineType}",
            // Instance creation requires at least one persistent disk.
            Disks =
            {
                new AttachedDisk
                {
                    AutoDelete = true,
                    Boot = true,
                    Type = ComputeEnumConstants.AttachedDisk.Type.Persistent,
                    InitializeParams = new AttachedDiskInitializeParams 
                    {
                        // See https://cloud.google.com/compute/docs/images for more information on available images.
                        SourceImage = diskImage,
                        DiskSizeGb = diskSizeGb
                    }
                }
            },
            NetworkInterfaces = { new NetworkInterface { Name = networkName } }
        };

        // Initialize client that will be used to send requests. This client only needs to be created
        // once, and can be reused for multiple requests.
        InstancesClient client = await InstancesClient.CreateAsync();

        // Insert the instance in the specified project and zone.
        var instanceCreation = await client.InsertAsync(projectId, zone, instance);

        // Wait for the operation to complete using client-side polling.
        // The server-side operation is not affected by polling,
        // and might finish successfully even if polling times out.
        await instanceCreation.PollUntilCompletedAsync();
    }
}

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 lingkungan pengembangan lokal.

import (
	"context"
	"fmt"
	"io"

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

// createInstance sends an instance creation request to the Compute Engine API and waits for it to complete.
func createInstance(w io.Writer, projectID, zone, instanceName, machineType, sourceImage, networkName string) error {
	// projectID := "your_project_id"
	// zone := "europe-central2-b"
	// instanceName := "your_instance_name"
	// machineType := "n1-standard-1"
	// sourceImage := "projects/debian-cloud/global/images/family/debian-12"
	// networkName := "global/networks/default"

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

	req := &computepb.InsertInstanceRequest{
		Project: projectID,
		Zone:    zone,
		InstanceResource: &computepb.Instance{
			Name: proto.String(instanceName),
			Disks: []*computepb.AttachedDisk{
				{
					InitializeParams: &computepb.AttachedDiskInitializeParams{
						DiskSizeGb:  proto.Int64(10),
						SourceImage: proto.String(sourceImage),
					},
					AutoDelete: proto.Bool(true),
					Boot:       proto.Bool(true),
					Type:       proto.String(computepb.AttachedDisk_PERSISTENT.String()),
				},
			},
			MachineType: proto.String(fmt.Sprintf("zones/%s/machineTypes/%s", zone, machineType)),
			NetworkInterfaces: []*computepb.NetworkInterface{
				{
					Name: proto.String(networkName),
				},
			},
		},
	}

	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

Untuk melakukan autentikasi ke Compute Engine, siapkan Kredensial Default Aplikasi. Untuk mengetahui informasi selengkapnya, lihat Menyiapkan autentikasi untuk lingkungan pengembangan lokal.


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.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.concurrent.ExecutionException;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.TimeoutException;

public class CreateInstance {

  public static void main(String[] args)
      throws IOException, InterruptedException, ExecutionException, TimeoutException {
    // TODO(developer): Replace these variables before running the sample.
    String project = "your-project-id";
    String zone = "zone-name";
    String instanceName = "instance-name";
    createInstance(project, zone, instanceName);
  }


  // Create a new instance with the provided "instanceName" value in the specified project and zone.
  public static void createInstance(String project, String zone, String instanceName)
      throws IOException, InterruptedException, ExecutionException, TimeoutException {
    // Below are sample values that can be replaced.
    // machineType: machine type of the VM being created.
    // *   This value uses the format zones/{zone}/machineTypes/{type_name}.
    // *   For a list of machine types, see https://cloud.google.com/compute/docs/machine-types
    // sourceImage: path to the operating system image to mount.
    // *   For details about images you can mount, see https://cloud.google.com/compute/docs/images
    // diskSizeGb: storage size of the boot disk to attach to the instance.
    // networkName: network interface to associate with the instance.
    String machineType = String.format("zones/%s/machineTypes/n1-standard-1", zone);
    String sourceImage = String
        .format("projects/debian-cloud/global/images/family/%s", "debian-11");
    long diskSizeGb = 10L;
    String networkName = "default";

    // Initialize client that will be used to send requests. This client only needs to be created
    // once, and can be reused for multiple requests. After completing all of your requests, call
    // the `instancesClient.close()` method on the client to safely
    // clean up any remaining background resources.
    try (InstancesClient instancesClient = InstancesClient.create()) {
      // Instance creation requires at least one persistent disk and one network interface.
      AttachedDisk disk =
          AttachedDisk.newBuilder()
              .setBoot(true)
              .setAutoDelete(true)
              .setType(Type.PERSISTENT.toString())
              .setDeviceName("disk-1")
              .setInitializeParams(
                  AttachedDiskInitializeParams.newBuilder()
                      .setSourceImage(sourceImage)
                      .setDiskSizeGb(diskSizeGb)
                      .build())
              .build();

      // Use the network interface provided in the networkName argument.
      NetworkInterface networkInterface = NetworkInterface.newBuilder()
          .setName(networkName)
          .build();

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

      System.out.printf("Creating instance: %s at %s %n", 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;
      }
      System.out.println("Operation Status: " + response.getStatus());
    }
  }
}

Node.js

Untuk melakukan autentikasi ke Compute Engine, siapkan Kredensial Default Aplikasi. Untuk mengetahui informasi selengkapnya, lihat Menyiapkan autentikasi untuk lingkungan pengembangan lokal.

/**
 * 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 machineType = 'n1-standard-1';
// const sourceImage = 'projects/debian-cloud/global/images/family/debian-11';
// const networkName = 'global/networks/default';

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

// Create a new instance with the values provided above in the specified project and zone.
async function createInstance() {
  const instancesClient = new compute.InstancesClient();

  console.log(`Creating the ${instanceName} instance in ${zone}...`);

  const [response] = await instancesClient.insert({
    instanceResource: {
      name: instanceName,
      disks: [
        {
          // Describe the size and source image of the boot disk to attach to the instance.
          initializeParams: {
            diskSizeGb: '10',
            sourceImage,
          },
          autoDelete: true,
          boot: true,
          type: 'PERSISTENT',
        },
      ],
      machineType: `zones/${zone}/machineTypes/${machineType}`,
      networkInterfaces: [
        {
          // Use the network interface provided in the networkName argument.
          name: networkName,
        },
      ],
    },
    project: projectId,
    zone,
  });
  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.');
}

createInstance();

PHP

Untuk melakukan autentikasi ke Compute Engine, siapkan Kredensial Default Aplikasi. Untuk mengetahui informasi selengkapnya, lihat Menyiapkan autentikasi untuk lingkungan pengembangan lokal.

use Google\Cloud\Compute\V1\AttachedDisk;
use Google\Cloud\Compute\V1\AttachedDiskInitializeParams;
use Google\Cloud\Compute\V1\Client\InstancesClient;
use Google\Cloud\Compute\V1\Enums\AttachedDisk\Type;
use Google\Cloud\Compute\V1\InsertInstanceRequest;

/**
 * To correctly handle string enums in Cloud Compute library
 * use constants defined in the Enums subfolder.
 */
use Google\Cloud\Compute\V1\Instance;
use Google\Cloud\Compute\V1\NetworkInterface;

/**
 * Creates an instance in the specified project and zone.
 *
 * @param string $projectId Project ID of the Cloud project to create the instance in.
 * @param string $zone Zone to create the instance in (like "us-central1-a").
 * @param string $instanceName Unique name for this Compute Engine instance.
 * @param string $machineType Machine type of the instance being created.
 * @param string $sourceImage Boot disk image name or family.
 * @param string $networkName Network interface to associate with the instance.
 *
 * @throws \Google\ApiCore\ApiException if the remote call fails.
 * @throws \Google\ApiCore\ValidationException if local error occurs before remote call.
 */
function create_instance(
    string $projectId,
    string $zone,
    string $instanceName,
    string $machineType = 'n1-standard-1',
    string $sourceImage = 'projects/debian-cloud/global/images/family/debian-11',
    string $networkName = 'global/networks/default'
) {
    // Set the machine type using the specified zone.
    $machineTypeFullName = sprintf('zones/%s/machineTypes/%s', $zone, $machineType);

    // Describe the source image of the boot disk to attach to the instance.
    $diskInitializeParams = (new AttachedDiskInitializeParams())
        ->setSourceImage($sourceImage);
    $disk = (new AttachedDisk())
        ->setBoot(true)
        ->setAutoDelete(true)
        ->setType(Type::PERSISTENT)
        ->setInitializeParams($diskInitializeParams);

    // Use the network interface provided in the $networkName argument.
    $network = (new NetworkInterface())
        ->setName($networkName);

    // Create the Instance object.
    $instance = (new Instance())
        ->setName($instanceName)
        ->setDisks([$disk])
        ->setMachineType($machineTypeFullName)
        ->setNetworkInterfaces([$network]);

    // Insert the new Compute Engine instance using InstancesClient.
    $instancesClient = new InstancesClient();
    $request = (new InsertInstanceRequest())
        ->setInstanceResource($instance)
        ->setProject($projectId)
        ->setZone($zone);
    $operation = $instancesClient->insert($request);

    // Wait for the operation to complete.
    $operation->pollUntilComplete();
    if ($operation->operationSucceeded()) {
        printf('Created instance %s' . PHP_EOL, $instanceName);
    } else {
        $error = $operation->getError();
        printf('Instance creation failed: %s' . PHP_EOL, $error?->getMessage());
    }
}

Python

Untuk melakukan autentikasi ke Compute Engine, siapkan Kredensial Default Aplikasi. Untuk mengetahui informasi selengkapnya, lihat Menyiapkan autentikasi untuk lingkungan pengembangan lokal.

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

Ruby

Untuk melakukan autentikasi ke Compute Engine, siapkan Kredensial Default Aplikasi. Untuk mengetahui informasi selengkapnya, lihat Menyiapkan autentikasi untuk lingkungan pengembangan lokal.


require "google/cloud/compute/v1"

# Sends an instance creation request to the Compute Engine API and waits for it to complete.
#
# @param [String] project project ID or project number of the Cloud project you want to use.
# @param [String] zone name of the zone you want to use. For example: "us-west3-b"
# @param [String] instance_name name of the new virtual machine.
# @param [String] machine_type machine type of the VM being created. For example: "e2-standard-2"
#         See https://cloud.google.com/compute/docs/machine-types for more information
#         on machine types.
# @param [String] source_image path to the operating system image to mount on your boot
#         disk. This can be one of the public images
#         (like "projects/debian-cloud/global/images/family/debian-11")
#         or a private image you have access to.
#         See https://cloud.google.com/compute/docs/images for more information on available images.
# @param [String] network_name name of the network you want the new instance to use.
#         For example: "global/networks/default" represents the `default`
#         network interface, which is created automatically for each project.
def create_instance project:, zone:, instance_name:,
                    machine_type: "n2-standard-2",
                    source_image: "projects/debian-cloud/global/images/family/debian-11",
                    network_name: "global/networks/default"
  # Initialize client that will be used to send requests. This client only needs to be created
  # once, and can be reused for multiple requests.
  client = ::Google::Cloud::Compute::V1::Instances::Rest::Client.new

  # Construct the instance object.
  # It can be either a hash or ::Google::Cloud::Compute::V1::Instance instance.
  instance = {
    name: instance_name,
    machine_type: "zones/#{zone}/machineTypes/#{machine_type}",
    # Instance creation requires at least one persistent disk.
    disks: [{
      auto_delete: true,
      boot: true,
      type: :PERSISTENT,
      initialize_params: {
        source_image: source_image,
        disk_size_gb: 10
      }
    }],
    network_interfaces: [{ name: network_name }]
  }

  # Prepare a request to create the instance in the specified project and zone.
  request = { project: project, zone: zone, instance_resource: instance }

  puts "Creating the #{instance_name} instance in #{zone}..."
  begin
    # Send the insert request.
    operation = client.insert request
    # Wait for the create operation to complete.
    operation = wait_until_done operation: operation

    if operation.error?
      warn "Error during creation:", operation.error
    else
      compute_operation = operation.operation
      warn "Warning during creation:", compute_operation.warnings unless compute_operation.warnings.empty?
      puts "Instance #{instance_name} created."
    end
  rescue ::Google::Cloud::Error => e
    warn "Exception during creation:", e
  end
end

REST

Pilih image publik. Catat nama image atau kelompok image dan nama project yang berisi image tersebut.
Gunakan metode instances.insert untuk membuat VM dari kelompok image atau versi OS image tertentu:
```
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
      }
   ],
   
   
   "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 or IMAGE_FAMILY: menentukan salah satu dari berikut ini:
  - IMAGE: versi spesifik dari image publik
    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 terbaru OS image dalam kelompok image Debian 10.
- NETWORK_NAME: jaringan VPC yang akan digunakan 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.

Membuat instance bare metal dari image publik

Google, komunitas open source, dan vendor pihak ketiga menyediakan dan mengelola OS image publik. Secara default, semua project Google Cloud dapat membuat instance bare metal menggunakan image OS publik yang didukung. Namun, jika project Google Cloud Anda memiliki daftar image tepercaya yang telah ditentukan, Anda hanya dapat menggunakan image yang berada di dalam daftar tersebut untuk membuat instance bare metal.

Konsol

Di konsol Google Cloud, buka halaman Instance VM.

Buka halaman VM instances
Pilih project Anda, lalu klik Continue.
Klik Create instance.
Tentukan Nama untuk instance Anda. Untuk informasi selengkapnya, lihat Konvensi penamaan resource.
Opsional: Ubah Zone untuk instance ini. Jika memilih zona yang tidak memiliki server bare metal yang tersedia, Anda akan diminta untuk memilih zona lain.
Di bagian Machine configuration, lakukan salah satu hal berikut:
- Klik tab General purpose, lalu pilih C3.
- Klik tab Memory optimized, lalu pilih X4.
Untuk Jenis mesin, klik daftar. Di kotak filter, ketik metal, lalu pilih salah satu jenis yang tersedia.
Di bagian Kebijakan ketersediaan, klik Setelan lanjutan model penyediaan VM untuk meluaskan bagian tersebut. Pastikan nilai untuk Pemeliharaan di host adalah Terminate instance.
Di bagian Boot disk, klik Change, lalu lakukan tindakan berikut ini:
1. Pada tab Image publik, pilih pilihan berikut ini:
  - Sistem operasi
  - Versi OS
  - Jenis boot disk
  - Ukuran boot disk
  - Opsional: Untuk disk booting Hyperdisk Balanced, pilih setelan Provisioned IOPS dan Provisioned throughput untuk disk.
2. Opsional: Untuk opsi konfigurasi disk tambahan, klik Tampilkan konfigurasi lanjutan.
3. Untuk mengonfirmasi opsi boot disk, klik Select.
  
  Catatan: Kecuali jika Anda secara eksplisit memilih boot disk lain, jika nama instance baru sama dengan nama disk yang ada, disk yang ada akan otomatis dipasang ke instance baru sebagai boot disk.
Di bagian Firewall, untuk mengizinkan traffic HTTP atau HTTPS ke instance bare metal, pilih Allow HTTP traffic atau Allow HTTPS traffic. Saat Anda memilih salah satu opsi ini, Compute Engine akan menambahkan tag jaringan ke instance Anda, yang mengaitkan aturan firewall dengan instance tersebut. Kemudian, Compute Engine akan membuat aturan firewall masuk yang sesuai, yang mengizinkan semua traffic masuk di tcp:80 (HTTP) atau tcp:443 (HTTPS).
Luaskan bagian Advanced options, lalu luaskan bagian Networking. Pastikan Kartu antarmuka jaringan disetel ke IDPF.
Untuk membuat dan memulai instance bare metal, klik Create.

gcloud

Pilih image publik yang mendukung instance bare metal. Catat nama image atau kelompok image dan nama project yang berisi image tersebut.
Gunakan perintah gcloud compute instances create untuk membuat instance bare metal dari kelompok image atau dari versi OS image tertentu.
```
gcloud compute instances create INSTANCE_NAME \
    --zone=ZONE \
    --machine-type=MACHINE_TYPE \
    --network-interface=nic-type=IDPF \
    --maintenance-policy=TERMINATE \
    --create-disk=boot=yes,image=projects/IMAGE_PROJECT/global/images/IMAGE,provisioned-iops=IOPS,provisioned-throughput=THROUGHPUT,size=SIZE,type=hyperdisk-balanced \
    --no-shielded-secure-boot
```
Ganti kode berikut:
- INSTANCE_NAME: nama untuk instance bare metal baru
- ZONE: zona tempat membuat instance bare metal
- MACHINE_TYPE: jenis mesin bare metal yang akan digunakan untuk instance. Nama jenis mesin harus diakhiri dengan -metal.
  
  Untuk mendapatkan daftar jenis mesin yang tersedia di zona, gunakan perintah gcloud compute machine-types list dengan flag --zones.
- IMAGE_PROJECT: project image yang berisi image
- IMAGE: tentukan salah satu dari hal berikut:
  - Versi tertentu dari image OS—misalnya, sles-15-sp4-sap-v20240208-x86-6.
  - Kelompok image, yang harus diformat sebagai family/IMAGE_FAMILY. Tindakan ini akan membuat instance dari image OS terbaru yang masih digunakan. Misalnya, jika Anda menentukan family/sles-15-sp4-sap, Compute Engine akan membuat instance bare metal dari OS image versi terbaru dalam kelompok image SUSE Linux Enterprise Server 15 SP4. Untuk mengetahui informasi selengkapnya tentang penggunaan kelompok image, lihat Praktik terbaik kelompok image.
- IOPS: Opsional: jumlah operasi I/O per detik (IOPS) tertinggi yang dapat ditangani disk.
- THROUGHPUT: Opsional: bilangan bulat yang mewakili throughput tertinggi, yang diukur dalam MiB per detik, yang dapat ditangani oleh disk.
- SIZE: Opsional: ukuran disk baru. Nilai harus berupa bilangan bulat. Satuan pengukuran defaultnya adalah GiB.
Pastikan Compute Engine telah membuat instance:
```
gcloud compute instances describe INSTANCE_NAME
```
Ganti INSTANCE_NAME dengan nama instance baru.

REST

Pilih image publik yang mendukung instance bare metal. Catat nama image atau kelompok image dan nama project yang berisi image tersebut.
Gunakan metode instances.insert untuk membuat instance bare metal dari kelompok image atau dari versi OS image tertentu:
```
POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/zones/ZONE/instances
{
 "machineType": "projects/PROJECT_ID/zones/MACHINE_TYPE_ZONE/machineTypes/MACHINE_TYPE",
 "name": "INSTANCE_NAME",
 "disks": [
   {
     "boot": true,
     "initializeParams": {
       "diskSizeGb": "DISK_SIZE",
       "diskType": "hyperdisk-balanced",
       "provisionedIops": "IOPS_LIMIT",
       "provisionedThroughput": "THROUGHPUT_LIMIT",
       "sourceImage": "projects/IMAGE_PROJECT/global/images/IMAGE"
     }
   }
 ],
 "networkInterfaces": [
   {
     "nicType": "IDPF"
   }
 ],
 "scheduling": {
   "onHostMaintenance": "TERMINATE"
 }
}
```
Ganti kode berikut:
- PROJECT_ID: ID project tempat instance bare metal akan dibuat
- ZONE: zona tempat membuat instance bare metal
- MACHINE_TYPE_ZONE: zona yang berisi jenis mesin yang akan digunakan untuk instance bare metal baru
- MACHINE_TYPE: jenis mesin yang akan digunakan untuk instance. Nama jenis mesin harus diakhiri dengan -metal.
- INSTANCE_NAME: nama instance baru
- DISK_SIZE: ukuran disk dalam GiB
- IOPS_LIMIT: jumlah operasi I/O per detik yang ingin Anda sediakan untuk disk.
- THROUGHPUT_LIMIT: bilangan bulat yang mewakili throughput, yang diukur dalam MB per detik, yang ingin Anda sediakan untuk disk.
- IMAGE_PROJECT: project image yang berisi image
- IMAGE: menentukan salah satu dari hal berikut:
  - Versi tertentu dari image OS—misalnya, sles-15-sp4-sap-v20240208-x86-6.
  - Kelompok image, yang harus diformat sebagai family/IMAGE_FAMILY. Tindakan ini akan membuat instance dari image OS terbaru yang masih digunakan. Misalnya, jika Anda menentukan family/sles-15-sp4-sap, Compute Engine akan membuat instance bare metal dari OS image versi terbaru dalam kelompok image SUSE Linux Enterprise Server 15 SP4. Untuk mengetahui informasi selengkapnya tentang penggunaan kelompok image, lihat Praktik terbaik kelompok image.

Membuat VM dari image kustom

Image kustom hanya berada di dalam project Anda. Untuk membuat VM dengan image kustom, Anda harus membuat image kustom terlebih dahulu, jika belum membuatnya.

Konsol

Di konsol Google Cloud, buka halaman Instance VM.

Buka halaman VM instances
Pilih project Anda, lalu klik Continue.
Klik Create instance.
Tentukan Name untuk VM Anda. Untuk informasi selengkapnya, lihat Konvensi penamaan resource.
Opsional: Ubah Zone untuk VM ini. Jika Anda memilih Any, Google akan otomatis memilih zona untuk Anda berdasarkan jenis dan ketersediaan mesin.
Pilih Machine configuration untuk VM Anda.
Di bagian Boot disk, klik Change, lalu lakukan tindakan berikut ini:
1. Pilih tab Custom Images.
2. Untuk memilih project image, klik Select a project, kemudian lakukan langkah berikut ini:
  1. Pilih project yang berisi image tersebut.
  2. Klik Open.
3. Di dalam daftar Image, klik image yang ingin Anda impor.
4. Pilih jenis dan ukuran boot disk Anda.
5. Opsional: Untuk opsi konfigurasi lanjutan Show advanced configuration.
6. Untuk mengonfirmasi opsi boot disk, klik Select.
Di dalam bagian Firewall, untuk mengizinkan traffic HTTP atau HTTPS ke VM, pilih Allow HTTP traffic, atau Allow HTTPS traffic.

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

gcloud

In the Google Cloud console, activate Cloud Shell.

Activate Cloud Shell

At the bottom of the Google Cloud console, a Cloud Shell session starts and displays a command-line prompt. Cloud Shell is a shell environment with the Google Cloud CLI already installed and with values already set for your current project. It can take a few seconds for the session to initialize.
Jalankan perintah gcloud compute instances create untuk membuat VM dengan image kustom:
```
gcloud compute instances create VM_NAME \
    --image-project IMAGE_PROJECT \
    [--image IMAGE | --image-family IMAGE_FAMILY]
    --subnet SUBNET
```
Ganti kode berikut:
- VM_NAME: nama VM
- IMAGE_PROJECT: Project ID yang berisi image
- IMAGE atau IMAGE_FAMILY: tentukan salah satu dari hal berikut:
  - IMAGE: nama image kustom Anda
    Misalnya, --image=my-debian-image-v2.
  - IMAGE_FAMILY: jika Anda membuat image kustom sebagai bagian dari kelompok image kustom, menentukan kelompok image kustom tersebut.
    Ini akan membuat VM dari OS image dan versi OS terbaru yang masih digunakan dalam kelompok image kustom Anda. Misalnya, jika Anda menentukan --image-family=my-debian-family, Compute Engine akan membuat VM dari OS image terbaru dalam kelompok image my-debian-family kustom Anda.
  Catatan: Compute Engine menggunakan kelompok image dan project default, jika Anda tidak menentukan image. Kelompok image dan project default adalah debian-10 dan debian-cloud.
- SUBNET: Jika subnet dan instance berada dalam project yang sama, ganti SUBNET dengan nama subnet yang berada di region yang sama dengan instance.

Terraform

Untuk membuat kode Terraform, Anda dapat menggunakan komponen Equivalent code di Konsol Google Cloud.

Di Konsol Google Cloud, buka halaman Instance VM.
Buka Instance VM
Klik Create instance.
Tentukan parameter yang Anda inginkan.
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 lingkungan pengembangan lokal.

import (
	"context"
	"fmt"
	"io"

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

// createInstanceFromCustomImage creates a new VM instance with custom image used as its boot disk.
func createInstanceFromCustomImage(w io.Writer, projectID, zone, instanceName, customImageLink string) error {
	// projectID := "your_project_id"
	// zone := "europe-central2-b"
	// instanceName := "your_instance_name"
	// customImageLink := "projects/project_name/global/images/image_name"

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

	req := &computepb.InsertInstanceRequest{
		Project: projectID,
		Zone:    zone,
		InstanceResource: &computepb.Instance{
			Name: proto.String(instanceName),
			Disks: []*computepb.AttachedDisk{
				{
					InitializeParams: &computepb.AttachedDiskInitializeParams{
						DiskSizeGb:  proto.Int64(10),
						SourceImage: proto.String(customImageLink),
						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()),
				},
			},
			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

Untuk melakukan autentikasi ke Compute Engine, siapkan Kredensial Default Aplikasi. Untuk mengetahui informasi selengkapnya, lihat Menyiapkan autentikasi untuk lingkungan pengembangan lokal.


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;
  }


  /**
   * 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 custom image used as its boot 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.
   * @param customImage link to the custom image you want to use in the form of:
   * "projects/{project_name}/global/images/{image_name}"
   * @return Instance object.
   */
  public static Instance createFromCustomImage(String project, String zone, String instanceName,
      String customImage)
      throws IOException, InterruptedException, ExecutionException, TimeoutException {
    String diskType = String.format("zones/%s/diskTypes/pd-standard", zone);
    Vector<AttachedDisk> disks = new Vector<>();
    disks.add(diskFromImage(diskType, 10, true, customImage));
    return createWithDisks(project, zone, instanceName, disks, "n1-standard-1",
        "global/networks/default", null);
  }

Node.js

Untuk melakukan autentikasi ke Compute Engine, siapkan Kredensial Default Aplikasi. Untuk mengetahui informasi selengkapnya, lihat Menyiapkan autentikasi untuk lingkungan pengembangan lokal.

/**
 * 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 customImageLink = 'projects/YOUR_PROJECT/global/images/YOUR_IMAGE_NAME';

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

// Creates a new VM instance with custom image used as its boot disk.
async function createInstanceFromCustomImage() {
  const instancesClient = new compute.InstancesClient();

  const [response] = await instancesClient.insert({
    project: projectId,
    zone,
    instanceResource: {
      name: instanceName,
      disks: [
        {
          initializeParams: {
            diskSizeGb: '10',
            sourceImage: customImageLink,
            diskType: `zones/${zone}/diskTypes/pd-standard`,
          },
          autoDelete: true,
          boot: true,
          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.');
}

createInstanceFromCustomImage();

Python

Untuk melakukan autentikasi ke Compute Engine, siapkan Kredensial Default Aplikasi. Untuk mengetahui informasi selengkapnya, lihat Menyiapkan autentikasi untuk lingkungan pengembangan lokal.

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 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_from_custom_image(
    project_id: str, zone: str, instance_name: str, custom_image_link: str
) -> compute_v1.Instance:
    """
    Create a new VM instance with custom image used as its boot 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.
        custom_image_link: link to the custom image you want to use in the form of:
            "projects/{project_name}/global/images/{image_name}"

    Returns:
        Instance object.
    """
    disk_type = f"zones/{zone}/diskTypes/pd-standard"
    disks = [disk_from_image(disk_type, 10, True, custom_image_link, True)]
    instance = create_instance(project_id, zone, instance_name, disks)
    return instance

REST

Proses untuk membuat VM dengan image kustom di dalam API sama seperti ketika Anda membuat VM dengan image yang tersedia secara publik.

Untuk membuat VM dari image kustom, gunakan metode instances.insert.

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
      }
   ],
   
   
   "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 yang baru
IMAGE_PROJECT: nama project yang berisi image kustom
IMAGE atau IMAGE_FAMILY: tentukan salah satu dari hal berikut ini:
- IMAGE: nama image kustom Anda. Misalnya, "sourceImage": "projects/my-project-1234/global/images/my-debian-image-v2".
- IMAGE_FAMILY: jika Anda membuat image kustom sebagai bagian dari kelompok image kustom, tentukan kelompok image kustom tersebut.
  Ini akan membuat VM dari OS image dan versi OS terbaru yang masih digunakan dalam kelompok image kustom Anda. Misalnya, jika Anda menentukan "sourceImage": "projects/my-project-1234/global/images/family/my-debian-family", Compute Engine akan membuat VM dari versi terbaru OS image di dalam kelompok image my-debian-family kustom.
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.

Membuat instance VM dengan non-boot disk tambahan

Saat membuat VM, Anda juga dapat membuat dan memasang disk non-boot tambahan ke VM secara bersamaan.

Namun, jika ingin membuat disk dalam mode multi-penulis, Anda tidak dapat membuat disk secara bersamaan saat membuat VM. Anda harus membuat disk terlebih dahulu, lalu Anda dapat melampirkan disk ke VM.

Konsol

Di konsol Google Cloud, buka halaman Instance VM.

Buka halaman VM instances
Pilih project Anda, lalu klik Continue.
Klik Create instance.
Tentukan Name untuk VM Anda. Untuk informasi selengkapnya, lihat Konvensi penamaan resource.
Opsional: Ubah Zone untuk VM ini. Jika Anda memilih Any, Google akan otomatis memilih zona untuk Anda berdasarkan jenis dan ketersediaan mesin.
Pilih Machine configuration untuk VM Anda.
Di bagian Boot disk, klik Change, lalu lakukan tindakan berikut ini:
1. Di dalam tab Public images, pilih pilihan berikut ini:
  - Sistem operasi
  - Versi OS
  - Jenis boot disk
  - Ukuran boot disk
2. Opsional: Untuk opsi konfigurasi lanjutan Show advanced configuration.
3. Untuk mengonfirmasi opsi boot disk, klik Select.
Catatan: Kecuali jika Anda secara eksplisit memilih boot disk lain, jika nama VM yang baru sama dengan nama persistent disk yang ada, persistent disk yang ada akan secara otomatis dipasang ke VM yang baru sebagai boot disk.
Di bagian Firewall, untuk mengizinkan traffic HTTP atau HTTPS ke VM, pilih Allow HTTP traffic atau Allow HTTPS traffic. Saat Anda memilih salah satu opsi tersebut, Compute Engine menambahkan tag jaringan ke VM Anda, yang mengaitkan aturan firewall dengan VM. Kemudian, Compute Engine akan membuat aturan firewall masuk yang sesuai, yang mengizinkan semua traffic masuk di tcp:80 (HTTP) atau tcp:443 (HTTPS).
Untuk menambahkan non-boot disk ke VM Anda, perluas bagian Advanced options, lalu lakukan hal berikut ini:
1. Perluas bagian Disks.
2. Klik Add new disk, lalu lakukan langkah berikut ini:
  1. Tentukan Name, Type, Source type, dan Size untuk disk.
  2. Di dalam bagian Attachment settings, pilih Mode untuk pemasangan disk, dan Deletion rule. Untuk informasi selengkapnya tentang cara menambahkan disk yang baru, baca Menambahkan persistent disk ke VM.
  3. Klik Save.
Untuk membuat dan memulai VM, klik Create.

gcloud

In the Google Cloud console, activate Cloud Shell.

Activate Cloud Shell

At the bottom of the Google Cloud console, a Cloud Shell session starts and displays a command-line prompt. Cloud Shell is a shell environment with the Google Cloud CLI already installed and with values already set for your current project. It can take a few seconds for the session to initialize.
Jalankan perintah gcloud compute instances create untuk membuat VM dengan non-boot disk tambahan.

Anda dapat menambahkan hingga 127 non-boot disk saat Anda sedang membuat VM. 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.

Secara opsional, Anda dapat menyertakan properti untuk:
- Ukuran disk: gunakan properti --size.
- Jenis disk: gunakan properti --type.
- Disk regional: sertakan properti replica-zones.
```
gcloud compute instances create VM_NAME \
  --zone=ZONE \
  [--image=IMAGE | --image-family=IMAGE_FAMILY] \
  --image-project=IMAGE_PROJECT \
  --create-disk [image=DISK_IMAGE | image-family=DISK_IMAGE_FAMILY ], \
    image-project=DISK_IMAGE_PROJECT,size=SIZE_GB,type=DISK_TYPE \
  --create-disk device-name=DISK_NAME, \
    replica-zones=^:^ZONE:REMOTE-ZONE,boot=false
```
Ganti kode berikut:
- VM_NAME: nama VM yang baru
- ZONE: zone untuk membuat VM tersebut
- IMAGE atau IMAGE_FAMILY. Tentukan salah satu dari hal berikut ini:
  - IMAGE: versi image publik tertentu
    
    Misalnya, --image=debian-10-buster-v20200309.
  - IMAGE_FAMILY: kelompok image
    
    Ini akan membuat VM dari OS image terbaru yang masih digunakan. Misalnya, jika Anda menentukan --image-family=debian-10, Compute Engine akan membuat VM dari OS image versi terbaru di dalam kelompok image Debian 10.
- IMAGE_PROJECT: project yang berisi image tersebut
- Untuk disk tambahan, ganti opsi berikut ini:
  - DISK_IMAGE atau DISK_IMAGE_FAMILY: Tentukan salah satu opsi berikut ini:
    - DISK_IMAGE: nama image yang ingin Anda gunakan sebagai non-boot disk
    - DISK_IMAGE_FAMILY: kelompok image untuk digunakan sebagai non-boot disk
  - DISK_IMAGE_PROJECT: project image yang memiliki image disk tersebut
  - SIZE_GB: Opsional: ukuran non-boot disk
  - DISK_TYPE: Opsional: URL lengkap atau sebagian untuk jenis persistent disk tersebut
    
    Misalnya, https://www.googleapis.com/compute/v1/projects/PROJECT_ID/zones/ZONE/diskTypes/pd-ssd. Untuk melihat jenis disk yang tersedia, jalankan perintah gcloud compute disk-types list.
  - DISK_NAME: Opsional: nama disk yang ditampilkan ke OS tamu setelah VM dibuat.
  - REMOTE_ZONE: zone tempat disk harus direplikasi
  Untuk disk yang kosong, jangan tentukan parameter DISK_IMAGE, DISK_IMAGE_FAMILY, atau DISK_IMAGE_PROJECT.
  
  Untuk disk zonal, jangan tentukan properti disk replica-zones.

Terraform

Untuk membuat kode Terraform, Anda dapat menggunakan komponen Equivalent code di Konsol Google Cloud.

Di Konsol Google Cloud, buka halaman Instance VM.
Buka Instance VM
Klik Create instance.
Tentukan parameter yang Anda inginkan.
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 lingkungan pengembangan lokal.

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

Untuk melakukan autentikasi ke Compute Engine, siapkan Kredensial Default Aplikasi. Untuk mengetahui informasi selengkapnya, lihat Menyiapkan autentikasi untuk lingkungan pengembangan lokal.


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

Untuk melakukan autentikasi ke Compute Engine, siapkan Kredensial Default Aplikasi. Untuk mengetahui informasi selengkapnya, lihat Menyiapkan autentikasi untuk lingkungan pengembangan lokal.

/**
 * 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

Untuk melakukan autentikasi ke Compute Engine, siapkan Kredensial Default Aplikasi. Untuk mengetahui informasi selengkapnya, lihat Menyiapkan autentikasi untuk lingkungan pengembangan lokal.

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 non-boot disk pada saat membuat VM 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 or IMAGE_FAMILY: menentukan salah satu dari berikut ini:
- IMAGE: versi spesifik dari image publik
  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 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: Menentukan 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 Misalnya, "sourceImage": "projects/DISK_IMAGE_PROJECT/global/images/family/DISK_IMAGE_FAMILY".
- DISK_TYPE: URL lengkap atau sebagian untuk jenis persistent disk. Misalnya, https://www.googleapis.com/compute/v1/projects/PROJECT_ID/zones/ZONE/diskTypes/pd-ssd.
- DISK_NAME: Opsional. Nama disk yang ditampilkan ke OS tamu setelah VM dibuat.
- REMOTE_ZONE: zone untuk mereplikasi disk regional untuk
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.

Format dan pasang disk sebelum menggunakannya.

Membuat VM instance dari image yang dibagikan

Jika pengguna lain telah membagikan image dengan Anda, Anda dapat menggunakan image tersebut untuk membuat VM.

Konsol

Di konsol Google Cloud, buka halaman Create an instance.

Buka Buat instance
Tentukan Name untuk VM Anda. Untuk informasi selengkapnya, lihat Konvensi penamaan resource.
Opsional: Ubah Zone untuk VM ini. Jika Anda memilih Any, Google akan otomatis memilih zona untuk Anda berdasarkan jenis dan ketersediaan mesin.
Pilih Machine configuration untuk VM Anda.
Di bagian Boot disk, klik Change untuk mengonfigurasi boot disk Anda, lalu lakukan hal berikut ini:

Pilih tab Custom Images.
Untuk memilih project image, klik Select a project, lalu lakukan tindakan berikut ini:
1. Pilih project yang berisi image tersebut.
2. Klik Open.
Di dalam daftar Image, klik image yang ingin Anda impor.
Pilih jenis dan ukuran boot disk Anda.
Untuk mengonfirmasi opsi boot disk, klik Select.

Untuk mengizinkan traffic HTTP atau HTTPS ke VM, di bagian Firewall, pilih Allow HTTP traffic atau Allow HTTPS traffic.

Konsol Google Cloud menambahkan tag jaringan ke VM 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 VM. Untuk informasi selengkapnya, lihat Ringkasan aturan firewall dalam dokumentasi Cloud Next Generation Firewall.
Untuk memulai dan membuat VM, klik Create.

gcloud

In the Google Cloud console, activate Cloud Shell.

Activate Cloud Shell

At the bottom of the Google Cloud console, a Cloud Shell session starts and displays a command-line prompt. Cloud Shell is a shell environment with the Google Cloud CLI already installed and with values already set for your current project. It can take a few seconds for the session to initialize.

Buat VM menggunakan gcloud compute instances create command, dan gunakan tanda --image dan --image-project untuk menentukan nama image serta project tempat image tersebut berada:

gcloud compute instances create VM_NAME \
        --image=IMAGE \
        --image-project=IMAGE_PROJECT

Ganti kode berikut:

VM_NAME: name untuk VM yang baru
IMAGE: nama image
IMAGE_PROJECT: project tempat image berada

Jika perintah ini berhasil, gcloud akan merespons dengan properti VM yang baru:

    Created [https://compute.googleapis.com/compute/v1/projects/myproject/zones/us-central1-b/instances/example-instance].
    NAME                 ZONE           MACHINE_TYPE   PREEMPTIBLE  INTERNAL_IP  EXTERNAL_IP    STATUS
    example-instance     us-central1-b  e2-standard-2               10.240.0.4   104.198.53.60  RUNNING

Terraform

Proses pembuatan VM dengan image yang dibagikan di Terraform sama seperti proses pembuatan VM dengan image yang tersedia untuk publik.

Di Konsol Google Cloud, buka halaman VM instance.
Buka Instance VM
Klik Create instance.
Tentukan parameter yang Anda inginkan.
Di bagian atas atau bawah halaman, klik Kode yang setara, lalu klik tab Terraform untuk melihat kode Terraform.

REST

Proses untuk membuat VM dengan image bersama di dalam API tersebut sama seperti jika Anda membuat VM dengan image yang tersedia untuk publik. Untuk membuat VM dari image bersama, gunakan metode instances.insert.

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
      }
   ],
   
   
   "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 yang baru
IMAGE_PROJECT: nama project yang berisi image yang dibagikan
IMAGE atau IMAGE_FAMILY: tentukan salah satu dari hal berikut ini:
- IMAGE: nama image yang dibagikan. Misalnya, "sourceImage": "projects/finance-project-1234/global/images/finance-debian-image-v2".
- IMAGE_FAMILY: jika image yang dibagikan dibuat sebagai bagian dari kelompok image kustom, tentukan kelompok image kustom tersebut.
  Ini akan membuat VM dari OS image dan versi OS terbaru yang masih digunakan dalam kelompok image kustom Anda. Misalnya, jika Anda menentukan "sourceImage": "projects/finance-project-1234/global/images/family/finance-debian-family", Compute Engine akan membuat VM dari versi terbaru OS image di dalam kelompok image finance-debian-family kustom.
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.

Membuat VM dari snapshot

Anda dapat membuat VM yang baru dari snapshot dengan cara berikut:

Memulihkan boot disk VM: Jika Anda mencadangkan boot disk VM dengan snapshot, Anda dapat menggunakan snapshot tersebut untuk membuat VM yang baru. Untuk petunjuknya, lihat Memulihkan snapshot boot disk ke VM yang baru.
Memulihkan non-boot disk: Jika Anda mencadangkan non-boot disk dengan snapshot, Anda dapat memulihkan snapshot ke non-boot disk yang baru saat membuat VM. Untuk petunjuknya, lihat Membuat VM dengan non-boot disk berdasarkan snapshot.

Untuk membuat lebih dari satu VM dengan cepat dengan boot disk yang sama, buat image kustom, lalu buat VM dari image tersebut alih-alih menggunakan snapshot.

Membuat VM instance dari image container

Untuk men-deploy dan meluncurkan container pada VM Compute Engine, tentukan nama image container dan parameter konfigurasi opsional saat Anda membuat VM. Compute Engine membuat VM menggunakan versi terbaru Image publik Container-Optimized OS, berisi Docker yang telah diinstal. Kemudian, Compute Engine akan meluncurkan container pada saat VM dimulai. Untuk informasi selengkapnya, lihat Men-deploy container pada VM.

Untuk membuat VM dari image container, Anda harus menggunakan Konsol Google Cloud, atau gcloud.

Konsol

Di konsol Google Cloud, buka halaman Instance VM.

Buka halaman VM instances
Pilih project Anda, lalu klik Continue.
Klik Create instance.
Tentukan Name untuk VM Anda. Untuk informasi selengkapnya, lihat Konvensi penamaan resource.
Di bagian Container, klik Deploy container.
1. Tentukan Image container yang akan digunakan. Misalnya:
  - Untuk memilih image container NGINX 1.12 dari Cloud Launcher:
    
    gcr.io/cloud-marketplace/google/nginx1:1.12
  - Untuk men-deploy image container Apache dari Docker Hub, selalu tentukan nama lengkap image Docker tersebut:
    
    docker.io/httpd:2.4
2. Opsional: Klik Advanced container options. Untuk informasi selengkapnya, lihat Mengonfigurasi opsi untuk menjalankan container.
Untuk membuat VM, melakukan booting pada VM, dan meluncurkan container, klik Create.

gcloud

In the Google Cloud console, activate Cloud Shell.

Activate Cloud Shell

At the bottom of the Google Cloud console, a Cloud Shell session starts and displays a command-line prompt. Cloud Shell is a shell environment with the Google Cloud CLI already installed and with values already set for your current project. It can take a few seconds for the session to initialize.
Jalankan perintah gcloud compute instances create-with-container:
```
gcloud compute instances create-with-container VM_NAME \
  --container-image=CONTAINER_IMAGE
```
Ganti kode berikut:
- VM_NAME: nama untuk VM yang baru.
- CONTAINER_IMAGE: nama image container tersebut.
Misalnya, perintah berikut ini membuat VM yang bernama nginx-vm, yang meluncurkan dan menjalankan image container:

gcr.io/cloud-marketplace/google/nginx1:1.12
```
gcloud compute instances create-with-container nginx-vm \
  --container-image=gcr.io/cloud-marketplace/google/nginx1:1.12
```
Untuk men-deploy image container Apache dari Docker Hub, selalu tentukan nama lengkap image Docker tersebut:

docker.io/httpd:2.4.

Membuat VM instance di dalam subnet tertentu

Secara default, Google Cloud membuat jaringan VPC mode otomatis yang disebut sebagai default untuk masing-masing project. Untuk menggunakan jaringan atau subnet lain yang Anda buat secara manual di dalam mode otomatis atau jaringan VPC mode kustom, Anda harus menentukan subnet saat membuat VM.

Saat membuat VM di dalam subnet, pertimbangkan aturan berikut ini:

Jika Anda tidak menentukan jaringan atau subnet, Compute Engine akan menggunakan jaringan VPC default dan subnet otomatis yang berada di dalam region yang sama dengan VM tersebut.
Jika Anda tidak menentukan jaringan, Compute Engine akan menyimpulkan jaringan dari subnet yang telah ditentukan.
Jika menentukan jaringan, Anda harus menentukan subnet dan subnet tersebut harus berasal dari jaringan yang sama. Jika tidak, pembuatan VM tersebut akan gagal.

Konsol

Di konsol Google Cloud, buka halaman Instance VM.

Buka halaman VM instances
Pilih project Anda, lalu klik Continue.
Klik Create instance.
Tentukan Name untuk VM Anda. Untuk informasi selengkapnya, lihat Konvensi penamaan resource.
Opsional: Ubah Zone untuk VM ini. Jika Anda memilih Any, Google akan otomatis memilih zona untuk Anda berdasarkan jenis dan ketersediaan mesin.
Di dalam bagian Firewall, untuk mengizinkan traffic HTTP atau HTTPS ke VM, pilih Allow HTTP traffic atau Allow HTTPS traffic.

Konsol Google Cloud menambahkan tag jaringan ke VM Anda dan membuat aturan firewall masuk yang sesuai, yang mengizinkan semua traffic yang masuk ke tcp:80 (HTTP), atau tcp:443 (HTTPS). Tag jaringan mengaitkan aturan firewall dengan VM. Untuk mengetahui informasi selengkapnya, lihat Ringkasan aturan firewall dalam dokumentasi Cloud NGFW.
Luaskan bagian Advanced options.
1. Perluas bagian Networking.
2. Untuk Network interfaces, tentukan detail jaringannya:
  1. Di dalam kolom Network, pilih jaringan VPC yang berisi subnet yang telah Anda buat.
  2. Di dalam kolom Subnet, pilih subnet yang akan digunakan oleh VM.
  3. Klik Done.
Untuk membuat dan memulai VM, klik Create.

gcloud

In the Google Cloud console, activate Cloud Shell.

Activate Cloud Shell

At the bottom of the Google Cloud console, a Cloud Shell session starts and displays a command-line prompt. Cloud Shell is a shell environment with the Google Cloud CLI already installed and with values already set for your current project. It can take a few seconds for the session to initialize.
Dengan menggunakan Google Cloud CLI, ikuti petunjuk yang sama untuk membuat VM dari image atau dari snapshot, lalu tambahkan--subnet=SUBNET_NAME dan --zone=ZONE saat Anda menjalankan perintah gcloud compute instances create:
```
gcloud compute instances create VM_NAME \
  --network=NETWORK_NAME \
  --subnet=SUBNET_NAME \
  --zone=ZONE
```
Ganti kode berikut:
- VM_NAME: nama dari VM tersebut
- NETWORK_NAME: Opsional: nama jaringan tersebut
- SUBNET_NAME: nama subnet tersebut
  
  Untuk melihat daftar subnet di dalam jaringan, gunakan perintah gcloud compute networks subnets list.
- ZONE: zone tempat VM dibuat, seperti europe-west1-b
  
  Region VM diinferensikan dari zone tersebut.

Terraform

Untuk membuat VM dalam subnet tertentu, Anda dapat menggunakan resource google_compute_instance.


# Create a VM in a custom VPC network and subnet

resource "google_compute_instance" "custom_subnet" {
  name         = "my-vm-instance"
  tags         = ["allow-ssh"]
  zone         = "europe-west1-b"
  machine_type = "e2-small"
  network_interface {
    network    = google_compute_network.custom.id
    subnetwork = google_compute_subnetwork.custom.id
  }
  boot_disk {
    initialize_params {
      image = "debian-cloud/debian-12"
    }
  }
}

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

Proses pembuatan VM dengan image yang dibagikan di Terraform sama seperti proses pembuatan VM dengan image yang tersedia untuk publik.

Di Konsol Google Cloud, buka halaman VM instance.
Buka Instance VM
Klik Create instance.
Tentukan parameter yang Anda inginkan.
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 lingkungan pengembangan lokal.

import (
	"context"
	"fmt"
	"io"

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

// createInstanceWithSubnet creates a new VM instance with Debian 10 operating system in specified network and subnetwork.
func createInstanceWithSubnet(w io.Writer, projectID, zone, instanceName, networkLink, subnetworkLink string) error {
	// projectID := "your_project_id"
	// zone := "europe-central2-b"
	// instanceName := "your_instance_name"
	// networkLink := "global/networks/default"
	// subnetworkLink := "regions/region/subnetworks/subnetwork_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()),
				},
			},
			MachineType: proto.String(fmt.Sprintf("zones/%s/machineTypes/n1-standard-1", zone)),
			NetworkInterfaces: []*computepb.NetworkInterface{
				{
					Name:       proto.String(networkLink),
					Subnetwork: proto.String(subnetworkLink),
				},
			},
		},
	}

	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

Untuk melakukan autentikasi ke Compute Engine, siapkan Kredensial Default Aplikasi. Untuk mengetahui informasi selengkapnya, lihat Menyiapkan autentikasi untuk lingkungan pengembangan lokal.


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;
  }


  /**
   * 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);
    }
  }

Node.js

Untuk melakukan autentikasi ke Compute Engine, siapkan Kredensial Default Aplikasi. Untuk mengetahui informasi selengkapnya, lihat Menyiapkan autentikasi untuk lingkungan pengembangan lokal.

/**
 * 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 networkLink = 'global/networks/default';
// const subnetworkLink = 'regions/europe-central2/subnetworks/default';

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

// Creates a new VM instance with Debian 10 operating system in specified network and subnetwork.
async function createInstanceWithSubnet() {
  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',
        },
      ],
      machineType: `zones/${zone}/machineTypes/n1-standard-1`,
      networkInterfaces: [
        {
          name: networkLink,
          subnetwork: subnetworkLink,
        },
      ],
    },
  });
  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.');
}

createInstanceWithSubnet();

Python

Untuk melakukan autentikasi ke Compute Engine, siapkan Kredensial Default Aplikasi. Untuk mengetahui informasi selengkapnya, lihat Menyiapkan autentikasi untuk lingkungan pengembangan lokal.

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 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_subnet(
    project_id: str, zone: str, instance_name: str, network_link: str, subnet_link: str
) -> compute_v1.Instance:
    """
    Create a new VM instance with Debian 10 operating system in specified network and subnetwork.

    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.
        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}"

    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, 10, True, newest_debian.self_link)]
    instance = create_instance(
        project_id,
        zone,
        instance_name,
        disks,
        network_link=network_link,
        subnetwork_link=subnet_link,
    )
    return instance

REST

Ikuti petunjuk API untuk membuat VM dari image atau dari snapshot, namun tentukan kolom subnet di dalam isi permintaan ini. Untuk menambahkan disk kosong, jangan tambahkan image sumber. Secara opsional, Anda dapat menentukan properti diskSizeGb, diskType, dan labels.

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
      }
   ],
   
   
   "networkInterfaces":[
      {
         "network":"global/networks/NETWORK_NAME",
         "subnetwork":"regions/REGION/subnetworks/SUBNET_NAME",
         "accessConfigs":{
            "name":"External NAT",
            "type":"ONE_TO_ONE_NAT"
         }
      }
   ],
   
  
   "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 or IMAGE_FAMILY: menentukan salah satu dari berikut ini:
- IMAGE: versi spesifik dari image publik
  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 dari versi terbaru OS image dalam kelompok image Debian 10.
NETWORK_NAME: jaringan VPC yang ingin Anda gunakan untuk VM. Anda dapat menentukan default untuk menggunakan jaringan default Anda.
REGION: region tempat subnet yang ditentukan berada
SUBNET_NAME: nama subnet tersebut
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.

Membuat VM yang dikonfigurasi untuk pemantauan dan logging Agen Operasional

Agen Operasional mengumpulkan data telemetri untuk VM yang kemudian dapat Anda gunakan untuk pemecahan masalah dan penyesuaian performa. Anda dapat menginstal Agen Operasional saat membuat VM atau pada VM yang ada, seperti yang dijelaskan di dalam topik berikut ini:

Menginstal Agen Operasional saat membuat VM menggunakan Konsol Google Cloud: Aktifkan penginstalan otomatis Agen Operasional dengan memilih kotak centang Install the Ops Agent for Monitoring and Logging di dalam halaman Create an instance. Opsi ini mengaktifkan VM Manager dalam mode fungsi terbatas dan membuat penetapan kebijakan OS untuk menginstal Agen Operasional di VM. Untuk informasi selengkapnya, lihat Menginstal Agen Operasional selama pembuatan VM.
Menginstal Agen Operasional di VM yang ada: Gunakan Konsol Google Cloud, gcloud CLI, atau alat otomatisasi untuk menginstal Agen Operasional di beberapa VM atau di VM individual. Untuk mengetahui petunjuknya, lihat Menginstal Agen Operasional.
Catatan: Jika Anda menginstal Agen Operasional, Anda mungkin akan dikenai biaya untuk metrik dan log yang dikirimkan oleh agen tersebut ke project Google Cloud Anda. Untuk informasi selengkapnya, lihat harga Google Cloud Observability.

Pemecahan masalah

Untuk menemukan metode penyelesaian error dari pembuatan VM yang umum, baca artikel Memecahkan masalah pembuatan VM.

Apa langkah selanjutnya?
- Periksa status VM untuk mengetahui kapan VM siap digunakan.
- Pelajari cara menggunakan snapshot untuk mencadangkan disk Anda.
- Pelajari cara membuat dan memasang disk penyimpanan non-boot ke VM Anda untuk menyimpan data secara terpisah dari boot disk.
- Pelajari cara terhubung ke VM.
- Pelajari cara menskalakan VM ke dalam grup VM.
Coba sendiri

Jika Anda baru pertama kali menggunakan Google Cloud, buat akun untuk mengevaluasi performa Compute Engine dalam skenario dunia nyata. Pelanggan baru mendapatkan kredit gratis senilai $300 untuk menjalankan, menguji, dan men-deploy workload.
Coba Compute Engine gratis