Créer des modèles d'instances

---

Cette page explique comment créer et gérer des modèles d'instances. Les modèles d'instances vous permettent de spécifier le type de machine, l'image de disque de démarrage, le réseau et d'autres propriétés de VM que vous souhaitez utiliser lors de la création d'instances de machines virtuelles (VM, virtual machine).

Vous pouvez utiliser des modèles d'instances pour effectuer les opérations suivantes :

• Créer des VM individuelles.
• Créer des VM dans un groupe d'instances géré (MIG).
• Créer des réservations pour des VM.
• Créer des réservations futures pour des VM.

Avant de commencer

• Découvrez quand et pourquoi créer des modèles d'instances déterministes.
• Apprenez-en plus sur les modèles d'instances régionaux et globaux.
• Si ce n'est pas déjà fait, configurez l'authentification. L'authentification est le processus permettant de valider votre identité pour accéder aux services et aux API Google Cloud. Pour exécuter du code ou des exemples depuis un environnement de développement local, vous pouvez vous authentifier auprès de Compute Engine comme suit :
  

  Select the tab for how you plan to use the samples on this page:

  Console

  When you use the Google Cloud console to access Google Cloud services and APIs, you don't need to set up authentication.

  gcloud

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

     gcloud init

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

  Terraform

  Pour utiliser les exemples Terraform de cette page dans un environnement de développement local, installez et initialisez gcloud CLI, puis configurez le service Identifiants par défaut de l'application à l'aide de vos identifiants utilisateur.

  1. Install the Google Cloud CLI.

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

     gcloud init

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

     gcloud auth application-default login

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

  Pour en savoir plus, consultez Set up authentication for a local development environment.

  Go

  Pour utiliser les exemples Go de cette page dans un environnement de développement local, installez et initialisez gcloud CLI, puis configurez le service Identifiants par défaut de l'application à l'aide de vos identifiants utilisateur.

  1. Install the Google Cloud CLI.

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

     gcloud init

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

     gcloud auth application-default login

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

  Pour en savoir plus, consultez Set up authentication for a local development environment.

  Java

  Pour utiliser les exemples Java de cette page dans un environnement de développement local, installez et initialisez gcloud CLI, puis configurez le service Identifiants par défaut de l'application à l'aide de vos identifiants utilisateur.

  1. Install the Google Cloud CLI.

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

     gcloud init

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

     gcloud auth application-default login

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

  Pour en savoir plus, consultez Set up authentication for a local development environment.

  Node.js

  Pour utiliser les exemples Node.js de cette page dans un environnement de développement local, installez et initialisez gcloud CLI, puis configurez le service Identifiants par défaut de l'application à l'aide de vos identifiants utilisateur.

  1. Install the Google Cloud CLI.

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

     gcloud init

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

     gcloud auth application-default login

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

  Pour en savoir plus, consultez Set up authentication for a local development environment.

  Python

  Pour utiliser les exemples Python de cette page dans un environnement de développement local, installez et initialisez gcloud CLI, puis configurez le service Identifiants par défaut de l'application à l'aide de vos identifiants utilisateur.

  1. Install the Google Cloud CLI.

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

     gcloud init

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

     gcloud auth application-default login

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

  Pour en savoir plus, consultez Set up authentication for a local development environment.

  REST

  Pour utiliser les exemples d'API REST de cette page dans un environnement de développement local, vous devez utiliser les identifiants que vous fournissez à gcloud CLI.

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

  gcloud init

  Pour en savoir plus, consultez la section S'authentifier pour utiliser REST dans la documentation sur l'authentification Google Cloud.

Limites

• Vous pouvez connecter un VPC partagé à des interfaces autres que nic0 pour les modèles d'instances dans gcloud CLI et REST, mais pas dans la console Google Cloud.
• Vous ne pouvez pas mettre à jour un modèle d'instance existant ni modifier un modèle d'instance après sa création. Si un modèle d'instance devient obsolète ou si vous devez en modifier la configuration, créez-en un autre.
• Si vous souhaitez spécifier une famille d'images dans un modèle d'instance, vous ne pouvez pas utiliser la console Google Cloud. Vous pouvez utiliser Google Cloud CLI ou REST.
• Si vous souhaitez spécifier un disque persistant régional dans un modèle d'instance, vous ne pouvez pas utiliser la console Google Cloud. Vous pouvez utiliser Google Cloud CLI ou REST.
• Vous pouvez utiliser un modèle d'instance pour créer des VM avec un disque de démarrage Hyperdisk Balanced situé dans un pool de stockage, sous réserve que ce pool de stockage existe dans la même zone que celle dans laquelle la VM est créée. Vous ne pouvez pas utiliser de modèles d'instances globaux pour créer des VM avec des disques non amorçables qui se trouvent dans un pool de stockage.

Créer un modèle d'instance

La plupart des propriétés de VM que vous pouvez spécifier dans une requête de création d'instance de VM individuelle peuvent également être spécifiées pour un modèle d'instance, y compris les métadonnées de VM, les scripts de démarrage, les disques persistants et les comptes de service. Vous devez spécifier le type de machine, le disque de démarrage et le réseau.

