Cette page a été traduite par l'API Cloud Translation.

Authentification automatisée

Cette page explique comment s'authentifier auprès d'Identity-Aware Proxy (IAP) sécurisée d'un compte utilisateur ou de service géré.

Un compte utilisateur appartient à un utilisateur individuel. Vous authentifiez un compte utilisateur lorsque votre application doit accéder à des ressources sécurisées par IAP au nom d'un utilisateur. Pour plus plus d'informations, consultez l'article Comptes utilisateur.
Un compte de service appartient à une application et non à un utilisateur individuel. Vous authentifiez un compte de service lorsque vous souhaitez autoriser une application à accéder à vos ressources sécurisées par IAP. Pour en savoir plus, consultez la page Comptes de service.

Avant de commencer

Avant de commencer, vous aurez besoin des éléments suivants :

Une application sécurisée par IAP vers laquelle vous souhaitez se connecter de manière programmatique à l'aide d'un compte de développeur, d'un compte de service ou identifiants de l'application.

Authentifier un compte utilisateur

Vous pouvez activer l'accès des utilisateurs à votre application depuis une application mobile ou de bureau afin de permettre à un programme d'interagir avec une ressource sécurisée par IAP.

Authentification à partir d'une application mobile

Créez ou utilisez un ID client OAuth 2.0 existant pour votre application mobile. Pour utiliser un ID client OAuth 2.0 existant, suivez la procédure décrite dans Partager des clients OAuth.
Ajoutez l'ID client OAuth à la liste d'autorisation pour l'accès programmatique de l'application.
Obtenez un jeton d'ID pour l'ID client sécurisé par IAP.
- Android : demandez un jeton OpenID Connect (OIDC) à l'aide de l'API Google Sign-In. Définissez l'ID client requestIdToken sur celui de la ressource à laquelle vous vous connectez.
- iOS : utilisez Google Sign-In pour obtenir un jeton d'ID.
Incluez le jeton d'ID dans un en-tête Authorization: Bearer pour envoyer la requête authentifiée à la ressource sécurisée par IAP.

Authentification à partir d'une application de bureau

Cette section décrit comment authentifier un compte utilisateur à partir d'une ligne de commande d'ordinateur de bureau.

Pour permettre aux développeurs d'accéder à votre application à partir de la ligne de commande, créez un ID client OAuth 2.0 pour ordinateur ou partagez un ID client OAuth de bureau existant.
Ajoutez l'ID client OAuth à la liste d'autorisation pour l'accès programmatique de l'application.

Se connecter à l'application

Chaque développeur qui souhaite accéder à une application sécurisée par IAP vous devez d'abord vous connecter. Vous pouvez intégrer le processus dans un script, par exemple à l'aide de la CLI gcloud. Voici un exemple montrant comment se connecter et générer un jeton pour accéder à l'application avec curl :

Connectez-vous à votre compte ayant accès à la ressource Google Cloud.
Démarrez un serveur local capable d'échouer les requêtes entrantes.
```
    $ nc -k -l 4444
    
```
REMARQUE: La commande utilise l'utilitaire NetCat. Vous pouvez utiliser l'utilitaire de votre choix.

Accédez à l'URI suivant, où DESKTOP_CLIENT_ID correspond à l'ID client de l'application de bureau :

https://accounts.google.com/o/oauth2/v2/auth?client_id=DESKTOP_CLIENT_ID&response_type=code&scope=openid%20email&access_type=offline&redirect_uri=http://localhost:4444&cred_ref=true

Dans la sortie du serveur local, recherchez les paramètres de la requête. Vous devriez voir quelque chose comme ceci: GET /?code=$CODE&scope=email%20openid%20https://www.googleapis.com/auth/userinfo.email&hd=google.com&prompt=consent HTTP/1.1 copiez le code CODE pour le remplacer AUTH_CODE ci-dessous avec l'ID client et le code secret de l'application de bureau:
```
curl --verbose \
      --data client_id=DESKTOP_CLIENT_ID \
      --data client_secret=DESKTOP_CLIENT_SECRET \
      --data code=AUTH_CODE \
      --data redirect_uri=http://localhost:4444 \
      --data grant_type=authorization_code \
      https://oauth2.googleapis.com/token
```
Ce code renvoie un objet JSON avec une id_token : que vous pouvez utiliser pour accéder à l'application.

