Crea template di istanza

Questa pagina descrive come creare e gestire i template di istanza. I template di istanza ti consentono di specificare il tipo di macchina, l'immagine del disco di avvio, la rete e altre proprietà della VM da utilizzare quando crei istanze di macchine virtuali (VM).

Puoi utilizzare i template di istanza per:

Prima di iniziare

Limitazioni

  • Il VPC condiviso su interfacce diverse da nic0 per i template di istanza è supportato in gcloud CLI e REST, ma non nella consoleGoogle Cloud .
  • Non puoi aggiornare un template di istanza esistente o modificarlo dopo la sua creazione. Se un template di istanza non è più aggiornato o se devi apportare modifiche alla configurazione, crea un nuovo template di istanza.
  • Se vuoi specificare una famiglia di immagini in un template di istanza, non puoi utilizzare la console Google Cloud . In alternativa, puoi utilizzare Google Cloud CLI o REST.
  • Se vuoi specificare dischi a livello di regione anziché dischi zonali in un template di istanza, non puoi utilizzare la console Google Cloud . In alternativa, puoi utilizzare Google Cloud CLI o REST.
  • Puoi utilizzare un template di istanza per creare VM con un disco di avvio Hyperdisk bilanciato che si trova in un pool di archiviazione, se il pool di archiviazione esiste nella stessa zona in cui è stata creata la VM. Non puoi utilizzare i template di istanza globali per creare VM con dischi non di avvio che si trovano in un pool di archiviazione.

Crea un template di istanza

La maggior parte delle proprietà delle VM che puoi specificare in una richiesta per creare un'istanza VM singola può essere specificata anche per un template di istanza, inclusi eventuali metadati della VM, script di avvio, dischi permanenti e service account. Devi specificare il tipo di macchina, il disco di avvio e la rete.

Crea un template di istanza regionale o globale tramite la Google Cloud console, Google Cloud CLI o l'API. Per creare un template di istanza globale, puoi anche utilizzare Terraform o le librerie client di Cloud.

Console

  1. Nella console Google Cloud , vai alla pagina Template di istanza.

    Vai a Template di istanza

    I passaggi rimanenti vengono visualizzati nella console Google Cloud .

  2. Fai clic su Crea template di istanza.
  3. Seleziona la Località come descritto di seguito:
    1. Se vuoi utilizzare il template di istanza tra regioni, scegli Globale.
    2. Se vuoi ridurre la dipendenza tra regioni, scegli Regionale.
  4. Se hai scelto Regionale, seleziona la Regione in cui creare il template di istanza.

  5. Per i campi seguenti, accetta i valori predefiniti o modificali in base alle necessità. I valori predefiniti cambiano in base alla famiglia di macchine selezionata.

    • Seleziona un Tipo di macchina.
    • Per aggiornare il tipo o l'immagine del disco di avvio, fai clic su Cambia nella sezione Disco di avvio.
    • Per aggiornare l'interfaccia di rete o le impostazioni relative agli indirizzi IP, fai clic su Opzioni avanzate, quindi su Networking e infine sull'interfaccia di rete da modificare.

  6. (Facoltativo) Se hai scelto un'immagine che supporta Shielded VM, modifica le impostazioni della Shielded VM:

    1. Fai clic su Opzioni avanzate, quindi sulla scheda Sicurezza.
    2. Se vuoi disattivare l'avvio protetto, deseleziona la casella di controllo Attiva Avvio protetto. L'avvio protetto consente di proteggere le istanze VM da rootkit e malware a livello di avvio e di kernel. Per ulteriori informazioni, consulta Avvio protetto.

    3. Se vuoi disattivare il Virtual Trusted Platform Module (vTPM), deseleziona la casella di controllo Attiva vTPM. Il vTPM abilita l'avvio con misurazioni, che convalida l'integrità in fase di pre-avvio e avvio della VM. Per saperne di più, consulta Virtual Trusted Platform Module (vTPM).

    4. Se vuoi disattivare il monitoraggio dell'integrità, deseleziona la casella di controllo Attiva il monitoraggio dell'integrità. Il monitoraggio dell'integrità consente di monitorare l'integrità in fase di avvio delle istanze Shielded VM utilizzando Cloud Monitoring. Per ulteriori informazioni, consulta Monitoraggio dell'integrità.

  7. (Facoltativo) In Opzioni avanzate, fai clic sulle schede per personalizzare ulteriormente il template. Ad esempio, puoi aggiungere fino a 15 dischi secondari non di avvio.

  8. (Facoltativo) Fai clic su REST equivalente per visualizzare il corpo della richiesta REST, che include la rappresentazione JSON del template di istanza.

  9. Fai clic su Crea per creare il template.

