Menghentikan atau memulai ulang instance Compute Engine

Dokumen ini menjelaskan cara menghentikan atau memulai ulang instance Compute Engine. Untuk mempelajari lebih lanjut cara menangguhkan, menghentikan, atau mereset instance, lihat Menangguhkan, menghentikan, atau mereset instance Compute Engine.

Menghentikan instance berguna saat Anda tidak lagi menggunakannya, atau untuk mengubah propertinya—misalnya, untuk mengubah jenis mesinnya, atau menghapus disk yang terpasang dan ter-mount. Setelah menghentikan instance, Anda dapat melakukan hal berikut:

  • Mulai ulang untuk melanjutkan beban kerja Anda.

  • Hapus jika Anda tidak lagi memerlukannya.

Untuk mengotomatiskan penghentian atau memulai ulang instance, lihat artikel berikut:

Sebelum memulai

  • Jika Anda belum melakukannya, siapkan autentikasi. Autentikasi memverifikasi identitas Anda untuk mengakses Google Cloud layanan dan API. Untuk menjalankan kode atau sampel dari lingkungan pengembangan lokal, Anda dapat melakukan autentikasi 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. Menginstal Google Cloud CLI. Setelah penginstalan, lakukan inisialisasi Google Cloud CLI dengan menjalankan perintah berikut: 

      gcloud init

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

    2. Set a default region and zone.

    Go

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

      Menginstal Google Cloud CLI.

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

      If you're using a local shell, then create local authentication credentials for your user account: 

      gcloud auth application-default login

      You don't need to do this if you're using Cloud Shell.

      If an authentication error is returned, and you are using an external identity provider (IdP), confirm that you have signed in to the gcloud CLI with your federated identity.

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

    Java

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

      Menginstal Google Cloud CLI.

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

      If you're using a local shell, then create local authentication credentials for your user account: 

      gcloud auth application-default login

      You don't need to do this if you're using Cloud Shell.

      If an authentication error is returned, and you are using an external identity provider (IdP), confirm that you have signed in to the gcloud CLI with your federated identity.

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

    Node.js

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

      Menginstal Google Cloud CLI.

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

      If you're using a local shell, then create local authentication credentials for your user account: 

      gcloud auth application-default login

      You don't need to do this if you're using Cloud Shell.

      If an authentication error is returned, and you are using an external identity provider (IdP), confirm that you have signed in to the gcloud CLI with your federated identity.

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

    PHP

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

      Menginstal Google Cloud CLI.

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

      If you're using a local shell, then create local authentication credentials for your user account: 

      gcloud auth application-default login

      You don't need to do this if you're using Cloud Shell.

      If an authentication error is returned, and you are using an external identity provider (IdP), confirm that you have signed in to the gcloud CLI with your federated identity.

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

    Python

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

      Menginstal Google Cloud CLI.

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

      If you're using a local shell, then create local authentication credentials for your user account: 

      gcloud auth application-default login

      You don't need to do this if you're using Cloud Shell.

      If an authentication error is returned, and you are using an external identity provider (IdP), confirm that you have signed in to the gcloud CLI with your federated identity.

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

    REST

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

      Menginstal Google Cloud CLI.

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

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

Peran yang diperlukan

Agar mendapatkan izin yang Anda perlukan untuk menghentikan atau memulai ulang instance Compute, 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 menghentikan atau memulai ulang instance komputasi. Untuk melihat izin yang benar-benar diperlukan, luaskan bagian Izin yang diperlukan:

Izin yang diperlukan

Izin berikut diperlukan untuk menghentikan atau memulai ulang instance komputasi:

  • Untuk menghentikan instance: compute.instances.stop pada instance
  • Untuk menghentikan instance dari OS tamu: compute.instances.setMetadata pada instance jika menggunakan kunci SSH publik level instance.
  • Untuk memulai ulang instance: compute.instances.start pada instance
  • Untuk memulai ulang instance yang menggunakan kunci enkripsi: compute.instances.startWithEncryptionKey di instance

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

Menghentikan instance

Saat Anda menghentikan instance komputasi, atau Compute Engine melakukannya untuk tindakan terjadwal, instance akan mempertahankan resource terlampir, setelan konfigurasi, alamat IP internal, alamat MAC, dan metadata. Namun, instance kehilangan data dalam memori dan status aplikasinya. Jika Anda perlu mempertahankan status ini, maka tangguhkan instance sebagai gantinya.