Accéder à l'application

Pour accéder à l'application, utilisez le champ id_token comme suit :

curl --verbose --header 'Authorization: Bearer ID_TOKEN' URL

Jeton d'actualisation

Vous pouvez utiliser le jeton d'actualisation généré lors du processus de connexion pour obtenir de nouveaux jetons d'identification. Cela est utile lorsque le jeton d'ID d'origine expire. Chaque ID est valide pendant environ une heure. Pendant ce temps, vous pouvez définir plusieurs à une application spécifique.

Voici un exemple dans lequel curl utilise le jeton d'actualisation pour obtenir un nouvel ID à partir d'un jeton d'accès. Dans l'exemple suivant, REFRESH_TOKEN correspond au jeton du flux de connexion. DESKTOP_CLIENT_ID et DESKTOP_CLIENT_SECRET sont les mêmes que ceux utilisés dans le flux de connexion :

curl --verbose \
--data client_id=DESKTOP_CLIENT_ID \
--data client_secret=DESKTOP_CLIENT_SECRET \
--data refresh_token=REFRESH_TOKEN \
--data grant_type=refresh_token \
https://oauth2.googleapis.com/token

Ce code renvoie un objet JSON avec un nouveau id_token que vous pouvez utiliser pour accéder à l'application.

Authentifier un compte de service

Vous pouvez utiliser un jeton JWT de compte de service. ou un OpenID Connect (OIDC) pour authentifier un compte de service Ressource sécurisée par IAP. Le tableau suivant décrit certaines des différences entre les différents jetons d'authentification et leurs fonctionnalités.

Fonctionnalités d'authentification	Jeton JWT du compte de service	Jeton OpenID Connect
Compatibilité avec l'accès contextuel
Exigence concernant l'ID client OAuth 2.0
Champ d'application du jeton	URL de la ressource sécurisée par IAP	ID client OAuth 2.0

S'authentifier avec un jeton JWT d'un compte de service

L'authentification d'un compte de service à l'aide d'un jeton JWT comprend les étapes principales suivantes :

Attribuez au compte de service appelant le rôle Créateur de jetons du compte de service (roles/iam.serviceAccountTokenCreator).

Ce rôle accorde aux comptes principaux l'autorisation de créer des identifiants éphémères, tels que des jetons JWT.
Créez un jeton JWT pour la ressource sécurisée par IAP.
Signez le jeton JWT à l'aide de la clé privée du compte de service.

Créer le jeton JWT

Le jeton JWT créé doit avoir une charge utile semblable à l'exemple suivant:

{
  "iss": SERVICE_ACCOUNT_EMAIL_ADDRESS,
  "sub": SERVICE_ACCOUNT_EMAIL_ADDRESS,
  "aud": TARGET_URL,
  "iat": IAT,
  "exp": EXP,
}

Dans les champs iss et sub, indiquez l'adresse e-mail du compte de service. Elle se trouve dans le champ client_email du fichier JSON du compte de service, ou transmise. Format type : service-account@PROJECT_ID.iam.gserviceaccount.com
Dans le champ aud, indiquez l'URL de la ressource sécurisée par IAP.
Pour le champ iat, spécifiez l'heure actuelle de l'epoch UNIX, et pour le champ exp, spécifiez une heure dans un délai de 3 600 secondes. Ce champ définit la date d'expiration du JWT.

Signer le jeton JWT

Vous pouvez signer le jeton JWT à l'aide de l'une des méthodes suivantes:

Utilisez l'API d'identifiants IAM pour signer un jeton JWT sans avoir à accéder directement à une clé privée.
Utilisez un fichier de clé d'identifiants local pour signer le jeton JWT en local.

Signer le jeton JWT à l'aide de l'API d'identifiants de compte de service IAM

Utilisez l'API d'identifiants de compte de service IAM pour signer un jeton JWT de compte de service. La méthode récupère la clé privée associée à votre compte de service et l'utilise pour signer la charge utile JWT. Cela permet de signer un jeton JWT sans accès direct à une clé privée.

