Créer une réservation partagée

---

Ce document explique comment créer des réservations partagées entre plusieurs projets et gérer les projets de votre organisation qui peuvent les utiliser.

Une réservation partagée peut être utilisée par le projet qui héberge la réservation (projet propriétaire) et par les projets avec lesquels la réservation est partagée (projets consommateurs). Utilisez les réservations partagées si votre organisation dispose de plusieurs projets nécessitant des instances de machine virtuelle (VM) avec les mêmes propriétés d'instance réservées. Les réservations partagées vous permettent d'améliorer l'utilisation de vos réservations et de réduire le nombre de réservations que vous devez créer et gérer. Pour en savoir plus, consultez la section Réservations de ressources zonales Compute Engine.

Pour découvrir d'autres méthodes de création de réservations, consultez les pages suivantes :

• Si vous avez des engagements d'un ou de trois ans dans le projet en cours, vos ressources réservées reçoivent automatiquement les remises sur engagement d'utilisation applicables. Vous pouvez également créer et associer une réservation à un engagement lorsque vous souscrivez cet engagement. Pour en savoir plus, consultez la section Associer des réservations à des engagements.

• Pour créer une réservation qui ne peut être utilisée que par un seul projet, consultez la page Créer une réservation pour un seul projet.

Remarque: La création d'une réservation entraîne des frais pour ses ressources réservées, même lorsqu'elles ne sont pas utilisées, jusqu'à ce que vous la supprimiez. Pour en savoir plus, consultez Facturation.

Avant de commencer

• Consultez les exigences et restrictions applicables aux réservations.
• Consultez les exigences relatives aux quotas et les restrictions applicables aux réservations partagées.
• Assurez-vous que le projet que vous utilisez pour créer des réservations partagées a été ajouté à la liste d'autorisation pour la contrainte de règle d'organisation des projets propriétaires de réservations partagées (compute.sharedReservationsOwnerProjects) par un administrateur des règles d'administration. Cette liste d'autorisation est vide par défaut, ce qui signifie que vous ne pouvez pas créer de réservations partagées tant que votre organisation n'accorde pas cette autorisation à un ou plusieurs projets. Pour en savoir plus sur l'affichage et la modification de la contrainte de règle d'administration, consultez la section Autoriser et restreindre la création et la modification de réservations partagées pour des projets de ce document.
• 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 en sélectionnant l'une des options suivantes:
  

  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.

Rôles requis

Pour obtenir les autorisations nécessaires pour créer des réservations partagées, demandez à votre administrateur de vous accorder les rôles IAM suivants :

• Administrateur Compute (roles/compute.admin) sur le projet
• Pour afficher et modifier des règles d'administration : Administrateur des règles d'administration (roles/orgpolicy.policyAdmin) sur l'organisation

Pour en savoir plus sur l'attribution de rôles, consultez la page Gérer l'accès aux projets, aux dossiers et aux organisations.

Ces rôles prédéfinis contiennent les autorisations requises pour créer des réservations partagées. Pour connaître les autorisations exactes requises, développez la section Autorisations requises :

Autorisations requises

Les autorisations suivantes sont requises pour créer des réservations partagées :

• compute.reservations.create sur le projet
• Pour afficher les règles d'administration : orgpolicy.policy.get sur l'organisation
• Pour modifier les règles d'administration : orgpolicy.policy.set sur l'organisation
• Pour spécifier un modèle d'instance : compute.instanceTemplates.useReadOnly sur le modèle d'instance

Vous pouvez également obtenir ces autorisations avec des rôles personnalisés ou d'autres rôles prédéfinis.

Bonnes pratiques

Lorsque vous créez des réservations partagées, il est recommandé de suivre les bonnes pratiques suivantes. Ce faisant, vous pouvez optimiser la gestion et l'utilisation des réservations partagées dans votre organisation.

• Demander au projet propriétaire de créer la réservation partagée, sans l'utiliser.
  • Pour répartir les dépenses entre plusieurs projets, il est recommandé de dédier l'utilisation d'une réservation partagée aux projets clients. Le projet propriétaire ne doit être utilisé que pour créer la réservation partagée.
  • Lors de la création d'une réservation partagée, le projet propriétaire doit disposer d'un quota suffisant pour le nombre total de ressources à réserver. Ensuite, une fois la réservation créée, le projet propriétaire doit disposer d'un quota pour toutes les ressources réservées qu'il souhaite consommer. Pour en savoir plus, consultez la section Exigences supplémentaires relatives aux quotas pour les réservations partagées.
• Minimisez le nombre de projets dans votre organisation que vous autorisez à créer des réservations partagées. Pour ce faire, vous pouvez utiliser la contrainte de règle d'administration des projets propriétaires de réservations partagées (compute.sharedReservationsOwnerProjects).
  • Vous ne pouvez répertorier que les réservations créées par chaque projet. Cela signifie que les réservations partagées ne sont répertoriées que dans le projet propriétaire. Vous ne pouvez pas répertorier les réservations partagées avec chaque projet ni répertorier toutes les réservations partagées dans chaque organisation. Limiter le nombre de projets propriétaires facilite la surveillance et la gestion de vos réservations partagées.
  • Limitez le partage d'une réservation partagée à seulement quelques projets, afin de gérer plus facilement le quota de vos ressources réservées.
  • Pour en savoir plus, consultez la section Autoriser et restreindre la création et la modification de réservations partagées pour des projets.
• Réduisez le nombre de réservations partagées distinctes avec des propriétés de VM identiques.
  • Une organisation peut avoir jusqu'à 100 réservations partagées pour chaque combinaison unique de propriétés de VM. Par conséquent, réduire le nombre de réservations partagées avec des propriétés de VM identiques que vous créez permet d'atténuer cette limite.
  • Un nombre réduit de réservations partagées facilite la gestion.
• Ne partagez les réservations qu'entre des projets associés au même compte de facturation Cloud.
  • Limitez chaque réservation partagée uniquement aux projets clients qui ont le même compte de facturation Cloud que le projet propriétaire. Cela vous permet de voir plus facilement si une réservation a été consommée et comment elle a été facturée.
  • Si vous avez activé le partage de remises sur engagement d'utilisation et que vous pouvez bénéficier de remises sur engagement d'utilisation au niveau du compte de facturation Cloud, limitez le partage de vos réservations au compte de facturation Cloud de cet engagement pour maximiser les remises sur engagement d'utilisation que vous recevrez pour vos réservations consommées. Cela vous permet de maintenir une facturation cohérente entre les projets qui créent et consomment des réservations partagées.
• Pour les demandes de réservations futures, examinez attentivement le nombre total de VM que vous demandez.
  • Si vous créez une demande de réservation future, veillez à demander un nombre total de VM qui tienne compte de tous les éléments suivants :
    • Toutes les VM réservées correspondantes qui existeront déjà à la date ultérieure.
    • Toutes les VM non réservées correspondantes qui existeront déjà à la date ultérieure.
    • Toutes les réservations à la demande correspondantes non utilisées qui existeront déjà à la date ultérieure.
    • Augmentation de l'utilisation que vous souhaitez réserver à la date ultérieure.

    Par exemple, supposons que vous ayez besoin de 10 VM supplémentaires à la date ultérieure et que vous ayez déjà les ressources suivantes à la date ultérieure :

    • 40 VM réservées correspondantes
    • 50 VM non réservées correspondantes

    ou

    • 40 VM réservées correspondantes
    • 50 réservations à la demande correspondantes non utilisées

    Étant donné que votre utilisation existante à la date future équivaut déjà à 90 VM et réservations correspondantes, et que vous avez besoin de 10 VM supplémentaires, vous devez spécifier un nombre total de 100 dans votre demande de réservation future.

    Remarque : Si vous créez des réservations à la demande supplémentaires après avoir envoyé la demande de réservation future et avant la date ultérieure, celles-ci sont comptabilisées dans votre total.
    
    Si, après la date ultérieure, vous ajoutez d'autres réservations à la demande, ces réservations sont ajoutées au total précédent. Par exemple, si vous réservez dix VM supplémentaires après la date ultérieure, vous aurez 110 réservations.

    Pour en savoir plus, consultez la section Compter et provisionner les ressources réservées.

Autoriser et restreindre la création et la modification de réservations partagées pour des projets

Par défaut, aucun projet n'est autorisé à créer ou à modifier des réservations partagées dans une organisation. Ajoutez des projets à la contrainte de règle d'administration des projets propriétaires de réservations partagées (compute.sharedReservationsOwnerProjects) pour les autoriser à créer et modifier des réservations partagées. Pour en savoir plus sur les contraintes liées aux règles d'administration, consultez la section Présentation du service de règles d'administration.

Procédez comme suit pour afficher et modifier la contrainte de règle d'administration des projets propriétaires de réservations partagées (compute.sharedReservationsOwnerProjects).

Afficher la contrainte de règle d'administration des réservations partagées

Pour savoir quels projets sont autorisés à créer et modifier des réservations partagées, utilisez la console Google Cloud ou la gcloud CLI.

Console

Suivez les étapes pour Afficher les règles d'administration à l'aide de la contrainte Projets propriétaire de réservations partagées.

gcloud

Pour afficher les projets que la contrainte compute.sharedReservationsOwnerProjects autorise à créer et modifier des réservations partagées, procédez comme suit :

1. Téléchargez la règle de votre organisation sous la forme d'un fichier nommé policy.yaml, à l'aide de la commande gcloud resource-manager org-policies describe :

   gcloud resource-manager org-policies describe compute.sharedReservationsOwnerProjects --organization=ORGANIZATION_ID > policy.yaml
   

   Remplacez ORGANIZATION_ID par l'ID de votre organisation.

