Diese Seite wurde von der Cloud Translation API übersetzt.

Maschinentyp einer Compute-Instanz bearbeiten

Wenn Ihre VM-Instanz keine angehängte lokale SSD hat und nicht Teil einer verwalteten Instanzgruppe (Managed Instance Group, MIG) ist, können Sie den Maschinentyp der Instanz ändern, nachdem Sie sie beendet haben.

Wenn der vorhandene Maschinentyp nicht für die Arbeitslasten geeignet ist, die Sie auf Ihrer VM ausführen, ändern Sie den Maschinentyp dieser VM. Sie können beispielsweise während Einrichtung, Entwicklung und Tests eine VM mit einer kleineren Maschine starten und die VM so ändern, dass ein größerer Maschinentyp verwendet wird, wenn sie für Produktionsarbeitslasten bereit ist.

Diese Vorgehensweise können Sie in den folgenden Fällen anwenden:

Beim Wechsel zu einem ähnlichen Maschinentyp mit einer anderen Anzahl von vCPUs oder einer anderen Arbeitsspeichergröße innerhalb derselben Maschinenreihe. Beispiel:
- Sie können n2-highcpu-4 in n2-standard-4 ändern.
- Sie können c3d-standard-30 in c3d-highmem-30 ändern.
Beim Ändern des Maschinentyps, um eine andere Maschinenreihe zu verwenden. Dies wird nur für Maschinenreihen der ersten und zweiten Generation unterstützt, mit Ausnahme der Maschinenreihe T2A und A2. Beispiel:
- Sie können n2-standard-4 in c2-standard-8 ändern.
- Sie können n1-highmem-4 in n2d-standard-16 ändern.

Wenn Sie den Maschinentyp einer VM, die eine Maschinenreihe der ersten oder zweiten Generation (z. B. N1, N2, M1) verwendet, in einen Maschinentyp für die Maschinenreihe der dritten Generation oder höher (z. B. M3, C3, N4) ändern möchten, müssen Sie das Verfahren unter Arbeitslast in eine neue Compute-Instanz verschieben ausführen.

Sie können den Maschinentyp ändern, ohne die folgenden Ressourcen zu beeinträchtigen:

SSH-Schlüssel der VM
VM-Konfigurationen, z. B. VM-Metadaten
Daten auf dem angehängten Persistent Disk- oder Hyperdisk-Volume, einschließlich installierter Anwendungen und Anwendungsdaten

Informationen zum Ändern des Maschinentyps von VMs innerhalb einer MIG finden Sie unter Aktualisierungen der VM-Konfiguration in einer MIG automatisch anwenden.

Vorbereitung

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

Select the tab for how you plan to use the samples on this page:
Console

When you use the Google Cloud console to access Google Cloud services and APIs, you don't need to set up authentication.
Java

Wenn Sie die Java Beispiele auf dieser Seite in einer lokalen Entwicklungsumgebung verwenden möchten, installieren und initialisieren Sie die gcloud CLI und richten dann die Standardanmeldedaten für Anwendungen mit Ihren Nutzeranmeldedaten ein.
1. Install the Google Cloud CLI.
2. To initialize the gcloud CLI, run the following command:
  gcloud init
3. If you're using a local shell, then create local authentication credentials for your user account:
  gcloud auth application-default login
  You don't need to do this if you're using Cloud Shell.
Weitere Informationen unter Set up authentication for a local development environment.
Python

Wenn Sie die Python Beispiele auf dieser Seite in einer lokalen Entwicklungsumgebung verwenden möchten, installieren und initialisieren Sie die gcloud CLI und richten dann die Standardanmeldedaten für Anwendungen mit Ihren Nutzeranmeldedaten ein.
1. Install the Google Cloud CLI.
2. To initialize the gcloud CLI, run the following command:
  gcloud init
3. If you're using a local shell, then create local authentication credentials for your user account:
  gcloud auth application-default login
  You don't need to do this if you're using Cloud Shell.
Weitere Informationen unter Set up authentication for a local development environment.
REST

Verwenden Sie die von der gcloud CLI bereitgestellten Anmeldedaten, um die REST API-Beispiele auf dieser Seite in einer lokalen Entwicklungsumgebung zu verwenden.
Weitere Informationen finden Sie unter Für die Verwendung von REST authentifizieren in der Dokumentation zur Google Cloud-Authentifizierung.