Créez un modèle d'instance régional ou global via la console Google Cloud, Google Cloud CLI ou l'API. Pour créer un modèle d'instance global, vous pouvez également utiliser les bibliothèques clientes Cloud ou Terraform.

Autorisations requises pour cette tâche

Pour effectuer cette tâche, vous devez disposer des autorisations suivantes :

• Toutes les autorisations requises pour appeler la méthode instanceTemplates.insert

Console

1. Dans la console Google Cloud, accédez à la page Modèles d'instances.

   Accéder à la page "Modèles d'instances"

   Les étapes restantes s'affichent dans la console Google Cloud.

2. Cliquez sur Créer un modèle d'instance.
3. Sélectionnez l'emplacement comme suit :
1. Si vous souhaitez utiliser le modèle d'instance dans plusieurs régions, sélectionnez Global.
2. Si vous souhaitez réduire la dépendance interrégionale, sélectionnez Régional.
4. Si vous avez choisi régional, sélectionnez la région dans laquelle vous souhaitez créer votre modèle d'instance.

5. Pour les champs suivants, acceptez les valeurs par défaut ou modifiez-les si nécessaire. Les valeurs par défaut varient en fonction de la famille de machines que vous sélectionnez.

   • Sélectionnez un Type de machine.
   • Pour mettre à jour le type ou l'image du disque de démarrage, cliquez sur Modifier dans la section Disque de démarrage.
   • Pour mettre à jour les paramètres de l'interface réseau ou de l'adresse IP, cliquez sur Options avancées, puis sur Réseau et sur l'interface réseau à modifier.

6. Facultatif : si vous avez choisi une image compatible avec les VM protégées, modifiez les paramètres de la VM protégée :

   1. Cliquez sur Options avancées, puis sur l'onglet Sécurité.
   2. Si vous souhaitez désactiver le démarrage sécurisé, décochez la case Activer le démarrage sécurisé. Le démarrage sécurisé permet de protéger vos instances de VM contre les logiciels malveillants et les rootkits opérant au niveau des secteurs de démarrage et du noyau. Pour plus d'informations, consultez la section Démarrage sécurisé.

   3. Si vous souhaitez désactiver le module vTPM (Virtual Trusted Platform Module), décochez la case Activer vTPM. Le module vTPM active le démarrage mesuré, ce qui permet de valider l'intégrité du pré-amorçage et du démarrage de la VM. Pour plus d'informations, consultez la section Module vTPM (Virtual Trusted Platform Module).

      Important : En désactivant le module vTPM, vous désactivez également la surveillance de l'intégrité, car celle-ci repose sur les données collectées par le démarrage mesuré.

   4. Si vous souhaitez désactiver la surveillance de l'intégrité, décochez la case Activer la surveillance de l'intégrité. La surveillance de l'intégrité vous permet de surveiller l'intégrité du démarrage de vos instances de VM protégées à l'aide de Cloud Monitoring. Pour plus d'informations, consultez la section Surveillance de l'intégrité.

7. Facultatif : Sous Options avancées, cliquez sur les onglets pour personnaliser davantage votre modèle. Vous pouvez ainsi ajouter jusqu'à 15 disques secondaires non amorçables.

8. Facultatif : cliquez sur REST équivalent pour afficher le corps de la requête REST, qui comprend la représentation JSON de votre modèle d'instance.

9. Cliquez sur Créer pour générer le modèle.

gcloud

Pour créer un modèle d'instance régional ou global, utilisez la commande instance-templates create. Pour un modèle d'instance régional, vous devez utiliser l'option --instance-template-region pour définir la région du modèle.

Créez un modèle d'instance régional à l'aide de la commande suivante :

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

Créez un modèle d'instance global à l'aide de la commande suivante :

gcloud compute instance-templates create INSTANCE_TEMPLATE_NAME

Si vous ne fournissez pas de paramètres explicites pour le modèle, gcloud compute utilise les valeurs par défaut suivantes :

• Type de machine : le type de machine, par exemple n1-standard-1
• Image : l'image la plus récente de Debian
• Disque de démarrage : le nouveau disque de démarrage standard nommé d'après la VM
• Réseau : le réseau VPC par défaut
• Adresse IP : une adresse IP externe éphémère

Vous pouvez également fournir ces paramètres de configuration de manière explicite. Exemple :

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

Vous pouvez ajouter jusqu'à 15 disques secondaires non amorçables. Spécifiez l'indicateur --create-disk pour chaque disque secondaire que vous créez. Pour créer des disques secondaires à partir d'une image publique ou personnalisée, spécifiez les propriétés image et image-project pour chaque disque dans l'option --create-disk. Pour créer un disque vide, n'incluez pas ces propriétés. Vous pouvez également inclure des valeurs pour les propriétés size et type du disque. Pour spécifier des disques persistants régionaux, utilisez la propriété replica-zones.

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

Conseil : Lorsque vous spécifiez les paramètres du disque, les caractères ^:^ indiquent que le caractère de séparation entre les valeurs est le signe deux-points (:) au lieu de la virgule attendue (,).

