Créer des identifiants éphémères pour un compte de service

Cette page explique comment créer des identifiants éphémères pour un compte de service, que vous pouvez utiliser pour emprunter l'identité du compte de service. Selon le type de jeton que vous créez, le jeton éphémère fournit l'identité (pour les jetons d'ID) ou les autorisations (pour les jetons d'accès) associées au compte de servic.

Si votre architecture système nécessite l'utilisation d'une série d'appels de génération de jetons, vous pouvez utiliser une chaîne de délégation composée de plusieurs comptes de service. Dans la plupart des cas, la méthode directe décrite sur cette page suffit.

Avant de commencer

Enable the IAM and Service Account Credentials APIs:
```
gcloud services enable iam.googleapis.com iamcredentials.googleapis.com
```
Configurez l'authentification.

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

In the Google Cloud console, activate Cloud Shell.

Activate Cloud Shell

At the bottom of the Google Cloud console, a Cloud Shell session starts and displays a command-line prompt. Cloud Shell is a shell environment with the Google Cloud CLI already installed and with values already set for your current project. It can take a few seconds for the session to initialize.
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 Configurer l'authentification pour un environnement de développement local dans la documentation sur l'authentification Google Cloud.
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 Configurer l'authentification pour un environnement de développement local dans la documentation sur l'authentification Google Cloud.
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 Configurer l'authentification pour un environnement de développement local dans la documentation sur l'authentification Google Cloud.
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 Configurer l'authentification pour un environnement de développement local dans la documentation sur l'authentification Google Cloud.
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.
Pour en savoir plus, consultez la section S'authentifier pour utiliser REST dans la documentation sur l'authentification Google Cloud.
Consultez la documentation sur les comptes de service IAM.
Comprendre l'emprunt d'identité du compte de service
Déterminez le type de jeton dont vous avez besoin et suivez les étapes appropriées décrites dans les sections ci-dessous :

Créer un jeton d'accès éphémère

Les jetons d'accès sont acceptés pour l'authentification par la plupart des API Google. Lorsque vous générez un jeton d'accès en empruntant l'identité d'un compte de service, le jeton d'accès est fourni sans jeton d'actualisation, ce qui signifie que lorsqu'il expire, vous devez répéter le processus d'emprunt d'identité pour en générer un nouveau.

Pour en savoir plus, consultez la section Jetons d'accès.

Pour créer un jeton d'accès éphémère, procédez comme suit :

Fournissez les autorisations requises à l'appelant.
Générez le jeton d'accès.

Fournir les autorisations requises

Une requête directe implique deux identités: l'auteur de la requête qui demande l'identifiant et le compte de service pour lequel l'identifiant est créé. La façon dont vous configurez les autorisations varie selon que l'appelant s'authentifie en tant que compte de service ou compte d'utilisateur.

Si vous souhaitez exécuter une commande REST ou gcloud CLI de cette page dans un environnement de développement local, l'appelant peut être représenté par des identifiants utilisateur. Pour les charges de travail automatisées, telles qu'une application exécutée sur Compute Engine, l'appelant doit être représenté par un compte de service.

Compte de service

Lorsque l'application appelante utilise un compte de service comme identité, les comptes principaux suivants sont impliqués :

Compte de service de l'appelant (CALLER_SA)

Ce compte de service représente l'application appelante, qui émet la requête de création d'identifiants éphémères.
Compte de service avec privilège (PRIV_SA)

Ce compte de service se voit attribuer les rôles IAM requis pour le jeton éphémère. Il s'agit du compte de service pour lequel le jeton éphémère est créé.

Pour permettre à CALLER_SA de créer des identifiants éphémères pour PRIV_SA, vous accordez à CALLER_SA le rôle de créateur de jetons du compte de service (roles/iam.serviceAccountTokenCreator) sur PRIV_SA.

Accordez le rôle requis sur PRIV_SA :

Console

Dans Google Cloud Console, accédez à la page Comptes de service.

Accéder à la page "Comptes de service"
Sélectionnez un projet.
Cliquez sur l'adresse e-mail du compte de service disposant de privilèges (PRIV_SA).
Cliquez sur l'onglet Autorisations.
Sous Comptes principaux ayant accès à ce compte de service, cliquez sur Accorder l'accès.
Saisissez l'adresse e-mail du compte de service de l'appelant (CALLER_SA).

Par exemple, demo@my-project.iam.gserviceaccount.com.
Sélectionnez le rôle de créateur de jetons du compte de service (roles/iam.serviceAccountTokenCreator).
Cliquez sur Enregistrer pour attribuer le rôle au compte de service.

gcloud

La commande gcloud iam service-accounts add-iam-policy-binding accorde un rôle à un compte de service.

Avant d'utiliser les données de la commande ci-dessous, effectuez les remplacements suivants :

PRIV_SA: l'adresse e-mail du compte de service avec privilège pour lequel le jeton est généré.
CALLER_SA: adresse e-mail du compte de service représentant l'application qui demande le jeton de courte durée.

Exécutez la commande suivante :

Linux, macOS ou Cloud Shell

gcloud iam service-accounts add-iam-policy-binding PRIV_SA \
    --member=serviceAccount:CALLER_SA --role=roles/iam.serviceAccountTokenCreator --format=json

Windows (PowerShell)

gcloud iam service-accounts add-iam-policy-binding PRIV_SA `
    --member=serviceAccount:CALLER_SA --role=roles/iam.serviceAccountTokenCreator --format=json

Windows (cmd.exe)

gcloud iam service-accounts add-iam-policy-binding PRIV_SA ^
    --member=serviceAccount:CALLER_SA --role=roles/iam.serviceAccountTokenCreator --format=json

Vous devriez obtenir un résultat semblable à celui-ci :

Updated IAM policy for serviceAccount [PRIV_SA].
{
  "bindings": [
    {
      "members": [
        "serviceAccount:CALLER_SA"
      ],
      "role": "roles/iam.serviceAccountTokenCreator"
    }
  ],
  "etag": "BwXhCB4eyjY=",
  "version": 1
}

REST

Lisez la règle d'autorisation de PRIV_SA :

La méthode serviceAccounts.getIamPolicy permet d'obtenir la stratégie d'autorisation d'un compte de service.

Avant d'utiliser les données de requête ci-dessous, effectuez les remplacements suivants :
- PROJECT_ID : ID de votre projet Google Cloud. Les ID de projet sont des chaînes alphanumériques, telles que my-project.
- PRIV_SA : adresse e-mail du compte de service avec privilège pour lequel le jeton de courte durée est créé.
- POLICY_VERSION : version de la stratégie à renvoyer. Les requêtes doivent spécifier la version de stratégie la plus récente, qui est la version 3. Pour plus d'informations, consultez la section Spécifier une version de stratégie lors de l'obtention d'une stratégie.
Méthode HTTP et URL :
```
POST https://iam.googleapis.com/v1/projects/PROJECT_ID/serviceAccounts/PRIV_SA:getIamPolicy
```
Corps JSON de la requête :
```
{
  "options": {
    "requestedPolicyVersion": POLICY_VERSION
  }
}
```
Pour envoyer votre requête, développez l'une des options suivantes :
curl (Linux, macOS ou Cloud Shell)

Remarque : La commande suivante suppose que vous êtes connecté à la CLI gcloud avec votre compte utilisateur en exécutant la commande gcloud init ou gcloud auth login, ou en utilisant Cloud Shell, qui vous connecte automatiquement à la CLI gcloud. Vous pouvez exécuter la commande gcloud auth list pour vérifier quel est le compte actuellement actif.

Enregistrez le corps de la requête dans un fichier nommé request.json, puis exécutez la commande suivante :
```
curl -X POST \
     -H "Authorization: Bearer $(gcloud auth print-access-token)" \
     -H "Content-Type: application/json; charset=utf-8" \
     -d @request.json \
     "https://iam.googleapis.com/v1/projects/PROJECT_ID/serviceAccounts/PRIV_SA:getIamPolicy"
```
PowerShell (Windows)

Remarque : La commande suivante suppose que vous vous êtes connecté à la CLI gcloud avec votre compte utilisateur en exécutant la commande gcloud init ou gcloud auth login. Vous pouvez exécuter la commande gcloud auth list pour vérifier quel est le compte actuellement actif.

Enregistrez le corps de la requête dans un fichier nommé request.json, puis exécutez la commande suivante :
```
$cred = gcloud auth print-access-token
$headers = @{ "Authorization" = "Bearer $cred" }

Invoke-WebRequest `
    -Method POST `
    -Headers $headers `
    -ContentType: "application/json; charset=utf-8" `
    -InFile request.json `
    -Uri "https://iam.googleapis.com/v1/projects/PROJECT_ID/serviceAccounts/PRIV_SA:getIamPolicy" | Select-Object -Expand Content
```
APIs Explorer (navigateur)

Copiez le corps de la requête et ouvrez la page de référence de la méthode. Le panneau APIs Explorer s'ouvre dans la partie droite de la page. Vous pouvez interagir avec cet outil pour envoyer des requêtes. Collez le corps de la requête dans cet outil, renseignez tous les champs obligatoires, puis cliquez sur Execute (Exécuter).

Vous devriez recevoir une réponse JSON de ce type :
```
{
  "version": 1,
  "etag": "BwWKmjvelug=",
  "bindings": [
    {
      "role": "roles/serviceAccountAdmin",
      "members": [
        "user:my-user@example.com"
      ]
    }
  ]
}
```
Si vous n'avez attribué aucun rôle au compte de service, la réponse ne contient qu'une valeur etag. Incluez cette valeur etag à l'étape suivante.

Modifiez la règle d'autorisation pour accorder à CALLER_SA le rôle de créateur de jetons du compte de service (roles/iam.serviceAccountTokenCreator).

Par exemple, pour modifier l'exemple de réponse de l'étape précédente, ajoutez ce qui suit :

  {
    "version": 1,
    "etag": "BwWKmjvelug=",
    "bindings": [
      {
        "role": "roles/serviceAccountAdmin",
        "members": [
          "user:my-user@example.com"
        ]
      },
      {
        "role": "roles/iam.serviceAccountTokenCreator",
        "members": [
          "serviceAccount:CALLER_SA"
        ]
      }
    ]
  }

Écrivez la stratégie d'autorisation mise à jour :

La méthode serviceAccounts.setIamPolicy définit une stratégie d'autorisation mise à jour pour le compte de service.

Avant d'utiliser les données de requête ci-dessous, effectuez les remplacements suivants :
- PROJECT_ID : ID de votre projet Google Cloud. Les ID de projet sont des chaînes alphanumériques, telles que my-project.
- PRIV_SA : adresse e-mail du compte de service avec privilège pour lequel le jeton de courte durée est créé.
- POLICY_VERSION : version de la stratégie à renvoyer. Les requêtes doivent spécifier la version de stratégie la plus récente, qui est la version 3. Pour plus d'informations, consultez la section Spécifier une version de stratégie lors de l'obtention d'une stratégie.
- POLICY : représentation JSON de la stratégie que vous souhaitez définir. Pour en savoir plus sur le format d'une stratégie, consultez la documentation de référence sur les stratégies.
  
  Par exemple, pour définir la règle d'autorisation affichée à l'étape précédente, remplacez POLICY par ce qui suit, où CALLER_SA correspond au compte de service créant le jeton de courte durée:
```
{
  "version": 1,
  "etag": "BwWKmjvelug=",
  "bindings": [
    {
      "role": "roles/serviceAccountAdmin",
      "members": [
        "user:my-user@example.com"
      ]
    },
    {
      "role": "roles/iam.serviceAccountTokenCreator",
      "members": [
        "serviceAccount:CALLER_SA"
      ]
    }
  ]
}
```
Méthode HTTP et URL :
```
POST https://iam.googleapis.com/v1/projects/PROJECT_ID/serviceAccounts/PRIV_SA
```
Corps JSON de la requête :
```
{
  "policy": POLICY
}
```
Pour envoyer votre requête, développez l'une des options suivantes :
curl (Linux, macOS ou Cloud Shell)

Enregistrez le corps de la requête dans un fichier nommé request.json, puis exécutez la commande suivante :
```
curl -X POST \
     -H "Authorization: Bearer $(gcloud auth print-access-token)" \
     -H "Content-Type: application/json; charset=utf-8" \
     -d @request.json \
     "https://iam.googleapis.com/v1/projects/PROJECT_ID/serviceAccounts/PRIV_SA"
```
PowerShell (Windows)

Enregistrez le corps de la requête dans un fichier nommé request.json, puis exécutez la commande suivante :
```
$cred = gcloud auth print-access-token
$headers = @{ "Authorization" = "Bearer $cred" }

Invoke-WebRequest `
    -Method POST `
    -Headers $headers `
    -ContentType: "application/json; charset=utf-8" `
    -InFile request.json `
    -Uri "https://iam.googleapis.com/v1/projects/PROJECT_ID/serviceAccounts/PRIV_SA" | Select-Object -Expand Content
