Menghentikan atau memulai ulang instance Compute Engine

Dokumen ini menjelaskan cara menghentikan atau memulai ulang instance Compute Engine secara manual. Atau, untuk mengotomatiskan kapan instance komputasi berhenti atau dimulai ulang, lihat referensi berikut:

Anda dapat menghentikan instance komputasi secara manual. Setelah operasi penghentian selesai dan status instance komputasi beralih ke TERMINATED, Anda dapat memulai ulang instance komputasi untuk melanjutkan workload, atau menghapus instance komputasi secara permanen jika tidak lagi diperlukan. Menghentikan instance komputasi secara manual berguna saat Anda ingin melakukan hal berikut:

  • Menghemat biaya sekaligus mempertahankan konfigurasi Anda: Anda tidak ingin lagi menjalankan workload di instance komputasi. Namun, Anda ingin mempertahankan instance komputasi dan disk yang terpasang, setelan konfigurasi, alamat IP, alamat MAC, dan metadata. Jika Anda juga perlu mempertahankan data dalam memori dan status aplikasi, tangguhkan instance komputasi.

  • Memperbarui properti: Anda ingin mengubah satu atau beberapa properti yang mengharuskan Anda menghentikan dan memulai ulang instance komputasi sebelum perubahan dapat diterapkan—misalnya, Anda ingin mengubah jenis mesin atau melepaskan disk. Untuk mengetahui informasi selengkapnya, lihat Properti yang dapat Anda perbarui.

Batasan

Saat Anda menghentikan instance komputasi, batasan berikut berlaku:

  • Anda hanya dapat menghentikan atau memulai ulang instance komputasi jika status instance komputasi mengizinkannya.

  • Anda hanya dapat memulai ulang instance komputasi jika ada resource yang memadai di zona tempat instance komputasi berada.

  • Anda tidak dapat memulai ulang instance komputasi TPU. Setelah menghentikan instance komputasi TPU, Anda hanya dapat menghapusnya.

Sebelum memulai

Peran yang diperlukan

Untuk mendapatkan izin yang diperlukan untuk menghentikan atau memulai ulang instance komputasi, minta administrator untuk memberi Anda peran IAM Compute Instance Admin (v1) (roles/compute.instanceAdmin.v1) pada 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, perluas bagian Izin yang diperlukan:

Izin yang diperlukan

Izin berikut diperlukan untuk menghentikan atau memulai ulang instance komputasi:

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

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

Menghentikan instance komputasi

Untuk menghentikan instance komputasi, gunakan salah satu metode berikut. Pendekatan terbaik untuk kasus penggunaan Anda bergantung pada apakah Anda memiliki disk SSD Lokal yang terpasang ke instance komputasi dan cara Anda ingin menangani skrip shutdown:

  • Menghentikan instance komputasi dari Google Cloud. Anda dapat menghentikan satu atau beberapa instance komputasi secara bersamaan dari Google Cloud. Jika instance komputasi memiliki disk SSD Lokal yang terpasang, Anda dapat memilih apakah akan menghapus atau mempertahankan (Pratinjau) data SSD Lokal. Setiap skrip shutdown di instance komputasi harus selesai berjalan sebelum instance komputasi berhenti. Untuk mengetahui petunjuknya, lihat salah satu hal berikut:

  • Menghentikan instance komputasi dari OS tamu. Pendekatan ini memastikan skrip shutdown Anda selesai berjalan sebelum instance komputasi berhenti. Jika telah mengaktifkan penghentian normal, Anda dapat melewati atau mengakhiri penghentian normal. Namun, menghentikan instance komputasi dari OS tamu akan menghapus data di disk SSD Lokal yang terpasang, kecuali jika Anda mencadangkan data terlebih dahulu ke penyimpanan persisten. Untuk mengetahui petunjuknya, lihat Menghentikan instance komputasi dari OS tamu.

Menghentikan instance komputasi tanpa disk SSD Lokal

Untuk menghentikan instance komputasi yang tidak memiliki disk SSD Lokal yang terpasang, tinjau opsi berikut:

  • Jika Anda telah mengaktifkan penghentian normal di instance komputasi, Anda dapat menghemat biaya dengan melewati atau mengakhiri penghentian normal yang sedang berlangsung. Untuk melakukannya, gunakan konsol Google Cloud , gcloud CLI, atau REST API.

  • Untuk menghentikan beberapa instance komputasi secara bersamaan, gunakan konsolGoogle Cloud atau, untuk instance komputasi yang ada di zona yang sama, gcloud CLI.

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

