Présentation
Pour obtenir un jeton d'accès par utilisateur permettant d'appeler les API Google, Google propose plusieurs Bibliothèques JavaScript:
Ce guide fournit des instructions pour migrer de ces bibliothèques vers la bibliothèque Google bibliothèque Identity Services.
En suivant ce guide, vous allez:
- remplacez la bibliothèque Platform obsolète par la bibliothèque Identity Services. et
- si vous utilisez la bibliothèque cliente des API, supprimez le module
gapi.auth2obsolète, ses méthodes et ses objets, en les remplaçant par des équivalents Identity Services.
Description des modifications apportées avec le code JavaScript Identity Services consultez la présentation et le fonctionnement des autorisations des utilisateurs les termes et concepts clés.
Si vous recherchez une authentification pour l'inscription et la connexion des utilisateurs, consultez Migrer depuis Google Sign-In.
Identifier votre flux d'autorisation
Il existe deux flux d'autorisation utilisateur: implicites et d'autorisation du code source.
Examinez votre application Web pour identifier le type de flux d'autorisation actuellement utilisé. en cours d'utilisation.
Indications que votre application Web utilise le flux implicite:
- Votre application Web est entièrement basée sur un navigateur, sans plate-forme de backend.
- L'utilisateur doit être présent pour appeler les API Google. Votre application n'utilise que l'accès et ne nécessite pas de jetons d'actualisation.
- Votre application Web charge
apis.google.com/js/api.js. - Votre implémentation est basée sur OAuth 2.0 pour le Web côté client Applications.
- Votre application utilise les modules
gapi.clientougapi.auth2disponibles dans Bibliothèque cliente des API Google pour JavaScript.
Indique que votre application Web utilise le flux avec code d'autorisation:
Votre implémentation repose sur les éléments suivants:
- Using OAuth 2.0 for Web Server Applications (Utiliser OAuth 2.0 pour les applications de serveur Web) ou
- Google Sign-In pour les applications côté serveur
Votre application s'exécute à la fois dans le navigateur de l'utilisateur et sur votre plate-forme backend.
Votre plate-forme backend héberge un point de terminaison de code d'autorisation.
Votre plate-forme backend appelle les API Google au nom des utilisateurs d’être présents, aussi connu sous le nom de mode hors connexion.
Les jetons d'actualisation sont gérés et stockés par votre plate-forme backend.
Dans certains cas, votre codebase peut être compatible avec les deux flux.
Choisir un flux d'autorisation
Avant de commencer la migration, vous devez déterminer si vous poursuivez flux existant ou l'adoption d'un flux différent répond le mieux à vos besoins.
Consultez la section Choisir un flux d'autorisation pour comprendre les principales différences. et les compromis entre les deux flux.
Dans la plupart des cas, le flux avec code d'autorisation est recommandé, car il offre le le plus haut niveau de sécurité de l'utilisateur. La mise en œuvre de ce flux permet également pour ajouter plus facilement de nouvelles fonctionnalités hors connexion, comme la récupération des mises à jour. pour informer les utilisateurs de modifications importantes apportées à leur agenda, leurs photos, leurs abonnements ainsi de suite.
Choisissez un flux d'autorisation à l'aide des sélecteurs ci-dessous.
Flux implicite
Procurez-vous un jeton d'accès à utiliser dans le navigateur lorsque l'utilisateur est présent.
Des exemples de flux implicites montrent les applications Web avant et après la migration vers Identity Services.
Flux avec code d'autorisation
Un code d'autorisation par utilisateur émis par Google est transmis à votre backend. plate-forme, où il est ensuite échangé contre un jeton d'accès et un jeton d'actualisation.
Exemples de flux avec code d'autorisation montrant les applications Web avant et après la migration vers Identity Services.
Tout au long de ce guide, suivez les instructions indiquées en gras pour Ajouter, Supprimer, Mettre à jour ou Remplacer une fonctionnalité existante
Modifications apportées à l'application Web intégrée au navigateur
Cette section passe en revue les modifications que vous apporterez à votre application Web dans votre navigateur lorsque la migration vers la bibliothèque JavaScript Google Identity Services.
Identifier le code concerné et effectuer des tests
Un cookie de débogage peut vous aider à localiser le code concerné et à tester le processus post-abandon comportemental.
Dans les applications volumineuses ou complexes, il peut être difficile de trouver tout le code affecté par le
Abandon du module gapi.auth2. Pour consigner l'utilisation existante de
fonctionnalité obsolète dans la console, définissez la valeur du paramètre
Cookie G_AUTH2_MIGRATION à informational. Vous pouvez aussi ajouter un signe deux-points, suivi
par une valeur de clé pour se connecter également au stockage de session. Après la connexion
et la réception de l'examen des identifiants ou l'envoi des journaux collectés à un backend pour une utilisation ultérieure
l'analyse. Par exemple, informational:showauth2use enregistre l'origine et l'URL dans un
de stockage de session nommée showauth2use.
Pour vérifier le comportement de l'application lorsque le module gapi.auth2 n'est plus chargé, définissez
la valeur du cookie G_AUTH2_MIGRATION sur enforced. Cela permet de tester
comportement post-abandon avant la date d'application forcée.
Valeurs possibles du cookie G_AUTH2_MIGRATION:
enforcedNe pas charger le modulegapi.auth2.informationalConsignez l'utilisation de fonctionnalités obsolètes dans la console JavaScript. Consigner également au stockage de session lorsqu'un nom de clé facultatif est défini:informational:key-name
Pour minimiser l'impact sur l'utilisateur, nous vous recommandons de définir d'abord ce cookie localement pendant les phases de développement et de test, avant de les utiliser dans des environnements de production.
Bibliothèques et modules
Le module gapi.auth2 gère l'authentification des utilisateurs pour la connexion et l'authentification
d'autorisation, remplacez ce module obsolète, ainsi que ses objets et
avec la bibliothèque Google Identity Services.
Ajoutez la bibliothèque Identity Services à votre application Web en l'incluant dans votre document:
<script src="https://accounts.google.com/gsi/client" async defer></script>
Supprimez toutes les instances de chargement du module auth2 avec gapi.load('auth2',
function).
La bibliothèque Google Identity Services remplace l'utilisation du module gapi.auth2.
Vous pouvez continuer à utiliser en toute sécurité le module gapi.client à partir de l'API Google
la bibliothèque cliente pour JavaScript et profiter de sa création automatique ;
de méthodes JS appelables à partir d'un document de découverte, le traitement par lot de plusieurs appels d'API,
et la fonctionnalité de gestion CORS.
Cookies
L'autorisation de l'utilisateur ne nécessite pas l'utilisation de cookies.
Consultez Migrer depuis Google Sign-In pour découvrir comment l'authentification des utilisateurs utilise les cookies et Comment Google utilise les cookies pour l'utilisation des cookies par d'autres produits et services Google.
Identifiants
Google Identity Services distingue l'authentification et l'autorisation des utilisateurs deux opérations distinctes et les identifiants de l'utilisateur sont séparés: le jeton d'ID utilisé pour identifier un utilisateur est renvoyé séparément du jeton d'accès utilisé pour une autorisation.
Pour afficher ces modifications, consultez les exemples d'identifiants.
Flux implicite
Séparer l'authentification et l'autorisation des utilisateurs en supprimant le profil utilisateur à partir de flux d'autorisation.
Supprimez ces références client JavaScript Google Sign-In:
Méthodes
GoogleUser.getBasicProfile()GoogleUser.getId()
Flux avec code d'autorisation
Identity Services sépare les identifiants du navigateur en jetons d'ID et en accès. à partir d'un jeton d'accès. Ce changement ne s'applique pas aux identifiants obtenus d'appels vers des points de terminaison Google OAuth 2.0 depuis votre plate-forme backend ou via bibliothèques s'exécutant sur un serveur sécurisé de votre plate-forme tel que Google Client des API Node.js
État de la session
Auparavant, Google Sign-In vous permettait de gérer l'état de connexion des utilisateurs à l'aide des éléments suivants:
- Gestionnaires de rappel pour surveiller l'état de la session de l'utilisateur
- Des écouteurs pour les événements et les modifications apportées à l'état de connexion des Compte Google.
Vous êtes responsable de la gestion de l'état de connexion et des sessions utilisateur sur votre l'application.
Supprimez ces références client JavaScript Google Sign-In:
Objets:
gapi.auth2.SignInOptions
Méthodes :
GoogleAuth.attachClickHandler()GoogleAuth.isSignedIn()GoogleAuth.isSignedIn.get()GoogleAuth.isSignedIn.listen()GoogleAuth.signIn()GoogleAuth.signOut()GoogleAuth.currentUser.get()GoogleAuth.currentUser.listen()GoogleUser.isSignedIn()
Configuration du client
Mettez à jour votre application Web afin d'initialiser un client de jetons pour l'API implicite ou via le flux avec code d'autorisation.
Supprimez ces références client JavaScript Google Sign-In:
Objets:
gapi.auth2.ClientConfiggapi.auth2.OfflineAccessOptions
Méthodes :
gapi.auth2.getAuthInstance()GoogleUser.grant()
Flux implicite
Ajoutez un objet TokenClientConfig et un appel initTokenClient() à
configurer votre application Web, en suivant l'exemple de la section Initialiser un jeton
client.
Remplacez les références client JavaScript Google Sign-In par Google Identity Services:
Objets:
gapi.auth2.AuthorizeConfigavecTokenClientConfig
Méthodes :
gapi.auth2.init()avecgoogle.accounts.oauth2.initTokenClient()
Paramètres :
gapi.auth2.AuthorizeConfig.login_hintavecTokenClientConfig.login_hintgapi.auth2.GoogleUser.getHostedDomain()correspond àTokenClientConfig.hd.
Flux avec code d'autorisation
Ajoutez un objet CodeClientConfig et un appel initCodeClient() pour configurer
votre application Web, en suivant l'exemple de la section Initialiser un client de code.
Lors du passage du flux implicite au flux avec code d'autorisation:
Supprimer les références client JavaScript Google Sign-In
Objets:
gapi.auth2.AuthorizeConfig
Méthodes :
gapi.auth2.init()
Paramètres :
gapi.auth2.AuthorizeConfig.login_hintgapi.auth2.GoogleUser.getHostedDomain()
Demande de jeton
Un geste de l'utilisateur (un clic sur un bouton, par exemple) génère une requête qui entraîne le jeton d'accès est directement renvoyé au navigateur de l'utilisateur avec l'autorisation ou vers votre plate-forme de backend après avoir échangé un code d'autorisation par utilisateur un jeton d'accès et un jeton d'actualisation.
Flux implicite
Vous pouvez obtenir et utiliser des jetons d'accès dans le navigateur pendant que l'utilisateur est connecté et a une session active avec Google. En mode implicite, un utilisateur un geste est nécessaire pour demander un jeton d'accès, même s'il existe requête.
Remplacez les références client JavaScript Google Sign-In par Google Identity Services:
Méthodes :
gapi.auth2.authorize()avecTokenClient.requestAccessToken()GoogleUser.reloadAuthResponse()avecTokenClient.requestAccessToken()
Ajoutez un lien ou un bouton pour appeler requestAccessToken() et lancer la
pour demander un jeton d'accès ou en obtenir un nouveau lorsque
le jeton existant expire.
Mettez à jour votre codebase comme suit:
- Déclenchez le flux de jetons OAuth 2.0 avec
requestAccessToken(). - Prise en charge des autorisations incrémentielles en utilisant
requestAccessTokenetOverridableTokenClientConfigpour séparer une requête pour plusieurs champs d'application en plusieurs requêtes plus petites. - Demandez un nouveau jeton lorsque le jeton existant expire ou est révoqué.
L'utilisation de plusieurs champs d'application peut nécessiter des modifications structurelles de votre codebase de demander l'accès aux niveaux d'accès uniquement selon leurs besoins, et non en une seule fois, c'est ce qu'on appelle l'autorisation incrémentielle. Chaque demande doit contenir au format que possible, et idéalement un seul champ d'application. Découvrez comment gérer les utilisateurs le consentement pour savoir comment mettre à jour votre application une autorisation.
Lorsqu'un jeton d'accès expire, le module gapi.auth2 obtient automatiquement
un nouveau jeton d'accès valide pour votre application Web. Pour renforcer la sécurité de l'utilisateur,
le processus d'actualisation automatique des jetons n'est pas compatible avec le
Bibliothèque de services. Vous devez mettre à jour votre appli Web pour détecter un accès expiré
et demandez-en un nouveau. Pour en savoir plus, consultez la section "Gestion des jetons" ci-dessous.
Flux avec code d'autorisation
Ajoutez un lien ou un bouton pour appeler requestCode() et demander une autorisation.
de Google. Pour obtenir un exemple, consultez la section Déclencher le flux de code OAuth 2.0.
Consultez la section "Gestion des jetons" ci-dessous pour savoir comment répondre à une un jeton d'accès expiré ou révoqué.
Gestion des jetons
Ajoutez la gestion des erreurs pour détecter les échecs des appels d'API Google en cas d'expiration ou un jeton d'accès révoqué est utilisé, et pour demander un nouveau jeton d'accès valide.
Un code d'état HTTP 401 Unauthorized et le message d'erreur invalid_token sont
renvoyés par les API Google lorsqu'un jeton d'accès expiré ou révoqué est utilisé. Pour une
un exemple, consultez la section Réponse de jeton non valide.
Jetons expirés
Les jetons d'accès ont une courte durée de vie et, bien souvent, ne sont valides que pendant quelques minutes.
Révocation des jetons
Le titulaire d'un compte Google peut à tout moment révoquer l'autorisation accordée précédemment. Faire
et invalide les jetons d'accès et d'actualisation existants. La révocation peut être
déclenchée depuis votre plate-forme à l'aide de revoke() ou via un
Compte.
Remplacez les références client JavaScript Google Sign-In par Google Identity Services:
Méthodes :
getAuthInstance().disconnect()avecgoogle.accounts.oauth2.revoke()GoogleUser.disconnect()avecgoogle.accounts.oauth2.revoke()
appeler revoke lorsqu'un utilisateur supprime son compte sur votre plate-forme ; ou
souhaite retirer le consentement pour partager des données avec votre application.
Invite de consentement de l'utilisateur
Google affiche une boîte de dialogue de recueil du consentement des utilisateurs lorsque votre application Web ou votre backend demande un jeton d'accès. Voir des exemples de boîtes de dialogue de recueil du consentement affichées par Google aux utilisateurs.
Avant l'émission d'un jeton d'accès à votre application, un jeton Google existant est nécessaire pour demander le consentement de l'utilisateur et enregistrer le résultat. L'utilisateur peut être invité à se connecter à un compte Google si une session existante n'a pas est déjà établie.
Connexion de l'utilisateur
Les utilisateurs peuvent être connectés à un compte Google dans un autre onglet du navigateur ou de façon native via un navigateur ou un système d'exploitation. Nous vous recommandons d'ajouter Se connecter avec Google à votre site pour établir une session active entre un compte Google et le navigateur lorsque l'utilisateur ouvre votre application pour la première fois. Cela vous offre avantages:
- Minimise le nombre de fois où un utilisateur doit se connecter et demander un accès Le jeton lance le processus de connexion au compte Google si une session active n'existent pas encore.
- Utilisez directement le champ identifiants
emaildu jeton d'ID JWT comme valeur de le paramètrelogin_hintdansCodeClientConfigouTokenClientConfig; d'objets. Cela est particulièrement utile si votre plate-forme ne maintient pas de gestion des comptes utilisateur. - Recherchez un compte Google et associez-le à un compte d'utilisateur local existant sur afin de limiter le nombre de comptes en double sur votre plate-forme.
- Lorsque vous créez un compte local, vos boîtes de dialogue et votre processus d'inscription clairement séparés des boîtes de dialogue et des flux d'authentification, ce qui réduit le nombre d'étapes requises et l'amélioration du taux d'abandon.
Après la connexion, et avant l'émission d'un jeton d'accès, les utilisateurs doivent donner leur autorisation pour votre application pour les champs d'application demandés.
Jeton et réponse de consentement
Après le consentement, un jeton d'accès est renvoyé avec une liste des champs d'application approuvés ou rejetées par l'utilisateur.
Des autorisations précises permettent aux utilisateurs d'approuver ou de refuser des champs d'application spécifiques. Quand ? demandant l'accès à plusieurs niveaux d'accès, chacun d'entre eux est autorisé ou refusé indépendamment des autres champs d'application. En fonction du choix de l'utilisateur, votre application est sélective active des fonctionnalités qui dépendent d'un champ d'application individuel.
Flux implicite
Remplacez les références client JavaScript Google Sign-In par Google Identity Services:
Objets:
gapi.auth2.AuthorizeResponseavecTokenClient.TokenResponsegapi.auth2.AuthResponseavecTokenClient.TokenResponse
Méthodes :
GoogleUser.hasGrantedScopes()avecgoogle.accounts.oauth2.hasGrantedAllScopes()GoogleUser.getGrantedScopes()avecgoogle.accounts.oauth2.hasGrantedAllScopes()
Supprimer les références client JavaScript Google Sign-In:
Méthodes :
GoogleUser.getAuthResponse()
Mettez à jour votre application Web avec hasGrantedAllScopes() et
hasGrantedAnyScope() en suivant cet exemple d'autorisations précises.
Flux avec code d'autorisation
Mettez à jour ou ajoutez un point de terminaison de code d'autorisation à votre backend. en suivant les instructions de gestion des codes d'autorisation.
Mettez à jour votre plate-forme pour suivre la procédure décrite dans la section Utiliser le code Model pour valider la requête, obtenir un jeton d'accès et actualiser à partir d'un jeton d'accès.
Mettez à jour votre plate-forme pour activer ou désactiver les fonctionnalités de votre choix. fonctionnalités en fonction des niveaux d'accès que l'utilisateur a approuvés en suivant les instructions relatives à l'autorisation incrémentielle et examinez les niveaux d'accès accordés par l'utilisateur.
Exemples de flux implicites
À l'ancienne
Bibliothèque cliente GAPI
Exemple de bibliothèque cliente des API Google pour JavaScript s'exécutant dans un navigateur à l'aide d'une boîte de dialogue pop-up demandant le consentement de l'utilisateur.
Le module gapi.auth2 est automatiquement chargé et utilisé par
gapi.client.init(), et est donc masqué.
<!DOCTYPE html>
<html>
<head>
<script src="https://apis.google.com/js/api.js"></script>
<script>
function start() {
gapi.client.init({
'apiKey': 'YOUR_API_KEY',
'clientId': 'YOUR_CLIENT_ID',
'scope': 'https://www.googleapis.com/auth/cloud-translation',
'discoveryDocs': ['https://www.googleapis.com/discovery/v1/apis/translate/v2/rest'],
}).then(function() {
// Execute an API request which is returned as a Promise.
// The method name language.translations.list comes from the API discovery.
return gapi.client.language.translations.list({
q: 'hello world',
source: 'en',
target: 'de',
});
}).then(function(response) {
console.log(response.result.data.translations[0].translatedText);
}, function(reason) {
console.log('Error: ' + reason.result.error.message);
});
};
// Load the JavaScript client library and invoke start afterwards.
gapi.load('client', start);
</script>
</head>
<body>
<div id="results"></div>
</body>
</html>
Bibliothèque cliente JS
OAuth 2.0 pour les applications Web côté client s'exécutant dans un navigateur à l'aide d'un pour demander le consentement de l'utilisateur.
Le module gapi.auth2 est chargé manuellement.
<!DOCTYPE html>
<html><head></head><body>
<script>
var GoogleAuth;
var SCOPE = 'https://www.googleapis.com/auth/drive.metadata.readonly';
function handleClientLoad() {
// Load the API's client and auth2 modules.
// Call the initClient function after the modules load.
gapi.load('client:auth2', initClient);
}
function initClient() {
// In practice, your app can retrieve one or more discovery documents.
var discoveryUrl = 'https://www.googleapis.com/discovery/v1/apis/drive/v3/rest';
// Initialize the gapi.client object, which app uses to make API requests.
// Get API key and client ID from API Console.
// 'scope' field specifies space-delimited list of access scopes.
gapi.client.init({
'apiKey': 'YOUR_API_KEY',
'clientId': 'YOUR_CLIENT_ID',
'discoveryDocs': [discoveryUrl],
'scope': SCOPE
}).then(function () {
GoogleAuth = gapi.auth2.getAuthInstance();
// Listen for sign-in state changes.
GoogleAuth.isSignedIn.listen(updateSigninStatus);
// Handle initial sign-in state. (Determine if user is already signed in.)
var user = GoogleAuth.currentUser.get();
setSigninStatus();
// Call handleAuthClick function when user clicks on
// "Sign In/Authorize" button.
$('#sign-in-or-out-button').click(function() {
handleAuthClick();
});
$('#revoke-access-button').click(function() {
revokeAccess();
});
});
}
function handleAuthClick() {
if (GoogleAuth.isSignedIn.get()) {
// User is authorized and has clicked "Sign out" button.
GoogleAuth.signOut();
} else {
// User is not signed in. Start Google auth flow.
GoogleAuth.signIn();
}
}
function revokeAccess() {
GoogleAuth.disconnect();
}
function setSigninStatus() {
var user = GoogleAuth.currentUser.get();
var isAuthorized = user.hasGrantedScopes(SCOPE);
if (isAuthorized) {
$('#sign-in-or-out-button').html('Sign out');
$('#revoke-access-button').css('display', 'inline-block');
$('#auth-status').html('You are currently signed in and have granted ' +
'access to this app.');
} else {
$('#sign-in-or-out-button').html('Sign In/Authorize');
$('#revoke-access-button').css('display', 'none');
$('#auth-status').html('You have not authorized this app or you are ' +
'signed out.');
}
}
function updateSigninStatus() {
setSigninStatus();
}
</script>
<button id="sign-in-or-out-button"
style="margin-left: 25px">Sign In/Authorize</button>
<button id="revoke-access-button"
style="display: none; margin-left: 25px">Revoke access</button>
<div id="auth-status" style="display: inline; padding-left: 25px"></div><hr>
<script src="https://ajax.googleapis.com/ajax/libs/jquery/1.11.3/jquery.min.js"></script>
<script async defer src="https://apis.google.com/js/api.js"
onload="this.onload=function(){};handleClientLoad()"
onreadystatechange="if (this.readyState === 'complete') this.onload()">
</script>
</body></html>
Points de terminaison OAuth 2.0
OAuth 2.0 pour les applications Web côté client s'exécutant dans un navigateur avec redirige vers Google pour obtenir le consentement de l'utilisateur.
Cet exemple illustre les appels directs aux points de terminaison OAuth 2.0 de Google depuis
le navigateur de l'utilisateur et n'utilise pas le module gapi.auth2 ni un code
bibliothèque.
<!DOCTYPE html>
<html><head></head><body>
<script>
var YOUR_CLIENT_ID = 'REPLACE_THIS_VALUE';
var YOUR_REDIRECT_URI = 'REPLACE_THIS_VALUE';
var fragmentString = location.hash.substring(1);
// Parse query string to see if page request is coming from OAuth 2.0 server.
var params = {};
var regex = /([^&=]+)=([^&]*)/g, m;
while (m = regex.exec(fragmentString)) {
params[decodeURIComponent(m[1])] = decodeURIComponent(m[2]);
}
if (Object.keys(params).length > 0) {
localStorage.setItem('oauth2-test-params', JSON.stringify(params) );
if (params['state'] && params['state'] == 'try_sample_request') {
trySampleRequest();
}
}
// If there's an access token, try an API request.
// Otherwise, start OAuth 2.0 flow.
function trySampleRequest() {
var params = JSON.parse(localStorage.getItem('oauth2-test-params'));
if (params && params['access_token']) {
var xhr = new XMLHttpRequest();
xhr.open('GET',
'https://www.googleapis.com/drive/v3/about?fields=user&' +
'access_token=' + params['access_token']);
xhr.onreadystatechange = function (e) {
if (xhr.readyState === 4 && xhr.status === 200) {
console.log(xhr.response);
} else if (xhr.readyState === 4 && xhr.status === 401) {
// Token invalid, so prompt for user permission.
oauth2SignIn();
}
};
xhr.send(null);
} else {
oauth2SignIn();
}
}
/*
* Create form to request access token from Google's OAuth 2.0 server.
*/
function oauth2SignIn() {
// Google's OAuth 2.0 endpoint for requesting an access token
var oauth2Endpoint = 'https://accounts.google.com/o/oauth2/v2/auth';
// Create element to open OAuth 2.0 endpoint in new window.
var form = document.createElement('form');
form.setAttribute('method', 'GET'); // Send as a GET request.
form.setAttribute('action', oauth2Endpoint);
// Parameters to pass to OAuth 2.0 endpoint.
var params = {'client_id': YOUR_CLIENT_ID,
'redirect_uri': YOUR_REDIRECT_URI,
'scope': 'https://www.googleapis.com/auth/drive.metadata.readonly',
'state': 'try_sample_request',
'include_granted_scopes': 'true',
'response_type': 'token'};
// Add form parameters as hidden input values.
for (var p in params) {
var input = document.createElement('input');
input.setAttribute('type', 'hidden');
input.setAttribute('name', p);
input.setAttribute('value', params[p]);
form.appendChild(input);
}
// Add form to page and submit it to open the OAuth 2.0 endpoint.
document.body.appendChild(form);
form.submit();
}
</script>
<button onclick="trySampleRequest();">Try sample request</button>
</body></html>
Nouvelle méthode
SIG uniquement
Cet exemple ne montre que la bibliothèque JavaScript de Google Identity Service utilisation du modèle de jeton et boîte de dialogue pop-up de consentement de l'utilisateur. Il est qui illustrent le nombre minimal d'étapes nécessaires pour configurer client, demander et obtenir un jeton d'accès, et appeler une API Google.
<!DOCTYPE html>
<html>
<head>
<script src="https://accounts.google.com/gsi/client" onload="initClient()" async defer></script>
</head>
<body>
<script>
var client;
var access_token;
function initClient() {
client = google.accounts.oauth2.initTokenClient({
client_id: 'YOUR_CLIENT_ID',
scope: 'https://www.googleapis.com/auth/calendar.readonly \
https://www.googleapis.com/auth/contacts.readonly',
callback: (tokenResponse) => {
access_token = tokenResponse.access_token;
},
});
}
function getToken() {
client.requestAccessToken();
}
function revokeToken() {
google.accounts.oauth2.revoke(access_token, () => {console.log('access token revoked')});
}
function loadCalendar() {
var xhr = new XMLHttpRequest();
xhr.open('GET', 'https://www.googleapis.com/calendar/v3/calendars/primary/events');
xhr.setRequestHeader('Authorization', 'Bearer ' + access_token);
xhr.send();
}
</script>
<h1>Google Identity Services Authorization Token model</h1>
<button onclick="getToken();">Get access token</button><br><br>
<button onclick="loadCalendar();">Load Calendar</button><br><br>
<button onclick="revokeToken();">Revoke token</button>
</body>
</html>
GAPI async/await
Cet exemple montre comment ajouter la bibliothèque Google Identity Service à l'aide de la propriété
modèle de jeton, supprimez le module gapi.auth2 et appelez une API à l'aide de la
Bibliothèque cliente des API Google pour JavaScript.
Les promesses, async et await sont utilisées pour appliquer l'ordre de chargement de la bibliothèque et pour détecter et relancer les erreurs d'autorisation. Un appel d'API est effectué uniquement après une un jeton d'accès est disponible.
Les utilisateurs doivent appuyer sur le bouton "Afficher l'agenda" lorsque le jeton d'accès est manquant lors du premier chargement de la page ou ultérieurement après le jeton d'accès. a expiré.
<!DOCTYPE html>
<html>
<head></head>
<body>
<h1>GAPI with GIS async/await</h1>
<button id="showEventsBtn" onclick="showEvents();">Show Calendar</button><br><br>
<button id="revokeBtn" onclick="revokeToken();">Revoke access token</button>
<script>
const gapiLoadPromise = new Promise((resolve, reject) => {
gapiLoadOkay = resolve;
gapiLoadFail = reject;
});
const gisLoadPromise = new Promise((resolve, reject) => {
gisLoadOkay = resolve;
gisLoadFail = reject;
});
var tokenClient;
(async () => {
document.getElementById("showEventsBtn").style.visibility="hidden";
document.getElementById("revokeBtn").style.visibility="hidden";
// First, load and initialize the gapi.client
await gapiLoadPromise;
await new Promise((resolve, reject) => {
// NOTE: the 'auth2' module is no longer loaded.
gapi.load('client', {callback: resolve, onerror: reject});
});
await gapi.client.init({
// NOTE: OAuth2 'scope' and 'client_id' parameters have moved to initTokenClient().
})
.then(function() { // Load the Calendar API discovery document.
gapi.client.load('https://www.googleapis.com/discovery/v1/apis/calendar/v3/rest');
});
// Now load the GIS client
await gisLoadPromise;
await new Promise((resolve, reject) => {
try {
tokenClient = google.accounts.oauth2.initTokenClient({
client_id: 'YOUR_CLIENT_ID',
scope: 'https://www.googleapis.com/auth/calendar.readonly',
prompt: 'consent',
callback: '', // defined at request time in await/promise scope.
});
resolve();
} catch (err) {
reject(err);
}
});
document.getElementById("showEventsBtn").style.visibility="visible";
document.getElementById("revokeBtn").style.visibility="visible";
})();
async function getToken(err) {
if (err.result.error.code == 401 || (err.result.error.code == 403) &&
(err.result.error.status == "PERMISSION_DENIED")) {
// The access token is missing, invalid, or expired, prompt for user consent to obtain one.
await new Promise((resolve, reject) => {
try {
// Settle this promise in the response callback for requestAccessToken()
tokenClient.callback = (resp) => {
if (resp.error !== undefined) {
reject(resp);
}
// GIS has automatically updated gapi.client with the newly issued access token.
console.log('gapi.client access token: ' + JSON.stringify(gapi.client.getToken()));
resolve(resp);
};
tokenClient.requestAccessToken();
} catch (err) {
console.log(err)
}
});
} else {
// Errors unrelated to authorization: server errors, exceeding quota, bad requests, and so on.
throw new Error(err);
}
}
function showEvents() {
// Try to fetch a list of Calendar events. If a valid access token is needed,
// prompt to obtain one and then retry the original request.
gapi.client.calendar.events.list({ 'calendarId': 'primary' })
.then(calendarAPIResponse => console.log(JSON.stringify(calendarAPIResponse)))
.catch(err => getToken(err)) // for authorization errors obtain an access token
.then(retry => gapi.client.calendar.events.list({ 'calendarId': 'primary' }))
.then(calendarAPIResponse => console.log(JSON.stringify(calendarAPIResponse)))
.catch(err => console.log(err)); // cancelled by user, timeout, etc.
}
function revokeToken() {
let cred = gapi.client.getToken();
if (cred !== null) {
google.accounts.oauth2.revoke(cred.access_token, () => {console.log('Revoked: ' + cred.access_token)});
gapi.client.setToken('');
}
}
</script>
<script async defer src="https://apis.google.com/js/api.js" onload="gapiLoadOkay()" onerror="gapiLoadFail(event)"></script>
<script async defer src="https://accounts.google.com/gsi/client" onload="gisLoadOkay()" onerror="gisLoadFail(event)"></script>
</body>
</html>
Rappel GAPI
Cet exemple montre comment ajouter la bibliothèque Google Identity Service à l'aide de la propriété
modèle de jeton, supprimez le module gapi.auth2 et appelez une API à l'aide de la
Bibliothèque cliente des API Google pour JavaScript.
Les variables sont utilisées pour appliquer l'ordre de chargement de la bibliothèque. des appels GAPI sont effectués à partir de dans le rappel après qu'un jeton d'accès valide a été renvoyé.
Les utilisateurs doivent appuyer sur le bouton "Afficher l'agenda" lorsque la page est ouverte en premier chargé et à nouveau quand ils veulent actualiser les informations de leur agenda.
<!DOCTYPE html>
<html>
<head>
<script async defer src="https://apis.google.com/js/api.js" onload="gapiLoad()"></script>
<script async defer src="https://accounts.google.com/gsi/client" onload="gisInit()"></script>
</head>
<body>
<h1>GAPI with GIS callbacks</h1>
<button id="showEventsBtn" onclick="showEvents();">Show Calendar</button><br><br>
<button id="revokeBtn" onclick="revokeToken();">Revoke access token</button>
<script>
let tokenClient;
let gapiInited;
let gisInited;
document.getElementById("showEventsBtn").style.visibility="hidden";
document.getElementById("revokeBtn").style.visibility="hidden";
function checkBeforeStart() {
if (gapiInited && gisInited){
// Start only when both gapi and gis are initialized.
document.getElementById("showEventsBtn").style.visibility="visible";
document.getElementById("revokeBtn").style.visibility="visible";
}
}
function gapiInit() {
gapi.client.init({
// NOTE: OAuth2 'scope' and 'client_id' parameters have moved to initTokenClient().
})
.then(function() { // Load the Calendar API discovery document.
gapi.client.load('https://www.googleapis.com/discovery/v1/apis/calendar/v3/rest');
gapiInited = true;
checkBeforeStart();
});
}
function gapiLoad() {
gapi.load('client', gapiInit)
}
function gisInit() {
tokenClient = google.accounts.oauth2.initTokenClient({
client_id: 'YOUR_CLIENT_ID',
scope: 'https://www.googleapis.com/auth/calendar.readonly',
callback: '', // defined at request time
});
gisInited = true;
checkBeforeStart();
}
function showEvents() {
tokenClient.callback = (resp) => {
if (resp.error !== undefined) {
throw(resp);
}
// GIS has automatically updated gapi.client with the newly issued access token.
console.log('gapi.client access token: ' + JSON.stringify(gapi.client.getToken()));
gapi.client.calendar.events.list({ 'calendarId': 'primary' })
.then(calendarAPIResponse => console.log(JSON.stringify(calendarAPIResponse)))
.catch(err => console.log(err));
document.getElementById("showEventsBtn").innerText = "Refresh Calendar";
}
// Conditionally ask users to select the Google Account they'd like to use,
// and explicitly obtain their consent to fetch their Calendar.
// NOTE: To request an access token a user gesture is necessary.
if (gapi.client.getToken() === null) {
// Prompt the user to select a Google Account and asked for consent to share their data
// when establishing a new session.
tokenClient.requestAccessToken({prompt: 'consent'});
} else {
// Skip display of account chooser and consent dialog for an existing session.
tokenClient.requestAccessToken({prompt: ''});
}
}
function revokeToken() {
let cred = gapi.client.getToken();
if (cred !== null) {
google.accounts.oauth2.revoke(cred.access_token, () => {console.log('Revoked: ' + cred.access_token)});
gapi.client.setToken('');
document.getElementById("showEventsBtn").innerText = "Show Calendar";
}
}
</script>
</body>
</html>
Exemples de flux avec code d'autorisation
Le pop-up de l'expérience utilisateur de la bibliothèque Google Identity Service peut utiliser une redirection d'URL renvoyer un code d'autorisation directement au point de terminaison de votre jeton de backend, ou Gestionnaire de rappel JavaScript s'exécutant dans le navigateur de l'utilisateur et qui sert de proxy pour à votre plate-forme. Dans les deux cas, votre plate-forme backend terminera le flux OAuth 2.0 pour obtenir un jeton d'actualisation et d'accès valide.
À l'ancienne
Applications Web côté serveur
Google Sign-In pour les applications côté serveur s'exécutant sur une plate-forme backend via une redirection vers Google pour obtenir le consentement de l'utilisateur.
<!DOCTYPE html>
<html>
<head>
<script src="//ajax.googleapis.com/ajax/libs/jquery/1.8.2/jquery.min.js"></script>
<script src="https://apis.google.com/js/client:platform.js?onload=start" async defer></script>
<script>
function start() {
gapi.load('auth2', function() {
auth2 = gapi.auth2.init({
client_id: 'YOUR_CLIENT_ID',
api_key: 'YOUR_API_KEY',
discovery_docs: ['https://www.googleapis.com/discovery/v1/apis/translate/v2/rest'],
// Scopes to request in addition to 'profile' and 'email'
scope: 'https://www.googleapis.com/auth/cloud-translation',
});
});
}
function signInCallback(authResult) {
if (authResult['code']) {
console.log("sending AJAX request");
// Send authorization code obtained from Google to backend platform
$.ajax({
type: 'POST',
url: 'YOUR_AUTHORIZATION_CODE_ENDPOINT_URL',
// Always include an X-Requested-With header to protect against CSRF attacks.
headers: {
'X-Requested-With': 'XMLHttpRequest'
},
contentType: 'application/octet-stream; charset=utf-8',
success: function(result) {
console.log(result);
},
processData: false,
data: authResult['code']
});
} else {
console.log('error: failed to obtain authorization code')
}
}
</script>
</head>
<body>
<button id="signinButton">Sign In With Google</button>
<script>
$('#signinButton').click(function() {
// Obtain an authorization code from Google
auth2.grantOfflineAccess().then(signInCallback);
});
</script>
</body>
</html>
HTTP/REST avec redirection
Utilisation du protocole OAuth 2.0 pour les applications de serveur Web afin d'envoyer un code d'autorisation depuis le navigateur de l'utilisateur vers votre plate-forme backend. Consentement de l'utilisateur géré par la redirection du navigateur de l'utilisateur vers Google.
/\*
\* Create form to request access token from Google's OAuth 2.0 server.
\*/
function oauthSignIn() {
// Google's OAuth 2.0 endpoint for requesting an access token
var oauth2Endpoint = 'https://accounts.google.com/o/oauth2/v2/auth';
// Create <form> element to submit parameters to OAuth 2.0 endpoint.
var form = document.createElement('form');
form.setAttribute('method', 'GET'); // Send as a GET request.
form.setAttribute('action', oauth2Endpoint);
// Parameters to pass to OAuth 2.0 endpoint.
var params = {'client\_id': 'YOUR_CLIENT_ID',
'redirect\_uri': 'YOUR_AUTHORIZATION_CODE_ENDPOINT_URL',
'response\_type': 'token',
'scope': 'https://www.googleapis.com/auth/drive.metadata.readonly',
'include\_granted\_scopes': 'true',
'state': 'pass-through value'};
// Add form parameters as hidden input values.
for (var p in params) {
var input = document.createElement('input');
input.setAttribute('type', 'hidden');
input.setAttribute('name', p);
input.setAttribute('value', params[p]);
form.appendChild(input);
}
// Add form to page and submit it to open the OAuth 2.0 endpoint.
document.body.appendChild(form);
form.submit();
}
Nouvelle méthode
Expérience utilisateur pop-up SIG
Cet exemple ne montre que la bibliothèque JavaScript de Google Identity Service à l'aide du modèle de code d'autorisation, une boîte de dialogue pop-up demandant le consentement de l'utilisateur et pour recevoir le code d'autorisation de Google. Il est qui illustrent le nombre minimal d'étapes nécessaires pour configurer d'obtenir le consentement des utilisateurs et d'envoyer un code d'autorisation à votre backend Google Cloud.
<!DOCTYPE html>
<html>
<head>
<script src="https://accounts.google.com/gsi/client" onload="initClient()" async defer></script>
</head>
<body>
<script>
var client;
function initClient() {
client = google.accounts.oauth2.initCodeClient({
client_id: 'YOUR_CLIENT_ID',
scope: 'https://www.googleapis.com/auth/calendar.readonly',
ux_mode: 'popup',
callback: (response) => {
var code_receiver_uri = 'YOUR_AUTHORIZATION_CODE_ENDPOINT_URI',
// Send auth code to your backend platform
const xhr = new XMLHttpRequest();
xhr.open('POST', code_receiver_uri, true);
xhr.setRequestHeader('Content-Type', 'application/x-www-form-urlencoded');
xhr.setRequestHeader('X-Requested-With', 'XMLHttpRequest');
xhr.onload = function() {
console.log('Signed in as: ' + xhr.responseText);
};
xhr.send('code=' + response.code);
// After receipt, the code is exchanged for an access token and
// refresh token, and the platform then updates this web app
// running in user's browser with the requested calendar info.
},
});
}
function getAuthCode() {
// Request authorization code and obtain user consent
client.requestCode();
}
</script>
<button onclick="getAuthCode();">Load Your Calendar</button>
</body>
</html>
Redirection SIG – Expérience utilisateur
Le modèle de code d'autorisation accepte les modes pop-up et redirige l'expérience utilisateur vers envoient un code d'autorisation par utilisateur au point de terminaison hébergé par votre plate-forme. Le mode d'expérience utilisateur de redirection est présenté ci-dessous:
<!DOCTYPE html>
<html>
<head>
<script src="https://accounts.google.com/gsi/client" onload="initClient()" async defer></script>
</head>
<body>
<script>
var client;
function initClient() {
client = google.accounts.oauth2.initCodeClient({
client_id: 'YOUR_CLIENT_ID',
scope: 'https://www.googleapis.com/auth/calendar.readonly \
https://www.googleapis.com/auth/photoslibrary.readonly',
ux_mode: 'redirect',
redirect_uri: 'YOUR_AUTHORIZATION_CODE_ENDPOINT_URI'
});
}
// Request an access token
function getAuthCode() {
// Request authorization code and obtain user consent
client.requestCode();
}
</script>
<button onclick="getAuthCode();">Load Your Calendar</button>
</body>
</html>
Bibliothèques JavaScript
Google Identity Services est une bibliothèque JavaScript unique utilisée pour les utilisateurs d'authentification et d'autorisation qui consolide et remplace les fonctionnalités et disponible dans plusieurs bibliothèques et modules différents:
Mesures à prendre lors de la migration vers Identity Services:
| Bibliothèque JS existante | Nouvelle bibliothèque JS | Remarques |
|---|---|---|
apis.google.com/js/api.js |
accounts.google.com/gsi/client |
Ajoutez une bibliothèque et suivez le flux implicite. |
apis.google.com/js/client.js |
accounts.google.com/gsi/client |
Ajoutez une bibliothèque et le flux avec code d'autorisation. |
Guide de référence pour les bibliothèques
Comparaison des objets et des méthodes entre l'ancien code JavaScript de Google Sign-In client et la nouvelle bibliothèque Google Identity Services, et Des notes contenant des informations supplémentaires et les actions à effectuer pendant la migration.
| Ancienne version | Nouveau | Remarques |
|---|---|---|
| L'objet GoogleAuth et les méthodes associées: | ||
| GoogleAuth.attachClickHandler() | Supprimer | |
| GoogleAuth.currentUser.get() | Supprimer | |
| GoogleAuth.currentUser.listen() | Supprimer | |
| GoogleAuth.disconnect() | google.accounts.oauth2.revoke | Remplacez l'ancienne version par la nouvelle. La révocation peut également se produire sur la page https://myaccount.google.com/permissions. |
| GoogleAuth.grantOfflineAccess() | Supprimez-le en suivant le flux avec code d'autorisation. | |
| GoogleAuth.isSignedIn.get() | Supprimer | |
| GoogleAuth.isSignedIn.listen() | Supprimer | |
| GoogleAuth.signIn() | Supprimer | |
| GoogleAuth.signOut() | Supprimer | |
| GoogleAuth.then() | Supprimer | |
| L'objet GoogleUser et les méthodes associées: | ||
| GoogleUser.disconnect() | google.accounts.id.revoke | Remplacez l'ancienne version par la nouvelle. La révocation peut également se produire sur la page https://myaccount.google.com/permissions. |
| GoogleUser.getAuthResponse() | requestCode() or requestAccessToken() | Remplacer l'ancien par le nouveau |
| GoogleUser.getBasicProfile() | Supprimer. Utilisez plutôt un jeton d'ID, consultez Migrer depuis Google Sign-In. | |
| GoogleUser.getGrantedScopes() | hasGrantedAnyScope() | Remplacer l'ancien par le nouveau |
| GoogleUser.getHostedDomain() | Supprimer | |
| GoogleUser.getId() | Supprimer | |
| GoogleUser.grantOfflineAccess() | Supprimez-le en suivant le flux avec code d'autorisation. | |
| GoogleUser.grant() | Supprimer | |
| GoogleUser.hasGrantedScopes() | hasGrantedAnyScope() | Remplacer l'ancien par le nouveau |
| GoogleUser.isSignedIn() | Supprimer | |
| GoogleUser.reloadAuthResponse() | requestAccessToken() | Supprimez l'ancien jeton, appelez-en un nouveau pour remplacer le jeton d'accès expiré ou révoqué. |
| L'objet gapi.auth2 et les méthodes associées: | ||
| Objet gapi.auth2.AuthorizeConfig | TokenClientConfig ou CodeClientConfig | Remplacer l'ancien par le nouveau |
| Objet gapi.auth2.AuthorizeResponse | Supprimer | |
| Objet gapi.auth2.AuthResponse | Supprimer | |
| gapi.auth2.authorize() | requestCode() or requestAccessToken() | Remplacer l'ancien par le nouveau |
| gapi.auth2.ClientConfig() | TokenClientConfig ou CodeClientConfig | Remplacer l'ancien par le nouveau |
| gapi.auth2.getAuthInstance() | Supprimer | |
| gapi.auth2.init() | initTokenClient() or initCodeClient() | Remplacer l'ancien par le nouveau |
| Objet gapi.auth2.offlineAccessOptions | Supprimer | |
| Objet gapi.auth2.SignInOptions | Supprimer | |
| L'objet gapi.signin2 et les méthodes associées: | ||
| gapi.signin2.render() | Supprimer. le chargement DOM HTML de g_id_signin ou un appel JS vers google.accounts.id.renderButton déclenche la connexion de l'utilisateur à un compte Google. | |
Exemples d'identifiants
Identifiants existants
La bibliothèque de la plate-forme Google Sign-In, la bibliothèque cliente des API Google pour JavaScript, ou les appels directs aux points de terminaison Google Auth 2.0, renvoient à la fois un jeton d'accès OAuth 2.0 et un jeton d'identification OpenID Connect de réponse.
Exemple de réponse contenant à la fois access_token et id_token:
{
"token_type": "Bearer",
"access_token": "ya29.A0ARrdaM-SmArZaCIh68qXsZSzyeU-8mxhQERHrP2EXtxpUuZ-3oW8IW7a6D2J6lRnZrRj8S6-ZcIl5XVEqnqxq5fuMeDDH_6MZgQ5dgP7moY-yTiKR5kdPm-LkuPM-mOtUsylWPd1wpRmvw_AGOZ1UUCa6UD5Hg",
"scope": "https://www.googleapis.com/auth/calendar.readonly",
"login_hint": "AJDLj6I2d1RH77cgpe__DdEree1zxHjZJr4Q7yOisoumTZUmo5W2ZmVFHyAomUYzLkrluG-hqt4RnNxrPhArd5y6p8kzO0t8xIfMAe6yhztt6v2E-_Bb4Ec3GLFKikHSXNh5bI-gPrsI",
"expires_in": 3599,
"id_token": "eyJhbGciOiJSUzI1NiIsImtpZCI6IjkzNDFhYmM0MDkyYjZmYzAzOGU0MDNjOTEwMjJkZDNlNDQ1MzliNTYiLCJ0eXAiOiJKV1QifQ.eyJpc3MiOiJhY2NvdW50cy5nb29nbGUuY29tIiwiYXpwIjoiNTM4MzQ0NjUzMjU1LTc1OGM1aDVpc2M0NXZnazI3ZDhoOGRlYWJvdnBnNnRvLmFwcHMuZ29vZ2xldXNlcmNvbnRlbnQuY29tIiwiYXVkIjoiNTM4MzQ0NjUzMjU1LTc1OGM1aDVpc2M0NXZnazI3ZDhoOGRlYWJvdnBnNnRvLmFwcHMuZ29vZ2xldXNlcmNvbnRlbnQuY29tIiwic3ViIjoiMTE3NzI2NDMxNjUxOTQzNjk4NjAwIiwiaGQiOiJnb29nbGUuY29tIiwiZW1haWwiOiJkYWJyaWFuQGdvb2dsZS5jb20iLCJlbWFpbF92ZXJpZmllZCI6dHJ1ZSwiYXRfaGFzaCI6IkJBSW55TjN2MS1ZejNLQnJUMVo0ckEiLCJuYW1lIjoiQnJpYW4gRGF1Z2hlcnR5IiwicGljdHVyZSI6Imh0dHBzOi8vbGgzLmdvb2dsZXVzZXJjb250ZW50LmNvbS9hLS9BT2gxNEdnenAyTXNGRGZvbVdMX3VDemRYUWNzeVM3ZGtxTE5ybk90S0QzVXNRPXM5Ni1jIiwiZ2l2ZW5fbmFtZSI6IkJyaWFuIiwiZmFtaWx5X25hbWUiOiJEYXVnaGVydHkiLCJsb2NhbGUiOiJlbiIsImlhdCI6MTYzODk5MTYzOCwiZXhwIjoxNjM4OTk1MjM4LCJqdGkiOiI5YmRkZjE1YWFiNzE2ZDhjYmJmNDYwMmM1YWM3YzViN2VhMDQ5OTA5In0.K3EA-3Adw5HA7O8nJVCsX1HmGWxWzYk3P7ViVBb4H4BoT2-HIgxKlx1mi6jSxIUJGEekjw9MC-nL1B9Asgv1vXTMgoGaNna0UoEHYitySI23E5jaMkExkTSLtxI-ih2tJrA2ggfA9Ekj-JFiMc6MuJnwcfBTlsYWRcZOYVw3QpdTZ_VYfhUu-yERAElZCjaAyEXLtVQegRe-ymScra3r9S92TA33ylMb3WDTlfmDpWL0CDdDzby2asXYpl6GQ7SdSj64s49Yw6mdGELZn5WoJqG7Zr2KwIGXJuSxEo-wGbzxNK-mKAiABcFpYP4KHPEUgYyz3n9Vqn2Tfrgp-g65BQ",
"session_state": {
"extraQueryParams": {
"authuser": "0"
}
},
"first_issued_at": 1638991637982,
"expires_at": 1638995236982,
"idpId": "google"
}
Identifiants Google Identity Services
La bibliothèque Google Identity Services renvoie:
Jeton d'accès utilisé pour l'autorisation:
{ "access_token": "ya29.A0ARrdaM_LWSO-uckLj7IJVNSfnUityT0Xj-UCCrGxFQdxmLiWuAosnAKMVQ2Z0LLqeZdeJii3TgULp6hR_PJxnInBOl8UoUwWoqsrGQ7-swxgy97E8_hnzfhrOWyQBmH6zs0_sUCzwzhEr_FAVqf92sZZHphr0g", "token_type": "Bearer", "expires_in": 3599, "scope": "https://www.googleapis.com/auth/calendar.readonly" }ou un jeton d'ID lorsqu'il est utilisé pour l'authentification:
{ "clientId": "538344653255-758c5h5isc45vgk27d8h8deabovpg6to.apps.googleusercontent.com", "credential": "eyJhbGciOiJSUzI1NiIsImtpZCI6ImMxODkyZWI0OWQ3ZWY5YWRmOGIyZTE0YzA1Y2EwZDAzMjcxNGEyMzciLCJ0eXAiOiJKV1QifQ.eyJpc3MiOiJodHRwczovL2FjY291bnRzLmdvb2dsZS5jb20iLCJuYmYiOjE2MzkxNTcyNjQsImF1ZCI6IjUzODM0NDY1MzI1NS03NThjNWg1aXNjNDV2Z2syN2Q4aDhkZWFib3ZwZzZ0by5hcHBzLmdvb2dsZXVzZXJjb250ZW50LmNvbSIsInN1YiI6IjExNzcyNjQzMTY1MTk0MzY5ODYwMCIsIm5vbmNlIjoiZm9vYmFyIiwiaGQiOiJnb29nbGUuY29tIiwiZW1haWwiOiJkYWJyaWFuQGdvb2dsZS5jb20iLCJlbWFpbF92ZXJpZmllZCI6dHJ1ZSwiYXpwIjoiNTM4MzQ0NjUzMjU1LTc1OGM1aDVpc2M0NXZnazI3ZDhoOGRlYWJvdnBnNnRvLmFwcHMuZ29vZ2xldXNlcmNvbnRlbnQuY29tIiwibmFtZSI6IkJyaWFuIERhdWdoZXJ0eSIsInBpY3R1cmUiOiJodHRwczovL2xoMy5nb29nbGV1c2VyY29udGVudC5jb20vYS0vQU9oMTRHZ3pwMk1zRkRmb21XTF91Q3pkWFFjc3lTN2RrcUxOcm5PdEtEM1VzUT1zOTYtYyIsImdpdmVuX25hbWUiOiJCcmlhbiIsImZhbWlseV9uYW1lIjoiRGF1Z2hlcnR5IiwiaWF0IjoxNjM5MTU3NTY0LCJleHAiOjE2MzkxNjExNjQsImp0aSI6IjRiOTVkYjAyZjU4NDczMmUxZGJkOTY2NWJiMWYzY2VhYzgyMmI0NjUifQ.Cr-AgMsLFeLurnqyGpw0hSomjOCU4S3cU669Hyi4VsbqnAV11zc_z73o6ahe9Nqc26kPVCNRGSqYrDZPfRyTnV6g1PIgc4Zvl-JBuy6O9HhClAK1HhMwh1FpgeYwXqrng1tifmuotuLQnZAiQJM73Gl-J_6s86Buo_1AIx5YAKCucYDUYYdXBIHLxrbALsA5W6pZCqqkMbqpTWteix-G5Q5T8LNsfqIu_uMBUGceqZWFJALhS9ieaDqoxhIqpx_89QAr1YlGu_UO6R6FYl0wDT-nzjyeF5tonSs3FHN0iNIiR3AMOHZu7KUwZaUdHg4eYkU-sQ01QNY_11keHROCRQ", "select_by": "user" }
Réponse de jeton non valide
Exemple de réponse de Google lors d'une tentative d'envoi d'une requête API à l'aide d'une jeton d'accès expiré, révoqué ou non valide:
En-têtes de réponse HTTP
www-authenticate: Bearer realm="https://accounts.google.com/", error="invalid_token"
Corps de la réponse
{
"error": {
"code": 401,
"message": "Request had invalid authentication credentials. Expected OAuth 2 access token, login cookie or other valid authentication credential. See https://developers.google.com/identity/sign-in/web/devconsole-project.",
"errors": [
{
"message": "Invalid Credentials",
"domain": "global",
"reason": "authError",
"location": "Authorization",
"locationType": "header"
}
],
"status": "UNAUTHENTICATED"
}
}