```
APIs Explorer (navigateur)

Copiez le corps de la requête et ouvrez la page de référence de la méthode. Le panneau APIs Explorer s'ouvre dans la partie droite de la page. Vous pouvez interagir avec cet outil pour envoyer des requêtes. Collez le corps de la requête dans cet outil, renseignez tous les champs obligatoires, puis cliquez sur Execute (Exécuter).

La réponse contient la stratégie d'autorisation mise à jour.

Remarque : Si vous traitez les stratégies d'autorisation comme du code et que vous les stockez dans un système de contrôle des versions, vous devez stocker la stratégie qui est renvoyée, et non celle que vous avez envoyée dans la requête.

Identifiants utilisateur

Lorsque vous souhaitez générer des jetons éphémères à l'aide de Google Cloud CLI ou depuis un environnement de développement local, vous pouvez utiliser un compte utilisateur pour générer les jetons. Vous pouvez souvent utiliser votre propre compte utilisateur.

Lorsque vous utilisez un compte utilisateur pour générer des jetons de éphémères, les identités suivantes sont impliquées :

Compte de l'appelant (CALLER_ACCOUNT)

Ce compte utilisateur permet de générer des identifiants éphémères pour le compte de service disposant de privilèges.
Compte de service avec privilège (PRIV_SA)

Ce compte de service se voit attribuer les rôles IAM requis pour le jeton éphémère. Il s'agit du compte de service pour lequel le jeton éphémère est créé.

Pour permettre à CALLER_ACCOUNT de créer des identifiants éphémères pour PRIV_SA, vous devez accorder à CALLER_ACCOUNT le rôle de créateur de jetons du compte de service (roles/iam.serviceAccountTokenCreator) sur PRIV_SA.

Accordez le rôle requis sur PRIV_SA :

Console

Dans Google Cloud Console, accédez à la page Comptes de service.

Accéder à la page "Comptes de service"
Sélectionnez un projet.
Cliquez sur l'adresse e-mail du compte de service disposant de privilèges (PRIV_SA).
Cliquez sur l'onglet Autorisations.
Sous Comptes principaux ayant accès à ce compte de service, cliquez sur Accorder l'accès.
Saisissez l'identifiant principal du compte appelant, CALLER_ACCOUNT.

Par exemple, example-user@example.com.
Sélectionnez le rôle de créateur de jetons du compte de service (roles/iam.serviceAccountTokenCreator).
Cliquez sur Enregistrer pour attribuer le rôle au compte utilisateur.

gcloud

La commande gcloud iam service-accounts add-iam-policy-binding accorde un rôle à un compte de service.

Avant d'utiliser les données de la commande ci-dessous, effectuez les remplacements suivants :

PRIV_SA: l'adresse e-mail du compte de service avec privilège pour lequel le jeton est généré.
CALLER_ACCOUNT: adresse e-mail du compte utilisateur utilisé pour demander le jeton de courte durée.

Exécutez la commande suivante :

Linux, macOS ou Cloud Shell

gcloud iam service-accounts add-iam-policy-binding PRIV_SA \
    --member=user:CALLER_ACCOUNT --role=roles/iam.serviceAccountTokenCreator --format=json

Windows (PowerShell)

gcloud iam service-accounts add-iam-policy-binding PRIV_SA `
    --member=user:CALLER_ACCOUNT --role=roles/iam.serviceAccountTokenCreator --format=json

Windows (cmd.exe)

gcloud iam service-accounts add-iam-policy-binding PRIV_SA ^
    --member=user:CALLER_ACCOUNT --role=roles/iam.serviceAccountTokenCreator --format=json

Vous devriez obtenir un résultat semblable à celui-ci :

Updated IAM policy for serviceAccount [PRIV_SA].
{
  "bindings": [
    {
      "members": [
        "user:my-user@example.com"
      ],
      "role": "roles/iam.serviceAccountTokenCreator"
    }
  ],
  "etag": "BwX1ZbefjXU=",
  "version": 1
}

REST

Lisez la règle d'autorisation de PRIV_SA :

La méthode serviceAccounts.getIamPolicy permet d'obtenir la stratégie d'autorisation d'un compte de service.

Avant d'utiliser les données de requête ci-dessous, effectuez les remplacements suivants :
- PROJECT_ID : ID de votre projet Google Cloud. Les ID de projet sont des chaînes alphanumériques, telles que my-project.
- PRIV_SA : adresse e-mail du compte de service avec privilège pour lequel le jeton de courte durée est créé.
- POLICY_VERSION : version de la stratégie à renvoyer. Les requêtes doivent spécifier la version de stratégie la plus récente, qui est la version 3. Pour plus d'informations, consultez la section Spécifier une version de stratégie lors de l'obtention d'une stratégie.
Méthode HTTP et URL :
```
POST https://iam.googleapis.com/v1/projects/PROJECT_ID/serviceAccounts/PRIV_SA:getIamPolicy
```
Corps JSON de la requête :
```
{
  "options": {
    "requestedPolicyVersion": POLICY_VERSION
  }
}
```
Pour envoyer votre requête, développez l'une des options suivantes :
curl (Linux, macOS ou Cloud Shell)

Remarque : La commande suivante suppose que vous êtes connecté à la CLI gcloud avec votre compte utilisateur en exécutant la commande gcloud init ou gcloud auth login, ou en utilisant Cloud Shell, qui vous connecte automatiquement à la CLI gcloud. Vous pouvez exécuter la commande gcloud auth list pour vérifier quel est le compte actuellement actif.

Enregistrez le corps de la requête dans un fichier nommé request.json, puis exécutez la commande suivante :
```
curl -X POST \
     -H "Authorization: Bearer $(gcloud auth print-access-token)" \
     -H "Content-Type: application/json; charset=utf-8" \
     -d @request.json \
     "https://iam.googleapis.com/v1/projects/PROJECT_ID/serviceAccounts/PRIV_SA:getIamPolicy"
```
PowerShell (Windows)

Remarque : La commande suivante suppose que vous vous êtes connecté à la CLI gcloud avec votre compte utilisateur en exécutant la commande gcloud init ou gcloud auth login. Vous pouvez exécuter la commande gcloud auth list pour vérifier quel est le compte actuellement actif.

Enregistrez le corps de la requête dans un fichier nommé request.json, puis exécutez la commande suivante :
```
$cred = gcloud auth print-access-token
$headers = @{ "Authorization" = "Bearer $cred" }

Invoke-WebRequest `
    -Method POST `
    -Headers $headers `
    -ContentType: "application/json; charset=utf-8" `
    -InFile request.json `
    -Uri "https://iam.googleapis.com/v1/projects/PROJECT_ID/serviceAccounts/PRIV_SA:getIamPolicy" | Select-Object -Expand Content
```
APIs Explorer (navigateur)

Copiez le corps de la requête et ouvrez la page de référence de la méthode. Le panneau APIs Explorer s'ouvre dans la partie droite de la page. Vous pouvez interagir avec cet outil pour envoyer des requêtes. Collez le corps de la requête dans cet outil, renseignez tous les champs obligatoires, puis cliquez sur Execute (Exécuter).

Vous devriez recevoir une réponse JSON de ce type :
```
{
  "version": 1,
  "etag": "BwWKmjvelug=",
  "bindings": [
    {
      "role": "roles/serviceAccountAdmin",
      "members": [
        "user:my-user@example.com"
      ]
    }
  ]
}
```
Si vous n'avez attribué aucun rôle au compte de service, la réponse ne contient qu'une valeur etag. Incluez cette valeur etag à l'étape suivante.

Modifiez la règle d'autorisation pour accorder à CALLER_ACCOUNT le rôle de créateur de jetons du compte de service (roles/iam.serviceAccountTokenCreator).

Par exemple, pour modifier l'exemple de réponse de l'étape précédente, ajoutez ce qui suit :

{
  "version": 1,
  "etag": "BwWKmjvelug=",
  "bindings": [
    {
      "role": "roles/serviceAccountAdmin",
      "members": [
        "user:my-user@example.com"
      ]
    },
    {
      "role": "roles/iam.serviceAccountTokenCreator",
      "members": [
        "user:my-user@example.com"
      ]
    }
  ]
}

Écrivez la stratégie d'autorisation mise à jour :

La méthode serviceAccounts.setIamPolicy définit une stratégie d'autorisation mise à jour pour le compte de service.

Avant d'utiliser les données de requête ci-dessous, effectuez les remplacements suivants :
- PROJECT_ID : ID de votre projet Google Cloud. Les ID de projet sont des chaînes alphanumériques, telles que my-project.
- PRIV_SA : adresse e-mail du compte de service avec privilège pour lequel le jeton de courte durée est créé.
- POLICY_VERSION : version de la stratégie à renvoyer. Les requêtes doivent spécifier la version de stratégie la plus récente, qui est la version 3. Pour plus d'informations, consultez la section Spécifier une version de stratégie lors de l'obtention d'une stratégie.
- POLICY : représentation JSON de la stratégie que vous souhaitez définir. Pour en savoir plus sur le format d'une stratégie, consultez la documentation de référence sur les stratégies.
  
  Par exemple, pour définir la règle d'autorisation affichée à l'étape précédente, remplacez POLICY par ce qui suit, où CALLER_ACCOUNT correspond au compte utilisateur créant le jeton de courte durée :
```
{
  "version": 1,
  "etag": "BwWKmjvelug=",
  "bindings": [
    {
      "role": "roles/serviceAccountAdmin",
      "members": [
        "user:my-user@example.com"
      ]
    },
    {
      "role": "roles/iam.serviceAccountTokenCreator",
      "members": [
        "CALLER_ACCOUNT"
      ]
    }
  ]
}
```
Méthode HTTP et URL :
```
POST https://iam.googleapis.com/v1/projects/PROJECT_ID/serviceAccounts/PRIV_SA
```
Corps JSON de la requête :
```
{
  "policy": POLICY
}
```
Pour envoyer votre requête, développez l'une des options suivantes :
curl (Linux, macOS ou Cloud Shell)

Enregistrez le corps de la requête dans un fichier nommé request.json, puis exécutez la commande suivante :
```
curl -X POST \
     -H "Authorization: Bearer $(gcloud auth print-access-token)" \
     -H "Content-Type: application/json; charset=utf-8" \
     -d @request.json \
     "https://iam.googleapis.com/v1/projects/PROJECT_ID/serviceAccounts/PRIV_SA"
```
PowerShell (Windows)

Enregistrez le corps de la requête dans un fichier nommé request.json, puis exécutez la commande suivante :
```
$cred = gcloud auth print-access-token
$headers = @{ "Authorization" = "Bearer $cred" }

Invoke-WebRequest `
    -Method POST `
    -Headers $headers `
    -ContentType: "application/json; charset=utf-8" `
    -InFile request.json `
    -Uri "https://iam.googleapis.com/v1/projects/PROJECT_ID/serviceAccounts/PRIV_SA" | Select-Object -Expand Content
```
APIs Explorer (navigateur)

Copiez le corps de la requête et ouvrez la page de référence de la méthode. Le panneau APIs Explorer s'ouvre dans la partie droite de la page. Vous pouvez interagir avec cet outil pour envoyer des requêtes. Collez le corps de la requête dans cet outil, renseignez tous les champs obligatoires, puis cliquez sur Execute (Exécuter).

La réponse contient la stratégie d'autorisation mise à jour.

Remarque : Si vous traitez les stratégies d'autorisation comme du code et que vous les stockez dans un système de contrôle des versions, vous devez stocker la stratégie qui est renvoyée, et non celle que vous avez envoyée dans la requête.

Générer le jeton d'accès

Vous pouvez générer un jeton d'accès OAuth 2.0 à l'aide de la CLI gcloud, de l'API REST ou des bibliothèques clientes Cloud et des bibliothèques clientes des API Google.

Si vous utilisez l'API REST et que votre système est configuré pour autoriser une durée de vie étendue des jetons, vous pouvez créer un jeton dont la durée de vie est supérieure à la valeur par défaut. Google Cloud CLI ne permet pas de définir une durée de vie pour le jeton.

Les exemples ci-dessous sont conçus pour être utilisés dans un environnement de développement local. L'appelant doit être représenté par un compte utilisateur plutôt que par un compte de service.

Générez un jeton d'accès OAuth 2.0 pour un compte de service :

gcloud

Assurez-vous d'être connecté à gcloud CLI avec le compte utilisateur de l'appelant.

Générez un jeton pour le compte de service à l'aide de la commande gcloud auth print-access-token.

Avant d'utiliser les données de la commande ci-dessous, effectuez les remplacements suivants :

PRIV_SA : adresse e-mail du compte de service avec privilège pour lequel le jeton de courte durée est créé.

Exécutez la commande suivante :

Linux, macOS ou Cloud Shell

gcloud auth print-access-token --impersonate-service-account=PRIV_SA

Windows (PowerShell)

gcloud auth print-access-token --impersonate-service-account=PRIV_SA

Windows (cmd.exe)

gcloud auth print-access-token --impersonate-service-account=PRIV_SA

Vous devriez obtenir un résultat semblable à celui-ci :

WARNING: This command is using service account impersonation. All API calls will be executed as
[my-sa@my-project.iam.gserviceaccount.com].
ya29.c.b0AXv0zTPnzTnDV8F8Aj5Fgy46Yf2v_v8eZIoKq7xGpfbpXuy23aQ1693m3gAuE8AZga7w6kdagN7a9bfdDYbdeoGY0CMHOClsCwIdutL7k_RFC672lOCbUgF5hS8Iu2nCA8hle-11LJXBLmaxFmH08ZTBJLuDrWSNd8cYqGYFunSC1K1qLIPBF18tsa0hxVgKPucI8b1A9L8_MK1JGLGcr0n7-zY77_lmbcdODG3NmIbLOGWOutjJgqSO_YoeCKK2QTUZIp5PG7RkKlXWnmYJA9pEahzNoQrs5sWZctc2bia9af_ITzqqlXC9h1Kj5-me6e8rd734MJvpagqYazRk0gGWpMb03XmMGpgPc_FBp4pnX9rGOzW83SNpcDz8zeFO1Q0Bo3N7CuZougjRce0y8I2_4rtw5ME_nV3wrCWa..................................................................................................................................................................................................................................................................................................

REST

La méthode serviceAccounts.generateAccessToken de l'API Service Account Credentials génère un jeton d'accès OAuth 2.0 pour un compte de service.

Avant d'utiliser les données de requête ci-dessous, effectuez les remplacements suivants :

PRIV_SA : adresse e-mail du compte de service avec privilège pour lequel le jeton de courte durée est créé.
LIFETIME : délai avant expiration du nouveau jeton d'accès, exprimé en secondes. Par exemple, 300s.

Par défaut, la durée de vie maximale du jeton est d'une heure, soit 3 600 secondes. Pour étendre la durée de vie maximale de ces jetons à 12 heures (43 200 secondes), ajoutez le compte de service à une règle d'administration comprenant la contrainte de liste constraints/iam.allowServiceAccountCredentialLifetimeExtension.

Méthode HTTP et URL :

POST https://iamcredentials.googleapis.com/v1/projects/-/serviceAccounts/PRIV_SA:generateAccessToken

Corps JSON de la requête :

{
  "scope": [
    "https://www.googleapis.com/auth/cloud-platform"
  ],
  "lifetime": "LIFETIME"
}

Pour envoyer votre requête, développez l'une des options suivantes :

curl (Linux, macOS ou Cloud Shell)