gcloud

Per creare un template di istanza regionale o globale, utilizza il comando instance-templates create. Per un template di istanza regionale, devi utilizzare il flag --instance-template-region per impostare la regione del template.

Crea un template di istanza a livello di regione utilizzando il seguente comando.

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

Sostituisci REGION con la regione in cui vuoi creare il template di istanza regionale.

Crea un template di istanza globale utilizzando il seguente comando:

gcloud compute instance-templates create INSTANCE_TEMPLATE_NAME

Se non fornisci impostazioni del template esplicite, gcloud compute utilizza i seguenti valori predefiniti:

  • Tipo di macchina: il tipo di macchina, ad esempio n1-standard-1
  • Immagine: l'immagine Debian più recente
  • Disco di avvio: un nuovo disco di avvio standard denominato in base alla VM
  • Rete: la rete VPC predefinita
  • Indirizzo IP: un indirizzo IPv4 esterno temporaneo
  • Tipo di stack: IPV4_ONLY

Puoi anche fornire esplicitamente queste impostazioni di configurazione. Ad esempio:

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

Puoi aggiungere fino a 15 dischi secondari non di avvio. Specifica il flag --create-disk per ogni disco secondario creato. Per creare dischi secondari da un'immagine pubblica o personalizzata, specifica le proprietà image e image-project per ogni disco nel flag --create-disk. Per creare un disco vuoto, non includere queste proprietà. Facoltativamente, includi le proprietà size e type del disco. Per specificare i dischi regionali, utilizza la proprietà replica-zones.

gcloud compute instance-templates create INSTANCE_TEMPLATE_NAME \
    --machine-type=MACHINE_TYPE \
    --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

Suggerimento: quando specifichi il parametro replica-zones del disco, i caratteri ^:^ specificano che il carattere di separazione tra i valori è costituito da due punti (:) anziché dalla virgola (,) prevista.

Sostituisci quanto segue:

  • INSTANCE_TEMPLATE_NAME: il nome del template
  • MACHINE_TYPE: il tipo di macchina delle VM

  • DISK_IMAGE_FAMILY: una famiglia di immagini da utilizzare come disco non di avvio

    Per ulteriori informazioni sulle famiglie di immagini, consulta le best practice per l'utilizzo delle famiglie di immagini su Compute Engine.

    In alternativa, puoi utilizzare il flag --image=IMAGE per specificare una versione specifica di un'immagine.

    Per i dischi vuoti, non specificare la proprietà image-family o image.

  • DISK_IMAGE_PROJECT: il progetto che contiene l'immagine

    Per i dischi vuoti, non specificare la proprietà image-project. Per saperne di più sulle immagini pubbliche, consulta Immagini pubbliche.

  • SIZE_GB_DISK1 e SIZE_GB_DISK2: le dimensioni di ciascun disco secondario.

  • DISK_NAME: (Facoltativo) il nome del disco visualizzato per il sistema operativo guest dopo la creazione della VM.

  • DISK_TYPE: (Facoltativo) il tipo di disco da creare. Se non specificato, il tipo di disco predefinito utilizzato dipende dal valore del flag --machine-type.

  • ZONE e REMOTE_ZONE: la zona in cui creare il disco regionale e la zona in cui replicarlo.

    Per i dischi zonali, non includere la proprietà replica-zones.

Se hai scelto un'immagine che supporta la Shielded VM, puoi facoltativamente modificare le impostazioni della Shielded VM dell'istanza utilizzando uno dei seguenti flag:

  • --no-shielded-secure-boot: disattiva l'avvio protetto

    L'avvio protetto consente di proteggere le istanze VM da rootkit e malware a livello di avvio e di kernel. Per ulteriori informazioni, consulta Avvio protetto.

  • --no-shielded-vtpm: disattiva il Virtual Trusted Platform Module (vTPM)

    Il vTPM abilita l'avvio con misurazioni, che convalida l'integrità della VM in fase di pre-avvio e avvio. Per ulteriori informazioni, consulta Virtual Trusted Platform Module (vTPM).

  • --no-shielded-integrity-monitoring: disattiva il monitoraggio dell'integrità

    Il monitoraggio dell'integrità consente di controllare l'integrità in fase di avvio delle istanze Shielded VM mediante Cloud Monitoring. Per ulteriori informazioni, consulta Monitoraggio dell'integrità.

