Creazione di modelli di istanza

In questa pagina viene descritto come creare e gestire modelli di istanze. I modelli di istanza consentono di specificare il tipo di macchina, l'immagine disco di avvio, la rete e altre proprietà della VM che vuoi utilizzare durante la creazione di macchine virtuali di Compute Engine.

Puoi utilizzare i modelli di istanza per:

• Crea singoli delle VM.
• Crea le VM in un gruppo di istanze gestite.
• Crea per le VM.

Prima di iniziare

• Leggi quando e perché creare modelli di istanza deterministici.
• Scopri di più sui modelli di istanza a livello di regione e globale.
• Se non l'hai già fatto, configura l'autenticazione. Autenticazione è Il processo di verifica dell'identità per l'accesso ai servizi e alle API di Google Cloud. Per eseguire codice o esempi da un ambiente di sviluppo locale, puoi eseguire l'autenticazione Compute Engine come segue.
  

  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. Installa Google Cloud CLI, quindi initialize eseguendo questo comando:

     gcloud init

     Nota: se hai già installato gcloud CLI in precedenza, assicurati di disporre della versione più recente eseguendo gcloud components update.
  2. Set a default region and zone.

  Terraform

  Per utilizzare gli esempi di Terraform in questa pagina in un ambiente dell'ambiente di sviluppo, installare e inizializzare gcloud CLI quindi configura Credenziali predefinite dell'applicazione con le tue credenziali utente.

  1. Installa Google Cloud CLI.

  2. Per initialize gcloud CLI, esegui questo comando:

     gcloud init

  3. Crea credenziali di autenticazione locali per il tuo Account Google:

     gcloud auth application-default login

  Per ulteriori informazioni, vedi Set up authentication for a local development environment.

  Vai

  Per utilizzare gli Go esempi in questa pagina in una località dell'ambiente di sviluppo, installare e inizializzare gcloud CLI quindi configura Credenziali predefinite dell'applicazione con le tue credenziali utente.

  1. Installa Google Cloud CLI.

  2. Per initialize gcloud CLI, esegui questo comando:

     gcloud init

  3. Crea credenziali di autenticazione locali per il tuo Account Google:

     gcloud auth application-default login

  Per ulteriori informazioni, vedi Set up authentication for a local development environment.

  Java

  Per utilizzare gli Java esempi in questa pagina in una località dell'ambiente di sviluppo, installare e inizializzare gcloud CLI quindi configura Credenziali predefinite dell'applicazione con le tue credenziali utente.

  1. Installa Google Cloud CLI.

  2. Per initialize gcloud CLI, esegui questo comando:

     gcloud init

  3. Crea credenziali di autenticazione locali per il tuo Account Google:

     gcloud auth application-default login

  Per ulteriori informazioni, vedi Set up authentication for a local development environment.

  Node.js

  Per utilizzare gli Node.js esempi in questa pagina in una località dell'ambiente di sviluppo, installare e inizializzare gcloud CLI quindi configura Credenziali predefinite dell'applicazione con le tue credenziali utente.

  1. Installa Google Cloud CLI.

  2. Per initialize gcloud CLI, esegui questo comando:

     gcloud init

  3. Crea credenziali di autenticazione locali per il tuo Account Google:

     gcloud auth application-default login

  Per ulteriori informazioni, vedi Set up authentication for a local development environment.

  Python

  Per utilizzare gli Python esempi in questa pagina in una località dell'ambiente di sviluppo, installare e inizializzare gcloud CLI quindi configura Credenziali predefinite dell'applicazione con le tue credenziali utente.

  1. Installa Google Cloud CLI.

  2. Per initialize gcloud CLI, esegui questo comando:

     gcloud init

  3. Crea credenziali di autenticazione locali per il tuo Account Google:

     gcloud auth application-default login

  Per ulteriori informazioni, vedi Set up authentication for a local development environment.

  REST

  Per utilizzare gli esempi di API REST in questa pagina in un ambiente di sviluppo locale, utilizzi le credenziali che fornisci a gcloud CLI.

  Installa Google Cloud CLI, quindi initialize eseguendo questo comando:

  gcloud init

  Per ulteriori informazioni, vedi Esegui l'autenticazione per l'utilizzo di REST nella documentazione sull'autenticazione di Google Cloud.

