VM beenden und starten


Auf dieser Seite wird beschrieben, wie Sie VM-Instanzen anhalten und starten. Beachten Sie, dass Compute Engine STOP und TERMINATE austauschbar verwendet. Informationen zum Anhalten und Fortsetzen einer VM finden Sie unter VM anhalten und fortsetzen. Weitere Informationen zum Anhalten und Sperren von VMs finden Sie unter Lebenszyklus von VM-Instanzen.

Sie können eine VM vorübergehend beenden, wenn Sie sie nicht mehr benötigen, und sie später neu starten. Eine angehaltene VM behält ihren nichtflüchtigen Speicher, ihre internen IP-Adressen und ihre MAC-Adressen bei. Die VM fährt jedoch das Gastbetriebssystem herunter und verliert ihren Anwendungsstatus. Wenn Sie das Gastbetriebssystem und den Anwendungsstatus beibehalten möchten, halten Sie stattdessen die VM an. Im Wesentlichen kehrt eine angehaltene VM zum Power-on-Zustand ohne gespeicherte Daten zurück. Halten Sie eine VM an, wenn Sie den Maschinentyp ändern, angehängte Laufwerke hinzufügen oder entfernen, die minimale CPU-Plattform ändern, GPUs hinzufügen oder entfernen oder Empfehlungen für Maschinentypen anwenden möchten.

Das Anhalten von VMs veranlasst Compute Engine, das ACPI-Shutdown-Signal an die VM zu senden. Moderne Gastbetriebssysteme sind so konfiguriert, dass sie korrekt herunterfahren, bevor sie als Reaktion auf das Abschaltsignal ausgeschaltet werden. Compute Engine wartet eine kurze Zeit, damit das Gastsystem vollständig heruntergefahren werden kann, und versetzt die VM dann in den Status TERMINATED.

Hinweis

Beschränkungen

Sie können eine VM mit einer angehängten lokalen SSD nicht beenden und neu starten. Wenn die VM jedoch lokale SSDs verwendet, hindert Compute Engine Sie nicht daran, die VM von innerhalb des Gastbetriebssystems herunterzufahren. Wenn Sie eine VM mithilfe lokaler SSDs über das Gastbetriebssystem herunterfahren, können Sie die VM nicht neu starten und die Daten auf der lokalen SSD gehen verloren. Achten Sie darauf, dass Sie Ihre kritischen Daten von der lokalen SSD zu einem nichtflüchtigen Speicher oder zu einer anderen VM migrieren, bevor Sie die VM löschen.

Abrechnung

VMs mit dem Status TERMINATED werden nicht pro Sekunde abgerechnet und nicht auf Ihr regionales CPU-Kontingent angerechnet. Alle an die VM angehängten Ressourcen, wie z. B. nichtflüchtige Speicher und externe IP-Adressen, werden jedoch berechnet, bis sie gelöscht werden. Um weitere Kosten für die angehängten Ressourcen zu vermeiden, können Sie eine gestoppte VM so rekonfigurieren, dass diese Ressourcen abgetrennt werden, und dann die Ressourcen löschen.

Sie können VMs, die Sie nicht mehr verwenden, beenden. Damit sparen Sie Kosten für inaktive VMs. Anschließend können Sie die VMs mit denselben VM-Attributen, -Metadaten und -Ressourcen neu starten.

VM beenden

Sie können VMs über die Google Cloud Console, das gcloud-Tool oder die Compute Engine API beenden.

Console

  1. Gehen Sie in der Cloud Console zur Seite VM-Instanzen.

    Zu „VM-Instanzen“

  2. Wählen Sie eine oder mehrere VMs aus, die Sie beenden möchten.

  3. Klicken Sie auf Beenden.

gcloud

Verwenden Sie zum Beenden einer VM den Befehl gcloud compute instances stop und geben Sie eine oder mehrere VMs an, die Sie beenden möchten:

gcloud compute instances stop VM_NAME

Ersetzen Sie dabei VM_NAME durch den Namen der VM, die Sie beenden möchten.

API

Erstellen Sie eine POST-Anfrage mit der Methode instances.stop, um eine VM zu beenden:

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

Dabei gilt:

  • PROJECT_ID: Projekt, in dem sich Ihre VM befindet
  • ZONE: Zone, in der sich Ihre VM befindet
  • VM_NAME: Name der VM, die Sie beenden möchten

Go

