Compute Engine-Instanz beenden oder neu starten

In diesem Dokument wird beschrieben, wie Sie eine Compute Engine-Instanz manuell beenden oder neu starten. Alternativ können Sie das Beenden oder Neustarten einer Compute-Instanz automatisieren. Weitere Informationen finden Sie hier:

Es ist möglich, eine Compute-Instanz manuell zu beenden. Nachdem ein Beendigungsvorgang abgeschlossen ist und der Status der Compute-Instanz in TERMINATED übergeht, können Sie die Compute-Instanz entweder neu starten, um Ihre Arbeitslast fortzusetzen, oder die Compute-Instanz dauerhaft löschen, wenn Sie sie nicht mehr benötigen. Das manuelle Beenden einer Compute-Instanz ist in folgenden Fällen nützlich:

  • Kosten sparen und Konfigurationen beibehalten: Sie möchten keine Arbeitslasten mehr auf der Compute-Instanz ausführen. Sie möchten jedoch die Compute-Instanz und die zugehörigen angehängten Laufwerke, Konfigurationseinstellungen, IP-Adressen, MAC-Adressen und Metadaten beibehalten. Wenn Sie auch In-Memory-Daten und den Anwendungsstatus beibehalten möchten, halten Sie stattdessen die Compute-Instanz an.

  • Attribute aktualisieren: Sie möchten ein oder mehrere Attribute ändern, für die Sie die Compute-Instanz beenden und neu starten müssen, bevor die Änderungen wirksam werden. Sie möchten beispielsweise den Maschinentyp ändern oder ein Laufwerk trennen. Weitere Informationen finden Sie unter Attribute, die Sie aktualisieren können.

Beschränkungen

Wenn Sie eine Compute-Instanz beenden, gelten die folgenden Einschränkungen:

  • Sie können eine Compute-Instanz nur beenden oder neu starten, wenn der Status der Compute-Instanz dies zulässt.

  • Sie können eine Compute-Instanz nur dann neu starten, wenn in der Zone, in der sich die Compute-Instanz befindet, genügend Ressourcen vorhanden sind.

  • TPU-Compute-Instanzen können nicht neu gestartet werden. Nachdem Sie TPU-Compute-Instanzen beendet haben, können Sie sie nur löschen.

Hinweis

Erforderliche Rollen

Bitten Sie Ihren Administrator, Ihnen die IAM-Rolle Compute Instance Admin (v1) (roles/compute.instanceAdmin.v1) für das Projekt zu gewähren, um die Berechtigungen zu erhalten, die Sie zum Beenden oder Neustarten einer Compute-Instanz benötigen. Weitere Informationen zum Zuweisen von Rollen finden Sie unter Zugriff auf Projekte, Ordner und Organisationen verwalten.

Diese vordefinierte Rolle enthält die Berechtigungen, die zum Beenden oder Neustarten einer Compute-Instanz erforderlich sind. Maximieren Sie den Abschnitt Erforderliche Berechtigungen, um die notwendigen Berechtigungen anzuzeigen:

Erforderliche Berechtigungen

Die folgenden Berechtigungen sind erforderlich, um eine Compute-Instanz zu beenden oder neu zu starten:

  • So beenden Sie eine Compute-Instanz: compute.instances.stop für die Compute-Instanz
  • So beenden Sie eine Compute-Instanz über das Gastbetriebssystem: compute.instances.setMetadata auf der Compute-Instanz, wenn sie öffentliche SSH-Schlüssel auf Instanzebene verwendet.
  • So starten Sie eine Compute-Instanz neu: compute.instances.start für die Compute-Instanz
  • So starten Sie eine Compute-Instanz neu, die Verschlüsselungsschlüssel verwendet: compute.instances.startWithEncryptionKey für die Compute-Instanz

Sie können diese Berechtigungen auch mit benutzerdefinierten Rollen oder anderen vordefinierten Rollen erhalten.

Compute-Instanz beenden