Limitazioni

• Il VPC condiviso su interfacce diverse da nic0 per i modelli di istanza è supportate in gcloud CLI e REST, ma non in nella console Google Cloud.
• Non puoi aggiornare un modello di istanza esistente o modificare un'istanza un modello dopo la sua creazione. Se un modello di istanza non è aggiornato, devi apportare modifiche alla configurazione, creare un nuovo modello di istanza.
• Se vuoi specificare una famiglia di immagini in un modello di istanza, non puoi utilizzare la console Google Cloud. Puoi utilizzare Google Cloud CLI oppure con REST.
• Se vuoi specificare un Persistent Disk regionale in un'istanza non puoi usare la console Google Cloud. Puoi utilizzare lo Google Cloud CLI o REST.

Crea un modello di istanza

La maggior parte delle proprietà della VM che puoi specificare in una richiesta di creazione puoi specificare anche una singola istanza VM per un modello di istanza, inclusi eventuali metadati della VM, script di avvio, dischi permanenti, account e così via. Devi specificare il tipo di macchina, il disco di avvio e la rete.

Crea un modello di istanza regionale o globale tramite Console Google Cloud, Google Cloud CLI o API. Per creare un modello globale di istanza di modello, puoi anche utilizzare Terraform Librerie client di Cloud.

Autorizzazioni richieste per questa attività

Per eseguire questa attività, devi disporre di quanto segue autorizzazioni:

• Tutte le autorizzazioni necessarie per chiamare Metodo instanceTemplates.insert.

Console

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

   Vai a Modelli di istanza

   I passaggi rimanenti vengono visualizzati nella console Google Cloud.

2. Fai clic su Crea modello istanza.
3. Seleziona la Località come descritto di seguito:
1. Se vuoi utilizzare il modello di istanza in più 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 modello 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 il campo Impostazioni della VM schermata:

   1. Fai clic su Opzioni avanzate. e fai clic sulla scheda Sicurezza.
   2. Se vuoi disabilitare l'Avvio protetto, cancella il contenuto Casella di controllo Attiva Avvio protetto. Avvio protetto aiuta a proteggere di istanze VM contro malware a livello di avvio e di kernel rootkit. Per ulteriori informazioni, vedi Avvio protetto.

   3. Se vuoi disabilitare il Virtual Trusted Platform Module (vTPM), Deseleziona la casella di controllo Attiva vTPM. vTPM abilita i valori che convalida l'integrità in fase di pre-avvio e avvio della VM. Per ulteriori informazioni le informazioni, vedi Virtual Trusted Platform Module (vTPM).

      Importante: la disabilitazione di vTPM disattiva anche il monitoraggio dell'integrità perché il monitoraggio dell'integrità si basa sui dati raccolti dal programma avvio.

   4. Se vuoi disabilitare il monitoraggio dell'integrità, deseleziona la casella Casella di controllo Attiva il monitoraggio dell'integrità. Monitoraggio dell'integrità consente di monitorare l'integrità in fase di avvio delle istanze Shielded VM e configurazione in Cloud Monitoring. Per ulteriori informazioni, vedi Monitoraggio dell'integrità.

7. (Facoltativo) Nella sezione Opzioni avanzate, fai clic sulle schede per personalizzarle ulteriormente. modello. 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, include Rappresentazione JSON del modello di istanza.

9. Fai clic su Crea per creare il modello.

gcloud

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

Crea un modello di istanza regionale utilizzando il comando seguente:

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

Crea un modello di istanza globale utilizzando il comando seguente:

gcloud compute instance-templates create INSTANCE_TEMPLATE_NAME

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

• Tipo di macchina: il tipo di macchina, ad esempio n1-standard-1
• Immagine: l'ultima immagine Debian
• Disco di avvio: un nuovo disco di avvio standard che prende il nome dalla VM
• Rete: la rete VPC predefinita
• Indirizzo IP: un indirizzo IP esterno temporaneo

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

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