Remarque : La commande suivante suppose que vous êtes connecté à la CLI gcloud avec votre compte utilisateur en exécutant la commande gcloud init ou gcloud auth login, ou en utilisant Cloud Shell, qui vous connecte automatiquement à la CLI gcloud. Vous pouvez exécuter la commande gcloud auth list pour vérifier quel est le compte actuellement actif.

Enregistrez le corps de la requête dans un fichier nommé request.json, puis exécutez la commande suivante :

curl -X POST \
     -H "Authorization: Bearer $(gcloud auth print-access-token)" \
     -H "Content-Type: application/json; charset=utf-8" \
     -d @request.json \
     "https://iamcredentials.googleapis.com/v1/projects/-/serviceAccounts/PRIV_SA:generateAccessToken"

PowerShell (Windows)

Remarque : La commande suivante suppose que vous vous êtes connecté à la CLI gcloud avec votre compte utilisateur en exécutant la commande gcloud init ou gcloud auth login. Vous pouvez exécuter la commande gcloud auth list pour vérifier quel est le compte actuellement actif.

Enregistrez le corps de la requête dans un fichier nommé request.json, puis exécutez la commande suivante :

$cred = gcloud auth print-access-token
$headers = @{ "Authorization" = "Bearer $cred" }

Invoke-WebRequest `
    -Method POST `
    -Headers $headers `
    -ContentType: "application/json; charset=utf-8" `
    -InFile request.json `
    -Uri "https://iamcredentials.googleapis.com/v1/projects/-/serviceAccounts/PRIV_SA:generateAccessToken" | Select-Object -Expand Content

APIs Explorer (navigateur)

Copiez le corps de la requête et ouvrez la page de référence de la méthode. Le panneau APIs Explorer s'ouvre dans la partie droite de la page. Vous pouvez interagir avec cet outil pour envoyer des requêtes. Collez le corps de la requête dans cet outil, renseignez tous les champs obligatoires, puis cliquez sur Execute (Exécuter).

Si la requête generateAccessToken a abouti, le corps de la réponse contient un jeton d'accès OAuth 2.0 et une heure d'expiration. Ce jeton d'accès (accessToken) peut alors être utilisé pour authentifier une requête au nom du compte de service jusqu'à ce que l'heure d'expiration spécifiée expireTime soit atteinte :

{
  "accessToken": "eyJ0eXAi...NiJ9",
  "expireTime": "2020-04-07T15:01:23.045123456Z"
}

Go

import (
	"context"
	"fmt"
	"io"
	"time"

	"golang.org/x/oauth2/google"
	"google.golang.org/api/impersonate"
	"google.golang.org/api/option"
)

// getAccessTokenFromImpersonatedCredentials uses a service account (SA1) to impersonate
// another service account (SA2) and obtain OAuth2 token for the impersonated account.
// To obtain a token for SA2, SA1 should have the "roles/iam.serviceAccountTokenCreator" permission on SA2.
func getAccessTokenFromImpersonatedCredentials(w io.Writer, impersonatedServiceAccount, scope string) error {
	// impersonatedServiceAccount := "name@project.service.gserviceaccount.com"
	// scope := "https://www.googleapis.com/auth/cloud-platform"

	ctx := context.Background()

	// Construct the GoogleCredentials object which obtains the default configuration from your
	// working environment.
	credentials, err := google.FindDefaultCredentials(ctx, scope)
	if err != nil {
		fmt.Fprintf(w, "failed to generate default credentials: %v", err)
		return fmt.Errorf("failed to generate default credentials: %w", err)
	}

	ts, err := impersonate.CredentialsTokenSource(ctx, impersonate.CredentialsConfig{
		TargetPrincipal: impersonatedServiceAccount,
		Scopes:          []string{scope},
		Lifetime:        300 * time.Second,
		// delegates: The chained list of delegates required to grant the final accessToken.
		// For more information, see:
		// https://cloud.google.com/iam/docs/create-short-lived-credentials-direct#sa-credentials-permissions
		// Delegates is NOT USED here.
		Delegates: []string{},
	}, option.WithCredentials(credentials))
	if err != nil {
		fmt.Fprintf(w, "CredentialsTokenSource error: %v", err)
		return fmt.Errorf("CredentialsTokenSource error: %w", err)
	}

	// Get the OAuth2 token.
	// Once you've obtained the OAuth2 token, you can use it to make an authenticated call.
	t, err := ts.Token()
	if err != nil {
		fmt.Fprintf(w, "failed to receive token: %v", err)
		return fmt.Errorf("failed to receive token: %w", err)
	}
	fmt.Fprintf(w, "Generated OAuth2 token with length %d.\n", len(t.AccessToken))

	return nil
}

Java


package com.google.cloud.auth.samples;

import com.google.auth.oauth2.GoogleCredentials;
import com.google.auth.oauth2.ImpersonatedCredentials;
import java.io.IOException;
import java.util.Arrays;
import java.util.List;

public class AccessTokenFromImpersonatedCredentials {

  public static void main(String[] args) throws IOException {
    // TODO(Developer): Replace the below variables before running the code.

    // Provide the scopes that you might need to request access to Google APIs,
    // depending on the level of access you need.
    // This example uses the cloud-wide scope and uses IAM to narrow the permissions.
    // https://cloud.google.com/docs/authentication/external/authorization-gcp
    // For more information, see: https://developers.google.com/identity/protocols/oauth2/scopes
    String scope = "https://www.googleapis.com/auth/cloud-platform";

    // The name of the privilege-bearing service account for whom the credential is created.
    String impersonatedServiceAccount = "name@project.service.gserviceaccount.com";

    getAccessToken(impersonatedServiceAccount, scope);
  }

  // Use a service account (SA1) to impersonate another service account (SA2) and obtain an ID token
  // for the impersonated account.
  // To obtain a token for SA2, SA1 should have the "roles/iam.serviceAccountTokenCreator"
  // permission on SA2.
  public static void getAccessToken(
      String impersonatedServiceAccount, String scope) throws IOException {

    // Construct the GoogleCredentials object which obtains the default configuration from your
    // working environment.
    GoogleCredentials googleCredentials = GoogleCredentials.getApplicationDefault();

    // delegates: The chained list of delegates required to grant the final accessToken.
    // For more information, see:
    // https://cloud.google.com/iam/docs/create-short-lived-credentials-direct#sa-credentials-permissions
    // Delegate is NOT USED here.
    List<String> delegates = null;

    // Create the impersonated credential.
    ImpersonatedCredentials impersonatedCredentials =
        ImpersonatedCredentials.newBuilder()
            .setSourceCredentials(googleCredentials)
            .setTargetPrincipal(impersonatedServiceAccount)
            .setScopes(Arrays.asList(scope))
            .setLifetime(300)
            .setDelegates(delegates)
            .build();

    // Get the OAuth2 token.
    // Once you've obtained the OAuth2 token, you can use it to make an authenticated call.
    impersonatedCredentials.refresh();
    String accessToken = impersonatedCredentials.getAccessToken().getTokenValue();
    System.out.println("Generated access token.");
  }
}

Node.js

/**
 * TODO(developer):
 *  Uncomment and replace these variables before running the sample.
 */
// const impersonatedServiceAccount = 'name@project.service.gserviceaccount.com';
// const scope = 'https://www.googleapis.com/auth/cloud-platform';

const {GoogleAuth, Impersonated} = require('google-auth-library');

async function getAccessTokenFromImpersonatedCredentials() {
  const googleAuth = new GoogleAuth({
    scopes: scope,
  });
  // Construct the GoogleCredentials object which obtains the default configuration from your
  // working environment.
  const {credential} = await googleAuth.getApplicationDefault();

  // delegates: The chained list of delegates required to grant the final accessToken.
  // For more information, see:
  // https://cloud.google.com/iam/docs/create-short-lived-credentials-direct#sa-credentials-permissions
  // Delegate is NOT USED here.
  const delegates = [];

  // Create the impersonated credential.
  const impersonatedCredentials = new Impersonated({
    sourceClient: credential,
    delegates,
    targetPrincipal: impersonatedServiceAccount,
    targetScopes: [scope],
    lifetime: 300,
  });

  // Get the OAuth2 token.
  // Once you've obtained the OAuth2 token, you can use it to make an authenticated call
  // to the target audience.
  const resp = await impersonatedCredentials.getAccessToken();
  // Token is in resp.token.
  console.log('Generated OAuth2 token with length %s', resp.token.length);
}

getAccessTokenFromImpersonatedCredentials();

Python

def accesstoken_from_impersonated_credentials(
    impersonated_service_account: str, scope: str
):
    from google.auth import impersonated_credentials
    import google.auth.transport.requests

    """
      Use a service account (SA1) to impersonate another service account (SA2)
      and obtain an ID token for the impersonated account.
      To obtain a token for SA2, SA1 should have the
      "roles/iam.serviceAccountTokenCreator" permission on SA2.

    Args:
        impersonated_service_account: The name of the privilege-bearing service account for whom the credential is created.
            Examples: name@project.service.gserviceaccount.com

        scope: Provide the scopes that you might need to request to access Google APIs,
            depending on the level of access you need.
            For this example, we use the cloud-wide scope and use IAM to narrow the permissions.
            https://cloud.google.com/docs/authentication#authorization_for_services
            For more information, see: https://developers.google.com/identity/protocols/oauth2/scopes
    """

    # Construct the GoogleCredentials object which obtains the default configuration from your
    # working environment.
    credentials, project_id = google.auth.default()

    # Create the impersonated credential.
    target_credentials = impersonated_credentials.Credentials(
        source_credentials=credentials,
        target_principal=impersonated_service_account,
        # delegates: The chained list of delegates required to grant the final accessToken.
        # For more information, see:
        # https://cloud.google.com/iam/docs/create-short-lived-credentials-direct#sa-credentials-permissions
        # Delegate is NOT USED here.
        delegates=[],
        target_scopes=[scope],
        lifetime=300,
    )

    # Get the OAuth2 token.
    # Once you've obtained the OAuth2 token, use it to make an authenticated call
    # to the target audience.
    request = google.auth.transport.requests.Request()
    target_credentials.refresh(request)
    # The token field is target_credentials.token.
    print("Generated OAuth2 token.")

Créer un jeton d'identification OpenID Connect (OIDC)

Les jetons d'ID sont conformes à la spécification OpenID Connect (OIDC). Ils sont acceptés par un nombre limité de services et d'applications.

Pour en savoir plus, consultez les sections Jetons d'ID et Authentification pour les applications hébergées sur Cloud Run ou Cloud Run Functions.

Pour créer un jeton d'ID, procédez comme suit :

Fournissez les autorisations requises à l'appelant.

Utilisez le rôle de créateur de jetons d'identité OpenID Connect du compte de service (roles/iam.serviceAccountOpenIdTokenCreator) pour créer un jeton d'ID. Il s'agit d'un rôle différent de celui que vous utilisez pour d'autres types de jetons.
Générez le jeton d'ID.

Fournir les autorisations requises

Compte de service

Lorsque l'application appelante utilise un compte de service comme identité, les comptes principaux suivants sont impliqués :

Compte de service de l'appelant (CALLER_SA)

Ce compte de service représente l'application appelante, qui émet la requête de création d'identifiants éphémères.
Compte de service avec privilège (PRIV_SA)

Ce compte de service se voit attribuer les rôles IAM requis pour le jeton éphémère. Il s'agit du compte de service pour lequel le jeton éphémère est créé.

Pour permettre à CALLER_SA de créer des identifiants éphémères pour PRIV_SA, vous accordez à CALLER_SA le rôle de créateur de jetons d'identité OpenID Connect du compte de service (roles/iam.serviceAccountOpenIdTokenCreator) sur PRIV_SA.

Accordez le rôle requis sur PRIV_SA :

Console

Dans Google Cloud Console, accédez à la page Comptes de service.

Accéder à la page "Comptes de service"
Sélectionnez un projet.
Cliquez sur l'adresse e-mail du compte de service disposant de privilèges (PRIV_SA).
Cliquez sur l'onglet Autorisations.
Sous Comptes principaux ayant accès à ce compte de service, cliquez sur Accorder l'accès.
Saisissez l'adresse e-mail du compte de service de l'appelant (CALLER_SA).

Par exemple, demo@my-project.iam.gserviceaccount.com.
Sélectionnez le rôle de créateur de jetons d'identité OpenID Connect du compte de service (roles/iam.serviceAccountOpenIdTokenCreator).
Cliquez sur Enregistrer pour attribuer le rôle au compte de service.

gcloud

La commande gcloud iam service-accounts add-iam-policy-binding accorde un rôle à un compte de service.

Avant d'utiliser les données de la commande ci-dessous, effectuez les remplacements suivants :

PRIV_SA: l'adresse e-mail du compte de service avec privilège pour lequel le jeton est généré.
CALLER_SA: adresse e-mail du compte de service représentant l'application qui demande le jeton de courte durée.

Exécutez la commande suivante :

Linux, macOS ou Cloud Shell

gcloud iam service-accounts add-iam-policy-binding PRIV_SA \
    --member=serviceAccount:CALLER_SA --role=roles/iam.serviceAccountOpenIdTokenCreator --format=json

Windows (PowerShell)

gcloud iam service-accounts add-iam-policy-binding PRIV_SA `
    --member=serviceAccount:CALLER_SA --role=roles/iam.serviceAccountOpenIdTokenCreator --format=json

Windows (cmd.exe)

gcloud iam service-accounts add-iam-policy-binding PRIV_SA ^
    --member=serviceAccount:CALLER_SA --role=roles/iam.serviceAccountOpenIdTokenCreator --format=json

Vous devriez obtenir un résultat semblable à celui-ci :

Updated IAM policy for serviceAccount [PRIV_SA].
{
  "bindings": [
    {
      "members": [
        "serviceAccount:CALLER_SA"
      ],
      "role": "roles/iam.serviceAccountOpenIdTokenCreator"
    }
  ],
  "etag": "BwXhCB4eyjY=",
  "version": 1
}

REST

Lisez la règle d'autorisation de PRIV_SA :

La méthode serviceAccounts.getIamPolicy permet d'obtenir la stratégie d'autorisation d'un compte de service.