Verwenden Sie eine der folgenden Methoden, um Ihre Compute-Instanz zu beenden. Der beste Ansatz für Ihren Anwendungsfall hängt davon ab, ob Sie lokale SSD-Laufwerke an Ihre Compute-Instanz angehängt haben und wie Sie mit Skripts zum Herunterfahren umgehen möchten:

  • Compute-Instanz von Google Cloudbeenden. Sie können eine oder mehrere Compute-Instanzen gleichzeitig über Google Cloudbeenden. Wenn an die Compute-Instanzen lokale SSD-Laufwerke angehängt sind, können Sie auswählen, ob die lokalen SSD-Daten verworfen oder beibehalten werden sollen (Vorabversion). Alle Shutdown-Scripts in der Compute-Instanz müssen abgeschlossen sein, bevor die Compute-Instanz beendet wird. Eine Anleitung finden Sie hier:

  • Compute-Instanz über das Gastbetriebssystem beenden So wird sichergestellt, dass die Shutdown-Scripts ausgeführt werden, bevor die Compute-Instanz beendet wird. Wenn Sie das ordnungsgemäße Herunterfahren aktiviert haben, können Sie es überspringen oder beenden. Wenn Sie eine Compute-Instanz über das Gastbetriebssystem beenden, werden jedoch die Daten auf allen angehängten lokalen SSD-Laufwerken verworfen, es sei denn, Sie sichern die Daten zuerst in einem langlebigen Speicher. Eine Anleitung finden Sie unter Compute-Instanz über das Gastbetriebssystem beenden.

Compute-Instanz ohne lokale SSD-Laufwerke beenden

Wenn Sie eine Compute-Instanz beenden möchten, an die keine lokalen SSD-Laufwerke angehängt sind, sehen Sie sich die folgenden Optionen an:

  • Wenn Sie das ordnungsgemäße Herunterfahren in der Compute-Instanz aktiviert haben, können Sie Kosten sparen, indem Sie ein laufendes ordnungsgemäßes Herunterfahren überspringen oder beenden. Verwenden Sie dazu die Google Cloud Console, die gcloud CLI oder die REST API.

  • Wenn Sie mehrere Compute-Instanzen gleichzeitig beenden möchten, verwenden Sie dieGoogle Cloud Console oder, für Compute-Instanzen in derselben Zone, die gcloud CLI.

Wählen Sie eine der folgenden Optionen aus, um eine oder mehrere Compute-Instanzen zu beenden:

Console

  1. Rufen Sie in der Google Cloud Console die Seite VM-Instanzen auf.

    Zur Seite „VM-Instanzen“

  2. Wählen Sie die laufenden Compute-Instanzen aus, die Sie beenden möchten.

  3. Klicken Sie auf Beenden. Wenn die Option Beenden nicht angezeigt wird, klicken Sie auf Weitere Aktionen und wählen Sie dann Beenden aus.

  4. Führen Sie im angezeigten Dialogfeld die folgenden Schritte aus:

    1. Optional: Wenn Sie die Compute-Instanzen beenden möchten, ohne sie ordnungsgemäß herunterzufahren, oder wenn Sie ein laufendes ordnungsgemäßes Herunterfahren beenden möchten, wählen Sie das Kästchen Ordnungsgemäßes Herunterfahren überspringen (falls zutreffend) aus.

    2. Klicken Sie zur Bestätigung auf Beenden.

gcloud

Wenn Sie eine oder mehrere Compute-Instanzen in derselben Zone beenden möchten, verwenden Sie den Befehl gcloud compute instances stop:

gcloud compute instances stop INSTANCE_NAMES \
    --zone=ZONE

Ersetzen Sie Folgendes:

  • INSTANCE_NAMES: eine Liste der Namen von Compute-Instanzen, die Sie beenden möchten, durch Leerzeichen getrennt. Geben Sie beispielsweise instance-01 instance-02 instance-03 an.

  • ZONE: die Zone, in der sich die Compute-Instanzen befinden.

Wenn Sie ein laufendes ordnungsgemäßes Herunterfahren überspringen oder beenden möchten, verwenden Sie denselben Befehl mit dem 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

Senden Sie zum Beenden einer Compute-Instanz eine POST-Anfrage an die Methode instances.stop:

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

Ersetzen Sie Folgendes:

  • INSTANCE_NAME: Der Name der Compute-Instanz.

  • PROJECT_ID: die ID des Projekts, in dem sich die Compute-Instanz befindet.

  • ZONE: die Zone, in der sich die Compute-Instanz befindet.

Wenn Sie ein laufendes ordnungsgemäßes Herunterfahren überspringen oder beenden möchten, fügen Sie den Suchparameter noGracefulShutdown=true in die Anfrage-URL ein:

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

Compute-Instanz mit lokalen SSD-Laufwerken beenden

