Compute Engine-Instanz anhalten oder fortsetzen

In diesem Dokument wird beschrieben, wie Sie Compute Engine-Instanzen anhalten oder fortsetzen. Weitere Informationen zum Pausieren, Beenden oder Zurücksetzen von Instanzen finden Sie unter Compute Engine-Instanzen pausieren, beenden oder zurücksetzen.

Wenn Sie Ihre Compute Engine-Instanz behalten, aber nicht in Rechnung stellen möchten, wenn sie nicht verwendet wird, können Sie die Instanz anhalten. Wenn Sie eine Instanz anhalten, wird die Instanz beibehalten und der Inhalt des Arbeitsspeichers der Instanz wird in den Speicher migriert. Nach dem Fortsetzen der Instanz migriert die Compute Engine den Arbeitsspeicher der Instanz aus dem Speicher zurück zur Instanz und die Instanz wird wieder ausgeführt.

Das Anhalten einer Compute Engine-Instanz ist in folgenden Fällen sinnvoll:

  • Entwicklungs- und Testumgebungen, die zu bestimmten Zeiten (z. B. abends oder am Wochenende) nicht vollständig genutzt werden. So lassen sich Kosten sparen und VM-Instanzen können schneller initialisiert werden, als die Erstellung neuer Instanzen dauern würde.

  • Anwendungen, die nach dem Starten der Instanz erst einmal lange initialisiert werden müssen, bevor die Anwendung zur Verarbeitung ihrer ersten Anfrage bereit ist. Beispiele für solche Anwendungen sind virtuelle Entwickler-Workstations oder komplexe Java-Anwendungen.

Hinweise

  • Richten Sie die Authentifizierung ein, falls Sie dies noch nicht getan haben. Bei der Authentifizierung wird Ihre Identität für den Zugriff auf Google Cloud-Dienste und APIs überprüft. Zur Ausführung von Code oder Beispielen aus einer lokalen Entwicklungsumgebung können Sie sich bei Compute Engine authentifizieren. Wählen Sie dazu eine der folgenden Optionen aus:

    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

      Wenn Sie die Go Beispiele auf dieser Seite in einer lokalen Entwicklungsumgebung verwenden möchten, installieren und initialisieren Sie die gcloud CLI und richten dann die Standardanmeldedaten für Anwendungen mit Ihren Nutzeranmeldedaten ein.

      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.

      Weitere Informationen unter Set up authentication for a local development environment.

      Java

      Wenn Sie die Java Beispiele auf dieser Seite in einer lokalen Entwicklungsumgebung verwenden möchten, installieren und initialisieren Sie die gcloud CLI und richten dann die Standardanmeldedaten für Anwendungen mit Ihren Nutzeranmeldedaten ein.

      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.

      Weitere Informationen unter Set up authentication for a local development environment.

      Node.js

      Wenn Sie die Node.js Beispiele auf dieser Seite in einer lokalen Entwicklungsumgebung verwenden möchten, installieren und initialisieren Sie die gcloud CLI und richten dann die Standardanmeldedaten für Anwendungen mit Ihren Nutzeranmeldedaten ein.

      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.

      Weitere Informationen unter Set up authentication for a local development environment.

      PHP

      Wenn Sie die PHP Beispiele auf dieser Seite in einer lokalen Entwicklungsumgebung verwenden möchten, installieren und initialisieren Sie die gcloud CLI und richten dann die Standardanmeldedaten für Anwendungen mit Ihren Nutzeranmeldedaten ein.

      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.

      Weitere Informationen unter Set up authentication for a local development environment.

      Python

      Wenn Sie die Python Beispiele auf dieser Seite in einer lokalen Entwicklungsumgebung verwenden möchten, installieren und initialisieren Sie die gcloud CLI und richten dann die Standardanmeldedaten für Anwendungen mit Ihren Nutzeranmeldedaten ein.

      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.

      Weitere Informationen unter Set up authentication for a local development environment.

      REST

      Verwenden Sie die von der gcloud CLI bereitgestellten Anmeldedaten, um die REST API-Beispiele auf dieser Seite in einer lokalen Entwicklungsumgebung zu verwenden.

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

        gcloud init

      Weitere Informationen finden Sie unter Für die Verwendung von REST authentifizieren in der Dokumentation zur Google Cloud-Authentifizierung.