Anda dapat menghentikan instance menggunakan metode berikut, bergantung pada apakah instance memiliki disk SSD Lokal yang terpasang dan cara Anda ingin menangani skrip penonaktifan:

  • Menghentikan instance tanpa disk SSD Lokal

    Anda dapat menghentikan satu atau beberapa instance secara bersamaan yang tidak memiliki disk SSD Lokal terpasang. Semua skrip shutdown dalam instance harus selesai berjalan dalam periode shutdown default.

  • Menghentikan instance dengan disk SSD Lokal

    Saat menghentikan satu atau beberapa instance secara bersamaan yang memiliki disk SSD Lokal terpasang, Anda dapat memilih untuk menghapus atau menyimpan (Pratinjau) data di disk tersebut. Semua skrip penonaktifan di instance harus selesai dijalankan dalam periode penonaktifan default.

  • Menghentikan instance dari OS tamu

    Dengan pendekatan ini, Anda dapat menghentikan satu instance hanya setelah skrip shutdown selesai berjalan, atau, jika Anda mengaktifkan shutdown yang benar, menghentikan instance tanpa menghentikannya dengan benar, atau mengakhiri shutdown yang benar yang sedang berlangsung. Kecuali jika Anda mencadangkan data secara manual dari disk SSD Lokal yang terpasang ke volume penyimpanan yang andal, menghentikan instance dari dalam disk OS tamu akan menghapus data apa pun di disk tersebut.

Menghentikan instance tanpa disk SSD Lokal

Bergantung pada tindakan yang ingin Anda lakukan saat menghentikan instance, gunakan opsi berikut:

  • Jika telah mengaktifkan penghentian yang benar di instance, Anda dapat menghentikan instance tanpa menghentikannya dengan benar atau mengakhiri penghentian yang benar yang sedang berlangsung menggunakan Google Cloud konsol, gcloud CLI, atau REST API.

  • Untuk menghentikan beberapa instance secara bersamaan, gunakan konsol Google Cloud atau, untuk instance yang berada di zona yang sama, gcloud CLI.

Untuk menghentikan satu atau beberapa instance, pilih salah satu opsi berikut:

Konsol

  1. Di konsol Google Cloud , buka halaman VM instances.

    Buka instance VM

  2. Pilih instance yang sedang berjalan untuk dihentikan.

  3. Klik Hentikan. Jika tidak ada opsi Hentikan, klik Tindakan lainnya > Hentikan.

  4. Dalam dialog, lakukan hal berikut:

    1. Opsional: Untuk menghentikan instance tanpa mematikan instance dengan benar, atau mengakhiri penonaktifan yang sedang berlangsung dengan benar, centang kotak Lewati penonaktifan yang benar (jika berlaku).

    2. Untuk mengonfirmasi, klik Hentikan.

gcloud

Untuk menghentikan satu atau beberapa instance di zona yang sama, gunakan perintah gcloud compute instances stop:

gcloud compute instances stop INSTANCE_NAMES \
    --zone=ZONE

Ganti kode berikut:

  • INSTANCE_NAMES: daftar nama instance yang dipisahkan oleh spasi—misalnya, instance-01 instance-02 instance-03.

  • ZONE: zona tempat instance berada.

Atau, jika Anda telah mengaktifkan penonaktifan yang benar di satu atau beberapa instance, Anda dapat menghentikan instance tanpa menonaktifkannya dengan benar, atau mengakhiri penonaktifan yang benar yang sedang berlangsung secara manual. Untuk melakukannya, gunakan perintah gcloud beta compute instances stop dengan flag --no-graceful-shutdown:

gcloud beta compute instances stop INSTANCE_NAMES \
    --no-graceful-shutdown \
    --zone=ZONE

Go 

import (
	"context"
	"fmt"
	"io"

	compute "cloud.google.com/go/compute/apiv1"
	computepb "cloud.google.com/go/compute/apiv1/computepb"
)