Die beste Methode zum Beenden einer Compute-Instanz mit angehängten lokalen SSD-Laufwerken hängt von Ihrem Anwendungsfall ab. Verwenden Sie eine der folgenden Optionen:

  • Wenn Sie das ordnungsgemäße Herunterfahren in einer Compute-Instanz aktiviert haben, können Sie Kosten sparen, indem Sie ein laufendes ordnungsgemäßes Herunterfahren überspringen oder beenden. Verwenden Sie dazu die Google Cloud Console, die gcloud CLI oder die REST API.

  • Wenn Sie Daten auf lokalen SSDs beibehalten möchten (außer bei Maschinentypen, die Titanium SSD verwenden), verwenden Sie die gcloud CLI oder die REST API.

  • Wenn Sie mehrere Compute-Instanzen gleichzeitig beenden möchten, verwenden Sie dieGoogle Cloud Console oder, für Compute-Instanzen in derselben Zone, die gcloud CLI.

Wählen Sie eine der folgenden Optionen aus, um eine oder mehrere Compute-Instanzen mit angehängten lokalen SSD-Laufwerken zu beenden:

Console

  1. Rufen Sie in der Google Cloud Console die Seite VM-Instanzen auf.

    Zur Seite „VM-Instanzen“

  2. Wählen Sie die laufenden Compute-Instanzen aus, die Sie beenden möchten.

  3. Klicken Sie auf Beenden. Wenn die Option Beenden nicht angezeigt wird, klicken Sie auf Weitere Aktionen und wählen Sie dann Beenden aus.

  4. Führen Sie im angezeigten Dialogfeld die folgenden Schritte aus:

    1. Optional: Wenn Sie die Compute-Instanzen beenden möchten, ohne sie ordnungsgemäß herunterzufahren, oder wenn Sie ein laufendes ordnungsgemäßes Herunterfahren beenden möchten, wählen Sie das Kästchen Ordnungsgemäßes Herunterfahren überspringen (falls zutreffend) aus.

    2. Klicken Sie zur Bestätigung auf Beenden.

gcloud

Wenn Sie eine oder mehrere Compute-Instanzen in derselben Zone beenden, an die lokale SSD-Laufwerke angehängt sind, geben Sie so an, ob lokale SSD-Daten verworfen oder beibehalten werden sollen:

  • Wenn Sie lokale SSD-Daten verwerfen möchten, verwenden Sie den Befehl gcloud compute instances stop mit dem Flag --discard-local-ssd=true:

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

  • Wenn Sie lokale SSD-Daten beibehalten möchten, verwenden Sie den Befehl gcloud beta compute instances stop mit dem Flag --discard-local-ssd=false:

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

Ersetzen Sie Folgendes:

  • INSTANCE_NAMES: eine Liste der Namen von Compute-Instanzen, die Sie beenden möchten, durch Leerzeichen getrennt. Geben Sie beispielsweise instance-01 instance-02 instance-03 an.

  • ZONE: die Zone, in der sich die Compute-Instanzen befinden.

Wenn Sie ein laufendes ordnungsgemäßes Herunterfahren überspringen oder beenden möchten, fügen Sie das Flag --no-graceful-shutdown in den Befehl ein:

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

Ersetzen Sie DISCARD_LOCAL_SSD durch true, um die Daten auf den lokalen SSD-Laufwerken zu verwerfen, oder durch false, um die Daten beizubehalten. Wenn Sie false angeben, müssen Sie den Befehl gcloud beta compute instances stop verwenden.

REST

Wenn Sie eine oder mehrere Compute-Instanzen in derselben Zone beenden, an die lokale SSD-Laufwerke angehängt sind, geben Sie so an, ob die lokalen SSD-Daten verworfen oder beibehalten werden sollen:

  • Wenn Sie lokale SSD-Daten verwerfen möchten, senden Sie eine POST-Anfrage an die Methode instances.stop. Fügen Sie in der Anfrage-URL den Abfrageparameter discardLocalSsd ein, wobei dieser auf true gesetzt ist:

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

  • Senden Sie eine POST-Anfrage an die Methode beta.instances.stop, um lokale SSD-Daten beizubehalten. Fügen Sie in der Anfrage-URL den Abfrageparameter discardLocalSsd ein, wobei dieser auf false gesetzt ist:

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

Ersetzen Sie Folgendes:

  • PROJECT_ID: die ID des Projekts, in dem sich die Compute-Instanz befindet.

  • ZONE: die Zone, in der sich die Compute-Instanz befindet.

  • INSTANCE_NAME: Der Name der Compute-Instanz.

Wenn Sie ein laufendes ordnungsgemäßes Herunterfahren überspringen oder beenden möchten, fügen Sie den Suchparameter noGracefulShutdown=true in die Anfrage-URL ein:

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