Per un elenco di tutti i sottocomandi e i flag disponibili, consulta il riferimento instance-templates.

Un template con le impostazioni di configurazione predefinite potrebbe avere il seguente aspetto:

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-12
    kind: compute#attachedDisk
    mode: READ_WRITE
    type: PERSISTENT
  machineType: c3-standard-4
  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

Per creare un template di istanza, puoi utilizzare la risorsa google_compute_instance_template.

Il seguente esempio di Terraform è simile al seguente comando gcloud CLI:

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

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/cloud-platform"
    ]
  }
}

Per scoprire come applicare o rimuovere una configurazione Terraform, consulta Comandi Terraform di base.

Go 

import (
	"context"
	"fmt"
	"io"

	compute "cloud.google.com/go/compute/apiv1"
	computepb "cloud.google.com/go/compute/apiv1/computepb"
	"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 

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-11").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 

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

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

Per creare un template di istanza regionale, effettua una richiesta POST al metodo regionInstanceTemplates.insert come segue:

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

Per creare un template di istanza globale, effettua una richiesta POST al metodo instanceTemplates.insert:

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

Puoi aggiungere fino a 15 dischi secondari non di avvio utilizzando la proprietà disks, con un campo per ogni disco aggiuntivo. Per ogni disco aggiuntivo, puoi:

  • Creare dischi aggiuntivi con un'immagine pubblica o personalizzata.
  • Per aggiungere un disco vuoto, definisci la voce initializeParams senza valore sourceImage.
  • Per creare dischi a livello di regione, definisci la voce initializeParams con la proprietà replicaZones.

Nel corpo della richiesta, fornisci le proprietà del template:

{
  "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"
          ]
        }
      }
    ]
  }
}

Sostituisci quanto segue:

  • PROJECT_ID: il tuo ID progetto
  • REGION: la regione in cui vuoi creare il template di istanza regionale
  • INSTANCE_TEMPLATE_NAME: il nome del template di istanza
  • ZONE: la zona in cui si trovano le VM

  • MACHINE_TYPE: il tipo di macchina delle VM

  • IMAGE_PROJECT: il progetto di immagini che contiene l'immagine

    Per ulteriori informazioni sulle immagini pubbliche, consulta Immagini pubbliche.

  • IMAGE o IMAGE_FAMILY: specifica una delle seguenti opzioni:
    • IMAGE: una versione specifica dell'immagine

      Ad esempio, "sourceImage": "projects/debian-cloud/global/images/debian-10-buster-v20200309"

    • IMAGE_FAMILY: una famiglia di immagini

      In questo modo, la VM viene creata dall'immagine sistema operativo più recente e non deprecata. Ad esempio, se specifichi "sourceImage": "projects/debian-cloud/global/images/family/debian-10", Compute Engine crea una VM dall'ultima versione dell'immagine sistema operativo nella famiglia di immagini Debian 10.

      Per saperne di più sulle famiglie di immagini, consulta le best practice per l'utilizzo delle famiglie di immagini su Compute Engine.

  • DISK_NAME: (Facoltativo) il nome del disco visualizzato per il sistema operativo guest dopo la creazione della VM.

  • PROJECT_NAME: il progetto associato alla VM

  • REMOTE_ZONE: la zona in cui deve essere replicato il disco regionale

Per la proprietà disks puoi specificare una delle seguenti opzioni:

  • Specifica initializeParams per creare dischi di avvio per ogni istanza. Puoi creare dischi utilizzando immagini pubbliche o personalizzate (o famiglie di immagini) utilizzando la proprietà sourceImage, come mostrato nell'esempio precedente. Per aggiungere dischi vuoti, non specificare una sourceImage. Puoi anche aggiungere fino a 15 dischi secondari non di avvio utilizzando la proprietà initializeParams per ogni disco aggiuntivo.

  • Specifica source per collegare un disco di avvio esistente. Se colleghi un disco di avvio esistente, puoi creare una sola istanza dal tuo template.