import (
	"context"
	"fmt"
	"io"

	compute "cloud.google.com/go/compute/apiv1"
	computepb "google.golang.org/genproto/googleapis/cloud/compute/v1"
)

// stopInstance stops a started Google Compute Engine instance
func stopInstance(w io.Writer, projectID, zone, instanceName string) error {
	// projectID := "your_project_id"
	// zone := "europe-central2-b"
	// instanceName := "your_instance_name"

	ctx := context.Background()
	instancesClient, err := compute.NewInstancesRESTClient(ctx)
	if err != nil {
		return fmt.Errorf("NewInstancesRESTClient: %v", err)
	}
	defer instancesClient.Close()

	req := &computepb.StopInstanceRequest{
		Project:  projectID,
		Zone:     zone,
		Instance: instanceName,
	}

	op, err := instancesClient.Stop(ctx, req)
	if err != nil {
		return fmt.Errorf("unable to stop instance: %v", err)
	}

	zoneOperationsClient, err := compute.NewZoneOperationsRESTClient(ctx)
	if err != nil {
		return fmt.Errorf("NewZoneOperationsRESTClient: %v", err)
	}
	defer zoneOperationsClient.Close()

	for {
		waitReq := &computepb.WaitZoneOperationRequest{
			Operation: op.Proto().GetName(),
			Project:   projectID,
			Zone:      zone,
		}
		zoneOp, err := zoneOperationsClient.Wait(ctx, waitReq)
		if err != nil {
			return fmt.Errorf("unable to wait for the operation: %v", err)
		}

		if *zoneOp.Status.Enum() == computepb.Operation_DONE {
			fmt.Fprintf(w, "Instance stopped\n")
			break
		}
	}

	return nil
}

Java


import com.google.api.gax.longrunning.OperationFuture;
import com.google.cloud.compute.v1.InstancesClient;
import com.google.cloud.compute.v1.Operation;
import com.google.cloud.compute.v1.Operation.Status;
import com.google.cloud.compute.v1.StopInstanceRequest;
import java.io.IOException;
import java.util.concurrent.ExecutionException;

public class StopInstance {

  public static void main(String[] args)
      throws IOException, ExecutionException, InterruptedException {
    // TODO(developer): Replace these variables before running the sample.
    /* project: project ID or project number of the Cloud project your instance belongs to.
       zone: name of the zone your instance belongs to.
       instanceName: name of the instance your want to stop.
     */
    String project = "your-project-id";
    String zone = "zone-name";
    String instanceName = "instance-name";

    stopInstance(project, zone, instanceName);
  }

  // Stops a started Google Compute Engine instance.
  public static void stopInstance(String project, String zone, String instanceName)
      throws IOException, ExecutionException, InterruptedException {
    /* Initialize client that will be used to send requests. This client only needs to be created
       once, and can be reused for multiple requests. After completing all of your requests, call
       the `instancesClient.close()` method on the client to safely
       clean up any remaining background resources. */
    try (InstancesClient instancesClient = InstancesClient.create()) {

      StopInstanceRequest stopInstanceRequest = StopInstanceRequest.newBuilder()
          .setProject(project)
          .setZone(zone)
          .setInstance(instanceName)
          .build();

      OperationFuture<Operation, Operation> operation = instancesClient.stopAsync(
          stopInstanceRequest);
      Operation response = operation.get();

      if (response.getStatus() == Status.DONE) {
        System.out.println("Instance stopped successfully ! ");
      }
    }
  }
}

Node.js

/**
 * TODO(developer): Uncomment and replace these variables before running the sample.
 */
// const projectId = 'YOUR_PROJECT_ID';
// const zone = 'europe-central2-b'
// const instanceName = 'YOUR_INSTANCE_NAME'

const compute = require('@google-cloud/compute');