Erforderliche Rollen

Bitten Sie Ihren Administrator, Ihnen die folgenden IAM-Rollen für das Projekt zuzuweisen, damit Sie die Berechtigungen zum Ändern des Maschinentyps einer VM erhalten:

Compute Instance Admin (v1) (roles/compute.instanceAdmin.v1)
Um eine Verbindung zu einer VM herzustellen, die als Dienstkonto ausgeführt werden kann: Service Account User (v1) (roles/iam.serviceAccountUser)

Weitere Informationen zum Zuweisen von Rollen finden Sie unter Zugriff auf Projekte, Ordner und Organisationen verwalten.

Diese vordefinierten Rollen enthalten die Berechtigungen, die zum Ändern des Maschinentyps einer VM erforderlich sind. Erweitern Sie den Abschnitt Erforderliche Berechtigungen, um die erforderlichen Berechtigungen anzuzeigen:

Erforderliche Berechtigungen

Die folgenden Berechtigungen sind zum Ändern des Maschinentyps einer VM erforderlich:

compute.instances.setMachineType für die VM
compute.instances.start für die VM
compute.instances.stop für die VM

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

Beschränkungen

Wenn Ihre Compute-Instanz ein oder mehrere lokale SSDs enthält, können Sie den Maschinentyp der Instanz nicht ändern.
Wenn die Compute-Instanz eine sitzungsspezifische externe IP-Adresse verwendet, ändert sich diese möglicherweise, wenn Sie den Maschinentyp der Instanz ändern. Sie können dies verhindern, wenn Sie die IP-Adresse auf eine statische externe IP-Adresse hochstufen, bevor Sie den Maschinentyp ändern.
Bei einigen Konfigurationen ist es nicht möglich, den Maschinentyp einer Compute-Instanz zu ändern:
- Der Maschinentyp von Bare-Metal-Instanzen kann nicht geändert werden.
- Wenn Sie den Maschinentyp von einer Maschinenreihe der ersten oder zweiten Generation in einen Maschinentyp für eine Maschinenreihe der dritten Generation oder höher ändern möchten, können Sie dieses Verfahren nicht verwenden. Folgen Sie stattdessen der Anleitung unter Arbeitslast auf eine neue Compute-Instanz verschieben.
- Wenn Sie den Maschinentyp in einen ARM-Maschinentyp ändern möchten, können Sie dieses Verfahren nicht verwenden. Folgen Sie stattdessen der Anleitung unter Arbeitslast auf eine neue Compute-Instanz verschieben.
- Anhand der Schritte in diesem Dokument können Sie den Maschinentyp für beschleunigungsoptimierte G2-Maschinentypen ändern. Informationen zu anderen beschleunigungsoptimierten Maschinentypen finden Sie unter Beschleunigungsoptimierte VMs ändern.

Auswirkungen auf die Abrechnung

Maschinentypen werden mit unterschiedlichen Tarifen abgerechnet. Informieren Sie sich daher über die preislichen Auswirkungen der Änderung des Maschinentyps. Beispiel: Der Maschinentyp e2-standard-2 kostet mehr als der Maschinentyp e2-micro.

Eine Änderung des Maschinentyps kann sich auch auf den Rabatt für kontinuierliche Nutzung für diese VM auswirken. Rabatte für kontinuierliche Nutzung werden für die unterschiedlichen Kategorien in derselben Region separat berechnet. Wenn Sie Maschinentypen ändern, sodass der neue Maschinentyp einer anderen Kategorie zugeordnet ist, wird die nachfolgende Ausführungszeit der VM-Instanz auf den Rabatt für kontinuierliche Nutzung der neuen Kategorie angerechnet.

Nehmen wir beispielsweise an, Sie haben eine VM mit dem Maschinentyp n2-standard-2 einen halben Monat lang ausgeführt. Anschließend ändern Sie den Maschinentyp in m1-ultramem-40. Nach der Änderung berechnet Compute Engine die Ausführungszeit der VM ab diesem Moment zum Rabatt für die kontinuierliche Nutzung der speicheroptimierten vCPU und Speicherkategorie hinzu.