Facoltativamente, puoi specificare le proprietà diskSizeGb, diskType e labels per initializeParams e la proprietà diskSizeGb per source.

Se hai scelto un'immagine che supporta Shielded VM, puoi facoltativamente modificare le impostazioni Shielded VM della VM utilizzando i seguenti elementi del corpo della richiesta booleani:

  • enableSecureBoot: attiva o disattiva l'avvio protetto

    L'avvio protetto consente di proteggere le istanze VM da rootkit e malware a livello di avvio e di kernel. Per ulteriori informazioni, consulta Avvio protetto.

  • enableVtpm: attiva o disattiva il Virtual Trusted Platform Module (vTPM)

    Il vTPM abilita l'avvio con misurazioni, che convalida l'integrità della VM in fase di pre-avvio e avvio. Per ulteriori informazioni, consulta Virtual Trusted Platform Module (vTPM).

  • enableIntegrityMonitoring: attiva o disattiva il monitoraggio dell'integrità

    Il monitoraggio dell'integrità consente di controllare e verificare l'integrità in fase di avvio runtime delle istanze Shielded VM mediante report di Cloud Monitoring. Per ulteriori informazioni, consulta Monitoraggio dell'integrità.

Per saperne di più sui parametri di richiesta, consulta il metodo instanceTemplates.insert.

Crea un template di istanza basato su un'istanza esistente

Puoi utilizzare REST o gcloud CLI per salvare la configurazione di un'istanza VM esistente come template di istanza. Facoltativamente, puoi eseguire l'override della definizione dei dischi di origine nel template.

Se devi eseguire l'override di altre proprietà, crea innanzitutto un template di istanza basato su un'istanza esistente, quindi crea un template simile con ulteriori override.

gcloud

Utilizza il comando gcloud compute instance-templates create con i flag --source-instance e --source-instance-zone. Se vuoi creare un template di istanza regionale, devi utilizzare anche il flag --instance-template-region per specificare la regione del template di istanza.

Per creare un template di istanza regionale, utilizza il seguente comando:

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

Per creare un template di istanza globale, utilizza il seguente comando:

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

Per eseguire l'override della definizione dei dischi dell'istanza di origine, aggiungi uno o più flag --configure-disk.

L'esempio seguente crea un template di istanza globale da un'istanza esistente ed esegue l'override del disco dell'istanza di origine con le specifiche fornite.

  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

Sostituisci quanto segue:

  • INSTANCE_TEMPLATE_NAME è il nome del template da creare.
  • SOURCE_INSTANCE è il nome dell'istanza da utilizzare come modello per il nuovo template.
  • SOURCE_INSTANCE_ZONE è la zona che contiene l'istanza di origine.
  • SOURCE_DISK è il nome di un disco dell'istanza di origine di cui vuoi eseguire l'override all'interno del template.

  • INSTANTIATE_OPTIONS specifica se includere il disco e quale immagine utilizzare. I valori validi dipendono dal tipo di disco:

    • source-image o source-image-family (valido solo per i dischi di avvio e altri dischi di lettura/scrittura permanenti). Specifica questa opzione se vuoi utilizzare la stessa immagine di origine o famiglia di immagini di origine utilizzata per creare il disco nell'istanza VM di origine.

    • custom-image (valido solo per i dischi di avvio e altri dischi di lettura/scrittura permanenti). Se vuoi conservare le applicazioni e le impostazioni delle VM di origine nel template di istanza, puoi creare un'immagine personalizzata e specificarla al momento della creazione del template. Se specificata, fornisci il percorso o l'URL dell'immagine personalizzata, come mostrato nell'esempio seguente. In alternativa, puoi specificare una famiglia di immagini utilizzando il seguente formato:

      --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 (valido solo per i dischi di sola lettura).

    • blank (valido solo per i dischi permanenti non di avvio e le unità SSD locali). Se specificato, quando il template viene utilizzato per creare una nuova istanza, il disco viene creato non formattato. Devi formattare e montare il disco in uno script di avvio prima di poterlo utilizzare in una configurazione scalabile.

    • do-not-include (valido solo per i dischi permanenti non di avvio e per i dischi di sola lettura).

  • AUTO_DELETE specifica se il disco viene eliminato automaticamente quando viene eliminata l'istanza. I valori validi sono false, no, true e yes.

