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 jika Anda tidak lagi menggunakannya, atau untuk mengubah propertinya—misalnya, untuk mengubah jenis mesinnya, atau menghapus disk yang terpasang dan di-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 mulai ulang instance, lihat hal berikut:

Sebelum memulai

  • Jika Anda belum melakukannya, siapkan autentikasi. Autentikasi adalah proses yang digunakan untuk memverifikasi identitas Anda agar dapat mengakses Google Cloud layanan dan API. Untuk menjalankan kode atau contoh dari lingkungan pengembangan lokal, Anda dapat mengautentikasi ke Compute Engine dengan memilih salah satu opsi berikut:

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

    Console

    When you use the Google Cloud console to access Google Cloud services and APIs, you don't need to set up authentication.

    gcloud

    1. Install the Google Cloud CLI, then initialize it by running the following command: 

      gcloud init
    2. Set a default region and zone.

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

      1. Install the Google Cloud CLI.

      2. To initialize the gcloud CLI, run the following command: 

        gcloud init

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

      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.

      1. Install the Google Cloud CLI.

      2. To initialize the gcloud CLI, run the following command: 

        gcloud init

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

      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.

      1. Install the Google Cloud CLI.

      2. To initialize the gcloud CLI, run the following command: 

        gcloud init

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

      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.

      1. Install the Google Cloud CLI.

      2. To initialize the gcloud CLI, run the following command: 

        gcloud init

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

      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.

      1. Install the Google Cloud CLI.

      2. To initialize the gcloud CLI, run the following command: 

        gcloud init

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

      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, gunakan kredensial yang Anda berikan ke gcloud CLI.

        Install the Google Cloud CLI, then initialize it by running the following command: 

        gcloud init

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

Peran yang diperlukan

Untuk mendapatkan izin yang Anda perlukan untuk menghentikan atau memulai ulang instance komputasi, 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 yang terpasang, 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.

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

  • Menghentikan instance tanpa disk SSD Lokal

    Anda dapat menghentikan satu atau beberapa instance secara bersamaan yang tidak memiliki disk SSD Lokal. Setiap 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 mempertahankan (Pratinjau) data di disk tersebut. Setiap skrip shutdown dalam instance harus selesai berjalan dalam periode shutdown default.

  • Menghentikan instance dari OS tamu

    Pendekatan ini memungkinkan Anda menghentikan satu instance hanya setelah skrip shutdown selesai berjalan, atau, jika Anda mengaktifkan penghentian halus, hentikan instance tanpa menghentikannya dengan halus, atau akhiri penghentian halus 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 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 halus di instance, Anda dapat menghentikan instance tanpa menghentikannya secara halus atau mengakhiri penghentian halus yang sedang berlangsung menggunakan konsol Google Cloud, 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 Instance VM.

    Buka instance VM

  2. Pilih instance yang sedang berjalan untuk dihentikan.

  3. Klik Hentikan.

  4. Dalam dialog, lakukan hal berikut:

    1. Opsional: Untuk menghentikan instance tanpa menonaktifkannya dengan baik, atau mengakhiri penonaktifan yang sedang berlangsung, pilih kotak centang Lewati penonaktifan yang baik (jika ada).

    2. Untuk mengonfirmasi, klik Berhenti.

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 penghentian halus di satu atau beberapa instance, Anda dapat menghentikan instance tanpa menghentikannya secara halus, atau mengakhiri penghentian halus 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 telah mengaktifkan penghentian halus di instance, Anda dapat menghentikan instance tanpa melakukan penghentian halus, atau mengakhiri penghentian halus 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 hal yang ingin Anda lakukan saat menghentikan instance komputasi, gunakan opsi berikut:

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

  • Untuk mempertahankan data disk SSD Lokal yang dilampirkan ke instance (tidak termasuk instance Z3), 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 Instance VM.

    Buka instance VM

  2. Pilih instance yang sedang berjalan untuk dihentikan.

  3. Klik Hentikan.

  4. Dalam dialog, lakukan hal berikut:

    1. Opsional: Untuk menghentikan instance tanpa menonaktifkannya dengan baik, atau mengakhiri penonaktifan yang sedang berlangsung, pilih kotak centang Lewati penonaktifan yang baik (jika ada).

    2. Untuk mengonfirmasi, klik Berhenti.

gcloud

Saat menghentikan satu atau beberapa instance di zona yang sama yang memiliki disk SSD Lokal yang 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 telah mengaktifkan penghentian halus di satu atau beberapa instance, Anda dapat menghentikan instance tanpa menghentikannya dengan halus, atau mengakhiri penghentian halus 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 yang terpasang, tentukan apakah data SSD Lokal akan dihapus atau dipertahankan 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 mempertahankan 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 telah mengaktifkan penghentian tuntas di instance, Anda dapat menghentikan instance tanpa menonaktifkannya dengan tuntas, atau mengakhiri penghentian 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 mempertahankan 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 mematikan OS tamu, jalankan perintah berikut:

      sudo shutdown -h now

    • Jika tidak, untuk memaksa penonaktifan, 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 dengan bersih dan mengizinkan instance menjalankan skrip shutdown sebelum mematikan OS tamu, jalankan perintah berikut:

      shutdown /s

    • Untuk memaksa penonaktifan, 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 ulang 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

Anda dapat memulai ulang beberapa instance komputasi secara bersamaan atau instance individual. Untuk beberapa instance, gunakan konsol Google Cloud atau, untuk instance yang berada di zona yang sama, gcloud CLI. Untuk setiap instance, pilih salah satu opsi berikut:

Konsol

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

    Buka instance VM

  2. Pilih satu atau beberapa instance.

  3. Klik Start / Resume.

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 yang memiliki disk terpasang yang dienkripsi menggunakan kunci enkripsi yang disediakan pelanggan, Anda harus memberikan informasi kunci enkripsi.

Anda dapat memulai ulang beberapa instance secara bersamaan atau satu per satu. Untuk beberapa instance, gunakan konsol Google Cloud atau, untuk instance yang berada di zona yang sama, gunakan gcloud CLI. Untuk setiap instance, pilih salah satu opsi berikut:

Konsol

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

    Buka instance VM

  2. Pilih instance yang akan dimulai ulang.

  3. Klik Start / Resume.

  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, 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 memulai ulang beberapa instance secara bersamaan jika instance menggunakan kunci enkripsi yang sama yang disediakan pelanggan.

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