Pour vous authentifier auprès d'IAP, configurez le service Identifiants par défaut de l'application. Pour en savoir plus, consultez Configurer l'authentification pour un environnement de développement local.

gcloud

Exécutez la commande suivante pour préparer une requête avec la charge utile JWT:

cat > claim.json << EOM
{
  "iss": "SERVICE_ACCOUNT_EMAIL_ADDRESS",
  "sub": "SERVICE_ACCOUNT_EMAIL_ADDRESS",
  "aud": "TARGET_URL",
  "iat": $(date +%s),
  "exp": $((`date +%s` + 3600))
}
EOM

Utilisez la commande Google Cloud CLI suivante pour signer la charge utile dans request.json :
```
gcloud iam service-accounts sign-jwt --iam-account=SERVICE_ACCOUNT_EMAIL_ADDRESS claim.json output.jwt
```
Si la requête aboutit, output.jwt contient un jeton JWT signé.
Utilisez le jeton JWT pour accéder à votre ressource sécurisée par IAP.

Python

import datetime
import json

import google.auth
from google.cloud import iam_credentials_v1
import jwt

def generate_jwt_payload(service_account_email: str, resource_url: str) -> str:
  """Generates JWT payload for service account.

  The resource url provided must be the same as the url of the IAP secured resource.

  Args:
    service_account_email (str): Specifies service account JWT is created for.
    resource_url (str): Specifies scope of the JWT, the URL that the JWT will be allowed to access.
  Returns:
    A signed-jwt that can be used to access IAP protected applications.
    Access the application with the JWT in the Authorization Header.
    curl --verbose --header 'Authorization: Bearer SIGNED_JWT' URL
  """
  iat = datetime.datetime.now(tz=datetime.timezone.utc)
  exp = iat + 3600
  return json.dumps({
      'iss': service_account_email,
      'sub': service_account_email,
      'aud': resource_url,
      'iat': iat,
      'exp': exp,
  })

def sign_jwt(target_sa: str, resource_url: str) -> str:
  """Signs JWT payload using ADC and IAM credentials API.

  Args:
    target_sa (str): Service Account JWT is being created for.
      iap.webServiceVersions.accessViaIap permission is required.
    resource_url (str): Audience of the JWT, and scope of the JWT token.
      This is the url of the IAP protected application.
  Returns:
    A signed-jwt that can be used to access IAP protected apps.
  """
  source_credentials, _ = google.auth.default()
  iam_client = iam_credentials_v1.IAMCredentialsClient(credentials=source_credentials)
  return iam_client.sign_jwt(
      name=iam_client.service_account_path('-', target_sa),
      payload=generate_jwt_payload(target_sa, resource_url),
  ).signed_jwt

Si la requête aboutit, le script renvoie un jeton JWT signé. Utilisez le jeton JWT pour accéder à votre ressource sécurisée par IAP.

curl

Exécutez la commande suivante pour préparer une requête avec la charge utile JWT:
```
cat << EOF > request.json
{
  "payload": JWT_PAYLOAD
}
EOF
```

Signez le jeton JWT à l'aide de l'API IAM Service Account Credentials:

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/SERVICE_ACCOUNT_EMAIL_ADDRESS:signJwt"

En cas de requête réussie, un jeton JWT signé est inclus dans la réponse.

Utilisez le jeton JWT pour accéder à votre ressource sécurisée par IAP.

Signer le jeton JWT à partir d'un fichier de clé d'identification local

Les jetons JWT sont signés à l'aide de la clé privée du compte de service.

Si vous disposez d'un fichier de clé de compte de service, le JWT peut être signé localement.

Le script envoie un en-tête JWT avec la charge utile. Pour le kid dans l'en-tête, utilisez l'ID de clé privée du compte de service, qui se trouve Champ private_key_id du fichier JSON contenant les identifiants du compte de service. La clé est également utilisée pour signer le jeton JWT.

Python

import time
import jwt
import json