Ad esempio, il seguente comando crea un template di istanza basato su my-source-instance, con la possibilità di utilizzare l'immagine originale da data-disk-a, ma imposta l'eliminazione automatica su true e sostituisce data-disk-b con un'immagine personalizzata.

 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

Go 

import (
	"context"
	"fmt"
	"io"

	compute "cloud.google.com/go/compute/apiv1"
	computepb "cloud.google.com/go/compute/apiv1/computepb"
	"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 


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 

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

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

Per creare un template di istanza regionale, utilizza il metodo regionInstanceTemplates.insert oppure, per creare un template di istanza globale, utilizza il metodo instanceTemplates.insert.

Nella richiesta, devi specificare il campo sourceInstance. Per eseguire l'override della definizione dei dischi dell'istanza di origine, aggiungi uno o più campi diskConfigs.

Ad esempio, esegui la seguente chiamata per creare un template di istanza globale da un'istanza esistente.

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
      }
    ]
  }
}

Sostituisci quanto segue:

  • PROJECT_ID: il tuo ID progetto.
  • INSTANCE_TEMPLATE_NAME: il nome del nuovo template.
  • SOURCE_INSTANCE_ZONE: la zona dell'istanza di origine.
  • SOURCE_INSTANCE: il nome dell'istanza di origine da utilizzare come modello per questo template di istanza.
  • SOURCE_DISK: il nome di un disco dell'istanza di origine di cui vuoi eseguire l'override all'interno del template.

  • INSTANTIATE_OPTIONS: specifica se includere il disco e quale immagine utilizzare.

    I valori validi dipendono dal tipo di disco:

    • source-image o source-image-family (valido solo per i dischi di avvio e altri dischi permanenti in lettura/scrittura).

    • custom-image (valido solo per i dischi di avvio e altri dischi di lettura/scrittura permanenti). Se vuoi conservare le applicazioni e le impostazioni delle VM di origine nel template di istanza, puoi creare un'immagine personalizzata e specificarla al momento della creazione del template. Se specificata, fornisci il percorso o l'URL dell'immagine personalizzata, come mostrato nell'esempio seguente. In alternativa, puoi specificare una famiglia di immagini utilizzando il seguente formato:

        "diskConfigs": [
    {
      "deviceName": DATA_DISK_NAME,
      "instantiateFrom": custom-image,
      "customImage": "projects/PROJECT_ID/global/images/family/IMAGE_FAMILY_NAME"
    }
  ]

    • attach-read-only (valido solo per i dischi di sola lettura).

    • blank (valido solo per i dischi permanenti non di avvio e le unità SSD locali). Se specificato, quando il template viene utilizzato per creare una nuova istanza, il disco viene creato non formattato. Devi formattare e montare il disco in uno script di avvio prima di poterlo utilizzare in una configurazione scalabile.

    • do-not-include (valido solo per i dischi permanenti non di avvio e per i dischi di sola lettura).

L'esempio seguente crea un nuovo template di istanza basato su my-source-instance. Nel template di istanza, l'immagine di data-disk-a viene sostituita da projects/cos-cloud/global/images/cos-89-16108-403-15.

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"
      }
    ]
  }
}

La tabella seguente mostra come vengono definite le opzioni per l'override dei dischi nel template.

Tipo di disco Opzioni
Disco di avvio
  • [Valore predefinito] Utilizza la stessa immagine di origine o la stessa famiglia di immagini utilizzata per creare il disco di avvio nell'istanza di origine.
  • Utilizza l'URL di qualsiasi immagine (personalizzata o pubblica) come descritto nell'esempio precedente o specifica una famiglia di immagini utilizzando il seguente formato:

    • projects/exampleproject/global/images/family/IMAGE_FAMILY_NAME

Altri dischi permanenti di lettura/scrittura
  • [Valore predefinito] Utilizza la stessa immagine di origine/famiglia di immagini di origine utilizzata per creare il disco nell'istanza di origine. Nota: se il disco dell'istanza di origine non ha una proprietà immagine di origine/famiglia di immagini di origine, viene incluso nel template come disco vuoto.
  • Utilizza l'URL di qualsiasi immagine (personalizzata o pubblica) come descritto nell'esempio precedente o specifica una famiglia di immagini utilizzando il seguente formato:

    projects/exampleproject/global/images/family/IMAGE_FAMILY_NAME

  • Utilizza invece un disco vuoto nel template. Quando il template viene utilizzato per creare una nuova istanza, il disco viene creato non formattato. Devi formattare e montare il disco in uno script di avvio prima di poterlo utilizzare in una configurazione scalabile.
  • Non includere il disco.
