Compute Engine-Instanz anhalten oder fortsetzen

In diesem Dokument wird beschrieben, wie Sie Compute Engine-Instanzen anhalten oder fortsetzen. Weitere Informationen zum Sperren, Beenden oder Zurücksetzen von Instanzen finden Sie unter Compute Engine-Instanzen sperren, 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 Compute Engine den Arbeitsspeicher der Instanz aus dem Speicher zurück zur Instanz und die Instanz wird wieder ausgeführt.

Das Sperren einer Compute Engine-Instanz ist in folgenden Fällen nützlich:

  • Entwicklungs- und Testumgebungen, die in Zeiten geringer Auslastung, z. B. abends oder am Wochenende, nicht vollständig genutzt werden und die Sie beibehalten möchten, um Kosten zu sparen oder die Initialisierung zu beschleunigen, anstatt neue Instanzen zu erstellen.

  • 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 sperren, 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 dann sperren, 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 sperren. Wenn Compute Engine die Instanz jedoch vorzeitig beendet, bevor der Sperrvorgang abgeschlossen ist, beendet Compute Engine den Sperrvorgang und beendet die Instanz vorzeitig.

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

  • Die folgenden Instanztypen können nicht gesperrt werden:

    • Bare-Metal-Instanzen

    • Confidential VMs.

    • Instanzen mit angehängten GPUs oder TPUs.

    • Instanzen mit mehr als 208 GB Arbeitsspeicher.

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

Hinweis

Erforderliche Rollen

Bitten Sie Ihren Administrator, Ihnen die IAM-Rolle Compute Instance Admin (v1) (roles/compute.instanceAdmin.v1) für die Instanz zu gewähren, um die Berechtigungen zu erhalten, die Sie zum Sperren 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 Sperren 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 zu sperren 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.

Sperrvorgänge auf einem Gastbetriebssystem aktivieren

Wenn Ihre Compute-Instanz Debian 8 oder 9 oder ein Windows-Betriebssystem als Gastbetriebssystem verwendet, müssen Sie das Betriebssystem konfigurieren, bevor Sie Instanzen sperren und fortsetzen können. Wenn Ihre Instanz ein anderes Gastbetriebssystem verwendet, überspringen Sie diesen Abschnitt.

Sperrvorgänge unter Debian 8 oder 9 aktivieren

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

ACPID konfigurieren

Wenn Sie den Vorgang zum Sperren und Fortsetzen 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 Ereignis der Ruhezustandstaste verarbeitet. Nachdem Sie das Ereignis für die Taste für den Tiefschlafmodus aktiviert haben, können Sie ein Shell-Skript zum Verarbeiten des Ereignisses hinzufügen, wie in diesem Abschnitt beschrieben.

So konfigurieren Sie den ACPID, um Vorgänge zum Anhalten und Fortsetzen zu unterstützen:

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

  2. Erstellen Sie den Ordner events im Ordner acpi:

    sudo mkdir -p /etc/acpi/events/
    
  3. Konfigurieren Sie den ACPID so, dass er das Ereignis der Ruhezustandstaste verarbeitet:

    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 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 Sie dies 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
    

Sperrvorgänge unter Windows aktivieren

Wenn Sie eine Instanz mit einem Windows-Gastbetriebssystem sperren 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 anzuhalten.

So deaktivieren Sie den Ruhezustand in Windows:

  1. Stellen Sie eine Verbindung zur 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
    

Instanz anhalten

Wenn das Gastbetriebssystem Ihrer Compute-Instanz Debian 8 oder 9 verwendet, müssen Sie vor dem Sperren der Instanz das Gastbetriebssystem so konfigurieren, dass es Sperr- und Fortsetzungsvorgänge unterstützt, wie in diesem Dokument beschrieben.

Wenn Sie eine Instanz sperren möchten, verwenden Sie eine der folgenden Methoden, je nachdem, ob an die Instanz lokale SSDs angehängt sind:

Instanz ohne lokale SSD-Laufwerke anhalten

Sie können mehrere Compute-Instanzen gleichzeitig oder einzelne Instanzen sperren. Verwenden Sie für mehrere Instanzen die Cloud de Confiance 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 Cloud de Confiance 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 noch einmal auf Sperren, um den Vorgang zu bestätigen.

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 Instanznamen, 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 eine POST-Anfrage an die Methode instances.suspend, um eine Instanz zu sperren:

POST https://compute.s3nsapis.fr/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

Je nachdem, wie viele Compute-Instanzen Sie gleichzeitig sperren möchten und ob Sie die Daten der angehängten lokalen SSDs beibehalten müssen, gehen Sie so vor:

  • Wenn Sie die Daten der an eine Instanz angehängten lokalen SSD-Laufwerke beibehalten möchten (mit Ausnahme von Instanzen mit Titanium-SSD-Laufwerken), müssen Sie die Instanz mit der gcloud CLI oder der REST API anhalten.

  • Wenn Sie mehrere Instanzen gleichzeitig sperren möchten, verwenden Sie die Cloud de Confiance Console oder, für Instanzen in derselben Zone, die gcloud CLI.

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

Console

  1. Rufen Sie in der Cloud de Confiance 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 noch einmal auf Sperren, um den Vorgang zu bestätigen.

gcloud

Wenn Sie eine oder mehrere Instanzen in einer einzelnen Zone mit angehängten lokalen SSDs anhalten, geben Sie so an, ob die Daten auf den lokalen SSDs verworfen oder beibehalten werden sollen:

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

    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 Instanznamen, 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 so an, ob die Daten auf den lokalen SSDs verworfen oder beibehalten werden sollen:

  • 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.s3nsapis.fr/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 Methode beta.instances.suspend. Fügen Sie in der Anfrage-URL den Abfrageparameter discardLocalSsd ein, wobei dieser auf false gesetzt ist:

    POST https://compute.s3nsapis.fr/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 gesperrte 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 oder wenn Sie Kapazität in dieser Zone reserviert haben.

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

Sie können mehrere Instanzen gleichzeitig oder einzelne Instanzen fortsetzen. Verwenden Sie für mehrere Instanzen die Cloud de Confiance 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 Cloud de Confiance Console die Seite VM-Instanzen auf.

    Zur Seite „VM-Instanzen“

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

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

gcloud

Verwenden Sie den Befehl gcloud compute instances resume, um eine oder mehrere gesperrte Instanzen in einer einzelnen Zone fortzusetzen:

gcloud compute instances resume INSTANCE_NAMES \
    --zone=ZONE

Ersetzen Sie Folgendes:

  • INSTANCE_NAMES: eine durch Leerzeichen getrennte Liste von Instanznamen, 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 gesperrte Instanz fortsetzen möchten, senden Sie eine POST-Anfrage an die Methode instances.resume:

POST https://compute.s3nsapis.fr/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