def generate_jwt_payload(service_account_email, resource_url):
  """Generates JWT payload for service account.

  The resource url provided must be the same as the url of the IAP secured resource.

  Args:
    service_account_email (str): Specifies service account JWT is created for.
    resource_url (str): Specifies scope of the JWT, the URL that the JWT will be allowed to access.
  Returns:
    A signed-jwt that can be used to access IAP protected applications.
    Access the application with the JWT in the Authorization Header.
    curl --verbose --header 'Authorization: Bearer SIGNED_JWT' URL
  """
  iat = datetime.datetime.now(tz=datetime.timezone.utc)
  exp = iat + 3600
  return json.dumps({
      'iss': service_account_email,
      'sub': service_account_email,
      'aud': resource_url,
      'iat': iat,
      'exp': exp,
  })

def sign_jwt_with_key_file(credential_key_file_path, resource_url):
  """Signs JWT payload using local service account credential key file.

  Args:
    credential_key_file_path (str): Path to the downloaded JSON credentials of the service
      account the JWT is being created for.
    resource_url (str): Scope of JWT token, This is the url of the IAP protected application.
  Returns:
    A service account JWT created with a downloaded private key.
  """
  with open(credential_key_file_path, 'r') as credential_key_file:
      key_data = json.load(credential_key_file)

  PRIVATE_KEY_ID_FROM_JSON = key_data["private_key_id"]
  PRIVATE_KEY_FROM_JSON = key_data["private_key"]
  SERVICE_ACCOUNT_EMAIL = key_data["client_email"]

  # Sign JWT with private key and store key id in the header
  additional_headers = {'kid': PRIVATE_KEY_ID_FROM_JSON}
  payload = generate_jwt_payload(service_account_email=SERVICE_ACCOUNT_EMAIL, resource_url=resource_url)

  signed_jwt = jwt.encode(
      payload,
      PRIVATE_KEY_FROM_JSON,
      headers=additional_headers,
      algorithm='RS256',
  )
  return signed_jwt

Le résultat est un jeton JWT signé.

Accéder à l'application

Dans tous les cas, pour accéder à l'application, utilisez l' signed-jwt comme suit:

curl --verbose --header 'Authorization: Bearer SIGNED_JWT' URL

S'authentifier avec un jeton OIDC

Créez ou utilisez un ID client OAuth 2.0 existant. Pour utiliser un ID client OAuth 2.0 existant, suivez la procédure décrite dans Partager des clients OAuth.
Ajoutez l'ID client OAuth à la liste d'autorisation pour l'accès programmatique de l'application.

Vous devez également ajouter le compte de service à la liste d'accès du projet sécurisé par IAP. Les exemples de code suivants montrent comment obtenir un jeton OIDC. Vous devez inclure le jeton dans un en-tête Authorization: Bearer pour envoyer la requête d'authentification à la ressource sécurisée par IAP.

Obtenir un jeton OIDC pour le compte de service par défaut

Si vous souhaitez obtenir un jeton OIDC pour le compte de service par défaut pour Compute Engine, App Engine ou Cloud Run, vous pouvez utiliser un exemple de code permettant de générer le jeton permettant d'accéder à ressource:

C#


using Google.Apis.Auth.OAuth2;
using System.Net.Http;
using System.Net.Http.Headers;
using System.Threading;
using System.Threading.Tasks;

public class IAPClient
{
    /// <summary>
    /// Makes a request to a IAP secured application by first obtaining
    /// an OIDC token.
    /// </summary>
    /// <param name="iapClientId">The client ID observed on 
    /// https://console.cloud.google.com/apis/credentials. </param>
    /// <param name="uri">HTTP URI to fetch.</param>
    /// <param name="cancellationToken">The token to propagate operation cancel notifications.</param>
    /// <returns>The HTTP response message.</returns>
    public async Task<HttpResponseMessage> InvokeRequestAsync(
        string iapClientId, string uri, CancellationToken cancellationToken = default)
    {
        // Get the OidcToken.
        // You only need to do this once in your application
        // as long as you can keep a reference to the returned OidcToken.
        OidcToken oidcToken = await GetOidcTokenAsync(iapClientId, cancellationToken);

        // Before making an HTTP request, always obtain the string token from the OIDC token,
        // the OIDC token will refresh the string token if it expires.
        string token = await oidcToken.GetAccessTokenAsync(cancellationToken);

        // Include the OIDC token in an Authorization: Bearer header to 
        // IAP-secured resource
        // Note: Normally you would use an HttpClientFactory to build the httpClient.
        // For simplicity we are building the HttpClient directly.
        using HttpClient httpClient = new HttpClient();
        httpClient.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Bearer", token);
        return await httpClient.GetAsync(uri, cancellationToken);
    }