Dischi di sola lettura
  • [Valore predefinito] Includi il disco in modalità di sola lettura.
  • Non includere il disco.
SSD locali
  • [Valore predefinito] Includi un'unità SSD locale vuota. Quando il template viene utilizzato per creare una nuova istanza, il disco viene creato non formattato. Devi formattare e montare il disco in uno script di avvio prima di poterlo utilizzare in una configurazione scalabile.

Per ogni disco, puoi anche eseguire l'override dell'attributo auto-delete per specificare se il disco deve essere eliminato quando viene eliminata l'istanza associata.

Per impostazione predefinita, se non vengono specificate opzioni di override, la configurazione del disco nel template corrisponde a quella dell'istanza di origine.

Crea un template di istanza basato su un template esistente

Non puoi aggiornare un template di istanza esistente. Tuttavia, se un template di istanza diventa obsoleto o se devi apportare modifiche, puoi crearne un altro con proprietà simili utilizzando la console.

  1. Vai alla pagina Template di istanza.

    Vai a Template di istanza

  2. Fai clic sul template di istanza da copiare e aggiornare.

  3. Fai clic su Crea simile.

  4. Aggiorna la configurazione nel nuovo template.

  5. Fai clic su Crea.

Crea un template di istanza per le VM GPU

Quando crei un template di istanza, puoi configurarlo per la creazione di VM con GPU collegate specificando quanto segue:

Console

Per creare un template di istanza per le VM GPU, segui questi passaggi:

  1. Nella console Google Cloud , vai alla pagina Template di istanza.

    Vai a Template di istanza

  2. Fai clic su Crea template istanza.

  3. Nel campo Nome, inserisci un nome per il template di istanza.

  4. Nella sezione Località, seleziona una delle seguenti opzioni:

    • Per creare un template di istanza globale, seleziona Globale (valore predefinito).

    • Per creare un template di istanza regionale, seleziona Regionale e poi la regione in cui vuoi creare il template di istanza.

  5. Nella sezione Configurazione macchina, segui questi passaggi:

    1. Fai clic sulla scheda GPU.

    2. Nel menu Tipo di GPU, seleziona il tipo di GPU.

    3. Nel menu Numero di GPU, seleziona il numero di GPU.

    4. (Facoltativo) Se il modello di GPU supporta le workstation virtuali (vWS) NVIDIA RTX per i workload grafici, e prevedi di eseguire workload ad alta intensità di grafica, seleziona Abilita workstation virtuale (NVIDIA GRID).

    5. Nella sezione Tipo di macchina, seleziona un tipo di macchina.

  6. (Facoltativo) Per modificare il tipo o l'immagine del disco di avvio predefinito, fai clic su Modifica nella sezione Disco di avvio. Dopodiché, segui le istruzioni per modificare il disco di avvio.

  7. Fai clic su Crea.

gcloud

Per creare un template di istanza per le VM GPU, utilizza il comando instance-templates create con il flag --maintenance-policy impostato su TERMINATE.

Ad esempio, per creare un template di istanza globale per le VM GPU, utilizza il seguente comando:

gcloud compute instance-templates create INSTANCE_TEMPLATE_NAME \
    --image-project=IMAGE_PROJECT \
    --image-family=IMAGE_FAMILY \
    --machine-type=MACHINE_TYPE \
    --maintenance-policy=TERMINATE

Sostituisci quanto segue:

  • INSTANCE_TEMPLATE_NAME: il nome del template di istanza.

  • IMAGE_PROJECT: il progetto immagine che contiene l'immagine, ad esempio debian-cloud. Per ulteriori informazioni sui progetti di immagini supportati, consulta Immagini pubbliche.

  • IMAGE_FAMILY o IMAGE: specifica una delle seguenti opzioni:

    • IMAGE_FAMILY: una famiglia di immagini. Specifica l'immagine sistema operativo più recente e non deprecata. Ad esempio, se specifichi debian-10, viene utilizzata l'ultima versione della famiglia di immagini Debian 10. Per ulteriori informazioni sull'utilizzo delle famiglie di immagini, consulta le rispettive best practice.

    • IMAGE: una versione specifica dell'immagine sistema operativo, ad esempio debian-10-buster-v20200309. Se scegli di specificare una versione specifica dell'immagine sistema operativo, devi sostituire il flag --image-family con il flag --image.

  • MACHINE_TYPE: il tipo di macchina delle VM. Se specifichi un tipo di macchina N1, includi il flag --accelerator per specificare il numero e il tipo di GPU da collegare alle VM.

