Diese Seite wurde von der Cloud Translation API übersetzt.

Instanz mit zusätzlichen Nicht-Bootlaufwerken erstellen

Wenn Sie eine Compute-Instanz erstellen, können Sie gleichzeitig auch zusätzliche Nicht-Bootlaufwerke erstellen und an die Instanz anhängen. Sie können auch vorhandene Laufwerke auswählen, die als Nicht-Bootlaufwerke angehängt werden sollen.

Wenn Sie ein Laufwerk im Modus für mehrere Autoren erstellen möchten, können Sie es nicht gleichzeitig mit der Instanz erstellen. Sie müssen zuerst das Laufwerk erstellen und es dann an die Instanz anhängen.

Hinweise

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. Zum Ausführen von Code oder Beispielen aus einer lokalen Entwicklungsumgebung können Sie sich so bei der Compute Engine authentifizieren:
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.
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.
  
  Hinweis: Wenn Sie die gcloud CLI zuvor installiert haben, prüfen Sie, ob Sie die aktuelle Version haben, indem Sie gcloud components update ausführen.
2. Set a default region and zone.
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.
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 neues Laufwerk für die Instanz: compute.disks.create für das Projekt

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

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

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.
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. 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.
3. 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
4. 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.
5. Wählen Sie im Abschnitt Maschinentyp den Maschinentyp für Ihre Instanz aus.
Klicken Sie im Navigationsmenü auf Betriebssystem und Speicher. Führen Sie im angezeigten Bereich Betriebssystem und Speicher die folgenden Schritte aus.

Weitere Informationen zu den Parametern, die Sie beim Hinzufügen neuer Laufwerke konfigurieren können, finden Sie unter Informationen zu Persistent Disk und Informationen zu Google Cloud Hyperdisk.
1. Klicken Sie auf Ändern, um Ihr Bootlaufwerk zu konfigurieren. Der Bereich Bootlaufwerk wird angezeigt und enthält den Tab Öffentliche Images.
2. Konfigurieren Sie die Datenquelle für das Bootlaufwerk auf eine der folgenden Arten:
  
  Hinweis: Wenn Sie nicht explizit ein anderes Bootlaufwerk auswählen und der Name der neuen Instanz mit dem Namen eines vorhandenen Laufwerks übereinstimmt, wird das vorhandene Laufwerk automatisch der neuen Instanz als Bootlaufwerk hinzugefügt.
  - 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 Ihre Startdiskette 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, der angezeigt wird, in der Liste Laufwerk ein vorhandenes regionales Persistent Disk- oder Hyperdisk Balanced High Availability-Volume aus.
3. Optional: Erweitern Sie für erweiterte Konfigurationsoptionen den Abschnitt Erweiterte Konfigurationen einblenden.
4. Klicken Sie auf Auswählen, um die Bootlaufwerksoptionen zu bestätigen und zum Bereich Betriebssystem und Speicher zurückzukehren.
5. Wenn Sie ein neues Nicht-Bootlaufwerk erstellen und an Ihre Instanz anhängen möchten, klicken Sie im Abschnitt Zusätzlicher Speicher und VM-Back-ups auf Neues Laufwerk hinzufügen.
  
  Führen Sie im angezeigten Bereich Neues Laufwerk hinzufügen die folgenden Schritte aus:
  1. Geben Sie im Feld Name einen Namen für das Nicht-Boot-Laufwerk an.
  2. Wählen Sie in der Liste Quelltyp den Quelltyp für das Nicht-Bootlaufwerk aus.
  3. Wählen Sie in der Liste Laufwerkstyp einen Typ für das Nicht-Bootlaufwerk aus.
  4. Geben Sie im Feld Größe die Größe des Nicht-Bootlaufwerks an.
  5. Führen Sie im Abschnitt Einstellungen für Anhänge die folgenden Schritte aus:
  6. Wählen Sie im Feld Modus den Modus für die Laufwerkanbringung aus.
  7. Wählen Sie im Feld Löschregel eine Option aus, um festzulegen, was mit dem Laufwerk geschieht, wenn die Instanz gelöscht wird.
  Wiederholen Sie diesen Schritt für jedes Nicht-Bootlaufwerk, das Sie erstellen und an Ihre Instanz anhängen möchten.
Klicken Sie im Navigationsmenü auf Datenschutz. Geben Sie im angezeigten Bereich Datenschutz an, wie Sie die Daten für Ihre Instanz sichern und replizieren möchten. Gehen Sie dazu so vor:

