Migrer vers les services Google Identity

Flux implicite

Permet d'obtenir un jeton d'accès pour une utilisation dans le navigateur lorsque l'utilisateur est présent.

Les exemples de flux implicites montrent les applications Web avant et après la migration vers Identity Services.

Flux de code d'autorisation

Un code d'autorisation par utilisateur émis par Google est transmis à votre plate-forme backend, qui l'échange ensuite contre un jeton d'accès et un jeton d'actualisation.

Les exemples de flux de code d'autorisation montrent les applications Web avant et après la migration vers Identity Services.

Flux implicite

Séparez l'authentification et l'autorisation des utilisateurs en supprimant la gestion du profil utilisateur des flux d'autorisation.

Supprimez ces références de client JavaScript Google Sign-In:

Méthodes

• GoogleUser.getBasicProfile()
• GoogleUser.getId()

Flux de code d'autorisation

Identity Services sépare les identifiants du navigateur en jetons d'ID et d'accès. Cette modification ne s'applique pas aux identifiants obtenus via des appels directs aux points de terminaison Google OAuth 2.0 depuis votre plate-forme de backend, ni aux bibliothèques exécutées sur un serveur sécurisé de votre plate-forme tel que le client Node.js des API Google.

Flux implicite

Ajoutez un objet TokenClientConfig et un appel initTokenClient() pour configurer votre application Web, en suivant l'exemple de la page Initialiser un client de jeton.

Remplacez les références client JavaScript Google Sign-In par les services Google Identity:

Objets:

• gapi.auth2.AuthorizeConfig avec TokenClientConfig

Méthodes :

• gapi.auth2.init() avec google.accounts.oauth2.initTokenClient()

Paramètres :

• gapi.auth2.AuthorizeConfig.login_hint correspond à TokenClientConfig.hint.
• gapi.auth2.GoogleUser.getHostedDomain() correspond à TokenClientConfig.hosted_domain.

Flux de 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.

Lorsque vous passez du flux implicite au code d'autorisation:

Supprimer Références client JavaScript Google Sign-In

Objets:

• gapi.auth2.AuthorizeConfig

Méthodes :

• gapi.auth2.init()

Paramètres :

• gapi.auth2.AuthorizeConfig.login_hint
• gapi.auth2.GoogleUser.getHostedDomain()

Flux implicite

Des jetons d'accès peuvent être obtenus et utilisés dans le navigateur lorsque l'utilisateur est connecté et a une session active avec Google. En mode implicite, un geste utilisateur est requis pour demander un jeton d'accès, même s'il y a eu une requête précédente.

Remplacez les références client JavaScript Google Sign-In par les services Google Identity :

Méthodes :

• gapi.auth2.authorize() avec TokenClient.requestAccessToken()
• GoogleUser.reloadAuthResponse() avec TokenClient.requestAccessToken()

Ajoutez un lien ou un bouton pour appeler requestAccessToken() afin de lancer le flux d'expérience utilisateur pop-up pour demander un jeton d'accès ou pour obtenir un nouveau jeton lorsque le jeton existant expire.

Mettez à jour votre codebase comme suit:

• Déclenchez le flux de jetons OAuth 2.0 avec requestAccessToken().
• Autorisez l'autorisation incrémentielle en utilisant requestAccessToken et OverridableTokenClientConfig pour séparer une requête pour de nombreux 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 afin de demander l'accès aux champs d'application uniquement lorsque ceux-ci sont nécessaires plutôt que simultanément. C'est ce qu'on appelle une autorisation incrémentielle. Chaque requête doit contenir le moins de champs d'application possible, et idéalement un seul. Découvrez comment gérer le consentement de l'utilisateur afin de mettre à jour votre application pour obtenir une autorisation incrémentielle.

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é des utilisateurs, ce processus d'actualisation automatique des jetons n'est pas pris en charge par la bibliothèque Google Identity Services. Votre application Web doit être mise à jour pour détecter un jeton d'accès expiré et en demander un nouveau. Pour en savoir plus, consultez la section sur la gestion des jetons ci-dessous.

Flux de code d'autorisation

Ajoutez un lien ou un bouton pour appeler requestCode() et demander un code d'autorisation à Google. Pour obtenir un exemple, consultez Déclencher le flux de code OAuth 2.0.

Consultez la section sur la gestion des jetons ci-dessous pour savoir comment répondre à un jeton d'accès expiré ou révoqué.

Flux implicite

Remplacez les références client JavaScript Google Sign-In par les services Google Identity:

Objets:

