Obtenir, répertorier et supprimer des modèles d'instance


Cette page décrit comment obtenir, répertorier et supprimer des modèles d'instances.

Avant de commencer

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

    Sélectionnez l'onglet correspondant à la façon dont vous prévoyez d'utiliser les exemples de cette page :

    Console

    Lorsque vous utilisez la console Google Cloud pour accéder aux services et aux API Google Cloud, vous n'avez pas besoin de configurer l'authentification.

    gcloud

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

      gcloud init
    2. Définissez une région et une zone par défaut.

    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. Create local authentication credentials for your user account:

      gcloud auth application-default login

    Pour en savoir plus, consultez les sections sur Configurer l'authentification pour un environnement de développement local.

    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. Create local authentication credentials for your user account:

      gcloud auth application-default login

    Pour en savoir plus, consultez les sections sur Configurer l'authentification pour un environnement de développement local.

    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. Create local authentication credentials for your user account:

      gcloud auth application-default login

    Pour en savoir plus, consultez les sections sur Configurer l'authentification pour un environnement de développement local.

    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. Create local authentication credentials for your user account:

      gcloud auth application-default login

    Pour en savoir plus, consultez les sections sur Configurer l'authentification pour un environnement de développement local.

    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

Obtenir des informations sur un modèle d'instance

Console

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

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

  2. Cliquez sur le nom d'un modèle d'instance pour afficher les détails s'y rapportant.

gcloud

Pour obtenir des informations sur un modèle d'instance régional ou global, utilisez instance-templates describe command.

Pour un modèle d'instance régional, utilisez la commande suivante :

gcloud compute instance-templates describe INSTANCE_TEMPLATE_NAME \
    --region=REGION

Pour un modèle d'instance global, utilisez la commande suivante :

gcloud compute instance-templates describe INSTANCE_TEMPLATE_NAME

Go