Remplacez les éléments suivants :

• INSTANCE_TEMPLATE_NAME : nom du modèle.
• REGION : région dans laquelle vous souhaitez créer le modèle d'instance régional

• IMAGE_FAMILY : famille d'images à utiliser comme disque non amorçable

  Pour en savoir plus sur les familles d'images, consultez la page Bonnes pratiques d'utilisation des familles d'images sur Compute Engine.

  Vous pouvez utiliser l'option --image=IMAGE pour stipuler une version spécifique d'une image.

  Pour les disques vides, ne spécifiez pas la propriété image-family ou image.

• DISK_IMAGE_PROJECT : projet contenant l'image

  Pour les disques vides, ne spécifiez pas la propriété image-project. Pour plus d'informations sur les images publiques, consultez la page Images publiques.

• SIZE_GB_DISK1 et SIZE_GB_DISK2 : taille de chaque disque secondaire

• DISK_NAME (facultatif) : nom du disque affiché sur l'OS invité après la création de la VM.

• DISK_TYPE : facultatif : type de disque à créer. Si aucune valeur n'est spécifiée, la valeur par défaut est pd-standard ou pd-balanced, selon le type de machine.

• ZONE et REMOTE_ZONE : zone dans laquelle créer le disque persistant régional et zone vers laquelle le dupliquer.

  Pour les disques zonaux, n'incluez pas la propriété replica-zones.

Si vous avez choisi une image compatible avec les VM protégées, vous pouvez également modifier les paramètres de la VM protégée de l'instance à l'aide de l'un des indicateurs suivants :

• --no-shielded-secure-boot : désactive le démarrage sécurisé.

  Le démarrage sécurisé permet de protéger vos instances de VM contre les logiciels malveillants et les rootkits opérant au niveau des secteurs de démarrage et du noyau. Pour plus d'informations, consultez la section Démarrage sécurisé.

• --no-shielded-vtpm : désactive le module vTPM (Virtual Trusted Platform Module).

  Le module vTPM active le démarrage mesuré, ce qui permet de valider l'intégrité du pré-amorçage et du démarrage de la VM. Pour plus d'informations, consultez la section Module vTPM (Virtual Trusted Platform Module).

  Important : En désactivant le module vTPM, vous désactivez également la surveillance de l'intégrité, car celle-ci repose sur les données collectées par le démarrage mesuré.

• --no-shielded-integrity-monitoring : désactive la surveillance de l'intégrité.

  La surveillance de l'intégrité vous permet de surveiller l'intégrité du démarrage de vos instances de VM protégées à l'aide de Cloud Monitoring. Pour plus d'informations, consultez la section Surveillance de l'intégrité.

Pour obtenir la liste de toutes les sous-commandes et options disponibles, consultez la documentation de référence sur instance-templates.

Un modèle créé à partir des paramètres de configuration par défaut ressemblera par exemple à ceci :

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

Pour créer un modèle d'instance, vous pouvez utiliser la ressource google_compute_instance_template.

L'exemple Terraform suivant est semblable à la commande suivante de 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"
    ]
  }
}

Pour savoir comment appliquer ou supprimer une configuration Terraform, consultez la page Commandes Terraform de 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

Pour créer un modèle d'instance régional, envoyez une requête POST à la méthode regionInstanceTemplates.insert comme suit :

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

Pour créer un modèle d'instance global, envoyez une requête POST à la méthode instanceTemplates.insert :

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

Vous pouvez ajouter jusqu'à 15 disques secondaires non amorçables en utilisant la propriété disks, avec un champ pour chaque disque supplémentaire. Pour chaque disque supplémentaire, vous pouvez effectuer les opérations suivantes :

• Créez des disques supplémentaires avec une image publique ou personnalisée.
• Pour ajouter un disque vide, définissez l'entrée initializeParams sans spécifier de valeur sourceImage.
• Pour créer des disques persistants régionaux, définissez l'entrée initializeParams avec la propriété replicaZones.

Dans le corps de la requête, indiquez les propriétés du modèle :

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

Remplacez les éléments suivants :

• PROJECT_ID : ID de votre projet
• REGION : région dans laquelle vous souhaitez créer votre modèle d'instance régional
• INSTANCE_TEMPLATE_NAME : nom du modèle d'instance
• ZONE : zone où se trouvent les VM

• MACHINE_TYPE : type de machine des VM

• IMAGE_PROJECT : projet contenant l'image

  Pour plus d'informations sur les images publiques, consultez la page Images publiques.

• IMAGE ou IMAGE_FAMILY : spécifiez l'un des éléments suivants :
  • IMAGE : version spécifique de l'image

    Par exemple, "sourceImage": "projects/debian-cloud/global/images/debian-10-buster-v20200309".

  • IMAGE_FAMILY : famille d'images

    Cette action crée la VM à partir de l'image d'OS la plus récente et non obsolète. Par exemple, si vous spécifiez "sourceImage": "projects/debian-cloud/global/images/family/debian-10", Compute Engine crée une VM à partir de la dernière version de l'image de l'OS dans la famille d'images Debian 10.

    Pour en savoir plus sur les familles d'images, consultez la page Bonnes pratiques d'utilisation des familles d'images sur Compute Engine.