// stopInstance stops a started Google Compute Engine instance
func stopInstance(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()

	req := &computepb.StopInstanceRequest{
		Project:  projectID,
		Zone:     zone,
		Instance: instanceName,
	}

	op, err := instancesClient.Stop(ctx, req)
	if err != nil {
		return fmt.Errorf("unable to stop 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 stopped\n")

	return nil
}

Java 


import com.google.api.gax.longrunning.OperationFuture;
import com.google.cloud.compute.v1.InstancesClient;
import com.google.cloud.compute.v1.Operation;
import com.google.cloud.compute.v1.Operation.Status;
import com.google.cloud.compute.v1.StopInstanceRequest;
import java.io.IOException;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.TimeoutException;

public class StopInstance {

  public static void main(String[] args)
      throws IOException, ExecutionException, InterruptedException, TimeoutException {
    // TODO(developer): Replace these variables before running the sample.
    /* project: project ID or project number of the Cloud project your instance belongs to.
       zone: name of the zone your instance belongs to.
       instanceName: name of the instance your want to stop.
     */
    String project = "your-project-id";
    String zone = "zone-name";
    String instanceName = "instance-name";

    stopInstance(project, zone, instanceName);
  }

  // Stops a started Google Compute Engine instance.
  public static void stopInstance(String project, String zone, String instanceName)
      throws IOException, ExecutionException, InterruptedException, TimeoutException {
    /* Initialize client that will be used to send requests. This client only needs to be created
       once, and can be reused for multiple requests. 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()) {

      StopInstanceRequest stopInstanceRequest = StopInstanceRequest.newBuilder()
          .setProject(project)
          .setZone(zone)
          .setInstance(instanceName)
          .build();

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

      if (response.getStatus() == Status.DONE) {
        System.out.println("Instance stopped successfully ! ");
      }
    }
  }
}

Node.js 

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

async function stopInstance() {
  const instancesClient = new compute.InstancesClient();

  const [response] = await instancesClient.stop({
    project: projectId,
    zone,
    instance: instanceName,
  });
  let operation = response.latestResponse;
  const operationsClient = new compute.ZoneOperationsClient();

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

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

stopInstance();

PHP 

use Google\Cloud\Compute\V1\Client\InstancesClient;
use Google\Cloud\Compute\V1\StopInstanceRequest;

/**
 * Stops a running Google Compute Engine instance.
 *
 * @param string $projectId Project ID or project number of the Cloud project your instance belongs to.
 * @param string $zone Name of the zone your instance belongs to.
 * @param string $instanceName Name of the instance you want to stop.
  *
 * @throws \Google\ApiCore\ApiException if the remote call fails.
 * @throws \Google\ApiCore\ValidationException if local error occurs before remote call.
 */
function stop_instance(
    string $projectId,
    string $zone,
    string $instanceName
) {
    // Stop the Compute Engine instance using InstancesClient.
    $instancesClient = new InstancesClient();
    $request = (new StopInstanceRequest())
        ->setInstance($instanceName)
        ->setProject($projectId)
        ->setZone($zone);
    $operation = $instancesClient->stop($request);

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

Python 

from __future__ import annotations

import sys
from typing import Any

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


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

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

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

    Returns:
        Whatever the operation.result() returns.

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

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

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

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

    return result


def stop_instance(project_id: str, zone: str, instance_name: str) -> None:
    """
    Stops a running Google Compute Engine instance.
    Args:
        project_id: project ID or project number of the Cloud project your instance belongs to.
        zone: name of the zone your instance belongs to.
        instance_name: name of the instance your want to stop.
    """
    instance_client = compute_v1.InstancesClient()

    operation = instance_client.stop(
        project=project_id, zone=zone, instance=instance_name
    )
    wait_for_extended_operation(operation, "instance stopping")

REST

Untuk menghentikan instance, buat permintaan POST ke metode instances.stop:

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

Ganti kode berikut:

  • INSTANCE_NAME: nama instance.

  • PROJECT_ID: ID project tempat instance berada.

  • ZONE: zona tempat instance berada.

Secara opsional, jika Anda telah mengaktifkan penonaktifan yang benar di instance, Anda dapat menghentikan instance tanpa menonaktifkannya dengan benar, atau mengakhiri penonaktifan yang benar yang sedang berlangsung secara manual. Untuk melakukannya, buat permintaan POST ke metode instances.stop. Di URL permintaan, sertakan parameter kueri noGracefulShutdown=true:

POST https://compute.googleapis.com/compute/beta/projects/PROJECT_ID/zones/ZONE/instances/VM_NAME/stop?noGracefulShutdown=true

Menghentikan instance dengan disk SSD Lokal

Bergantung pada tindakan yang ingin Anda lakukan saat menghentikan instance komputasi, gunakan opsi berikut:

  • Jika Anda telah mengaktifkan penonaktifan yang benar di instance, Anda dapat menghentikan instance tanpa menonaktifkannya dengan benar atau mengakhiri penonaktifan yang benar yang sedang berlangsung menggunakan Google Cloud konsol, gcloud CLI, atau REST API.

  • Untuk mempertahankan data disk SSD Lokal yang terpasang ke instance (kecuali jenis mesin yang menggunakan SSD Titanium), hentikan instance menggunakan gcloud CLI atau REST API.

  • Untuk menghentikan beberapa instance secara bersamaan, gunakan konsol Google Cloud atau, untuk instance yang berada di zona yang sama, gcloud CLI.

Untuk menghentikan satu atau beberapa instance yang memiliki disk SSD Lokal terpasang, pilih salah satu opsi berikut:

Konsol

  1. Di konsol Google Cloud , buka halaman VM instances.

    Buka instance VM

  2. Pilih instance yang sedang berjalan untuk dihentikan.

  3. Klik Hentikan. Jika tidak ada opsi Hentikan, klik Tindakan lainnya > Hentikan.

  4. Dalam dialog, lakukan hal berikut:

    1. Opsional: Untuk menghentikan instance tanpa mematikan instance dengan benar, atau mengakhiri penonaktifan yang sedang berlangsung dengan benar, centang kotak Lewati penonaktifan yang benar (jika berlaku).

    2. Untuk mengonfirmasi, klik Hentikan.

gcloud

Saat menghentikan satu atau beberapa instance di zona yang sama yang memiliki disk SSD Lokal terpasang, tentukan apakah akan menghapus atau mempertahankan data SSD Lokal sebagai berikut:

  • Untuk menghapus data SSD Lokal, gunakan perintah gcloud compute instances stop dengan flag --discard-local-ssd=true:

    gcloud compute instances stop INSTANCE_NAMES \
    --discard-local-ssd=true \
    --zone=ZONE

  • Untuk mempertahankan data SSD Lokal, gunakan perintah gcloud beta compute instances stop dengan flag --discard-local-ssd=false:

    gcloud beta compute instances stop INSTANCE_NAMES \
    --discard-local-ssd=false \
    --zone=ZONE

Ganti kode berikut:

  • INSTANCE_NAMES: daftar nama instance yang dipisahkan oleh spasi—misalnya, instance-01 instance-02 instance-03.

  • ZONE: zona tempat instance berada.

Secara opsional, jika Anda telah mengaktifkan penonaktifan yang benar di satu atau beberapa instance, Anda dapat menghentikan instance tanpa menonaktifkannya dengan benar, atau mengakhiri penonaktifan yang benar yang sedang berlangsung. Untuk melakukannya, gunakan perintah gcloud beta compute instances stop dengan flag --no-graceful-shutdown:

gcloud beta compute instances stop INSTANCE_NAMES \
    --discard-local-ssd=DISCARD_LOCAL_SSD \
    --no-graceful-shutdown \
    --zone=ZONE

Ganti DISCARD_LOCAL_SSD dengan true untuk menghapus data di disk SSD Lokal, atau false untuk mempertahankan data.

REST

Saat menghentikan instance yang memiliki disk SSD Lokal terpasang, tentukan apakah akan menghapus atau mempertahankan data SSD Lokal sebagai berikut:

  • Untuk menghapus data SSD Lokal, buat permintaan POST ke metode instances.stop. Di URL permintaan, sertakan parameter kueri discardLocalSsd yang ditetapkan ke true:

    POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/zones/ZONE/instances/INSTANCE_NAME/stop?discardLocalSsd=true

  • Untuk menyimpan data SSD Lokal, buat permintaan POST ke metode beta.instances.stop. Di URL permintaan, sertakan parameter kueri discardLocalSsd yang ditetapkan ke false:

    POST https://compute.googleapis.com/compute/beta/projects/PROJECT_ID/zones/ZONE/instances/INSTANCE_NAME/stop?discardLocalSsd=false

Ganti kode berikut:

  • PROJECT_ID: ID project tempat instance berada.

  • ZONE: zona tempat instance berada.

  • INSTANCE_NAME: nama instance.

Atau, jika Anda telah mengaktifkan penonaktifan yang tuntas di instance, Anda dapat menghentikan instance tanpa menonaktifkannya secara tuntas, atau mengakhiri penonaktifan tuntas yang sedang berlangsung secara manual. Untuk melakukannya, buat permintaan POST ke metode instances.stop. Di URL permintaan, sertakan parameter kueri noGracefulShutdown=true:

POST https://compute.googleapis.com/compute/beta/projects/PROJECT_ID/zones/ZONE/instances/VM_NAME/stop?discardLocalSsd=DISCARD_LOCAL_SSD&noGracefulShutdown=true

Ganti DISCARD_LOCAL_SSD dengan true untuk menghapus data di disk SSD Lokal, atau false untuk mempertahankan data.

Menghentikan instance dari OS tamu

Jika instance komputasi memiliki disk SSD Lokal yang terpasang, menonaktifkan OS tamu akan otomatis menghapus data SSD Lokal. Untuk menyimpan data ini, salin data secara manual ke opsi penyimpanan persisten sebelum menghentikan instance.

Untuk menghentikan instance dari OS tamu, pilih salah satu opsi berikut:

Linux

  1. Jika Anda belum melakukannya, hubungkan ke instance.

  2. Untuk menghentikan instance, pilih salah satu metode berikut:

    • Untuk penonaktifan bersih yang memungkinkan instance menjalankan skrip penonaktifan sebelum menonaktifkan OS tamu, jalankan perintah berikut:

      sudo shutdown -h now

    • Jika tidak, untuk mematikan secara paksa, jalankan perintah berikut:

      sudo poweroff

Windows

  1. Jika Anda belum melakukannya, hubungkan ke instance menggunakan salah satu metode berikut:

  2. Untuk menghentikan instance, pilih salah satu metode berikut:

    • Untuk menghentikan instance secara bersih dan membiarkan instance menjalankan skrip penonaktifan sebelum mematikan OS tamu, jalankan perintah berikut:

      shutdown /s

    • Untuk mematikan secara paksa, jalankan perintah berikut:

      shutdown /f

Memulai ulang instance

Anda dapat memulai ulang instance komputasi yang telah dihentikan sepenuhnya, yaitu saat status instance adalah TERMINATED.

Jika Anda memilih untuk mempertahankan data disk SSD Lokal saat menghentikan instance, Anda mungkin perlu memasang kembali disk SSD Lokal setelah memulai ulang instance. Untuk mengetahui informasi selengkapnya tentang cara memasang disk SSD Lokal, lihat Memformat dan memasang perangkat SSD Lokal.

Untuk memulai ulang instance, gunakan salah satu metode berikut berdasarkan apakah instance memiliki disk terenkripsi yang terpasang:

Memulai ulang instance tanpa disk terenkripsi

Untuk memulai ulang beberapa instance secara bersamaan di berbagai zona, gunakan konsolGoogle Cloud . Untuk instance yang berada dalam zona yang sama, Anda dapat menggunakan gcloud CLI. Jika tidak, untuk skenario mulai ulang lainnya, pilih salah satu opsi berikut:

Konsol

  1. Di konsol Google Cloud , buka halaman VM instances.

    Buka instance VM

  2. Pilih satu atau beberapa instance.

  3. Klik Mulai / Lanjutkan.

gcloud

Untuk memulai ulang satu atau beberapa instance di zona yang sama, gunakan perintah gcloud compute instances start:

gcloud compute instances start INSTANCE_NAMES \
    --zone=ZONE

Ganti kode berikut:

  • INSTANCE_NAMES: daftar nama instance yang dipisahkan oleh spasi—misalnya, instance-01 instance-02 instance-03.

  • ZONE: zona tempat instance berada.

Go 

import (
	"context"
	"fmt"
	"io"

	compute "cloud.google.com/go/compute/apiv1"
	computepb "cloud.google.com/go/compute/apiv1/computepb"
)

// startInstance starts a stopped Google Compute Engine instance (with unencrypted disks).
func startInstance(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()

	req := &computepb.StartInstanceRequest{
		Project:  projectID,
		Zone:     zone,
		Instance: instanceName,
	}

	op, err := instancesClient.Start(ctx, req)
	if err != nil {
		return fmt.Errorf("unable to start 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 started\n")

	return nil
}

Java 


import com.google.api.gax.longrunning.OperationFuture;
import com.google.cloud.compute.v1.InstancesClient;
import com.google.cloud.compute.v1.Operation;
import com.google.cloud.compute.v1.Operation.Status;
import com.google.cloud.compute.v1.StartInstanceRequest;
import java.io.IOException;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.TimeoutException;

public class StartInstance {

  public static void main(String[] args)
      throws IOException, ExecutionException, InterruptedException, TimeoutException {
    // TODO(developer): Replace these variables before running the sample.
    /* project: project ID or project number of the Cloud project your instance belongs to.
       zone: name of the zone your instance belongs to.
       instanceName: name of the instance your want to start. */
    String project = "your-project-id";
    String zone = "zone-name";
    String instanceName = "instance-name";

    startInstance(project, zone, instanceName);
  }

  // Starts a stopped Google Compute Engine instance (with unencrypted disks).
  public static void startInstance(String project, String zone, String instanceName)
      throws IOException, ExecutionException, InterruptedException, TimeoutException {
    /* Initialize client that will be used to send requests. This client only needs to be created
       once, and can be reused for multiple requests. 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()) {

      // Create the request.
      StartInstanceRequest startInstanceRequest = StartInstanceRequest.newBuilder()
          .setProject(project)
          .setZone(zone)
          .setInstance(instanceName)
          .build();

      OperationFuture<Operation, Operation> operation = instancesClient.startAsync(
          startInstanceRequest);

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

      if (response.getStatus() == Status.DONE) {
        System.out.println("Instance started successfully ! ");
      }
    }
  }
}

Node.js 

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

async function startInstance() {
  const instancesClient = new compute.InstancesClient();

  const [response] = await instancesClient.start({
    project: projectId,
    zone,
    instance: instanceName,
  });
  let operation = response.latestResponse;
  const operationsClient = new compute.ZoneOperationsClient();

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

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

startInstance();

PHP 

use Google\Cloud\Compute\V1\Client\InstancesClient;
use Google\Cloud\Compute\V1\StartInstanceRequest;

/**
 * Starts a stopped Google Compute Engine instance (with unencrypted disks).
 *
 * @param string $projectId Project ID or project number of the Cloud project your instance belongs to.
 * @param string $zone Name of the zone your instance belongs to.
 * @param string $instanceName Name of the instance you want to stop.
  *
 * @throws \Google\ApiCore\ApiException if the remote call fails.
 * @throws \Google\ApiCore\ValidationException if local error occurs before remote call.
 */
function start_instance(
    string $projectId,
    string $zone,
    string $instanceName
) {
    // Start the Compute Engine instance using InstancesClient.
    $instancesClient = new InstancesClient();
    $request = (new StartInstanceRequest())
        ->setInstance($instanceName)
        ->setProject($projectId)
        ->setZone($zone);
    $operation = $instancesClient->start($request);

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

Python 

from __future__ import annotations

import sys
from typing import Any

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


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

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

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

    Returns:
        Whatever the operation.result() returns.

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

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

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

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

    return result


def start_instance(project_id: str, zone: str, instance_name: str) -> None:
    """
    Starts a stopped Google Compute Engine instance (with unencrypted disks).
    Args:
        project_id: project ID or project number of the Cloud project your instance belongs to.
        zone: name of the zone your instance belongs to.
        instance_name: name of the instance your want to start.
    """
    instance_client = compute_v1.InstancesClient()

    operation = instance_client.start(
        project=project_id, zone=zone, instance=instance_name
    )

    wait_for_extended_operation(operation, "instance start")

REST

Untuk memulai ulang instance, buat permintaan POST ke metode instances.start:

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

Ganti kode berikut:

  • INSTANCE_NAME: nama instance yang akan dimulai ulang.

  • PROJECT_ID: ID project tempat instance berada.

  • ZONE: zona tempat instance berada.

Memulai ulang instance dengan disk terenkripsi

Saat memulai ulang instance komputasi yang dihentikan dan memiliki disk terlampir yang dienkripsi menggunakan kunci enkripsi yang disediakan pelanggan, Anda harus memberikan informasi kunci enkripsi.

Untuk memulai ulang beberapa instance secara bersamaan di berbagai zona, gunakan konsolGoogle Cloud . Untuk instance yang berada dalam zona yang sama, Anda dapat menggunakan gcloud CLI. Jika tidak, untuk skenario mulai ulang lainnya, pilih salah satu opsi berikut:

Konsol

  1. Di konsol Google Cloud , buka halaman VM instances.

    Buka instance VM

  2. Pilih instance yang akan dimulai ulang.

  3. Klik Mulai / Lanjutkan.

  4. Tentukan kunci enkripsi untuk setiap disk terenkripsi yang terpasang ke instance, lalu klik Mulai.

gcloud

Untuk memulai ulang satu atau beberapa instance yang menggunakan disk terenkripsi di zona yang sama, gunakan perintah gcloud compute instances start dengan flag --csek-key-file. Jika Anda menggunakan kunci yang digabungkan RSA, maka gunakan perintah gcloud beta compute instances start dengan flag --csek-key-file:

gcloud compute instances start INSTANCE_NAMES \
    --csek-key-file=ENCRYPTION_KEY_FILE \
    --zone=ZONE

Ganti kode berikut:

  • INSTANCE_NAMES: daftar nama instance yang dipisahkan oleh spasi—misalnya, instance-01 instance-02 instance-03.

  • ENCRYPTION_KEY_FILE: jalur relatif ke file JSON yang berisi kunci enkripsi yang disediakan pelanggan. Anda hanya dapat me-restart beberapa instance secara bersamaan jika instance menggunakan kunci enkripsi yang disediakan pelanggan yang sama.

  • ZONE: zona tempat instance berada.

Go 

import (
	"context"
	"fmt"
	"io"

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

// startInstanceWithEncKey starts a stopped Google Compute Engine instance (with encrypted disks).
func startInstanceWithEncKey(w io.Writer, projectID, zone, instanceName, key string) error {
	// projectID := "your_project_id"
	// zone := "europe-central2-b"
	// instanceName := "your_instance_name"
	// key := "your_encryption_key"

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

	instanceReq := &computepb.GetInstanceRequest{
		Project:  projectID,
		Zone:     zone,
		Instance: instanceName,
	}

	instance, err := instancesClient.Get(ctx, instanceReq)
	if err != nil {
		return fmt.Errorf("unable to get instance: %w", err)
	}

	req := &computepb.StartWithEncryptionKeyInstanceRequest{
		Project:  projectID,
		Zone:     zone,
		Instance: instanceName,
		InstancesStartWithEncryptionKeyRequestResource: &computepb.InstancesStartWithEncryptionKeyRequest{
			Disks: []*computepb.CustomerEncryptionKeyProtectedDisk{
				{
					Source: proto.String(instance.GetDisks()[0].GetSource()),
					DiskEncryptionKey: &computepb.CustomerEncryptionKey{
						RawKey: proto.String(key),
					},
				},
			},
		},
	}

	op, err := instancesClient.StartWithEncryptionKey(ctx, req)
	if err != nil {
		return fmt.Errorf("unable to start instance with encryption key: %w", err)
	}

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

	fmt.Fprintf(w, "Instance with encryption key started\n")

	return nil
}

Java 


import com.google.api.gax.longrunning.OperationFuture;
import com.google.cloud.compute.v1.CustomerEncryptionKey;
import com.google.cloud.compute.v1.CustomerEncryptionKeyProtectedDisk;
import com.google.cloud.compute.v1.GetInstanceRequest;
import com.google.cloud.compute.v1.Instance;
import com.google.cloud.compute.v1.InstancesClient;
import com.google.cloud.compute.v1.InstancesStartWithEncryptionKeyRequest;
import com.google.cloud.compute.v1.Operation;
import com.google.cloud.compute.v1.Operation.Status;
import com.google.cloud.compute.v1.StartWithEncryptionKeyInstanceRequest;
import java.io.IOException;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.TimeoutException;

public class StartEncryptedInstance {

  public static void main(String[] args)
      throws IOException, ExecutionException, InterruptedException, TimeoutException {
    // TODO(developer): Replace these variables before running the sample.
    /* project: project ID or project number of the Cloud project your instance belongs to.
       zone: name of the zone your instance belongs to.
       instanceName: name of the instance your want to start.
       key: bytes object representing a raw base64 encoded key to your machines boot disk.
            For more information about disk encryption see:
            https://cloud.google.com/compute/docs/disks/customer-supplied-encryption#specifications
     */
    String project = "your-project-id";
    String zone = "zone-name";
    String instanceName = "instance-name";
    String key = "raw-key";

    startEncryptedInstance(project, zone, instanceName, key);
  }

  // Starts a stopped Google Compute Engine instance (with encrypted disks).
  public static void startEncryptedInstance(String project, String zone, String instanceName,
      String key)
      throws IOException, ExecutionException, InterruptedException, TimeoutException {
    /* Initialize client that will be used to send requests. This client only needs to be created
       once, and can be reused for multiple requests. 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()) {

      GetInstanceRequest getInstanceRequest = GetInstanceRequest.newBuilder()
          .setProject(project)
          .setZone(zone)
          .setInstance(instanceName).build();

      Instance instance = instancesClient.get(getInstanceRequest);

      // Prepare the information about disk encryption.
      CustomerEncryptionKeyProtectedDisk protectedDisk = CustomerEncryptionKeyProtectedDisk
          .newBuilder()
          /* Use raw_key to send over the key to unlock the disk
             To use a key stored in KMS, you need to provide:
             `kms_key_name` and `kms_key_service_account`
           */
          .setDiskEncryptionKey(CustomerEncryptionKey.newBuilder()
              .setRawKey(key).build())
          .setSource(instance.getDisks(0).getSource())
          .build();

      InstancesStartWithEncryptionKeyRequest startWithEncryptionKeyRequest =
          InstancesStartWithEncryptionKeyRequest.newBuilder()
              .addDisks(protectedDisk).build();

      StartWithEncryptionKeyInstanceRequest encryptionKeyInstanceRequest =
          StartWithEncryptionKeyInstanceRequest.newBuilder()
              .setProject(project)
              .setZone(zone)
              .setInstance(instanceName)
              .setInstancesStartWithEncryptionKeyRequestResource(startWithEncryptionKeyRequest)
              .build();

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

      if (response.getStatus() == Status.DONE) {
        System.out.println("Encrypted instance started successfully ! ");
      }
    }
  }

}

Node.js 

/**
 * 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 key = 'YOUR_KEY_STRING'

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

async function startInstanceWithEncryptionKey() {
  const instancesClient = new compute.InstancesClient();

  const [instance] = await instancesClient.get({
    project: projectId,
    zone,
    instance: instanceName,
  });

  const [response] = await instancesClient.startWithEncryptionKey({
    project: projectId,
    zone,
    instance: instanceName,
    instancesStartWithEncryptionKeyRequestResource: {
      disks: [
        {
          source: instance.disks[0].source,
          diskEncryptionKey: {
            rawKey: key,
          },
        },
      ],
    },
  });
  let operation = response.latestResponse;
  const operationsClient = new compute.ZoneOperationsClient();

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

  console.log('Instance with encryption key started.');
}

startInstanceWithEncryptionKey();

PHP 

use Google\Cloud\Compute\V1\Client\InstancesClient;
use Google\Cloud\Compute\V1\CustomerEncryptionKey;
use Google\Cloud\Compute\V1\CustomerEncryptionKeyProtectedDisk;
use Google\Cloud\Compute\V1\GetInstanceRequest;
use Google\Cloud\Compute\V1\InstancesStartWithEncryptionKeyRequest;
use Google\Cloud\Compute\V1\StartWithEncryptionKeyInstanceRequest;

/**
 * Starts a stopped Google Compute Engine instance (with encrypted disks).
 *
 * @param string $projectId Project ID or project number of the Cloud project your instance belongs to.
 * @param string $zone Name of the zone your instance belongs to.
 * @param string $instanceName Name of the instance you want to stop.
 * @param string $key Bytes object representing a raw base64 encoded key to your instance's boot disk.
 *                    For more information about disk encryption see:
 *                    https://cloud.google.com/compute/docs/disks/customer-supplied-encryption#specifications
 *
 * @throws \Google\ApiCore\ApiException if the remote call fails.
 * @throws \Google\ApiCore\ValidationException if local error occurs before remote call.
 */
function start_instance_with_encryption_key(
    string $projectId,
    string $zone,
    string $instanceName,
    string $key
) {
    // Initiate the InstancesClient.
    $instancesClient = new InstancesClient();

    // Get data about the instance.
    $request = (new GetInstanceRequest())
        ->setInstance($instanceName)
        ->setProject($projectId)
        ->setZone($zone);
    $instanceData = $instancesClient->get($request);

    // Use `setRawKey` to send over the key to unlock the disk
    // To use a key stored in KMS, you need to use `setKmsKeyName` and `setKmsKeyServiceAccount`
    $customerEncryptionKey = (new CustomerEncryptionKey())
        ->setRawKey($key);

    /** @var \Google\Cloud\Compute\V1\AttachedDisk */
    $disk = $instanceData->getDisks()[0];

    // Prepare the information about disk encryption.
    $diskData = (new CustomerEncryptionKeyProtectedDisk())
        ->setSource($disk->getSource())
        ->setDiskEncryptionKey($customerEncryptionKey);

    // Set request with one disk.
    $instancesStartWithEncryptionKeyRequest = (new InstancesStartWithEncryptionKeyRequest())
        ->setDisks(array($diskData));

    // Start the instance with encrypted disk.
    $request2 = (new StartWithEncryptionKeyInstanceRequest())
        ->setInstance($instanceName)
        ->setInstancesStartWithEncryptionKeyRequestResource($instancesStartWithEncryptionKeyRequest)
        ->setProject($projectId)
        ->setZone($zone);
    $operation = $instancesClient->startWithEncryptionKey($request2);

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

Python 

from __future__ import annotations

import sys
from typing import Any

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


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

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

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

    Returns:
        Whatever the operation.result() returns.

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

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

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

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

    return result


def start_instance_with_encryption_key(
    project_id: str, zone: str, instance_name: str, key: bytes
) -> None:
    """
    Starts a stopped Google Compute Engine instance (with encrypted disks).
    Args:
        project_id: project ID or project number of the Cloud project your instance belongs to.
        zone: name of the zone your instance belongs to.
        instance_name: name of the instance your want to start.
        key: bytes object representing a raw base64 encoded key to your machines boot disk.
            For more information about disk encryption see:
            https://cloud.google.com/compute/docs/disks/customer-supplied-encryption#specifications
    """
    instance_client = compute_v1.InstancesClient()

    instance_data = instance_client.get(
        project=project_id, zone=zone, instance=instance_name
    )

    # Prepare the information about disk encryption
    disk_data = compute_v1.CustomerEncryptionKeyProtectedDisk()
    disk_data.source = instance_data.disks[0].source
    disk_data.disk_encryption_key = compute_v1.CustomerEncryptionKey()
    # Use raw_key to send over the key to unlock the disk
    # To use a key stored in KMS, you need to provide `kms_key_name` and `kms_key_service_account`
    disk_data.disk_encryption_key.raw_key = key
    enc_data = compute_v1.InstancesStartWithEncryptionKeyRequest()
    enc_data.disks = [disk_data]

    operation = instance_client.start_with_encryption_key(
        project=project_id,
        zone=zone,
        instance=instance_name,
        instances_start_with_encryption_key_request_resource=enc_data,
    )

    wait_for_extended_operation(operation, "instance start (with encrypted disk)")

REST

Untuk memulai ulang instance yang menggunakan disk terenkripsi, buat permintaan POST ke metode instances.startWithEncryptionKey:

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

{
  "disks": [
    {
      "source": "DISK_URL",
      "diskEncryptionKey": {
        "ENCRYPTION_TYPE": "ENCRYPTION_KEY"
      }
    }
  ]
}

Ganti kode berikut:

  • PROJECT_ID: ID project tempat instance berada.

  • ZONE: zona tempat instance berada.

  • INSTANCE_NAME: nama instance.

  • DISK_URL: URL resource yang sesuai dengan nama lengkap resource dari disk yang terpasang yang dienkripsi dengan kunci enkripsi yang disediakan pelanggan.

  • ENCRYPTION_TYPE: jenis enkripsi disk yang Anda gunakan, yang dapat berupa salah satu dari berikut ini: rawKey, kmsKeyName, atau rsaEncryptedKey. Jika Anda menggunakan jenis rsaEncryptedKey, buat permintaan POST ke metode beta.instances.startWithEncryptionKey.

  • ENCRYPTION_KEY: kunci enkripsi yang digunakan untuk mengenkripsi persistent disk yang terpasang ke instance. Kunci rawKey atau rsaEncryptedKey harus berenkode base64. Selain itu, untuk menyiapkan kunci rsaEncryptedKey, lihat Penggabungan kunci RSA.

Langkah berikutnya