Instanz mit zusätzlichen Nicht-Bootlaufwerken erstellen

In diesem Dokument wird beschrieben, wie Sie beim Erstellen einer Compute Engine-Instanz zusätzliche Nicht-Bootlaufwerke erstellen und an die Instanz anhängen.

Die Informationen in diesem Dokument beziehen sich auf das Erstellen einer Compute-Instanz mit zonalen Laufwerken, die sich nicht in einem Hyperdisk-Pool befinden. In der folgenden Liste werden die zugehörigen Aufgaben und die entsprechende Dokumentation beschrieben.

Hinweis

  • 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 so bei Compute Engine authentifizieren:

    Wählen Sie den Tab aus, der Ihrer geplanten Verwendung der Beispiele auf dieser Seite entspricht:

    Console

    Wenn Sie über die Google Cloud Console auf Google Cloud Dienste und APIs zugreifen, müssen Sie die Authentifizierung nicht einrichten.

    gcloud

    1. Installieren Sie die Google Cloud CLI. Initialisieren Sie die Google Cloud CLI nach der Installation mit dem folgenden Befehl: 

      gcloud init

      Wenn Sie einen externen Identitätsanbieter (IdP) verwenden, müssen Sie sich zuerst mit Ihrer föderierten Identität in der gcloud CLI anmelden.

  • Legen Sie eine Standardregion und -zone fest.

    • REST

    Wenn Sie die REST API-Beispiele auf dieser Seite in einer lokalen Entwicklungsumgebung verwenden möchten, verwenden Sie die Anmeldedaten, die Sie der gcloud CLI bereitstellen.

      Installieren Sie die Google Cloud CLI.

      Wenn Sie einen externen Identitätsanbieter (IdP) verwenden, müssen Sie sich zuerst mit Ihrer föderierten Identität in der gcloud CLI anmelden.

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

Erforderliche Rollen

Bitten Sie Ihren Administrator, Ihnen die IAM-Rolle Compute Instance Admin (v1) (roles/compute.instanceAdmin.v1) für das Projekt zu gewähren, um die Berechtigungen zu erhalten, die Sie zum Erstellen einer Instanz mit zusätzlichen Nicht-Boot-Laufwerken 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 Erstellen einer Instanz mit zusätzlichen Nicht-Boot-Laufwerken erforderlich sind. Maximieren Sie den Abschnitt Erforderliche Berechtigungen, um die notwendigen Berechtigungen anzuzeigen:

Erforderliche Berechtigungen

Die folgenden Berechtigungen sind erforderlich, um eine Instanz mit zusätzlichen Nicht-Bootlaufwerken zu erstellen:

  • compute.instances.create für das Projekt
  • So erstellen Sie ein Laufwerk für die Instanz: compute.disks.create für das Projekt
  • So erstellen Sie ein Laufwerk aus einem Image: compute.images.useReadOnly für das Quell-Image
  • So erstellen Sie ein Laufwerk aus einem Standard- oder Archiv-Snapshot: compute.snapshots.useReadOnly für den Quell-Snapshot
  • So erstellen Sie ein Laufwerk aus einem Instant Snapshot, wenn das Quelllaufwerk des Instant Snapshots das Bootlaufwerk einer Instanz mit einem angehängten Dienstkonto ist: iam.serviceAccounts.actAs für das Dienstkonto der Instanz
  • So erstellen Sie ein Laufwerk aus einem Instant Snapshot: compute.instantSnapshots.useReadOnly für den Quell-Instant Snapshot
  • So erstellen Sie ein Laufwerk aus einem vorhandenen Laufwerk: compute.disks.useReadOnly auf dem Quelllaufwerk

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

Beschränkungen

Die Anzahl, die kombinierte Gesamtgröße und der Typ der Laufwerke, die Sie an eine Instanz anhängen können, hängen vom Maschinentyp der Instanz ab.

C4-Instanzen unterstützen beispielsweise keine Persistent Disk. Außerdem darf die kombinierte Größe aller Laufwerke, die an eine c4-standard-2-Instanz angehängt sind, 257 TiB nicht überschreiten. Für eine c4-standard-192-Instanz liegt das Limit bei 512 TiB.

Die detaillierten Limits für jede Maschinenserie finden Sie im Abschnitt Unterstützte Laufwerkstypen in der Dokumentation der jeweiligen Maschinenserie. Die Grenzwerte für die Maschinenreihe Ihrer neuen Instanz finden Sie unter dem entsprechenden Link in der folgenden Tabelle.

Maschinentypen für allgemeine Zwecke
 Computing-optimierte
Maschinentypen		 Speicheroptimierte
Maschinentypen		 Beschleunigungsoptimierte
Maschinentypen		 Speicheroptimierte
Maschinentypen

Grenzwerte für die Laufwerkgröße und Referenznamen

Die Größe, die Sie für ein regionales Laufwerk angeben, muss innerhalb der Bereiche liegen, die in der folgenden Tabelle aufgeführt sind.

Wenn Sie ein Laufwerk mit der Google Cloud CLI, REST oder den Cloud-Clientbibliotheken für Compute Engine erstellen, geben Sie den Typ des zu erstellenden Laufwerks mit dem entsprechenden Wert der Spalte Referenzname in der folgenden Tabelle an.

Laufwerkstyp Referenzname Mindestgröße Maximalgröße Standardgröße
Hyperdisk Balanced hyperdisk-balanced 4 GiB 64 TiB1 100 GiB
Hyperdisk Balanced High Availability hyperdisk-balanced-high-availability 4 GiB 64 TiB 100 GiB
Hyperdisk Extrem hyperdisk-extreme 64 GiB 64 TiB 1 TiB
Hyperdisk Throughput hyperdisk-throughput 2 TiB 32 TiB 2 TiB
Hyperdisk ML hyperdisk-ml 4 GiB 64 TiB 100 GiB
Abgestimmter nichtflüchtiger Speicher pd-balanced Zonal: 10 GiB
Regional: 10 GiB		 64 TiB 100 GiB
Leistungsstarker nichtflüchtiger Speicher (SSD) pd-ssd Zonal: 10 GiB
Regional: 10 GiB		 64 TiB 100 GiB
Nichtflüchtiger Standardspeicher pd-standard Zonal: 10 GiB
Regional: 200 GiB		 64 TiB 500 GiB
Extrem nichtflüchtiger Speicher pd-extreme 500 GiB 64 TiB 1 TiB
1 Vorschau: C4 unterstützt eine maximale Laufwerksgröße von 128 TiB. Wenn Sie Zugriff auf diese Funktion benötigen, wenden Sie sich an hyperdisk-questions@google.com.