2. Utilisez un éditeur de texte pour ouvrir le fichier policy.yaml et afficher la contrainte compute.sharedReservationsOwnerProjects. Les projets autorisés à créer et à modifier des réservations partagées sont répertoriés sous sa propriété allowedValues :

   ...
   constraint: constraints/compute.sharedReservationsOwnerProjects
   listPolicy:
     allowedValues:
     - projects/PROJECT_NUMBER_1
     - projects/PROJECT_NUMBER_2
     - projects/PROJECT_NUMBER_3
   ...
   

   où PROJECT_NUMBER_1, PROJECT_NUMBER_2 et PROJECT_NUMBER_3 sont les numéros de projets des seuls projets de votre organisation autorisés à créer des réservations partagées.

3. Facultatif : supprimez le fichier policy.yaml.

   • Si vous utilisez un terminal Linux ou macOS, exécutez la commande suivante :

     rm policy.yaml
     

   • Si vous utilisez un terminal Windows, exécutez la commande suivante :

     del policy.yaml
     

Modifier la contrainte de règle d'administration des réservations partagées

Pour changer les projets autorisés à créer et modifier des réservations partagées, utilisez la console Google Cloud ou gcloud CLI.

Console

Suivez les étapes décrites dans la section Personnaliser les règles pour les contraintes de liste à l'aide de la contrainte Projets propriétaires de réservations partagées.