Erforderliche Rollen

Bitten Sie Ihren Administrator, Ihnen die IAM-Rolle Compute-Instanzadministrator (v1) (roles/compute.instanceAdmin.v1) für die Instanz zu gewähren, um die Berechtigungen zu erhalten, die Sie zum Pausieren oder Fortsetzen 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 Pausieren oder Fortsetzen einer Compute-Instanz erforderlich sind. Erweitern Sie den Abschnitt Erforderliche Berechtigungen, um die erforderlichen Berechtigungen anzuzeigen:

Erforderliche Berechtigungen

Die folgenden Berechtigungen sind erforderlich, um eine Compute-Instanz zu pausieren oder fortzusetzen:

  • So halten Sie eine Instanz an: compute.instances.suspend
  • So setzen Sie eine Instanz fort: compute.instances.resume

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

Beschränkungen

Beim Pausieren einer Compute-Instanz gelten die folgenden Einschränkungen:

  • Sie können eine Instanz nur anhalten, wenn das Gastbetriebssystem dies unterstützt. Weitere Informationen finden Sie unter Details zu Betriebssystemen.

  • Sie können eine Instanz, die Debian 8 oder 9 als Gastbetriebssystem verwendet, nur anhalten, wenn Sie das Betriebssystem konfigurieren, bevor Sie die VM anhalten.

  • Sie können eine Instanz nur bis zu 60 Tage lang anhalten, bevor die Compute Engine ihren Status automatisch in TERMINATED ändert.

  • Sie können Spot-VMs oder Instanzen auf Abruf anhalten. Wenn die Compute Engine die Instanz jedoch vor Abschluss des Anhaltevorgangs vorzeitig beendet, beendet die Compute Engine den Anhaltevorgang und beendet die Instanzen vorzeitig.

  • Sie können Instanzen mit angehängten GPUs nicht anhalten.

  • Bare-Metal-Instanzen können nicht angehalten werden.

  • Sie können Confidential VMs nicht anhalten.

  • Sie können Instanzen nicht mithilfe der Standardprozesse anhalten, die in die Gastumgebung eingebunden sind. Befehle wie systemctl suspend in Ubuntu 16.04 oder höher werden nicht unterstützt. Wenn diese Funktion aufgerufen wird, ignoriert Compute Engine das Gastsignal.

  • Sie können Instanzen mit mehr als 208 GB Arbeitsspeicher nicht anhalten.

  • Sie können keine Instanzen anhalten, an die CSEK-geschützte Laufwerke angehängt sind.

Suspend-Vorgänge in Debian 8 oder 9 aktivieren

Wenn auf einer Compute-Instanz Debian 8 und 9 als Gastbetriebssystem ausgeführt wird, müssen Sie die Funktionen „Anhalten“ und „Fortsetzen“ aktivieren, bevor Sie die Instanz anhalten. Gehen Sie dazu so vor:

ACPID konfigurieren

Wenn Sie den Ruhemodus und die Wiederaufnahme in Debian 8 oder 9 aktivieren möchten, können Sie den Advanced Configuration and Power Interface events Daemon (ACPID) so konfigurieren, dass er das Schaltflächenereignis für den Ruhemodus verarbeitet. Nachdem Sie das Schaltflächenereignis für den Ruhemodus aktiviert haben, können Sie wie in diesem Abschnitt beschrieben ein Shell-Script für die Verarbeitung des Ruhemodusereignisses hinzufügen.