• DISK_NAME (facultatif) : nom du disque affiché sur l'OS invité après la création de la VM.

• PROJECT_NAME : projet associé à la VM.

• REMOTE_ZONE : zone dans laquelle le disque régional doit être répliqué.

Vous pouvez spécifier l'une des options suivantes pour la propriété disks :

• Spécifiez initializeParams pour créer des disques de démarrage persistants pour chaque instance. Vous pouvez ajouter jusqu'à 15 disques secondaires non amorçables en utilisant la propriété initializeParams pour chaque disque supplémentaire. Vous pouvez créer des disques à l'aide d'images publiques ou personnalisées (ou de familles d'images) dans sourceImage, comme indiqué dans l'exemple précédent. Pour ajouter des disques vides, ne spécifiez pas d'image source sourceImage.

• Spécifiez source pour associer un disque de démarrage persistant existant. Si vous associez un disque de démarrage existant, vous ne pouvez créer qu'une seule instance à partir de votre modèle.

Si vous le souhaitez, vous pouvez spécifier les propriétés diskSizeGb,diskType et labels pour initializeParams et la propriété diskSizeGb pour source.

Si vous avez choisi une image compatible avec les VM protégées, vous pouvez éventuellement modifier les paramètres de VM protégée de la VM en renseignant les éléments booléens suivants dans le corps de la requête :

• enableSecureBoot : active ou désactive le démarrage sécurisé.

  Le démarrage sécurisé permet de protéger vos instances de VM contre les logiciels malveillants et les rootkits opérant au niveau des secteurs de démarrage et du noyau. Pour plus d'informations, consultez la section Démarrage sécurisé.

• enableVtpm : active ou désactive le module vTPM (Virtual Trusted Platform Module).

  Le module vTPM active le démarrage mesuré, ce qui permet de valider l'intégrité du pré-amorçage et du démarrage de la VM. Pour plus d'informations, consultez la section Module vTPM (Virtual Trusted Platform Module).

  Important : En désactivant le module vTPM, vous désactivez également la surveillance de l'intégrité, car celle-ci repose sur les données collectées par le démarrage mesuré.

• enableIntegrityMonitoring : active ou désactive la surveillance de l'intégrité.

  Cette fonctionnalité vous permet de surveiller et de valider l'intégrité pendant le démarrage de l'environnement d'exécution de vos instances de VM protégées au moyen de rapports Cloud Monitoring. Pour plus d'informations, consultez la section Surveillance de l'intégrité.

Pour en savoir plus sur les paramètres de requête, consultez la documentation sur la méthode instanceTemplates.insert.

Créer un modèle d'instance basé sur une instance existante

Vous pouvez utiliser REST ou gcloud CLI pour enregistrer la configuration d'une instance de VM existante en tant que modèle d'instance. Vous pouvez éventuellement modifier la façon dont les disques sources sont définis dans le modèle.

Si vous devez modifier d'autres propriétés, commencez par créer un modèle d'instance basé sur une instance existante, puis créez un modèle similaire avec des modifications supplémentaires.

Avertissement : Si l'instance existante contient une adresse IP externe statique, cette adresse est copiée dans le modèle d'instance et peut limiter l'utilisation du modèle.

Autorisations requises pour cette tâche

Pour effectuer cette tâche, vous devez disposer des autorisations suivantes :

• Toutes les autorisations requises pour appeler la méthode instanceTemplates.insert

gcloud

Exécutez la commande gcloud compute instance-templates create avec les options --source-instance et --source-instance-zone. Si vous souhaitez créer un modèle d'instance régional, vous devez également utiliser l'option --instance-template-region pour spécifier la région du modèle d'instance.

Pour créer un modèle d'instance régional, exécutez la commande suivante :

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

Pour créer un modèle d'instance global, exécutez la commande suivante :

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

Pour modifier la façon dont les disques de l'instance source sont définis, ajoutez une ou plusieurs options --configure-disk.

L'exemple suivant crée un modèle d'instance global à partir d'une instance existante, et remplace le disque de l'instance source par les spécifications que vous fournissez.

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

Remplacez les éléments suivants :

• INSTANCE_TEMPLATE_NAME correspond au nom du modèle à créer.
• SOURCE_INSTANCE correspond au nom de l'instance à utiliser comme référence pour le nouveau modèle.
• SOURCE_INSTANCE_ZONE correspond à la zone hébergeant l'instance source.
• REGION : région dans laquelle vous souhaitez créer le modèle d'instance régional.
• SOURCE_DISK correspond au nom d'un disque d'instance source que vous souhaitez remplacer dans le modèle.