Avant d'utiliser les données de requête ci-dessous, effectuez les remplacements suivants :
- PROJECT_ID : ID de votre projet Google Cloud. Les ID de projet sont des chaînes alphanumériques, telles que my-project.
- PRIV_SA : adresse e-mail du compte de service avec privilège pour lequel le jeton de courte durée est créé.
- POLICY_VERSION : version de la stratégie à renvoyer. Les requêtes doivent spécifier la version de stratégie la plus récente, qui est la version 3. Pour plus d'informations, consultez la section Spécifier une version de stratégie lors de l'obtention d'une stratégie.
Méthode HTTP et URL :
```
POST https://iam.googleapis.com/v1/projects/PROJECT_ID/serviceAccounts/PRIV_SA:getIamPolicy
```
Corps JSON de la requête :
```
{
  "options": {
    "requestedPolicyVersion": POLICY_VERSION
  }
}
```
Pour envoyer votre requête, développez l'une des options suivantes :
curl (Linux, macOS ou Cloud Shell)

Remarque : La commande suivante suppose que vous êtes connecté à la CLI gcloud avec votre compte utilisateur en exécutant la commande gcloud init ou gcloud auth login, ou en utilisant Cloud Shell, qui vous connecte automatiquement à la CLI gcloud. Vous pouvez exécuter la commande gcloud auth list pour vérifier quel est le compte actuellement actif.

Enregistrez le corps de la requête dans un fichier nommé request.json, puis exécutez la commande suivante :
```
curl -X POST \
     -H "Authorization: Bearer $(gcloud auth print-access-token)" \
     -H "Content-Type: application/json; charset=utf-8" \
     -d @request.json \
     "https://iam.googleapis.com/v1/projects/PROJECT_ID/serviceAccounts/PRIV_SA:getIamPolicy"
```
PowerShell (Windows)

Remarque : La commande suivante suppose que vous vous êtes connecté à la CLI gcloud avec votre compte utilisateur en exécutant la commande gcloud init ou gcloud auth login. Vous pouvez exécuter la commande gcloud auth list pour vérifier quel est le compte actuellement actif.

Enregistrez le corps de la requête dans un fichier nommé request.json, puis exécutez la commande suivante :
```
$cred = gcloud auth print-access-token
$headers = @{ "Authorization" = "Bearer $cred" }

Invoke-WebRequest `
    -Method POST `
    -Headers $headers `
    -ContentType: "application/json; charset=utf-8" `
    -InFile request.json `
    -Uri "https://iam.googleapis.com/v1/projects/PROJECT_ID/serviceAccounts/PRIV_SA:getIamPolicy" | Select-Object -Expand Content
```
APIs Explorer (navigateur)

Copiez le corps de la requête et ouvrez la page de référence de la méthode. Le panneau APIs Explorer s'ouvre dans la partie droite de la page. Vous pouvez interagir avec cet outil pour envoyer des requêtes. Collez le corps de la requête dans cet outil, renseignez tous les champs obligatoires, puis cliquez sur Execute (Exécuter).

Vous devriez recevoir une réponse JSON de ce type :
```
{
  "version": 1,
  "etag": "BwWKmjvelug=",
  "bindings": [
    {
      "role": "roles/serviceAccountAdmin",
      "members": [
        "user:my-user@example.com"
      ]
    }
  ]
}
```
Si vous n'avez attribué aucun rôle au compte de service, la réponse ne contient qu'une valeur etag. Incluez cette valeur etag à l'étape suivante.

Modifiez la règle d'autorisation pour accorder à CALLER_SA le rôle de créateur de jetons d'identité OpenID Connect du compte de service (roles/iam.serviceAccountOpenIdTokenCreator).

Par exemple, pour modifier l'exemple de réponse de l'étape précédente, ajoutez ce qui suit :

  {
    "version": 1,
    "etag": "BwWKmjvelug=",
    "bindings": [
      {
        "role": "roles/serviceAccountAdmin",
        "members": [
          "user:my-user@example.com"
        ]
      },
      {
        "role": "roles/iam.serviceAccountOpenIdTokenCreator",
        "members": [
          "serviceAccount:CALLER_SA"
        ]
      }
    ]
  }

Écrivez la stratégie d'autorisation mise à jour :

La méthode serviceAccounts.setIamPolicy définit une stratégie d'autorisation mise à jour pour le compte de service.

Avant d'utiliser les données de requête ci-dessous, effectuez les remplacements suivants :
- PROJECT_ID : ID de votre projet Google Cloud. Les ID de projet sont des chaînes alphanumériques, telles que my-project.
- PRIV_SA : adresse e-mail du compte de service avec privilège pour lequel le jeton de courte durée est créé.
- POLICY_VERSION : version de la stratégie à renvoyer. Les requêtes doivent spécifier la version de stratégie la plus récente, qui est la version 3. Pour plus d'informations, consultez la section Spécifier une version de stratégie lors de l'obtention d'une stratégie.
- POLICY : représentation JSON de la stratégie que vous souhaitez définir. Pour en savoir plus sur le format d'une stratégie, consultez la documentation de référence sur les stratégies.
  
  Par exemple, pour définir la règle d'autorisation affichée à l'étape précédente, remplacez POLICY par ce qui suit, où CALLER_SA correspond au compte de service créant le jeton de courte durée:
```
{
  "version": 1,
  "etag": "BwWKmjvelug=",
  "bindings": [
    {
      "role": "roles/serviceAccountAdmin",
      "members": [
        "user:my-user@example.com"
      ]
    },
    {
      "role": "roles/iam.serviceAccountOpenIdTokenCreator",
      "members": [
        "serviceAccount:CALLER_SA"
      ]
    }
  ]
}
```
Méthode HTTP et URL :
```
POST https://iam.googleapis.com/v1/projects/PROJECT_ID/serviceAccounts/PRIV_SA
```
Corps JSON de la requête :
```
{
  "policy": POLICY
}
```
Pour envoyer votre requête, développez l'une des options suivantes :
curl (Linux, macOS ou Cloud Shell)

Enregistrez le corps de la requête dans un fichier nommé request.json, puis exécutez la commande suivante :
```
curl -X POST \
     -H "Authorization: Bearer $(gcloud auth print-access-token)" \
     -H "Content-Type: application/json; charset=utf-8" \
     -d @request.json \
     "https://iam.googleapis.com/v1/projects/PROJECT_ID/serviceAccounts/PRIV_SA"
```
PowerShell (Windows)

Enregistrez le corps de la requête dans un fichier nommé request.json, puis exécutez la commande suivante :
```
$cred = gcloud auth print-access-token
$headers = @{ "Authorization" = "Bearer $cred" }

Invoke-WebRequest `
    -Method POST `
    -Headers $headers `
    -ContentType: "application/json; charset=utf-8" `
    -InFile request.json `
    -Uri "https://iam.googleapis.com/v1/projects/PROJECT_ID/serviceAccounts/PRIV_SA" | Select-Object -Expand Content
```
APIs Explorer (navigateur)

Copiez le corps de la requête et ouvrez la page de référence de la méthode. Le panneau APIs Explorer s'ouvre dans la partie droite de la page. Vous pouvez interagir avec cet outil pour envoyer des requêtes. Collez le corps de la requête dans cet outil, renseignez tous les champs obligatoires, puis cliquez sur Execute (Exécuter).

La réponse contient la stratégie d'autorisation mise à jour.

Remarque : Si vous traitez les stratégies d'autorisation comme du code et que vous les stockez dans un système de contrôle des versions, vous devez stocker la stratégie qui est renvoyée, et non celle que vous avez envoyée dans la requête.

Identifiants utilisateur

Lorsque vous utilisez un compte utilisateur pour générer des jetons de éphémères, les identités suivantes sont impliquées :

Compte de l'appelant (CALLER_ACCOUNT)

Ce compte utilisateur permet de générer des identifiants éphémères pour le compte de service disposant de privilèges.
Compte de service avec privilège (PRIV_SA)

Ce compte de service se voit attribuer les rôles IAM requis pour le jeton éphémère. Il s'agit du compte de service pour lequel le jeton éphémère est créé.

Pour permettre à CALLER_ACCOUNT de créer des identifiants éphémères pour PRIV_SA, vous devez accorder à CALLER_ACCOUNT le rôle de créateur de jetons d'identité OpenID Connect du compte de service (roles/iam.serviceAccountOpenIdTokenCreator) sur PRIV_SA.

Accordez le rôle requis sur PRIV_SA :

Console

Dans Google Cloud Console, accédez à la page Comptes de service.

Accéder à la page "Comptes de service"
Sélectionnez un projet.
Cliquez sur l'adresse e-mail du compte de service disposant de privilèges (PRIV_SA).
Cliquez sur l'onglet Autorisations.
Sous Comptes principaux ayant accès à ce compte de service, cliquez sur Accorder l'accès.
Saisissez l'identifiant principal du compte appelant, CALLER_ACCOUNT.

Par exemple, example-user@example.com.
Sélectionnez le rôle de créateur de jetons d'identité OpenID Connect du compte de service (roles/iam.serviceAccountOpenIdTokenCreator).
Cliquez sur Enregistrer pour attribuer le rôle au compte utilisateur.

gcloud

La commande gcloud iam service-accounts add-iam-policy-binding accorde un rôle à un compte de service.

Avant d'utiliser les données de la commande ci-dessous, effectuez les remplacements suivants :

PRIV_SA: l'adresse e-mail du compte de service avec privilège pour lequel le jeton est généré.
CALLER_ACCOUNT: adresse e-mail du compte utilisateur utilisé pour demander le jeton de courte durée.

Exécutez la commande suivante :

Linux, macOS ou Cloud Shell

gcloud iam service-accounts add-iam-policy-binding PRIV_SA \
    --member=user:CALLER_ACCOUNT --role=roles/iam.serviceAccountOpenIdTokenCreator --format=json

Windows (PowerShell)

gcloud iam service-accounts add-iam-policy-binding PRIV_SA `
    --member=user:CALLER_ACCOUNT --role=roles/iam.serviceAccountOpenIdTokenCreator --format=json

Windows (cmd.exe)

gcloud iam service-accounts add-iam-policy-binding PRIV_SA ^
    --member=user:CALLER_ACCOUNT --role=roles/iam.serviceAccountOpenIdTokenCreator --format=json

Vous devriez obtenir un résultat semblable à celui-ci :

Updated IAM policy for serviceAccount [PRIV_SA].
{
  "bindings": [
    {
      "members": [
        "user:my-user@example.com"
      ],
      "role": "roles/iam.serviceAccountOpenIdTokenCreator"
    }
  ],
  "etag": "BwX1ZbefjXU=",
  "version": 1
}

REST

Lisez la règle d'autorisation de PRIV_SA :

La méthode serviceAccounts.getIamPolicy permet d'obtenir la stratégie d'autorisation d'un compte de service.

Avant d'utiliser les données de requête ci-dessous, effectuez les remplacements suivants :
- PROJECT_ID : ID de votre projet Google Cloud. Les ID de projet sont des chaînes alphanumériques, telles que my-project.
- PRIV_SA : adresse e-mail du compte de service avec privilège pour lequel le jeton de courte durée est créé.
- POLICY_VERSION : version de la stratégie à renvoyer. Les requêtes doivent spécifier la version de stratégie la plus récente, qui est la version 3. Pour plus d'informations, consultez la section Spécifier une version de stratégie lors de l'obtention d'une stratégie.
Méthode HTTP et URL :
```
POST https://iam.googleapis.com/v1/projects/PROJECT_ID/serviceAccounts/PRIV_SA:getIamPolicy
```
Corps JSON de la requête :
```
{
  "options": {
    "requestedPolicyVersion": POLICY_VERSION
  }
}
```
Pour envoyer votre requête, développez l'une des options suivantes :
curl (Linux, macOS ou Cloud Shell)

Remarque : La commande suivante suppose que vous êtes connecté à la CLI gcloud avec votre compte utilisateur en exécutant la commande gcloud init ou gcloud auth login, ou en utilisant Cloud Shell, qui vous connecte automatiquement à la CLI gcloud. Vous pouvez exécuter la commande gcloud auth list pour vérifier quel est le compte actuellement actif.

Enregistrez le corps de la requête dans un fichier nommé request.json, puis exécutez la commande suivante :
```
curl -X POST \
     -H "Authorization: Bearer $(gcloud auth print-access-token)" \
     -H "Content-Type: application/json; charset=utf-8" \
     -d @request.json \
     "https://iam.googleapis.com/v1/projects/PROJECT_ID/serviceAccounts/PRIV_SA:getIamPolicy"
```
PowerShell (Windows)

Remarque : La commande suivante suppose que vous vous êtes connecté à la CLI gcloud avec votre compte utilisateur en exécutant la commande gcloud init ou gcloud auth login. Vous pouvez exécuter la commande gcloud auth list pour vérifier quel est le compte actuellement actif.

Enregistrez le corps de la requête dans un fichier nommé request.json, puis exécutez la commande suivante :
```
$cred = gcloud auth print-access-token
$headers = @{ "Authorization" = "Bearer $cred" }

Invoke-WebRequest `
    -Method POST `
    -Headers $headers `
    -ContentType: "application/json; charset=utf-8" `
    -InFile request.json `
    -Uri "https://iam.googleapis.com/v1/projects/PROJECT_ID/serviceAccounts/PRIV_SA:getIamPolicy" | Select-Object -Expand Content
```
APIs Explorer (navigateur)

Copiez le corps de la requête et ouvrez la page de référence de la méthode. Le panneau APIs Explorer s'ouvre dans la partie droite de la page. Vous pouvez interagir avec cet outil pour envoyer des requêtes. Collez le corps de la requête dans cet outil, renseignez tous les champs obligatoires, puis cliquez sur Execute (Exécuter).

Vous devriez recevoir une réponse JSON de ce type :
```
{
  "version": 1,
  "etag": "BwWKmjvelug=",
  "bindings": [
    {
      "role": "roles/serviceAccountAdmin",
      "members": [
        "user:my-user@example.com"
      ]
    }
  ]
}
```
Si vous n'avez attribué aucun rôle au compte de service, la réponse ne contient qu'une valeur etag. Incluez cette valeur etag à l'étape suivante.

Modifiez la règle d'autorisation pour accorder à CALLER_ACCOUNT le rôle de créateur de jetons d'identité OpenID Connect du compte de service (roles/iam.serviceAccountOpenIdTokenCreator).

Par exemple, pour modifier l'exemple de réponse de l'étape précédente, ajoutez ce qui suit :