So konfigurieren Sie die ACPID für die Unterstützung von Anhalten und Fortsetzen:

  1. Stellen Sie eine Verbindung zu Ihrer Linux-Instanz her, falls Sie das noch nicht getan haben.

  2. Erstellen Sie den Ordner events im Ordner acpi:

    sudo mkdir -p /etc/acpi/events/

  3. Konfigurieren Sie ACPID so, dass das Schaltflächenereignis für den Ruhemodus verarbeitet wird:

    cat <<EOF | sudo tee /etc/acpi/events/sleepbtn-acpi-support
event=button[ /]sleep
action=/etc/acpi/sleepbtn-acpi-support.sh
EOF

  4. Erstellen Sie das Skript zur Verarbeitung von Ruhemodusereignissen:

    cat <<EOF | sudo tee /etc/acpi/sleepbtn-acpi-support.sh
#!/bin/sh
echo mem > /sys/power/state
EOF

  5. Legen Sie die Berechtigungen für das Skript fest:

    sudo chmod 755 /etc/acpi/sleepbtn-acpi-support.sh

  6. Starten Sie ACPID neu, damit die Änderungen wirksam werden:

    sudo systemctl restart acpid.service

D-Bus installieren

Wenn Sie die Funktionen „Anhalten“ und „Fortsetzen“ in Debian 8 oder 9 aktivieren möchten, können Sie D-Bus installieren.

So installieren Sie D-Bus im Gastbetriebssystem Ihrer Compute-Instanz, wenn das Betriebssystem Debian 8 oder 9 verwendet:

  1. Stellen Sie eine Verbindung zu Ihrer Linux-Instanz her, falls Sie das noch nicht getan haben.

  2. Installieren Sie D-Bus:

    sudo apt-get install dbus

  3. Starten Sie logind neu, damit die Änderungen wirksam werden:

    sudo systemctl restart systemd-logind.service

Instanz anhalten

Wenn das Gastbetriebssystem Ihrer Compute-Instanz Debian 8 oder 9 verwendet, müssen Sie es vor dem Aussetzen der Instanz so konfigurieren, dass es die Aussetzung und Fortführung von Vorgängen wie in diesem Dokument beschrieben unterstützt.

Je nachdem, ob an der Instanz lokale SSDs angehängt sind, können Sie eine der folgenden Methoden verwenden, um sie zu sperren:

Instanz ohne lokale SSDs anhalten

Sie können mehrere Compute-Instanzen gleichzeitig oder einzelne Instanzen pausieren. Verwenden Sie für mehrere Instanzen die Google Cloud Console oder für Instanzen in derselben Zone die Google Cloud CLI. Wählen Sie für einzelne Instanzen eine der folgenden Optionen aus:

Console

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

    Zu „VM-Instanzen“

  2. Wählen Sie eine oder mehrere Instanzen aus, die angehalten werden sollen.

  3. Klicken Sie auf Sperren und dann zum Bestätigen auf Sperren.

gcloud

Wenn Sie eine oder mehrere Instanzen in einer einzelnen Zone sperren möchten, verwenden Sie den Befehl gcloud compute instances suspend:

gcloud compute instances suspend INSTANCE_NAMES \
    --zone=ZONE

Ersetzen Sie Folgendes:

  • INSTANCE_NAMES: eine durch Leerzeichen getrennte Liste von Instanzennamen, z. B. instance-01 instance-02 instance-03.

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

Go

