Instanzvorlagen erstellen

---

Auf dieser Seite wird das Erstellen und Verwalten von Instanzvorlagen beschrieben. Mit Instanzvorlagen können Sie den Maschinentyp, das Bootlaufwerk-Image, das Netzwerk und andere VM-Attribute angeben, die Sie beim Erstellen von VM-Instanzen verwenden möchten.

Mit Instanzvorlagen haben Sie folgende Möglichkeiten:

• Erstellen Sie einzelne VMs.
• Erstellen Sie VMs in einer verwalteten Instanzgruppe (MIG).
• Erstellen Sie Reservierungen für VMs.
• Erstellen Sie zukünftige Reservierungen für VMs.

Hinweise

• Lesen Sie, wann und warum Sie deterministische Instanzvorlagen erstellen müssen.
• Erfahren Sie mehr über Regionale und globale Instanzvorlagen.
• 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 wie folgt bei 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. Install the Google Cloud CLI, then initialize it by running the following command:

     gcloud init

     Note: If you installed the gcloud CLI previously, make sure you have the latest version by running gcloud components update.
  2. Set a default region and zone.

  Terraform

  Wenn Sie die Terraform-Beispiele auf dieser Seite in einer lokalen Entwicklungsumgebung verwenden möchten, installieren und initialisieren Sie die gcloud CLI und richten dann die Standardanmeldedaten für Anwendungen mit Ihren Nutzeranmeldedaten ein.

  1. Install the Google Cloud CLI.

  2. To initialize the gcloud CLI, run the following command:

     gcloud init

  3. If you're using a local shell, then create local authentication credentials for your user account:

     gcloud auth application-default login

     You don't need to do this if you're using Cloud Shell.

  Weitere Informationen unter Set up authentication for a local development environment.

  Go

  Wenn Sie die Go Beispiele auf dieser Seite in einer lokalen Entwicklungsumgebung verwenden möchten, installieren und initialisieren Sie die gcloud CLI und richten dann die Standardanmeldedaten für Anwendungen mit Ihren Nutzeranmeldedaten ein.

  1. Install the Google Cloud CLI.

  2. To initialize the gcloud CLI, run the following command:

     gcloud init

  3. If you're using a local shell, then create local authentication credentials for your user account:

     gcloud auth application-default login

     You don't need to do this if you're using Cloud Shell.

  Weitere Informationen unter Set up authentication for a local development environment.

  Java

  Wenn Sie die Java Beispiele auf dieser Seite in einer lokalen Entwicklungsumgebung verwenden möchten, installieren und initialisieren Sie die gcloud CLI und richten dann die Standardanmeldedaten für Anwendungen mit Ihren Nutzeranmeldedaten ein.

  1. Install the Google Cloud CLI.

  2. To initialize the gcloud CLI, run the following command:

     gcloud init

  3. If you're using a local shell, then create local authentication credentials for your user account:

     gcloud auth application-default login

     You don't need to do this if you're using Cloud Shell.

  Weitere Informationen unter Set up authentication for a local development environment.

  Node.js

  Wenn Sie die Node.js Beispiele auf dieser Seite in einer lokalen Entwicklungsumgebung verwenden möchten, installieren und initialisieren Sie die gcloud CLI und richten dann die Standardanmeldedaten für Anwendungen mit Ihren Nutzeranmeldedaten ein.

  1. Install the Google Cloud CLI.

  2. To initialize the gcloud CLI, run the following command:

     gcloud init

  3. If you're using a local shell, then create local authentication credentials for your user account:

     gcloud auth application-default login

     You don't need to do this if you're using Cloud Shell.

  Weitere Informationen unter Set up authentication for a local development environment.

  Python

  Wenn Sie die Python Beispiele auf dieser Seite in einer lokalen Entwicklungsumgebung verwenden möchten, installieren und initialisieren Sie die gcloud CLI und richten dann die Standardanmeldedaten für Anwendungen mit Ihren Nutzeranmeldedaten ein.

  1. Install the Google Cloud CLI.

  2. To initialize the gcloud CLI, run the following command:

     gcloud init

  3. If you're using a local shell, then create local authentication credentials for your user account:

     gcloud auth application-default login

     You don't need to do this if you're using Cloud Shell.

  Weitere Informationen unter Set up authentication for a local development environment.

  REST

  Verwenden Sie die von der gcloud CLI bereitgestellten Anmeldedaten, um die REST API-Beispiele auf dieser Seite in einer lokalen Entwicklungsumgebung zu verwenden.

  Install the Google Cloud CLI, then initialize it by running the following command:

  gcloud init

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

Beschränkungen

• Eine freigegebene VPC auf anderen Schnittstellen als nic0 für Instanzvorlagen wird in der gcloud CLI und in REST unterstützt, jedoch nicht in der Cloud Console.
• Nach der Erstellung können Sie vorhandene Instanzvorlage weder aktualisieren noch ändern. Wenn eine Instanzvorlage nicht mehr aktuell ist oder Sie Änderungen an der Konfiguration vornehmen müssen, erstellen Sie eine neue Instanzvorlage.
• Wenn Sie eine Image-Familie in einer Instanzvorlage angeben möchten, können Sie die Google Cloud Console nicht verwenden. Sie können stattdessen die Google Cloud CLI oder REST verwenden.
• Wenn Sie regionalen nichtflüchtigen Speicher in einer Instanzvorlage angeben möchten, können Sie die Google Cloud Console nicht verwenden. Sie können stattdessen das Google Cloud CLI oder REST verwenden.

Instanzvorlage erstellen

Die meisten VM-Attribute, die Sie in einer Anfrage zum Erstellen einer einzelnen VM-Instanz angeben können, lassen sich auch für eine Instanzvorlage angeben, z. B. beliebige Instanzmetadaten, Startskripts, nichtflüchtiger Speicher, Dienstkonten und so weiter. Sie müssen den Maschinentyp, das Bootlaufwerk und das Netzwerk angeben.

Erstellen Sie eine regionale oder globale Instanzvorlage über die Google Cloud Console, die Google Cloud CLI oder die API. Zum Erstellen einer globalen Instanzvorlage können Sie auch Terraform oder die Cloud-Clientbibliotheken nutzen.

Erforderliche Berechtigungen für diese Aufgabe

Zum Ausführen dieser Aufgabe benötigen Sie die folgenden Berechtigungen:

• Alle Berechtigungen, die zum Aufrufen der Methode instanceTemplates.insert erforderlich sind.

Console

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

   Zu Instanzvorlagen

   Die verbleibenden Schritte werden automatisch in der Google Cloud Console angezeigt.

2. Klicken Sie auf Instanzvorlage erstellen.
3. Wählen Sie den Standort so aus:
1. Wenn Sie die Instanzvorlage regionenübergreifend verwenden möchten, wählen Sie Global.
2. Wenn Sie die regionsübergreifende Abhängigkeit reduzieren möchten, wählen Sie Regional.
4. Wenn Sie "Regional" ausgewählt haben, wählen Sie die Region, in der Sie die Instanzvorlage erstellen möchten.

5. Übernehmen Sie für die folgenden Felder die Standardwerte oder ändern Sie sie je nach Bedarf. Die Standardwerte ändern sich je nach ausgewählter Maschinenfamilie.

   • Wählen Sie einen Maschinentyp aus.
   • Klicken Sie im Abschnitt Bootlaufwerk auf Ändern, um den Bootlaufwerkstyp oder das Bootlaufwerk-Image zu aktualisieren.
   • Klicken Sie zum Aktualisieren der Netzwerkschnittstellen- oder IP-Adresseinstellungen auf Erweiterte Optionen, dann auf Netzwerk und dann auf die Netzwerkschnittstelle, die Sie bearbeiten möchten.

6. Optional: Wenn Sie ein Image ausgewählt haben, das Shielded VM unterstützt, ändern Sie die Einstellungen der VM für Shielded VM:

   1. Klicken Sie auf Erweiterte Optionen und dann auf den Tab Sicherheit.
   2. Wenn Sie Secure Boot deaktivieren möchten, entfernen Sie das Häkchen bei Secure Boot aktivieren. Mit Secure Boot können Sie Ihre VM-Instanzen besser vor Malware und Rootkits auf Boot- und Kernelebene schützen. Weitere Informationen finden Sie unter Secure Boot.

   3. Wenn Sie das Virtual Trusted Platform Module (vTPM) deaktivieren möchten, entfernen Sie das Häkchen bei vTPM aktivieren. Durch das vTPM wird Measured Boot aktiviert, das die Integrität der VM vor und während des Startens überprüft. Weitere Informationen finden Sie unter Virtual Trusted Platform Module (vTPM).

      Wichtig: Beim Deaktivieren des vTPM wird auch die Integritätsüberwachung deaktiviert, da dies auf Daten basiert, die von Measured Boot erfasst werden.

   4. Wenn Sie die Integritätsüberwachung deaktivieren möchten, entfernen Sie das Häkchen bei Integritätsüberwachung aktivieren. Mit der Integritätsüberwachung können Sie die Integrität beim Starten Ihrer Shielded VM-Instanzen mithilfe von Cloud Monitoring überwachen. Weitere Informationen finden Sie unter Integritätsüberwachung.

7. Optional: Klicken Sie unter Erweiterte Optionen auf die Tabs, um Ihre Vorlage weiter anzupassen. Dort können Sie z. B. bis zu 15 sekundäre Nicht-Bootlaufwerke hinzufügen.

8. Optional: Klicken Sie auf Entsprechende REST-Anfrage, um den REST-Anfragetext aufzurufen, der die JSON-Darstellung Ihrer Instanzvorlage enthält.

9. Klicken Sie auf Erstellen, um die Vorlage anzulegen.

gcloud

Verwenden Sie zum Erstellen einer regionalen oder globalen Instanzvorlage den instance-templates create-Befehl: Bei einer regionalen Instanzvorlage müssen Sie mit dem --instance-template-region-Flag die Region der Vorlage festlegen.

Erstellen Sie mit folgendem Befehl eine regionale Instanzvorlage:

gcloud compute instance-templates create INSTANCE_TEMPLATE_NAME \
    --instance-template-region=REGION

Erstellen Sie mit folgendem Befehl eine globale Instanzvorlage:

gcloud compute instance-templates create INSTANCE_TEMPLATE_NAME

Wenn Sie die Vorlageneinstellungen nicht explizit angeben, verwendet gcloud compute die folgenden Standardwerte:

• Maschinentyp: der Maschinentyp, z. B. n1-standard-1.
• Image: Das neueste Debian-Image
• Bootlaufwerk: Ein neues Standardbootlaufwerk mit dem gleichen Namen wie die VM
• Netzwerk: Das Standard-VPC-Netzwerk
• IP-Adresse: Eine sitzungsspezifische externe IP-Adresse

Sie können diese Konfigurationseinstellungen auch explizit festlegen. Beispiel:

