Cette page explique comment s'authentifier auprès d'une ressource sécurisée par Identity-Aware Proxy (IAP) avec un compte utilisateur ou un compte de service.
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 en savoir plus, consultez la page 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 section Comptes de service.
Avant de commencer
Avant de commencer, vous aurez besoin des éléments suivants :
- Une application sécurisée par IAP à laquelle vous souhaitez vous connecter de manière automatisée à l'aide d'un compte de développeur, d'un compte de service ou d'identifiants d'application mobile.
Authentifier un compte utilisateur
Vous pouvez autoriser l'accès des utilisateurs à votre application à partir d'une application de bureau ou mobile pour 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 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.
- Android : demandez un jeton OpenID Connect (OIDC) à l'aide de l'API Google Sign-In. Définissez l'ID client
- 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 doit d'abord se connecter. Vous pouvez empaqueter le processus dans un script, par exemple à l'aide de gcloud CLI. 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'envoyer un écho des 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
est 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 requête. Le résultat doit ressembler à ce qui suit :
GET /?code=$CODE&scope=email%20openid%20https://www.googleapis.com/auth/userinfo.email&hd=google.com&prompt=consent HTTP/1.1
Copiez le CODE pour remplacerAUTH_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 un champ
id_token
que vous pouvez utiliser pour accéder à l'application.
Accéder à l'application
Pour accéder à l'application, utilisez 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 flux de connexion pour obtenir de nouveaux jetons d'ID. Cela s'avère utile lorsque le jeton d'ID d'origine expire. Chaque jeton d'ID est valide pendant environ une heure, au cours de laquelle vous pouvez envoyer plusieurs requêtes à une application spécifique.
Voici un exemple où la commande curl se sert du jeton d'actualisation pour obtenir un nouveau jeton d'ID. Dans l'exemple suivant, REFRESH_TOKEN
est le jeton du flux de connexion.
DESKTOP_CLIENT_ID
et DESKTOP_CLIENT_SECRET
sont identiques à celles utilisées 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 champ id_token
que vous pouvez utiliser pour accéder à l'application.
Authentifier un compte de service
Utilisez un jeton OpenID Connect (OIDC) pour authentifier un compte de service auprès d'une ressource sécurisée par IAP.
- 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 l'exemple de code suivant pour générer le jeton permettant d'accéder à une ressource sécurisée par IAP:
C#
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.
Java
Node.js
PHP
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.
Python
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.
Ruby
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.
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é.
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 IAM Credentials pour générer un jeton OIDC en usurpant l'identité d'un compte de service cible juste avant d'accéder à une ressource sécurisée par IAP. Ce processus comprend les étapes suivantes:
Indiquez au compte de service appelant (le compte de service associé au code qui obtient le jeton d'ID) 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'emprunter 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 inclure le jeton d'ID dans un en-tête Proxy-Authorization: Bearer
à la place. Si un jeton d'ID valide est trouvé dans un en-tête Proxy-Authorization
, IAP autorise la requête avec cet en-tête. Après avoir autorisé la requête, 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
et supprime l'en-tête Proxy-Authorization
avant de transmettre la requête à votre application.
Étapes suivantes
- Obtenez plus d'informations sur l'autorisation avec les jetons de support.
- Essayez Sign-In pour Android ou Sign-In pour iOS.