Puoi aggiungere fino a 15 dischi secondari non di avvio. Specifica il valore --create-disk per ogni disco secondario che crei. Per creare dischi secondari da una 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 includono queste proprietà. Se vuoi, includi le proprietà per il disco size e type. Per specificare i dischi permanenti a livello di regione, utilizza replica-zones proprietà.

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

Suggerimento: quando specifichi i parametri del disco, i caratteri ^:^ specificano che il carattere di separazione tra i valori è rappresentato dai due punti (:) e non dai virgola prevista (,).

Sostituisci quanto segue:

• INSTANCE_TEMPLATE_NAME: il nome del modello
• REGION: la regione in cui vuoi creare un modello di istanza regionale

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

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

  Puoi invece utilizzare il flag --image=IMAGE per specificare uno specifico di un'immagine.

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

• DISK_IMAGE_PROJECT: il valore che contiene l'immagine

  Per i dischi vuoti, non specificare la proprietà image-project. Per ulteriori informazioni informazioni sulle immagini pubbliche, consulta Immagini pubbliche.

• SIZE_GB_DISK1 e SIZE_GB_DISK2: la dimensione di ogni disco secondario

• DISK_NAME: facoltativo: il nome del disco mostrato a il sistema operativo guest dopo la creazione della VM.

• DISK_TYPE: facoltativo: il tipo di disco da creare. Se non specificato, il valore predefinito è pd-standard o pd-balanced, a seconda del tipo di macchina.

• ZONE e REMOTE_ZONE: la zona in cui creare il disco permanente a livello di regione e la zona di replicarlo.

  Per i dischi a livello di zona, non includere la proprietà replica-zones.

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

• --no-shielded-secure-boot: disattiva Avvio protetto

  Avvio protetto aiuta a proteggere le istanze VM da livello di avvio rootkit e malware a livello di kernel. Per ulteriori informazioni, vedi Avvio protetto.

• --no-shielded-vtpm: disattiva il modulo Virtual Trusted Platform (piattaforma attendibile virtuale) (vTPM)

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

  Importante: la disattivazione di vTPM anche disabilita il monitoraggio dell'integrità perché si basa su raccolti dall'Avvio con misurazioni.

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

  Il monitoraggio dell'integrità consente di controllare l'integrità in fase di avvio del tuo Istanze Shielded VM utilizzando Cloud Monitoring. Per ulteriori informazioni, vedi Monitoraggio dell'integrità.

Per un elenco di tutti i sottocomandi e i flag disponibili, vedi Riferimento instance-templates.

Un modello con le impostazioni di configurazione predefinite potrebbe essere simile seguenti:

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

Per creare un modello di istanza, puoi utilizzare google_compute_instance_template risorsa.

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

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

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.

Vai

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