Ersetzen Sie DISCARD_LOCAL_SSD durch true, um die Daten auf den lokalen SSD-Laufwerken zu verwerfen, oder durch false, um die Daten beizubehalten. Wenn Sie false angeben, müssen Sie eine POST-Anfrage an die Methode beta.instances.stop senden.

Compute-Instanz über das Gastbetriebssystem beenden

Wenn an eine Compute-Instanz lokale SSD-Laufwerke angehängt sind, werden die Daten auf den lokalen SSDs beim Herunterfahren des Gastbetriebssystems automatisch verworfen. Wenn Sie diese Daten behalten möchten, kopieren Sie sie manuell in eine nichtflüchtige Speicheroption, bevor Sie die Compute-Instanz beenden.

Wählen Sie eine der folgenden Optionen aus, um eine Compute-Instanz über das Gastbetriebssystem zu beenden:

Linux

  1. Stellen Sie eine Verbindung zur Compute-Instanz her, falls Sie dies noch nicht getan haben.

  2. Wählen Sie eine der folgenden Methoden aus, um die Compute-Instanz über das Gastbetriebssystem zu beenden:

    • Führen Sie den folgenden Befehl aus, um das Gastbetriebssystem erst dann ordnungsgemäß herunterzufahren, wenn alle Shutdown-Skripts ausgeführt wurden:

      sudo shutdown -h now

    • Führen Sie den folgenden Befehl aus, um das Herunterfahren des Gastbetriebssystems zu erzwingen:

      sudo poweroff

Windows

  1. Falls noch nicht geschehen, stellen Sie mit einer der folgenden Methoden eine Verbindung zur Compute-Instanz her:

  2. Wählen Sie eine der folgenden Methoden aus, um die Compute-Instanz über das Gastbetriebssystem zu beenden:

    • Führen Sie den folgenden Befehl aus, um das Gastbetriebssystem erst dann ordnungsgemäß herunterzufahren, wenn alle Shutdown-Skripts ausgeführt wurden:

      shutdown /s

    • Führen Sie den folgenden Befehl aus, um das Herunterfahren des Gastbetriebssystems zu erzwingen:

      shutdown /f

Compute-Instanz neu starten

Sie können eine Compute-Instanz neu starten, die vollständig beendet wurde. Das ist der Fall, wenn der Status der Compute-Instanz TERMINATED lautet. Wenn Sie beim Beenden der Compute-Instanz die Option zum Beibehalten der lokalen SSD-Daten ausgewählt haben, müssen Sie die lokalen SSD-Laufwerke nach dem Neustart der Compute-Instanz möglicherweise neu bereitstellen. Weitere Informationen finden Sie unter Lokales SSD-Gerät formatieren und bereitstellen.

Verwenden Sie eine der folgenden Methoden, um eine Compute-Instanz neu zu starten. Die beste Methode für Ihren Anwendungsfall hängt davon ab, ob die Compute-Instanz Laufwerke hat, die mit vom Kunden bereitgestellten Verschlüsselungsschlüsseln (CSEK) verschlüsselt wurden:

Compute-Instanz ohne CSEK-verschlüsselte Laufwerke neu starten

Wenn Sie mehrere Compute-Instanzen gleichzeitig in verschiedenen Zonen neu starten möchten, verwenden Sie die Google Cloud Console. Für Compute-Instanzen, die sich in derselben Zone befinden, können Sie die gcloud CLI verwenden. Wählen Sie für andere Neustartszenarien eine der folgenden Optionen aus:

Console

  1. Rufen Sie in der Google Cloud Console die Seite VM-Instanzen auf.

    Zur Seite „VM-Instanzen“

  2. Wählen Sie die Compute-Instanzen aus, die Sie neu starten möchten.

  3. Klicken Sie auf Starten/Fortsetzen.

gcloud

Wenn Sie eine oder mehrere Compute-Instanzen in derselben Zone neu starten möchten, verwenden Sie den Befehl gcloud compute instances start:

gcloud compute instances start INSTANCE_NAMES \
    --zone=ZONE

Ersetzen Sie Folgendes:

  • INSTANCE_NAMES: eine Liste der Namen von Compute-Instanzen, die Sie neu starten möchten, durch Leerzeichen getrennt. Geben Sie beispielsweise instance-01 instance-02 instance-03 an.

  • ZONE: die Zone, in der sich die Compute-Instanzen befinden.

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