Auf der Abrechnung sehen Sie einen Rabatt für die kontinuierliche Nutzung des Maschinentyps n2-standard-2 vor dem Wechsel und einen separaten Rabatt für den Typ m1-ultramem-40, wenn die VM mindestens 25 % des restlichen Monats auf m1-ultramem-40 ausgeführt wird.

Zu einem kleineren Maschinentyp wechseln

Wenn Sie von einem Maschinentyp mit mehr Ressourcen zu einem Maschinentyp mit weniger Ressourcen wechseln, z. B. von e2-standard-8 zu e2-standard-2, kann es zu Problemen mit den Hardwareressourcen oder zu Leistungseinschränkungen kommen, da kleinere Maschinentypen weniger leistungsstark sind als große. Achten Sie daher darauf, dass der neue Maschinentyp die derzeit auf der VM ausgeführten Anwendungen oder Dienste unterstützt oder aktualisieren Sie die Dienste und Anwendungen so, dass sie auf dem kleineren Maschinentyp laufen können.

Lesen Sie die Empfehlungen zur Größenanpassung, bevor Sie den Maschinentyp ändern. Informationen zu Größenempfehlungen für die Compute Engine finden Sie unter Empfehlungen für Maschinentypen für VM-Instanzen anwenden.

Best Practices

Hier sind einige Best Practices für das Ändern des VM-Maschinentyps.

Führen Sie mithilfe von Snapshots regelmäßige Sicherungen der Daten in nichtflüchtigen Speichern durch. Erstellen Sie einen Snapshot der Daten des nichtflüchtigen Speichers, bevor Sie den Maschinentyp ändern. Wenn Sie sicher sein möchten, dass der neue Maschinentyp die Daten der vorhandenen VM unterstützt, können Sie einen Snapshot des nichtflüchtigen Speichers erstellen und damit eine zweite VM mit dem neuen Maschinentyp starten. Sie können dann sehen, ob die VM erfolgreich gestartet wurde.
Fügen Sie der Datei /etc/fstab weitere Laufwerke hinzu. Wenn an Ihre VM weitere nichtflüchtige Speicher angehängt sind, müssen Sie sie der Datei /etc/fstab hinzufügen, damit sie beim Neustart der VM automatisch bereitgestellt werden.
Erstellen Sie eine Reservierung, bevor Sie den Maschinentyp ändern. Um Fehler im Zusammenhang mit der Ressourcenverfügbarkeit zu vermeiden, erstellen Sie Compute Engine-Reservierungen für die neuen Maschinentypen, sobald sie verfügbar sind, um sie in einer Zone zu reservieren. Mit Reservierungen sorgen Sie dafür, dass die Ressourcen verfügbar sind, wenn Sie sie benötigen.

Führen Sie die folgenden Schritte aus, um eine Reservierung zu erstellen:

Erstellen Sie eine Reservierung (oder identifizieren Sie vorhandene Reservierungen) mit identischen Attributen wie die geplanten VMs. Die VM-Anzahl der Reservierung muss gleich oder größer als die Anzahl der VMs sein, die Sie ändern möchten. Optional können Sie verhindern, dass andere VMs diese Reservierung nutzen. Verwenden Sie dazu die Option specificReservationRequired.
Prüfen Sie, ob die geplanten VMs die Reservierung nutzen können:
1. Prüfen Sie, ob die gewünschten VMs die richtige Reservierungsaffinität haben.
2. Sorgen Sie unmittelbar vor dem Ändern der VMs dafür, dass die Reservierung über genügend Kapazität verfügt.

Maschinentyp ändern

Eine Änderung des Maschinentyps ist nur bei beendeten VMs möglich. Eine VM gilt nur dann als beendet, wenn sie den Status TERMINATED hat. Der Maschinentyp einer laufenden VM kann nicht geändert werden.

Wenn Sie Ihren Maschinentyp auf die neueste Generation aktualisieren, lesen Sie vorher die Informationen unter VM-Migrationsoptionen bewerten.

Console

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