Ad esempio, supponiamo che tu voglia creare un template di istanza globale per le VM GPU che specifichi le seguenti proprietà:

  • Un tipo di macchina predefinita N1 con 2 vCPU.

  • Una GPU NVIDIA T4 da collegare alle VM.

  • Debian come progetto immagine.

  • Debian 10 come famiglia di immagini.

Per creare il template di istanza di esempio, utilizza il seguente comando:

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

Per creare un template di istanza per le VM GPU, utilizza la risorsa google_compute_region_instance_template.

Ad esempio, per creare un template di istanza globale che specifica un tipo di macchina predefinita N1 con 2 vCPU e una GPU NVIDIA T4 collegata, utilizza la seguente risorsa:

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"
  }
}

Per scoprire come applicare o rimuovere una configurazione Terraform, consulta Comandi Terraform di base.

REST

Per creare un template di istanza per le VM GPU, effettua una richiesta POST al metodo instanceTemplates.insert. Nel corpo della richiesta, includi il campo onHostMaintenance e impostalo su TERMINATE.

Ad esempio, per creare un template di istanza globale per le VM GPU, effettua una richiesta POST come segue:

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"
    }
  }
}

Sostituisci quanto segue:

  • PROJECT_ID: l'ID del progetto in cui vuoi creare il template di istanza.

  • INSTANCE_TEMPLATE_NAME: il nome del template di istanza.

  • IMAGE_PROJECT: il progetto immagine che contiene l'immagine, ad esempio debian-cloud. Per ulteriori informazioni sui progetti di immagini supportati, consulta Immagini pubbliche.

  • IMAGE o IMAGE_FAMILY: specifica una delle seguenti opzioni:

    • IMAGE: una versione specifica dell'immagine sistema operativo, ad esempio debian-10-buster-v20200309.

    • IMAGE_FAMILY: una famiglia di immagini. Specifica l'immagine sistema operativo più recente e non deprecata. Ad esempio, se specifichi family/debian-10, viene utilizzata l'ultima versione della famiglia di immagini Debian 10. Per ulteriori informazioni sull'utilizzo delle famiglie di immagini, consulta le rispettive best practice.

  • MACHINE_TYPE: il tipo di macchina delle VM. Se specifichi un tipo di macchina N1, includi il campo guestAccelerators per specificare il numero e il tipo di GPU da collegare alle VM.

Ad esempio, supponiamo che tu voglia creare un template di istanza globale per le VM GPU che specifichi le seguenti proprietà:

  • Un tipo di macchina predefinita N1 con 2 vCPU.

  • Una GPU NVIDIA T4 da collegare alle VM.

  • Debian come progetto immagine.

  • Debian 10 come famiglia di immagini.

Per creare il template di istanza di esempio, effettua una richiesta POST come segue:

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/family/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"
    }
  }
}

Per altre opzioni di configurazione durante la creazione di un template di istanza, consulta Crea un template di istanza in questo documento.

Crea un template di istanza con un'immagine container

Puoi specificare un'immagine container in un template di istanza. Per impostazione predefinita, Compute Engine include nel template anche un'immagine di Container-Optimized OS con Docker installato. Quando utilizzi il template per creare una nuova istanza, il container viene avviato automaticamente all'avvio dell'istanza.

Console

  1. Vai alla pagina Template di istanza.

    Vai a Template di istanza

  2. Fai clic su Crea template istanza.

  3. Nella sezione Container, fai clic su Esegui il deployment del container.

  4. Nella finestra di dialogo Configura container, specifica l'Immagine container da utilizzare.

    • Puoi specificare un'immagine da Container Registry o Artifact Registry. Ad esempio:
      • gcr.io/cloud-marketplace/google/nginx1:TAG, dove TAG è il tag definito per una versione specifica dell'immagine container NGINX disponibile su Google Cloud Marketplace.
      • us-docker.pkg.dev/google-samples/containers/gke/hello-app:1.0 seleziona un'immagine hello-app di esempio archiviata in Artifact Registry.
    • Se utilizzi un'immagine container di Docker Hub, specifica sempre il nome completo dell'immagine Docker. Ad esempio, specifica il seguente nome dell'immagine per eseguire il deployment di un'immagine container di Apache: docker.io/httpd:2.4.

  5. Facoltativamente, fai clic su Opzioni container avanzate. Per ulteriori informazioni, consulta Configurazione delle opzioni per l'esecuzione del container.

  6. Fai clic su Crea.