{
  "version": 1,
  "etag": "BwWKmjvelug=",
  "bindings": [
    {
      "role": "roles/serviceAccountAdmin",
      "members": [
        "user:my-user@example.com"
      ]
    },
    {
      "role": "roles/iam.serviceAccountOpenIdTokenCreator",
      "members": [
        "user:my-user@example.com"
      ]
    }
  ]
}

Écrivez la stratégie d'autorisation mise à jour :

La méthode serviceAccounts.setIamPolicy définit une stratégie d'autorisation mise à jour pour le compte de service.

Avant d'utiliser les données de requête ci-dessous, effectuez les remplacements suivants :
- PROJECT_ID : ID de votre projet Google Cloud. Les ID de projet sont des chaînes alphanumériques, telles que my-project.
- PRIV_SA : adresse e-mail du compte de service avec privilège pour lequel le jeton de courte durée est créé.
- POLICY_VERSION : version de la stratégie à renvoyer. Les requêtes doivent spécifier la version de stratégie la plus récente, qui est la version 3. Pour plus d'informations, consultez la section Spécifier une version de stratégie lors de l'obtention d'une stratégie.
- POLICY : représentation JSON de la stratégie que vous souhaitez définir. Pour en savoir plus sur le format d'une stratégie, consultez la documentation de référence sur les stratégies.
  
  Par exemple, pour définir la règle d'autorisation affichée à l'étape précédente, remplacez POLICY par ce qui suit, où CALLER_ACCOUNT correspond au compte utilisateur créant le jeton de courte durée :
```
{
  "version": 1,
  "etag": "BwWKmjvelug=",
  "bindings": [
    {
      "role": "roles/serviceAccountAdmin",
      "members": [
        "user:my-user@example.com"
      ]
    },
    {
      "role": "roles/iam.serviceAccountOpenIdTokenCreator",
      "members": [
        "CALLER_ACCOUNT"
      ]
    }
  ]
}
```
Méthode HTTP et URL :
```
POST https://iam.googleapis.com/v1/projects/PROJECT_ID/serviceAccounts/PRIV_SA
```
Corps JSON de la requête :
```
{
  "policy": POLICY
}
```
Pour envoyer votre requête, développez l'une des options suivantes :
curl (Linux, macOS ou Cloud Shell)

Enregistrez le corps de la requête dans un fichier nommé request.json, puis exécutez la commande suivante :
```
curl -X POST \
     -H "Authorization: Bearer $(gcloud auth print-access-token)" \
     -H "Content-Type: application/json; charset=utf-8" \
     -d @request.json \
     "https://iam.googleapis.com/v1/projects/PROJECT_ID/serviceAccounts/PRIV_SA"
```
PowerShell (Windows)

Enregistrez le corps de la requête dans un fichier nommé request.json, puis exécutez la commande suivante :
```
$cred = gcloud auth print-access-token
$headers = @{ "Authorization" = "Bearer $cred" }

Invoke-WebRequest `
    -Method POST `
    -Headers $headers `
    -ContentType: "application/json; charset=utf-8" `
    -InFile request.json `
    -Uri "https://iam.googleapis.com/v1/projects/PROJECT_ID/serviceAccounts/PRIV_SA" | Select-Object -Expand Content
```
APIs Explorer (navigateur)

Copiez le corps de la requête et ouvrez la page de référence de la méthode. Le panneau APIs Explorer s'ouvre dans la partie droite de la page. Vous pouvez interagir avec cet outil pour envoyer des requêtes. Collez le corps de la requête dans cet outil, renseignez tous les champs obligatoires, puis cliquez sur Execute (Exécuter).

La réponse contient la stratégie d'autorisation mise à jour.

Remarque : Si vous traitez les stratégies d'autorisation comme du code et que vous les stockez dans un système de contrôle des versions, vous devez stocker la stratégie qui est renvoyée, et non celle que vous avez envoyée dans la requête.

Générer le jeton d'ID

Vous pouvez générer un jeton d'identification OpenID Connect (OIDC) à l'aide de la CLI gcloud, de l'API REST ou des bibliothèques clientes Cloud et des bibliothèques clientes des API Google.

Les jetons d'identification OIDC sont valides pendant 1 heure,soit 3 600 secondes.

Générez un jeton d'ID OIDC signé par Google pour un compte de service:

gcloud

Assurez-vous d'être connecté à gcloud CLI avec le compte utilisateur de l'appelant.

Générez un jeton pour le compte de service à l'aide de la commande gcloud auth print-identity-token.

Avant d'utiliser les données de la commande ci-dessous, effectuez les remplacements suivants :

PRIV_SA : adresse e-mail du compte de service avec privilège pour lequel le jeton de courte durée est créé.
AUDIENCE_NAME : audience du jeton, généralement l'URL de l'application ou du service auquel le jeton sera appliqué pour autoriser l'accès.

Exécutez la commande suivante :

Linux, macOS ou Cloud Shell

gcloud auth print-identity-token --impersonate-service-account=PRIV_SA --audiences="AUDIENCE_NAME"

Windows (PowerShell)

gcloud auth print-identity-token --impersonate-service-account=PRIV_SA --audiences="AUDIENCE_NAME"

Windows (cmd.exe)

gcloud auth print-identity-token --impersonate-service-account=PRIV_SA --audiences="AUDIENCE_NAME"

Vous devriez obtenir un résultat semblable à celui-ci :

WARNING: This command is using service account impersonation. All API calls will be executed as
[my-sa@my-project.iam.gserviceaccount.com].
eyJhbGciOiJSUzI1NiIsImtpZDNhMDg4ZDRmZmMjJkYTVmZTM5MDZjY2MiLCJ0eXAiOiJKV1QifQ.eyJhdWQiOiJ3d3cuZXhhbXBsJhenAiOiIxMTYzwNDYyMDk0ODIiLCJleHAiOjE2NTQ4ODU0MzEsImlhdCI6MTY1NDg4MTgzMSwiaXN6Ly9hY2NvdW50cy5nb29nbGUuY29tIiwic3ViIMDQ2MjA5NDgyIn0.F7mu8IHj5VQdu7ItFrnYAKyGd7YqXuOP_rFLc98q8BaFBycAF1zAQnSnwqnSUXba0UK9PDT_-IOry68qLwBObz4XlX9lk0ehpN0O0W9FcFToKLB6wefXXPd4h7xtuPe5KzmpSOqj2Qqv34HriGw00Nqd-oGSgNY_lZ4wGEf4rT4oQa_kEcrY57Q2G6pwd769BhgeFwoLi5aK_Cv2kvf_zfMszC-xlkP9zwWQ8XinJBwe-qcQBa4NTgrbueNtXsEjccBS366zmw

REST

La méthode serviceAccounts.generateIdToken de l'API Service Account Credentials génère un jeton d'identification OIDC pour un compte de service.

Avant d'utiliser les données de requête ci-dessous, effectuez les remplacements suivants :

PRIV_SA : adresse e-mail du compte de service avec privilège pour lequel le jeton de courte durée est créé.
AUDIENCE_NAME : audience du jeton, généralement l'URL de l'application ou du service auquel le jeton sera appliqué pour autoriser l'accès.

Méthode HTTP et URL :

POST https://iamcredentials.googleapis.com/v1/projects/-/serviceAccounts/PRIV_SA:generateIdToken

Corps JSON de la requête :

{
  "audience": "AUDIENCE_NAME",
  "includeEmail": "true"
}

Pour envoyer votre requête, développez l'une des options suivantes :

curl (Linux, macOS ou Cloud Shell)

Enregistrez le corps de la requête dans un fichier nommé request.json, puis exécutez la commande suivante :

curl -X POST \
     -H "Authorization: Bearer $(gcloud auth print-access-token)" \
     -H "Content-Type: application/json; charset=utf-8" \
     -d @request.json \
     "https://iamcredentials.googleapis.com/v1/projects/-/serviceAccounts/PRIV_SA:generateIdToken"

PowerShell (Windows)

Enregistrez le corps de la requête dans un fichier nommé request.json, puis exécutez la commande suivante :

$cred = gcloud auth print-access-token
$headers = @{ "Authorization" = "Bearer $cred" }

Invoke-WebRequest `
    -Method POST `
    -Headers $headers `
    -ContentType: "application/json; charset=utf-8" `
    -InFile request.json `
    -Uri "https://iamcredentials.googleapis.com/v1/projects/-/serviceAccounts/PRIV_SA:generateIdToken" | Select-Object -Expand Content

APIs Explorer (navigateur)

Si la requête generateId a abouti, le corps de la réponse contient un jeton d'identification valide pendant une heure. Ce jeton d'accès (token) peut alors être utilisé pour authentifier une requête au nom du compte de service :

{
  "token": "eyJ0eXAi...NiJ9"
}

Créer un jeton Web JSON (JWT) autosigné

Les jetons Web JSON (JWT) autosignés sont utiles dans différents scénarios :

Communication sécurisée entre vos propres applications. Dans un tel scénario, une application est susceptible de signer un jeton qui pourra être validé par une autre application à des fins d'authentification.
Authentification d'un appel à une API Google, comme indiqué dans Autorisation du compte de service sans OAuth.
Authentification auprès d'une API déployée avec l'API Gateway.
Traitement d'un compte de service en tant que fournisseur d'identité, via la signature d'un jeton JWT contenant des revendications arbitraires sur un utilisateur, un compte ou un appareil.

Pour créer un jeton JWT, procédez comme suit :

Fournissez les autorisations requises à l'appelant.
Générez le jeton JWT.

Fournir les autorisations requises

Compte de service

Lorsque l'application appelante utilise un compte de service comme identité, les comptes principaux suivants sont impliqués :

Compte de service de l'appelant (CALLER_SA)

Ce compte de service représente l'application appelante, qui émet la requête de création d'identifiants éphémères.
Compte de service avec privilège (PRIV_SA)

Ce compte de service se voit attribuer les rôles IAM requis pour le jeton éphémère. Il s'agit du compte de service pour lequel le jeton éphémère est créé.

Accordez le rôle requis sur PRIV_SA :

Console

Dans Google Cloud Console, accédez à la page Comptes de service.

Accéder à la page "Comptes de service"
Sélectionnez un projet.
Cliquez sur l'adresse e-mail du compte de service disposant de privilèges (PRIV_SA).
Cliquez sur l'onglet Autorisations.
Sous Comptes principaux ayant accès à ce compte de service, cliquez sur Accorder l'accès.
Saisissez l'adresse e-mail du compte de service de l'appelant (CALLER_SA).

Par exemple, demo@my-project.iam.gserviceaccount.com.
Sélectionnez le rôle de créateur de jetons du compte de service (roles/iam.serviceAccountTokenCreator).
Cliquez sur Enregistrer pour attribuer le rôle au compte de service.

gcloud

La commande gcloud iam service-accounts add-iam-policy-binding accorde un rôle à un compte de service.

Avant d'utiliser les données de la commande ci-dessous, effectuez les remplacements suivants :

PRIV_SA: l'adresse e-mail du compte de service avec privilège pour lequel le jeton est généré.
CALLER_SA: adresse e-mail du compte de service représentant l'application qui demande le jeton de courte durée.

Exécutez la commande suivante :

Linux, macOS ou Cloud Shell

gcloud iam service-accounts add-iam-policy-binding PRIV_SA \
    --member=serviceAccount:CALLER_SA --role=roles/iam.serviceAccountTokenCreator --format=json

Windows (PowerShell)

gcloud iam service-accounts add-iam-policy-binding PRIV_SA `
    --member=serviceAccount:CALLER_SA --role=roles/iam.serviceAccountTokenCreator --format=json

Windows (cmd.exe)

gcloud iam service-accounts add-iam-policy-binding PRIV_SA ^
    --member=serviceAccount:CALLER_SA --role=roles/iam.serviceAccountTokenCreator --format=json

Vous devriez obtenir un résultat semblable à celui-ci :

Updated IAM policy for serviceAccount [PRIV_SA].
{
  "bindings": [
    {
      "members": [
        "serviceAccount:CALLER_SA"
      ],
      "role": "roles/iam.serviceAccountTokenCreator"
    }
  ],
  "etag": "BwXhCB4eyjY=",
  "version": 1
}

REST

Lisez la règle d'autorisation de PRIV_SA :

La méthode serviceAccounts.getIamPolicy permet d'obtenir la stratégie d'autorisation d'un compte de service.

Avant d'utiliser les données de requête ci-dessous, effectuez les remplacements suivants :
- PROJECT_ID : ID de votre projet Google Cloud. Les ID de projet sont des chaînes alphanumériques, telles que my-project.
- PRIV_SA : adresse e-mail du compte de service avec privilège pour lequel le jeton de courte durée est créé.
- POLICY_VERSION : version de la stratégie à renvoyer. Les requêtes doivent spécifier la version de stratégie la plus récente, qui est la version 3. Pour plus d'informations, consultez la section Spécifier une version de stratégie lors de l'obtention d'une stratégie.
Méthode HTTP et URL :
```
POST https://iam.googleapis.com/v1/projects/PROJECT_ID/serviceAccounts/PRIV_SA:getIamPolicy
```
Corps JSON de la requête :
```
{
  "options": {
    "requestedPolicyVersion": POLICY_VERSION
  }
}
```
Pour envoyer votre requête, développez l'une des options suivantes :
curl (Linux, macOS ou Cloud Shell)

Remarque : La commande suivante suppose que vous êtes connecté à la CLI gcloud avec votre compte utilisateur en exécutant la commande gcloud init ou gcloud auth login, ou en utilisant Cloud Shell, qui vous connecte automatiquement à la CLI gcloud. Vous pouvez exécuter la commande gcloud auth list pour vérifier quel est le compte actuellement actif.

Enregistrez le corps de la requête dans un fichier nommé request.json, puis exécutez la commande suivante :
```
curl -X POST \
     -H "Authorization: Bearer $(gcloud auth print-access-token)" \
     -H "Content-Type: application/json; charset=utf-8" \
     -d @request.json \
     "https://iam.googleapis.com/v1/projects/PROJECT_ID/serviceAccounts/PRIV_SA:getIamPolicy"