• INSTANTIATE_OPTIONS spécifie si le disque doit être inclus et quelle image utiliser. Les valeurs valides dépendent du type de disque :

  • source-image ou source-image-family (valide uniquement pour les disques de démarrage et les autres disques persistants accessibles en lecture-écriture). Spécifiez cette option si vous souhaitez utiliser la même image source ou famille d'images sources que celle utilisée pour créer le disque dans l'instance de VM source.

  • custom-image (valide uniquement pour les disques de démarrage et les autres disques persistants accessibles en lecture-écriture). Si vous souhaitez conserver les applications et les paramètres des VM sources dans votre modèle d'instance, vous pouvez créer une image personnalisée, puis la spécifier lors de la création du modèle. Si cette option est utilisée, indiquez le chemin d'accès ou l'URL de l'image personnalisée, comme illustré dans l'exemple suivant. Vous pouvez également spécifier une famille d'images au format suivant :

    --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 (valide uniquement pour les disques en lecture seule).

  • blank (valide uniquement pour les disques persistants non amorçables et les disques SSD locaux). Si cette valeur est utilisée, le disque est alors créé sans formatage lorsque le modèle est utilisé pour créer une instance. Vous devez formater et installer le disque dans un script de démarrage avant de pouvoir l'utiliser dans une configuration évolutive.

  • do-not-include (valide uniquement pour les disques persistants non amorçables et les disques en lecture seule).

• AUTO_DELETE spécifie si le disque sera automatiquement supprimé lorsque l'instance elle-même est supprimée. Les valeurs valides sont false, no, true et yes.

À titre d'exemple, la commande suivante crée un modèle d'instance basé sur l'instance my-source-instance en utilisant l'image d'origine pour data-disk-a, par ailleurs configuré pour être supprimé automatiquement (valeur auto-delete définie sur true) et pour remplacer data-disk-b par une image personnalisée.

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

Pour créer un modèle d'instance régional, utilisez la méthode regionInstanceTemplates.insert ou, pour créer un modèle d'instance global, utilisez la méthode instanceTemplates.insert.

Dans votre requête, vous devez spécifier le champ sourceInstance. Pour modifier la façon dont les disques de l'instance source sont définis, ajoutez un ou plusieurs champs diskConfigs.

Par exemple, effectuez l'appel suivant pour créer un modèle d'instance global à partir d'une instance existante.

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

Remplacez les éléments suivants :

• PROJECT_ID : ID de votre projet
• INSTANCE_TEMPLATE_NAME : nom du nouveau modèle.
• SOURCE_INSTANCE_ZONE : zone de l'instance source.
• SOURCE_INSTANCE : nom de l'instance source à utiliser comme modèle pour ce modèle d'instance.
• SOURCE_DISK : nom d'un disque d'instance source que vous souhaitez remplacer dans le modèle.

• INSTANTIATE_OPTIONS : spécifie si le disque doit être inclus et quelle image utiliser.

  Les valeurs valides dépendent du type de disque :

  • source-image ou source-image-family (valide uniquement pour les disques de démarrage et les autres disques persistants accessibles en lecture-écriture).

  • custom-image (valide uniquement pour les disques de démarrage et les autres disques persistants accessibles en lecture-écriture). Si vous souhaitez conserver les applications et les paramètres des VM sources dans votre modèle d'instance, vous pouvez créer une image personnalisée, puis la spécifier lors de la création du modèle. Si cette option est utilisée, indiquez le chemin d'accès ou l'URL de l'image personnalisée, comme illustré dans l'exemple suivant. Vous pouvez également spécifier une famille d'images au format suivant :

    --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 (valide uniquement pour les disques en lecture seule).

  • blank (valide uniquement pour les disques persistants non amorçables et les disques SSD locaux). Si cette valeur est utilisée, le disque est alors créé sans formatage lorsque le modèle est utilisé pour créer une instance. Vous devez formater et installer le disque dans un script de démarrage avant de pouvoir l'utiliser dans une configuration évolutive.

  • do-not-include (valide uniquement pour les disques persistants non amorçables et les disques en lecture seule).

L'exemple suivant crée un modèle d'instance basé sur my-source-instance. Dans le modèle d'instance, l'image de data-disk-a est remplacée par 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"
      }
    ]
  }
}

Le tableau suivant montre comment les options de remplacement de disques sont définies dans le modèle.

Type de disque	Options
Disque de démarrage	[Par défaut] Utiliser la même image source ou famille d'images sources que celle utilisée pour créer le disque de démarrage dans l'instance source. Utilisez l'URL d'une image (personnalisée ou publique) comme décrit dans l'exemple précédent, ou spécifiez une famille d'images au format suivant : projects/exampleproject/global/images/family/IMAGE_FAMILY_NAME
Autres disques persistants en lecture/écriture	[Par défaut] Utiliser la même image source ou famille d'images sources que celle utilisée pour créer le disque dans l'instance source. Remarque : Si le disque de l'instance source ne possède pas de propriété d'image source ou de famille d'image source, il est inclus dans le modèle en tant que disque vide. Utilisez l'URL d'une image (personnalisée ou publique) comme décrit dans l'exemple précédent, ou spécifiez une famille d'images au format suivant : projects/exampleproject/global/images/family/IMAGE_FAMILY_NAME Utiliser un disque vide dans le modèle. Lorsque le modèle est utilisé pour créer une instance, ce disque est créé sans formatage. Vous devez formater et installer le disque dans un script de démarrage avant de pouvoir l'utiliser dans une configuration évolutive. N'incluez pas le disque.
Disque(s) en lecture seule	[Par défaut] Inclure le disque en mode lecture seule. N'incluez pas le disque.
Disque(s) SSD local/locaux	[Par défaut] Inclure un disque SSD local vide. Lorsque le modèle est utilisé pour créer une instance, ce disque est créé sans formatage. Vous devez formater et installer le disque dans un script de démarrage avant de pouvoir l'utiliser dans une configuration évolutive.