Wenn Sie eine Compute-Instanz neu starten möchten, senden Sie eine POST-Anfrage an die Methode instances.start:

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

Ersetzen Sie Folgendes:

  • INSTANCE_NAME: Der Name der Compute-Instanz.

  • PROJECT_ID: die ID des Projekts, in dem sich die Compute-Instanz befindet.

  • ZONE: die Zone, in der sich die Compute-Instanz befindet.

Compute-Instanz mit CSEK-verschlüsselten Laufwerken neu starten

Wenn Sie eine angehaltene Compute-Instanz mit angehängten Laufwerken neu starten, die mit vom Kunden bereitgestellten Verschlüsselungsschlüsseln verschlüsselt wurden, müssen Sie die Informationen zum Verschlüsselungsschlüssel angeben.

Wenn Sie mehrere Compute-Instanzen gleichzeitig in verschiedenen Zonen neu starten möchten, verwenden Sie die Google Cloud Console. Für Compute-Instanzen, die sich in derselben Zone befinden, können Sie die gcloud CLI verwenden. Wählen Sie für andere Neustartszenarien eine der folgenden Optionen aus:

Console

  1. Rufen Sie in der Google Cloud Console die Seite VM-Instanzen auf.

    Zur Seite „VM-Instanzen“

  2. Wählen Sie die Compute-Instanzen aus, die Sie neu starten möchten.

  3. Klicken Sie auf Starten/Fortsetzen.

  4. Führen Sie im angezeigten Dialogfeld die folgenden Schritte aus:

    1. Geben Sie Verschlüsselungsschlüssel für jedes der verschlüsselten Laufwerke an, die an die Compute-Instanzen angehängt sind.

    2. Klicken Sie auf Start.

gcloud

Wenn Sie eine oder mehrere Compute-Instanzen neu starten möchten, die verschlüsselte Laufwerke in derselben Zone verwenden, verwenden Sie den Befehl gcloud compute instances start mit dem Flag --csek-key-file. Wenn Sie einen mit RSA verpackten Schlüssel verwenden, nutzen Sie stattdessen den Befehl gcloud beta compute instances start mit dem Flag --csek-key-file:

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

Ersetzen Sie Folgendes:

  • INSTANCE_NAMES: eine Liste der Namen von Compute-Instanzen, die Sie neu starten möchten, durch Leerzeichen getrennt. Geben Sie beispielsweise instance-01 instance-02 instance-03 an.

  • ENCRYPTION_KEY_FILE: der relative Pfad zur JSON-Datei, die den vom Kunden bereitgestellten Verschlüsselungsschlüssel enthält. Sie können mehrere Compute-Instanzen nur dann gleichzeitig neu starten, wenn sie denselben vom Kunden bereitgestellten Verschlüsselungsschlüssel verwenden. Das Format der Datei wird unter Schlüsseldateiformat beschrieben.

  • ZONE: die Zone, in der sich die Compute-Instanzen befinden.

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

Wenn Sie eine Compute-Instanz mit verschlüsselten Laufwerken neu starten möchten, senden Sie eine POST-Anfrage an die Methode 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"
      }
    }
  ]
}

Ersetzen Sie Folgendes:

  • PROJECT_ID: die ID des Projekts, in dem sich die Compute-Instanz befindet.

  • ZONE: die Zone, in der sich die Compute-Instanz befindet.

  • INSTANCE_NAME: Der Name der Compute-Instanz.

  • DISK_URL: Ressourcen-URL, die dem vollständigen Ressourcennamen des angehängten Laufwerks entspricht und mit einem vom Kunden bereitgestellten Verschlüsselungsschlüssel verschlüsselt ist

  • ENCRYPTION_TYPE: der Typ der Laufwerksverschlüsselung, die Sie verwenden. Dies kann einer der folgenden sein: rawKey, kmsKeyName oder rsaEncryptedKey. Wenn Sie den Typ rsaEncryptedKey verwenden, stellen Sie eine POST-Anfrage an die Methode beta.instances.startWithEncryptionKey.

  • ENCRYPTION_KEY: der Verschlüsselungsschlüssel, der zum Verschlüsseln der nichtflüchtigen Speicher verwendet wird, die an die Compute-Instanz angehängt sind. rawKey- oder rsaEncryptedKey-Schlüssel müssen Base64-codiert sein. Informationen zum Vorbereiten eines rsaEncryptedKey-Schlüssels finden Sie unter RSA-Schlüssel-Wrapping.

Nächste Schritte