```
PowerShell (Windows)

Remarque : La commande suivante suppose que vous vous êtes connecté à la CLI gcloud avec votre compte utilisateur en exécutant la commande gcloud init ou gcloud auth login. Vous pouvez exécuter la commande gcloud auth list pour vérifier quel est le compte actuellement actif.

Enregistrez le corps de la requête dans un fichier nommé request.json, puis exécutez la commande suivante :
```
$cred = gcloud auth print-access-token
$headers = @{ "Authorization" = "Bearer $cred" }

Invoke-WebRequest `
    -Method POST `
    -Headers $headers `
    -ContentType: "application/json; charset=utf-8" `
    -InFile request.json `
    -Uri "https://iam.googleapis.com/v1/projects/PROJECT_ID/serviceAccounts/PRIV_SA:getIamPolicy" | Select-Object -Expand Content
```
APIs Explorer (navigateur)

Copiez le corps de la requête et ouvrez la page de référence de la méthode. Le panneau APIs Explorer s'ouvre dans la partie droite de la page. Vous pouvez interagir avec cet outil pour envoyer des requêtes. Collez le corps de la requête dans cet outil, renseignez tous les champs obligatoires, puis cliquez sur Execute (Exécuter).

Vous devriez recevoir une réponse JSON de ce type :
```
{
  "version": 1,
  "etag": "BwWKmjvelug=",
  "bindings": [
    {
      "role": "roles/serviceAccountAdmin",
      "members": [
        "user:my-user@example.com"
      ]
    }
  ]
}
```
Si vous n'avez attribué aucun rôle au compte de service, la réponse ne contient qu'une valeur etag. Incluez cette valeur etag à l'étape suivante.

Modifiez la règle d'autorisation pour accorder à CALLER_SA le rôle de créateur de jetons du compte de service (roles/iam.serviceAccountTokenCreator).

Par exemple, pour modifier l'exemple de réponse de l'étape précédente, ajoutez ce qui suit :

  {
    "version": 1,
    "etag": "BwWKmjvelug=",
    "bindings": [
      {
        "role": "roles/serviceAccountAdmin",
        "members": [
          "user:my-user@example.com"
        ]
      },
      {
        "role": "roles/iam.serviceAccountTokenCreator",
        "members": [
          "serviceAccount:CALLER_SA"
        ]
      }
    ]
  }

Écrivez la stratégie d'autorisation mise à jour :

La méthode serviceAccounts.setIamPolicy définit une stratégie d'autorisation mise à jour pour le compte de service.

Avant d'utiliser les données de requête ci-dessous, effectuez les remplacements suivants :
- PROJECT_ID : ID de votre projet Google Cloud. Les ID de projet sont des chaînes alphanumériques, telles que my-project.
- PRIV_SA : adresse e-mail du compte de service avec privilège pour lequel le jeton de courte durée est créé.
- POLICY_VERSION : version de la stratégie à renvoyer. Les requêtes doivent spécifier la version de stratégie la plus récente, qui est la version 3. Pour plus d'informations, consultez la section Spécifier une version de stratégie lors de l'obtention d'une stratégie.
- POLICY : représentation JSON de la stratégie que vous souhaitez définir. Pour en savoir plus sur le format d'une stratégie, consultez la documentation de référence sur les stratégies.
  
  Par exemple, pour définir la règle d'autorisation affichée à l'étape précédente, remplacez POLICY par ce qui suit, où CALLER_SA correspond au compte de service créant le jeton de courte durée:
```
{
  "version": 1,
  "etag": "BwWKmjvelug=",
  "bindings": [
    {
      "role": "roles/serviceAccountAdmin",
      "members": [
        "user:my-user@example.com"
      ]
    },
    {
      "role": "roles/iam.serviceAccountTokenCreator",
      "members": [
        "serviceAccount:CALLER_SA"
      ]
    }
  ]
}
```
Méthode HTTP et URL :
```
POST https://iam.googleapis.com/v1/projects/PROJECT_ID/serviceAccounts/PRIV_SA
```
Corps JSON de la requête :
```
{
  "policy": POLICY
}
```
Pour envoyer votre requête, développez l'une des options suivantes :
curl (Linux, macOS ou Cloud Shell)

Enregistrez le corps de la requête dans un fichier nommé request.json, puis exécutez la commande suivante :
```
curl -X POST \
     -H "Authorization: Bearer $(gcloud auth print-access-token)" \
     -H "Content-Type: application/json; charset=utf-8" \
     -d @request.json \
     "https://iam.googleapis.com/v1/projects/PROJECT_ID/serviceAccounts/PRIV_SA"
```
PowerShell (Windows)

Enregistrez le corps de la requête dans un fichier nommé request.json, puis exécutez la commande suivante :
```
$cred = gcloud auth print-access-token
$headers = @{ "Authorization" = "Bearer $cred" }

Invoke-WebRequest `
    -Method POST `
    -Headers $headers `
    -ContentType: "application/json; charset=utf-8" `
    -InFile request.json `
    -Uri "https://iam.googleapis.com/v1/projects/PROJECT_ID/serviceAccounts/PRIV_SA" | Select-Object -Expand Content
```
APIs Explorer (navigateur)

Copiez le corps de la requête et ouvrez la page de référence de la méthode. Le panneau APIs Explorer s'ouvre dans la partie droite de la page. Vous pouvez interagir avec cet outil pour envoyer des requêtes. Collez le corps de la requête dans cet outil, renseignez tous les champs obligatoires, puis cliquez sur Execute (Exécuter).

La réponse contient la stratégie d'autorisation mise à jour.

Remarque : Si vous traitez les stratégies d'autorisation comme du code et que vous les stockez dans un système de contrôle des versions, vous devez stocker la stratégie qui est renvoyée, et non celle que vous avez envoyée dans la requête.

Identifiants utilisateur

Lorsque vous utilisez un compte utilisateur pour générer des jetons de éphémères, les identités suivantes sont impliquées :

Compte de l'appelant (CALLER_ACCOUNT)

Ce compte utilisateur permet de générer des identifiants éphémères pour le compte de service disposant de privilèges.
Compte de service avec privilège (PRIV_SA)

Ce compte de service se voit attribuer les rôles IAM requis pour le jeton éphémère. Il s'agit du compte de service pour lequel le jeton éphémère est créé.

Accordez le rôle requis sur PRIV_SA :

Console

Dans Google Cloud Console, accédez à la page Comptes de service.

Accéder à la page "Comptes de service"
Sélectionnez un projet.
Cliquez sur l'adresse e-mail du compte de service disposant de privilèges (PRIV_SA).
Cliquez sur l'onglet Autorisations.
Sous Comptes principaux ayant accès à ce compte de service, cliquez sur Accorder l'accès.
Saisissez l'identifiant principal du compte appelant, CALLER_ACCOUNT.

Par exemple, example-user@example.com.
Sélectionnez le rôle de créateur de jetons du compte de service (roles/iam.serviceAccountTokenCreator).
Cliquez sur Enregistrer pour attribuer le rôle au compte utilisateur.

gcloud

La commande gcloud iam service-accounts add-iam-policy-binding accorde un rôle à un compte de service.

Avant d'utiliser les données de la commande ci-dessous, effectuez les remplacements suivants :

PRIV_SA: l'adresse e-mail du compte de service avec privilège pour lequel le jeton est généré.
CALLER_ACCOUNT: adresse e-mail du compte utilisateur utilisé pour demander le jeton de courte durée.

Exécutez la commande suivante :

Linux, macOS ou Cloud Shell

gcloud iam service-accounts add-iam-policy-binding PRIV_SA \
    --member=user:CALLER_ACCOUNT --role=roles/iam.serviceAccountTokenCreator --format=json

Windows (PowerShell)

gcloud iam service-accounts add-iam-policy-binding PRIV_SA `
    --member=user:CALLER_ACCOUNT --role=roles/iam.serviceAccountTokenCreator --format=json

Windows (cmd.exe)

gcloud iam service-accounts add-iam-policy-binding PRIV_SA ^
    --member=user:CALLER_ACCOUNT --role=roles/iam.serviceAccountTokenCreator --format=json

Vous devriez obtenir un résultat semblable à celui-ci :

Updated IAM policy for serviceAccount [PRIV_SA].
{
  "bindings": [
    {
      "members": [
        "user:my-user@example.com"
      ],
      "role": "roles/iam.serviceAccountTokenCreator"
    }
  ],
  "etag": "BwX1ZbefjXU=",
  "version": 1
}

REST

Lisez la règle d'autorisation de PRIV_SA :

La méthode serviceAccounts.getIamPolicy permet d'obtenir la stratégie d'autorisation d'un compte de service.

Avant d'utiliser les données de requête ci-dessous, effectuez les remplacements suivants :
- PROJECT_ID : ID de votre projet Google Cloud. Les ID de projet sont des chaînes alphanumériques, telles que my-project.
- PRIV_SA : adresse e-mail du compte de service avec privilège pour lequel le jeton de courte durée est créé.
- POLICY_VERSION : version de la stratégie à renvoyer. Les requêtes doivent spécifier la version de stratégie la plus récente, qui est la version 3. Pour plus d'informations, consultez la section Spécifier une version de stratégie lors de l'obtention d'une stratégie.
Méthode HTTP et URL :
```
POST https://iam.googleapis.com/v1/projects/PROJECT_ID/serviceAccounts/PRIV_SA:getIamPolicy
```
Corps JSON de la requête :
```
{
  "options": {
    "requestedPolicyVersion": POLICY_VERSION
  }
}
```
Pour envoyer votre requête, développez l'une des options suivantes :
curl (Linux, macOS ou Cloud Shell)

Remarque : La commande suivante suppose que vous êtes connecté à la CLI gcloud avec votre compte utilisateur en exécutant la commande gcloud init ou gcloud auth login, ou en utilisant Cloud Shell, qui vous connecte automatiquement à la CLI gcloud. Vous pouvez exécuter la commande gcloud auth list pour vérifier quel est le compte actuellement actif.

Enregistrez le corps de la requête dans un fichier nommé request.json, puis exécutez la commande suivante :
```
curl -X POST \
     -H "Authorization: Bearer $(gcloud auth print-access-token)" \
     -H "Content-Type: application/json; charset=utf-8" \
     -d @request.json \
     "https://iam.googleapis.com/v1/projects/PROJECT_ID/serviceAccounts/PRIV_SA:getIamPolicy"
```
PowerShell (Windows)

Remarque : La commande suivante suppose que vous vous êtes connecté à la CLI gcloud avec votre compte utilisateur en exécutant la commande gcloud init ou gcloud auth login. Vous pouvez exécuter la commande gcloud auth list pour vérifier quel est le compte actuellement actif.

Enregistrez le corps de la requête dans un fichier nommé request.json, puis exécutez la commande suivante :
```
$cred = gcloud auth print-access-token
$headers = @{ "Authorization" = "Bearer $cred" }

Invoke-WebRequest `
    -Method POST `
    -Headers $headers `
    -ContentType: "application/json; charset=utf-8" `
    -InFile request.json `
    -Uri "https://iam.googleapis.com/v1/projects/PROJECT_ID/serviceAccounts/PRIV_SA:getIamPolicy" | Select-Object -Expand Content
```
APIs Explorer (navigateur)

Copiez le corps de la requête et ouvrez la page de référence de la méthode. Le panneau APIs Explorer s'ouvre dans la partie droite de la page. Vous pouvez interagir avec cet outil pour envoyer des requêtes. Collez le corps de la requête dans cet outil, renseignez tous les champs obligatoires, puis cliquez sur Execute (Exécuter).

Vous devriez recevoir une réponse JSON de ce type :
```
{
  "version": 1,
  "etag": "BwWKmjvelug=",
  "bindings": [
    {
      "role": "roles/serviceAccountAdmin",
      "members": [
        "user:my-user@example.com"
      ]
    }
  ]
}
```
Si vous n'avez attribué aucun rôle au compte de service, la réponse ne contient qu'une valeur etag. Incluez cette valeur etag à l'étape suivante.

Modifiez la règle d'autorisation pour accorder à CALLER_ACCOUNT le rôle de créateur de jetons du compte de service (roles/iam.serviceAccountTokenCreator).

Par exemple, pour modifier l'exemple de réponse de l'étape précédente, ajoutez ce qui suit :

{
  "version": 1,
  "etag": "BwWKmjvelug=",
  "bindings": [
    {
      "role": "roles/serviceAccountAdmin",
      "members": [
        "user:my-user@example.com"
      ]
    },
    {
      "role": "roles/iam.serviceAccountTokenCreator",
      "members": [
        "user:my-user@example.com"
      ]
    }
  ]
}

Écrivez la stratégie d'autorisation mise à jour :

La méthode serviceAccounts.setIamPolicy définit une stratégie d'autorisation mise à jour pour le compte de service.

Avant d'utiliser les données de requête ci-dessous, effectuez les remplacements suivants :
- PROJECT_ID : ID de votre projet Google Cloud. Les ID de projet sont des chaînes alphanumériques, telles que my-project.
- PRIV_SA : adresse e-mail du compte de service avec privilège pour lequel le jeton de courte durée est créé.
- POLICY_VERSION : version de la stratégie à renvoyer. Les requêtes doivent spécifier la version de stratégie la plus récente, qui est la version 3. Pour plus d'informations, consultez la section Spécifier une version de stratégie lors de l'obtention d'une stratégie.
- POLICY : représentation JSON de la stratégie que vous souhaitez définir. Pour en savoir plus sur le format d'une stratégie, consultez la documentation de référence sur les stratégies.
  
  Par exemple, pour définir la règle d'autorisation affichée à l'étape précédente, remplacez POLICY par ce qui suit, où CALLER_ACCOUNT correspond au compte utilisateur créant le jeton de courte durée :
```
{
  "version": 1,
  "etag": "BwWKmjvelug=",
  "bindings": [
    {
      "role": "roles/serviceAccountAdmin",
      "members": [
        "user:my-user@example.com"
      ]
    },
    {
      "role": "roles/iam.serviceAccountTokenCreator",
      "members": [
        "CALLER_ACCOUNT"
      ]
    }
  ]
}
```
Méthode HTTP et URL :
```
POST https://iam.googleapis.com/v1/projects/PROJECT_ID/serviceAccounts/PRIV_SA
```
Corps JSON de la requête :
```
{
  "policy": POLICY
}
```
Pour envoyer votre requête, développez l'une des options suivantes :
curl (Linux, macOS ou Cloud Shell)

Enregistrez le corps de la requête dans un fichier nommé request.json, puis exécutez la commande suivante :
```
curl -X POST \
     -H "Authorization: Bearer $(gcloud auth print-access-token)" \
     -H "Content-Type: application/json; charset=utf-8" \
     -d @request.json \
     "https://iam.googleapis.com/v1/projects/PROJECT_ID/serviceAccounts/PRIV_SA"