Pour chaque disque, vous pouvez également remplacer l'attribut auto-delete pour indiquer si le disque doit être supprimé ou non lorsque l'instance associée est elle-même supprimée.

Par défaut, si aucune option de remplacement n'est spécifiée, la configuration du disque dans le modèle correspond à celle de l'instance source.

Créer un modèle d'instance basé sur un modèle existant

Vous ne pouvez pas mettre à jour un modèle d'instance existant. Toutefois, si un modèle d'instance devient obsolète ou si vous devez effectuer des modifications, vous pouvez en créer un autre avec des propriétés similaires à l'aide de la console.

1. Accédez à la page Modèles d'instance.

   Accéder à la page Modèles d'instances

2. Cliquez sur le modèle d'instance que vous souhaitez copier et mettre à jour.

3. Cliquez sur Créer une instance similaire.

4. Mettez à jour la configuration du nouveau modèle.

5. Cliquez sur Créer.

Créer un modèle d'instance pour les VM de GPU

Lorsque vous créez un modèle d'instance, vous pouvez le configurer pour créer des VM auxquelles sont associés des GPU en spécifiant les éléments suivants :

• Un type de machine compatible avec le type de GPU souhaité. Si vous souhaitez créer un modèle d'instance régional, le type de GPU que vous spécifiez dans le modèle doit être disponible dans au moins une zone de la région.

• Une stratégie de maintenance qui arrête les VM lors des événements de maintenance de l'hôte.

Remarque : Si vous souhaitez exécuter des charges de travail de data science ou de machine learning, envisagez d'utiliser une instance Deep Learning VM Image lorsque vous créez un modèle d'instance. Deep Learning VM Image est un ensemble d'images de VM préinstallées, fourni avec des frameworks de machine learning et des outils essentiels. Pour en savoir plus sur ces images, consultez la section Choisir une image de la documentation sur Deep Learning VM Image.

Autorisations requises pour cette tâche

Pour effectuer cette tâche, vous devez disposer des autorisations suivantes :

• Toutes les autorisations requises pour appeler la méthode instanceTemplates.insert

Console

Pour créer un modèle d'instance pour les VM avec GPU, procédez comme suit :

1. Dans la console Google Cloud, accédez à la page Modèles d'instances.

   Accéder à la page Modèles d'instances

2. Cliquez sur Créer un modèle d'instance.

3. Dans le champ Nom, saisissez un nom pour le modèle d'instance.

4. Dans la section Emplacement, sélectionnez l'une des options suivantes :

   • Pour créer un modèle d'instance global, sélectionnez Global (par défaut).

   • Pour créer un modèle d'instance régional, sélectionnez Régional puis sélectionnez la région dans laquelle vous souhaitez créer le modèle d'instance.

5. Dans la section Configuration de la machine, procédez comme suit :

   1. Cliquez sur l'onglet GPU.

   2. Dans le menu Type de GPU, sélectionnez le type de GPU.

   3. Dans le menu Nombre de GPU, sélectionnez le nombre de GPU.

   4. Facultatif : si votre modèle de GPU est compatible avec les postes de travail virtuels NVIDIA RTX (vWS) pour les charges de travail graphiques et que vous prévoyez d'exécuter des charges de travail graphiques lourdes, sélectionnez l'option Activer le poste de travail virtuel (NVIDIA GRID).

   5. Dans la section Type de machine, sélectionnez un type de machine.

6. Pour modifier le type ou l'image de disque de démarrage par défaut, cliquez sur Modifier dans la section Disque de démarrage. Suivez ensuite les instructions pour modifier le disque de démarrage.

7. Cliquez sur Créer.

gcloud

Pour créer un modèle d'instance pour les VM avec GPU, exécutez la commande instance-templates create avec l'option --maintenance-policy définie sur TERMINATE.

Par exemple, pour créer un modèle d'instance global pour les VM avec GPU, utilisez la commande suivante :

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

Remplacez les éléments suivants :

• INSTANCE_TEMPLATE_NAME : nom du modèle d'instance.

• IMAGE_PROJECT : projet contenant l'image, par exemple, debian-cloud. Pour en savoir plus sur les projets d'image compatibles, consultez la page Images publiques.