Konsol

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

    Buka instance VM

  2. Pilih instance komputasi yang sedang berjalan untuk dihentikan.

  3. Klik Hentikan. Jika tidak ada opsi Stop, klik More actions, lalu pilih Stop.

  4. Pada dialog yang muncul, lakukan hal berikut:

    1. Opsional: Untuk menghentikan instance komputasi tanpa penghentian normal, atau untuk mengakhiri penghentian normal yang sedang berlangsung, centang kotak Skip graceful shutdown (if applicable).

    2. Untuk mengonfirmasi, klik Stop.

gcloud

Untuk menghentikan satu atau beberapa instance komputasi yang ada 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 komputasi yang ingin Anda hentikan, dipisahkan dengan spasi. Misalnya, tentukan instance-01 instance-02 instance-03.

  • ZONE: zona tempat instance komputasi berada.

Jika Anda ingin melewati atau mengakhiri penghentian normal yang sedang berlangsung, gunakan perintah yang sama dengan flag --no-graceful-shutdown:

gcloud 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 komputasi, 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 komputasi.

  • PROJECT_ID: ID project tempat instance komputasi berada.

  • ZONE: zona tempat instance komputasi berada.

Jika Anda ingin melewati atau mengakhiri penghentian normal yang sedang berlangsung, sertakan parameter kueri noGracefulShutdown=true di URL permintaan:

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

Menghentikan instance komputasi dengan disk SSD Lokal

Metode terbaik untuk menghentikan instance komputasi yang memiliki disk SSD Lokal terpasang bergantung pada kasus penggunaan Anda. Gunakan salah satu opsi berikut:

  • Jika Anda telah mengaktifkan penghentian normal di instance komputasi, Anda dapat menghemat biaya dengan melewati atau mengakhiri penghentian normal yang sedang berlangsung. Untuk melakukannya, gunakan konsol Google Cloud , gcloud CLI, atau REST API.

  • Untuk mempertahankan data SSD Lokal (tidak termasuk untuk jenis mesin yang menggunakan Titanium SSD), gunakan gcloud CLI atau REST API.

  • Untuk menghentikan beberapa instance komputasi secara bersamaan, gunakan konsolGoogle Cloud atau, untuk instance komputasi yang ada di zona yang sama, gcloud CLI.

Untuk menghentikan satu atau beberapa instance komputasi 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 komputasi yang sedang berjalan untuk dihentikan.

  3. Klik Hentikan. Jika tidak ada opsi Stop, klik More actions, lalu pilih Stop.

  4. Pada dialog yang muncul, lakukan hal berikut:

    1. Opsional: Untuk menghentikan instance komputasi tanpa penghentian normal, atau mengakhiri penghentian normal yang sedang berlangsung, centang kotak Skip graceful shutdown (if applicable).

    2. Untuk mengonfirmasi, klik Stop.

gcloud

Saat Anda menghentikan satu atau beberapa instance komputasi 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 komputasi yang ingin Anda hentikan, dipisahkan dengan spasi. Misalnya, tentukan instance-01 instance-02 instance-03.

  • ZONE: zona tempat instance komputasi berada.

Jika Anda ingin melewati atau mengakhiri penghentian normal yang sedang berlangsung, sertakan flag --no-graceful-shutdown dalam perintah:

gcloud 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. Jika Anda menentukan false, Anda harus menggunakan perintah gcloud beta compute instances stop.

REST

Saat Anda menghentikan satu atau beberapa instance komputasi 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, buat permintaan POST ke metode instances.stop. Dalam 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 mempertahankan data SSD Lokal, buat permintaan POST ke metode beta.instances.stop. Dalam 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 komputasi berada.

  • ZONE: zona tempat instance komputasi berada.

  • INSTANCE_NAME: nama instance komputasi.

Jika Anda ingin melewati atau mengakhiri penghentian normal yang sedang berlangsung, sertakan parameter kueri noGracefulShutdown=true di URL permintaan:

POST https://compute.googleapis.com/compute/v1/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. Jika Anda menentukan false, Anda harus membuat permintaan POST ke metode beta.instances.stop.

