Compute Engine-Instanz anhalten oder fortsetzen

In diesem Dokument wird beschrieben, wie Sie Compute Engine-Instanzen anhalten oder fortsetzen. Weitere Informationen zum Anhalten, Beenden oder Zurücksetzen von Instanzen finden Sie unter Compute Engine-Instanzen anhalten, 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 Instanzspeichers wird in den Speicher migriert. Nach dem Fortsetzen der Instanz migriert 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 nützlich:

  • Entwicklungs- und Testumgebungen, die zu bestimmten Zeiten (z. B. abends oder am Wochenende) nicht vollständig genutzt werden und die Sie beibehalten möchten, um Kosten zu sparen oder schneller initialisiert zu 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.

Beschränkungen

Wenn Sie eine Compute-Instanz anhalten, 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 die folgenden Betriebssystem-Images verwendet, nur anhalten, wenn Sie das Betriebssystem konfigurieren, wie in diesem Dokument beschrieben:

    • Debian 8 oder 9

    • Beliebiges Windows-Betriebssystem

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

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

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

  • Die folgenden Instanztypen können Sie nicht anhalten:

    • Bare-Metal-Instanzen.

    • Confidential VMs

    • Instanzen mit angehängten GPUs.

    • Instanzen mit mehr als 208 GB Arbeitsspeicher.

    • Instanzen, an die CSEK-geschützte Laufwerke angehängt sind.

Suspend-Vorgänge für ein Gastbetriebssystem aktivieren

Wenn auf Ihrer Compute-Instanz Debian 8 oder 9 als Gastbetriebssystem oder ein beliebiges Windows-Betriebssystem ausgeführt wird, müssen Sie das Betriebssystem konfigurieren, bevor Sie Instanzen anhalten und fortsetzen können. Wenn auf Ihrer Instanz ein anderes Gastbetriebssystem verwendet wird, überspringen Sie diesen Abschnitt.

Ruhezustand unter Debian 8 oder 9 aktivieren

Bevor Sie Compute-Instanzen, die Debian 8 oder 9 als Gastbetriebssystem verwenden, anhalten oder fortsetzen können, müssen Sie das Gastbetriebssystem mit einer der folgenden Methoden konfigurieren:

ACPID konfigurieren

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

So konfigurieren Sie ACPID zur Unterstützung von Anhalten und Fortsetzen:

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

  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. Damit die Änderungen wirksam werden, starten Sie den ACPID neu:

    sudo systemctl restart acpid.service

D-Bus installieren

Wenn Sie den Vorgang zum 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 noch nicht geschehen.

  2. Installieren Sie D-Bus:

    sudo apt-get install dbus

  3. Damit die Änderungen wirksam werden, starten Sie logind neu:

    sudo systemctl restart systemd-logind.service

Vorgänge zum Anhalten unter Windows aktivieren

Wenn Sie eine Instanz mit einem Windows-Gastbetriebssystem anhalten möchten, müssen Sie den Ruhezustand im Betriebssystem deaktivieren. Wenn Sie ein Windows-Image importiert haben, ist der Ruhezustand möglicherweise standardmäßig aktiviert. Sie müssen ihn deaktivieren, um die Instanz in den Suspend-Modus zu versetzen.

So deaktivieren Sie den Ruhezustand in Windows:

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

  2. Öffnen Sie PowerShell als Administrator.

  3. Ruhezustand deaktivieren:

    powercfg -h off

  4. Prüfen Sie, ob der Ruhezustand deaktiviert ist:

    powercfg -a

Hinweis

Erforderliche Rollen

Um die Berechtigungen zu erhalten, die Sie zum Anhalten oder Fortsetzen einer Compute-Instanz benötigen, bitten Sie Ihren Administrator, Ihnen die IAM-Rolle Compute Instance Admin (v1) (roles/compute.instanceAdmin.v1) für die Instanz zu gewähren. 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 Anhalten oder Fortsetzen 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 anzuhalten 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.

Instanz anhalten

Wenn auf dem Gastbetriebssystem Ihrer Compute-Instanz Debian 8 oder 9 ausgeführt wird, müssen Sie das Gastbetriebssystem konfigurieren, um Vorgänge zum Anhalten und Fortsetzen zu unterstützen, wie in diesem Dokument beschrieben, bevor Sie die Instanz anhalten.

Verwenden Sie eine der folgenden Methoden, um eine Instanz anzuhalten, je nachdem, ob an die Instanz lokale SSD-Laufwerke angehängt sind:

Instanz ohne lokale SSD-Laufwerke anhalten

Sie können mehrere Compute-Instanzen gleichzeitig oder einzelne Instanzen anhalten. 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.

    Zur Seite „VM-Instanzen“

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

  3. Klicken Sie auf  Sperren und dann zur Bestätigung auf Sperren.

gcloud

Wenn Sie eine oder mehrere Instanzen in einer einzelnen Zone anhalten 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 mit Namen von Instanzen, 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

Senden Sie zum Anhalten einer Instanz 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

Führen Sie je nachdem, wie viele Compute-Instanzen Sie gleichzeitig anhalten möchten und ob Sie die Daten der angehängten lokalen SSDs beibehalten müssen, die folgenden Schritte aus:

  • Wenn Sie die Daten der an eine Instanz angehängten lokalen SSD-Laufwerke beibehalten möchten (mit Ausnahme von Instanzen mit Titanium-SSDs), 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, für Instanzen in derselben Zone, die gcloud CLI.

Wenn Sie eine oder mehrere Instanzen mit angehängten lokalen SSD-Laufwerken 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.

    Zur Seite „VM-Instanzen“

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

  3. Klicken Sie auf  Sperren und dann zur Bestätigung auf Sperren.

gcloud

Wenn Sie eine oder mehrere Instanzen in einer einzelnen Zone anhalten, an die lokale SSD-Laufwerke angehängt sind, geben Sie an, ob die lokalen SSD-Daten 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 mit Namen von Instanzen, 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 SSD-Laufwerken anhalten, geben Sie an, ob die lokalen SSD-Daten verworfen oder beibehalten werden sollen:

  • Senden Sie eine POST-Anfrage an die Methode instances.suspend, um lokale SSD-Daten zu verwerfen. 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 Daten auf der lokalen SSD beibehalten möchten, stellen Sie eine POST-Anfrage an die Methode beta.instances.suspend. 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

Bevor Sie eine angehaltene Compute-Instanz fortsetzen, sollten Sie Folgendes berücksichtigen:

  • 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 beim Fortsetzen einer Instanz haben, versuchen Sie es später noch einmal.

  • Wenn Sie lokale SSD-Laufwerke an die Instanz angehängt und die Option zum Beibehalten lokaler SSD-Daten beim Anhalten ausgewählt haben, müssen Sie die lokalen SSD-Laufwerke nach dem Fortsetzen möglicherweise neu einbinden. Weitere Informationen finden Sie unter Nicht-Bootlaufwerke auf Linux-Instanzen neu bereitstellen oder Nicht-Bootlaufwerke auf Windows-Instanzen neu bereitstellen.

Sie können mehrere Instanzen gleichzeitig oder einzelne Instanzen fortsetzen. Bei mehreren Instanzen verwenden Sie 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.

    Zur Seite „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 mit Namen von Instanzen, 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