• IMAGE_FAMILY ou IMAGE : spécifiez l'un des éléments suivants :

  • IMAGE_FAMILY : famille d'images. Cela permet de spécifier l'image d'OS non obsolète la plus récente. Par exemple, si vous spécifiez debian-10, la dernière version de la famille d'images Debian 10 est utilisée. Pour en savoir plus sur l'utilisation des familles d'images, consultez la page Bonnes pratiques concernant les familles d'images.

  • IMAGE : version spécifique de l'image de l'OS. Exemple : debian-10-buster-v20200309. Si vous choisissez de stipuler une version spécifique de l'image du système d'exploitation, vous devez remplacer l'option --image-family par l'option --image.

• MACHINE_TYPE : type de machine des VM. Si vous spécifiez un type de machine N1, incluez l'option --accelerator pour spécifier le nombre et le type de GPU à associer à vos VM.

Par exemple, supposons que vous souhaitiez créer un modèle d'instance global spécifiant les propriétés suivantes pour les VM avec GPU :

• Type de machine prédéfini N1 doté de deux processeurs virtuels.

• Un GPU NVIDIA T4 à associer aux VM.

• Debian comme projet d'image.

• Debian 10 comme famille d'images.

Pour créer l'exemple de modèle d'instance, utilisez la commande suivante :

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

Pour créer un modèle d'instance pour les VM avec GPU, utilisez la ressource google_compute_region_instance_template.

Par exemple, pour créer un modèle d'instance global, qui spécifie un type de machine prédéfini N1 doté de deux processeurs virtuels et d'un GPU NVIDIA T4 associé, utilisez la ressource suivante :

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

Pour savoir comment appliquer ou supprimer une configuration Terraform, consultez la page Commandes Terraform de base.

REST

Pour créer un modèle d'instance pour les VM avec GPU, envoyez une requête POST à la méthode instanceTemplates.insert. Dans le corps de la requête, incluez le champ onHostMaintenance et définissez-le sur TERMINATE.

Par exemple, pour créer un modèle d'instance global pour les VM avec GPU, envoyez une requête POST comme suit :

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

Remplacez les éléments suivants :

• PROJECT_ID : ID du projet dans lequel vous souhaitez créer le modèle d'instance.

• INSTANCE_TEMPLATE_NAME : nom du modèle d'instance.

• IMAGE_PROJECT : projet contenant l'image, par exemple, debian-cloud. Pour en savoir plus sur les projets d'image compatibles, consultez la page Images publiques.

• IMAGE ou IMAGE_FAMILY : spécifiez l'un des éléments suivants :

  • IMAGE : version spécifique de l'image de l'OS. Exemple : debian-10-buster-v20200309.

  • IMAGE_FAMILY : famille d'images. Cela permet de spécifier l'image d'OS non obsolète la plus récente. Par exemple, si vous spécifiez family/debian-10, la dernière version de la famille d'images Debian 10 est utilisée. Pour en savoir plus sur l'utilisation des familles d'images, consultez la page Bonnes pratiques concernant les familles d'images.

• MACHINE_TYPE : type de machine des VM. Si vous spécifiez un type de machine N1, incluez l'option guestAccelerators pour spécifier le nombre et le type de GPU à associer à vos VM.

Par exemple, supposons que vous souhaitiez créer un modèle d'instance global spécifiant les propriétés suivantes pour les VM avec GPU :

• Type de machine prédéfini N1 doté de deux processeurs virtuels.

• Un GPU NVIDIA T4 à associer aux VM.

• Debian comme projet d'image.

• Debian 10 comme famille d'images.

Pour créer l'exemple de modèle d'instance, envoyez une requête POST comme suit :

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

Pour plus d'options de configuration lors de la création d'un modèle d'instance, consultez la section Créer un modèle d'instance du présent document.

Créer un modèle d'instance avec une image de conteneur

Vous pouvez spécifier une image de conteneur dans un modèle d'instance. Par défaut, Compute Engine inclut également dans le modèle une image Container-Optimized OS sur laquelle Docker est installé. Lorsque vous utilisez le modèle pour créer une instance, le conteneur est lancé automatiquement au démarrage de l'instance.

Console

1. Accédez à la page Modèles d'instance.

   Accéder à la page Modèles d'instances

2. Cliquez sur Créer un modèle d'instance.

3. Dans la section Conteneur, cliquez sur Déployer le conteneur.

4. Dans la boîte de dialogue Configurer le conteneur, spécifiez l'image de conteneur à utiliser.

   • Vous pouvez spécifier une image provenant de Container Registry ou d'Artifact Registry. Exemple :
     • gcr.io/cloud-marketplace/google/nginx1:TAG, où TAG est le tag défini pour une version spécifique de l'image de conteneur NGINX disponible sur Google Cloud Marketplace.
     • us-docker.pkg.dev/google-samples/containers/gke/hello-app:1.0 sélectionne un exemple d'image hello-app stockée dans Artifact Registry.
   • Si vous utilisez une image de conteneur de Docker Hub, spécifiez toujours le nom complet de l'image Docker. Par exemple, indiquez le nom d'image suivant pour déployer une image de conteneur Apache : docker.io/httpd:2.4.

5. Vous pouvez également cliquer sur Options avancées des conteneurs. Pour plus d'informations, consultez la page Configurer des options pour exécuter votre conteneur.