Menghentikan instance komputasi 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 Anda menghentikan instance komputasi.

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

Linux

  1. Jika Anda belum melakukannya, hubungkan ke instance komputasi.

  2. Untuk menghentikan instance komputasi dari dalam OS tamu, pilih salah satu metode berikut:

    • Untuk menonaktifkan OS tamu dengan baik hanya setelah semua skrip shutdown selesai dijalankan, jalankan perintah berikut:

      sudo shutdown -h now

    • Untuk menghentikan paksa OS tamu, jalankan perintah berikut:

      sudo poweroff

Windows

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

  2. Untuk menghentikan instance komputasi dari dalam OS tamu, pilih salah satu metode berikut:

    • Untuk menonaktifkan OS tamu dengan baik hanya setelah semua skrip shutdown selesai dijalankan, jalankan perintah berikut:

      shutdown /s

    • Untuk menghentikan paksa OS tamu, jalankan perintah berikut:

      shutdown /f

Memulai ulang instance komputasi

Anda dapat memulai ulang instance komputasi yang telah dihentikan sepenuhnya, yaitu saat status instance komputasi adalah TERMINATED. Jika Anda memilih untuk mempertahankan data SSD Lokal saat menghentikan instance komputasi, Anda mungkin perlu memasang kembali disk SSD Lokal setelah memulai ulang instance komputasi. Untuk mengetahui informasi selengkapnya, lihat Memformat dan memasang perangkat SSD Lokal.

Untuk memulai ulang instance komputasi, gunakan salah satu metode berikut. Metode terbaik untuk kasus penggunaan Anda bergantung pada apakah instance komputasi memiliki disk yang dienkripsi dengan kunci enkripsi yang disediakan pelanggan (CSEK):

Memulai ulang instance komputasi yang tidak memiliki disk terenkripsi CSEK

Untuk memulai ulang beberapa instance komputasi secara bersamaan di berbagai zona, gunakan konsol Google Cloud . Untuk instance komputasi yang ada di 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 komputasi yang ingin Anda mulai ulang.

  3. Klik Start / Resume.

gcloud

Untuk memulai ulang satu atau beberapa instance komputasi yang ada 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 komputasi yang ingin Anda mulai ulang, dipisahkan dengan spasi. Misalnya, tentukan instance-01 instance-02 instance-03.

  • ZONE: zona tempat instance komputasi 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 komputasi, 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 komputasi.

  • PROJECT_ID: ID project tempat instance komputasi berada.

  • ZONE: zona tempat instance komputasi berada.

Memulai ulang instance komputasi dengan disk yang dienkripsi CSEK

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

Untuk memulai ulang beberapa instance komputasi secara bersamaan di berbagai zona, gunakan konsol Google Cloud . Untuk instance komputasi yang ada di 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 komputasi yang ingin Anda mulai ulang.

  3. Klik Start / Resume.

  4. Pada dialog yang muncul, lakukan hal berikut:

    1. Tentukan kunci enkripsi untuk setiap disk terenkripsi yang terpasang ke instance komputasi.

    2. Klik Mulai.

gcloud

Untuk memulai ulang satu atau beberapa instance komputasi yang menggunakan disk terenkripsi yang ada di zona yang sama, gunakan perintah gcloud compute instances start dengan flag --csek-key-file. Jika Anda menggunakan kunci yang digabungkan RSA, 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 komputasi yang ingin Anda mulai ulang, dipisahkan dengan spasi. Misalnya, tentukan instance-01 instance-02 instance-03.

  • ENCRYPTION_KEY_FILE: jalur relatif ke file JSON yang berisi kunci enkripsi yang disediakan pelanggan. Anda hanya dapat memulai ulang beberapa instance komputasi secara bersamaan jika instance komputasi tersebut menggunakan kunci enkripsi yang disediakan pelanggan yang sama. Format file dijelaskan dalam Format file kunci.

  • ZONE: zona tempat instance komputasi 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 komputasi 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 komputasi berada.

  • ZONE: zona tempat instance komputasi berada.

  • INSTANCE_NAME: nama instance komputasi.

  • 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 komputasi. Kunci rawKey atau rsaEncryptedKey harus berenkode base64. Selain itu, untuk menyiapkan kunci rsaEncryptedKey, lihat penggabungan kunci RSA.

Langkah berikutnya