Achtung :Die Einstellungen für Datensicherung und Replikation, die Sie beim Erstellen einer Instanz über die Google Cloud Konsole angeben, werden nur angewendet, wenn die von Ihnen ausgewählten Instanz- und Laufwerkskonfigurationen diese Optionen unterstützen. Sie müssen prüfen, ob Ihre Konfiguration für die Instanz und jede Festplatte die Anforderungen für jede von Ihnen angegebene Datenschutzoption erfüllt. Weitere Informationen finden Sie unter Datenschutzoptionen.
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.
  Wichtig :Das Kästchen Regionale Datenträger wirkt sich nicht auf vorhandene Datenträger aus. Wenn Sie einen vorhandenen zonalen Speicher in einen regionalen Speicher ändern möchten, lesen Sie stattdessen Zonalen Speicher in einen regionalen Speicher ändern.
  1. Wenn Sie möchten, dass die Laufwerke für die Instanz in einer zweiten Region mit der asynchronen Replikation für Persistent Disks repliziert werden, wählen Sie das Kästchen Asynchrone Replikation aus.
3. Wenn Sie die angegebenen Datenschutzoptionen nur auf Nicht-Bootlaufwerke anwenden möchten, wählen Sie das Kästchen Bootlaufwerke ausschließen aus.
  
  Wichtig :Diese Option hat keine Auswirkungen auf Sicherungspläne, bei denen Bootlaufwerke nicht ausgeschlossen werden können.
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.
Optional: Geben Sie weitere Konfigurationsoptionen an. Weitere Informationen finden Sie unter Konfigurationsoptionen beim Erstellen von Instanzen.
Klicken Sie zum Erstellen und Starten der Instanz auf Erstellen.

gcloud

In the Google Cloud console, activate Cloud Shell.

Activate Cloud Shell

At the bottom of the Google Cloud console, a Cloud Shell session starts and displays a command-line prompt. Cloud Shell is a shell environment with the Google Cloud CLI already installed and with values already set for your current project. It can take a few seconds for the session to initialize.
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.

Optional können Sie Attribute für Folgendes einfügen:
- 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 \
    --image-project=IMAGE_PROJECT \
    IMAGE_FLAG \
    --create-disk DISK_IMAGE,image-project=DISK_IMAGE_PROJECT,size=SIZE_GB,type=DISK_TYPE \
    --create-disk device-name=DISK_NAME,replica-zones=^:^ZONE:REMOTE-ZONE,boot=false
```
Ersetzen Sie Folgendes:
- INSTANCE_NAME: Name der neuen Instanz
- ZONE: Die Zone, in der die Instanz erstellt werden soll
- IMAGE_PROJECT ist das Projekt, das das Image enthält.
- 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_IMAGE: Geben Sie eine der folgenden Optionen an:
    - image=DISK_IMAGE_NAME: Name des Images, das Sie beim Erstellen eines Nicht-Bootlaufwerks verwenden möchten.
    - image-family=DISK_IMAGE_FAMILY>: Eine Image-Familie, die beim Erstellen eines Nicht-Bootlaufwerks verwendet werden soll.
  - DISK_IMAGE_PROJECT ist ein Image-Projekt, zu dem das Laufwerk-Image gehört.
  - SIZE_GB (optional): die Größe des Nicht-Bootlaufwerks.
  - DISK_TYPE (optional): die vollständige oder partielle URL für den Typ des Laufwerks.
    
    Beispiel: https://www.googleapis.com/compute/v1/projects/PROJECT_ID/zones/ZONE/diskTypes/hyperdisk-balanced. Verwenden Sie den Befehl gcloud compute disk-types list --zones=ZONE_LIST, um die verfügbaren Laufwerkstypen in einer oder mehreren Zonen aufzurufen. Ersetzen Sie ZONE_LIST durch eine durch Kommas getrennte Liste von Zonen.
  - DISK_NAME: Optional; der Laufwerkname, der dem Gastbetriebssystem nach dem Erstellen der Instanz angezeigt wird.
  - REMOTE_ZONE: Die Zone, in der das Laufwerk repliziert werden soll
  Bei leeren Laufwerken geben Sie die Parameter image, image-project oder image-family nicht an.
  
  Bei zonalen Laufwerken geben Sie nicht Laufwerksattribut replica-zones an.

Terraform

Zum Generieren des Terraform-Codes können Sie die Komponente Entsprechender Code in der Google Cloud Console verwenden.

Rufen Sie in der Google Cloud Console die Seite VM-Instanzen auf.
Zur Seite „VM-Instanzen“
Klicken Sie auf Instanz erstellen.
Geben Sie die gewünschten Parameter an.
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 eine lokale Entwicklungsumgebung 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.


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.

/**
 * 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.

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

Formatieren und stellen Sie die Laufwerke bereit, bevor Sie sie verwenden.

Instanz mit zusätzlichen Nicht-Bootlaufwerken erstellen Mit Sammlungen den Überblick behalten Sie können Inhalte basierend auf Ihren Einstellungen speichern und kategorisieren.

Hinweise

Console

gcloud

REST

Erforderliche Rollen

Erforderliche Berechtigungen

Instanz mit neuen zusätzlichen Nicht-Bootlaufwerken erstellen

Console

gcloud

Terraform

Go

Java

Node.js

Python

REST

Instanz mit zusätzlichen Nicht-Bootlaufwerken erstellen