6. Cliquez sur Créer.

gcloud

Exécutez la commande gcloud compute instance-templates create-with-container :

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

Remplacez les éléments suivants :

• INSTANCE_TEMPLATE_NAME : le nom du modèle à créer.
• CONTAINER_IMAGE : le nom complet de l'image de conteneur à utiliser.

Par exemple, la commande suivante crée un modèle d'instance appelé nginx-vm. Une instance de VM créée à partir de ce modèle lance et exécute l'image de conteneur gcr.io/cloud-marketplace/google/nginx1:TAG au démarrage de la VM.

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

Remplacez TAG par le tag défini pour une version spécifique de l'image de conteneur NGINX disponible sur Google Cloud Marketplace.

Vous pouvez également configurer des options pour exécuter votre conteneur.

Attention : Container Registry est obsolète et son abandon est planifié. Les organisations n'ayant pas utilisé Container Registry avant le 8 janvier 2024 disposeront par défaut des nouveaux dépôts gcr.io hébergés sur Artifact Registry. Depuis le 15 mai 2024, les projets Google Cloud qui n'utilisaient pas Container Registry précédemment n'accepteront que l'hébergement et la gestion des images dans Artifact Registry pour le domaine gcr.io.

L'arrêt de Container Registry est prévu pour le 18 mars 2025. Pour en savoir plus sur cet arrêt, consultez la page Abandon de Container Registry.

Créer un modèle d'instance spécifiant un sous-réseau

gcloud

Pour créer un modèle d'instance régional ou global, utilisez la commande instance-templates create. Utilisez l'option --subnet pour placer des instances créées à partir du modèle dans le sous-réseau de votre choix. L'option --subnet requiert l'option --region.

Si vous souhaitez créer un modèle d'instance régional, vous devez utiliser l'option --instance-template-region pour spécifier la région du modèle. Assurez-vous d'utiliser un sous-réseau de la même région que celle dans laquelle vous souhaitez créer le modèle d'instance régional.

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

Remplacez les éléments suivants :

• INSTANCE_TEMPLATE_NAME : le nom du modèle d'instance.
• REGION : la région du sous-réseau.

• SUBNET_NAME_OR_URL : le nom ou l'URL du sous-réseau.

  Remarque : Si vous utilisez le nom du sous-réseau, Google trouve ce sous-réseau dans la région cible (à condition qu'il existe dans cette région). Toutefois, si vous utilisez l'URL du sous-réseau, le modèle d'instance ne peut être utilisé que pour créer des instances dans la région spécifique associée à l'URL du sous-réseau.

• INSTANCE_TEMPLATE_REGION : région dans laquelle vous souhaitez créer le modèle d'instance. Cette valeur doit être identique à celle stipulée à la place de REGION.

L'exemple suivant génère un modèle appelé template-qa qui crée uniquement des instances dans le sous-réseau 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

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)

En utilisant ce modèle pour créer des instances pour un MIG (avec ou sans autoscaling), vous créez automatiquement l'instance dans la région et le sous-réseau spécifiés. Cela vous permet de contrôler le sous-réseau des nouvelles instances créées pour l'équilibrage de charge.

Utiliser des images personnalisées ou publiques dans vos modèles d'instances

Vous pouvez utiliser une image personnalisée ou une image publique pour vos modèles d'instances :

• Images personnalisées : les MIG étant conçus pour ajouter et supprimer fréquemment des instances, il est utile de créer une image personnalisée et de la spécifier dans le modèle d'instance. Vous pouvez préparer votre image avec les applications et les paramètres dont vos VM ont besoin. Vous n'avez donc pas besoin de configurer manuellement ces éléments sur des VM individuelles dans le MIG.

• Images publiques : vous pouvez créer un modèle d'instance qui utilise une image publique et un script de démarrage pour préparer l'instance après son démarrage.

Les images personnalisées sont plus déterministes et démarrent plus rapidement que les VM utilisant des scripts de démarrage. Cependant, les scripts de démarrage sont plus souples et vous facilitent la mise à jour des applications et des paramètres de vos instances.

Si vous gérez des images à l'aide de familles d'images, vous pouvez spécifier le nom de votre famille d'images personnalisée ou publique dans le modèle d'instance. Pour en savoir plus sur les familles d'images, consultez la page Bonnes pratiques d'utilisation des familles d'images sur Compute Engine.

Remarque : Si l'image que vous souhaitez utiliser appartient à un projet différent, vous pouvez tout de même l'utiliser dans votre modèle d'instance, à condition que le propriétaire de ce projet accorde l'accès aux images au groupe d'instances géré. Pour en savoir plus, consultez la section Accorder l'accès aux images à un groupe d'instances géré.

Étapes suivantes

• Créer une instance de VM à partir d'un modèle d'instance
• Créez un groupe d'instances géré zonal.
• Créez un groupe d'instances géré régional.
• Mettez à jour les VM d'un MIG existant pour utiliser la configuration à partir d'un nouveau modèle.
• Créez une réservation pour des VM.