    /// <summary>
    /// Obtains an OIDC token for authentication an IAP request.
    /// </summary>
    /// <param name="iapClientId">The client ID observed on 
    /// https://console.cloud.google.com/apis/credentials. </param>
    /// <param name="cancellationToken">The token to propagate operation cancel notifications.</param>
    /// <returns>The HTTP response message.</returns>
    public async Task<OidcToken> GetOidcTokenAsync(string iapClientId, CancellationToken cancellationToken)
    {
        // Obtain the application default credentials.
        GoogleCredential credential = await GoogleCredential.GetApplicationDefaultAsync(cancellationToken);

        // Request an OIDC token for the Cloud IAP-secured client ID.
       return await credential.GetOidcTokenAsync(OidcTokenOptions.FromTargetAudience(iapClientId), cancellationToken);
    }
}

Go

Pour vous authentifier auprès d'IAP, configurez les identifiants par défaut de l'application. Pour en savoir plus, consultez Configurer l'authentification pour un environnement de développement local.

import (
	"context"
	"fmt"
	"io"
	"net/http"

	"google.golang.org/api/idtoken"
)

// makeIAPRequest makes a request to an application protected by Identity-Aware
// Proxy with the given audience.
func makeIAPRequest(w io.Writer, request *http.Request, audience string) error {
	// request, err := http.NewRequest("GET", "http://example.com", nil)
	// audience := "IAP_CLIENT_ID.apps.googleusercontent.com"
	ctx := context.Background()

	// client is a http.Client that automatically adds an "Authorization" header
	// to any requests made.
	client, err := idtoken.NewClient(ctx, audience)
	if err != nil {
		return fmt.Errorf("idtoken.NewClient: %w", err)
	}

	response, err := client.Do(request)
	if err != nil {
		return fmt.Errorf("client.Do: %w", err)
	}
	defer response.Body.Close()
	if _, err := io.Copy(w, response.Body); err != nil {
		return fmt.Errorf("io.Copy: %w", err)
	}

	return nil
}

Java


import com.google.api.client.http.HttpRequest;
import com.google.api.client.http.HttpRequestInitializer;
import com.google.api.client.http.HttpTransport;
import com.google.api.client.http.javanet.NetHttpTransport;
import com.google.auth.http.HttpCredentialsAdapter;
import com.google.auth.oauth2.GoogleCredentials;
import com.google.auth.oauth2.IdTokenCredentials;
import com.google.auth.oauth2.IdTokenProvider;
import com.google.common.base.Preconditions;
import java.io.IOException;
import java.util.Collections;

public class BuildIapRequest {
  private static final String IAM_SCOPE = "https://www.googleapis.com/auth/iam";

  private static final HttpTransport httpTransport = new NetHttpTransport();

  private BuildIapRequest() {}

  private static IdTokenProvider getIdTokenProvider() throws IOException {
    GoogleCredentials credentials =
        GoogleCredentials.getApplicationDefault().createScoped(Collections.singleton(IAM_SCOPE));

    Preconditions.checkNotNull(credentials, "Expected to load credentials");
    Preconditions.checkState(
        credentials instanceof IdTokenProvider,
        String.format(
            "Expected credentials that can provide id tokens, got %s instead",
            credentials.getClass().getName()));

    return (IdTokenProvider) credentials;
  }

  /**
   * Clone request and add an IAP Bearer Authorization header with ID Token.
   *
   * @param request Request to add authorization header
   * @param iapClientId OAuth 2.0 client ID for IAP protected resource
   * @return Clone of request with Bearer style authorization header with ID Token.
   * @throws IOException exception creating ID Token
   */
  public static HttpRequest buildIapRequest(HttpRequest request, String iapClientId)
      throws IOException {

    IdTokenProvider idTokenProvider = getIdTokenProvider();
    IdTokenCredentials credentials =
        IdTokenCredentials.newBuilder()
            .setIdTokenProvider(idTokenProvider)
            .setTargetAudience(iapClientId)
            .build();

    HttpRequestInitializer httpRequestInitializer = new HttpCredentialsAdapter(credentials);

    return httpTransport
        .createRequestFactory(httpRequestInitializer)
        .buildRequest(request.getRequestMethod(), request.getUrl(), request.getContent());
  }
}