• gapi.auth2.AuthorizeResponse avec TokenClient.TokenResponse
• gapi.auth2.AuthResponse avec TokenClient.TokenResponse

Méthodes :

• GoogleUser.hasGrantedScopes() avec google.accounts.oauth2.hasGrantedAllScopes()
• GoogleUser.getGrantedScopes() avec google.accounts.oauth2.hasGrantedAllScopes()

Supprimer Références client JavaScript Google Sign-In:

Méthodes :

• GoogleUser.getAuthResponse()

Mettez à jour votre application Web avec hasGrantedAllScopes() et hasGrantedAnyScope() en suivant cet autorisation précise.

Flux de code d'autorisation

Mettez à jour ou ajoutez un point de terminaison du code d'autorisation à votre plate-forme backend en suivant les instructions de la page Gérer le code d'autorisation.

Mettez à jour votre plate-forme en suivant la procédure décrite dans le guide Utiliser un modèle de code pour valider la requête et obtenir un jeton d'accès et un jeton d'actualisation.

Mettez à jour votre plate-forme pour activer ou désactiver de manière sélective des fonctionnalités en fonction des champs d'application individuels que l'utilisateur a approuvés. Pour ce faire, suivez les instructions concernant l'autorisation incrémentielle et examinez les champs d'application d'accès accordés par l'utilisateur.

Bibliothèque cliente GAPI

Exemple de bibliothèque cliente des API Google pour JavaScript s'exécutant dans un navigateur à l'aide d'une fenêtre pop-up demandant le consentement des utilisateurs

Le module gapi.auth2 est automatiquement chargé et utilisé par gapi.client.init(). Il 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'une boîte de dialogue pop-up demandant le consentement des utilisateurs.

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 exécutées dans le navigateur à l'aide de redirections vers Google pour le consentement des utilisateurs.

Cet exemple présente des appels directs vers les points de terminaison OAuth 2.0 de Google à partir du navigateur de l'utilisateur et n'utilise ni le module gapi.auth2, ni une bibliothèque JavaScript.

<!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>

SIG uniquement

Cet exemple ne montre que la bibliothèque JavaScript Google Identity Service utilisant le modèle de jeton et la boîte de dialogue pop-up pour le consentement de l'utilisateur. Il est fourni pour illustrer le nombre minimal d'étapes requises pour configurer un 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 du modèle de jeton, supprimer le module gapi.auth2 et appeler une API à l'aide de la bibliothèque cliente des API Google pour JavaScript.

Les promesses, les requêtes asynchrones et les règles d'attente sont utilisées pour appliquer l'ordre de chargement des bibliothèques, ainsi que pour détecter les erreurs d'autorisation et effectuer de nouvelles tentatives. Un appel d'API n'est effectué qu'après la disponibilité d'un jeton d'accès valide.

Les utilisateurs doivent appuyer sur le bouton "Afficher l'agenda" lorsqu'il n'y a pas de jeton d'accès lors du premier chargement de la page, ou plus tard après l'expiration du jeton d'accès.

<!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 du modèle de jeton, supprimer le module gapi.auth2 et appeler une API à l'aide de la bibliothèque cliente des API Google pour JavaScript.

Les variables permettent d'appliquer l'ordre de chargement des bibliothèques. Les appels GAPI sont effectués depuis le rappel après le renvoi d'un jeton d'accès valide.

Les utilisateurs doivent appuyer sur le bouton "Afficher l'agenda" lors du premier chargement de la page, puis lorsqu'ils souhaitent 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>

Applications Web côté serveur

Google Sign-In pour les applications côté serveur exécutées sur la 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 d'OAuth 2.0 pour les applications de serveur Web pour envoyer le code d'autorisation du navigateur de l'utilisateur vers votre plate-forme backend. Consentement de l'utilisateur géré en redirigeant le 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();
}

Pop-up SIG (expérience utilisateur)

Dans cet exemple, seule la bibliothèque JavaScript Google Identity Service utilise le modèle de code d'autorisation. Une boîte de dialogue s'affiche pour que le gestionnaire de rappel et le consentement de l'utilisateur puissent recevoir le code d'autorisation de Google. Il est fourni pour illustrer le nombre minimal d'étapes requises pour configurer un client, obtenir le consentement de l'utilisateur et envoyer un code d'autorisation à votre plate-forme backend.

<!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>

Expérience utilisateur de redirection SIG

Le modèle de code d'autorisation est compatible avec les modes pop-up et de redirection de l'expérience utilisateur permettant d'envoyer 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 illustré ici:

<!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>