gcloud compute instance-templates create example-template-custom \
    --machine-type=e2-standard-4 \
    --image-family=debian-10 \
    --image-project=debian-cloud \
    --boot-disk-size=250GB

Sie können bis zu 15 sekundäre Nicht-Bootlaufwerke hinzufügen. Geben Sie das Flag --create-disk für jedes erstellte sekundäre Laufwerk an. Wenn Sie sekundäre Laufwerke aus einem öffentlichen oder benutzerdefinierten Image erstellen möchten, geben Sie im Flag --create-disk pro Laufwerk die Attribute image und image-project an. Wenn Sie diese Attribute nicht angeben, wird ein leeres Laufwerk erstellt. Fügen Sie optional Attribute für das Laufwerk size und type hinzu. Verwenden Sie das Attribut replica-zones, um regionale nichtflüchtige Speicher anzugeben.

gcloud compute instance-templates create INSTANCE_TEMPLATE_NAME \
    --create-disk= \
        image-family=DISK_IMAGE_FAMILY, \
        image-project=DISK_IMAGE_PROJECT, \
        size=SIZE_GB_DISK1 \
    --create-disk= \
        device-name=DISK_NAME,type=DISK_TYPE, \
        size=SIZE_GB_DISK2 \
        replica-zones=^:^ZONE:REMOTE_ZONE, \
        boot=false

Tipp: Bei der Angabe der Laufwerkparameter geben die Zeichen ^:^ an, dass das Trennzeichen zwischen Werten ein Doppelpunkt (:) statt des erwarteten Kommas (,) ist.

Ersetzen Sie Folgendes:

• INSTANCE_TEMPLATE_NAME ist der Name der Vorlage.
• REGION: Region, in der Sie die regionale Instanzvorlage erstellen möchten.

• IMAGE_FAMILY: Eine Image-Familie, die als Nicht-Bootlaufwerk verwendet werden soll.

  Weitere Informationen zu Image-Familien finden Sie unter Best Practices für die Verwendung von Image-Familien in Compute Engine.

  Sie können stattdessen das Flag --image=IMAGE verwenden, um eine bestimmte Version eines Images anzugeben.

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

• DISK_IMAGE_PROJECT: Das Image-Projekt, das das Image enthält

  Bei leeren Laufwerken geben Sie nicht Attribut image-project nicht an. Weitere Informationen zu öffentlichen Images finden Sie unter Öffentliche Images.

• SIZE_GB_DISK1 und SIZE_GB_DISK2: Größe der einzelnen sekundären Laufwerke.

• DISK_NAME: Optional; der Laufwerkname, der dem Gastbetriebssystem nach dem Erstellen der VM angezeigt wird.

• DISK_TYPE: Optional; der zu erstellende Laufwerkstyp. Wenn keine Angabe erfolgt, wird je nach Maschinentyp pd-standard oder pd-balanced verwendet.

• ZONE und REMOTE_ZONE: Zone, in der der regionale Persistent Disk-Speicher erstellt werden soll, und die Zone, in der er repliziert werden soll.

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

Wenn Sie ein Image ausgewählt haben, das Shielded VM unterstützt, können Sie optional die Shielded VM-Einstellungen der Instanz mit einem der folgenden Flags ändern:

• --no-shielded-secure-boot: Secure Boot deaktivieren

  Mit Secure Boot können Sie Ihre VM-Instanzen vor Malware und Rootkits auf Boot- und Kernelebene schützen. Weitere Informationen finden Sie unter Secure Boot.

• --no-shielded-vtpm: Deaktiviert das Virtual Trusted Platform Module (vTPM)

  Durch das vTPM wird Measured Boot aktiviert, das die Integrität der VM vor und während des Startens überprüft. Weitere Informationen finden Sie unter Virtual Trusted Platform Module (vTPM).

  Wichtig: Beim Deaktivieren des vTPM wird auch die Integritätsüberwachung deaktiviert, da diese auf Daten basiert, die von Measured Boot erfasst werden.

• --no-shielded-integrity-monitoring: Deaktiviert die Integritätsüberwachung

  Mit dem Integritätsmonitoring können Sie die Integrität beim Booten Ihrer Shielded VM-Instanzen mithilfe von Cloud Monitoring beobachten. Weitere Informationen finden Sie unter Integritätsüberwachung.

Eine Liste aller verfügbaren Unterbefehle und Flags finden Sie in der Referenz zu instance-templates.

Eine Vorlage mit den Einstellungen für die Standardkonfiguration könnte wie folgt aussehen:

gcloud compute instance-templates describe example-template

creationTimestamp: '2019-09-10T16:18:32.042-07:00'
description: ''
id: '6057583701980539406'
kind: compute#instanceTemplate
name: example-template
properties:
  canIpForward: false
  disks:
  - autoDelete: true
    boot: true
    initializeParams:
      sourceImage: https://compute.googleapis.com/compute/v1/projects/debian-cloud/global/images/family/debian-10
    kind: compute#attachedDisk
    mode: READ_WRITE
    type: PERSISTENT
  machineType: e2-standard-2
  networkInterfaces:
  - accessConfigs:
    - kind: compute#accessConfig
      name: external-nat
      type: ONE_TO_ONE_NAT
    network: https://compute.googleapis.com/compute/v1/projects/myproject/global/networks/default
  scheduling:
    automaticRestart: true
    onHostMaintenance: MIGRATE
  serviceAccounts:
  - email: default
    scopes:
    - https://www.googleapis.com/auth/devstorage.read_only
selfLink: https://compute.googleapis.com/compute/v1/projects/myproject/global/instanceTemplates/example-template

Terraform

Zum Erstellen einer Instanzvorlage können Sie die Ressource google_compute_instance_template verwenden.

Das folgende Terraform-Beispiel ähnelt dem folgenden gcloud CLI-Befehl:

gcloud compute instance-templates create my-instance-template \
    --machine-type=e2-standard-4 \
    --image-family=debian-9 \
    --image-project=debian-cloud \
    --boot-disk-size=250GB

compute/region_autoscaler_basic/main.tf

Auf GitHub ansehen Feedback

resource "google_compute_instance_template" "foobar" {
  name         = "my-instance-template"
  machine_type = "e2-standard-4"

  disk {
    source_image = "debian-cloud/debian-11"
    disk_size_gb = 250
  }

  network_interface {
    network = "default"

    # default access config, defining external IP configuration
    access_config {
      network_tier = "PREMIUM"
    }
  }

  # To avoid embedding secret keys or user credentials in the instances, Google recommends that you use custom service accounts with the following access scopes.
  service_account {
    scopes = [
      "https://www.googleapis.com/auth/devstorage.read_only",
      "https://www.googleapis.com/auth/logging.write",
      "https://www.googleapis.com/auth/monitoring.write",
      "https://www.googleapis.com/auth/pubsub",
      "https://www.googleapis.com/auth/service.management.readonly",
      "https://www.googleapis.com/auth/servicecontrol",
      "https://www.googleapis.com/auth/trace.append",
    ]
  }
}

Informationen zum Anwenden oder Entfernen einer Terraform-Konfiguration finden Sie unter Grundlegende Terraform-Befehle.

Einfach loslegen (Go)

compute/instance-templates/create-instance-templates/create_template.go

Auf GitHub ansehen Feedback