Node.js

/**
 * TODO(developer): Uncomment these variables before running the sample.
 */
// const url = 'https://some.iap.url';
// const targetAudience = 'IAP_CLIENT_ID.apps.googleusercontent.com';

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

async function request() {
  console.info(`request IAP ${url} with target audience ${targetAudience}`);
  const client = await auth.getIdTokenClient(targetAudience);
  const res = await client.request({url});
  console.info(res.data);
}

request().catch(err => {
  console.error(err.message);
  process.exitCode = 1;
});

PHP

namespace Google\Cloud\Samples\Iap;

# Imports Auth libraries and Guzzle HTTP libraries.
use Google\Auth\ApplicationDefaultCredentials;
use GuzzleHttp\Client;
use GuzzleHttp\HandlerStack;

/**
 * Make a request to an application protected by Identity-Aware Proxy.
 *
 * @param string $url The Identity-Aware Proxy-protected URL to fetch.
 * @param string $clientId The client ID used by Identity-Aware Proxy.
 */
function make_iap_request($url, $clientId)
{
    // create middleware, using the client ID as the target audience for IAP
    $middleware = ApplicationDefaultCredentials::getIdTokenMiddleware($clientId);
    $stack = HandlerStack::create();
    $stack->push($middleware);

    // create the HTTP client
    $client = new Client([
        'handler' => $stack,
        'auth' => 'google_auth'
    ]);

    // make the request
    $response = $client->get($url);
    print('Printing out response body:');
    print($response->getBody());
}

Python

from google.auth.transport.requests import Request
from google.oauth2 import id_token
import requests


def make_iap_request(url, client_id, method="GET", **kwargs):
    """Makes a request to an application protected by Identity-Aware Proxy.

    Args:
      url: The Identity-Aware Proxy-protected URL to fetch.
      client_id: The client ID used by Identity-Aware Proxy.
      method: The request method to use
              ('GET', 'OPTIONS', 'HEAD', 'POST', 'PUT', 'PATCH', 'DELETE')
      **kwargs: Any of the parameters defined for the request function:
                https://github.com/requests/requests/blob/master/requests/api.py
                If no timeout is provided, it is set to 90 by default.

    Returns:
      The page body, or raises an exception if the page couldn't be retrieved.
    """
    # Set the default timeout, if missing
    if "timeout" not in kwargs:
        kwargs["timeout"] = 90

    # Obtain an OpenID Connect (OIDC) token from metadata server or using service
    # account.
    open_id_connect_token = id_token.fetch_id_token(Request(), client_id)

    # Fetch the Identity-Aware Proxy-protected URL, including an
    # Authorization header containing "Bearer " followed by a
    # Google-issued OpenID Connect token for the service account.
    resp = requests.request(
        method,
        url,
        headers={"Authorization": "Bearer {}".format(open_id_connect_token)},
        **kwargs
    )
    if resp.status_code == 403:
        raise Exception(
            "Service account does not have permission to "
            "access the IAP-protected application."
        )
    elif resp.status_code != 200:
        raise Exception(
            "Bad response from application: {!r} / {!r} / {!r}".format(
                resp.status_code, resp.headers, resp.text
            )
        )
    else:
        return resp.text

Ruby

# url = "The Identity-Aware Proxy-protected URL to fetch"
# client_id = "The client ID used by Identity-Aware Proxy"
require "googleauth"
require "faraday"

# The client ID as the target audience for IAP
id_token_creds = Google::Auth::Credentials.default target_audience: client_id

headers = {}
id_token_creds.client.apply! headers

resp = Faraday.get url, nil, headers

if resp.status == 200
  puts "X-Goog-Iap-Jwt-Assertion:"
  puts resp.body
else
  puts "Error requesting IAP"
  puts resp.status
  puts resp.headers
end