/**
 * 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 modello di istanza regionale, effettua una richiesta POST alla Metodo regionInstanceTemplates.insert come segue:

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

Per creare un modello di istanza globale, effettua una richiesta POST alla 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 disks, con un campo per ogni disco aggiuntivo. Per ogni disco aggiuntivo, puoi:

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

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

{
  "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 i tuoi modello di istanza regionale
• INSTANCE_TEMPLATE_NAME: il nome dell'istanza modello
• ZONE: la zona in cui si trovano le VM

• MACHINE_TYPE: il tipo di macchina delle VM

• IMAGE_PROJECT: il progetto immagine che contiene l'immagine

  Per ulteriori informazioni sulle immagini pubbliche, vedi Immagini pubbliche.

• IMAGE o IMAGE_FAMILY: specificare 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

    Questa operazione crea la VM dall'immagine del 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 dalla versione più recente dell'immagine sistema operativo nell'immagine Debian 10 famiglia.

    Per ulteriori informazioni sulle famiglie di immagini, consulta la sezione quando si utilizzano famiglie di immagini su Compute Engine.

• DISK_NAME: facoltativo: il nome del disco mostrato a il sistema operativo guest dopo la creazione della VM.

• PROJECT_NAME: il progetto associato alla VM

• REMOTE_ZONE: la zona in cui il disco regionale devono essere replicati

Puoi specificare una delle seguenti opzioni per la proprietà disks:

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

• Specifica source per collegare un disco di avvio permanente esistente. Se alleghi un disco di avvio esistente, puoi creare una sola istanza modello.

Se vuoi, puoi specificare diskSizeGb, diskType e labels proprietà per initializeParams e la proprietà diskSizeGb per source.

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

• enableSecureBoot: attiva o disattiva Avvio protetto

  Avvio protetto aiuta a proteggere le istanze VM da livello di avvio rootkit e malware a livello di kernel. Per ulteriori informazioni, vedi Avvio protetto.

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

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

  Importante: la disattivazione di vTPM anche disabilita il monitoraggio dell'integrità perché si basa su raccolti dall'Avvio con misurazioni.

• enableIntegrityMonitoring: attiva o disattiva l'integrità monitoring

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

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

Crea un modello di istanza basato su un'istanza esistente

Puoi utilizzare REST o gcloud CLI per salvare la configurazione di un'istanza VM esistente come modello di istanza. Puoi facoltativamente sostituire il modo in cui i dischi di origine vengono definiti nel modello.

Se devi eseguire l'override di altre proprietà, crea prima un'istanza basato su un'istanza esistente, crea un modello simile con altre overrides.

Avviso: se l'istanza esistente contiene un indirizzo IP esterno statico, di destinazione viene copiato nel modello di istanza e potrebbe limitare l'uso modello.

Autorizzazioni richieste per questa attività

Per eseguire questa attività, devi disporre di quanto segue autorizzazioni:

• Tutte le autorizzazioni necessarie per chiamare Metodo instanceTemplates.insert.

gcloud

Utilizza la Comando gcloud compute instance-templates create con i flag --source-instance e --source-instance-zone. Se vuoi per creare un modello di istanza regionale, devi utilizzare anche Flag --instance-template-region per specificare la regione dell'istanza modello.

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

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 modello di istanza globale, utilizza il comando seguente:

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

Per eseguire l'override del modo in cui vengono definiti i dischi dell'istanza di origine, aggiungi uno o più --configure-disk flag.

L'esempio seguente crea un'istanza globale modello da un'istanza esistente ed esegue l'override di quello dell'istanza di origine con le specifiche da te 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 modello per creare.
• SOURCE_INSTANCE è il nome dell'istanza da utilizzare come modello per il nuovo modello.
• SOURCE_INSTANCE_ZONE è la zona che contiene di origine.
• REGION è la regione in cui vuoi creare di un modello di istanza regionale.
• SOURCE_DISK è il nome di un disco di un'istanza di origine da sostituire all'interno del modello.

• 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 avvio e altro dischi permanenti di lettura/scrittura). Specifica questa opzione se vuoi utilizzare la stessa immagine di origine o famiglia di immagini di origine utilizzata per creare disco nell'istanza VM di origine.

  • custom-image (valido solo per l'avvio e per altre funzionalità di lettura/scrittura permanenti) i dischi permanenti). Se vuoi conservare applicazioni e impostazioni dall'origine VM nel modello di istanza, puoi creare un'immagine personalizzata e specificarlo quando crei il modello. Se specificato, fornisci il percorso o l'URL per l'immagine personalizzata. come mostrato nell'esempio seguente. In alternativa, puoi specificare una famiglia di immagini nel 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 dischi permanenti non di avvio e SSD locali). Se specificato, quando il modello viene utilizzato per creare una nuova istanza, il disco viene creato senza formattazione. 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 dischi di sola lettura).

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

Ad esempio, il comando seguente crea un modello 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 sostituisci 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

Vai

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 modello di istanza regionale, utilizza il metodo regionInstanceTemplates.insert, In alternativa, per creare un modello di istanza globale, utilizza il metodo instanceTemplates.insert.

Nella richiesta, devi specificare il campo sourceInstance. Per sostituire il modo in cui l'origine dischi dell'istanza. Aggiungi uno o più campi diskConfigs.

Ad esempio, esegui la chiamata seguente per creare un modello di istanza globale di 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 modello
• SOURCE_INSTANCE_ZONE: la zona dell'istanza di origine
• SOURCE_INSTANCE: il nome dell'istanza di origine da utilizzare come modello per questo modello di istanza
• SOURCE_DISK: il nome del disco di un'istanza di origine a cui vuoi eseguire l'override all'interno del modello

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

  I valori validi dipendono dal tipo di disco:

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

  • custom-image (valido solo per l'avvio e per altre funzionalità di lettura/scrittura permanenti) i dischi permanenti). Se vuoi conservare applicazioni e impostazioni dall'origine VM nel modello di istanza, puoi creare un'immagine personalizzata e specificarlo quando crei il modello. Se specificato, fornisci il percorso o l'URL per l'immagine personalizzata. come mostrato nell'esempio seguente. In alternativa, puoi specificare una famiglia di immagini nel 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 dischi permanenti non di avvio e SSD locali). Se specificato, quando il modello viene utilizzato per creare una nuova istanza, il disco viene creato senza formattazione. 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 dischi di sola lettura).

L'esempio seguente crea un nuovo modello di istanza basato su my-source-instance. Nel modello di istanza, l'immagine di data-disk-a viene sostituito con 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 modello.

Tipo di disco	Opzioni
Disco di avvio	[Predefinito] Usa la stessa immagine di origine o la stessa famiglia di immagini utilizzato per creare il disco di avvio nell'istanza di origine. Utilizza l'URL di qualsiasi immagine (personalizzata o pubblica) come descritto nei dell'esempio precedente o specificare una famiglia di immagini utilizzando formato: projects/exampleproject/global/images/family/IMAGE_FAMILY_NAME
Altri dischi permanenti di lettura/scrittura	[Predefinito] Utilizza la stessa immagine di origine/famiglia di immagini di origine utilizzato per creare il disco nell'istanza di origine. Nota: se il disco dell'istanza di origine non ha un'immagine/un'origine di origine proprietà della famiglia di immagini, viene inclusa nel modello come un disco vuoto. Utilizza l'URL di qualsiasi immagine (personalizzata o pubblica) come descritto nei dell'esempio precedente o specificare una famiglia di immagini utilizzando formato: projects/exampleproject/global/images/family/IMAGE_FAMILY_NAME Usa invece un disco vuoto nel modello. Quando il modello è utilizzato per creare una nuova istanza, il disco viene creato senza formattazione. Devi formato 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	[Predefinito] Includi il disco in modalità di sola lettura. Non includere il disco.
SSD locali	[Predefinito] Includi un'unità SSD locale vuota. Quando il modello è utilizzato per creare una nuova istanza, questo disco viene creato senza formattazione. Devi formato e montare il disco in uno script di avvio prima di poterlo utilizzare in una e scalabile.

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

Per impostazione predefinita, se non vengono specificate opzioni di override, la configurazione del disco che il modello corrisponda all'istanza di origine.

Crea un modello di istanza basato su un modello esistente

Non puoi aggiornare un modello di istanza esistente. Tuttavia, se un modello di istanza non è aggiornata oppure, se devi apportare modifiche, puoi crearne un'altra proprietà simili utilizzando la console.

1. Vai alla pagina Modelli di istanza.

   Vai a Modelli di istanza

2. Fai clic sul modello di istanza che vuoi copiare e aggiornare.

3. Fai clic su Crea simile.

4. Aggiorna la configurazione nel nuovo modello.

5. Fai clic su Crea.

Crea un modello di istanza per le VM GPU

Quando crei un modello di istanza, puoi configurarlo per creare VM che hanno GPU collegate specificando quanto segue:

• Un tipo di macchina supporta il tipo di GPU desiderato. Se vuoi creare un modello di istanza regionale, il tipo di GPU specificato nel modello deve essere disponibile in almeno una zona della regione.

• un criterio di manutenzione che arresta le VM durante ospitare eventi di manutenzione.

Nota: se vuoi eseguire carichi di lavoro di data science o machine learning, prendi in considerazione l'utilizzo di un'immagine VM di deep learning quando crei modello di istanza. Deep Learning VM Image è un insieme di immagini VM preconfezionate con framework di machine learning ed elementi essenziali tools. Per ulteriori informazioni su queste immagini, vedi Scegliere un'immagine nella documentazione di Deep Learning VM Images.

Autorizzazioni richieste per questa attività

Per eseguire questa attività, devi disporre di quanto segue autorizzazioni:

• Tutte le autorizzazioni necessarie per chiamare Metodo instanceTemplates.insert.

Console

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

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

   Vai a Modelli di istanza

2. Fai clic su Crea modello istanza.

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

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

   • Per creare un modello di istanza globale, seleziona Globale (impostazione predefinita).

   • Per creare un modello di istanza regionale, seleziona A livello di regione e quindi seleziona la regione in cui vuoi creare l'istanza modello.

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 GPU supporta Workstation virtuali (vWS) NVIDIA RTX per carichi di lavoro di grafica e prevedi di eseguire carichi di lavoro 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 di disco di avvio o l'immagine del valore predefinito, nella sezione Nella sezione Disco di avvio, fai clic su Cambia. Poi segui le istruzioni per e modificare il disco di avvio.

7. Fai clic su Crea.

gcloud

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

Ad esempio, per creare un modello di istanza globale per le VM GPU, utilizza il metodo 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 dell'istanza modello.

• IMAGE_PROJECT: il progetto immagine che contiene image; ad esempio debian-cloud. Per ulteriori informazioni sui per i progetti immagine supportati, consulta Immagini pubbliche.

• IMAGE_FAMILY o IMAGE: specificane uno dei seguenti:

  • IMAGE_FAMILY: un famiglia di immagini. Questo specifica l'immagine del sistema operativo più recente e non deprecata. Ad esempio, se specifichi debian-10, l'ultima versione della famiglia di immagini Debian 10 è in uso. Per ulteriori informazioni sull'utilizzo delle famiglie di immagini, consulta Best practice per le famiglie di immagini.

  • IMAGE: una versione specifica dell'immagine del sistema operativo; della ad esempio debian-10-buster-v20200309. Se scegli di specificare specifica dell'immagine del sistema operativo, devi sostituire Bandiera --image-family con la bandiera --image.

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

Ad esempio, supponiamo di voler creare un modello di istanza globale VM GPU che specificano 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 un modello di istanza di esempio, utilizza il comando seguente:

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 modello di istanza per le VM GPU, utilizza google_compute_region_instance_template risorsa.

Ad esempio, per creare un modello di istanza globale che specifica un codice N1 un tipo di macchina predefinita 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 modello di istanza per le VM GPU, effettua una richiesta POST alla Metodo instanceTemplates.insert. Nel corpo della richiesta, includi il campo onHostMaintenance e impostalo su TERMINATE.

Ad esempio, per creare un modello di istanza globale per le VM GPU, crea un 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 per creare il modello di istanza.

• INSTANCE_TEMPLATE_NAME: il nome dell'istanza modello.

• IMAGE_PROJECT: il progetto immagine che contiene image; ad esempio debian-cloud. Per ulteriori informazioni sui per i progetti immagine supportati, consulta Immagini pubbliche.

• IMAGE o IMAGE_FAMILY: specificane uno dei seguenti:

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

  • IMAGE_FAMILY: un famiglia di immagini. Questo specifica l'immagine del sistema operativo più recente e non deprecata. Ad esempio, se specifichi family/debian-10, la versione più recente della famiglia di immagini Debian 10 . Per ulteriori informazioni sull'utilizzo delle famiglie di immagini, consulta Best practice per le famiglie di immagini.

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

Ad esempio, supponiamo di voler creare un modello di istanza globale VM GPU che specificano 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 un modello 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 ulteriori opzioni di configurazione quando crei un modello di istanza, consulta Crea un modello di istanza in questo documento.

Crea un modello di istanza con un'immagine container

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

Console

1. Vai alla pagina Modelli di istanza.

   Vai a Modelli di istanza

2. Fai clic su Crea modello istanza.

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

4. Nella finestra di dialogo Configura contenitore, 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 uno specifico 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 immagine per eseguire il deployment di un'immagine container Apache: docker.io/httpd:2.4.

5. Facoltativamente, fai clic su Opzioni contenitore avanzate. Per ulteriori informazioni, vedi Configura le opzioni per l'esecuzione del container.

6. Fai clic su Crea.

gcloud

Utilizza la 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 modello per creare.
• CONTAINER_IMAGE: nome completo del container l'immagine da utilizzare.

Ad esempio, il comando seguente crea un nuovo modello di istanza denominato nginx-vm. Un'istanza VM creata da questo modello avvia 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 uno specifico dell'immagine container NGINX disponibile su Google Cloud Marketplace.

Puoi anche configurare opzioni per eseguire il container.

Attenzione:Container Registry è deprecato e programmato per l'arresto. Organizzazioni che non hanno utilizzato Container Registry prima dell'8 gennaio 2024 hanno il nuovo file gcr.io ospitati su Artifact Registry per impostazione predefinita. In vigore dal 15 maggio 2024, i progetti Google Cloud senza precedente utilizzo di Container Registry supporterà solo l'hosting e la gestione il dominio gcr.io in Artifact Registry.

L'arresto di Container Registry è pianificato per il giorno 18 marzo 2025. Per maggiori dettagli sul ritiro, vedi Ritiro di Container Registry.

Crea un modello di istanza che specifichi una subnet

gcloud

Per creare un modello di istanza regionale o globale, utilizza Comando instance-templates create. Utilizza il flag --subnet per posizionare le istanze create dal modello nella subnet che preferisci. Il flag --subnet richiede l'elemento --region flag.

Se vuoi creare un modello di istanza regionale, devi utilizzare il metodo --instance-template-region per impostare la regione del modello. Assicurati che di utilizzare una subnet dalla stessa regione in cui vuoi creare a livello di regione.

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

Sostituisci quanto segue:

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

• SUBNET_NAME_OR_URL: il nome della subnet o relativo URL

  Nota: se utilizzi il nome della subnet, Google trova quella subnet nella regione (se esiste). Tuttavia, se utilizzi l'URL della subnet, il modello di istanza può essere utilizzato solo per creare istanze in regione associata all'URL della subnet.

• INSTANCE_TEMPLATE_REGION: la regione in cui vuoi per creare il modello di istanza. Deve essere uguale a REGION

L'esempio seguente crea un modello denominato template-qa che crea solo di Compute Engine nella subnet subnet-us-qa.

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

Vai

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 modello per creare istanze per un MIG (con o senza scalabilità automatica) crea automaticamente l'istanza nella regione e nella subnet specificate. Questo consente di controllare la subnet dei nuovi di Compute Engine create per il bilanciamento del carico.

Utilizza immagini personalizzate o pubbliche nei modelli di istanza

Per i modelli di istanza puoi utilizzare un'immagine personalizzata o un'immagine pubblica:

• Immagini personalizzate. Poiché i gruppi di istanze gestite sono progettati per aggiungere e rimuovere istanze di frequente, è utile creare un'immagine personalizzata e specificarlo nel modello di istanza. Puoi preparare l'immagine con le applicazioni e le impostazioni necessarie alle tue VM, per cui configurare manualmente quegli elementi sulle singole VM nel gruppo di istanze gestite.

• Immagini pubbliche. Puoi creare un modello di istanza che utilizza un oggetto immagine pubblica e un script di avvio per preparare l'istanza dopo viene avviata l'esecuzione.

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

Se gestisci le immagini utilizzando famiglie di immagini, puoi specificare il nome della tua famiglia di immagini personalizzate o pubbliche nell'istanza, modello. Per ulteriori informazioni sulle famiglie di immagini, consulta la sezione Migliori quando utilizzi famiglie di immagini su Compute Engine.

Nota: se l'immagine che vuoi utilizzare appartiene a un altro progetto, puoi utilizzare comunque quell'immagine nel modello di istanza, a condizione che il proprietario il progetto concede al gruppo di istanze gestite l'accesso alle immagini. Per ulteriori informazioni, vedi Concessione dell'accesso alle immagini da parte di un gruppo di istanze gestite.

Passaggi successivi

• Crea una VM da un modello di istanza.
• Crea un gruppo di istanze gestite a livello di zona.
• Crea un gruppo di istanze gestite a livello di regione.
• Aggiorna le VM in un gruppo di istanze gestite esistente per utilizzare la configurazione da un nuovo modello.
• Crea una prenotazione per le VM.