Remarque : Vous devez spécifier le numéro du projet (pas l'ID) pour chaque projet que vous souhaitez autoriser à créer des réservations partagées.

gcloud

Pour modifier les projets que la contrainte compute.sharedReservationsOwnerProjects autorise à créer et modifier des réservations partagées, utilisez l'une des méthodes suivantes :

• Pour autoriser un seul projet à créer et modifier des réservations partagées, utilisez la commande gcloud resource-manager org-policies allow. Vous pouvez répéter cette commande pour chaque projet auquel vous souhaitez accorder cette autorisation.

  gcloud resource-manager org-policies allow compute.sharedReservationsOwnerProjects projects/PROJECT_NUMBER \
      --organization=ORGANIZATION_ID
  

  Remplacez les éléments suivants :

  • PROJECT_NUMBER : numéro de projet (et non ID) d'un projet de votre organisation que vous souhaitez autoriser à créer et à modifier les réservations partagées.
  • ORGANIZATION_ID : ID de votre organisation.

• Pour accorder ou révoquer les autorisations de création et modification des réservations partagées pour plusieurs projets, remplacez la contrainte de règle d'administration :

  1. Pour télécharger la règle de votre organisation sous la forme d'un fichier nommé policy.yaml, utilisez la commande gcloud resource-manager org-policies describe :

     gcloud resource-manager org-policies describe compute.sharedReservationsOwnerProjects --organization=ORGANIZATION_ID > policy.yaml
     

     Remplacez ORGANIZATION_ID par l'ID de votre organisation.

  2. À l'aide d'un éditeur de texte, modifiez le fichier policy.yaml afin que la contrainte compute.sharedReservationsOwnerProjects répertorie tous les projets pour lesquels vous souhaitez autoriser la création et la modification de réservations partagées sous allowedValues.

     • Pour chaque projet que vous souhaitez autoriser à créer et à modifier des réservations partagées, ajoutez-le sur une nouvelle ligne sous allowedValues.
     • Pour chaque projet pour lequel vous souhaitez révoquer l'autorisation de créer et de modifier des réservations partagées, supprimez la ligne pour ce projet.

     Lorsque vous avez terminé, assurez-vous que le fichier policy.yaml ressemble à ce qui suit :

     ...
     constraint: constraints/compute.sharedReservationsOwnerProjects
     listPolicy:
       allowedValues:
       - projects/PROJECT_NUMBER_1
       - projects/PROJECT_NUMBER_2
       - projects/PROJECT_NUMBER_3
     ...
     

     où PROJECT_NUMBER_1, PROJECT_NUMBER_2 et PROJECT_NUMBER_3 sont les numéros de projet (et non les ID de projet) de tous les projets de l'organisation que vous souhaitez autoriser à créer et modifier les réservations partagées.

  3. Enregistrez le fichier policy.yaml et fermez l'éditeur.

  4. Pour mettre à jour la règle de votre organisation avec vos modifications, utilisez la commande gcloud resource-manager org-policies set-policy :

     gcloud resource-manager org-policies set-policy --organization=ORGANIZATION_ID policy.yaml
     

     Remplacez ORGANIZATION_ID par l'ID de votre organisation.

  5. Facultatif : supprimez le fichier policy.yaml.

     • Si vous utilisez un terminal Linux ou macOS, exécutez la commande suivante :

       rm policy.yaml
       

     • Si vous utilisez un terminal Windows, exécutez la commande suivante :

       del policy.yaml
       

Vous devrez peut-être patienter quelques minutes pour que la modification soit prise en compte.

Créer une réservation partagée

Cette section explique comment créer des réservations partagées. Une fois que vous avez créé une réservation partagée, celle-ci ne peut être modifiée que par le projet propriétaire, mais les ressources d'une réservation partagée peuvent être utilisées par le projet propriétaire ou par tout projet client.

Pour utiliser une réservation, une VM doit avoir des propriétés qui correspondent exactement à cette réservation. Pour spécifier les propriétés des VM que vous souhaitez réserver, accédez à l'une des sections suivantes de ce document :

• Option recommandée : spécifier un modèle d'instance

  Cette section explique comment utiliser un modèle d'instance pour définir les propriétés d'une réservation partagée. En utilisant un modèle d'instance, vous pouvez définir les propriétés d'une réservation et les VM pouvant utiliser la réservation au même endroit. Toutefois, comme les modèles sont spécifiques à un projet, vous ne pouvez pas utiliser le même modèle pour créer des VM pouvant utiliser la réservation en dehors du projet qui a créé la réservation. Pour les projets avec lesquels la réservation partagée est partagée, vous devez créer des modèles similaires dans ces projets ou créer des VM en spécifiant directement les propriétés.

• Spécifier une VM existante

  Cette section explique comment utiliser une VM existante pour définir les propriétés d'une réservation. En utilisant les propriétés d'une VM existante, vous pouvez utiliser la réservation en créant des VM dont les propriétés correspondent à la VM de référence.

• Spécifier les propriétés directement

  Cette section explique comment définir directement les propriétés d'une réservation partagée. Cette méthode nécessite de vous assurer manuellement que les propriétés de vos VM et de vos réservations correspondent exactement. Lespropriétés non concordantes empêchent l'utilisation des réservations.

Par défaut, une réservation peut être automatiquement utilisée par toutes les VM dont les propriétés correspondent. Si vous souhaitez contrôler l'utilisation des réservations, effectuez une ou plusieurs des opérations suivantes :

• Créez une réservation qui ne peut être utilisée que par des VM qui la ciblent spécifiquement, comme expliqué dans les sections suivantes de ce document. Ensuite, configurez les VM pour qu'elles utilisent cette réservation spécifique.

• Configurez des VM qui ne peuvent utiliser aucune réservation.

Spécifier un modèle d'instance

Avant de créer une réservation en spécifiant un modèle d'instance, vérifiez les points suivants :

• Un modèle d'instance contient des paramètres spécifiques au projet. Vous ne pouvez donc accéder à un modèle d'instance et ne l'utiliser que dans le cadre du même projet. Si vous créez une réservation partagée en spécifiant un modèle d'instance, vous ne pouvez pas utiliser le même modèle pour créer des VM pouvant utiliser la réservation en dehors du projet qui a créé la réservation.

• Créez votre réservation dans la même région et la même zone que les ressources du modèle d'instance. Toutes les ressources régionales ou zonales spécifiées dans un modèle d'instance (telles qu'un type de machine ou un volume de disque persistant) limitent l'utilisation du modèle aux emplacements où ces ressources existent. Par exemple, si votre modèle d'instance spécifie un volume de disque persistant existant dans la zone us-central1-a, vous ne pouvez créer votre réservation que dans la même zone. Pour vérifier si un modèle existant spécifie des ressources qui l'associent à une région ou à une zone spécifique, affichez les détails du modèle d'instance et recherchez des références à des ressources régionales ou zonales qu'il contient.

Pour créer une réservation partagée en spécifiant un modèle d'instance, sélectionnez l'une des options suivantes :

Console

1. Dans la console Google Cloud, accédez à la page Réservations.

   Accéder à la page "Réservations"

   La page Réservations s'affiche.

2. Cliquez sur Créer une réservation.

   La page Créer une réservation s'affiche.

3. Dans le champ Name, saisissez le nom de votre réservation.

4. Pour les champs Région et Zone, sélectionnez l'emplacement dans lequel vous souhaitez réserver des ressources.

5. Dans la section Type de partage, procédez comme suit :

   1. Pour spécifier une réservation partagée, sélectionnez Partagé.

   2. Cliquez sur Ajouter des projets, puis sélectionnez les projets de l'organisation du projet actuel avec lesquels vous souhaitez partager la réservation. Vous pouvez sélectionner jusqu'à 100 projets clients.

6. Facultatif: Pour permettre à une réservation de VM avec GPU d'être utilisée par des tâches d'entraînement personnalisées ou des tâches de prédiction dans Vertex AI, sélectionnez Partager la réservation dans la section Services Google Cloud.

7. Dans la section Utiliser avec une instance de VM, sélectionnez l'une des options suivantes :

   • Pour autoriser les instances de VM correspondantes à utiliser automatiquement cette réservation, sélectionnez l'option Utiliser automatiquement une réservation si elle n'est pas déjà sélectionnée.

   • Pour n'utiliser les ressources de cette réservation que lors de la création de VM correspondantes qui ciblent spécifiquement cette réservation par son nom, cliquez sur Sélectionner une réservation spécifique.

     Remarque : Si votre modèle d'instance spécifie un type de machine A3, vous devez sélectionner Sélectionner une réservation spécifique. Sinon, vous rencontrerez des erreurs.

8. Pour Nombre d'instances de VM, saisissez le nombre de VM que vous souhaitez réserver.

9. Dans la section Configuration de la machine, sélectionnez Utiliser un modèle d'instance, puis sélectionnez le modèle d'instance de votre choix. Si vous sélectionnez un modèle d'instance régional, vous ne pouvez réserver que des ressources situées dans la même région que celle du modèle.

10. Dans la section Suppression automatique, vous pouvez activer l'option de suppression automatique pour permettre à Compute Engine de supprimer automatiquement la réservation à une date et une heure spécifiques. La suppression automatique des réservations peut vous permettre d'éviter des frais inutiles lorsque vous arrêtez de consommer la réservation.

11. Pour créer la réservation, cliquez sur Créer.

    La page Réservations s'affiche. La création de la réservation partagée peut prendre jusqu'à une minute.

gcloud

Pour créer une réservation partagée, utilisez la commande gcloud compute reservations create avec les options --share-setting=projects et --share-with.

Pour créer une réservation partagée en spécifiant un modèle d'instance sans option facultative, exécutez la commande suivante :

gcloud compute reservations create RESERVATION_NAME \
    --share-setting=projects \
    --share-with=CONSUMER_PROJECT_IDS \
    --source-instance-template=projects/PROJECT_ID/LOCATION/instanceTemplates/INSTANCE_TEMPLATE_NAME \
    --vm-count=NUMBER_OF_VMS \
    --zone=ZONE

Remplacez les éléments suivants :

• RESERVATION_NAME : le nom de la réservation à créer.

• PROJECT_ID : l'ID du projet dans lequel vous souhaitez réserver des ressources et où le modèle d'instance existe.

• CONSUMER_PROJECT_IDS : liste d'ID de projets séparés par une virgule pouvant utiliser cette réservation, par exemple project-1,project-2. Vous pouvez inclure jusqu'à 100 projets clients. Ces projets doivent appartenir à la même organisation que le projet propriétaire. N'incluez pas le projet propriétaire. Par défaut, il est déjà autorisé à utiliser la réservation.

• LOCATION : emplacement du modèle d'instance. Spécifiez une des valeurs suivantes :

  • Pour un modèle d'instance global : global

  • Pour un modèle d'instance régional : regions/REGION. Remplacez REGION par la région dans laquelle se trouve le modèle d'instance. Si vous sélectionnez un modèle d'instance régional, vous ne pouvez réserver que des ressources situées dans la même région que celle du modèle.

• INSTANCE_TEMPLATE_NAME : nom d'un modèle d'instance existant. Si le modèle d'instance spécifie un type de machine A3, vous devez inclure l'option --require-specific-reservation. Cela indique que seules les VM qui ciblent spécifiquement cette réservation peuvent l'utiliser. Pour en savoir plus, consultez la section Consommer des VM d'une réservation spécifique.

• NUMBER_OF_VMS : nombre de VM à réserver.

• ZONE : la zone dans laquelle vous devez réserver des ressources.

Par exemple, pour créer une réservation en spécifiant un modèle d'instance global dans la zone us-central1-a, partager la réservation avec les projets project-1 et project-2, et réserver dix VM qui utilisent chacune un type de machine prédéfini N2 avec 4 processeurs virtuels, exécutez la commande suivante :

gcloud compute reservations create my-reservation \
    --share-setting=projects \
    --share-with=project-1,project-2 \
    --source-instance-template=projects/example-project/global/example-instance-template \
    --vm-count=10 \
    --zone=us-central1-a

Vous pouvez éventuellement effectuer une ou plusieurs des opérations suivantes :

• Pour spécifier que seules les VM qui ciblent spécifiquement cette réservation peuvent l'utiliser, incluez l'option --require-specific-reservation.

  gcloud compute reservations create RESERVATION_NAME \
      --require-specific-reservation \
      --share-setting=projects \
      --share-with=CONSUMER_PROJECT_IDS \
      --source-instance-template=projects/PROJECT_ID/LOCATION/instanceTemplates/INSTANCE_TEMPLATE_NAME \
      --vm-count=NUMBER_OF_VMS \
      --zone=ZONE
  

• Pour permettre à une réservation de VM avec GPU d'être utilisée par des tâches d'entraînement personnalisées ou des tâches de prédiction dans Vertex AI, exécutez la commande gcloud beta compute reservations create avec l'option --reservation-sharing-policy=ALLOW_ALL.

  Preview — The --reservation-sharing-policy flag

  Cette fonctionnalité est soumise aux "Conditions des offres de pré-DG" dans la section "Conditions d'utilisation générales" des Conditions spécifiques au service. Les fonctionnalités pré-DG sont disponibles "en l'état" et peuvent avoir une assistance limitée. Pour en savoir plus, consultez les descriptions des étapes de lancement.

  gcloud beta compute reservations create RESERVATION_NAME \
      --reservation-sharing-policy=ALLOW_ALL \
      --share-setting=projects \
      --share-with=CONSUMER_PROJECT_IDS \
      --source-instance-template=projects/PROJECT_ID/LOCATION/instanceTemplates/INSTANCE_TEMPLATE_NAME \
      --vm-count=NUMBER_OF_VMS \
      --zone=ZONE
  

• Pour permettre à Compute Engine de supprimer automatiquement la réservation, sélectionnez l'une des méthodes suivantes :

  Preview — The --delete-at-time and --delete-after-duration flags

  Cette fonctionnalité est soumise aux "Conditions des offres de pré-DG" dans la section "Conditions d'utilisation générales" des Conditions spécifiques au service. Les fonctionnalités pré-DG sont disponibles "en l'état" et peuvent avoir une assistance limitée. Pour en savoir plus, consultez les descriptions des étapes de lancement.

  • Pour supprimer la réservation à une date et une heure spécifiques, utilisez la commande gcloud beta compute reservations create avec l'option --delete-at-time.

    gcloud beta compute reservations create RESERVATION_NAME \
        --delete-at-time=DELETE_AT_TIME \
        --share-setting=projects \
        --share-with=CONSUMER_PROJECT_IDS \
        --source-instance-template=projects/PROJECT_ID/LOCATION/instanceTemplates/INSTANCE_TEMPLATE_NAME \
        --vm-count=NUMBER_OF_VMS \
        --zone=ZONE
    

    Remplacez DELETE_AT_TIME par une date et une heure au format de code temporel RFC 3339 comme suit :

    YYYY-MM-DDTHH:MM:SSOFFSET
    

    Remplacez les éléments suivants :

    • YYYY-MM-DD : date respectant la syntaxe année à 4 chiffres, mois à 2 chiffres et jour du mois à 2 chiffres, séparés par des traits d'union (-).

    • HH:MM:SS : heure respectant la syntaxe heures à 2 chiffres sur 24 heures, minutes à 2 chiffres et secondes à 2 chiffres, séparés par des signes deux-points (:).

    • OFFSET : fuseau horaire mis en forme en tant que décalage par rapport au temps universel coordonné (UTC). Par exemple, pour utiliser l'heure normale du Pacifique (PST), spécifiez -08:00. Sinon, pour n'utiliser aucun décalage, spécifiez Z.

  • Pour supprimer la réservation après une certaine durée, exécutez la commande gcloud beta compute reservations create avec l'option --delete-after-duration.

    gcloud beta compute reservations create RESERVATION_NAME \
        --delete-after-duration=DELETE_AFTER_DURATION \
        --share-setting=projects \
        --share-with=CONSUMER_PROJECT_IDS \
        --source-instance-template=projects/PROJECT_ID/LOCATION/instanceTemplates/INSTANCE_TEMPLATE_NAME \
        --vm-count=NUMBER_OF_VMS \
        --zone=ZONE
    

    Remplacez DELETE_AFTER_DURATION par une durée en jours, heures, minutes ou secondes. Par exemple, spécifiez 30m pour 30 minutes ou 1d2h3m4s pour 1 jour, 2 heures, 3 minutes et 4 secondes.

Go

import (
	"context"
	"fmt"
	"io"

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

// Creates shared reservation from given template in particular zone
func createSharedReservation(w io.Writer, client ClientInterface, projectID, baseProjectId, zone, reservationName, sourceTemplate string) error {
	// client, err := compute.NewReservationsRESTClient(ctx)
	// projectID := "your_project_id". Destination of sharing.
	// baseProjectId := "your_project_id2". Project where the reservation will be created.
	// zone := "us-west3-a"
	// reservationName := "your_reservation_name"
	// sourceTemplate: existing template path. Following formats are allowed:
	//  	- projects/{project_id}/global/instanceTemplates/{template_name}
	//  	- projects/{project_id}/regions/{region}/instanceTemplates/{template_name}
	//  	- https://www.googleapis.com/compute/v1/projects/{project_id}/global/instanceTemplates/instanceTemplate
	//  	- https://www.googleapis.com/compute/v1/projects/{project_id}/regions/{region}/instanceTemplates/instanceTemplate

	ctx := context.Background()

	shareSettings := map[string]*computepb.ShareSettingsProjectConfig{
		projectID: {ProjectId: proto.String(projectID)},
	}

	req := &computepb.InsertReservationRequest{
		Project: baseProjectId,
		ReservationResource: &computepb.Reservation{
			Name: proto.String(reservationName),
			Zone: proto.String(zone),
			SpecificReservation: &computepb.AllocationSpecificSKUReservation{
				Count:                  proto.Int64(2),
				SourceInstanceTemplate: proto.String(sourceTemplate),
			},
			ShareSettings: &computepb.ShareSettings{
				ProjectMap: shareSettings,
				ShareType:  proto.String("SPECIFIC_PROJECTS"),
			},
		},
		Zone: zone,
	}

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

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

	fmt.Fprintf(w, "Reservation created\n")

	return nil
}

Java

import com.google.cloud.compute.v1.AllocationSpecificSKUReservation;
import com.google.cloud.compute.v1.Operation;
import com.google.cloud.compute.v1.Reservation;
import com.google.cloud.compute.v1.ReservationsClient;
import com.google.cloud.compute.v1.ShareSettings;
import com.google.cloud.compute.v1.ShareSettingsProjectConfig;
import java.io.IOException;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.TimeoutException;

public class CreateSharedReservation {
  private final ReservationsClient reservationsClient;

  // Constructor to inject the ReservationsClient
  public CreateSharedReservation(ReservationsClient reservationsClient) {
    this.reservationsClient = reservationsClient;
  }

  public static void main(String[] args)
      throws IOException, ExecutionException, InterruptedException, TimeoutException {
    // TODO(developer): Replace these variables before running the sample.
    // The ID of the project where you want to reserve resources
    // and where the instance template exists.
    // By default, no projects are allowed to create or modify shared reservations
    // in an organization. Add projects to the Shared Reservations Owner Projects
    // (compute.sharedReservationsOwnerProjects) organization policy constraint
    // to allow them to create and modify shared reservations.
    // For more information visit this page:
    // https://cloud.google.com/compute/docs/instances/reservations-shared#shared_reservation_constraint
    String projectId = "YOUR_PROJECT_ID";
    // Zone in which the reservation resides.
    String zone = "us-central1-a";
    // Name of the reservation to be created.
    String reservationName = "YOUR_RESERVATION_NAME";
    // The URI of the global instance template to be used for creating the reservation.
    String instanceTemplateUri = String.format(
        "projects/%s/global/instanceTemplates/YOUR_INSTANCE_TEMPLATE_NAME", projectId);
    // Number of instances for which capacity needs to be reserved.
    int vmCount = 3;
    // In your main method, create ReservationsClient
    ReservationsClient client = ReservationsClient.create();
    // Create an instance of your class, passing in the client
    CreateSharedReservation creator = new CreateSharedReservation(client);

    creator.createSharedReservation(projectId, zone, reservationName, instanceTemplateUri, vmCount);
  }

  // Creates a shared reservation with the given name in the given zone.
  public void createSharedReservation(
      String projectId, String zone,
      String reservationName, String instanceTemplateUri, int vmCount)
      throws ExecutionException, InterruptedException, TimeoutException {

    ShareSettings shareSettings = ShareSettings.newBuilder()
        .setShareType(String.valueOf(ShareSettings.ShareType.SPECIFIC_PROJECTS))
        // The IDs of projects that can consume this reservation. You can include up to 100
        // consumer projects. These projects must be in the same organization as
        // the owner project. Don't include the owner project. By default, it is already allowed
        // to consume the reservation.
        .putProjectMap("CONSUMER_PROJECT_ID_1", ShareSettingsProjectConfig.newBuilder().build())
        .putProjectMap("CONSUMER_PROJECT_ID_2", ShareSettingsProjectConfig.newBuilder().build())
        .build();

    // Create the reservation.
    Reservation reservation =
        Reservation.newBuilder()
            .setName(reservationName)
            .setZone(zone)
            .setSpecificReservationRequired(true)
            .setShareSettings(shareSettings)
            .setSpecificReservation(
                AllocationSpecificSKUReservation.newBuilder()
                    .setCount(vmCount)
                    .setSourceInstanceTemplate(instanceTemplateUri)
                    .build())
            .build();

    // Wait for the create reservation operation to complete.
    Operation response =
        this.reservationsClient.insertAsync(projectId, zone, reservation).get(3, TimeUnit.MINUTES);

    if (response.hasError()) {
      System.out.println("Reservation creation failed!" + response);
      return;
    }
    System.out.println("Reservation created. Operation Status: " + response.getStatus());
  }
}

Node.js

// Import the Compute library
const computeLib = require('@google-cloud/compute');
const compute = computeLib.protos.google.cloud.compute.v1;

/**
 * TODO(developer): Uncomment reservationsClient and zoneOperationsClient before running the sample.
 */
// Instantiate a reservationsClient
// reservationsClient = new computeLib.ReservationsClient();
// Instantiate a zoneOperationsClient
// zoneOperationsClient = new computeLib.ZoneOperationsClient();

/**
 * TODO(developer): Update these variables before running the sample.
 */
// The ID of the project where you want to reserve resources and where the instance template exists.
const projectId = await reservationsClient.getProjectId();
// The zone in which to reserve resources.
const zone = 'us-central1-a';
// The name of the reservation to create.
const reservationName = 'reservation-01';
// The number of VMs to reserve.
const vmsNumber = 3;
// The name of an existing instance template.
const instanceTemplateName = 'global-instance-template-name';
// The location of the instance template.
const location = 'global';

async function callCreateComputeSharedReservation() {
  // Create reservation for 3 VMs in zone us-central1-a by specifying a instance template.
  const specificReservation = new compute.AllocationSpecificSKUReservation({
    count: vmsNumber,
    sourceInstanceTemplate: `projects/${projectId}/${location}/instanceTemplates/${instanceTemplateName}`,
  });

  // Create share settings. Share reservation with one customer project.
  const shareSettings = new compute.ShareSettings({
    shareType: 'SPECIFIC_PROJECTS',
    projectMap: {
      // The IDs of projects that can consume this reservation. You can include up to 100 consumer projects.
      // These projects must be in the same organization as the owner project.
      // Don't include the owner project. By default, it is already allowed to consume the reservation.
      consumer_project_id: {
        projectId: 'consumer_project_id',
      },
    },
  });

  // Create a reservation.
  const reservation = new compute.Reservation({
    name: reservationName,
    specificReservation,
    specificReservationRequired: true,
    shareSettings,
  });

  const [response] = await reservationsClient.insert({
    project: projectId,
    reservationResource: reservation,
    zone,
  });

  let operation = response.latestResponse;

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

  console.log(`Reservation: ${reservationName} created.`);
  return response;
}

return await callCreateComputeSharedReservation();

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_compute_shared_reservation(
    project_id: str,
    zone: str = "us-central1-a",
    reservation_name="your-reservation-name",
    shared_project_id: str = "shared-project-id",
) -> compute_v1.Reservation:
    """Creates a compute reservation in GCP.
    Args:
        project_id (str): The ID of the Google Cloud project.
        zone (str): The zone to create the reservation.
        reservation_name (str): The name of the reservation to create.
        shared_project_id (str): The ID of the project that the reservation is shared with.
    Returns:
        Reservation object that represents the new reservation.
    """

    instance_properties = compute_v1.AllocationSpecificSKUAllocationReservedInstanceProperties(
        machine_type="n1-standard-1",
        # Optional. Specifies amount of local ssd to reserve with each instance.
        local_ssds=[
            compute_v1.AllocationSpecificSKUAllocationAllocatedInstancePropertiesReservedDisk(
                disk_size_gb=375, interface="NVME"
            ),
        ],
    )

    reservation = compute_v1.Reservation(
        name=reservation_name,
        specific_reservation=compute_v1.AllocationSpecificSKUReservation(
            count=3,  # Number of resources that are allocated.
            # If you use source_instance_template, you must exclude the instance_properties field.
            # It can be a full or partial URL.
            # source_instance_template="projects/[PROJECT_ID]/global/instanceTemplates/my-instance-template",
            instance_properties=instance_properties,
        ),
        share_settings=compute_v1.ShareSettings(
            share_type="SPECIFIC_PROJECTS",
            project_map={
                shared_project_id: compute_v1.ShareSettingsProjectConfig(
                    project_id=shared_project_id
                )
            },
        ),
    )

    # Create a client
    client = compute_v1.ReservationsClient()

    operation = client.insert(
        project=project_id,
        zone=zone,
        reservation_resource=reservation,
    )
    wait_for_extended_operation(operation, "Reservation creation")

    reservation = client.get(
        project=project_id, zone=zone, reservation=reservation_name
    )
    shared_project = next(iter(reservation.share_settings.project_map.values()))

    print("Name: ", reservation.name)
    print("STATUS: ", reservation.status)
    print("SHARED PROJECT: ", shared_project)
    # Example response:
    # Name:  your-reservation-name
    # STATUS:  READY
    # SHARED PROJECT:  project_id: "123456789012"

    return reservation

REST

Pour créer une réservation partagée, envoyez une requête POST à la méthode reservations.insert. Dans le corps de la requête, incluez les éléments suivants :

• Le champ projectMap

• Le champ shareType défini sur SPECIFIC_PROJECTS.

Par exemple, pour créer une réservation partagée en spécifiant un modèle d'instance sans champs facultatifs et partager la réservation avec deux projets clients, envoyez la requête POST suivante :

POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/zones/ZONE/reservations

{
  "name": "RESERVATION_NAME",
  "shareSettings": {
    "shareType": "SPECIFIC_PROJECTS",
    "projectMap": {
      "CONSUMER_PROJECT_ID_1": {
        "projectId": "CONSUMER_PROJECT_ID_1"
      },
      "CONSUMER_PROJECT_ID_2": {
        "projectId": "CONSUMER_PROJECT_ID_2"
      }
    }
  },
  "specificReservation": {
    "count": "NUMBER_OF_VMS",
    "sourceInstanceTemplate": "projects/PROJECT_ID/LOCATION/instanceTemplates/INSTANCE_TEMPLATE_NAME"
  }
}

Remplacez les éléments suivants :

• PROJECT_ID : l'ID du projet dans lequel vous souhaitez réserver des ressources et où le modèle d'instance existe.

• ZONE : la zone dans laquelle vous devez réserver des ressources.

• RESERVATION_NAME : le nom de la réservation à créer.

• CONSUMER_PROJECT_ID_1 et CONSUMER_PROJECT_ID_2 : ID des projets pouvant utiliser cette réservation. Vous pouvez inclure jusqu'à 100 projets clients. Ces projets doivent appartenir à la même organisation que le projet propriétaire. N'incluez pas le projet propriétaire. Par défaut, il est déjà autorisé à utiliser la réservation.

• NUMBER_OF_VMS : nombre de VM à réserver.

• LOCATION : emplacement du modèle d'instance. Spécifiez une des valeurs suivantes :

  • Pour un modèle d'instance global : global

  • Pour un modèle d'instance régional : regions/REGION. Remplacez REGION par la région dans laquelle se trouve le modèle d'instance. Si vous sélectionnez un modèle d'instance régional, vous ne pouvez réserver que des ressources situées dans la même région que celle du modèle.

• INSTANCE_TEMPLATE_NAME : nom d'un modèle d'instance existant. Si le modèle d'instance spécifie un type de machine A3, vous devez inclure le champ specificReservationRequired dans le corps de la requête et le définir sur true. Cela indique que seules les VM qui ciblent spécifiquement cette réservation peuvent l'utiliser. Pour en savoir plus, consultez la section Consommer des VM d'une réservation spécifique.

Par exemple, pour créer une réservation pour dix VM dans la zone us-central1-a en spécifiant un modèle d'instance global et partager la réservation avec les projets project-1 et project-2, effectuez la requête POST suivante :

POST https://compute.googleapis.com/compute/v1/projects/example-project/zones/us-central1-a/reservations

{
  "name": "my-reservation",
  "shareSettings": {
    "shareType": "SPECIFIC_PROJECTS",
    "projectMap": {
      "project-1": {
        "projectId": "project-1"
      },
      "project-2": {
        "projectId": "project-2"
      }
    }
  },
  "specificReservation": {
    "count": "10",
    "sourceInstanceTemplate": "projects/example-project/global/instanceTemplates/example-instance-template"
  }
}

Vous pouvez éventuellement effectuer une ou plusieurs des opérations suivantes :

• Pour spécifier que seules les VM qui ciblent spécifiquement cette réservation peuvent l'utiliser, incluez le champ specificReservationRequired dans le corps de la requête et définissez-le sur true.

  Par exemple, pour créer une réservation spécifique en spécifiant un modèle d'instance et partager la réservation avec deux projets clients, envoyez une requête comme suit:

  POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/zones/ZONE/reservations
  
  {
    "name": "RESERVATION_NAME",
    "shareSettings": {
      "shareType": "SPECIFIC_PROJECTS",
      "projectMap": {
        "CONSUMER_PROJECT_ID_1": {
          "projectId": "CONSUMER_PROJECT_ID_1"
        },
        "CONSUMER_PROJECT_ID_2": {
          "projectId": "CONSUMER_PROJECT_ID_2"
        }
      }
    },
    "specificReservation": {
      "count": "NUMBER_OF_VMS",
      "sourceInstanceTemplate": "projects/PROJECT_ID/LOCATION/instanceTemplates/INSTANCE_TEMPLATE_NAME"
    },
    "specificReservationRequired": true
  }
  

• Pour permettre à une réservation de VM GPU d'être utilisée par des tâches d'entraînement personnalisées ou des tâches de prédiction dans Vertex AI, envoyez une requête POST à la méthode beta.reservations.insert. Dans le corps de la requête, incluez le champ serviceShareType et définissez-le sur ALLOW_ALL.

  Preview — The reservationSharingPolicy field

  Cette fonctionnalité est soumise aux "Conditions des offres de pré-DG" dans la section "Conditions d'utilisation générales" des Conditions spécifiques au service. Les fonctionnalités pré-DG sont disponibles "en l'état" et peuvent avoir une assistance limitée. Pour en savoir plus, consultez les descriptions des étapes de lancement.

  POST https://compute.googleapis.com/compute/beta/projects/PROJECT_ID/zones/ZONE/reservations
  
  {
    "name": "RESERVATION_NAME",
    "reservationSharingPolicy": {
      "serviceShareType": "ALLOW_ALL"
    },
    "shareSettings": {
      "shareType": "SPECIFIC_PROJECTS",
      "projectMap": {
        "CONSUMER_PROJECT_ID_1": {
          "projectId": "CONSUMER_PROJECT_ID_1"
        },
        "CONSUMER_PROJECT_ID_2": {
          "projectId": "CONSUMER_PROJECT_ID_2"
        }
      }
    },
    "specificReservation": {
      "count": "NUMBER_OF_VMS",
      "sourceInstanceTemplate": "projects/PROJECT_ID/LOCATION/instanceTemplates/INSTANCE_TEMPLATE_NAME"
    }
  }
  

• Pour permettre à Compute Engine de supprimer automatiquement la réservation, sélectionnez l'une des méthodes suivantes :

  Preview — The deleteAtTime and deleteAfterDuration fields

  Cette fonctionnalité est soumise aux "Conditions des offres de pré-DG" dans la section "Conditions d'utilisation générales" des Conditions spécifiques au service. Les fonctionnalités pré-DG sont disponibles "en l'état" et peuvent avoir une assistance limitée. Pour en savoir plus, consultez les descriptions des étapes de lancement.

  • Pour supprimer la réservation à une date et une heure spécifiques, envoyez une requête POST à la méthode beta.reservations.insert. Dans le corps de la requête, incluez le champ deleteAtTime.

    Par exemple, pour créer une réservation en spécifiant un modèle d'instance, supprimer automatiquement la réservation à une date et une heure spécifiques, et partager la réservation avec deux projets clients, envoyez une requête comme suit:

    POST https://compute.googleapis.com/compute/beta/projects/PROJECT_ID/zones/ZONE/reservations
    
    {
      "deleteAtTime": "DELETE_AT_TIME",
      "name": "RESERVATION_NAME",
      "shareSettings": {
        "shareType": "SPECIFIC_PROJECTS",
        "projectMap": {
          "CONSUMER_PROJECT_ID_1": {
            "projectId": "CONSUMER_PROJECT_ID_1"
          },
          "CONSUMER_PROJECT_ID_2": {
            "projectId": "CONSUMER_PROJECT_ID_2"
          }
        }
      },
      "specificReservation": {
        "count": "NUMBER_OF_VMS",
        "sourceInstanceTemplate": "projects/PROJECT_ID/LOCATION/instanceTemplates/INSTANCE_TEMPLATE_NAME"
      }
    }
    

    Remplacez DELETE_AT_TIME par une date et une heure au format de code temporel RFC 3339 comme suit :

    YYYY-MM-DDTHH:MM:SSOFFSET
    

    Remplacez les éléments suivants :

    • YYYY-MM-DD : date respectant la syntaxe année à 4 chiffres, mois à 2 chiffres et jour du mois à 2 chiffres, séparés par des traits d'union (-).

    • HH:MM:SS : heure respectant la syntaxe heures à 2 chiffres sur 24 heures, minutes à 2 chiffres et secondes à 2 chiffres, séparés par des signes deux-points (:).

    • OFFSET : fuseau horaire mis en forme en tant que décalage par rapport au temps universel coordonné (UTC). Par exemple, pour utiliser l'heure normale du Pacifique (PST), spécifiez -08:00. Sinon, pour n'utiliser aucun décalage, spécifiez Z.

  • Pour supprimer la réservation après une certaine durée, envoyez une requête POST à la méthode beta.reservations.insert. Dans le corps de la requête, incluez le champ deleteAfterDuration.

    Par exemple, pour créer une réservation en spécifiant un modèle d'instance, la supprimer automatiquement après une durée spécifique et la partager avec deux projets clients, envoyez une requête comme suit:

    POST https://compute.googleapis.com/compute/beta/projects/PROJECT_ID/zones/ZONE/reservations
    
    {
      "deleteAfterDuration": {
        "seconds": "DELETE_AFTER_DURATION"
      },
      "name": "RESERVATION_NAME",
      "shareSettings": {
        "shareType": "SPECIFIC_PROJECTS",
        "projectMap": {
          "CONSUMER_PROJECT_ID_1": {
            "projectId": "CONSUMER_PROJECT_ID_1"
          },
          "CONSUMER_PROJECT_ID_2": {
            "projectId": "CONSUMER_PROJECT_ID_2"
          }
        }
      },
      "specificReservation": {
        "count": "NUMBER_OF_VMS",
        "sourceInstanceTemplate": "projects/PROJECT_ID/LOCATION/instanceTemplates/INSTANCE_TEMPLATE_NAME"
      }
    }
    

    Remplacez DELETE_AFTER_DURATION par une durée en secondes. Par exemple, spécifiez 86400 pour 86 400 secondes (1 jour).

Spécifier une VM existante

Vous ne pouvez créer une réservation partagée que sur la base d'une VM existante, située dans la même zone et le même projet que la VM.

Une fois la réservation créée, vous pouvez l'utiliser en créant des VM dont les propriétés correspondent à la VM de référence. Pour ce faire :

• Créez et utilisez un modèle d'instance en procédant comme suit :

  1. Créez un modèle d'instance basé sur la VM de référence, sans remplacer les propriétés de la VM de référence.

     Remarque : Vous ne pouvez pas créer de modèle d'instance basé sur la VM de référence en dehors du projet de la VM. Pour les projets avec lesquels la réservation partagée est partagée, vous devez créer des modèles d'instance similaires dans ces projets.

  2. Créez des VM à l'aide du modèle que vous venez de créer en effectuant l'une des opérations suivantes, ou les deux :

     • Créer une VM unique

     • Créez un groupe d'instances géré (MIG) zonal.

• Créez une VM dont les propriétés correspondent exactement à la VM de référence comme suit:

  • Dans le projet propriétaire, créez une VM basée sur la VM de référence sans modifier les propriétés de la VM que vous créez.

  • Dans les projets client, créez une VM en vous assurant manuellement que ses propriétés et celles de la VM de référence correspondent.

Pour créer une réservation partagée qui utilise les propriétés d'une VM existante, procédez comme suit:

1. Dans la console Google Cloud, accédez à la page Réservations.

   Accéder à la page "Réservations"

2. Dans l'onglet Réservations à la demande (par défaut), cliquez sur Créer une réservation.

   La page Créer une réservation s'affiche.

3. Dans le champ Name, saisissez le nom de votre réservation.

4. Pour les champs Région et Zone, sélectionnez l'emplacement dans lequel vous souhaitez réserver des ressources.

5. Dans la section Type de partage, procédez comme suit :

   1. Pour spécifier une réservation partagée, sélectionnez Partagé.

   2. Cliquez sur Ajouter des projets, puis sélectionnez les projets de l'organisation du projet actuel avec lesquels vous souhaitez partager la réservation. Vous pouvez sélectionner jusqu'à 100 projets de client.

6. Dans la section Utiliser avec une instance de VM, sélectionnez l'une des options suivantes :

   • Pour autoriser les VM correspondantes à utiliser automatiquement cette réservation, sélectionnez l'option Utiliser automatiquement une réservation si elle n'est pas déjà sélectionnée.

   • Pour n'utiliser les ressources de cette réservation que lors de la création de VM correspondantes qui ciblent spécifiquement cette réservation par son nom, cliquez sur Sélectionner une réservation spécifique.

     Remarque : Si la VM de référence spécifie un type de machine A3, vous devez sélectionner Sélectionner une réservation spécifique. Sinon, vous ne pourrez pas supprimer la réservation.

7. Pour Nombre d'instances de VM, saisissez le nombre de VM que vous souhaitez réserver.

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

   1. Sélectionnez Utiliser une VM existante.

   2. Pour VM existante, sélectionnez la VM dont vous souhaitez utiliser les propriétés pour créer la réservation.

9. Dans la section Suppression automatique, vous pouvez activer l'option de suppression automatique pour permettre à Compute Engine de supprimer automatiquement la réservation à une date et une heure spécifiques. La suppression automatique des réservations peut vous permettre d'éviter des frais inutiles lorsque vous arrêtez de consommer la réservation.

10. Pour créer la réservation, cliquez sur Créer.

    La page Réservations s'affiche. La création de la réservation peut prendre jusqu'à une minute.

Spécifier les propriétés directement

Pour créer une réservation partagée en spécifiant directement les propriétés, sélectionnez l'une des options suivantes :

Console

1. Dans la console Google Cloud, accédez à la page Réservations.

   Accéder à la page "Réservations"

2. Dans l'onglet Réservations à la demande (par défaut), cliquez sur Créer une réservation.

3. Cliquez sur Créer une réservation.

   La page Créer une réservation s'affiche.

4. Dans le champ Name, saisissez le nom de votre réservation.

5. Pour les champs Région et Zone, sélectionnez l'emplacement dans lequel vous souhaitez réserver des ressources.

6. Dans la section Type de partage, procédez comme suit :

   1. Pour spécifier une réservation partagée, sélectionnez Partagé.

   2. Cliquez sur Ajouter des projets, puis sélectionnez les projets de l'organisation du projet actuel avec lesquels vous souhaitez partager la réservation. Vous pouvez sélectionner jusqu'à 100 projets clients.

7. Facultatif: Pour permettre à une réservation de VM avec GPU d'être utilisée par des tâches d'entraînement personnalisées ou des tâches de prédiction dans Vertex AI, sélectionnez Partager la réservation dans la section Services Google Cloud.

8. Dans la section Utiliser avec une instance de VM, sélectionnez l'une des options suivantes :

   • Pour autoriser les VM correspondantes à utiliser automatiquement cette réservation, sélectionnez l'option Utiliser automatiquement une réservation (par défaut).

   • Pour n'utiliser les ressources de cette réservation que lors de la création de VM correspondantes qui ciblent spécifiquement cette réservation par son nom, cliquez sur Sélectionner une réservation spécifique.

     Remarque : Si vous souhaitez spécifier un type de machine A3 dans la réservation, vous devez sélectionner Sélectionner une réservation spécifique. Sinon, vous rencontrerez des erreurs.

9. Pour Nombre d'instances de VM, saisissez le nombre de VM que vous souhaitez réserver.

10. Dans la section Configuration de la machine, sélectionnez Spécifier un type de machine, puis spécifiez les éléments suivants :

    1. Dans les champs Famille de machines, Série et Type de machine, sélectionnez une famille de machines, une série et un type de machine.

    2. Facultatif : pour spécifier une configuration minimale de plate-forme de processeur ou associer des GPU à des VM N1, procédez comme suit :

       1. Développez la section Plate-forme du CPU et GPU en cliquant sur la flèche de développement .

       2. Facultatif : pour spécifier une plate-forme de processeur minimale, sélectionnez une option sous Plate-forme de processeur.

       3. Facultatif : pour associer des GPU à des VM N1, cliquez sur Ajouter un GPU. Ensuite, pour Type de GPU et Nombre de GPU, sélectionnez le type et le nombre de GPU à associer à chaque VM N1.

    3. Facultatif : pour ajouter des disques SSD locaux, procédez comme suit :

       1. Pour Nombre de disques, sélectionnez le nombre de disques SSD locaux pour chaque VM.

       2. Pour Type d'interface, sélectionnez l'interface des disques SSD locaux.

11. Dans la section Suppression automatique, vous pouvez activer l'option de suppression automatique pour permettre à Compute Engine de supprimer automatiquement la réservation à une date et une heure spécifiques. La suppression automatique des réservations peut vous permettre d'éviter des frais inutiles lorsque vous arrêtez de consommer la réservation.

12. Pour créer la réservation, cliquez sur Créer.

    La page Réservations s'affiche. La création de la réservation partagée peut prendre jusqu'à une minute.

gcloud

Pour créer une réservation partagée, utilisez la commande gcloud compute reservations create avec les options --share-setting=projects et --share-with.

Pour créer une réservation partagée en spécifiant directement les propriétés, sans inclure d'options facultatives, exécutez la commande suivante :

gcloud compute reservations create RESERVATION_NAME \
    --machine-type=MACHINE_TYPE \
    --share-setting=projects \
    --share-with=CONSUMER_PROJECT_IDS \
    --vm-count=NUMBER_OF_VMS \
    --zone=ZONE

Remplacez les éléments suivants :

• RESERVATION_NAME : le nom de la réservation à créer.

• MACHINE_TYPE : un type de machine à utiliser pour chaque VM. Si vous spécifiez un type de machine A3, vous devez inclure l'option --require-specific-reservation. Cela indique que seules les VM qui ciblent spécifiquement cette réservation peuvent l'utiliser. Pour en savoir plus, consultez la section Consommer des VM d'une réservation spécifique.

• CONSUMER_PROJECT_IDS : liste d'ID de projets séparés par une virgule pouvant utiliser cette réservation, par exemple project-1,project-2. Vous pouvez inclure jusqu'à 100 projets clients. Ces projets doivent appartenir à la même organisation que le projet propriétaire. N'incluez pas le projet propriétaire. Par défaut, il est déjà autorisé à utiliser la réservation.

• NUMBER_OF_VMS : nombre de VM à réserver.

• ZONE : la zone dans laquelle vous devez réserver des ressources.

Par exemple, pour créer une réservation dans la zone us-central1-a pour dix VM utilisant chacune un type de machine prédéfini N2 avec 4 processeurs virtuels, et qui partagent la réservation avec les projets project-1 et project-2, exécutez la commande suivante :

gcloud compute reservations create my-reservation \
    --machine-type=n2-standard-4 \
    --share-setting=projects \
    --share-with=project-1,project-2 \
    --vm-count=10 \
    --zone=us-central1-a

Vous pouvez éventuellement effectuer une ou plusieurs des opérations suivantes :

• Pour associer des GPU à vos VM N1 réservées, incluez l'option --accelerator.

  gcloud compute reservations create RESERVATION_NAME \
      --accelerator=count=NUMBER_OF_ACCELERATORS,type=ACCELERATOR_TYPE
      --machine-type=MACHINE_TYPE \
      --share-setting=projects \
      --share-with=CONSUMER_PROJECT_IDS \
      --vm-count=NUMBER_OF_VMS \
      --zone=ZONE
  

  Remplacez les éléments suivants :

  • NUMBER_OF_ACCELERATORS : nombre de GPU à ajouter par VM réservée.

  • ACCELERATOR_TYPE : modèle de GPU compatible avec les VM N1. Assurez-vous que le modèle de GPU choisi est disponible dans la zone où vous souhaitez réserver des ressources. Sinon, la création de la réservation échoue.

• Pour ajouter un ou plusieurs disques SSD locaux à chaque VM réservée, incluez une ou plusieurs options --local-ssd. Vous pouvez spécifier jusqu'à 24 disques SSD locaux. La capacité de chaque disque SSD local est de 375 Go.

  Par exemple, pour spécifier deux disques SSD locaux lors de la création d'une réservation partagée, incluez deux options --local-ssd comme suit:

  gcloud compute reservations create RESERVATION_NAME \
      --local-ssd=size=375,interface=INTERFACE_1 \
      --local-ssd=size=375,interface=INTERFACE_2 \
      --machine-type=MACHINE_TYPE \
      --share-setting=projects \
      --share-with=CONSUMER_PROJECT_IDS \
      --vm-count=NUMBER_OF_VMS \
      --zone=ZONE
  

  Remplacez INTERFACE_1 et INTERFACE_2 par le type d'interface que chaque disque SSD local doit utiliser. Spécifiez une des valeurs suivantes :

  • Interfaces de disque NVME : nvme

  • Interfaces de disque SCSI : scsi

  Assurez-vous que le type de machine que vous spécifiez pour les VM réservées est compatible avec les interfaces de disque choisies. Sinon, la création de la réservation échoue. Pour en savoir plus, découvrez comment choisir une interface de disque.

• Pour que les VM réservées utilisent une plate-forme CPU minimale spécifique au lieu de la plate-forme CPU par défaut de la zone, incluez l'option --min-cpu-platform.

  gcloud compute reservations create RESERVATION_NAME \
      --machine-type=MACHINE_TYPE \
      --min-cpu-platform="MIN_CPU_PLATFORM" \
      --share-setting=projects \
      --share-with=CONSUMER_PROJECT_IDS \
      --vm-count=NUMBER_OF_VMS \
      --zone=ZONE
  

  Remplacez MIN_CPU_PLATFORM par une plate-forme CPU minimale. Pour vous assurer qu'une plate-forme CPU est disponible dans la zone où vous réservez des ressources, affichez les plates-formes CPU disponibles par zone.

• Pour spécifier que seules les VM qui ciblent spécifiquement cette réservation peuvent l'utiliser, incluez l'option --require-specific-reservation.

  gcloud compute reservations create RESERVATION_NAME \
      --machine-type=MACHINE_TYPE \
      --require-specific-reservation \
      --share-setting=projects \
      --share-with=CONSUMER_PROJECT_IDS \
      --vm-count=NUMBER_OF_VMS \
      --zone=ZONE
  

• Pour permettre à une réservation de VM avec GPU d'être utilisée par des tâches d'entraînement personnalisées ou des tâches de prédiction dans Vertex AI, exécutez la commande gcloud beta compute reservations create avec l'option --reservation-sharing-policy=ALLOW_ALL.

  Preview — The --reservation-sharing-policy flag

  Cette fonctionnalité est soumise aux "Conditions des offres de pré-DG" dans la section "Conditions d'utilisation générales" des Conditions spécifiques au service. Les fonctionnalités pré-DG sont disponibles "en l'état" et peuvent avoir une assistance limitée. Pour en savoir plus, consultez les descriptions des étapes de lancement.

  gcloud beta compute reservations create RESERVATION_NAME \
      --machine-type=MACHINE_TYPE \
      --reservation-sharing-policy=ALLOW_ALL \
      --share-setting=projects \
      --share-with=CONSUMER_PROJECT_IDS \
      --vm-count=NUMBER_OF_VMS \
      --zone=ZONE
  

• Pour permettre à Compute Engine de supprimer automatiquement la réservation, sélectionnez l'une des méthodes suivantes :

  Preview — The --delete-at-time and --delete-after-duration flags

  Cette fonctionnalité est soumise aux "Conditions des offres de pré-DG" dans la section "Conditions d'utilisation générales" des Conditions spécifiques au service. Les fonctionnalités pré-DG sont disponibles "en l'état" et peuvent avoir une assistance limitée. Pour en savoir plus, consultez les descriptions des étapes de lancement.

  • Pour supprimer la réservation à une date et une heure spécifiques, utilisez la commande gcloud beta compute reservations create avec l'option --delete-at-time.

    gcloud beta compute reservations create RESERVATION_NAME \
        --delete-at-time=DELETE_AT_TIME \
        --machine-type=MACHINE_TYPE \
        --share-setting=projects \
        --share-with=CONSUMER_PROJECT_IDS \
        --vm-count=NUMBER_OF_VMS \
        --zone=ZONE
    

    Remplacez DELETE_AT_TIME par une date et une heure au format de code temporel RFC 3339 comme suit :

    YYYY-MM-DDTHH:MM:SSOFFSET
    

    Remplacez les éléments suivants :

    • YYYY-MM-DD : date respectant la syntaxe année à 4 chiffres, mois à 2 chiffres et jour du mois à 2 chiffres, séparés par des traits d'union (-).

    • HH:MM:SS : heure respectant la syntaxe heures à 2 chiffres sur 24 heures, minutes à 2 chiffres et secondes à 2 chiffres, séparés par des signes deux-points (:).

    • OFFSET : fuseau horaire mis en forme en tant que décalage par rapport au temps universel coordonné (UTC). Par exemple, pour utiliser l'heure normale du Pacifique (PST), spécifiez -08:00. Sinon, pour n'utiliser aucun décalage, spécifiez Z.

  • Pour supprimer la réservation après une certaine durée, exécutez la commande gcloud beta compute reservations create avec l'option --delete-after-duration.

    gcloud beta compute reservations create RESERVATION_NAME \
        --delete-after-duration=DELETE_AFTER_DURATION \
        --machine-type=MACHINE_TYPE \
        --share-setting=projects \
        --share-with=CONSUMER_PROJECT_IDS \
        --vm-count=NUMBER_OF_VMS \
        --zone=ZONE
    

    Remplacez DELETE_AFTER_DURATION par une durée en jours, heures, minutes ou secondes. Par exemple, spécifiez 30m pour 30 minutes ou 1d2h3m4s pour 1 jour, 2 heures, 3 minutes et 4 secondes.

Terraform

Pour créer une réservation, utilisez la ressource Terraform google_compute_reservation. Pour spécifier une réservation partagée, définissez le bloc share_settings :

• Définissez le champ share_type sur SPECIFIC_PROJECTS.
• Dans le bloc project_map, spécifiez les ID de projet des projets avec lesquels vous souhaitez partager cette réservation.

Pour en savoir plus sur l'utilisation de Terraform, consultez la page Utiliser Terraform avec Google Cloud.

REST

Pour créer une réservation partagée, envoyez une requête POST à la méthode reservations.insert. Dans le corps de la requête, incluez les éléments suivants :

• Le champ projectMap

• Le champ shareType défini sur SPECIFIC_PROJECTS.

Par exemple, pour créer une réservation partagée sans champs facultatifs et partager la réservation avec deux projets clients, envoyez la requête POST suivante :

POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/zones/ZONE/reservations

{
  "name": "RESERVATION_NAME",
  "shareSettings": {
    "shareType": "SPECIFIC_PROJECTS",
    "projectMap": {
      "CONSUMER_PROJECT_ID_1": {
        "projectId": "CONSUMER_PROJECT_ID_1"
      },
      "CONSUMER_PROJECT_ID_2": {
        "projectId": "CONSUMER_PROJECT_ID_2"
      }
    }
  },
  "specificReservation": {
    "count": "NUMBER_OF_VMS",
    "instanceProperties": {
      "machineType": "MACHINE_TYPE"
    }
  }
}

Remplacez les éléments suivants :

• PROJECT_ID : ID du projet dans lequel vous souhaitez réserver des ressources.

• ZONE : la zone dans laquelle vous devez réserver des ressources.

• RESERVATION_NAME : le nom de la réservation à créer.

• CONSUMER_PROJECT_ID_1 et CONSUMER_PROJECT_ID_2 : ID des projets pouvant utiliser cette réservation. Vous pouvez inclure jusqu'à 100 projets clients. Ces projets doivent appartenir à la même organisation que le projet propriétaire. N'incluez pas le projet propriétaire. Par défaut, il est déjà autorisé à utiliser la réservation.

• NUMBER_OF_VMS : nombre de VM à réserver.

• MACHINE_TYPE : un type de machine à utiliser pour chaque VM. Si vous spécifiez un type de machine A3, vous devez inclure le champ specificReservationRequired dans le corps de la requête et le définir sur true. Cela indique que seules les VM qui ciblent spécifiquement cette réservation peuvent l'utiliser.

Par exemple, pour créer une réservation en spécifiant un modèle d'instance global dans la zone us-central1-a, partager la réservation avec les projets project-1 et project-2, et réserver dix VM qui utilisent chacune un type de machine prédéfini N2 avec 4 processeurs virtuels, effectuez la requête POST suivante :

POST https://compute.googleapis.com/compute/v1/projects/example-project/zones/us-central1-a/reservations

{
  "name": "my-reservation",
  "shareSettings": {
    "shareType": "SPECIFIC_PROJECTS",
    "projectMap": {
      "project-1": {
        "projectId": "project-1"
      },
      "project-2": {
        "projectId": "project-2"
      }
    }
  },
  "specificReservation": {
    "count": "10",
    "instanceProperties": {
      "machineType": "n2-standard-4",
    }
  }
}

Vous pouvez éventuellement effectuer une ou plusieurs des opérations suivantes :

• Pour associer des GPU à vos VM N1 réservées, incluez le champ guestAccelerators dans le corps de la requête.

  Par exemple, pour créer une réservation partagée avec deux projets clients et associer des GPU à toutes les VM N1 réservées, envoyez une requête comme suit:

  POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/zones/ZONE/reservations
  
  {
    "name": "RESERVATION_NAME",
    "shareSettings": {
      "shareType": "SPECIFIC_PROJECTS",
      "projectMap": {
        "CONSUMER_PROJECT_ID_1": {
          "projectId": "CONSUMER_PROJECT_ID_1"
        },
        "CONSUMER_PROJECT_ID_2": {
          "projectId": "CONSUMER_PROJECT_ID_2"
        }
      }
    },
    "specificReservation": {
      "count": "NUMBER_OF_VMS",
      "instanceProperties": {
        "guestAccelerators": [
          {
            "acceleratorCount": NUMBER_OF_ACCELERATORS,
            "acceleratorType": "ACCELERATOR_TYPE"
          }
        ],
        "machineType": "MACHINE_TYPE"
      }
    }
  }
  

  Remplacez les éléments suivants :

  • NUMBER_OF_ACCELERATORS : nombre de GPU à ajouter par VM réservée.

  • ACCELERATOR_TYPE : modèle de GPU compatible avec les VM N1. Assurez-vous que le modèle de GPU choisi est disponible dans la zone où vous souhaitez réserver des ressources. Sinon, la création de la réservation échoue.

• Pour ajouter un ou plusieurs disques SSD locaux à chaque VM réservée, incluez le champ localSsds dans le corps de la requête. Vous pouvez spécifier jusqu'à 24 disques SSD locaux. La capacité de chaque disque SSD local est de 375 Go.

  Par exemple, pour créer une réservation partagée en spécifiant deux disques SSD locaux et deux projets clients, envoyez une requête comme suit:

  POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/zones/ZONE/reservations
  
  {
    "name": "RESERVATION_NAME",
    "shareSettings": {
      "shareType": "SPECIFIC_PROJECTS",
      "projectMap": {
        "CONSUMER_PROJECT_ID_1": {
          "projectId": "CONSUMER_PROJECT_ID_1"
        },
        "CONSUMER_PROJECT_ID_2": {
          "projectId": "CONSUMER_PROJECT_ID_2"
        }
      }
    },
    "specificReservation": {
      "count": "NUMBER_OF_VMS",
      "instanceProperties": {
        "localSsds": [
          {
            "diskSizeGb": "375",
            "interface": "INTERFACE_1"
          },
          {
            "diskSizeGb": "375",
            "interface": "INTERFACE_2"
          }
        ],
        "machineType": "MACHINE_TYPE"
      }
    }
  }
  

  Remplacez INTERFACE_1 et INTERFACE_2 par le type d'interface que chaque disque SSD local doit utiliser. Spécifiez une des valeurs suivantes :

  • Interfaces de disque NVME : NVME

  • Interfaces de disque SCSI : SCSI

  Assurez-vous que le type de machine que vous spécifiez pour les VM réservées est compatible avec les interfaces de disque choisies. Sinon, la création de la réservation échoue. Pour en savoir plus, découvrez comment choisir une interface de disque.

• Pour que les VM réservées utilisent une plate-forme CPU minimale spécifique au lieu de la plate-forme CPU par défaut de la zone, incluez le champ minCpuPlatform dans le corps de la requête.

  Par exemple, pour créer une réservation partagée en spécifiant une plate-forme de processeur minimale et deux projets clients, envoyez une requête comme suit:

  POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/zones/ZONE/reservations
  
  {
    "name": "RESERVATION_NAME",
    "shareSettings": {
      "shareType": "SPECIFIC_PROJECTS",
      "projectMap": {
        "CONSUMER_PROJECT_ID_1": {
          "projectId": "CONSUMER_PROJECT_ID_1"
        },
        "CONSUMER_PROJECT_ID_2": {
          "projectId": "CONSUMER_PROJECT_ID_2"
        }
      }
    },
    "specificReservation": {
      "count": "NUMBER_OF_VMS",
      "instanceProperties": {
        "machineType": "MACHINE_TYPE",
        "minCpuPlatform": "MIN_CPU_PLATFORM"
      }
    }
  }
  

  Remplacez MIN_CPU_PLATFORM par une plate-forme CPU minimale. Pour vous assurer qu'une plate-forme CPU est disponible dans la zone où vous réservez des ressources, affichez les plates-formes CPU disponibles par zone.

• Pour spécifier que seules les VM qui ciblent spécifiquement cette réservation peuvent l'utiliser, incluez le champ specificReservationRequired dans le corps de la requête et définissez-le sur true.

  Par exemple, pour créer une réservation spécifique et la partager avec deux projets clients, envoyez une requête comme suit:

  POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/zones/ZONE/reservations
  
  {
    "name": "RESERVATION_NAME",
    "shareSettings": {
      "shareType": "SPECIFIC_PROJECTS",
      "projectMap": {
        "CONSUMER_PROJECT_ID_1": {
          "projectId": "CONSUMER_PROJECT_ID_1"
        },
        "CONSUMER_PROJECT_ID_2": {
          "projectId": "CONSUMER_PROJECT_ID_2"
        }
      }
    },
    "specificReservation": {
      "count": "NUMBER_OF_VMS",
      "instanceProperties": {
        "machineType": "MACHINE_TYPE"
      }
    },
    "specificReservationRequired": true
  }
  

• Pour permettre à une réservation de VM GPU d'être utilisée par des tâches d'entraînement personnalisées ou des tâches de prédiction dans Vertex AI, envoyez une requête POST à la méthode beta.reservations.insert. Dans le corps de la requête, incluez le champ serviceShareType et définissez-le sur ALLOW_ALL.

  Preview — The reservationSharingPolicy field

  Cette fonctionnalité est soumise aux "Conditions des offres de pré-DG" dans la section "Conditions d'utilisation générales" des Conditions spécifiques au service. Les fonctionnalités pré-DG sont disponibles "en l'état" et peuvent avoir une assistance limitée. Pour en savoir plus, consultez les descriptions des étapes de lancement.

  POST https://compute.googleapis.com/compute/beta/projects/PROJECT_ID/zones/ZONE/reservations
  
  {
    "name": "RESERVATION_NAME",
    "reservationSharingPolicy": {
      "serviceShareType": "ALLOW_ALL"
    },
    "shareSettings": {
      "shareType": "SPECIFIC_PROJECTS",
      "projectMap": {
        "CONSUMER_PROJECT_ID_1": {
          "projectId": "CONSUMER_PROJECT_ID_1"
        },
        "CONSUMER_PROJECT_ID_2": {
          "projectId": "CONSUMER_PROJECT_ID_2"
        }
      }
    },
    "specificReservation": {
      "count": "NUMBER_OF_VMS",
      "instanceProperties": {
        "machineType": "MACHINE_TYPE"
      }
    }
  }
  

• Pour permettre à Compute Engine de supprimer automatiquement la réservation, sélectionnez l'une des méthodes suivantes :

  Preview — The deleteAtTime and deleteAfterDuration fields

  Cette fonctionnalité est soumise aux "Conditions des offres de pré-DG" dans la section "Conditions d'utilisation générales" des Conditions spécifiques au service. Les fonctionnalités pré-DG sont disponibles "en l'état" et peuvent avoir une assistance limitée. Pour en savoir plus, consultez les descriptions des étapes de lancement.

  • Pour supprimer la réservation à une date et une heure spécifiques, envoyez une requête POST à la méthode beta.reservations.insert. Dans le corps de la requête, incluez le champ deleteAtTime.

    Par exemple, pour créer une réservation en spécifiant une date et une heure de suppression, et partager la réservation avec deux projets clients, envoyez une requête comme suit:

    POST https://compute.googleapis.com/compute/beta/projects/PROJECT_ID/zones/ZONE/reservations
    
    {
      "deleteAtTime": "DELETE_AT_TIME",
      "name": "RESERVATION_NAME",
      "shareSettings": {
        "shareType": "SPECIFIC_PROJECTS",
        "projectMap": {
          "CONSUMER_PROJECT_ID_1": {
            "projectId": "CONSUMER_PROJECT_ID_1"
          },
          "CONSUMER_PROJECT_ID_2": {
            "projectId": "CONSUMER_PROJECT_ID_2"
          }
        }
      },
      "specificReservation": {
        "count": "NUMBER_OF_VMS",
        "instanceProperties": {
          "machineType": "MACHINE_TYPE"
        }
      }
    }
    

    Remplacez DELETE_AT_TIME par une date et une heure au format de code temporel RFC 3339 comme suit :

    YYYY-MM-DDTHH:MM:SSOFFSET
    

    Remplacez les éléments suivants :

    • YYYY-MM-DD : date respectant la syntaxe année à 4 chiffres, mois à 2 chiffres et jour du mois à 2 chiffres, séparés par des traits d'union (-).

    • HH:MM:SS : heure respectant la syntaxe heures à 2 chiffres sur 24 heures, minutes à 2 chiffres et secondes à 2 chiffres, séparés par des signes deux-points (:).

    • OFFSET : fuseau horaire mis en forme en tant que décalage par rapport au temps universel coordonné (UTC). Par exemple, pour utiliser l'heure normale du Pacifique (PST), spécifiez -08:00. Sinon, pour n'utiliser aucun décalage, spécifiez Z.

  • Pour supprimer la réservation après une certaine durée, envoyez une requête POST à la méthode beta.reservations.insert. Dans le corps de la requête, incluez le champ deleteAfterDuration.

    Par exemple, pour créer une réservation que Compute Engine supprime après une durée spécifique et partager la réservation avec deux projets clients, envoyez une requête comme suit:

    POST https://compute.googleapis.com/compute/beta/projects/PROJECT_ID/zones/ZONE/reservations
    
    {
      "deleteAfterDuration": {
        "seconds": "DELETE_AFTER_DURATION"
      },
      "name": "RESERVATION_NAME",
      "shareSettings": {
        "shareType": "SPECIFIC_PROJECTS",
        "projectMap": {
          "CONSUMER_PROJECT_ID_1": {
            "projectId": "CONSUMER_PROJECT_ID_1"
          },
          "CONSUMER_PROJECT_ID_2": {
            "projectId": "CONSUMER_PROJECT_ID_2"
          }
        }
      },
      "specificReservation": {
        "count": "NUMBER_OF_VMS",
        "instanceProperties": {
          "machineType": "MACHINE_TYPE"
        }
      }
    }
    

    Remplacez DELETE_AFTER_DURATION par une durée en secondes. Par exemple, spécifiez 86400 pour 86 400 secondes (1 jour).

Dépannage

Découvrez comment résoudre les problèmes de création de réservations.

Étapes suivantes

• Découvrez comment afficher vos réservations.

• Découvrez comment associer des réservations à des engagements.

• Découvrez comment consommer des réservations.

• Découvrez comment surveiller la consommation des réservations.