Instanz mit neuen zusätzlichen Nicht-Bootlaufwerken erstellen

So erstellen Sie eine Instanz mit zusätzlichen Nicht-Bootlaufwerken, die erstellt und angehängt werden:

Console

  1. Rufen Sie in der Google Cloud Console die Seite Instanz erstellen auf.

    Zu „Instanz erstellen“ wechseln

    Wenn Sie dazu aufgefordert werden, wählen Sie Ihr Projekt aus und klicken auf Weiter.

    Die Seite Instanz erstellen wird angezeigt und enthält den Bereich Maschinenkonfiguration.

  2. Führen Sie im Bereich Maschinenkonfiguration die folgenden Schritte aus:

    1. Geben Sie im Feld Name einen Namen für die Instanz an. Weitere Informationen finden Sie unter Namenskonvention für Ressourcen.
    2. Geben Sie im Feld Region die Region an, in der sich Ihre Instanz befinden soll.

    3. Optional: Wählen Sie im Feld Zone eine Zone für diese Instanz aus.

      Die Standardauswahl ist Beliebig. Wenn Sie diese Standardauswahl nicht ändern, wählt Google automatisch eine Zone für Sie aus, die auf dem Maschinentyp und der Verfügbarkeit basiert.

    4. Wählen Sie die Maschinenfamilie für Ihre Instanz aus. In der Google Cloud Console werden dann die Maschinenreihen angezeigt, die für die ausgewählte Maschinenfamilie verfügbar sind. Die folgenden Optionen für Maschinenfamilien sind verfügbar:

      • Für allgemeine Zwecke
      • Computing-optimiert
      • Speicheroptimiert
      • Speicheroptimiert
      • GPUs

    5. Wählen Sie in der Spalte Reihe die Maschinenreihe für Ihre Instanz aus.

      Wenn Sie im vorherigen Schritt GPUs als Maschinenfamilie ausgewählt haben, wählen Sie den gewünschten GPU-Typ aus. Die Maschinenreihe wird dann automatisch für den ausgewählten GPU-Typ ausgewählt.

    6. Wählen Sie im Abschnitt Maschinentyp den Maschinentyp für Ihre Instanz aus.

  3. Klicken Sie im Navigationsmenü auf Betriebssystem und Speicher. Der Bereich Betriebssystem und Speicher wird angezeigt.

  4. Klicken Sie auf Ändern, um Ihr Bootlaufwerk zu konfigurieren. Der Bereich Bootlaufwerk wird angezeigt und enthält den Tab Öffentliche Images.

  5. Konfigurieren Sie die Datenquelle für das Bootlaufwerk auf eine der folgenden Arten:

    • Wenn Sie ein öffentliches Image als Datenquelle für Ihr Bootlaufwerk auswählen möchten, geben Sie auf dem Tab Öffentliche Images Folgendes an:

      1. Wählen Sie in der Liste Betriebssystem den Betriebssystemtyp aus.
      2. Wählen Sie in der Liste Version die Version des Betriebssystems aus.
      3. Wählen Sie in der Liste Typ des Bootlaufwerks den Bootlaufwerkstyp aus.
      4. Geben Sie im Feld Größe (GB) die Größe des Bootlaufwerks an.

    • Wenn Sie ein benutzerdefiniertes Image als Datenquelle für Ihr Bootlaufwerk auswählen möchten, klicken Sie auf Benutzerdefinierte Images und geben Sie dann auf dem Tab Benutzerdefinierte Images Folgendes an:

      1. Klicken Sie zum Auswählen des Image-Projekts auf Ändern und wählen Sie dann das Projekt aus, das das Image enthält.
      2. Klicken Sie in der Liste Image auf das Image, das Sie importieren möchten.
      3. Wählen Sie in der Liste Typ des Bootlaufwerks den Bootlaufwerkstyp aus.
      4. Geben Sie im Feld Größe (GB) die Größe des Bootlaufwerks an.

    • Wenn Sie einen Standardsnapshot als Datenquelle für Ihr Bootlaufwerk auswählen möchten, klicken Sie auf Snapshots und geben Sie dann auf dem Tab Snapshots Folgendes an:

      1. Wählen Sie in der Liste Snapshot den Snapshot aus.
      2. Wählen Sie in der Liste Typ des Bootlaufwerks den Bootlaufwerkstyp aus.
      3. Geben Sie im Feld Größe (GB) die Größe des Bootlaufwerks an.

    • Wenn Sie einen Archiv-Snapshot als Datenquelle für Ihr Bootlaufwerk auswählen möchten, klicken Sie auf Archiv-Snapshots und geben Sie dann auf dem Tab Archiv-Snapshots Folgendes an:

      1. Wählen Sie in der Liste Archiv-Snapshot den Archiv-Snapshot aus.
      2. Wählen Sie in der Liste Typ des Bootlaufwerks den Bootlaufwerkstyp aus.
      3. Geben Sie im Feld Größe (GB) die Größe des Bootlaufwerks an.

    • Wenn Sie ein vorhandenes Laufwerk als Bootlaufwerk auswählen möchten, klicken Sie auf Vorhandene Laufwerke. Wählen Sie dann auf dem Tab Vorhandene Laufwerke in der Liste Laufwerk ein vorhandenes regionales Persistent Disk- oder Hyperdisk Balanced High Availability-Volume aus.

  6. Optional: Wenn das Bootlaufwerk ein Hyperdisk Balanced-Volume ist, können Sie Leistungslimits für das neue Laufwerk festlegen. Die von Ihnen angegebenen Werte müssen im Bereich der unterstützten Werte liegen.

  7. Optional: Erweitern Sie für erweiterte Konfigurationsoptionen den Abschnitt Erweiterte Konfigurationen einblenden.

    • Wählen Sie im Feld Modus den Modus für die Laufwerkanbringung aus.
    • Wählen Sie aus, ob das Laufwerk beibehalten oder gelöscht werden soll, wenn die Instanz gelöscht wird. Wählen Sie dazu die entsprechende Option im Feld Löschregel aus.
    • Geben Sie einen benutzerdefinierten Gerätenamen an, um das Laufwerk im Gastbetriebssystem leichter identifizieren zu können. Wählen Sie unter der Überschrift Gerätename die Option Benutzerdefinierten Gerätenamen verwenden aus. Geben Sie im Feld Gerätename einen String ein, der als symbolischer Link für das Laufwerk verwendet werden soll.

  8. Klicken Sie auf Auswählen, um die Bootlaufwerksoptionen zu bestätigen und zum Bereich Betriebssystem und Speicher zurückzukehren.

  9. Wenn Sie ein neues Nicht-Bootlaufwerk erstellen und an Ihre Instanz anhängen möchten, führen Sie die folgenden Schritte für jedes Laufwerk aus, das Sie hinzufügen möchten.

    1. Klicken Sie im Abschnitt Zusätzliche Laufwerke auf Neues Laufwerk hinzufügen. Der Bereich Neues Laufwerk hinzufügen wird angezeigt.

    2. Geben Sie im Abschnitt Laufwerkskonfiguration im Feld Name einen Namen für das Nicht-Boot-Laufwerk an.

    3. Optional: Geben Sie im Feld Beschreibung eine Beschreibung für die Festplatte an.

    4. Wählen Sie die Datenquelle für das neue Laufwerk aus:

      • Wenn Sie ein leeres, nicht formatiertes Laufwerk erstellen möchten, wählen Sie in der Liste Quelltyp die Option Leeres Laufwerk aus.
      • Wenn Sie eine Kopie vorhandener Daten erstellen möchten, wählen Sie den Quelltyp für das Nicht-Bootlaufwerk aus.

    5. Wählen Sie in der Liste Laufwerkstyp einen Typ für das Nicht-Bootlaufwerk aus. Der Maschinentyp muss den Laufwerkstyp unterstützen.

    6. Geben Sie im Feld Größe die Größe des Nicht-Bootlaufwerks an.

    7. Optional: Wenn das neue Laufwerk ein Hyperdisk-Volume ist, können Sie Leistungsgrenzen für das neue Laufwerk festlegen. Die von Ihnen angegebenen Werte müssen im Bereich der unterstützten Werte liegen und hängen vom Hyperdisk-Typ ab:

      • Hyperdisk abgestimmt. Sie können die Größe, die bereitgestellten IOPS und den bereitgestellten Durchsatz des Laufwerks ändern.
      • Hyperdisk Extrem. Sie können die Größe und die bereitgestellten IOPS des Laufwerks ändern.
      • Hyperdisk ML. Sie können die Größe und den Bereitgestellten Durchsatz des Laufwerks ändern.
      • Hyperdisk Throughput.Sie können die Größe und den Bereitgestellten Durchsatz des Laufwerks ändern.

    8. Optional: Erweitern Sie für erweiterte Konfigurationsoptionen den Abschnitt Erweiterte Konfigurationen einblenden.

      • Wählen Sie im Feld Modus den Modus für die Laufwerkanbringung aus.
      • Wählen Sie aus, ob das Laufwerk beibehalten oder gelöscht werden soll, wenn die Instanz gelöscht wird. Wählen Sie dazu die entsprechende Option im Feld Löschregel aus.
      • Geben Sie einen benutzerdefinierten Gerätenamen an, um das Laufwerk im Gastbetriebssystem leichter identifizieren zu können. Wählen Sie unter der Überschrift Gerätename die Option Benutzerdefinierten Gerätenamen verwenden aus. Geben Sie im Feld Gerätename einen String ein, der als symbolischer Link für das Laufwerk verwendet werden soll.

    9. Klicken Sie auf Speichern, um die Optionen zu bestätigen und zum Bereich Betriebssystem und Speicher zurückzukehren.

    Wiederholen Sie diesen Schritt für jedes Nicht-Bootlaufwerk, das Sie erstellen und an Ihre Instanz anhängen möchten.

  10. Optional: Geben Sie Sicherungs- und Replikationsoptionen für Ihre Compute-Instanz an. Klicken Sie im Navigationsmenü auf Datenschutz. Geben Sie im angezeigten Bereich Datenschutz an, wie Sie die Daten für Ihre Compute-Instanz sichern und replizieren möchten. Gehen Sie dazu so vor:

    1. Wählen Sie unter Daten sichern eine Option aus, um festzulegen, wie Daten gesichert werden sollen.

    2. So geben Sie an, wie Daten repliziert werden sollen:

      1. Wenn Sie möchten, dass neue Laufwerke für die Instanz mithilfe von regionalen Laufwerkstypen synchron in einer zweiten Zone repliziert werden, wählen Sie das Kästchen Regionale Laufwerke aus.
      1. Wenn Sie möchten, dass die Laufwerke für die Instanz in einer zweiten Region mit Asynchrone Replikation repliziert werden, wählen Sie das Kästchen Asynchrone Replikation aus.

    3. Wenn Sie die angegebenen Datenschutzoptionen nur auf Nicht-Bootlaufwerke anwenden möchten, aktivieren Sie das Kästchen Bootlaufwerke ausschließen.

  11. Klicken Sie im Navigationsmenü auf Netzwerk. Führen Sie im angezeigten Bereich Netzwerk die folgenden Schritte aus:

    1. Rufen Sie den Abschnitt Firewall auf.

    2. Wählen Sie dann HTTP-Traffic zulassen oder HTTPS-Traffic zulassen aus, damit die Instanz HTTP- oder HTTPS-Traffic empfangen kann.

      In der Compute Engine wird der Instanz ein Netzwerk-Tag hinzugefügt und es werden entsprechende Firewallregeln für eingehenden Traffic erstellt, die den gesamten eingehenden Traffic über tcp:80 (HTTP) oder tcp:443 (HTTPS) zulassen. Das Netzwerk-Tag ordnet die Firewallregel der Instanz zu. Weitere Informationen finden Sie unter Übersicht zu Firewallregeln in der Dokumentation zur Cloud Next Generation Firewall.

  12. Optional: Geben Sie weitere Konfigurationsoptionen an. Weitere Informationen finden Sie unter Konfigurationsoptionen beim Erstellen von Instanzen.

  13. Klicken Sie zum Erstellen und Starten der Instanz auf Erstellen.