Obtenir un jeton OIDC à partir d'un fichier de clé de compte de service local

Si vous disposez d'un fichier de clé de compte de service, vous pouvez adapter les exemples de code précédents pour fournir le fichier de clé de compte de service.

Bash

  #!/usr/bin/env bash
  set -euo pipefail

  get_token() {
    # Get the bearer token in exchange for the service account credentials.
    local service_account_key_file_path="${1}"
    local iap_client_id="${2}"

    local iam_scope="https://www.googleapis.com/auth/iam"
    local oauth_token_uri="https://www.googleapis.com/oauth2/v4/token"

    local private_key_id="$(cat "${service_account_key_file_path}" | jq -r '.private_key_id')"
    local client_email="$(cat "${service_account_key_file_path}" | jq -r '.client_email')"
    local private_key="$(cat "${service_account_key_file_path}" | jq -r '.private_key')"
    local issued_at="$(date +%s)"
    local expires_at="$((issued_at + 600))"
    local header="{'alg':'RS256','typ':'JWT','kid':'${private_key_id}'}"
    local header_base64="$(echo "${header}" | base64)"
    local payload="{'iss':'${client_email}','aud':'${oauth_token_uri}','exp':${expires_at},'iat':${issued_at},'sub':'${client_email}','target_audience':'${iap_client_id}'}"
    local payload_base64="$(echo "${payload}" | base64)"
    local signature_base64="$(printf %s "${header_base64}.${payload_base64}" | openssl dgst -binary -sha256 -sign <(printf '%s\n' "${private_key}")  | base64)"
    local assertion="${header_base64}.${payload_base64}.${signature_base64}"
    local token_payload="$(curl -s \
      --data-urlencode "grant_type=urn:ietf:params:oauth:grant-type:jwt-bearer" \
      --data-urlencode "assertion=${assertion}" \
      https://www.googleapis.com/oauth2/v4/token)"
    local bearer_id_token="$(echo "${token_payload}" | jq -r '.id_token')"
    echo "${bearer_id_token}"
  }

  main(){
    # TODO: Replace the following variables:
    SERVICE_ACCOUNT_KEY="service_account_key_file_path"
    IAP_CLIENT_ID="iap_client_id"
    URL="application_url"

    # Obtain the ID token.
    ID_TOKEN=$(get_token "${SERVICE_ACCOUNT_KEY}" "${IAP_CLIENT_ID}")
    # Access the application with the ID token.
    curl --header "Authorization: Bearer ${ID_TOKEN}" "${URL}"
  }

  main "$@"

Obtenir un jeton OIDC dans tous les autres cas

Dans tous les autres cas, utilisez l'API des identifiants IAM pour générer un jeton OIDC en usurpant l'identité d'un compte de service cible juste avant d'accéder Ressource sécurisée par IAP. Ce processus implique les étapes suivantes : étapes:

Attribuez au compte de service appelant (le compte de service associé au code qui obtient le jeton d'identification) le rôle Créateur de jetons d'identité OpenID Connect du compte de service (roles/iam.serviceAccountOpenIdTokenCreator).

Cela permet au compte de service appelant d'usurper l'identité du compte de service cible.
Utilisez les identifiants fournis par le compte de service appelant pour appeler la méthode generateIdToken sur le compte de service cible.

Définissez le champ audience sur votre ID client.

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

Authentification à partir de l'en-tête Proxy-Authorization

Si votre application utilise l'en-tête de requête Authorization, vous pouvez incluez plutôt le jeton d'ID dans un en-tête Proxy-Authorization: Bearer. Si un jeton d'ID valide est détecté dans un en-tête Proxy-Authorization, l'IAP autorise la requête avec celui-ci. Après avoir autorisé , IAP transmet l'en-tête Authorization à votre application sans traiter le contenu.

Si aucun jeton d'ID valide n'est trouvé dans l'en-tête Proxy-Authorization, IAP continue de traiter l'en-tête Authorization. supprime l'en-tête Proxy-Authorization avant de transmettre la requête à votre application.

Étape suivante

Obtenez plus d'informations sur l'autorisation avec les jetons de support.
Essayez Sign-In pour Android ou Sign-In pour iOS.