Obtenir un jeton d'ID

Cette page décrit plusieurs façons d'obtenir un jeton d'identification OpenID Connect (OIDC) signé par Google.

Pour en savoir plus sur le contenu et la durée de vie des jetons d'ID, consultez la section Jetons d'ID.

Les jetons d'ID ont un service ou une application spécifique pour lesquels ils peuvent être utilisés, spécifiés par la valeur de leur revendication aud. Cette page utilise le terme service cible pour désigner le service ou l'application auxquels le jeton d'ID peut être utilisé pour s'authentifier.

Lorsque vous obtenez le jeton d'ID, vous pouvez l'inclure dans un en-tête Authorization de la requête adressée au service cible.

Méthodes permettant d'obtenir un jeton d'ID

Il existe différentes manières d'obtenir un jeton d'ID. Cette page décrit les méthodes suivantes :

Si vous avez besoin qu'un jeton d'ID soit accepté par une application non hébergée surTrusted Cloud, vous pouvez probablement utiliser ces méthodes. Toutefois, vous devez déterminer quelles sont les revendications de jeton d'ID requises par l'application.

Obtenir un jeton d'ID à partir du serveur de métadonnées

Lorsque votre code est exécuté sur une ressource à laquelle un compte de service est associé, le serveur de métadonnées du service associé peut généralement fournir un jeton d'ID. Le serveur de métadonnées génère des jetons d'ID pour le compte de service associé. Vous ne pouvez pas obtenir de jeton d'ID en fonction des identifiants utilisateur à partir du serveur de métadonnées.

Vous pouvez obtenir un jeton d'ID à partir du serveur de métadonnées lorsque votre code s'exécute sur les services Trusted Cloud suivants :

Pour récupérer un jeton d'ID à partir du serveur de métadonnées, vous interrogez le point de terminaison de l'identité du compte de service, comme indiqué dans cet exemple.

curl

Remplacez AUDIENCE par l'URI du service cible, par exemple http://www.example.com.

curl -H "Metadata-Flavor: Google" \
  'http://metadata/computeMetadata/v1/instance/service-accounts/default/identity?audience=AUDIENCE'

PowerShell

Remplacez AUDIENCE par l'URI du service cible, par exemple http://www.example.com.

$value = (Invoke-RestMethod `
  -Headers @{'Metadata-Flavor' = 'Google'} `
  -Uri "http://metadata/computeMetadata/v1/instance/service-accounts/default/identity?audience=AUDIENCE")
$value

Java

Pour exécuter cet exemple de code, vous devez d'abord effectuer les étapes suivantes :


import com.google.auth.oauth2.GoogleCredentials;
import com.google.auth.oauth2.IdTokenCredentials;
import com.google.auth.oauth2.IdTokenProvider;
import com.google.auth.oauth2.IdTokenProvider.Option;
import java.io.IOException;
import java.security.GeneralSecurityException;
import java.util.Arrays;

public class IdTokenFromMetadataServer {

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

    // The url or target audience to obtain the ID token for.
    String url = "https://example.com";

    getIdTokenFromMetadataServer(url);
  }

  // Use the Google Cloud metadata server to create an identity token and add it to the
  // HTTP request as part of an Authorization header.
  public static void getIdTokenFromMetadataServer(String url) throws IOException {
    // Construct the GoogleCredentials object which obtains the default configuration from your
    // working environment.
    GoogleCredentials googleCredentials = GoogleCredentials.getApplicationDefault();

    IdTokenCredentials idTokenCredentials =
        IdTokenCredentials.newBuilder()
            .setIdTokenProvider((IdTokenProvider) googleCredentials)
            .setTargetAudience(url)
            // Setting the ID token options.
            .setOptions(Arrays.asList(Option.FORMAT_FULL, Option.LICENSES_TRUE))
            .build();

    // Get the ID token.
    // Once you've obtained the ID token, you can use it to make an authenticated call to the
    // target audience.
    String idToken = idTokenCredentials.refreshAccessToken().getTokenValue();
    System.out.println("Generated ID token.");
  }
}

Go

Avant d'exécuter des exemples de code, définissez la variable d'environnement GOOGLE_CLOUD_UNIVERSE_DOMAIN sur s3nsapis.fr. 