import (
	"context"
	"fmt"

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

// getInstanceTemplate retrieves an instance template, which you can use to create virtual machine
// (VM) instances and managed instance groups (MIGs).
func getInstanceTemplate(projectID, templateName string) (*computepb.InstanceTemplate, error) {
	// projectID := "your_project_id"
	// templateName := "your_template_name"

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

	req := &computepb.GetInstanceTemplateRequest{
		Project:          projectID,
		InstanceTemplate: templateName,
	}

	return instanceTemplatesClient.Get(ctx, req)
}

Java


import com.google.cloud.compute.v1.GetInstanceTemplateRequest;
import com.google.cloud.compute.v1.InstanceTemplate;
import com.google.cloud.compute.v1.InstanceTemplatesClient;
import java.io.IOException;

public class GetInstanceTemplate {

  public static void main(String[] args) throws IOException {
    // 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 template to retrieve.
    String projectId = "your-project-id";
    String templateName = "template-name";
    getInstanceTemplate(projectId, templateName);
  }

  //  Retrieve an instance template, which you can use to create virtual machine
  //  (VM) instances and managed instance groups (MIGs).
  public static void getInstanceTemplate(String projectId, String templateName) throws IOException {
    try (InstanceTemplatesClient instanceTemplatesClient = InstanceTemplatesClient.create()) {

      GetInstanceTemplateRequest getInstanceTemplateRequest = GetInstanceTemplateRequest
          .newBuilder()
          .setProject(projectId)
          .setInstanceTemplate(templateName).build();

      InstanceTemplate instanceTemplate = instanceTemplatesClient.get(getInstanceTemplateRequest);
      System.out.println("Instance Template retrieved: " + instanceTemplate.getName());
    }
  }
}

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');

// Retrieve an instance template, which you can use to create
// virtual machine (VM) instances and managed instance groups (MIGs).
async function getInstanceTemplate() {
  const instanceTemplatesClient = new compute.InstanceTemplatesClient();

  const [instance] = await instanceTemplatesClient.get({
    project: projectId,
    instanceTemplate: templateName,
  });

  console.log('Instance template:', instance);
}

getInstanceTemplate();

Python

from google.cloud import compute_v1

def get_instance_template(
    project_id: str, template_name: str
) -> compute_v1.InstanceTemplate:
    """
    Retrieve an instance template, which you can use to create virtual machine
    (VM) instances and managed instance groups (MIGs).

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

    Returns:
        InstanceTemplate object that represents the retrieved template.
    """
    template_client = compute_v1.InstanceTemplatesClient()
    return template_client.get(project=project_id, instance_template=template_name)

REST

Pour obtenir des informations sur un modèle d'instance régional, utilisez la méthode regionInstanceTemplates.get comme suit :

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

Pour obtenir des informations sur un modèle d'instance global, utilisez la commande instanceTemplates.get comme suit :

GET https://compute.googleapis.com/compute/v1/projects/[PROJECT_ID]/global/instanceTemplates/[INSTANCE_TEMPLATE]

Obtenir la liste des modèles d'instances

Pour obtenir une liste des modèles d'instances que vous avez créés :

Console

La page "Modèles d'instances" répertorie tous les modèles d'instances de votre projet.

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

gcloud

Pour obtenir la liste de tous les modèles d'instances régionaux, utilisez la commande suivante :

gcloud compute instance-templates list \
    --regions

Pour obtenir la liste des modèles d'instances régionaux dans une région spécifique, utilisez la commande suivante :

gcloud compute instance-templates list \
    --filter="region:(REGION)"

Pour obtenir la liste des modèles d'instances globaux, utilisez la commande suivante :

gcloud compute instance-templates list \
    --global

Pour obtenir la liste de tous les modèles d'instance, y compris les modèles régionaux et globaux, utilisez la commande suivante :

gcloud compute instance-templates list

Go

import (
	"context"
	"fmt"
	"io"

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

// listInstanceTemplates prints a list of InstanceTemplate objects available in a project.
func listInstanceTemplates(w io.Writer, projectID string) error {
	// projectID := "your_project_id"

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

	req := &computepb.ListInstanceTemplatesRequest{
		Project: projectID,
	}

	it := instanceTemplatesClient.List(ctx, req)
	for {
		instance, err := it.Next()
		if err == iterator.Done {
			break
		}
		if err != nil {
			return err
		}
		fmt.Fprintf(w, "- %s %s\n", instance.GetName(), instance.GetProperties().GetMachineType())
	}

	return nil
}

Java


import com.google.cloud.compute.v1.InstanceTemplate;
import com.google.cloud.compute.v1.InstanceTemplatesClient;
import com.google.cloud.compute.v1.InstanceTemplatesClient.ListPagedResponse;
import java.io.IOException;

public class ListInstanceTemplates {

  public static void main(String[] args) throws IOException {
    // TODO(developer): Replace these variables before running the sample.
    // projectId: project ID or project number of the Cloud project you use.
    String projectId = "your-project-id";
    listInstanceTemplates(projectId);
  }

  // Get a list of InstanceTemplate objects available in a project.
  public static ListPagedResponse listInstanceTemplates(String projectId) throws IOException {
    try (InstanceTemplatesClient instanceTemplatesClient = InstanceTemplatesClient.create()) {
      int count = 0;
      System.out.println("Listing instance templates...");
      ListPagedResponse templates = instanceTemplatesClient.list(projectId);
      for (InstanceTemplate instanceTemplate : templates.iterateAll()) {
        System.out.printf("%s. %s%n", ++count, instanceTemplate.getName());
      }
      return templates;
    }
  }
}

Node.js

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

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

// Print a list of instance template objects available in a project.
async function listInstanceTemplates() {
  const instanceTemplatesClient = new compute.InstanceTemplatesClient();

  const instanceTemplates = instanceTemplatesClient.listAsync({
    project: projectId,
  });

  for await (const instanceTemplate of instanceTemplates) {
    console.log(` - ${instanceTemplate.name}`);
  }
}

listInstanceTemplates();

Python

from __future__ import annotations

from collections.abc import Iterable

from google.cloud import compute_v1

def list_instance_templates(project_id: str) -> Iterable[compute_v1.InstanceTemplate]:
    """
    Get a list of InstanceTemplate objects available in a project.

    Args:
        project_id: project ID or project number of the Cloud project you use.

    Returns:
        Iterable list of InstanceTemplate objects.
    """
    template_client = compute_v1.InstanceTemplatesClient()
    return template_client.list(project=project_id)

REST

Pour obtenir la liste des modèles d'instances régionaux, envoyez une requête regionInstanceTemplates.list :

GET https://compute.googleapis.com/compute/v1/projects/PROJECT/regions/REGION/instanceTemplates

Pour obtenir la liste des modèles d'instances globaux, envoyez une requête instanceTemplates.list :

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

Supprimer un modèle d'instance

Lorsque vous supprimez un modèle d'instance, celui-ci est retiré de votre liste de modèles. Vous ne pouvez pas supprimer un modèle d'instance si un groupe d'instances géré y fait référence.

Console

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

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

  2. Sélectionnez les modèles d'instances à supprimer.
  3. Cliquez sur Supprimer.

gcloud

À l'aide de Google Cloud CLI, exécutez la commande suivante :

gcloud compute instance-templates delete INSTANCE_TEMPLATE_NAME

Pour un modèle d'instance régional, INSTANCE_TEMPLATE_NAME doit contenir l'URL complète du modèle. Par exemple, https://www.googleapis.com/compute/v1/projects/example-project/regions/us-central1/instanceTemplates/example-regional-instance-template.

Go

import (
	"context"
	"fmt"
	"io"

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

// deleteInstanceTemplate deletes an instance template.
func deleteInstanceTemplate(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.DeleteInstanceTemplateRequest{
		Project:          projectID,
		InstanceTemplate: templateName,
	}

	op, err := instanceTemplatesClient.Delete(ctx, req)
	if err != nil {
		return fmt.Errorf("unable to delete 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 deleted\n")

	return nil
}

Java


import com.google.cloud.compute.v1.DeleteInstanceTemplateRequest;
import com.google.cloud.compute.v1.InstanceTemplatesClient;
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 DeleteInstanceTemplate {

  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";
    deleteInstanceTemplate(projectId, templateName);
  }

  // Delete an instance template.
  public static void deleteInstanceTemplate(String projectId, String templateName)
      throws IOException, ExecutionException, InterruptedException, TimeoutException {
    try (InstanceTemplatesClient instanceTemplatesClient = InstanceTemplatesClient.create()) {

      DeleteInstanceTemplateRequest deleteInstanceTemplateRequest = DeleteInstanceTemplateRequest
          .newBuilder()
          .setProject(projectId)
          .setInstanceTemplate(templateName).build();

      Operation response = instanceTemplatesClient.deleteAsync(deleteInstanceTemplateRequest)
          .get(3, TimeUnit.MINUTES);

      if (response.hasError()) {
        System.out.println("Instance template deletion failed ! ! " + response);
        return;
      }
      System.out.printf("Instance template deletion operation status for %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');

// Delete an instance template.
async function deleteInstanceTemplate() {
  const instanceTemplatesClient = new compute.InstanceTemplatesClient();

  const [response] = await instanceTemplatesClient.delete({
    project: projectId,
    instanceTemplate: templateName,
  });
  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 deleted.');
}

deleteInstanceTemplate();

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 delete_instance_template(project_id: str, template_name: str) -> None:
    """
    Delete an instance template.

    Args:
        project_id: project ID or project number of the Cloud project you use.
        template_name: name of the template to delete.
    """
    template_client = compute_v1.InstanceTemplatesClient()
    operation = template_client.delete(
        project=project_id, instance_template=template_name
    )
    wait_for_extended_operation(operation, "instance template deletion")

REST

Pour supprimer un modèle d'instance régional, envoyez une requête regionInstanceTemplates.delete :

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

Pour supprimer un modèle d'instance global, envoyez une requête instanceTemplates.delete :

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

Parfois, les VM d'un groupe d'instances géré ne sont pas synchronisées avec le reste du groupe. Elles utilisent un modèle d'instance différent de celui du reste du groupe. Si une VM d'un groupe d'instances géré utilise un modèle différent de celui spécifié dans le groupe, cette VM continuera d'utiliser son modèle pour la réparation, même si ce modèle est supprimé. Pour plus d'informations sur l'application d'un nouveau modèle d'instance, consultez la page Appliquer de nouvelles configurations aux VM dans un MIG.