import (
	"context"
	"fmt"
	"io"

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

// createTemplate creates a new instance template with the provided name and a specific instance configuration.
func createTemplate(w io.Writer, projectID, templateName string) error {
	// projectID := "your_project_id"
	// templateName := "your_template_name"

	ctx := context.Background()
	instanceTemplatesClient, err := compute.NewInstanceTemplatesRESTClient(ctx)
	if err != nil {
		return fmt.Errorf("NewInstanceTemplatesRESTClient: %w", err)
	}
	defer instanceTemplatesClient.Close()

	req := &computepb.InsertInstanceTemplateRequest{
		Project: projectID,
		InstanceTemplateResource: &computepb.InstanceTemplate{
			Name: proto.String(templateName),
			Properties: &computepb.InstanceProperties{
				// The template describes the size and source image of the boot disk
				// to attach to the instance.
				Disks: []*computepb.AttachedDisk{
					{
						InitializeParams: &computepb.AttachedDiskInitializeParams{
							DiskSizeGb:  proto.Int64(250),
							SourceImage: proto.String("projects/debian-cloud/global/images/family/debian-11"),
						},
						AutoDelete: proto.Bool(true),
						Boot:       proto.Bool(true),
					},
				},
				MachineType: proto.String("e2-standard-4"),
				// The template connects the instance to the `default` network,
				// without specifying a subnetwork.
				NetworkInterfaces: []*computepb.NetworkInterface{
					{
						Name: proto.String("global/networks/default"),
						// The template lets the instance use an external IP address.
						AccessConfigs: []*computepb.AccessConfig{
							{
								Name:        proto.String("External NAT"),
								Type:        proto.String(computepb.AccessConfig_ONE_TO_ONE_NAT.String()),
								NetworkTier: proto.String(computepb.AccessConfig_PREMIUM.String()),
							},
						},
					},
				},
			},
		},
	}

	op, err := instanceTemplatesClient.Insert(ctx, req)
	if err != nil {
		return fmt.Errorf("unable to create instance template: %w", err)
	}

	if err = op.Wait(ctx); err != nil {
		return fmt.Errorf("unable to wait for the operation: %w", err)
	}

	fmt.Fprintf(w, "Instance template created\n")

	return nil
}

Java

compute/cloud-client/src/main/java/compute/CreateInstanceTemplate.java

Auf GitHub ansehen Feedback

import com.google.cloud.compute.v1.AccessConfig;
import com.google.cloud.compute.v1.AccessConfig.NetworkTier;
import com.google.cloud.compute.v1.AttachedDisk;
import com.google.cloud.compute.v1.AttachedDiskInitializeParams;
import com.google.cloud.compute.v1.GlobalOperationsClient;
import com.google.cloud.compute.v1.InsertInstanceTemplateRequest;
import com.google.cloud.compute.v1.InstanceProperties;
import com.google.cloud.compute.v1.InstanceTemplate;
import com.google.cloud.compute.v1.InstanceTemplatesClient;
import com.google.cloud.compute.v1.NetworkInterface;
import com.google.cloud.compute.v1.Operation;
import java.io.IOException;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.TimeoutException;

public class CreateInstanceTemplate {

  public static void main(String[] args)
      throws IOException, ExecutionException, InterruptedException, TimeoutException {
    // TODO(developer): Replace these variables before running the sample.
    // projectId: project ID or project number of the Cloud project you use.
    // templateName: name of the new template to create.
    String projectId = "your-project-id";
    String templateName = "template-name";
    createInstanceTemplate(projectId, templateName);
  }

  /*
    Create a new instance template with the provided name and a specific
    instance configuration.
   */
  public static void createInstanceTemplate(String projectId, String templateName)
      throws IOException, ExecutionException, InterruptedException, TimeoutException {
    try (InstanceTemplatesClient instanceTemplatesClient = InstanceTemplatesClient.create()) {

      String machineType = "e2-standard-4";
      String sourceImage = "projects/debian-cloud/global/images/family/debian-11";

      // The template describes the size and source image of the boot disk
      // to attach to the instance.
      AttachedDisk attachedDisk = AttachedDisk.newBuilder()
          .setInitializeParams(AttachedDiskInitializeParams.newBuilder()
              .setSourceImage(sourceImage)
              .setDiskType("pd-balanced")
              .setDiskSizeGb(250).build())
          .setAutoDelete(true)
          .setBoot(true).build();

      // The template connects the instance to the `default` network,
      // without specifying a subnetwork.
      NetworkInterface networkInterface = NetworkInterface.newBuilder()
          .setName("global/networks/default")
          // The template lets the instance use an external IP address.
          .addAccessConfigs(AccessConfig.newBuilder()
              .setName("External NAT")
              .setType(AccessConfig.Type.ONE_TO_ONE_NAT.toString())
              .setNetworkTier(NetworkTier.PREMIUM.toString()).build()).build();

      InstanceProperties instanceProperties = InstanceProperties.newBuilder()
          .addDisks(attachedDisk)
          .setMachineType(machineType)
          .addNetworkInterfaces(networkInterface).build();

      InsertInstanceTemplateRequest insertInstanceTemplateRequest = InsertInstanceTemplateRequest
          .newBuilder()
          .setProject(projectId)
          .setInstanceTemplateResource(InstanceTemplate.newBuilder()
              .setName(templateName)
              .setProperties(instanceProperties).build()).build();

      // Create the Instance Template.
      Operation response = instanceTemplatesClient.insertAsync(insertInstanceTemplateRequest)
          .get(3, TimeUnit.MINUTES);

      if (response.hasError()) {
        System.out.println("Instance Template creation failed ! ! " + response);
        return;
      }
      System.out
          .printf("Instance Template Operation Status %s: %s", templateName, response.getStatus());
    }
  }

  public static void createInstanceTemplateWithDiskType(String projectId, String templateName)
      throws IOException, ExecutionException, InterruptedException, TimeoutException {
    try (InstanceTemplatesClient instanceTemplatesClient = InstanceTemplatesClient.create();
        GlobalOperationsClient globalOperationsClient = GlobalOperationsClient.create()) {

      AttachedDisk disk = AttachedDisk.newBuilder()
          .setInitializeParams(AttachedDiskInitializeParams.newBuilder()
              .setDiskSizeGb(10)
              .setDiskType("pd-balanced")
              .setSourceImage("projects/debian-cloud/global/images/family/debian-10").build())
          .setAutoDelete(true)
          .setBoot(true)
          .setType(AttachedDisk.Type.PERSISTENT.toString()).build();

      InstanceTemplate instanceTemplate = InstanceTemplate.newBuilder()
          .setName(templateName)
          .setProperties(InstanceProperties.newBuilder()
              .setMachineType("n1-standard-1")
              .addDisks(disk)
              .addNetworkInterfaces(NetworkInterface.newBuilder()
                  .setName("global/networks/default").build()).build()).build();

      InsertInstanceTemplateRequest insertInstanceTemplateRequest = InsertInstanceTemplateRequest
          .newBuilder()
          .setProject(projectId)
          .setInstanceTemplateResource(instanceTemplate).build();

      Operation response = instanceTemplatesClient.insertAsync(insertInstanceTemplateRequest)
          .get(3, TimeUnit.MINUTES);

      if (response.hasError()) {
        System.out.println("Instance Template creation failed ! ! " + response);
        return;
      }
      System.out
          .printf("Instance Template Operation Status %s: %s", templateName, response.getStatus());
    }
  }
}

Node.js

compute/create-instance-templates/createTemplate.js

Auf GitHub ansehen Feedback

/**
 * TODO(developer): Uncomment and replace these variables before running the sample.
 */
// const projectId = 'YOUR_PROJECT_ID';
// const templateName = 'your_template_name';

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

// Create a new instance template with the provided name and a specific instance configuration.
async function createTemplate() {
  const instanceTemplatesClient = new compute.InstanceTemplatesClient();

  const [response] = await instanceTemplatesClient.insert({
    project: projectId,
    instanceTemplateResource: {
      name: templateName,
      properties: {
        disks: [
          {
            // The template describes the size and source image of the boot disk
            // to attach to the instance.
            initializeParams: {
              diskSizeGb: '250',
              sourceImage:
                'projects/debian-cloud/global/images/family/debian-11',
            },
            autoDelete: true,
            boot: true,
          },
        ],
        machineType: 'e2-standard-4',
        // The template connects the instance to the `default` network,
        // without specifying a subnetwork.
        networkInterfaces: [
          {
            // Use the network interface provided in the networkName argument.
            name: 'global/networks/default',
            // The template lets the instance use an external IP address.
            accessConfigs: [
              {
                name: 'External NAT',
                type: 'ONE_TO_ONE_NAT',
                networkTier: 'PREMIUM',
              },
            ],
          },
        ],
      },
    },
  });
  let operation = response.latestResponse;
  const operationsClient = new compute.GlobalOperationsClient();

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

  console.log('Instance template created.');
}

createTemplate();

Python

compute/client_library/snippets/instance_templates/create.py

Auf GitHub ansehen Feedback

from __future__ import annotations

import sys
from typing import Any

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

def wait_for_extended_operation(
    operation: ExtendedOperation, verbose_name: str = "operation", timeout: int = 300
) -> Any:
    """
    Waits for the extended (long-running) operation to complete.

    If the operation is successful, it will return its result.
    If the operation ends with an error, an exception will be raised.
    If there were any warnings during the execution of the operation
    they will be printed to sys.stderr.

    Args:
        operation: a long-running operation you want to wait on.
        verbose_name: (optional) a more verbose name of the operation,
            used only during error and warning reporting.
        timeout: how long (in seconds) to wait for operation to finish.
            If None, wait indefinitely.

    Returns:
        Whatever the operation.result() returns.

    Raises:
        This method will raise the exception received from `operation.exception()`
        or RuntimeError if there is no exception set, but there is an `error_code`
        set for the `operation`.

        In case of an operation taking longer than `timeout` seconds to complete,
        a `concurrent.futures.TimeoutError` will be raised.
    """
    result = operation.result(timeout=timeout)

    if operation.error_code:
        print(
            f"Error during {verbose_name}: [Code: {operation.error_code}]: {operation.error_message}",
            file=sys.stderr,
            flush=True,
        )
        print(f"Operation ID: {operation.name}", file=sys.stderr, flush=True)
        raise operation.exception() or RuntimeError(operation.error_message)

    if operation.warnings:
        print(f"Warnings during {verbose_name}:\n", file=sys.stderr, flush=True)
        for warning in operation.warnings:
            print(f" - {warning.code}: {warning.message}", file=sys.stderr, flush=True)

    return result

def create_template(project_id: str, template_name: str) -> compute_v1.InstanceTemplate:
    """
    Create a new instance template with the provided name and a specific
    instance configuration.

    Args:
        project_id: project ID or project number of the Cloud project you use.
        template_name: name of the new template to create.

    Returns:
        InstanceTemplate object that represents the new instance template.
    """
    # The template describes the size and source image of the boot disk
    # to attach to the instance.
    disk = compute_v1.AttachedDisk()
    initialize_params = compute_v1.AttachedDiskInitializeParams()
    initialize_params.source_image = (
        "projects/debian-cloud/global/images/family/debian-11"
    )
    initialize_params.disk_size_gb = 250
    disk.initialize_params = initialize_params
    disk.auto_delete = True
    disk.boot = True

    # The template connects the instance to the `default` network,
    # without specifying a subnetwork.
    network_interface = compute_v1.NetworkInterface()
    network_interface.name = "global/networks/default"

    # The template lets the instance use an external IP address.
    access_config = compute_v1.AccessConfig()
    access_config.name = "External NAT"
    access_config.type_ = "ONE_TO_ONE_NAT"
    access_config.network_tier = "PREMIUM"
    network_interface.access_configs = [access_config]

    template = compute_v1.InstanceTemplate()
    template.name = template_name
    template.properties.disks = [disk]
    template.properties.machine_type = "e2-standard-4"
    template.properties.network_interfaces = [network_interface]

    template_client = compute_v1.InstanceTemplatesClient()
    operation = template_client.insert(
        project=project_id, instance_template_resource=template
    )

    wait_for_extended_operation(operation, "instance template creation")

    return template_client.get(project=project_id, instance_template=template_name)

REST

So erstellen Sie eine regionale Instanzvorlage und senden eine POST-Anfrage an die regionInstanceTemplates.insert-Methode:

POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/regions/REGION/instanceTemplates

Senden Sie zum Erstellen einer globalen Instanzvorlage eine POST-Anfrage an die instanceTemplates.insert-Methode:

POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/global/instanceTemplates

Sie können bis zu 15 sekundäre Nicht-Bootlaufwerke mit dem disks-Attribut mit einem Feld für jedes zusätzliche Laufwerk hinzufügen. Für jedes zusätzliche Laufwerk können Sie Folgendes tun:

• Sie können zusätzliche Laufwerke mit einem öffentlichen oder mit einem benutzerdefinierten Image erstellen.
• Wenn Sie ein leeres Laufwerk erstellen möchten, geben Sie für den Eintrag initializeParams keinen sourceImage-Wert an.
• Definieren Sie zum Erstellen regionaler nichtflüchtiger Speicher den Eintrag initializeParams mit dem Attribut replicaZones.

Geben Sie im Anfragetext die Vorlagenattribute an:

{
  "name": "INSTANCE_TEMPLATE_NAME",
  "properties": {
    "machineType": "MACHINE_TYPE",
    "networkInterfaces": [
      {
        "network": "global/networks/default",
        "accessConfigs":
        [
          {
            "name": "external-IP",
            "type": "ONE_TO_ONE_NAT"
          }
        ]
      }
    ],
    "disks":
    [
      {
        "type": "PERSISTENT",
        "boot": true,
        "mode": "READ_WRITE",
        "initializeParams":
        {
          "sourceImage": "projects/IMAGE_PROJECT/global/images/IMAGE"
        }
      },
      {
        "type": "PERSISTENT",
        "boot": false,
        "deviceName": "DISK_NAME",
        "initializeParams":
        {
          "replicaZones": [
              "projects/PROJECT_NAME/zones/ZONE",
              "projects/PROJECT_NAME/zones/REMOTE_ZONE"
          ]
        }
      }
    ]
  }
}

Ersetzen Sie Folgendes:

• PROJECT_ID: Ihre Projekt-ID
• REGION: Region, in der Sie Ihre regionale Instanzvorlage erstellen möchten
• INSTANCE_TEMPLATE_NAME: der Name der Instanzvorlage
• ZONE: Die Zone, in der sich die VMs befinden

• MACHINE_TYPE: der Maschinentyp der VMs

• IMAGE_PROJECT: das Image-Projekt, das das Image enthält

  Weitere Informationen zu öffentlichen Images finden Sie unter Öffentliche Images.

• Für IMAGE oder IMAGE_FAMILY muss eine der folgenden Optionen angegeben werden:
  • IMAGE: Eine bestimmte Version des 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, legt Compute Engine eine VM aus der neuesten Version des Betriebssystem-Images in der Debian 10-Image-Familie an.

    Weitere Informationen zu Image-Familien finden Sie unter Best Practices für die Verwendung von Image-Familien in Compute Engine.

• DISK_NAME: Optional; der Laufwerkname, der dem Gastbetriebssystem nach dem Erstellen der VM angezeigt wird.

• PROJECT_NAME: das mit der VM verknüpfte Projekt

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

Sie können eine der folgenden Optionen für das Attribut disks angeben:

• Geben Sie initializeParams an, um nichtflüchtige Bootlaufwerke für jede Instanz zu erstellen. Sie können bis zu 15 sekundäre Nicht-Bootlaufwerke hinzufügen. Geben Sie dazu für jedes zusätzliche Laufwerk das Attribut initializeParams an. Sie können Laufwerke mithilfe von öffentlichen oder benutzerdefinierten Images (oder Image-Familien) im sourceImage erstellen, wie im vorherigen Beispiel gezeigt. Wenn Sie leere Laufwerke hinzufügen möchten, geben Sie kein sourceImage an.

• Geben Sie source an, um ein vorhandenes nichtflüchtiges Bootlaufwerk anzuhängen. Wenn Sie ein vorhandenes Bootlaufwerk anhängen, können Sie aus Ihrer Vorlage nur eine Instanz erstellen.

Optional können Sie die Attribute diskSizeGb, diskType undlabels für initializeParams und das Attribut diskSizeGb für source angeben.

Wenn Sie ein Image ausgewählt haben, das Shielded VM unterstützt, können Sie optional die Shielded VM-Einstellungen der VM mit den folgenden booleschen Anfragetextelementen ändern:

• enableSecureBoot: aktiviert oder deaktiviert Secure Boot

  Mit Secure Boot können Sie Ihre VM-Instanzen vor Malware und Rootkits auf Boot- und Kernelebene schützen. Weitere Informationen finden Sie unter Secure Boot.

• enableVtpm: Aktiviert oder deaktiviert das Virtual Trusted Platform Module (vTPM)

  Durch das vTPM wird Measured Boot aktiviert, das die Integrität der VM vor und während des Startens überprüft. Weitere Informationen finden Sie unter Virtual Trusted Platform Module (vTPM).

  Wichtig:
  Beim Deaktivieren des vTPM wird auch die Integritätsüberwachung deaktiviert, da dies auf Daten basiert, die von Measured Boot erfasst werden.

• enableIntegrityMonitoring: aktiviert oder deaktiviert Integritätsüberwachung

  Mit dem Integritätsmonitoring können Sie die Integrität beim Booten der Laufzeit Ihrer Shielded VM-Instanzen mithilfe von Cloud Monitoring-Berichten beobachten und prüfen. Weitere Informationen finden Sie unter Integritätsüberwachung.

Weitere Informationen zu Anfrageparametern finden Sie unter der Methode instanceTemplates.insert.

Instanzvorlage auf Basis einer vorhandenen Instanz erstellen

Mit der REST oder der gcloud CLI können Sie die Konfiguration einer vorhandenen VM-Instanz als Instanzvorlage speichern. Die Definition der Quelllaufwerke in der Vorlage kann optional überschrieben werden.

Wenn Sie andere Attribute überschreiben müssen, erstellen Sie zuerst eine Instanzvorlage auf der Grundlage einer vorhandenen Instanz und dann eine ähnliche Vorlage mit den gewünschten Überschreibungen.

Warnung: Wenn die vorhandene Instanz eine statische externe IP-Adresse enthält, wird diese Adresse in die Instanzvorlage kopiert und schränkt möglicherweise die Verwendung der Vorlage ein.

Erforderliche Berechtigungen für diese Aufgabe

Zum Ausführen dieser Aufgabe benötigen Sie die folgenden Berechtigungen:

• Alle Berechtigungen, die zum Aufrufen der Methode instanceTemplates.insert erforderlich sind.

gcloud

Verwenden Sie den Befehl gcloud compute instance-templates create mit den Flags --source-instance und --source-instance-zone. Wenn Sie eine regionale Instanzvorlage erstellen möchten, müssen Sie außerdem mit dem --instance-template-region-Flag die Region der Instanzvorlage angeben.

Verwenden Sie zum Erstellen einer regionalen Instanzvorlage folgenden Befehl:

gcloud compute instance-templates create INSTANCE_TEMPLATE_NAME \
    --source-instance=SOURCE_INSTANCE \
    --source-instance-zone=SOURCE_INSTANCE_ZONE \
    --instance-template-region=REGION

Erstellen Sie mit folgendem Befehl eine globale Instanzvorlage:

gcloud compute instance-templates create INSTANCE_TEMPLATE_NAME \
    --source-instance=SOURCE_INSTANCE \
    --source-instance-zone=SOURCE_INSTANCE_ZONE

Fügen Sie ein oder mehrere --configure-disk-Flags hinzu, um die Definition der Laufwerke der Quellinstanz zu überschreiben.

Im folgenden Beispiel wird eine globale Instanzvorlage aus einer vorhandenen Instanz erstellt. Sie überschreibt das Laufwerk der Quellinstanz mit den von Ihnen bereitgestellten Spezifikationen.

gcloud compute instance-templates create INSTANCE_TEMPLATE_NAME \
    --source-instance=SOURCE_INSTANCE \
    --source-instance-zone=SOURCE_INSTANCE_ZONE \
    --configure-disk= \
        device-name=SOURCE_DISK, \
        instantiate-from=INSTANTIATE_OPTIONS, \
        auto-delete=AUTO_DELETE

Ersetzen Sie Folgendes:

• INSTANCE_TEMPLATE_NAME: Name der zu erstellenden Vorlage.
• SOURCE_INSTANCE: Name der Instanz, die als Modell für die neue Vorlage verwendet werden soll.
• SOURCE_INSTANCE_ZONE: Zone, die die Quellinstanz enthält.
• REGION: Region, in der Sie die regionale Instanzvorlage erstellen möchten.
• SOURCE_DISK: Name eines Laufwerks der Quellinstanz, das Sie in der Vorlage überschreiben möchten.

• INSTANTIATE_OPTIONS gibt an, ob das Laufwerk mit aufgenommen und welches Image verwendet werden soll. Gültige Werte sind vom Laufwerkstyp abhängig:

  • source-image oder source-image-family (nur für Boot- und andere nichtflüchtige Laufwerke mit Lese-/Schreibzugriff gültig). Geben Sie diese Option an, wenn Sie dasselbe Quell-Image oder dieselbe Quell-Image-Familie verwenden möchten, mit der das Laufwerk in der Quell-VM-Instanz erstellt wurde.

  • custom-image (nur für Boot- und andere nichtflüchtige Laufwerke mit Lese-/Schreibzugriff gültig). Wenn Sie Anwendungen und Einstellungen von den Quell-VMs in Ihrer Instanzvorlage beibehalten möchten, können Sie ein benutzerdefiniertes Image erstellen und dann beim Erstellen der Vorlage angeben. Wenn angegeben, geben Sie den Pfad oder die URL für das benutzerdefinierte Image an, wie im folgenden Beispiel gezeigt. Alternativ können Sie eine Image-Familie auch im folgenden Format angeben:

    --configure-disk=device-name=DATA_DISK_NAME,instantiate-from=custom-image,
custom-image=projects/PROJECT_ID/global/images/family/IMAGE_FAMILY_NAME

  • attach-read-only (nur für schreibgeschützte Laufwerke gültig).

  • blank (nur für nichtflüchtige Speicher, bei denen es sich nicht um ein Bootlaufwerk handelt, und lokale SSDs gültig). Ist dieser Wert angegeben und dient die Vorlage zum Erstellen einer neuen Instanz, wird das Laufwerk unformatiert erstellt. Sie müssen das Laufwerk in einem Startskript formatieren und bereitstellen, bevor Sie es in einer skalierbaren Konfiguration verwenden können.

  • do-not-include (nur für nichtflüchtige Speicher, bei denen es sich nicht um ein Bootlaufwerk handelt, und schreibgeschützte Laufwerke gültig).

• AUTO_DELETE gibt an, ob das Laufwerk automatisch gelöscht wird, sobald die Instanz gelöscht wird. Gültige Werte sind false, no, true und yes.

Mit folgendem Befehl wird beispielsweise eine Instanzvorlage auf der Basis von my-source-instance erstellt, mit der Option, das ursprüngliche Image von data-disk-a zu verwenden, aber mit true für automatisches Löschen. Außerdem wird data-disk-b durch ein benutzerdefiniertes Image ersetzt.

gcloud compute instance-templates create my-instance-template  \
    --source-instance=my-source-instance \
    --configure-disk=device-name=data-disk-a,instantiate-from=source-image, \
      auto-delete=true
    --configure-disk=device-name=data-disk-b,instantiate-from=custom-image, \
      custom-image=projects/cps-cloud/global/images/cos-89-16108-403-15

Einfach loslegen (Go)

compute/instance-templates/create-instance-templates/create_template_from_instance.go

Auf GitHub ansehen Feedback

import (
	"context"
	"fmt"
	"io"

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

// createTemplateFromInstance creates a new instance template based on an existing instance.
// This new template specifies a different boot disk.
func createTemplateFromInstance(w io.Writer, projectID, instance, templateName string) error {
	// projectID := "your_project_id"
	// instance := "projects/project/zones/zone/instances/instance"
	// templateName := "your_template_name"

	ctx := context.Background()
	instanceTemplatesClient, err := compute.NewInstanceTemplatesRESTClient(ctx)
	if err != nil {
		return fmt.Errorf("NewInstanceTemplatesRESTClient: %w", err)
	}
	defer instanceTemplatesClient.Close()

	req := &computepb.InsertInstanceTemplateRequest{
		Project: projectID,
		InstanceTemplateResource: &computepb.InstanceTemplate{
			Name:           proto.String(templateName),
			SourceInstance: proto.String(instance),
			SourceInstanceParams: &computepb.SourceInstanceParams{
				DiskConfigs: []*computepb.DiskInstantiationConfig{
					{
						// Device name must match the name of a disk attached to the instance
						// your template is based on.
						DeviceName: proto.String("disk-1"),
						// Replace the original boot disk image used in your instance with a Rocky Linux image.
						InstantiateFrom: proto.String(computepb.DiskInstantiationConfig_CUSTOM_IMAGE.String()),
						CustomImage:     proto.String("projects/rocky-linux-cloud/global/images/family/rocky-linux-8"),
						// Override the auto_delete setting.
						AutoDelete: proto.Bool(true),
					},
				},
			},
		},
	}

	op, err := instanceTemplatesClient.Insert(ctx, req)
	if err != nil {
		return fmt.Errorf("unable to create instance template: %w", err)
	}

	if err = op.Wait(ctx); err != nil {
		return fmt.Errorf("unable to wait for the operation: %w", err)
	}

	fmt.Fprintf(w, "Instance template created\n")

	return nil
}

Java

compute/cloud-client/src/main/java/compute/CreateTemplateFromInstance.java

Auf GitHub ansehen Feedback

import com.google.cloud.compute.v1.DiskInstantiationConfig;
import com.google.cloud.compute.v1.DiskInstantiationConfig.InstantiateFrom;
import com.google.cloud.compute.v1.GlobalOperationsClient;
import com.google.cloud.compute.v1.InsertInstanceTemplateRequest;
import com.google.cloud.compute.v1.InstanceTemplate;
import com.google.cloud.compute.v1.InstanceTemplatesClient;
import com.google.cloud.compute.v1.Operation;
import com.google.cloud.compute.v1.SourceInstanceParams;
import java.io.IOException;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.TimeoutException;

public class CreateTemplateFromInstance {

  public static void main(String[] args)
      throws IOException, ExecutionException, InterruptedException, TimeoutException {
    // TODO(developer): Replace these variables before running the sample.
    // projectId: project ID or project number of the Cloud project you use.
    // instance: the instance to base the new template on. This value uses the following format:
    // **NOTE**: "projects/{project}/zones/{zone}/instances/{instance_name}"
    // templateName: name of the new template to create.
    String projectId = "your-project-id";
    String templateName = "template-name";
    String instance = String.format("projects/%s/zones/%s/instances/%s", projectId, "zone",
        "instanceName");
    createTemplateFromInstance(projectId, templateName, instance);
  }

  // Create a new instance template based on an existing instance.
  // This new template specifies a different boot disk.
  public static void createTemplateFromInstance(String projectId, String templateName,
      String instance)
      throws IOException, ExecutionException, InterruptedException, TimeoutException {
    try (InstanceTemplatesClient instanceTemplatesClient = InstanceTemplatesClient.create();
        GlobalOperationsClient globalOperationsClient = GlobalOperationsClient.create()) {

      SourceInstanceParams sourceInstanceParams = SourceInstanceParams.newBuilder()
          .addDiskConfigs(DiskInstantiationConfig.newBuilder()
              // Device name must match the name of a disk attached to the instance you are
              // basing your template on.
              .setDeviceName("disk-1")
              // Replace the original boot disk image used in your instance
              // with a Rocky Linux image.
              .setInstantiateFrom(InstantiateFrom.CUSTOM_IMAGE.toString())
              .setCustomImage(
                  String.format("projects/%s/global/images/family/%s", "rocky-linux-cloud",
                      "rocky-linux-8"))
              // Override the AutoDelete setting.
              .setAutoDelete(true).build())
          .build();

      InstanceTemplate instanceTemplate = InstanceTemplate.newBuilder()
          .setName(templateName)
          .setSourceInstance(instance)
          .setSourceInstanceParams(sourceInstanceParams)
          .build();

      InsertInstanceTemplateRequest insertInstanceTemplateRequest = InsertInstanceTemplateRequest
          .newBuilder()
          .setProject(projectId)
          .setInstanceTemplateResource(instanceTemplate)
          .build();

      Operation operation = instanceTemplatesClient.insertCallable()
          .futureCall(insertInstanceTemplateRequest).get(3, TimeUnit.MINUTES);

      Operation response = globalOperationsClient.wait(projectId, operation.getName());

      if (response.hasError()) {
        System.out.println("Instance Template creation failed ! ! " + response);
        return;
      }
      System.out.printf("Instance Template creation operation status %s: %s", templateName,
          response.getStatus());
    }
  }
}

Node.js

compute/create-instance-templates/createTemplateFromInstance.js

Auf GitHub ansehen Feedback

/**
 * TODO(developer): Uncomment and replace these variables before running the sample.
 */
// const projectId = 'YOUR_PROJECT_ID';
// const instance = 'projects/project/zones/zone/instances/instance';
// const templateName = 'your_template_name';

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

// Create a new instance template based on an existing instance.
// This new template specifies a different boot disk.
async function createTemplateFromInstance() {
  const instanceTemplatesClient = new compute.InstanceTemplatesClient();

  const [response] = await instanceTemplatesClient.insert({
    project: projectId,
    instanceTemplateResource: {
      name: templateName,
      sourceInstance: instance,
      sourceInstanceParams: {
        diskConfigs: [
          {
            // Device name must match the name of a disk attached to the instance
            // your template is based on.
            deviceName: 'disk-1',
            // Replace the original boot disk image used in your instance with a Rocky Linux image.
            instantiateFrom: 'CUSTOM_IMAGE',
            customImage:
              'projects/rocky-linux-cloud/global/images/family/rocky-linux-8',
            // Override the auto_delete setting.
            autoDelete: true,
          },
        ],
      },
    },
  });
  let operation = response.latestResponse;
  const operationsClient = new compute.GlobalOperationsClient();

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

  console.log('Instance template created.');
}

createTemplateFromInstance();

Python

compute/client_library/snippets/instance_templates/create_from_instance.py

Auf GitHub ansehen Feedback

from __future__ import annotations

import sys
from typing import Any

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

def wait_for_extended_operation(
    operation: ExtendedOperation, verbose_name: str = "operation", timeout: int = 300
) -> Any:
    """
    Waits for the extended (long-running) operation to complete.

    If the operation is successful, it will return its result.
    If the operation ends with an error, an exception will be raised.
    If there were any warnings during the execution of the operation
    they will be printed to sys.stderr.

    Args:
        operation: a long-running operation you want to wait on.
        verbose_name: (optional) a more verbose name of the operation,
            used only during error and warning reporting.
        timeout: how long (in seconds) to wait for operation to finish.
            If None, wait indefinitely.

    Returns:
        Whatever the operation.result() returns.

    Raises:
        This method will raise the exception received from `operation.exception()`
        or RuntimeError if there is no exception set, but there is an `error_code`
        set for the `operation`.

        In case of an operation taking longer than `timeout` seconds to complete,
        a `concurrent.futures.TimeoutError` will be raised.
    """
    result = operation.result(timeout=timeout)

    if operation.error_code:
        print(
            f"Error during {verbose_name}: [Code: {operation.error_code}]: {operation.error_message}",
            file=sys.stderr,
            flush=True,
        )
        print(f"Operation ID: {operation.name}", file=sys.stderr, flush=True)
        raise operation.exception() or RuntimeError(operation.error_message)

    if operation.warnings:
        print(f"Warnings during {verbose_name}:\n", file=sys.stderr, flush=True)
        for warning in operation.warnings:
            print(f" - {warning.code}: {warning.message}", file=sys.stderr, flush=True)

    return result

def create_template_from_instance(
    project_id: str, instance: str, template_name: str
) -> compute_v1.InstanceTemplate:
    """
    Create a new instance template based on an existing instance.
    This new template specifies a different boot disk.

    Args:
        project_id: project ID or project number of the Cloud project you use.
        instance: the instance to base the new template on. This value uses
            the following format: "projects/{project}/zones/{zone}/instances/{instance_name}"
        template_name: name of the new template to create.

    Returns:
        InstanceTemplate object that represents the new instance template.
    """
    disk = compute_v1.DiskInstantiationConfig()
    # Device name must match the name of a disk attached to the instance you are
    # basing your template on.
    disk.device_name = "disk-1"
    # Replace the original boot disk image used in your instance with a Rocky Linux image.
    disk.instantiate_from = "CUSTOM_IMAGE"
    disk.custom_image = "projects/rocky-linux-cloud/global/images/family/rocky-linux-8"
    # Override the auto_delete setting.
    disk.auto_delete = True

    template = compute_v1.InstanceTemplate()
    template.name = template_name
    template.source_instance = instance
    template.source_instance_params = compute_v1.SourceInstanceParams()
    template.source_instance_params.disk_configs = [disk]

    template_client = compute_v1.InstanceTemplatesClient()
    operation = template_client.insert(
        project=project_id, instance_template_resource=template
    )

    wait_for_extended_operation(operation, "instance template creation")

    return template_client.get(project=project_id, instance_template=template_name)

REST

Verwenden Sie zum Erstellen einer regionalen Instanzvorlage die Methode regionInstanceTemplates.insert oder verwenden Sie zum Erstellen einer globalen Instanzvorlage die Methode instanceTemplates.insert.

In der Anfrage müssen Sie das Feld sourceInstance angeben. Wenn Sie die Definition der Laufwerke der Quellinstanz überschreiben möchten, fügen Sie ein oder mehrere diskConfigs-Felder hinzu.

Mit dem folgenden Aufruf können Sie beispielsweise eine globale Instanzvorlage aus einer vorhandenen Instanz erstellen.

POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/global/instanceTemplates

{
  "name": "INSTANCE_TEMPLATE_NAME",
  "sourceInstance": "zones/SOURCE_INSTANCE_ZONE/instances/SOURCE_INSTANCE",
  "sourceInstanceParams": {
    "diskConfigs": [
      {
        "deviceName": "SOURCE_DISK",
        "instantiateFrom": "INSTANTIATE_OPTIONS",
        "autoDelete": false
      }
    ]
  }
}

Ersetzen Sie Folgendes:

• PROJECT_ID: Ihre Projekt-ID
• INSTANCE_TEMPLATE_NAME: Der Name der neuen Vorlage.
• SOURCE_INSTANCE_ZONE ist die Zone der Quellinstanz.
• SOURCE_INSTANCE: der Name der Quellinstanz, die als Modell für diese Instanzvorlage verwendet werden soll.
• SOURCE_DISK: der Name eines Laufwerks der Quellinstanz, das Sie in der Vorlage überschreiben möchten.

• INSTANTIATE_OPTIONS: gibt an, ob das Laufwerk mit aufgenommen und welches Image verwendet werden soll.

  Gültige Werte sind vom Laufwerkstyp abhängig:

  • source-image oder source-image-family (nur für Boot- und andere nichtflüchtige Laufwerke mit Lese-/Schreibzugriff gültig).

  • custom-image (nur für Boot- und andere nichtflüchtige Laufwerke mit Lese-/Schreibzugriff gültig). Wenn Sie Anwendungen und Einstellungen von den Quell-VMs in Ihrer Instanzvorlage beibehalten möchten, können Sie ein benutzerdefiniertes Image erstellen und dann beim Erstellen der Vorlage angeben. Wenn angegeben, geben Sie den Pfad oder die URL für das benutzerdefinierte Image an, wie im folgenden Beispiel gezeigt. Alternativ können Sie eine Image-Familie auch im folgenden Format angeben:

    --configure-disk=device-name=DATA_DISK_NAME,instantiate-from=custom-image,
custom-image=projects/PROJECT_ID/global/images/family/IMAGE_FAMILY_NAME

  • attach-read-only (nur für schreibgeschützte Laufwerke gültig).

  • blank (nur für nichtflüchtige Speicher, bei denen es sich nicht um ein Bootlaufwerk handelt, und lokale SSDs gültig). Ist dieser Wert angegeben und dient die Vorlage zum Erstellen einer neuen Instanz, wird das Laufwerk unformatiert erstellt. Sie müssen das Laufwerk in einem Startskript formatieren und bereitstellen, bevor Sie es in einer skalierbaren Konfiguration verwenden können.

  • do-not-include (nur für nichtflüchtige Speicher, bei denen es sich nicht um ein Bootlaufwerk handelt, und schreibgeschützte Laufwerke gültig).

Im folgenden Beispiel wird eine neue Instanzvorlage auf der Basis von my-source-instance erstellt. In der Instanzvorlage wird das Image für data-disk-a durch projects/cos-cloud/global/images/cos-89-16108-403-15 ersetzt.

POST https://compute.googleapis.com/compute/v1/projects/my_project/global/instanceTemplates

{
  "name": "my-instance-template",
  "sourceInstance": "zones/us-central1-a/instances/my-source-instance",
  "sourceInstanceParams":
  {
    "diskConfigs":
    [
      {
        "deviceName": "data-disk-a",
        "instantiateFrom": "custom-image",
        "customImage": "projects/cos-cloud/global/images/cos-89-16108-403-15"
      }
    ]
  }
}

Folgende Tabelle zeigt, wie die Optionen zum Überschreiben von Laufwerken in der Vorlage definiert sind.

Laufwerkstyp	Optionen
Bootlaufwerk	[Standard] Dasselbe Quell-Image oder dieselbe Image-Familie wie zum Erstellen des Bootlaufwerks auf der Quellinstanz verwenden. Verwenden Sie die URL eines beliebigen benutzerdefinierten oder öffentlichen Images, wie im vorherigen Beispiel beschrieben, oder geben Sie eine Image-Familie im folgenden Format an: projects/exampleproject/global/images/family/IMAGE_FAMILY_NAME
Andere nichtflüchtige Speicher mit Lese-/Schreibzugriff	[Standard] Dasselbe Quell-Image oder dieselbe Image-Familie wie zum Erstellen des Bootlaufwerks auf der Quellinstanz verwenden. Hinweis: Wenn das Laufwerk der Quellinstanz kein Attribut für Quell-Image-/Quell-Image-Familie hat, wird es als leeres Laufwerk in die Vorlage aufgenommen. Verwenden Sie die URL eines beliebigen benutzerdefinierten oder öffentlichen Images, wie im vorherigen Beispiel beschrieben, oder geben Sie eine Image-Familie im folgenden Format an: projects/exampleproject/global/images/family/IMAGE_FAMILY_NAME Stattdessen ein leeres Laufwerk in der Vorlage verwenden. Dient die Vorlage zum Erstellen einer neuen Instanz, wird das Laufwerk unformatiert erstellt. Sie müssen das Laufwerk in einem Startskript formatieren und bereitstellen, bevor Sie es in einer skalierbaren Konfiguration verwenden können. Das Laufwerk nicht mit aufnehmen.
Schreibgeschützte Laufwerke	[Standard] Das Laufwerk im schreibgeschützten Modus aufnehmen. Das Laufwerk nicht mit aufnehmen.
Lokale SSD(s)	[Standard] Eine leere lokale SSD mit aufnehmen. Dient die Vorlage zum Erstellen einer neuen Instanz, wird das Laufwerk unformatiert erstellt. Sie müssen das Laufwerk in einem Startskript formatieren und bereitstellen, bevor Sie es in einer skalierbaren Konfiguration verwenden können.

Sie können für jedes Laufwerk auch das Attribut auto-delete überschreiben und angeben, ob das Laufwerk gelöscht oder nicht gelöscht werden soll, wenn die zugehörige Instanz gelöscht wird.

Wenn keine Optionen zum Überschreiben angegeben sind, entspricht die Laufwerkskonfiguration in der Vorlage standardmäßig der Quellinstanz.

Instanzvorlage auf Basis einer vorhandenen Vorlage erstellen

Sie können eine vorhandene Instanzvorlage nicht aktualisieren. Wenn eine Instanzvorlage jedoch veraltet ist oder Sie Änderungen vornehmen müssen, können Sie über die Konsole eine andere mit ähnlichen Attributen erstellen.

1. Zur Seite Instanzvorlagen.

   Zu Instanzvorlagen

2. Klicken Sie auf die Instanzvorlage, die Sie kopieren und aktualisieren möchten.

3. Klicken Sie auf Ähnliche erstellen.

4. Aktualisieren Sie die Konfiguration in der neuen Vorlage.

5. Klicken Sie auf Erstellen.

Instanzvorlage für GPU-VMs erstellen

Beim Erstellen einer Instanzvorlage können Sie sie so konfigurieren, dass VMs mit angehängten GPUs erstellt werden. Geben Sie dazu Folgendes an:

• Ein Maschinentyp, der den gewünschten GPU-Typ unterstützt. Wenn Sie eine regionale Instanzvorlage erstellen möchten, muss der in der Vorlage angegebene GPU-Typ in mindestens einer Zone in der Region verfügbar sein.

• Eine Wartungsrichtlinie, die VMs während Hostwartungsereignissen beendet.

Erforderliche Berechtigungen für diese Aufgabe

Zum Ausführen dieser Aufgabe benötigen Sie die folgenden Berechtigungen:

• Alle Berechtigungen, die zum Aufrufen der Methode instanceTemplates.insert erforderlich sind.

Console

So erstellen Sie eine Instanzvorlage für GPU-VMs:

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

   Zu Instanzvorlagen

2. Klicken Sie auf Instanzvorlage erstellen.

3. Geben Sie im Feld Name einen Namen für die Instanzvorlage ein.

4. Wählen Sie im Bereich Standort eine der folgenden Optionen aus:

   • Zum Erstellen einer globalen Instanzvorlage wählen Sie Global (Standardeinstellung) aus.

   • Um eine regionale Instanzvorlage zu erstellen, wählen Sie Regional und dann die Region aus, in der Sie die Instanzvorlage erstellen möchten.

5. Führen Sie im Abschnitt Maschinenkonfiguration die folgenden Schritte aus:

   1. Klicken Sie auf den Tab GPUs.

   2. Wählen Sie im Menü GPU-Typ den GPU-Typ.

   3. Wählen Sie in der Liste Anzahl der GPUs die Anzahl der GPUs aus.

   4. Optional: Wenn Ihr GPU-Modell NVIDIA RTX Virtual Workstations (vWS) für Grafikarbeitslasten unterstützt und Sie grafikintensive Arbeitslasten ausführen möchten, wählen Sie Virtuelle aktivieren Workstation (NVIDIA GRID).

   5. Wählen Sie im Abschnitt Maschinentyp einen Maschinentyp aus.

6. Klicken Sie im Abschnitt Bootlaufwerk auf Ändern, um den Standardwert für den Bootlaufwerktyp oder das Image zu ändern. Folgen Sie dann den Aufforderungen, um das Bootlaufwerk zu ändern.

7. Klicken Sie auf Erstellen.

gcloud

Verwenden Sie zum Erstellen einer Instanzvorlage für GPU-VMs den Befehl instance-templates create, wobei das Flag --maintenance-policy auf TERMINATE gesetzt ist.

Verwenden Sie beispielsweise den folgenden Befehl, um eine globale Instanzvorlage für GPU-VMs zu erstellen:

gcloud compute instance-templates create INSTANCE_TEMPLATE_NAME \
    --machine-type=MACHINE_TYPE \
    --maintenance-policy=TERMINATE

Ersetzen Sie Folgendes:

• INSTANCE_TEMPLATE_NAME: der Name der Instanzvorlage.

• MACHINE_TYPE: der Maschinentyp der VMs. Wenn Sie einen N1-Maschinentyp angeben, fügen Sie das Flag --accelerator ein, um die Anzahl und den Typ der GPUs anzugeben, die an Ihre VMs angehängt werden sollen.

Angenommen, Sie möchten eine globale Instanzvorlage für GPU-VMs mit den folgenden Attributen erstellen:

• Ein vordefinierter N1-Maschinentyp mit 2 vCPUs.

• Eine NVIDIA T4-GPU, die an die VMs angehängt wird.

• Debian als Image-Projekt

• Debian 10 als Image-Familie

Verwenden Sie zum Erstellen der Beispielinstanzvorlage den folgenden Befehl:

gcloud compute instance-templates create instance-template-gpu \
    --accelerator=count=1,type=nvidia-tesla-t4 \
    --machine-type=n1-standard-2 \
    --image-family=debian-10 \
    --image-project=debian-cloud \
    --maintenance-policy=TERMINATE

Terraform

Verwenden Sie zum Erstellen einer Instanzvorlage für GPU-VMs die Ressource google_compute_region_instance_template.

Verwenden Sie beispielsweise die folgende Ressource, um eine globale Instanzvorlage zu erstellen, die einen vordefinierten N1-Maschinentyp mit 2 vCPUs und einer angehängten NVIDIA T4-GPU angibt:

compute/instance_template_with_gpu/main.tf

Auf GitHub ansehen Feedback

resource "google_compute_instance_template" "default" {
  name         = "gpu-template"
  machine_type = "n1-standard-2"

  disk {
    source_image = "debian-cloud/debian-11"
  }

  network_interface {
    network = "default"
  }

  guest_accelerator {
    type  = "nvidia-tesla-t4"
    count = 1
  }

  scheduling {
    on_host_maintenance = "TERMINATE"
  }
}

Informationen zum Anwenden oder Entfernen einer Terraform-Konfiguration finden Sie unter Grundlegende Terraform-Befehle.

REST

Senden Sie zum Erstellen einer Instanzvorlage für GPU-VMs eine POST-Anfrage an die Methode instanceTemplates.insert. Fügen Sie im Anfragetext das Feld onHostMaintenance ein und setzen Sie es auf TERMINATE.

Wenn Sie beispielsweise eine globale Instanzvorlage für GPU-VMs erstellen möchten, stellen Sie eine POST-Anfrage:

POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/global/instanceTemplates

{
  "name": "INSTANCE_TEMPLATE_NAME",
  "properties": {
    "disks": [
      {
        "type": "PERSISTENT",
        "boot": true,
        "mode": "READ_WRITE",
        "initializeParams": {
          "sourceImage": "projects/IMAGE_PROJECT/global/images/IMAGE"
        }
      }
    ],
    "machineType": "MACHINE_TYPE",
    "networkInterfaces": [
      {
        "accessConfigs": [
          {
            "name": "external-IP",
            "type": "ONE_TO_ONE_NAT"
          }
        ],
        "network": "global/networks/default"
      }
    ],
    "scheduling": {
      "onHostMaintenance": "TERMINATE"
    }
  }
}

Ersetzen Sie Folgendes:

• PROJECT_ID: ID des Projekts, in dem Sie die Instanzvorlage erstellen möchten.

• INSTANCE_TEMPLATE_NAME ist der Name der Instanzvorlage.

• IMAGE_PROJECT ist das Image-Projekt, das das Image enthält; Beispiel: debian-cloud. Weitere Informationen zu den unterstützten Image-Projekten finden Sie unter Öffentliche Images.

• Für IMAGE oder IMAGE_FAMILY muss eine der folgenden Optionen angegeben werden:

  • IMAGE ist eine bestimmte Version des Betriebssystem-Images; Beispiel: debian-10-buster-v20200309.

  • IMAGE_FAMILY ist eine Image-Familie. Damit wird das neueste nicht verworfene Betriebssystem-Image angegeben. Wenn Sie beispielsweise debian-10 angeben, wird die neueste Version in der Debian 10-Image-Familie verwendet. Weitere Informationen zur Verwendung von Image-Familien finden Sie unter Best Practices für Image-Familien.

• MACHINE_TYPE: der Maschinentyp der VMs. Wenn Sie einen N1-Maschinentyp angeben, fügen Sie das Flag guestAccelerators ein, um die Anzahl und den Typ der GPUs anzugeben, die an Ihre VMs angehängt werden sollen.

Angenommen, Sie möchten eine globale Instanzvorlage für GPU-VMs mit den folgenden Attributen erstellen:

• Ein vordefinierter N1-Maschinentyp mit 2 vCPUs.

• Eine NVIDIA T4-GPU, die an die VMs angehängt wird.

• Debian als Image-Projekt

• Debian 10 als Image-Familie

Um die Beispielinstanzvorlage zu erstellen, stellen Sie eine POST-Anfrage so:

POST https://compute.googleapis.com/compute/v1/projects/example-project/global/instanceTemplates

{
  "name": "instance-template-gpu",
  "properties": {
    "disks": [
      {
        "type": "PERSISTENT",
        "boot": true,
        "mode": "READ_WRITE",
        "initializeParams": {
          "sourceImage": "projects/debian-cloud/global/images/debian-10"
        }
      }
    ],
    "guestAccelerators": [
      {
        "acceleratorType": "nvidia-tesla-t4",
        "acceleratorCount": 1
      }
    ],
    "machineType": "n1-standard-2",
    "networkInterfaces": [
      {
        "accessConfigs": [
          {
            "name": "external-IP",
            "type": "ONE_TO_ONE_NAT"
          }
        ],
        "network": "global/networks/default"
      }
    ],
    "scheduling": {
      "onHostMaintenance": "TERMINATE"
    }
  }
}

Weitere Konfigurationsoptionen beim Erstellen einer Instanzvorlage finden Sie in diesem Dokument unter Instanzvorlage erstellen.

Instanzvorlage mit einem Container-Image erstellen

Sie können ein Container-Image in einer Instanzvorlage angeben. Standardmäßig enthält Compute Engine in der Vorlage auch ein Container-Optimized OS-Image mit installiertem Docker. Wenn Sie die Vorlage zum Erstellen einer neuen Instanz verwenden, wird der Container beim Start der Instanz automatisch gestartet.

Console

1. Rufen Sie die Seite Instanzvorlagen auf.

   Zu Instanzvorlagen

2. Klicken Sie auf Instanzvorlage erstellen.

3. Klicken Sie im Abschnitt Container auf Container bereitstellen.

4. Geben Sie im Dialogfeld Container konfigurieren das zu verwendende Container-Image an.

   • Sie können ein Image aus der Container Registry oder der Artifact Registry angeben. Beispiel:
     • gcr.io/cloud-marketplace/google/nginx1:TAG, wobei TAG das Tag ist, das für eine bestimmte Version des NGINX-Container-Images definiert ist, das auf dem Google Cloud Marketplace verfügbar ist.
     • us-docker.pkg.dev/google-samples/containers/gke/hello-app:1.0 wählt ein Beispiel-hello-app-Image aus, das in Artifact Registry gespeichert ist.
   • Wenn Sie ein Container-Image von Docker Hub verwenden, geben Sie immer den vollständigen Docker-Image-Namen an. Geben Sie zum Beispiel den folgenden Image-Namen an, um ein Apache-Container-Image bereitzustellen: docker.io/httpd:2.4.

5. Klicken Sie optional auf Erweiterte Containeroptionen. Weitere Informationen finden Sie unter Optionen zum Ausführen von Containern konfigurieren.

6. Klicken Sie auf Erstellen.

gcloud

Führen Sie den Befehl gcloud compute instance-templates create-with-container aus:

gcloud compute instance-templates create-with-container INSTANCE_TEMPLATE_NAME \
     --container-image=CONTAINER_IMAGE

Ersetzen Sie Folgendes:

• INSTANCE_TEMPLATE_NAME: Der Name der zu erstellenden Vorlage.
• CONTAINER_IMAGE: Der vollständige Name des zu verwendenden Container-Images.

Mit dem folgenden Befehl wird beispielsweise eine neue Instanzvorlage mit dem Namen nginx-vm erstellt. Eine aus dieser Vorlage erstellte VM-Instanz startet das Container-Image gcr.io/cloud-marketplace/google/nginx1:TAG und führt es aus, wenn die VM gestartet wird.

gcloud compute instance-templates create-with-container nginx-vm \
     --container-image=gcr.io/cloud-marketplace/google/nginx1:TAG

Ersetzen Sie TAG durch das für eine bestimmte Version des NGINX-Container-Images definierte Tag, das im Google Cloud Marketplace verfügbar ist.

Sie können auch Optionen zum Ausführen des Containers konfigurieren.

Hinweis: Container Registry wurde verworfen. Organisationen, die Container Registry vor dem 8. Januar 2024 nicht verwendet haben, werden standardmäßig neue gcr.io-Repositories in Artifact Registry gehostet. Nach dem 15. Mai 2024 unterstützen Google Cloud-Projekte ohne vorherige Verwendung von Container Registry nur das Hosting und die Verwaltung von Images für die Domain gcr.io in Artifact Registry. Weitere Informationen finden Sie unter Einstellung von Container Registry.

Erstellen einer Instanzvorlage, die ein Subnetz spezifiziert

gcloud

Verwenden Sie zum Erstellen einer regionalen oder globalen Instanzvorlage den instance-templates create-Befehl: Mit dem Flag --subnet können Sie Instanzen, die aus der Vorlage erstellt wurden, in das Subnetz Ihrer Wahl einfügen. Für das Flag --subnet ist das Flag --region erforderlich.

Wenn Sie eine regionale Instanzvorlage erstellen möchten, müssen Sie das --instance-template-region-Flag verwenden, um die Region der Vorlage festzulegen. Achten Sie darauf, dass Sie ein Subnetz aus der Region verwenden, in der Sie die regionale Instanzvorlage erstellen möchten.

gcloud compute instance-templates create INSTANCE_TEMPLATE_NAME \
  --region=REGION \
  --subnet=SUBNET_NAME_OR_URL \
  --instance-template-region=INSTANCE_TEMPLATE_REGION

Ersetzen Sie Folgendes:

• INSTANCE_TEMPLATE_NAME: Der Name der Instanzvorlage.
• REGION: Die Region des Subnetzes.

• SUBNET_NAME_OR_URL: Entweder der Name des Subnetzes oder seine URL.

  Hinweis: Wenn Sie den Namen des Subnetzes verwenden, findet Google das Subnetz in der Zielregion (sofern es dort vorhanden ist). Wenn Sie jedoch die URL des Subnetzes verwenden, können Sie mit der Instanzvorlage nur in der Region Instanzen erstellen, die der URL des Subnetzes zugeordnet ist.

• INSTANCE_TEMPLATE_REGION: Region, in der Sie die Instanzvorlage erstellen möchten. Diese muss mit REGION übereinstimmen.

Im folgenden Beispiel wird eine Vorlage namens template-qa erstellt, die nur Instanzen im Subnetz subnet-us-qa erstellt.

gcloud compute instance-templates create template-qa \
  --region=us-central1 \
  --subnet=subnet-us-qa

Created [https://compute.googleapis.com/compute/latest/projects/PROJECT_ID/global/instanceTemplates/template-qa].
NAME        MACHINE_TYPE        PREEMPTIBLE CREATION_TIMESTAMP
template-qa e2-standard-2       2019-12-23T20:34:00.791-07:00

Einfach loslegen (Go)

compute/instance-templates/create-instance-templates/create_template_with_subnet.go

Auf GitHub ansehen Feedback

import (
	"context"
	"fmt"
	"io"

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

// createTemplateWithSubnet creates an instance template that uses a provided subnet.
func createTemplateWithSubnet(w io.Writer, projectID, network, subnetwork, templateName string) error {
	// projectID := "your_project_id"
	// network := "projects/project/global/networks/network"
	// subnetwork := "projects/project/regions/region/subnetworks/subnetwork"
	// templateName := "your_template_name"

	ctx := context.Background()
	instanceTemplatesClient, err := compute.NewInstanceTemplatesRESTClient(ctx)
	if err != nil {
		return fmt.Errorf("NewInstanceTemplatesRESTClient: %w", err)
	}
	defer instanceTemplatesClient.Close()

	req := &computepb.InsertInstanceTemplateRequest{
		Project: projectID,
		InstanceTemplateResource: &computepb.InstanceTemplate{
			Name: proto.String(templateName),
			Properties: &computepb.InstanceProperties{
				// The template describes the size and source image of the boot disk
				// to attach to the instance.
				Disks: []*computepb.AttachedDisk{
					{
						InitializeParams: &computepb.AttachedDiskInitializeParams{
							DiskSizeGb:  proto.Int64(250),
							SourceImage: proto.String("projects/debian-cloud/global/images/family/debian-11"),
						},
						AutoDelete: proto.Bool(true),
						Boot:       proto.Bool(true),
					},
				},
				MachineType: proto.String("e2-standard-4"),
				// The template connects the instance to the specified network and subnetwork.
				NetworkInterfaces: []*computepb.NetworkInterface{
					{
						Network:    proto.String(network),
						Subnetwork: proto.String(subnetwork),
					},
				},
			},
		},
	}

	op, err := instanceTemplatesClient.Insert(ctx, req)
	if err != nil {
		return fmt.Errorf("unable to create instance template: %w", err)
	}

	if err = op.Wait(ctx); err != nil {
		return fmt.Errorf("unable to wait for the operation: %w", err)
	}

	fmt.Fprintf(w, "Instance template created\n")

	return nil
}

Java

compute/cloud-client/src/main/java/compute/CreateTemplateWithSubnet.java

Auf GitHub ansehen Feedback

import com.google.cloud.compute.v1.AttachedDisk;
import com.google.cloud.compute.v1.AttachedDiskInitializeParams;
import com.google.cloud.compute.v1.GlobalOperationsClient;
import com.google.cloud.compute.v1.InsertInstanceTemplateRequest;
import com.google.cloud.compute.v1.InstanceProperties;
import com.google.cloud.compute.v1.InstanceTemplate;
import com.google.cloud.compute.v1.InstanceTemplatesClient;
import com.google.cloud.compute.v1.NetworkInterface;
import com.google.cloud.compute.v1.Operation;
import java.io.IOException;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.TimeoutException;

public class CreateTemplateWithSubnet {

  public static void main(String[] args)
      throws IOException, ExecutionException, InterruptedException, TimeoutException {
    /*
    TODO(developer): Replace these variables before running the sample.
    projectId: project ID or project number of the Cloud project you use.
    network: the network to be used in the new template. This value uses
        the following format: "projects/{project}/global/networks/{network}"
    subnetwork: the subnetwork to be used in the new template. This value
        uses the following format: "projects/{project}/regions/{region}/subnetworks/{subnetwork}"
    templateName: name of the new template to create.
    */
    String projectId = "your-project-id";
    String network = String.format("projects/%s/global/networks/%s", projectId, "network");
    String subnetwork = String.format("projects/%s/regions/%s/subnetworks/%s", projectId, "region",
        "subnetwork");
    String templateName = "template-name";
    createTemplateWithSubnet(projectId, network, subnetwork, templateName);
  }

  // Create an instance template that uses a provided subnet.
  public static void createTemplateWithSubnet(String projectId, String network, String subnetwork,
      String templateName)
      throws IOException, ExecutionException, InterruptedException, TimeoutException {
    try (InstanceTemplatesClient instanceTemplatesClient = InstanceTemplatesClient.create();
        GlobalOperationsClient globalOperationsClient = GlobalOperationsClient.create()) {

      AttachedDisk disk = AttachedDisk.newBuilder()
          .setInitializeParams(AttachedDiskInitializeParams.newBuilder()
              .setSourceImage(
                  String.format("projects/%s/global/images/family/%s", "debian-cloud", "debian-11"))
              .setDiskSizeGb(250).build())
          .setAutoDelete(true)
          .setBoot(true)
          .build();

      InstanceProperties instanceProperties = InstanceProperties.newBuilder()
          .addDisks(disk)
          .setMachineType("e2-standard-4")
          .addNetworkInterfaces(NetworkInterface.newBuilder()
              .setNetwork(network)
              .setSubnetwork(subnetwork).build())
          .build();

      InstanceTemplate instanceTemplate = InstanceTemplate.newBuilder()
          .setName(templateName)
          .setProperties(instanceProperties)
          .build();

      InsertInstanceTemplateRequest insertInstanceTemplateRequest = InsertInstanceTemplateRequest
          .newBuilder()
          .setProject(projectId)
          .setInstanceTemplateResource(instanceTemplate)
          .build();

      Operation operation = instanceTemplatesClient.insertCallable()
          .futureCall(insertInstanceTemplateRequest).get(3, TimeUnit.MINUTES);

      Operation response = globalOperationsClient.wait(projectId, operation.getName());

      if (response.hasError()) {
        System.out.println("Template creation from subnet failed ! ! " + response);
        return;
      }
      System.out.printf("Template creation from subnet operation status %s: %s", templateName,
          response.getStatus());
    }
  }
}

Node.js

compute/create-instance-templates/createTemplateWithSubnet.js

Auf GitHub ansehen Feedback

/**
 * TODO(developer): Uncomment and replace these variables before running the sample.
 */
// const projectId = 'YOUR_PROJECT_ID';
// const network = 'projects/project/global/networks/network';
// const subnetwork = 'projects/project/regions/region/subnetworks/subnetwork';
// const templateName = 'your_template_name';

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

// Create an instance template that uses a provided subnet.
async function createTemplateWithSubnet() {
  const instanceTemplatesClient = new compute.InstanceTemplatesClient();

  const [response] = await instanceTemplatesClient.insert({
    project: projectId,
    instanceTemplateResource: {
      name: templateName,
      properties: {
        // The template describes the size and source image of the boot disk
        // to attach to the instance.
        disks: [
          {
            // The template describes the size and source image of the boot disk
            // to attach to the instance.
            initializeParams: {
              diskSizeGb: '250',
              sourceImage:
                'projects/debian-cloud/global/images/family/debian-11',
            },
            autoDelete: true,
            boot: true,
          },
        ],
        machineType: 'e2-standard-4',
        // The template connects the instance to the specified network and subnetwork.
        networkInterfaces: [
          {
            network,
            subnetwork,
          },
        ],
      },
    },
  });
  let operation = response.latestResponse;
  const operationsClient = new compute.GlobalOperationsClient();

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

  console.log('Instance template created.');
}

createTemplateWithSubnet();

Python

compute/client_library/snippets/instance_templates/create_with_subnet.py

Auf GitHub ansehen Feedback

from __future__ import annotations

import sys
from typing import Any

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

def wait_for_extended_operation(
    operation: ExtendedOperation, verbose_name: str = "operation", timeout: int = 300
) -> Any:
    """
    Waits for the extended (long-running) operation to complete.

    If the operation is successful, it will return its result.
    If the operation ends with an error, an exception will be raised.
    If there were any warnings during the execution of the operation
    they will be printed to sys.stderr.

    Args:
        operation: a long-running operation you want to wait on.
        verbose_name: (optional) a more verbose name of the operation,
            used only during error and warning reporting.
        timeout: how long (in seconds) to wait for operation to finish.
            If None, wait indefinitely.

    Returns:
        Whatever the operation.result() returns.

    Raises:
        This method will raise the exception received from `operation.exception()`
        or RuntimeError if there is no exception set, but there is an `error_code`
        set for the `operation`.

        In case of an operation taking longer than `timeout` seconds to complete,
        a `concurrent.futures.TimeoutError` will be raised.
    """
    result = operation.result(timeout=timeout)

    if operation.error_code:
        print(
            f"Error during {verbose_name}: [Code: {operation.error_code}]: {operation.error_message}",
            file=sys.stderr,
            flush=True,
        )
        print(f"Operation ID: {operation.name}", file=sys.stderr, flush=True)
        raise operation.exception() or RuntimeError(operation.error_message)

    if operation.warnings:
        print(f"Warnings during {verbose_name}:\n", file=sys.stderr, flush=True)
        for warning in operation.warnings:
            print(f" - {warning.code}: {warning.message}", file=sys.stderr, flush=True)

    return result

def create_template_with_subnet(
    project_id: str, network: str, subnetwork: str, template_name: str
) -> compute_v1.InstanceTemplate:
    """
    Create an instance template that uses a provided subnet.

    Args:
        project_id: project ID or project number of the Cloud project you use.
        network: the network to be used in the new template. This value uses
            the following format: "projects/{project}/global/networks/{network}"
        subnetwork: the subnetwork to be used in the new template. This value
            uses the following format: "projects/{project}/regions/{region}/subnetworks/{subnetwork}"
        template_name: name of the new template to create.

    Returns:
        InstanceTemplate object that represents the new instance template.
    """
    # The template describes the size and source image of the book disk to
    # attach to the instance.
    disk = compute_v1.AttachedDisk()
    initialize_params = compute_v1.AttachedDiskInitializeParams()
    initialize_params.source_image = (
        "projects/debian-cloud/global/images/family/debian-11"
    )
    initialize_params.disk_size_gb = 250
    disk.initialize_params = initialize_params
    disk.auto_delete = True
    disk.boot = True

    template = compute_v1.InstanceTemplate()
    template.name = template_name
    template.properties = compute_v1.InstanceProperties()
    template.properties.disks = [disk]
    template.properties.machine_type = "e2-standard-4"

    # The template connects the instance to the specified network and subnetwork.
    network_interface = compute_v1.NetworkInterface()
    network_interface.network = network
    network_interface.subnetwork = subnetwork
    template.properties.network_interfaces = [network_interface]

    template_client = compute_v1.InstanceTemplatesClient()
    operation = template_client.insert(
        project=project_id, instance_template_resource=template
    )
    wait_for_extended_operation(operation, "instance template creation")

    return template_client.get(project=project_id, instance_template=template_name)

Wenn Sie mit dieser Vorlage eine Instanz für eine MIG (mit oder ohne Autoscaling) erstellen, wird die Instanz automatisch in der angegebenen Region und im angegebenen Subnetz erstellt. Auf diese Weise können Sie das Subnetz von neuen Instanzen kontrollieren, die für das Load-Balancing erstellt wurden.

Verwendung benutzerdefinierter und öffentlicher Images in Ihren Instanzvorlagen

Sie können entweder ein benutzerdefiniertes Image oder ein öffentliches Image für Ihre Instanzvorlagen verwenden:

• Benutzerdefinierte Images. Weil MIGs darauf ausgerichtet sind, dass Instanzen oft hinzugefügt und entfernt werden, ist es sinnvoll, ein benutzerdefiniertes Image zu erstellen und dieses in der Instanzvorlage anzugeben. Sie können das Image mit den Anwendungen und Einstellungen vorbereiten, die Ihre VMs benötigen, sodass Sie diese Elemente bei einzelnen VMs der MIG nicht manuell konfigurieren müssen.

• Öffentliche Images Sie können eine Instanzvorlage erstellen, die ein öffentliches Image und ein Startskript für die Vorbereitung der Instanz nach dem Start verwendet.

Benutzerdefinierte Images sind deterministischer und starten schneller als VMs mit Startskripts. Auf der anderen Seite sind Startskripts flexibler und ermöglichen Ihnen, die Anwendungen und Einstellungen in Ihren Instanzen leichter zu verändern.

Wenn Sie Images mithilfe von Image-Familien verwalten, können Sie den Namen der benutzerdefinierten oder öffentlichen Image-Familie in der Instanzvorlage angeben. Weitere Informationen zu Image-Familien finden Sie unter Best Practices für die Verwendung von Image-Familien in Compute Engine.

Hinweis: Das jeweilige Image können Sie in Ihrer Instanzvorlage auch dann verwenden, wenn es zu einem anderen Projekt gehört. Voraussetzung dafür ist, dass der Inhaber dieses Projekts der MIG Zugriff auf das Image gewährt. Weitere Informationen finden Sie unter Einer verwalteten Instanzgruppe Zugriff auf Images gewähren.

Nächste Schritte

• VM aus einer Instanzvorlage erstellen
• Zonale verwaltete Instanzgruppe (MIG) erstellen
• Eine regionale MIG erstellen
• VMs in einer vorhandenen MIG aktualisieren, um die Konfiguration aus einer neuen Vorlage zu verwenden
• Eine Reservierung für VMs erstellen