```
PowerShell (Windows)

Enregistrez le corps de la requête dans un fichier nommé request.json, puis exécutez la commande suivante :
```
$cred = gcloud auth print-access-token
$headers = @{ "Authorization" = "Bearer $cred" }

Invoke-WebRequest `
    -Method POST `
    -Headers $headers `
    -ContentType: "application/json; charset=utf-8" `
    -InFile request.json `
    -Uri "https://iam.googleapis.com/v1/projects/PROJECT_ID/serviceAccounts/PRIV_SA" | Select-Object -Expand Content
```
APIs Explorer (navigateur)

Copiez le corps de la requête et ouvrez la page de référence de la méthode. Le panneau APIs Explorer s'ouvre dans la partie droite de la page. Vous pouvez interagir avec cet outil pour envoyer des requêtes. Collez le corps de la requête dans cet outil, renseignez tous les champs obligatoires, puis cliquez sur Execute (Exécuter).

La réponse contient la stratégie d'autorisation mise à jour.

Remarque : Si vous traitez les stratégies d'autorisation comme du code et que vous les stockez dans un système de contrôle des versions, vous devez stocker la stratégie qui est renvoyée, et non celle que vous avez envoyée dans la requête.

Générer le jeton JWT

Générez un jeton JWT autosigné :

REST

La méthode serviceAccounts.signJwt de l'API Service Account Credentials signe un jeton JWT à l'aide de la clé privée gérée par le système d'un compte de service.

Avant d'utiliser les données de requête ci-dessous, effectuez les remplacements suivants :

PRIV_SA : adresse e-mail du compte de service avec privilège pour lequel le jeton de courte durée est créé.
JWT_PAYLOAD : la charge utile JWT à signer. Il s'agit d'un objet JSON contenant un ensemble de revendications JWT. Incluez les revendications nécessaires pour répondre aux besoins du cas d'utilisation souhaité et aux exigences de validation du service que vous appelez. Si vous appelez une API Google, reportez-vous au guide de l'authentification de Google (en anglais) pour connaître les exigences concernant les revendications.

