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

Vérifiez que la facturation est activée pour votre projet Google Cloud.
Activer les API IAM and Service Account Credentials :
```
gcloud services enable iam.googleapis.com iamcredentials.googleapis.com
```
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 en tant que compte Google.

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 s'exécutant 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 gcloud auth list pour vérifier 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 ê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 gcloud auth list pour vérifier 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
```
Explorateur d'API (navigateur)

Copiez le corps de la requête et ouvrez la page de référence de la méthode. Le panneau de l'explorateur d'API 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:admin@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:admin@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:admin@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
```
Explorateur d'API (navigateur)

Copiez le corps de la requête et ouvrez la page de référence de la méthode. Le panneau de l'explorateur d'API 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 Google.

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

Compte Google 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'adresse e-mail du compte Google de l'appelant (CALLER_ACCOUNT).

Par exemple, username@google.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:CALLER_ACCOUNT"
      ],
      "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 gcloud auth list pour vérifier 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 ê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 gcloud auth list pour vérifier 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
```
Explorateur d'API (navigateur)

Copiez le corps de la requête et ouvrez la page de référence de la méthode. Le panneau de l'explorateur d'API 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:admin@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:admin@example.com"
      ]
    },
    {
      "role": "roles/iam.serviceAccountTokenCreator",
      "members": [
        "user:CALLER_ACCOUNT"
      ]
    }
  ]
}

É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:admin@example.com"
      ]
    },
    {
      "role": "roles/iam.serviceAccountTokenCreator",
      "members": [
        "user: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
```
Explorateur d'API (navigateur)

Copiez le corps de la requête et ouvrez la page de référence de la méthode. Le panneau de l'explorateur d'API 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. La CLI Google Cloud 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

Connectez-vous à la CLI Google Cloud en tant que compte Google appelant.
```
gcloud auth login CALLER_ACCOUNT
```

Générez un jeton pour le compte de service.

La commande gcloud auth print-access-token génère un jeton d'accès OAuth 2.0 pour un compte de service.

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. 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 gcloud auth list pour vérifier 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)

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

Explorateur d'API (navigateur)

Copiez le corps de la requête et ouvrez la page de référence de la méthode. Le panneau de l'explorateur d'API 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"
}

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 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 gcloud auth list pour vérifier 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 ê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 gcloud auth list pour vérifier 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
```
Explorateur d'API (navigateur)

Copiez le corps de la requête et ouvrez la page de référence de la méthode. Le panneau de l'explorateur d'API 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:admin@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:admin@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:admin@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
```
Explorateur d'API (navigateur)

Copiez le corps de la requête et ouvrez la page de référence de la méthode. Le panneau de l'explorateur d'API 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 Google 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'adresse e-mail du compte Google de l'appelant (CALLER_ACCOUNT).

Par exemple, username@google.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:CALLER_ACCOUNT"
      ],
      "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 gcloud auth list pour vérifier 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 ê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 gcloud auth list pour vérifier 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
```
Explorateur d'API (navigateur)

Copiez le corps de la requête et ouvrez la page de référence de la méthode. Le panneau de l'explorateur d'API 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:admin@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:admin@example.com"
      ]
    },
    {
      "role": "roles/iam.serviceAccountOpenIdTokenCreator",
      "members": [
        "user:CALLER_ACCOUNT"
      ]
    }
  ]
}

É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:admin@example.com"
      ]
    },
    {
      "role": "roles/iam.serviceAccountOpenIdTokenCreator",
      "members": [
        "user: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
```
Explorateur d'API (navigateur)

Copiez le corps de la requête et ouvrez la page de référence de la méthode. Le panneau de l'explorateur d'API 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

Connectez-vous à la CLI Google Cloud en tant que compte Google appelant.
```
gcloud auth login CALLER_ACCOUNT
```

Générez un jeton pour le compte de service.

La commande gcloud auth print-identity-token génère un jeton d'ID OIDC pour un compte de service.

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

Explorateur d'API (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 :

Authentification auprès d'une API déployée avec l'API Gateway.
Authentification d'un appel à une API Google, comme indiqué dans le guide d'authentification Google.
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.
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 gcloud auth list pour vérifier 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 ê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 gcloud auth list pour vérifier 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
```
Explorateur d'API (navigateur)

Copiez le corps de la requête et ouvrez la page de référence de la méthode. Le panneau de l'explorateur d'API 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:admin@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:admin@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:admin@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
```
Explorateur d'API (navigateur)

Copiez le corps de la requête et ouvrez la page de référence de la méthode. Le panneau de l'explorateur d'API 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 Google 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'adresse e-mail du compte Google de l'appelant (CALLER_ACCOUNT).

Par exemple, username@google.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:CALLER_ACCOUNT"
      ],
      "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 gcloud auth list pour vérifier 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 ê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 gcloud auth list pour vérifier 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
```
Explorateur d'API (navigateur)

Copiez le corps de la requête et ouvrez la page de référence de la méthode. Le panneau de l'explorateur d'API 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:admin@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:admin@example.com"
      ]
    },
    {
      "role": "roles/iam.serviceAccountTokenCreator",
      "members": [
        "user:CALLER_ACCOUNT"
      ]
    }
  ]
}

É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:admin@example.com"
      ]
    },
    {
      "role": "roles/iam.serviceAccountTokenCreator",
      "members": [
        "user: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
```
Explorateur d'API (navigateur)

Copiez le corps de la requête et ouvrez la page de référence de la méthode. Le panneau de l'explorateur d'API 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

Explorateur d'API (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 gcloud auth list pour vérifier 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 ê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 gcloud auth list pour vérifier 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
```
Explorateur d'API (navigateur)

Copiez le corps de la requête et ouvrez la page de référence de la méthode. Le panneau de l'explorateur d'API 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:admin@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:admin@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:admin@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
```
Explorateur d'API (navigateur)

Copiez le corps de la requête et ouvrez la page de référence de la méthode. Le panneau de l'explorateur d'API 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 Google 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'adresse e-mail du compte Google de l'appelant (CALLER_ACCOUNT).

Par exemple, username@google.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:CALLER_ACCOUNT"
      ],
      "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 gcloud auth list pour vérifier 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 ê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 gcloud auth list pour vérifier 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
```
Explorateur d'API (navigateur)

Copiez le corps de la requête et ouvrez la page de référence de la méthode. Le panneau de l'explorateur d'API 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:admin@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:admin@example.com"
      ]
    },
    {
      "role": "roles/iam.serviceAccountTokenCreator",
      "members": [
        "user:CALLER_ACCOUNT"
      ]
    }
  ]
}

É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:admin@example.com"
      ]
    },
    {
      "role": "roles/iam.serviceAccountTokenCreator",
      "members": [
        "user: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
```
Explorateur d'API (navigateur)

Copiez le corps de la requête et ouvrez la page de référence de la méthode. Le panneau de l'explorateur d'API 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

Explorateur d'API (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"
}