import (
	"context"
	"fmt"
	"io"

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

// suspendInstance suspends a running Google Compute Engine instance.
func suspendInstance(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.SuspendInstanceRequest{
		Project:  projectID,
		Zone:     zone,
		Instance: instanceName,
	}

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

	return nil
}

Java 


import com.google.cloud.compute.v1.Instance.Status;
import com.google.cloud.compute.v1.InstancesClient;
import com.google.cloud.compute.v1.Operation;
import java.io.IOException;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.TimeoutException;

public class SuspendInstance {

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

    String project = "your-project-id";
    String zone = "zone-name";
    String instanceName = "instance-name";

    suspendInstance(project, zone, instanceName);
  }

  // Suspend a running Google Compute Engine instance.
  // For limitations and compatibility on which instances can be suspended,
  // see: https://cloud.google.com/compute/docs/instances/suspend-resume-instance#limitations
  public static void suspendInstance(String project, String zone, String instanceName)
      throws IOException, ExecutionException, InterruptedException, TimeoutException {
    // Instantiates a client.
    try (InstancesClient instancesClient = InstancesClient.create()) {

      Operation operation = instancesClient.suspendAsync(project, zone, instanceName)
          .get(300, TimeUnit.SECONDS);

      if (operation.hasError() || !instancesClient.get(project, zone, instanceName).getStatus()
          .equalsIgnoreCase(Status.SUSPENDED.toString())) {
        System.out.println("Cannot suspend instance. Try again!");
        return;
      }

      System.out.printf("Instance suspended successfully ! %s", instanceName);
    }
  }
}

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