Zu "VM-Instanzen"
Klicken Sie in der Spalte Name auf den Namen der VM, deren Maschinentyp Sie ändern möchten.
Führen Sie auf der Seite VM-Instanzdetails folgende Schritte aus:
1. Wenn die VM ausgeführt wird, wählen Sie oben auf der Seite im Menü die Option Beenden aus, um die VM zu beenden.
2. Klicken Sie zum Bearbeiten der VM auf Bearbeiten.
3. Wählen Sie im Abschnitt Maschinenkonfiguration den Maschinentyp aus, den Sie verwenden möchten, oder erstellen Sie einen benutzerdefinierten Maschinentyp.
4. Um die Änderungen zu speichern, klicken Sie auf Speichern.
5. Starten Sie die VM neu.

gcloud

Beenden Sie die VM mit dem Befehl gcloud compute instances stop.
```
gcloud compute instances stop VM_NAME
```
Ersetzen Sie VM_NAME durch die VM, die den zu ändernden Maschinentyp enthält.
Ändern Sie den Maschinentyp mit dem Befehl gcloud compute instances set-machine-type:
```
gcloud compute instances set-machine-type VM_NAME \
    --machine-type NEW_MACHINE_TYPE
```
Ersetzen Sie NEW_MACHINE_TYPE durch den neuen Maschinentyp für die VM. Es gibt folgende Maschinentypen:
- Ein vordefinierter Maschinentyp
  
  Beispiel: e2-standard-2
- Ein benutzerdefinierter Maschinentyp
  
  Sie können beispielsweise --machine-type e2-custom-4-2048 angeben, um einen benutzerdefinierten Maschinentyp mit 4 vCPUs und 2 GB Arbeitsspeicher festzulegen.
Starten Sie die VM mit dem Befehl gcloud compute instances start.
```
gcloud compute instances start VM_NAME
```
Ersetzen Sie VM_NAME durch den Namen der geänderten VM.

Java

Bevor Sie dieses Beispiel anwenden, folgen Sie den Schritten zur Einrichtung von Java in der Compute Engine-Kurzanleitung zur Verwendung von Clientbibliotheken. Weitere Informationen finden Sie in der Referenzdokumentation zur Compute Engine Java API.

Richten Sie die Standardanmeldedaten für Anwendungen ein, um sich bei Compute Engine zu authentifizieren. Weitere Informationen finden Sie unter Authentifizierung für eine lokale Entwicklungsumgebung einrichten.


import com.google.cloud.compute.v1.Instance;
import com.google.cloud.compute.v1.Instance.Status;
import com.google.cloud.compute.v1.InstancesClient;
import com.google.cloud.compute.v1.InstancesSetMachineTypeRequest;
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 ChangeInstanceMachineType {

  public static void main(String[] args)
      throws IOException, ExecutionException, InterruptedException, TimeoutException {
    // TODO(developer): Replace these variables before running the sample.
    // Project ID or project number of the Cloud project you want to use.
    String projectId = "your-project-id";
    // Name of the zone your instance belongs to.
    String zone = "zone-name";
    // Name of the VM you want to modify.
    String instanceName = "instance-name";
    // The new machine type you want to use for the VM.
    // For example: "e2-standard-8", "e2-custom-4-2048" or "m1-ultramem-40"
    // More about machine types: https://cloud.google.com/compute/docs/machine-resource
    String newMachineType = "e2-standard-8";
    changeMachineType(projectId, zone, instanceName, newMachineType);
  }

  // Changes the machine type of VM.
  // The VM needs to be in the 'TERMINATED' state for this operation to be successful.
  public static void changeMachineType(String projectId, String zone, String instanceName,
      String newMachineType)
      throws IOException, ExecutionException, InterruptedException, TimeoutException {
    // Initialize client that will be used to send requests. This client only needs to be created
    // once, and can be reused for multiple requests. After completing all of your requests, call
    // the `instancesClient.close()` method on the client to safely
    // clean up any remaining background resources.
    try (InstancesClient instancesClient = InstancesClient.create()) {

      Instance instance = instancesClient.get(projectId, zone, instanceName);
      if (!instance.getStatus().equals(Status.TERMINATED.name())) {
        throw new Error(String.format(
            "Only machines in TERMINATED state can have their machine type changed. "
                + "%s is in %s state.", instance.getName(), instance.getStatus()));
      }

      InstancesSetMachineTypeRequest machineTypeRequest =
          InstancesSetMachineTypeRequest.newBuilder()
              .setMachineType(String.format("projects/%s/zones/%s/machineTypes/%s",
                  projectId, zone, newMachineType))
              .build();

      Operation response = instancesClient
          .setMachineTypeAsync(projectId, zone, instanceName, machineTypeRequest)
          .get(3, TimeUnit.MINUTES);

      if (response.hasError()) {
        System.out.println("Machine type update failed! " + response);
        return;
      }
      System.out.println("Machine type update - operation status: " + response.getStatus());
    }
  }
}