gcloud

Utilizza il comando gcloud compute instance-templates create-with-container:

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

Sostituisci quanto segue:

  • INSTANCE_TEMPLATE_NAME: il nome del template da creare.
  • CONTAINER_IMAGE: il nome completo dell'immagine container da utilizzare.

Ad esempio, il seguente comando crea un nuovo template di istanza denominato nginx-vm. Un'istanza VM creata da questo template avvia ed esegue l'immagine container gcr.io/cloud-marketplace/google/nginx1:TAG all'avvio della VM.

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

Sostituisci TAG con il tag definito per una versione specifica dell'immagine container NGINX disponibile su Google Cloud Marketplace.

Puoi anche configurare opzioni per l'esecuzione del container.

Crea un template di istanza che specifica una subnet

gcloud

Per creare un template di istanza regionale o globale, utilizza il comando instance-templates create. Utilizza il flag --subnet per posizionare le istanze create dal template nella sottorete che preferisci. Il flag --subnet richiede il flag --region.

Se vuoi creare un template di istanza regionale, devi utilizzare il flag --instance-template-region per impostare la regione del template. Assicurati di utilizzare una subnet della stessa regione in cui vuoi creare il template di istanza regionale.

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

Sostituisci quanto segue:

  • INSTANCE_TEMPLATE_NAME: il nome del template di istanza.
  • REGION: la regione della subnet.

  • SUBNET_NAME_OR_URL: il nome della subnet o il relativo URL.

  • STACK_TYPE: (Facoltativo) indica se IPv6 è abilitato sull'interfaccia di rete predefinita. Puoi utilizzare i seguenti valori: IPV4_ONLY, IPV4_IPV6 o IPV6_ONLY (Anteprima). Se non includi questo flag, il valore predefinito è IPV4_ONLY.

  • INSTANCE_TEMPLATE_REGION: la regione in cui vuoi creare il template di istanza. Questa regione deve essere la stessa di REGION.

L'esempio seguente crea un template denominato template-qa che crea solo istanze nella subnet subnet-us-qa.

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

L'output è simile al seguente:

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

Go 

import (
	"context"
	"fmt"
	"io"

	compute "cloud.google.com/go/compute/apiv1"
	computepb "cloud.google.com/go/compute/apiv1/computepb"
	"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 


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 

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

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)

L'utilizzo di questo template per creare istanze per un MIG (con o senza scalabilità automatica) crea automaticamente l'istanza nella regione e nella subnet specificate. In questo modo puoi controllare la subnet delle nuove istanze create per il bilanciamento del carico.

Utilizza immagini personalizzate o pubbliche nei template di istanza

Puoi utilizzare un'immagine personalizzata o un'immagine pubblica per i template di istanza:

  • Immagini personalizzate. Poiché i MIG sono progettati per aggiungere e rimuovere frequentemente le istanze, è utile creare un'immagine personalizzata e specificarla nel template di istanza. Puoi preparare l'immagine con le applicazioni e le impostazioni necessarie per le tue VM, in modo da non dover configurare manualmente questi elementi sulle singole VM nel MIG.

  • Immagini pubbliche. Puoi creare un template di istanza che utilizzi un'immagine pubblica e uno script di avvio per preparare l'istanza dopo che è iniziata l'esecuzione.

Le immagini personalizzate sono più deterministiche e si avviano più rapidamente delle VM con script di avvio. Tuttavia, gli script di avvio sono più flessibili e ti consentono di aggiornare le app e le impostazioni nelle tue istanze.

Se gestisci le immagini utilizzando le famiglie di immagini, puoi specificare il nome della famiglia di immagini personalizzata o pubblica nel template di istanza. Per ulteriori informazioni sulle famiglie di immagini, consulta le best practice per l'utilizzo delle famiglie di immagini su Compute Engine.

Passaggi successivi