import (
	"context"
	"fmt"
	"io"

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

// getIdTokenFromMetadataServer uses the Google Cloud metadata server environment
// to create an identity token and add it to the HTTP request as part of an Authorization header.
func getIdTokenFromMetadataServer(w io.Writer, url string) error {
	// url := "http://www.example.com"

	ctx := context.Background()

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

	ts, err := idtoken.NewTokenSource(ctx, url, option.WithCredentials(credentials))
	if err != nil {
		return fmt.Errorf("failed to create NewTokenSource: %w", err)
	}

	// Get the ID token.
	// Once you've obtained the ID token, you can use it to make an authenticated call
	// to the target audience.
	_, err = ts.Token()
	if err != nil {
		return fmt.Errorf("failed to receive token: %w", err)
	}
	fmt.Fprintf(w, "Generated ID token.\n")

	return nil
}

Node.js

Pour exécuter cet exemple de code, vous devez d'abord effectuer les étapes suivantes : 

/**
 * TODO(developer):
 *  1. Uncomment and replace these variables before running the sample.
 */
// const targetAudience = 'http://www.example.com';

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

async function getIdTokenFromMetadataServer() {
  const googleAuth = new GoogleAuth();

  const client = await googleAuth.getIdTokenClient(targetAudience);

  // Get the ID token.
  // Once you've obtained the ID token, you can use it to make an authenticated call
  // to the target audience.
  await client.idTokenProvider.fetchIdToken(targetAudience);
  console.log('Generated ID token.');
}

getIdTokenFromMetadataServer();

Python

Pour exécuter cet exemple de code, vous devez d'abord effectuer les étapes suivantes : 


import google
import google.oauth2.credentials
from google.auth import compute_engine
import google.auth.transport.requests


def idtoken_from_metadata_server(url: str):
    """
    Use the Google Cloud metadata server in the Cloud Run (or AppEngine or Kubernetes etc.,)
    environment to create an identity token and add it to the HTTP request as part of an
    Authorization header.

    Args:
        url: The url or target audience to obtain the ID token for.
            Examples: http://www.example.com
    """

    request = google.auth.transport.requests.Request()
    # Set the target audience.
    # Setting "use_metadata_identity_endpoint" to "True" will make the request use the default application
    # credentials. Optionally, you can also specify a specific service account to use by mentioning
    # the service_account_email.
    credentials = compute_engine.IDTokenCredentials(
        request=request, target_audience=url, use_metadata_identity_endpoint=True
    )

    # Get the ID token.
    # Once you've obtained the ID token, use it to make an authenticated call
    # to the target audience.
    credentials.refresh(request)
    # print(credentials.token)
    print("Generated ID token.")

Ruby

Pour exécuter cet exemple de code, vous devez d'abord effectuer les étapes suivantes : 

require "googleauth"

##
# Uses the Google Cloud metadata server environment to create an identity token
# and add it to the HTTP request as part of an Authorization header.
#
# @param url [String] The url or target audience to obtain the ID token for
#   (e.g. "http://www.example.com")
#
def auth_cloud_idtoken_metadata_server url:
  # Create the GCECredentials client.
  id_client = Google::Auth::GCECredentials.new target_audience: url

  # Get the ID token.
  # Once you've obtained the ID token, you can use it to make an authenticated call
  # to the target audience.
  id_client.fetch_access_token
  puts "Generated ID token."

  id_client.refresh!
end

Utiliser un service de connexion pour générer un jeton d'ID

Certains Trusted Cloud services vous aident à appeler d'autres services. Ces services de connexion peuvent vous aider à déterminer quand l'appel est effectué ou à gérer un workflow incluant l'appel du service. Les services suivants peuvent automatiquement inclure un jeton d'ID, avec la valeur appropriée pour la revendication aud, lorsqu'ils appellent un service nécessitant un jeton d'ID :

Pub/Sub
Pub/Sub permet la communication asynchrone entre les services. Vous pouvez configurer Pub/Sub de façon à inclure un jeton d'ID avec un message. Pour en savoir plus, consultez la section Authentification pour les abonnements push.

Générer un jeton d'ID en empruntant l'identité d'un compte de service

Emprunter l'identité d'un compte de service permet à un compte principal de générer des identifiants éphémères pour un compte de service approuvé. Le compte principal peut ensuite utiliser ces identifiants pour s'authentifier en tant que compte de service.

Pour qu'un compte principal puisse emprunter l'identité d'un compte de service, il doit disposer d'un rôle IAM permettant d'emprunter une identité sur ce compte de service. Si le compte principal est lui-même un autre compte de service, il peut sembler plus simple de fournir les autorisations requises directement à ce compte de service et de lui permettre d'emprunter une identité. Cette configuration, appelée "auto-emprunt d'identité", crée une faille de sécurité, car elle permet au compte de service de créer un jeton d'accès pouvant être actualisé à l'infini.

L'emprunt d'identité d'un compte de service doit toujours impliquer deux comptes principaux : le compte principal qui représente l'appelant, et le compte de service dont l'identité est empruntée, appelé compte de service porteur de privilèges.

Vous pouvez appliquer le processus général suivant pour générer un jeton d'ID en empruntant l'identité d'un compte de service.

Pour obtenir des instructions détaillées, consultez la section Créer un jeton d'ID.

  1. Identifiez ou créez un compte de service en tant que compte de service avec privilège.

  2. Consultez la documentation du produit afin d'identifier les rôles requis pour appeler le service cible. Attribuez ces rôles au compte de service sur le service cible.

  3. Identifiez le compte principal qui effectuera l'emprunt d'identité et configurez les ADC (Identifiants par défaut de l'application) pour utiliser les identifiants de ce compte principal.

    Pour les environnements de développement, le compte principal est généralement le compte utilisateur que vous avez fourni aux ADC en utilisant gcloud CLI. Toutefois, si l'exécution se déroule sur une ressource à laquelle un compte de service est associé, le compte de service associé est le compte principal.

  4. Attribuez au compte principal le rôle "Créateur de jetons d'identité OpenID Connect du compte de service" (roles/iam.serviceAccountOpenIdTokenCreator).

  5. Utilisez l'API IAM Credentials pour générer le jeton d'ID pour le compte de service autorisé.

    Remplacez les éléments suivants :

    • AUDIENCE : URI du service cible (par exemple, http://www.example.com).
    • SERVICE_ACCOUNT_EMAIL : adresse e-mail du compte de service avec privilège.
    curl -X POST \
-H "Authorization: Bearer $(gcloud auth print-access-token)" \
-H "Content-Type: application/json" \
-d '{"audience": "AUDIENCE", "includeEmail": "true"}' \
https://iamcredentials.googleapis.com/v1/projects/-/serviceAccounts/SERVICE_ACCOUNT_EMAIL:generateIdToken

Étapes suivantes