// Suspends a running Google Compute Engine instance.
async function suspendInstance() {
  const instancesClient = new compute.InstancesClient();

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

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

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

suspendInstance();

PHP

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

/**
 * Suspend 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 suspend.
  *
 * @throws \Google\ApiCore\ApiException if the remote call fails.
 * @throws \Google\ApiCore\ValidationException if local error occurs before remote call.
 */
function suspend_instance(
    string $projectId,
    string $zone,
    string $instanceName
) {
    // Suspend the running Compute Engine instance using InstancesClient.
    $instancesClient = new InstancesClient();
    $request = (new SuspendInstanceRequest())
        ->setInstance($instanceName)
        ->setProject($projectId)
        ->setZone($zone);
    $operation = $instancesClient->suspend($request);

    // Wait for the operation to complete.
    $operation->pollUntilComplete();
    if ($operation->operationSucceeded()) {
        printf('Instance %s suspended successfully' . PHP_EOL, $instanceName);
    } else {
        $error = $operation->getError();
        printf('Failed to suspend 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 suspend_instance(project_id: str, zone: str, instance_name: str) -> None:
    """
    Suspend 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 you want to suspend.
    """
    instance_client = compute_v1.InstancesClient()

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

    wait_for_extended_operation(operation, "suspend instance")

REST

Wenn Sie eine Instanz pausieren möchten, senden Sie eine POST-Anfrage an die Methode instances.suspend:

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

Ersetzen Sie Folgendes:

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

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

  • INSTANCE_NAME: der Name der Instanz.

Instanz mit lokalen SSD-Laufwerken anhalten

Gehen Sie je nachdem, wie viele Compute-Instanzen Sie gleichzeitig anhalten möchten und ob Sie die Daten der angehängten lokalen SSDs beibehalten möchten, so vor:

  • Wenn Sie die Daten der an eine Instanz angeschlossenen lokalen SSDs beibehalten möchten, halten Sie die Instanz mit der gcloud CLI oder der REST API an.

  • Wenn Sie mehrere Instanzen gleichzeitig anhalten möchten, verwenden Sie die Google Cloud Console oder, bei Instanzen in derselben Zone, die gcloud CLI.

Wenn Sie eine oder mehrere Instanzen mit angehängten lokalen SSDs anhalten möchten, wählen Sie eine der folgenden Optionen aus:

Console

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

    Zu „VM-Instanzen“

  2. Wählen Sie eine oder mehrere Instanzen aus, die angehalten werden sollen.

  3. Klicken Sie auf Sperren und dann zum Bestätigen auf Sperren.

gcloud

Wenn Sie eine oder mehrere Instanzen in einer einzelnen Zone anhalten, an die lokale SSDs angehängt sind, können Sie angeben, ob die Daten auf den lokalen SSDs verworfen oder beibehalten werden sollen:

  • Verwenden Sie den Befehl gcloud compute instances suspend mit dem Flag --discard-local-ssd=true, um lokale SSD-Daten zu verwerfen:

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

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

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

Ersetzen Sie Folgendes:

  • INSTANCE_NAMES: eine durch Leerzeichen getrennte Liste von Instanzennamen, z. B. instance-01 instance-02 instance-03.

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

REST

Wenn Sie eine Instanz mit angehängten lokalen SSDs anhalten, können Sie angeben, ob die Daten auf den lokalen SSDs verworfen oder beibehalten werden sollen. Gehen Sie dazu so vor:

  • Wenn Sie lokale SSD-Daten verwerfen möchten, senden Sie eine POST-Anfrage an die Methode instances.suspend. 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/suspend?discardLocalSsd=true

  • Wenn Sie lokale SSD-Daten beibehalten möchten, senden Sie eine POST-Anfrage an die beta.instances.suspend-Methode. 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/suspend?discardLocalSsd=false

Ersetzen Sie Folgendes:

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

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

  • INSTANCE_NAME: der Name der Instanz.

Eine angehaltene Instanz fortsetzen

Beachten Sie Folgendes, bevor Sie eine ausgesetzte Compute-Instanz fortsetzen:

  • Sie können eine Instanz nur dann fortsetzen, wenn in der Zone, in der sich die Instanz befindet, genügend Kapazität vorhanden ist. Das ist in der Regel kein Problem. Wenn Sie Probleme haben, eine Instanz fortzusetzen, versuchen Sie es später noch einmal.

  • Wenn Sie lokale SSD-Laufwerke an die Instanz angehängt und beim Anhalten die Option zum Beibehalten lokaler SSD-Daten ausgewählt haben, müssen Sie die lokalen SSD-Laufwerke möglicherweise nach dem Fortsetzen neu bereitstellen. Weitere Informationen zum erneuten Bereitstellen von nicht bootfähigen Laufwerken in Linux-Instanzen oder Windows-Instanzen

Sie können mehrere oder einzelne Instanzen gleichzeitig fortsetzen. Verwenden Sie für mehrere Instanzen die Google Cloud Console oder für Instanzen in derselben Zone die gcloud CLI. Wählen Sie für einzelne Instanzen eine der folgenden Optionen aus:

Console

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

    Zu „VM-Instanzen“

  2. Wählen Sie eine oder mehrere angehaltene Instanzen aus, die fortgesetzt werden sollen.

  3. Klicken Sie auf Starten / Fortsetzen und dann auf Starten.

gcloud

Wenn Sie eine oder mehrere angehaltene Instanzen in einer einzelnen Zone fortsetzen möchten, verwenden Sie den Befehl gcloud compute instances resume:

gcloud compute instances resume INSTANCE_NAMES \
    --zone=ZONE

Ersetzen Sie Folgendes:

  • INSTANCE_NAMES: eine durch Leerzeichen getrennte Liste von Instanzennamen, z. B. instance-01 instance-02 instance-03.

  • ZONE: Die Zone, in der sich die gesperrten Instanzen befinden.

Go

import (
	"context"
	"fmt"
	"io"

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

// resumeInstance resumes a suspended Google Compute Engine instance
// (with unencrypted disks).
func resumeInstance(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()

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

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

	if instance.GetStatus() != "SUSPENDED" {
		return fmt.Errorf(
			"only suspended instances can be resumed, instance %s is in %s state",
			instanceName,
			instance.GetStatus(),
		)
	}

	resumeInstanceReq := &computepb.ResumeInstanceRequest{
		Project:  projectID,
		Zone:     zone,
		Instance: instanceName,
	}

	op, err := instancesClient.Resume(ctx, resumeInstanceReq)
	if err != nil {
		return fmt.Errorf("unable to resume 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 resumed\n")

	return nil
}

Java 


import com.google.cloud.compute.v1.Instance.Status;
import com.google.cloud.compute.v1.InstancesClient;
import com.google.cloud.compute.v1.Operation;
import java.io.IOException;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.TimeoutException;

public class ResumeInstance {

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

    String project = "your-project-id";
    String zone = "zone-name";
    String instanceName = "instance-name";

    resumeInstance(project, zone, instanceName);
  }

  // Resume a suspended Google Compute Engine instance (with unencrypted disks).
  // Instance state changes to RUNNING, if successfully resumed.
  public static void resumeInstance(String project, String zone, String instanceName)
      throws IOException, ExecutionException, InterruptedException, TimeoutException {
    // Instantiates a client.
    try (InstancesClient instancesClient = InstancesClient.create()) {

      String currentInstanceState = instancesClient.get(project, zone, instanceName).getStatus();

      // Check if the instance is currently suspended.
      if (!currentInstanceState.equalsIgnoreCase(Status.SUSPENDED.toString())) {
        throw new RuntimeException(
            String.format("Only suspended instances can be resumed. Instance %s is in %s state.",
                instanceName, currentInstanceState));
      }

      Operation operation = instancesClient.resumeAsync(project, zone, instanceName)
          .get(300, TimeUnit.SECONDS);

      if (operation.hasError() || !instancesClient.get(project, zone, instanceName).getStatus()
          .equalsIgnoreCase(
              Status.RUNNING.toString())) {
        System.out.println("Cannot resume instance. Try again!");
        return;
      }

      System.out.printf("Instance resumed successfully ! %s", instanceName);
    }
  }
}

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

// Resumes a suspended Google Compute Engine instance (with unencrypted disks).
async function resumeInstance() {
  const instancesClient = new compute.InstancesClient();

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

  if (instance.status !== 'SUSPENDED') {
    throw new Error(
      'Only suspended instances can be resumed.' +
        `Instance ${instanceName} is in ${instance.status} state.`
    );
  }

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

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

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

resumeInstance();

PHP

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

/**
 * Resume a suspended 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 resume.
  *
 * @throws \Google\ApiCore\ApiException if the remote call fails.
 * @throws \Google\ApiCore\ValidationException if local error occurs before remote call.
 */
function resume_instance(
    string $projectId,
    string $zone,
    string $instanceName
) {
    // Resume the suspended Compute Engine instance using InstancesClient.
    $instancesClient = new InstancesClient();
    $request = (new ResumeInstanceRequest())
        ->setInstance($instanceName)
        ->setProject($projectId)
        ->setZone($zone);
    $operation = $instancesClient->resume($request);

    // Wait for the operation to complete.
    $operation->pollUntilComplete();
    if ($operation->operationSucceeded()) {
        printf('Instance %s resumed successfully' . PHP_EOL, $instanceName);
    } else {
        $error = $operation->getError();
        printf('Failed to resume 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 resume_instance(project_id: str, zone: str, instance_name: str) -> None:
    """
    Resume a suspended 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 you want to resume.
    """
    instance_client = compute_v1.InstancesClient()

    instance = instance_client.get(
        project=project_id, zone=zone, instance=instance_name
    )
    if instance.status != compute_v1.Instance.Status.SUSPENDED.name:
        raise RuntimeError(
            f"Only suspended instances can be resumed. "
            f"Instance {instance_name} is in {instance.status} state."
        )

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

    wait_for_extended_operation(operation, "instance resumption")

REST

Wenn Sie eine angehaltene Instanz fortsetzen möchten, senden Sie eine POST-Anfrage an die Methode instances.resume:

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

Ersetzen Sie Folgendes:

  • INSTANCE_NAME: der Name der angehaltenen Instanz, die fortgesetzt werden soll.

  • PROJECT_ID: Die ID des Projekts, in dem sich die gesperrte Instanz befindet.

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

Nächste Schritte