La revendication exp (heure d'expiration) ne doit pas être fixée au delà de 12 heures dans le futur. Si vous appelez une API Google, la revendication exp ne doit pas être fixée au delà d'une heure dans le futur.

L'exemple de charge utile suivant contient des revendications pour appeler une API Google, où EXP est un horodatage entier représentant le délai d'expiration :
```
{ \"iss\": \"PRIV_SA\", \"sub\": \"PRIV_SA\", \"aud\": \"https://firestore.googleapis.com/\", \"iat\": 1529350000, \"exp\": EXP }
```

Méthode HTTP et URL :

POST https://iamcredentials.googleapis.com/v1/projects/-/serviceAccounts/PRIV_SA:signJwt

Corps JSON de la requête :

{
  "payload": "JWT_PAYLOAD"
}

Pour envoyer votre requête, développez l'une des options suivantes :

curl (Linux, macOS ou Cloud Shell)

Enregistrez le corps de la requête dans un fichier nommé request.json, puis exécutez la commande suivante :

curl -X POST \
     -H "Authorization: Bearer $(gcloud auth print-access-token)" \
     -H "Content-Type: application/json; charset=utf-8" \
     -d @request.json \
     "https://iamcredentials.googleapis.com/v1/projects/-/serviceAccounts/PRIV_SA:signJwt"

PowerShell (Windows)

Enregistrez le corps de la requête dans un fichier nommé request.json, puis exécutez la commande suivante :

$cred = gcloud auth print-access-token
$headers = @{ "Authorization" = "Bearer $cred" }

Invoke-WebRequest `
    -Method POST `
    -Headers $headers `
    -ContentType: "application/json; charset=utf-8" `
    -InFile request.json `
    -Uri "https://iamcredentials.googleapis.com/v1/projects/-/serviceAccounts/PRIV_SA:signJwt" | Select-Object -Expand Content

APIs Explorer (navigateur)

Si la requête signJwt a abouti, le corps de la réponse contient un jeton JWT signé, ainsi que l'ID de clé de signature utilisé pour signer ce jeton JWT. Vous pouvez utiliser la valeur signedJwt en tant que jeton de support pour authentifier directement une requête émise au nom du compte de service. Le jeton est valide jusqu'à l'heure d'expiration spécifiée dans la requête :

{
  "keyId": "42ba1e...fc0a",
  "signedJwt": "eyJ0eXAi...NiJ9"
}

Créer un objet binaire autosigné (blob)

Les objets binaires autosignés, ou blobs, permettent de transmettre des données binaires de telle sorte que le créateur des données soit connu (car le blob est autosigné). Les blobs peuvent servir à créer des signatures, un objet Cloud Storage requis pour divers flux d'authentification, y compris les URL signées. Pour en savoir plus sur les signatures, consultez la documentation de Cloud Storage.

Pour créer un objet binaire autosigné, procédez comme suit :

Fournissez les autorisations requises à l'appelant.
Générez le blob autosigné.

Fournir les autorisations requises

Compte de service

Lorsque l'application appelante utilise un compte de service comme identité, les comptes principaux suivants sont impliqués :

Compte de service de l'appelant (CALLER_SA)

Ce compte de service représente l'application appelante, qui émet la requête de création d'identifiants éphémères.
Compte de service avec privilège (PRIV_SA)

Ce compte de service se voit attribuer les rôles IAM requis pour le jeton éphémère. Il s'agit du compte de service pour lequel le jeton éphémère est créé.

Accordez le rôle requis sur PRIV_SA :

Console

Dans Google Cloud Console, accédez à la page Comptes de service.

Accéder à la page "Comptes de service"
Sélectionnez un projet.
Cliquez sur l'adresse e-mail du compte de service disposant de privilèges (PRIV_SA).
Cliquez sur l'onglet Autorisations.
Sous Comptes principaux ayant accès à ce compte de service, cliquez sur Accorder l'accès.
Saisissez l'adresse e-mail du compte de service de l'appelant (CALLER_SA).

Par exemple, demo@my-project.iam.gserviceaccount.com.
Sélectionnez le rôle de créateur de jetons du compte de service (roles/iam.serviceAccountTokenCreator).
Cliquez sur Enregistrer pour attribuer le rôle au compte de service.

gcloud

La commande gcloud iam service-accounts add-iam-policy-binding accorde un rôle à un compte de service.

Avant d'utiliser les données de la commande ci-dessous, effectuez les remplacements suivants :

PRIV_SA: l'adresse e-mail du compte de service avec privilège pour lequel le jeton est généré.
CALLER_SA: adresse e-mail du compte de service représentant l'application qui demande le jeton de courte durée.

Exécutez la commande suivante :

Linux, macOS ou Cloud Shell

gcloud iam service-accounts add-iam-policy-binding PRIV_SA \
    --member=serviceAccount:CALLER_SA --role=roles/iam.serviceAccountTokenCreator --format=json

Windows (PowerShell)

gcloud iam service-accounts add-iam-policy-binding PRIV_SA `
    --member=serviceAccount:CALLER_SA --role=roles/iam.serviceAccountTokenCreator --format=json

Windows (cmd.exe)

gcloud iam service-accounts add-iam-policy-binding PRIV_SA ^
    --member=serviceAccount:CALLER_SA --role=roles/iam.serviceAccountTokenCreator --format=json

Vous devriez obtenir un résultat semblable à celui-ci :

Updated IAM policy for serviceAccount [PRIV_SA].
{
  "bindings": [
    {
      "members": [
        "serviceAccount:CALLER_SA"
      ],
      "role": "roles/iam.serviceAccountTokenCreator"
    }
  ],
  "etag": "BwXhCB4eyjY=",
  "version": 1
}

REST

Lisez la règle d'autorisation de PRIV_SA :

La méthode serviceAccounts.getIamPolicy permet d'obtenir la stratégie d'autorisation d'un compte de service.

Avant d'utiliser les données de requête ci-dessous, effectuez les remplacements suivants :
- PROJECT_ID : ID de votre projet Google Cloud. Les ID de projet sont des chaînes alphanumériques, telles que my-project.
- PRIV_SA : adresse e-mail du compte de service avec privilège pour lequel le jeton de courte durée est créé.
- POLICY_VERSION : version de la stratégie à renvoyer. Les requêtes doivent spécifier la version de stratégie la plus récente, qui est la version 3. Pour plus d'informations, consultez la section Spécifier une version de stratégie lors de l'obtention d'une stratégie.
Méthode HTTP et URL :
```
POST https://iam.googleapis.com/v1/projects/PROJECT_ID/serviceAccounts/PRIV_SA:getIamPolicy
```
Corps JSON de la requête :
```
{
  "options": {
    "requestedPolicyVersion": POLICY_VERSION
  }
}
```
Pour envoyer votre requête, développez l'une des options suivantes :
curl (Linux, macOS ou Cloud Shell)

Remarque : La commande suivante suppose que vous êtes connecté à la CLI gcloud avec votre compte utilisateur en exécutant la commande gcloud init ou gcloud auth login, ou en utilisant Cloud Shell, qui vous connecte automatiquement à la CLI gcloud. Vous pouvez exécuter la commande gcloud auth list pour vérifier quel est le compte actuellement actif.

Enregistrez le corps de la requête dans un fichier nommé request.json, puis exécutez la commande suivante :
```
curl -X POST \
     -H "Authorization: Bearer $(gcloud auth print-access-token)" \
     -H "Content-Type: application/json; charset=utf-8" \
     -d @request.json \
     "https://iam.googleapis.com/v1/projects/PROJECT_ID/serviceAccounts/PRIV_SA:getIamPolicy"
```
PowerShell (Windows)

Remarque : La commande suivante suppose que vous vous êtes connecté à la CLI gcloud avec votre compte utilisateur en exécutant la commande gcloud init ou gcloud auth login. Vous pouvez exécuter la commande gcloud auth list pour vérifier quel est le compte actuellement actif.

Enregistrez le corps de la requête dans un fichier nommé request.json, puis exécutez la commande suivante :
```
$cred = gcloud auth print-access-token
$headers = @{ "Authorization" = "Bearer $cred" }

Invoke-WebRequest `
    -Method POST `
    -Headers $headers `
    -ContentType: "application/json; charset=utf-8" `
    -InFile request.json `
    -Uri "https://iam.googleapis.com/v1/projects/PROJECT_ID/serviceAccounts/PRIV_SA:getIamPolicy" | Select-Object -Expand Content
```
APIs Explorer (navigateur)

Copiez le corps de la requête et ouvrez la page de référence de la méthode. Le panneau APIs Explorer s'ouvre dans la partie droite de la page. Vous pouvez interagir avec cet outil pour envoyer des requêtes. Collez le corps de la requête dans cet outil, renseignez tous les champs obligatoires, puis cliquez sur Execute (Exécuter).

Vous devriez recevoir une réponse JSON de ce type :
```
{
  "version": 1,
  "etag": "BwWKmjvelug=",
  "bindings": [
    {
      "role": "roles/serviceAccountAdmin",
      "members": [
        "user:my-user@example.com"
      ]
    }
  ]
}
```
Si vous n'avez attribué aucun rôle au compte de service, la réponse ne contient qu'une valeur etag. Incluez cette valeur etag à l'étape suivante.

Modifiez la règle d'autorisation pour accorder à CALLER_SA le rôle de créateur de jetons du compte de service (roles/iam.serviceAccountTokenCreator).

Par exemple, pour modifier l'exemple de réponse de l'étape précédente, ajoutez ce qui suit :

  {
    "version": 1,
    "etag": "BwWKmjvelug=",
    "bindings": [
      {
        "role": "roles/serviceAccountAdmin",
        "members": [
          "user:my-user@example.com"
        ]
      },
      {
        "role": "roles/iam.serviceAccountTokenCreator",
        "members": [
          "serviceAccount:CALLER_SA"
        ]
      }
    ]
  }

Écrivez la stratégie d'autorisation mise à jour :

La méthode serviceAccounts.setIamPolicy définit une stratégie d'autorisation mise à jour pour le compte de service.

Avant d'utiliser les données de requête ci-dessous, effectuez les remplacements suivants :
- PROJECT_ID : ID de votre projet Google Cloud. Les ID de projet sont des chaînes alphanumériques, telles que my-project.
- PRIV_SA : adresse e-mail du compte de service avec privilège pour lequel le jeton de courte durée est créé.
- POLICY_VERSION : version de la stratégie à renvoyer. Les requêtes doivent spécifier la version de stratégie la plus récente, qui est la version 3. Pour plus d'informations, consultez la section Spécifier une version de stratégie lors de l'obtention d'une stratégie.
- POLICY : représentation JSON de la stratégie que vous souhaitez définir. Pour en savoir plus sur le format d'une stratégie, consultez la documentation de référence sur les stratégies.
  
  Par exemple, pour définir la règle d'autorisation affichée à l'étape précédente, remplacez POLICY par ce qui suit, où CALLER_SA correspond au compte de service créant le jeton de courte durée:
```
{
  "version": 1,
  "etag": "BwWKmjvelug=",
  "bindings": [
    {
      "role": "roles/serviceAccountAdmin",
      "members": [
        "user:my-user@example.com"
      ]
    },
    {
      "role": "roles/iam.serviceAccountTokenCreator",
      "members": [
        "serviceAccount:CALLER_SA"
      ]
    }
  ]
}
```
Méthode HTTP et URL :
```
POST https://iam.googleapis.com/v1/projects/PROJECT_ID/serviceAccounts/PRIV_SA
```
Corps JSON de la requête :
```
{
  "policy": POLICY
}
```
Pour envoyer votre requête, développez l'une des options suivantes :
curl (Linux, macOS ou Cloud Shell)

Enregistrez le corps de la requête dans un fichier nommé request.json, puis exécutez la commande suivante :
```
curl -X POST \
     -H "Authorization: Bearer $(gcloud auth print-access-token)" \
     -H "Content-Type: application/json; charset=utf-8" \
     -d @request.json \
     "https://iam.googleapis.com/v1/projects/PROJECT_ID/serviceAccounts/PRIV_SA"
```
PowerShell (Windows)

Enregistrez le corps de la requête dans un fichier nommé request.json, puis exécutez la commande suivante :
```
$cred = gcloud auth print-access-token
$headers = @{ "Authorization" = "Bearer $cred" }

Invoke-WebRequest `
    -Method POST `
    -Headers $headers `
    -ContentType: "application/json; charset=utf-8" `
    -InFile request.json `
    -Uri "https://iam.googleapis.com/v1/projects/PROJECT_ID/serviceAccounts/PRIV_SA" | Select-Object -Expand Content
```
APIs Explorer (navigateur)

Copiez le corps de la requête et ouvrez la page de référence de la méthode. Le panneau APIs Explorer s'ouvre dans la partie droite de la page. Vous pouvez interagir avec cet outil pour envoyer des requêtes. Collez le corps de la requête dans cet outil, renseignez tous les champs obligatoires, puis cliquez sur Execute (Exécuter).

La réponse contient la stratégie d'autorisation mise à jour.

Remarque : Si vous traitez les stratégies d'autorisation comme du code et que vous les stockez dans un système de contrôle des versions, vous devez stocker la stratégie qui est renvoyée, et non celle que vous avez envoyée dans la requête.

Identifiants utilisateur

Lorsque vous utilisez un compte utilisateur pour générer des jetons de éphémères, les identités suivantes sont impliquées :

Compte de l'appelant (CALLER_ACCOUNT)

Ce compte utilisateur permet de générer des identifiants éphémères pour le compte de service disposant de privilèges.
Compte de service avec privilège (PRIV_SA)

Ce compte de service se voit attribuer les rôles IAM requis pour le jeton éphémère. Il s'agit du compte de service pour lequel le jeton éphémère est créé.

Accordez le rôle requis sur PRIV_SA :

Console

Dans Google Cloud Console, accédez à la page Comptes de service.

Accéder à la page "Comptes de service"
Sélectionnez un projet.
Cliquez sur l'adresse e-mail du compte de service disposant de privilèges (PRIV_SA).
Cliquez sur l'onglet Autorisations.
Sous Comptes principaux ayant accès à ce compte de service, cliquez sur Accorder l'accès.
Saisissez l'identifiant principal du compte appelant, CALLER_ACCOUNT.

Par exemple, example-user@example.com.
Sélectionnez le rôle de créateur de jetons du compte de service (roles/iam.serviceAccountTokenCreator).
Cliquez sur Enregistrer pour attribuer le rôle au compte utilisateur.

gcloud

La commande gcloud iam service-accounts add-iam-policy-binding accorde un rôle à un compte de service.

Avant d'utiliser les données de la commande ci-dessous, effectuez les remplacements suivants :

PRIV_SA: l'adresse e-mail du compte de service avec privilège pour lequel le jeton est généré.
CALLER_ACCOUNT: adresse e-mail du compte utilisateur utilisé pour demander le jeton de courte durée.

Exécutez la commande suivante :

Linux, macOS ou Cloud Shell

gcloud iam service-accounts add-iam-policy-binding PRIV_SA \
    --member=user:CALLER_ACCOUNT --role=roles/iam.serviceAccountTokenCreator --format=json

Windows (PowerShell)

gcloud iam service-accounts add-iam-policy-binding PRIV_SA `
    --member=user:CALLER_ACCOUNT --role=roles/iam.serviceAccountTokenCreator --format=json

Windows (cmd.exe)

gcloud iam service-accounts add-iam-policy-binding PRIV_SA ^
    --member=user:CALLER_ACCOUNT --role=roles/iam.serviceAccountTokenCreator --format=json

Vous devriez obtenir un résultat semblable à celui-ci :

Updated IAM policy for serviceAccount [PRIV_SA].
{
  "bindings": [
    {
      "members": [
        "user:my-user@example.com"
      ],
      "role": "roles/iam.serviceAccountTokenCreator"
    }
  ],
  "etag": "BwX1ZbefjXU=",
  "version": 1
}

REST

Lisez la règle d'autorisation de PRIV_SA :

La méthode serviceAccounts.getIamPolicy permet d'obtenir la stratégie d'autorisation d'un compte de service.

Avant d'utiliser les données de requête ci-dessous, effectuez les remplacements suivants :
- PROJECT_ID : ID de votre projet Google Cloud. Les ID de projet sont des chaînes alphanumériques, telles que my-project.
- PRIV_SA : adresse e-mail du compte de service avec privilège pour lequel le jeton de courte durée est créé.
- POLICY_VERSION : version de la stratégie à renvoyer. Les requêtes doivent spécifier la version de stratégie la plus récente, qui est la version 3. Pour plus d'informations, consultez la section Spécifier une version de stratégie lors de l'obtention d'une stratégie.
Méthode HTTP et URL :
```
POST https://iam.googleapis.com/v1/projects/PROJECT_ID/serviceAccounts/PRIV_SA:getIamPolicy
```
Corps JSON de la requête :
```
{
  "options": {
    "requestedPolicyVersion": POLICY_VERSION
  }
}
```
Pour envoyer votre requête, développez l'une des options suivantes :
curl (Linux, macOS ou Cloud Shell)

Remarque : La commande suivante suppose que vous êtes connecté à la CLI gcloud avec votre compte utilisateur en exécutant la commande gcloud init ou gcloud auth login, ou en utilisant Cloud Shell, qui vous connecte automatiquement à la CLI gcloud. Vous pouvez exécuter la commande gcloud auth list pour vérifier quel est le compte actuellement actif.

Enregistrez le corps de la requête dans un fichier nommé request.json, puis exécutez la commande suivante :
```
curl -X POST \
     -H "Authorization: Bearer $(gcloud auth print-access-token)" \
     -H "Content-Type: application/json; charset=utf-8" \
     -d @request.json \
     "https://iam.googleapis.com/v1/projects/PROJECT_ID/serviceAccounts/PRIV_SA:getIamPolicy"
```
PowerShell (Windows)

Remarque : La commande suivante suppose que vous vous êtes connecté à la CLI gcloud avec votre compte utilisateur en exécutant la commande gcloud init ou gcloud auth login. Vous pouvez exécuter la commande gcloud auth list pour vérifier quel est le compte actuellement actif.

Enregistrez le corps de la requête dans un fichier nommé request.json, puis exécutez la commande suivante :
```
$cred = gcloud auth print-access-token
$headers = @{ "Authorization" = "Bearer $cred" }

Invoke-WebRequest `
    -Method POST `
    -Headers $headers `
    -ContentType: "application/json; charset=utf-8" `
    -InFile request.json `
    -Uri "https://iam.googleapis.com/v1/projects/PROJECT_ID/serviceAccounts/PRIV_SA:getIamPolicy" | Select-Object -Expand Content
```
APIs Explorer (navigateur)

Copiez le corps de la requête et ouvrez la page de référence de la méthode. Le panneau APIs Explorer s'ouvre dans la partie droite de la page. Vous pouvez interagir avec cet outil pour envoyer des requêtes. Collez le corps de la requête dans cet outil, renseignez tous les champs obligatoires, puis cliquez sur Execute (Exécuter).

Vous devriez recevoir une réponse JSON de ce type :
```
{
  "version": 1,
  "etag": "BwWKmjvelug=",
  "bindings": [
    {
      "role": "roles/serviceAccountAdmin",
      "members": [
        "user:my-user@example.com"
      ]
    }
  ]
}
```
Si vous n'avez attribué aucun rôle au compte de service, la réponse ne contient qu'une valeur etag. Incluez cette valeur etag à l'étape suivante.

Modifiez la règle d'autorisation pour accorder à CALLER_ACCOUNT le rôle de créateur de jetons du compte de service (roles/iam.serviceAccountTokenCreator).

Par exemple, pour modifier l'exemple de réponse de l'étape précédente, ajoutez ce qui suit :

{
  "version": 1,
  "etag": "BwWKmjvelug=",
  "bindings": [
    {
      "role": "roles/serviceAccountAdmin",
      "members": [
        "user:my-user@example.com"
      ]
    },
    {
      "role": "roles/iam.serviceAccountTokenCreator",
      "members": [
        "user:my-user@example.com"
      ]
    }
  ]
}

Écrivez la stratégie d'autorisation mise à jour :

La méthode serviceAccounts.setIamPolicy définit une stratégie d'autorisation mise à jour pour le compte de service.

Avant d'utiliser les données de requête ci-dessous, effectuez les remplacements suivants :
- PROJECT_ID : ID de votre projet Google Cloud. Les ID de projet sont des chaînes alphanumériques, telles que my-project.
- PRIV_SA : adresse e-mail du compte de service avec privilège pour lequel le jeton de courte durée est créé.
- POLICY_VERSION : version de la stratégie à renvoyer. Les requêtes doivent spécifier la version de stratégie la plus récente, qui est la version 3. Pour plus d'informations, consultez la section Spécifier une version de stratégie lors de l'obtention d'une stratégie.
- POLICY : représentation JSON de la stratégie que vous souhaitez définir. Pour en savoir plus sur le format d'une stratégie, consultez la documentation de référence sur les stratégies.
  
  Par exemple, pour définir la règle d'autorisation affichée à l'étape précédente, remplacez POLICY par ce qui suit, où CALLER_ACCOUNT correspond au compte utilisateur créant le jeton de courte durée :
```
{
  "version": 1,
  "etag": "BwWKmjvelug=",
  "bindings": [
    {
      "role": "roles/serviceAccountAdmin",
      "members": [
        "user:my-user@example.com"
      ]
    },
    {
      "role": "roles/iam.serviceAccountTokenCreator",
      "members": [
        "CALLER_ACCOUNT"
      ]
    }
  ]
}
```
Méthode HTTP et URL :
```
POST https://iam.googleapis.com/v1/projects/PROJECT_ID/serviceAccounts/PRIV_SA
```
Corps JSON de la requête :
```
{
  "policy": POLICY
}
```
Pour envoyer votre requête, développez l'une des options suivantes :
curl (Linux, macOS ou Cloud Shell)

Enregistrez le corps de la requête dans un fichier nommé request.json, puis exécutez la commande suivante :
```
curl -X POST \
     -H "Authorization: Bearer $(gcloud auth print-access-token)" \
     -H "Content-Type: application/json; charset=utf-8" \
     -d @request.json \
     "https://iam.googleapis.com/v1/projects/PROJECT_ID/serviceAccounts/PRIV_SA"
```
PowerShell (Windows)

Enregistrez le corps de la requête dans un fichier nommé request.json, puis exécutez la commande suivante :
```
$cred = gcloud auth print-access-token
$headers = @{ "Authorization" = "Bearer $cred" }

Invoke-WebRequest `
    -Method POST `
    -Headers $headers `
    -ContentType: "application/json; charset=utf-8" `
    -InFile request.json `
    -Uri "https://iam.googleapis.com/v1/projects/PROJECT_ID/serviceAccounts/PRIV_SA" | Select-Object -Expand Content
```
APIs Explorer (navigateur)

Copiez le corps de la requête et ouvrez la page de référence de la méthode. Le panneau APIs Explorer s'ouvre dans la partie droite de la page. Vous pouvez interagir avec cet outil pour envoyer des requêtes. Collez le corps de la requête dans cet outil, renseignez tous les champs obligatoires, puis cliquez sur Execute (Exécuter).

La réponse contient la stratégie d'autorisation mise à jour.

Remarque : Si vous traitez les stratégies d'autorisation comme du code et que vous les stockez dans un système de contrôle des versions, vous devez stocker la stratégie qui est renvoyée, et non celle que vous avez envoyée dans la requête.

Générer le blob autosigné

Générez un blob autosigné pour le compte de service:

REST

La méthode serviceAccounts.signBlob de l'API Service Account Credentials signe un blob à l'aide de la clé privée gérée par le système d'un compte de service.

Avant d'utiliser les données de requête ci-dessous, effectuez les remplacements suivants :

PRIV_SA : adresse e-mail du compte de service avec privilège pour lequel le jeton de courte durée est créé.
BLOB_PAYLOAD : chaîne d'octets encodée en base64. Exemple : VGhlIHF1aWNrIGJyb3duIGZveCBqdW1wZWQgb3ZlciB0aGUgbGF6eSBkb2cu.

Méthode HTTP et URL :

POST https://iamcredentials.googleapis.com/v1/projects/-/serviceAccounts/PRIV_SA:signBlob

Corps JSON de la requête :

{
  "payload": "BLOB_PAYLOAD"
}

Pour envoyer votre requête, développez l'une des options suivantes :

curl (Linux, macOS ou Cloud Shell)

Enregistrez le corps de la requête dans un fichier nommé request.json, puis exécutez la commande suivante :

curl -X POST \
     -H "Authorization: Bearer $(gcloud auth print-access-token)" \
     -H "Content-Type: application/json; charset=utf-8" \
     -d @request.json \
     "https://iamcredentials.googleapis.com/v1/projects/-/serviceAccounts/PRIV_SA:signBlob"

PowerShell (Windows)

Enregistrez le corps de la requête dans un fichier nommé request.json, puis exécutez la commande suivante :

$cred = gcloud auth print-access-token
$headers = @{ "Authorization" = "Bearer $cred" }

Invoke-WebRequest `
    -Method POST `
    -Headers $headers `
    -ContentType: "application/json; charset=utf-8" `
    -InFile request.json `
    -Uri "https://iamcredentials.googleapis.com/v1/projects/-/serviceAccounts/PRIV_SA:signBlob" | Select-Object -Expand Content

APIs Explorer (navigateur)

Si la requête signBlob a abouti, le corps de la réponse contient un blob signé, ainsi que l'ID de clé de signature utilisé pour signer ce blob. Vous pouvez utiliser la valeur signedBlob en tant que jeton de support pour authentifier directement une requête émise au nom du compte de service. Le jeton est valide jusqu'à l'expiration de la clé privée gérée par le système d'un compte de service. L'ID de cette clé correspond à la valeur du champ keyId dans la réponse.

{
  "keyId": "42ba1e...fc0a",
  "signedBlob": "eyJ0eXAi...NiJ9"
}