gcloud

  1. Aktivieren Sie Cloud Shell in der Google Cloud Console.

    Cloud Shell aktivieren

    Unten in der Google Cloud Console wird eine Cloud Shell-Sitzung gestartet und eine Eingabeaufforderung angezeigt. Cloud Shell ist eine Shell-Umgebung, in der das Google Cloud CLI bereits installiert ist und Werte für Ihr aktuelles Projekt bereits festgelegt sind. Das Initialisieren der Sitzung kann einige Sekunden dauern.

  2. Führen Sie den Befehl gcloud compute instances create aus, um eine Instanz mit zusätzlichen Nicht-Bootlaufwerken zu erstellen.

    Beim Erstellen einer Instanz können Sie bis zu 127 Nicht-Bootlaufwerke hinzufügen. Geben Sie das Flag --create-disk für jedes Nicht-Bootlaufwerk an, das Sie erstellen.

    Wenn Sie Nicht-Bootlaufwerke aus einem öffentlichen oder einem vorhandenen Image erstellen möchten, geben Sie im Flag --create-disk die Attribute image oder image-family und image-project an. Wenn Sie diese Attribute nicht angeben, wird ein leeres Laufwerk erstellt.

    Sie können optional Werte für die folgenden Eigenschaften angeben:

    • Laufwerksgröße: Verwenden Sie das Attribut --size.
    • Laufwerkstyp: Verwenden Sie das Attribut --type.
    • Regionale Laufwerke: Fügen Sie das Attribut replica-zones hinzu.
    gcloud compute instances create INSTANCE_NAME \
    --zone=ZONE \
    --machine-type=MACHINE_TYPE \
    --image-project=BOOT_DISK_IMAGE_PROJECT \
    BOOT_DISK_IMAGE_FLAG \
    --create-disk name=DISK_NAME,device-name=DISK_DEVICE_NAME,size=SIZE_GB,type=DISK_TYPE,image=DISK_IMAGE,image-project=DISK_IMAGE_PROJECT,replica-zones=^:^ZONE:REMOTE_ZONE,boot=false

    Ersetzen Sie Folgendes:

    • INSTANCE_NAME: Der Name der neuen Instanz.
    • ZONE: Die Zone, in der die Instanz erstellt wird.
    • MACHINE_TYPE: der gewünschte Maschinentyp für die Instanz. Beispiel: c3-standard-4.
    • BOOT_DISK_IMAGE_PROJECT: Das Projekt, das das Bild enthält. Für Debian ist das beispielsweise debian-cloud. Weitere Informationen zum Image-Projekt für öffentliche Images finden Sie auf der Seite Details zu Betriebssystemen. Im Abschnitt GA-Versionen für Ihr Betriebssystem ist das Image-Projekt auf dem Tab Allgemeine Informationen in der Spalte Image-Projekt aufgeführt.

    • BOOT_DISK_IMAGE_FLAG: Geben Sie eine der folgenden Optionen an:

      • Verwenden Sie das Flag --image IMAGE_NAME, um eine bestimmte Version eines öffentlichen oder benutzerdefinierten Images anzugeben. Beispiel: --image debian-12-bookworm-v20241112

      • Verwenden Sie das Flag --image-family IMAGE_FAMILY_NAME, um eine Image-Familie anzugeben. Dadurch wird die Instanz mit dem neuesten nicht verworfenen Betriebssystem-Image in der Image-Familie erstellt. Wenn Sie beispielsweise --image-family debian-12 angeben, verwendet Compute Engine die neueste Version des Betriebssystem-Images in der Debian 12-Image-Familie, wenn die Instanz erstellt wird.

    • Ersetzen Sie für zusätzliche Laufwerke folgende Optionen:

      • DISK_NAME (optional): der Name des Nicht-Bootlaufwerks.
      • SIZE_GB (optional): die Größe des Nicht-Bootlaufwerks.
      • DISK_TYPE: der Typ des Laufwerks. Beispiel: hyperdisk-balanced Der Maschinentyp muss den Laufwerkstyp unterstützen.
      • DISK_DEVICE_NAME: Optional: Der Name für das Laufwerk, der dem Gastbetriebssystem nach dem Erstellen der Instanz angezeigt wird.
      • DISK_IMAGE (optional): Wenn Sie ein Laufwerk aus einem vorhandenen Image erstellen möchten, geben Sie eine der folgenden Optionen an:
        • image=DISK_IMAGE_NAME: Der Name des Images, das Sie zum Erstellen des Nicht-Bootlaufwerks verwenden möchten, z. B. debian-12-bookworm-v20260210.
        • image-family=DISK_IMAGE_FAMILY: Eine Image-Familie, die beim Erstellen eines Nicht-Bootlaufwerks verwendet werden soll, z. B. debian-12.
      • DISK_IMAGE_PROJECT (optional): Wenn Sie ein Nicht-Bootlaufwerk aus einem vorhandenen Image erstellen möchten, geben Sie das Image-Projekt an, das das Image enthält.
      • REMOTE_ZONE: Optional. Wenn Sie ein regionales Laufwerk erstellen, geben Sie die Zone an, in die das Laufwerk repliziert werden soll, z. B. us-central1-b.

      Bei leeren Laufwerken geben Sie die Parameter image, image-project oder image-family nicht an.

      Bei zonalen Laufwerken geben Sie nicht das Laufwerksattribut replica-zones an.