async function stopInstance() {
  const instancesClient = new compute.InstancesClient();

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

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

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

stopInstance();

Python

from google.cloud import compute_v1

def stop_instance(project_id: str, zone: str, instance_name: str):
    """
    Stops a running Google Compute Engine instance.

    Args:
        project_id: project ID or project number of the Cloud project your instance belongs to.
        zone: name of the zone your instance belongs to.
        instance_name: name of the instance your want to stop.
    """
    instance_client = compute_v1.InstancesClient()
    op_client = compute_v1.ZoneOperationsClient()

    op = instance_client.stop_unary(
        project=project_id, zone=zone, instance=instance_name
    )

    while op.status != compute_v1.Operation.Status.DONE:
        op = op_client.wait(operation=op.name, zone=zone, project=project_id)
    return

Eine TERMINATED-VM ist weiter mit ihren Konfigurationseinstellungen und Instanzmetadaten vorhanden, verliert jedoch ihre Daten im Arbeitsspeicher und den Status einer virtuellen Maschine. Alle Ressourcen, die an die beendete VM angehängt sind, bleiben angehängt, bis Sie diese Ressourcen manuell trennen oder die VM löschen.

Wenn eine VM den Status TERMINATED hat, können Sie die VM neu starten oder die VM löschen. Wenn Sie die VM nicht neu starten möchten, löschen Sie sie.

VM über das Betriebssystem beenden

Optional können Sie eine VM über das Gastbetriebssystem mit dem Befehl sudo shutdown -h now oder sudo poweroff beenden. Beenden Sie mit diesen Befehlen eine VM, die lokale SSDs verwendet. Führen Sie einen der folgenden Befehle aus, während Sie bei der VM angemeldet sind:

sudo shutdown -h now
sudo poweroff

Beendete VM ohne verschlüsseltes Laufwerk neu starten

Verwenden Sie die Methode instances().start, um eine angehaltene VM neu zu starten. Diese Methode startet eine angehaltene VM, die sich im Zustand TERMINATED befindet.

Über die Methode start wird eine VM mit dem Status TERMINATED neu gestartet, wohingegen Methoden wie reset() und sudo reboot nur mit laufenden VMs funktionieren. Fast alle VMs, einschließlich VMs auf Abruf, können neu gestartet werden, wenn sich die VM im Zustand TERMINATED befindet.

Console

  1. Öffnen Sie in der Google Cloud Console die Seite VM-Instanzen.

    Zu „VM-Instanzen“

  2. Wählen Sie eine oder mehrere VMs aus, die Sie starten möchten.

  3. Klicken Sie auf Starten/Fortsetzen.

gcloud

Verwenden Sie zum Starten einer VM den Befehl gcloud compute instances start und geben Sie eine oder mehrere VMs an, die Sie starten möchten:

gcloud compute instances start VM_NAME

Ersetzen Sie dabei VM_NAME durch den Namen der VM, die Sie starten möchten.

API

Erstellen Sie eine POST-Anfrage mit der Methode instances.start, um eine VM zu starten:

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

Dabei gilt:

  • PROJECT_ID: Projekt, in dem sich Ihre VM befindet
  • ZONE: Zone, in der sich Ihre VM befindet
  • VM_NAME: Name der VM, die Sie starten möchten

Go

import (
	"context"
	"fmt"
	"io"

	compute "cloud.google.com/go/compute/apiv1"
	computepb "google.golang.org/genproto/googleapis/cloud/compute/v1"
)

// startInstance starts a stopped Google Compute Engine instance (with unencrypted disks).
func startInstance(w io.Writer, projectID, zone, instanceName string) error {
	// projectID := "your_project_id"
	// zone := "europe-central2-b"
	// instanceName := "your_instance_name"

	ctx := context.Background()
	instancesClient, err := compute.NewInstancesRESTClient(ctx)
	if err != nil {
		return fmt.Errorf("NewInstancesRESTClient: %v", err)
	}
	defer instancesClient.Close()

	req := &computepb.StartInstanceRequest{
		Project:  projectID,
		Zone:     zone,
		Instance: instanceName,
	}

	op, err := instancesClient.Start(ctx, req)
	if err != nil {
		return fmt.Errorf("unable to start instance: %v", err)
	}

	zoneOperationsClient, err := compute.NewZoneOperationsRESTClient(ctx)
	if err != nil {
		return fmt.Errorf("NewZoneOperationsRESTClient: %v", err)
	}
	defer zoneOperationsClient.Close()

	for {
		waitReq := &computepb.WaitZoneOperationRequest{
			Operation: op.Proto().GetName(),
			Project:   projectID,
			Zone:      zone,
		}
		zoneOp, err := zoneOperationsClient.Wait(ctx, waitReq)
		if err != nil {
			return fmt.Errorf("unable to wait for the operation: %v", err)
		}

		if *zoneOp.Status.Enum() == computepb.Operation_DONE {
			fmt.Fprintf(w, "Instance started\n")
			break
		}
	}

	return nil
}

Java


import com.google.api.gax.longrunning.OperationFuture;
import com.google.cloud.compute.v1.InstancesClient;
import com.google.cloud.compute.v1.Operation;
import com.google.cloud.compute.v1.Operation.Status;
import com.google.cloud.compute.v1.StartInstanceRequest;
import java.io.IOException;
import java.util.concurrent.ExecutionException;

public class StartInstance {

  public static void main(String[] args)
      throws IOException, ExecutionException, InterruptedException {
    // TODO(developer): Replace these variables before running the sample.
    /* project: project ID or project number of the Cloud project your instance belongs to.
       zone: name of the zone your instance belongs to.
       instanceName: name of the instance your want to start. */
    String project = "your-project-id";
    String zone = "zone-name";
    String instanceName = "instance-name";

    startInstance(project, zone, instanceName);
  }

  // Starts a stopped Google Compute Engine instance (with unencrypted disks).
  public static void startInstance(String project, String zone, String instanceName)
      throws IOException, ExecutionException, InterruptedException {
    /* Initialize client that will be used to send requests. This client only needs to be created
       once, and can be reused for multiple requests. After completing all of your requests, call
       the `instancesClient.close()` method on the client to safely
       clean up any remaining background resources. */
    try (InstancesClient instancesClient = InstancesClient.create()) {

      // Create the request.
      StartInstanceRequest startInstanceRequest = StartInstanceRequest.newBuilder()
          .setProject(project)
          .setZone(zone)
          .setInstance(instanceName)
          .build();

      OperationFuture<Operation, Operation> operation = instancesClient.startAsync(
          startInstanceRequest);

      // Wait for the operation to complete.
      Operation response = operation.get();

      if (response.getStatus() == Status.DONE) {
        System.out.println("Instance started successfully ! ");
      }
    }
  }
}

Node.js

/**
 * TODO(developer): Uncomment and replace these variables before running the sample.
 */
// const projectId = 'YOUR_PROJECT_ID';
// const zone = 'europe-central2-b'
// const instanceName = 'YOUR_INSTANCE_NAME'

const compute = require('@google-cloud/compute');

async function startInstance() {
  const instancesClient = new compute.InstancesClient();

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

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

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

startInstance();

Python

from google.cloud import compute_v1

def start_instance(project_id: str, zone: str, instance_name: str):
    """
    Starts a stopped Google Compute Engine instance (with unencrypted disks).

    Args:
        project_id: project ID or project number of the Cloud project your instance belongs to.
        zone: name of the zone your instance belongs to.
        instance_name: name of the instance your want to start.
    """
    instance_client = compute_v1.InstancesClient()
    op_client = compute_v1.ZoneOperationsClient()

    op = instance_client.start_unary(
        project=project_id, zone=zone, instance=instance_name
    )

    while op.status != compute_v1.Operation.Status.DONE:
        op = op_client.wait(operation=op.name, zone=zone, project=project_id)
    return

VM mit verschlüsselten Laufwerken neu starten

Wenn die neu zu startende VM vom Kunden bereitgestellte Verschlüsselungsschlüssel verwendet, müssen Sie diese Schlüssel angeben, wenn Sie versuchen, die VM neu zu starten.

Console

  1. Öffnen Sie in der Google Cloud Console die Seite VM-Instanzen.

    Zu „VM-Instanzen“

  2. Wählen Sie die VM aus, die Sie starten möchten.

  3. Klicken Sie auf Starten/Fortsetzen. Geben Sie im folgenden Fenster Verschlüsselungsschlüssel für die Geräte an, die an diese VM angehängt sind.

  4. Geben Sie Verschlüsselungsschlüssel für alle verschlüsselten Laufwerke an, die an diese VM angehängt sind.

  5. Klicken Sie auf Starten, um die VM zu starten.

gcloud

Verwenden Sie den Befehl gcloud compute instances start mit dem Flag --csek-key-file, um eine VM zu starten, die Verschlüsselungsschlüssel verwendet. Wenn Sie einen mit RSA verpackten Schlüssel verwenden, nutzen Sie den Befehl gcloud beta.

gcloud compute instances start VM_NAME \
    --csek-key-file ENCRYPTION_KEY_FILE

Dabei gilt:

  • VM_NAME: Name der VM, die Sie starten möchten
  • ENCRYPTION_KEY_FILE: der relative Pfad zur JSON-Datei, die den Verschlüsselungsschlüssel enthält. Mit diesem Schlüssel werden nichtflüchtige Speicher verschlüsselt, die an die VM angehängt sind. Weitere Informationen finden Sie unter Dateiformat für Verschlüsselungsschlüssel.

API

Um eine VM mit Verschlüsselungsschlüsseln zu starten, stellen Sie mit der Methode instances.startWithEncryptionKey eine POST-Anfrage:

    POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/zones/ZONE/instances/VM_NAME/startWithEncryptionKey
    {
      "disks": [
        {
           "source": "DISK_URL",
           "diskEncryptionKey": {
             "ENCRYPTION_TYPE": "ENCRYPTION_KEY"
           }
        }
      ]
    }
 

Dabei gilt:

  • PROJECT_ID: Projekt, in dem sich Ihre VM befindet
  • ZONE: Zone, in der sich Ihre VM befindet
  • VM_NAME: Name der VM, die Sie starten möchten
  • DISK_URL: Ressourcen-URL, die dem vollständigen Ressourcennamen des angehängten Laufwerks entspricht und mit einem vom Kunden bereitgestellten Verschlüsselungsschlüssel verschlüsselt ist
  • ENCRYPTION_TYPE: Der Typ der verwendeten Laufwerksverschlüsselung: rawKey, kmsKeyName oder rsaEncryptedKey. Wenn Sie rsaEncryptedKey verwenden, müssen Sie die Beta API anstelle der v1 API verwenden.
  • ENCRYPTION_KEY: Verschlüsselungsschlüssel, mit dem Sie nichtflüchtige Speicher verschlüsseln, die an die VM angehängt sind. Schlüssel vom Typ rawKey oder rsaEncryptedKey müssen base64-codiert sein. Bereiten Sie einen Schlüssel vom Typ rsaEncryptedKey vor. Folgen Sie dazu der Anleitung unter RSA-Schlüsselverpackung.

Go

import (
	"context"
	"fmt"
	"io"

	compute "cloud.google.com/go/compute/apiv1"
	computepb "google.golang.org/genproto/googleapis/cloud/compute/v1"
	"google.golang.org/protobuf/proto"
)

// startInstanceWithEncKey starts a stopped Google Compute Engine instance (with encrypted disks).
func startInstanceWithEncKey(w io.Writer, projectID, zone, instanceName, key string) error {
	// projectID := "your_project_id"
	// zone := "europe-central2-b"
	// instanceName := "your_instance_name"
	// key := "your_encryption_key"

	ctx := context.Background()
	instancesClient, err := compute.NewInstancesRESTClient(ctx)
	if err != nil {
		return fmt.Errorf("NewInstancesRESTClient: %v", err)
	}
	defer instancesClient.Close()

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

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

	req := &computepb.StartWithEncryptionKeyInstanceRequest{
		Project:  projectID,
		Zone:     zone,
		Instance: instanceName,
		InstancesStartWithEncryptionKeyRequestResource: &computepb.InstancesStartWithEncryptionKeyRequest{
			Disks: []*computepb.CustomerEncryptionKeyProtectedDisk{
				{
					Source: proto.String(instance.GetDisks()[0].GetSource()),
					DiskEncryptionKey: &computepb.CustomerEncryptionKey{
						RawKey: proto.String(key),
					},
				},
			},
		},
	}

	op, err := instancesClient.StartWithEncryptionKey(ctx, req)
	if err != nil {
		return fmt.Errorf("unable to start instance with encryption key: %v", err)
	}

	zoneOperationsClient, err := compute.NewZoneOperationsRESTClient(ctx)
	if err != nil {
		return fmt.Errorf("NewZoneOperationsRESTClient: %v", err)
	}
	defer zoneOperationsClient.Close()

	for {
		waitReq := &computepb.WaitZoneOperationRequest{
			Operation: op.Proto().GetName(),
			Project:   projectID,
			Zone:      zone,
		}
		zoneOp, err := zoneOperationsClient.Wait(ctx, waitReq)
		if err != nil {
			return fmt.Errorf("unable to wait for the operation: %v", err)
		}

		if *zoneOp.Status.Enum() == computepb.Operation_DONE {
			fmt.Fprintf(w, "Instance with encryption key started\n")
			break
		}
	}

	return nil
}

Java


import com.google.api.gax.longrunning.OperationFuture;
import com.google.cloud.compute.v1.CustomerEncryptionKey;
import com.google.cloud.compute.v1.CustomerEncryptionKeyProtectedDisk;
import com.google.cloud.compute.v1.GetInstanceRequest;
import com.google.cloud.compute.v1.Instance;
import com.google.cloud.compute.v1.InstancesClient;
import com.google.cloud.compute.v1.InstancesStartWithEncryptionKeyRequest;
import com.google.cloud.compute.v1.Operation;
import com.google.cloud.compute.v1.Operation.Status;
import com.google.cloud.compute.v1.StartWithEncryptionKeyInstanceRequest;
import java.io.IOException;
import java.util.concurrent.ExecutionException;

public class StartEncryptedInstance {

  public static void main(String[] args)
      throws IOException, ExecutionException, InterruptedException {
    // TODO(developer): Replace these variables before running the sample.
    /* project: project ID or project number of the Cloud project your instance belongs to.
       zone: name of the zone your instance belongs to.
       instanceName: name of the instance your want to start.
       key: bytes object representing a raw base64 encoded key to your machines boot disk.
            For more information about disk encryption see:
            https://cloud.google.com/compute/docs/disks/customer-supplied-encryption#specifications
     */
    String project = "your-project-id";
    String zone = "zone-name";
    String instanceName = "instance-name";
    String key = "raw-key";

    startEncryptedInstance(project, zone, instanceName, key);
  }

  // Starts a stopped Google Compute Engine instance (with encrypted disks).
  public static void startEncryptedInstance(String project, String zone, String instanceName,
      String key)
      throws IOException, ExecutionException, InterruptedException {
    /* Initialize client that will be used to send requests. This client only needs to be created
       once, and can be reused for multiple requests. After completing all of your requests, call
       the `instancesClient.close()` method on the client to safely
       clean up any remaining background resources. */
    try (InstancesClient instancesClient = InstancesClient.create()) {

      GetInstanceRequest getInstanceRequest = GetInstanceRequest.newBuilder()
          .setProject(project)
          .setZone(zone)
          .setInstance(instanceName).build();

      Instance instance = instancesClient.get(getInstanceRequest);

      // Prepare the information about disk encryption.
      CustomerEncryptionKeyProtectedDisk protectedDisk = CustomerEncryptionKeyProtectedDisk
          .newBuilder()
          /* Use raw_key to send over the key to unlock the disk
             To use a key stored in KMS, you need to provide:
             `kms_key_name` and `kms_key_service_account`
           */
          .setDiskEncryptionKey(CustomerEncryptionKey.newBuilder()
              .setRawKey(key).build())
          .setSource(instance.getDisks(0).getSource())
          .build();

      InstancesStartWithEncryptionKeyRequest startWithEncryptionKeyRequest =
          InstancesStartWithEncryptionKeyRequest.newBuilder()
              .addDisks(protectedDisk).build();

      StartWithEncryptionKeyInstanceRequest encryptionKeyInstanceRequest =
          StartWithEncryptionKeyInstanceRequest.newBuilder()
              .setProject(project)
              .setZone(zone)
              .setInstance(instanceName)
              .setInstancesStartWithEncryptionKeyRequestResource(startWithEncryptionKeyRequest)
              .build();

      OperationFuture<Operation, Operation> operation = instancesClient.startWithEncryptionKeyAsync(
          encryptionKeyInstanceRequest);
      Operation response = operation.get();

      if (response.getStatus() == Status.DONE) {
        System.out.println("Encrypted instance started successfully ! ");
      }
    }
  }

}

Node.js

/**
 * TODO(developer): Uncomment and replace these variables before running the sample.
 */
// const projectId = 'YOUR_PROJECT_ID';
// const zone = 'europe-central2-b'
// const instanceName = 'YOUR_INSTANCE_NAME'
// const key = 'YOUR_KEY_STRING'

const compute = require('@google-cloud/compute');

async function startInstanceWithEncryptionKey() {
  const instancesClient = new compute.InstancesClient();

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

  const [response] = await instancesClient.startWithEncryptionKey({
    project: projectId,
    zone,
    instance: instanceName,
    instancesStartWithEncryptionKeyRequestResource: {
      disks: [
        {
          source: instance.disks[0].source,
          diskEncryptionKey: {
            rawKey: key,
          },
        },
      ],
    },
  });
  let operation = response.latestResponse;
  const operationsClient = new compute.ZoneOperationsClient();

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

  console.log('Instance with encryption key started.');
}

startInstanceWithEncryptionKey();

Python

from google.cloud import compute_v1

def start_instance_with_encryption_key(
    project_id: str, zone: str, instance_name: str, key: bytes
):
    """
    Starts a stopped Google Compute Engine instance (with encrypted disks).

    Args:
        project_id: project ID or project number of the Cloud project your instance belongs to.
        zone: name of the zone your instance belongs to.
        instance_name: name of the instance your want to start.
        key: bytes object representing a raw base64 encoded key to your machines boot disk.
            For more information about disk encryption see:
            https://cloud.google.com/compute/docs/disks/customer-supplied-encryption#specifications
    """
    instance_client = compute_v1.InstancesClient()
    op_client = compute_v1.ZoneOperationsClient()

    instance_data = instance_client.get(
        project=project_id, zone=zone, instance=instance_name
    )

    # Prepare the information about disk encryption
    disk_data = compute_v1.CustomerEncryptionKeyProtectedDisk()
    disk_data.source = instance_data.disks[0].source
    disk_data.disk_encryption_key = compute_v1.CustomerEncryptionKey()
    # Use raw_key to send over the key to unlock the disk
    # To use a key stored in KMS, you need to provide `kms_key_name` and `kms_key_service_account`
    disk_data.disk_encryption_key.raw_key = key
    enc_data = compute_v1.InstancesStartWithEncryptionKeyRequest()
    enc_data.disks = [disk_data]

    op = instance_client.start_with_encryption_key_unary(
        project=project_id,
        zone=zone,
        instance=instance_name,
        instances_start_with_encryption_key_request_resource=enc_data,
    )

    while op.status != compute_v1.Operation.Status.DONE:
        op = op_client.wait(operation=op.name, zone=zone, project=project_id)
    return

VM zurücksetzen

Das Zurücksetzen einer VM ist vergleichbar mit dem Zurücksetzen eines Computers durch Drücken der Reset-Taste oder Drücken und längeres Halten der Ein/Aus-Taste. Durch das Zurücksetzen einer VM wird der Speicherinhalt der Maschine gelöscht und die VM auf ihren Ausgangstatus zurückgesetzt. Die VM fährt das Gastbetriebssystem nicht ordnungsgemäß herunter. Während dieses Vorgangs bleibt die VM im Status RUNNING.

Zum Zurücksetzen einer ausgeführten VM verwenden Sie die Google Cloud Console, das gcloud-Tool oder die Compute Engine API.

Console

  1. Öffnen Sie in der Google Cloud Console die Seite VM-Instanzen.

    Zu „VM-Instanzen“

  2. Wählen Sie eine oder mehrere VMs aus, die Sie zurücksetzen möchten.

  3. Klicken Sie auf Zurücksetzen.

gcloud

Verwenden Sie zum Zurücksetzen einer ausgeführten VM den Befehl gcloud compute instances reset und geben Sie eine oder mehrere VMs an, die Sie zurücksetzen möchten:

gcloud compute instances reset VM_NAME

Ersetzen Sie dabei VM_NAME durch den Namen der VM, die Sie zurücksetzen möchten.

API

Zum Zurücksetzen einer VM erstellen Sie eine POST-Anfrage mit der Methode instances.reset:

 POST https://www.googleapis.com/compute/v1/projects/PROJECT_ID/zones/ZONE/instances/VM_NAME/reset

Dabei gilt:

  • PROJECT_ID: Projekt, in dem sich Ihre VM befindet
  • ZONE: Zone, in der sich Ihre VM befindet
  • VM_NAME: Name der VM, die Sie zurücksetzen möchten.

Go

import (
	"context"
	"fmt"
	"io"

	compute "cloud.google.com/go/compute/apiv1"
	computepb "google.golang.org/genproto/googleapis/cloud/compute/v1"
)

// resetInstance resets a stopped Google Compute Engine instance (with unencrypted disks).
func resetInstance(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: %v", err)
	}
	defer instancesClient.Close()

	req := &computepb.ResetInstanceRequest{
		Project:  projectID,
		Zone:     zone,
		Instance: instanceName,
	}

	op, err := instancesClient.Reset(ctx, req)
	if err != nil {
		return fmt.Errorf("unable to reset instance: %v", err)
	}

	zoneOperationsClient, err := compute.NewZoneOperationsRESTClient(ctx)
	if err != nil {
		return fmt.Errorf("NewZoneOperationsRESTClient: %v", err)
	}
	defer zoneOperationsClient.Close()

	for {
		waitReq := &computepb.WaitZoneOperationRequest{
			Operation: op.Proto().GetName(),
			Project:   projectID,
			Zone:      zone,
		}
		zoneOp, err := zoneOperationsClient.Wait(ctx, waitReq)
		if err != nil {
			return fmt.Errorf("unable to wait for the operation: %v", err)
		}

		if *zoneOp.Status.Enum() == computepb.Operation_DONE {
			fmt.Fprintf(w, "Instance reset\n")
			break
		}
	}

	return nil
}

Java


import com.google.api.gax.longrunning.OperationFuture;
import com.google.cloud.compute.v1.InstancesClient;
import com.google.cloud.compute.v1.Operation;
import com.google.cloud.compute.v1.Operation.Status;
import com.google.cloud.compute.v1.ResetInstanceRequest;
import java.io.IOException;
import java.util.concurrent.ExecutionException;

public class ResetInstance {

  public static void main(String[] args)
      throws IOException, ExecutionException, InterruptedException {
    // 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 reset.
     */
    String project = "your-project-id";
    String zone = "zone-name";
    String instanceName = "instance-name";

    resetInstance(project, zone, instanceName);
  }

  // Resets a stopped Google Compute Engine instance (with unencrypted disks).
  public static void resetInstance(String project, String zone, String instanceName)
      throws IOException, ExecutionException, InterruptedException {
    /* Initialize client that will be used to send requests. This client only needs to be created
       once, and can be reused for multiple requests. After completing all of your requests, call
       the `instancesClient.close()` method on the client to safely
       clean up any remaining background resources. */
    try (InstancesClient instancesClient = InstancesClient.create()) {

      ResetInstanceRequest resetInstanceRequest = ResetInstanceRequest.newBuilder()
          .setProject(project)
          .setZone(zone)
          .setInstance(instanceName)
          .build();

      OperationFuture<Operation, Operation> operation = instancesClient.resetAsync(
          resetInstanceRequest);
      Operation response = operation.get();

      if (response.getStatus() == Status.DONE) {
        System.out.println("Instance reset successfully ! ");
      }
    }
  }

}

Node.js

/**
 * TODO(developer): Uncomment and replace these variables before running the sample.
 */
// const projectId = 'YOUR_PROJECT_ID';
// const zone = 'europe-central2-b'
// const instanceName = 'YOUR_INSTANCE_NAME'

const compute = require('@google-cloud/compute');

async function resetInstance() {
  const instancesClient = new compute.InstancesClient();

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

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

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

resetInstance();

Python

from google.cloud import compute_v1

def reset_instance(project_id: str, zone: str, instance_name: str):
    """
    Resets a stopped Google Compute Engine instance (with unencrypted disks).

    Args:
        project_id: project ID or project number of the Cloud project your instance belongs to.
        zone: name of the zone your instance belongs to.
        instance_name: name of the instance your want to reset.
    """
    instance_client = compute_v1.InstancesClient()
    op_client = compute_v1.ZoneOperationsClient()

    op = instance_client.reset_unary(
        project=project_id, zone=zone, instance=instance_name
    )

    while op.status != compute_v1.Operation.Status.DONE:
        op = op_client.wait(operation=op.name, zone=zone, project=project_id)
    return

Wenn Sie den Befehl reset ausführen, wird der nachfolgende Zonenvorgang DONE zurückgegeben, nachdem die VM heruntergefahren wurde.

Andere Neustartmethoden

Sie können Ihre VM auch mit den folgenden Methoden zurücksetzen:

  • sudo reboot (nur Linux): Rufen Sie diese Methode innerhalb der VM auf. Diese Methode löscht den Arbeitsspeicher und initialisiert die VM mit den ursprünglichen Metadaten, dem Image und den nichtflüchtigen Speichern neu. Mit diesem Befehl werden keine aktualisierten Versionen des Images abgerufen und die VM behält dieselbe sitzungsspezifische IP-Adresse bei. Dies ist vergleichbar mit einem Neustart Ihres Computers.
  • Windows-VM neu starten: Sie können eine Windows-VM ähnlich wie mit sudo reboot im vorherigen Beispiel über das Startmenü neu starten. Klicken Sie dazu im Startmenü auf den Pfeil neben Abmelden und dann auf Neu starten.

Nächste Schritte