Python

Bevor Sie dieses Beispiel anwenden, folgen Sie den Schritten zur Einrichtung von Python in der Compute Engine-Kurzanleitung zur Verwendung von Clientbibliotheken. Weitere Informationen finden Sie in der Referenzdokumentation zur Compute Engine Python API.

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 change_machine_type(
    project_id: str, zone: str, instance_name: str, new_machine_type: str
) -> None:
    """
    Changes the machine type of VM. The VM needs to be in the 'TERMINATED' state for this operation to be successful.

    Args:
        project_id: project ID or project number of the Cloud project you want to use.
        zone: name of the zone your instance belongs to.
        instance_name: name of the VM you want to modify.
        new_machine_type: the new machine type you want to use for the VM.
            For example: `e2-standard-8`, `e2-custom-4-2048` or `m1-ultramem-40`
            More about machine types: https://cloud.google.com/compute/docs/machine-resource
    """
    client = compute_v1.InstancesClient()
    instance = client.get(project=project_id, zone=zone, instance=instance_name)

    if instance.status != compute_v1.Instance.Status.TERMINATED.name:
        raise RuntimeError(
            f"Only machines in TERMINATED state can have their machine type changed. "
            f"{instance.name} is in {instance.status}({instance.status_message}) state."
        )

    machine_type = compute_v1.InstancesSetMachineTypeRequest()
    machine_type.machine_type = (
        f"projects/{project_id}/zones/{zone}/machineTypes/{new_machine_type}"
    )
    operation = client.set_machine_type(
        project=project_id,
        zone=zone,
        instance=instance_name,
        instances_set_machine_type_request_resource=machine_type,
    )

    wait_for_extended_operation(operation, "changing machine type")

REST

Beenden Sie die VM mithilfe der Methode instances.stop:
```
POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/zones/ZONE/instances/VM_NAME/stop
```
Dabei gilt:
- PROJECT_ID: die Projekt-ID
- ZONE ist die Zone mit der VM.
- VM_NAME ist die VM mit dem zu ändernden Maschinentyp.
Ändern Sie den Maschinentyp mit der Methode instances.setMachineType:
```
POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/zones/ZONE/instances/VM_NAME/setMachineType
```
Geben Sie im Anfragetext den aktualisierten machineType an:
```
{
    machineType: "zones/MACHINE_TYPE_ZONE/machineTypes/NEW_MACHINE_TYPE"
}
```
Dabei gilt:
- MACHINE_TYPE_ZONE ist die Zone mit dem Maschinentyp.
- NEW_MACHINE_TYPE ist der neue Maschinentyp für die VM.
  
  Es gibt folgende Maschinentypen:
  - Ein vordefinierter Maschinentyp
    
    Beispiel: e2-standard-2
  - Ein benutzerdefinierter Maschinentyp
    
    Sie können beispielsweise --machine-type e2-custom-4-2048 angeben, um einen benutzerdefinierten Maschinentyp mit 4 vCPUs und 2 GB Arbeitsspeicher festzulegen.
Starten Sie die VM mithilfe der Methode instances.start:
```
POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/zones/ZONE/instances/VM_NAME/start
```
Dabei gilt:
- PROJECT_ID: die Projekt-ID
- ZONE ist die Zone mit der VM.
- VM_NAME ist der Name der VM, die Sie geändert haben

Nächste Schritte

Weitere Informationen zu Empfehlungen für Maschinentypen
Verwaltete Instanzgruppen
Muster für skalierbare und ausfallsichere Anwendungen
Informationen zum Aktualisieren einer VM der ersten oder zweiten Generation für die Verwendung einer Maschinenreihe der dritten Generation oder höher: Arbeitslast in eine neue Compute-Instanz verschieben