Terraform

Zum Generieren des Terraform-Codes können Sie die Komponente Entsprechender Code in der Google Cloud Console verwenden.
  1. Rufen Sie in der Google Cloud Console die Seite VM-Instanzen auf.

    Zur Seite „VM-Instanzen“

  2. Klicken Sie auf Instanz erstellen.
  3. Geben Sie die gewünschten Parameter an.
  4. Klicken Sie oben oder unten auf der Seite auf Entsprechender Code und dann auf den Tab Terraform, um den Terraform-Code aufzurufen.

Go

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

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

import (
	"context"
	"fmt"
	"io"

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

// createWithAdditionalDisk create a new VM instance with Debian 10 operating system and a 11 GB additional empty disk.
func createWithAdditionalDisk(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()

	imagesClient, err := compute.NewImagesRESTClient(ctx)
	if err != nil {
		return fmt.Errorf("NewImagesRESTClient: %w", err)
	}
	defer imagesClient.Close()

	// List of public operating system (OS) images: https://cloud.google.com/compute/docs/images/os-details.
	newestDebianReq := &computepb.GetFromFamilyImageRequest{
		Project: "debian-cloud",
		Family:  "debian-12",
	}
	newestDebian, err := imagesClient.GetFromFamily(ctx, newestDebianReq)
	if err != nil {
		return fmt.Errorf("unable to get image from family: %w", err)
	}

	req := &computepb.InsertInstanceRequest{
		Project: projectID,
		Zone:    zone,
		InstanceResource: &computepb.Instance{
			Name: proto.String(instanceName),
			Disks: []*computepb.AttachedDisk{
				{
					InitializeParams: &computepb.AttachedDiskInitializeParams{
						DiskSizeGb:  proto.Int64(10),
						SourceImage: newestDebian.SelfLink,
						DiskType:    proto.String(fmt.Sprintf("zones/%s/diskTypes/pd-standard", zone)),
					},
					AutoDelete: proto.Bool(true),
					Boot:       proto.Bool(true),
					Type:       proto.String(computepb.AttachedDisk_PERSISTENT.String()),
				},
				{
					InitializeParams: &computepb.AttachedDiskInitializeParams{
						DiskSizeGb: proto.Int64(11),
						DiskType:   proto.String(fmt.Sprintf("zones/%s/diskTypes/pd-standard", zone)),
					},
					AutoDelete: proto.Bool(true),
					Boot:       proto.Bool(false),
					Type:       proto.String(computepb.AttachedDisk_PERSISTENT.String()),
				},
			},
			MachineType: proto.String(fmt.Sprintf("zones/%s/machineTypes/n1-standard-1", zone)),
			NetworkInterfaces: []*computepb.NetworkInterface{
				{
					Name: proto.String("global/networks/default"),
				},
			},
		},
	}

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

	return nil
}

Java

Bevor Sie dieses Beispiel verwenden, 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 der Compute Engine zu authentifizieren. Weitere Informationen finden Sie unter Authentifizierung für Clientbibliotheken einrichten. 


import com.google.api.gax.longrunning.OperationFuture;
import com.google.cloud.compute.v1.AttachedDisk;
import com.google.cloud.compute.v1.AttachedDisk.Type;
import com.google.cloud.compute.v1.AttachedDiskInitializeParams;
import com.google.cloud.compute.v1.Image;
import com.google.cloud.compute.v1.ImagesClient;
import com.google.cloud.compute.v1.InsertInstanceRequest;
import com.google.cloud.compute.v1.Instance;
import com.google.cloud.compute.v1.InstancesClient;
import com.google.cloud.compute.v1.NetworkInterface;
import com.google.cloud.compute.v1.Operation;
import java.io.IOException;
import java.util.Vector;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.TimeoutException;

public class CreateInstancesAdvanced {

  /**
   * Create an AttachedDisk object to be used in VM instance creation. Uses an image as the source
   * for the new disk.
   *
   * @param diskType the type of disk you want to create. This value uses the following format:
   * "zones/{zone}/diskTypes/(pd-standard|pd-ssd|pd-balanced|pd-extreme)". For example:
   * "zones/us-west3-b/diskTypes/pd-ssd"
   * @param diskSizeGb size of the new disk in gigabytes
   * @param boot boolean flag indicating whether this disk should be used as a boot disk of an
   * instance
   * @param sourceImage source image to use when creating this disk. You must have read access to
   * this disk. This can be one of the publicly available images or an image from one of your
   * projects. This value uses the following format:
   * "projects/{project_name}/global/images/{image_name}"
   * @return AttachedDisk object configured to be created using the specified image.
   */
  private static AttachedDisk diskFromImage(String diskType, int diskSizeGb, boolean boot,
      String sourceImage) {
    AttachedDisk disk =
        AttachedDisk.newBuilder()
            .setBoot(boot)
            // Remember to set auto_delete to True if you want the disk to be deleted when
            // you delete your VM instance.
            .setAutoDelete(true)
            .setType(Type.PERSISTENT.toString())
            .setInitializeParams(
                AttachedDiskInitializeParams.newBuilder()
                    .setSourceImage(sourceImage)
                    .setDiskSizeGb(diskSizeGb)
                    .setDiskType(diskType)
                    .build())
            .build();
    return disk;
  }


  /**
   * Create an AttachedDisk object to be used in VM instance creation. The created disk contains no
   * data and requires formatting before it can be used.
   *
   * @param diskType the type of disk you want to create. This value uses the following format:
   * "zones/{zone}/diskTypes/(pd-standard|pd-ssd|pd-balanced|pd-extreme)". For example:
   * "zones/us-west3-b/diskTypes/pd-ssd"
   * @param diskSizeGb size of the new disk in gigabytes
   * @return AttachedDisk object configured to be created as an empty disk.
   */
  private static AttachedDisk emptyDisk(String diskType, int diskSizeGb) {
    AttachedDisk disk =
        AttachedDisk.newBuilder()
            .setBoot(false)
            // Remember to set auto_delete to True if you want the disk to be deleted when
            // you delete your VM instance.
            .setAutoDelete(true)
            .setType(Type.PERSISTENT.toString())
            .setInitializeParams(
                AttachedDiskInitializeParams.newBuilder()
                    .setDiskSizeGb(diskSizeGb)
                    .setDiskType(diskType)
                    .build())
            .build();
    return disk;
  }

  /**
   * Send an instance creation request to the Compute Engine API and wait for it to complete.
   *
   * @param project project ID or project number of the Cloud project you want to use.
   * @param zone name of the zone to create the instance in. For example: "us-west3-b"
   * @param instanceName name of the new virtual machine (VM) instance.
   * @param disks a list of compute_v1.AttachedDisk objects describing the disks you want to attach
   * to your new instance.
   * @param machineType machine type of the VM being created. This value uses the following format:
   * "zones/{zone}/machineTypes/{type_name}".
   * For example: "zones/europe-west3-c/machineTypes/f1-micro"
   * @param network name of the network you want the new instance to use. For example:
   * "global/networks/default" represents the network named "default", which is created
   * automatically for each project.
   * @param subnetwork name of the subnetwork you want the new instance to use. This value uses the
   * following format: "regions/{region}/subnetworks/{subnetwork_name}"
   * @return Instance object.
   */
  private static Instance createWithDisks(String project, String zone, String instanceName,
      Vector<AttachedDisk> disks, String machineType, String network, String subnetwork)
      throws IOException, InterruptedException, ExecutionException, TimeoutException {
    try (InstancesClient instancesClient = InstancesClient.create()) {
      // Use the network interface provided in the networkName argument.
      NetworkInterface networkInterface;
      if (subnetwork != null) {
        networkInterface = NetworkInterface.newBuilder()
            .setName(network).setSubnetwork(subnetwork)
            .build();
      } else {
        networkInterface = NetworkInterface.newBuilder()
            .setName(network).build();
      }

      machineType = String.format("zones/%s/machineTypes/%s", zone, machineType);

      // Bind `instanceName`, `machineType`, `disk`, and `networkInterface` to an instance.
      Instance instanceResource =
          Instance.newBuilder()
              .setName(instanceName)
              .setMachineType(machineType)
              .addAllDisks(disks)
              .addNetworkInterfaces(networkInterface)
              .build();

      System.out.printf("Creating instance: %s at %s ", instanceName, zone);

      // Insert the instance in the specified project and zone.
      InsertInstanceRequest insertInstanceRequest = InsertInstanceRequest.newBuilder()
          .setProject(project)
          .setZone(zone)
          .setInstanceResource(instanceResource).build();

      OperationFuture<Operation, Operation> operation = instancesClient.insertAsync(
          insertInstanceRequest);

      // Wait for the operation to complete.
      Operation response = operation.get(3, TimeUnit.MINUTES);

      if (response.hasError()) {
        System.out.println("Instance creation failed ! ! " + response);
        return null;
      }
      System.out.println("Operation Status: " + response.getStatus());

      return instancesClient.get(project, zone, instanceName);
    }
  }

  /**
   * Create a new VM instance with Debian 11 operating system and a 11 GB additional empty disk.
   *
   * @param project project ID or project number of the Cloud project you want to use.
   * @param zone name of the zone to create the instance in. For example: "us-west3-b"
   * @param instanceName name of the new virtual machine (VM) instance.
   * @return Instance object.
   */
  public static Instance createWithAdditionalDisk(String project, String zone, String instanceName)
      throws IOException, InterruptedException, ExecutionException, TimeoutException {
    try (ImagesClient imagesClient = ImagesClient.create()) {
      // List of public operating system (OS) images: https://cloud.google.com/compute/docs/images/os-details
      Image image = imagesClient.getFromFamily("debian-cloud", "debian-11");
      String diskType = String.format("zones/%s/diskTypes/pd-standard", zone);
      Vector<AttachedDisk> disks = new Vector<>();
      disks.add(diskFromImage(diskType, 10, true, image.getSelfLink()));
      disks.add(emptyDisk(diskType, 11));
      return createWithDisks(project, zone, instanceName, disks, "n1-standard-1",
          "global/networks/default", null);
    }
  }

Node.js

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

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

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

// Create a new VM instance with Debian 10 operating system and a 11 GB additional empty disk.
async function createWithAdditionalDisk() {
  const instancesClient = new compute.InstancesClient();
  const imagesClient = new compute.ImagesClient();

  // List of public operating system (OS) images: https://cloud.google.com/compute/docs/images/os-details.
  const [newestDebian] = await imagesClient.getFromFamily({
    project: 'debian-cloud',
    family: 'debian-11',
  });

  const [response] = await instancesClient.insert({
    project: projectId,
    zone,
    instanceResource: {
      name: instanceName,
      disks: [
        {
          initializeParams: {
            diskSizeGb: '10',
            sourceImage: newestDebian.selfLink,
            diskType: `zones/${zone}/diskTypes/pd-standard`,
          },
          autoDelete: true,
          boot: true,
          type: 'PERSISTENT',
        },
        {
          initializeParams: {
            diskSizeGb: '11',
            diskType: `zones/${zone}/diskTypes/pd-standard`,
          },
          autoDelete: true,
          boot: false,
          type: 'PERSISTENT',
        },
      ],
      machineType: `zones/${zone}/machineTypes/n1-standard-1`,
      networkInterfaces: [
        {
          name: 'global/networks/default',
        },
      ],
    },
  });
  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 created.');
}

createWithAdditionalDisk();

Python

Bevor Sie dieses Beispiel verwenden, 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.

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

from __future__ import annotations

import re
import sys
from typing import Any
import warnings

from google.api_core.extended_operation import ExtendedOperation
from google.cloud import compute_v1


def get_image_from_family(project: str, family: str) -> compute_v1.Image:
    """
    Retrieve the newest image that is part of a given family in a project.

    Args:
        project: project ID or project number of the Cloud project you want to get image from.
        family: name of the image family you want to get image from.

    Returns:
        An Image object.
    """
    image_client = compute_v1.ImagesClient()
    # List of public operating system (OS) images: https://cloud.google.com/compute/docs/images/os-details
    newest_image = image_client.get_from_family(project=project, family=family)
    return newest_image


def disk_from_image(
    disk_type: str,
    disk_size_gb: int,
    boot: bool,
    source_image: str,
    auto_delete: bool = True,
) -> compute_v1.AttachedDisk:
    """
    Create an AttachedDisk object to be used in VM instance creation. Uses an image as the
    source for the new disk.

    Args:
         disk_type: the type of disk you want to create. This value uses the following format:
            "zones/{zone}/diskTypes/(pd-standard|pd-ssd|pd-balanced|pd-extreme)".
            For example: "zones/us-west3-b/diskTypes/pd-ssd"
        disk_size_gb: size of the new disk in gigabytes
        boot: boolean flag indicating whether this disk should be used as a boot disk of an instance
        source_image: source image to use when creating this disk. You must have read access to this disk. This can be one
            of the publicly available images or an image from one of your projects.
            This value uses the following format: "projects/{project_name}/global/images/{image_name}"
        auto_delete: boolean flag indicating whether this disk should be deleted with the VM that uses it

    Returns:
        AttachedDisk object configured to be created using the specified image.
    """
    boot_disk = compute_v1.AttachedDisk()
    initialize_params = compute_v1.AttachedDiskInitializeParams()
    initialize_params.source_image = source_image
    initialize_params.disk_size_gb = disk_size_gb
    initialize_params.disk_type = disk_type
    boot_disk.initialize_params = initialize_params
    # Remember to set auto_delete to True if you want the disk to be deleted when you delete
    # your VM instance.
    boot_disk.auto_delete = auto_delete
    boot_disk.boot = boot
    return boot_disk


def empty_disk(
    disk_type: str, disk_size_gb: int, boot: bool = False, auto_delete: bool = True
) -> compute_v1.AttachedDisk():
    """
    Create an AttachedDisk object to be used in VM instance creation. The created disk contains
    no data and requires formatting before it can be used.

    Args:
         disk_type: the type of disk you want to create. This value uses the following format:
            "zones/{zone}/diskTypes/(pd-standard|pd-ssd|pd-balanced|pd-extreme)".
            For example: "zones/us-west3-b/diskTypes/pd-ssd"
        disk_size_gb: size of the new disk in gigabytes
        boot: boolean flag indicating whether this disk should be used as a boot disk of an instance
        auto_delete: boolean flag indicating whether this disk should be deleted with the VM that uses it

    Returns:
        AttachedDisk object configured to be created as an empty disk.
    """
    disk = compute_v1.AttachedDisk()
    initialize_params = compute_v1.AttachedDiskInitializeParams()
    initialize_params.disk_type = disk_type
    initialize_params.disk_size_gb = disk_size_gb
    disk.initialize_params = initialize_params
    # Remember to set auto_delete to True if you want the disk to be deleted when you delete
    # your VM instance.
    disk.auto_delete = auto_delete
    disk.boot = boot
    return disk


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 create_instance(
    project_id: str,
    zone: str,
    instance_name: str,
    disks: list[compute_v1.AttachedDisk],
    machine_type: str = "n1-standard-1",
    network_link: str = "global/networks/default",
    subnetwork_link: str = None,
    internal_ip: str = None,
    external_access: bool = False,
    external_ipv4: str = None,
    accelerators: list[compute_v1.AcceleratorConfig] = None,
    preemptible: bool = False,
    spot: bool = False,
    instance_termination_action: str = "STOP",
    custom_hostname: str = None,
    delete_protection: bool = False,
) -> compute_v1.Instance:
    """
    Send an instance creation request to the Compute Engine API and wait for it to complete.

    Args:
        project_id: project ID or project number of the Cloud project you want to use.
        zone: name of the zone to create the instance in. For example: "us-west3-b"
        instance_name: name of the new virtual machine (VM) instance.
        disks: a list of compute_v1.AttachedDisk objects describing the disks
            you want to attach to your new instance.
        machine_type: machine type of the VM being created. This value uses the
            following format: "zones/{zone}/machineTypes/{type_name}".
            For example: "zones/europe-west3-c/machineTypes/f1-micro"
        network_link: name of the network you want the new instance to use.
            For example: "global/networks/default" represents the network
            named "default", which is created automatically for each project.
        subnetwork_link: name of the subnetwork you want the new instance to use.
            This value uses the following format:
            "regions/{region}/subnetworks/{subnetwork_name}"
        internal_ip: internal IP address you want to assign to the new instance.
            By default, a free address from the pool of available internal IP addresses of
            used subnet will be used.
        external_access: boolean flag indicating if the instance should have an external IPv4
            address assigned.
        external_ipv4: external IPv4 address to be assigned to this instance. If you specify
            an external IP address, it must live in the same region as the zone of the instance.
            This setting requires `external_access` to be set to True to work.
        accelerators: a list of AcceleratorConfig objects describing the accelerators that will
            be attached to the new instance.
        preemptible: boolean value indicating if the new instance should be preemptible
            or not. Preemptible VMs have been deprecated and you should now use Spot VMs.
        spot: boolean value indicating if the new instance should be a Spot VM or not.
        instance_termination_action: What action should be taken once a Spot VM is terminated.
            Possible values: "STOP", "DELETE"
        custom_hostname: Custom hostname of the new VM instance.
            Custom hostnames must conform to RFC 1035 requirements for valid hostnames.
        delete_protection: boolean value indicating if the new virtual machine should be
            protected against deletion or not.
    Returns:
        Instance object.
    """
    instance_client = compute_v1.InstancesClient()

    # Use the network interface provided in the network_link argument.
    network_interface = compute_v1.NetworkInterface()
    network_interface.network = network_link
    if subnetwork_link:
        network_interface.subnetwork = subnetwork_link

    if internal_ip:
        network_interface.network_i_p = internal_ip

    if external_access:
        access = compute_v1.AccessConfig()
        access.type_ = compute_v1.AccessConfig.Type.ONE_TO_ONE_NAT.name
        access.name = "External NAT"
        access.network_tier = access.NetworkTier.PREMIUM.name
        if external_ipv4:
            access.nat_i_p = external_ipv4
        network_interface.access_configs = [access]

    # Collect information into the Instance object.
    instance = compute_v1.Instance()
    instance.network_interfaces = [network_interface]
    instance.name = instance_name
    instance.disks = disks
    if re.match(r"^zones/[a-z\d\-]+/machineTypes/[a-z\d\-]+$", machine_type):
        instance.machine_type = machine_type
    else:
        instance.machine_type = f"zones/{zone}/machineTypes/{machine_type}"

    instance.scheduling = compute_v1.Scheduling()
    if accelerators:
        instance.guest_accelerators = accelerators
        instance.scheduling.on_host_maintenance = (
            compute_v1.Scheduling.OnHostMaintenance.TERMINATE.name
        )

    if preemptible:
        # Set the preemptible setting
        warnings.warn(
            "Preemptible VMs are being replaced by Spot VMs.", DeprecationWarning
        )
        instance.scheduling = compute_v1.Scheduling()
        instance.scheduling.preemptible = True

    if spot:
        # Set the Spot VM setting
        instance.scheduling.provisioning_model = (
            compute_v1.Scheduling.ProvisioningModel.SPOT.name
        )
        instance.scheduling.instance_termination_action = instance_termination_action

    if custom_hostname is not None:
        # Set the custom hostname for the instance
        instance.hostname = custom_hostname

    if delete_protection:
        # Set the delete protection bit
        instance.deletion_protection = True

    # Prepare the request to insert an instance.
    request = compute_v1.InsertInstanceRequest()
    request.zone = zone
    request.project = project_id
    request.instance_resource = instance

    # Wait for the create operation to complete.
    print(f"Creating the {instance_name} instance in {zone}...")

    operation = instance_client.insert(request=request)

    wait_for_extended_operation(operation, "instance creation")

    print(f"Instance {instance_name} created.")
    return instance_client.get(project=project_id, zone=zone, instance=instance_name)


def create_with_additional_disk(
    project_id: str, zone: str, instance_name: str
) -> compute_v1.Instance:
    """
    Create a new VM instance with Debian 10 operating system on a 20 GB disk
    and a 25 GB additional empty disk.

    Args:
        project_id: project ID or project number of the Cloud project you want to use.
        zone: name of the zone to create the instance in. For example: "us-west3-b"
        instance_name: name of the new virtual machine (VM) instance.

    Returns:
        Instance object.
    """
    newest_debian = get_image_from_family(project="debian-cloud", family="debian-12")
    disk_type = f"zones/{zone}/diskTypes/pd-standard"
    disks = [
        disk_from_image(disk_type, 20, True, newest_debian.self_link),
        empty_disk(disk_type, 25),
    ]
    instance = create_instance(project_id, zone, instance_name, disks)
    return instance

REST

Sie können beim Erstellen einer Instanz bis zu 127 Nicht-Bootlaufwerke erstellen. Geben Sie dazu für jedes zusätzliche Laufwerk das Attribut initializeParams an. Sie können zusätzliche Laufwerke mit einem öffentlichen oder mit einem privaten Image erstellen. Wenn Sie ein leeres Laufwerk erstellen möchten, geben Sie für den Eintrag initializeParams keinen sourceImage-Wert an. Fügen Sie das Laufwerksattribut replicaZones ein, um regionale Laufwerke anstelle von zonalen Laufwerken zu erstellen.

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

{
   "machineType":"zones/MACHINE_TYPE_ZONE/machineTypes/MACHINE_TYPE",
   "name":"VM_NAME",
   
   "disks":[
      {
         "initializeParams":{
            "sourceImage":"projects/IMAGE_PROJECT/global/images/IMAGE"
         },
         "boot":true
      },
      {
         "initializeParams":{
            "diskSizeGb":"SIZE_GB",
            "sourceImage":"projects/DISK_IMAGE_PROJECT/global/images/DISK_IMAGE",
            "diskType":"DISK_TYPE"
         }
      },
      {
         "initializeParams":{
            "diskSizeGb":"SIZE_GB",
            "diskType":"DISK_TYPE"
         },
      },
      {
         "boot": false,
         "deviceName":"DISK_NAME",
         "initializeParams": {
            "diskType": "DISK_TYPE",
            "replicaZones": [
               "projects/PROJECT_ID/zones/ZONE",
               "projects/PROJECT_ID/zones/REMOTE_ZONE"
            ]
         }
      }
   ],
   
   
   "networkInterfaces":[
      {
         "network":"global/networks/NETWORK_NAME"
      }
   ],
   
  
   "shieldedInstanceConfig":{
      "enableSecureBoot":"ENABLE_SECURE_BOOT"
   }
}

Ersetzen Sie Folgendes:

  • PROJECT_ID: Die ID des Projekts, in dem die VM erstellt werden soll.
  • ZONE: Die Zone, in der die VM erstellt werden soll.
  • MACHINE_TYPE_ZONE: Die Zone mit dem Maschinentyp, der für die neue VM verwendet werden soll.
  • MACHINE_TYPE: Der Maschinentyp für die neue VM, entweder vordefiniert oder benutzerdefiniert.
  • VM_NAME ist der Name der neuen VM.
  • IMAGE_PROJECT: Projekt, das das Image enthält
    Wenn Sie beispielsweise debian-10 als Image-Familie angeben, geben Sie debian-cloud als Image-Projekt an.
  • IMAGE: Geben Sie eine der folgenden Optionen an:

    • IMAGE: Eine bestimmte Version eines öffentlichen Images

      Beispiel: "sourceImage": "projects/debian-cloud/global/images/debian-10-buster-v20200309"

    • IMAGE_FAMILY ist eine Image-Familie.

      Dadurch wird die VM aus dem neuesten nicht verworfenen Betriebssystem-Image erstellt. Wenn Sie beispielsweise "sourceImage": "projects/debian-cloud/global/images/family/debian-10" angeben, erstellt Compute Engine eine VM aus der neuesten Version des Betriebssystem-Images in der Debian 10-Image-Familie.

  • Ersetzen Sie für zusätzliche Laufwerke folgende Optionen:

    • SIZE_GB ist die Laufwerkgröße.
    • DISK_IMAGE oder
    • DISK_IMAGE_FAMILY: Geben Sie entweder ein Quell-Image oder eine Image-Familie für das Nicht-Bootlaufwerk an:
      • DISK_IMAGE: Der Name des Images, das Sie als Nicht-Bootlaufwerk verwenden möchten. Beispiel: "sourceImage": "projects/DISK_IMAGE_PROJECT/global/images/DISK_IMAGE".
      • DISK_IMAGE_FAMILY: Eine Image-Familie, die als Nicht-Bootlaufwerk verwendet werden soll. Beispiel: "sourceImage": "projects/DISK_IMAGE_PROJECT/global/images/family/DISK_IMAGE_FAMILY".
    • DISK_TYPE: Vollständige oder partielle URL für den Typ des Laufwerktyps. Beispiel: https://www.googleapis.com/compute/v1/projects/PROJECT_ID/zones/ZONE/diskTypes/hyperdisk-balanced Der Maschinentyp muss den Laufwerkstyp unterstützen.
    • DISK_NAME: Optional. Der Laufwerkname, der dem Gastbetriebssystem nach dem Erstellen der VM angezeigt wird.

    • REMOTE_ZONE: die Zone, in die das regionale Laufwerk repliziert werden soll

    Bei leeren Laufwerken geben Sie nicht Attribut sourceImage nicht an.

    Bei zonalen Laufwerken geben Sie das Attribut replicaZones nicht an.

  • NETWORK_NAME: Das VPC-Netzwerk, das Sie für die VM verwenden möchten. Sie können default angeben, um Ihr Standardnetzwerk zu verwenden.

  • ENABLE_SECURE_BOOT: (Optional) Wenn Sie ein Image ausgewählt haben, das Shielded VM-Funktionen unterstützt, aktiviert Compute Engine standardmäßig das Virtual Trusted Platform Module (vTPM) und das Integritätsmonitoring. Compute Engine aktiviert nicht standardmäßig Secure Boot.

    Wenn Sie den Wert true für enableSecureBoot angeben, erstellt Compute Engine eine VM, bei der alle drei Shielded VM-Features aktiviert sind. Nachdem Compute Engine Ihre VM gestartet hat, müssen Sie die VM beenden, um Shielded VM-Optionen zu ändern.

Nachdem Sie die Instanz erstellt haben, müssen Sie alle leeren Laufwerke formatieren und alle Laufwerke bereitstellen, bevor Sie sie verwenden können.