Eseguire la migrazione ai Servizi di identità Google

Panoramica

Per ottenere un token di accesso per utente per chiamare le API di Google, Google offre più Librerie JavaScript:

Questa guida fornisce le istruzioni per eseguire la migrazione da queste librerie al Libreria Servizi di identità.

Seguendo questa guida, imparerai a:

  • sostituire la libreria della piattaforma deprecata con la libreria Servizi di identità, e
  • Se utilizzi la libreria client dell'API, rimuovi il modulo gapi.auth2 deprecato, i suoi metodi e oggetti, sostituendoli con equivalenti dei servizi di identità.

Per una descrizione di cosa è cambiato con Identity Services JavaScript consulta la panoramica e come funziona l'autorizzazione utente per consultarli termini e concetti chiave.

Se cerchi l'autenticazione per la registrazione e l'accesso degli utenti, consulta Eseguire la migrazione da Accedi con Google.

Identifica il flusso di autorizzazione

Esistono due possibili flussi di autorizzazione utente: implicita e autorizzazione le API nel tuo codice.

Esamina l'app web per identificare il tipo di flusso di autorizzazione attualmente in uso.

Indicazioni che la tua app web utilizza il flusso implicito:

  • La tua app web è basata esclusivamente su browser e non ha una piattaforma di backend.
  • L'utente deve essere presente per chiamare le API di Google, la tua app utilizza solo l'accesso e non richiede token di aggiornamento.
  • La tua app web carica apis.google.com/js/api.js.
  • La tua implementazione è basata su OAuth 2.0 per il web lato client Applicazioni.
  • La tua app utilizza i moduli gapi.client o gapi.auth2 presenti in Libreria client dell'API di Google per JavaScript.

Indicazioni che la tua app web utilizza il flusso del codice di autorizzazione:

  • La tua implementazione si basa su:

  • L'app viene eseguita sia nel browser dell'utente sia sulla tua piattaforma di backend.

  • La tua piattaforma di backend ospita un endpoint del codice di autorizzazione.

  • La tua piattaforma di backend chiama le API di Google per conto degli utenti senza richiedere perché siano presenti, una modalità anche nota come modalità offline.

  • I token di aggiornamento vengono gestiti e archiviati dalla tua piattaforma di backend.

In alcuni casi, il codebase potrebbe supportare entrambi i flussi.

Scegli un flusso di autorizzazione

Prima di iniziare la migrazione devi stabilire se stai continuando flusso esistente o l'adozione di un flusso diverso soddisfa al meglio le tue esigenze.

Esamina la scelta di un flusso di autorizzazione per comprendere le principali differenze e i compromessi tra i due flussi.

Nella maggior parte dei casi, è consigliato il flusso del codice di autorizzazione in quanto offre il più alto livello di sicurezza degli utenti. L'implementazione di questo flusso consente inoltre piattaforma per aggiungere più facilmente nuove funzionalità offline come il recupero degli aggiornamenti di informare gli utenti in caso di modifiche importanti apportate al calendario, alle foto, alle iscrizioni e così via.

Scegli un flusso di autorizzazione utilizzando i selettori riportati di seguito.

Flusso implicito

Ottieni un token di accesso da utilizzare nel browser mentre l'utente è presente.

Gli esempi di flusso implicito mostrano le app web prima e dopo la migrazione a Servizi di identità.

Flusso del codice di autorizzazione

Un codice di autorizzazione per utente emesso da Google viene consegnato al tuo backend su Google Cloud, in cui viene poi scambiato un token di accesso e un token di aggiornamento.

Gli esempi di flusso del codice di autorizzazione mostrano le app web prima e dopo la migrazione a Identity Services.

Nella guida, segui le istruzioni in grassetto per Aggiungi, Rimuovi, Aggiorna o Sostituisci le funzionalità esistenti.

Modifiche all'app web nel browser

Questa sezione esamina le modifiche che apporterai all'app web nel browser quando migrazione alla libreria JavaScript dei Servizi di identità Google.

Identificazione del codice interessato e test

Un cookie di debug può aiutarti a individuare il codice interessato e a testare dopo il ritiro comportamento degli utenti.

Nelle app di grandi dimensioni o complesse, può essere difficile trovare tutto il codice interessato dal il ritiro del modulo gapi.auth2. Per registrare l'utilizzo esistente di a breve funzionalità deprecata alla console, imposta il valore G_AUTH2_MIGRATION cookie per informational. Se vuoi, aggiungi i due punti seguiti in base a un valore chiave per accedere anche all'archiviazione sessione. Dopo l'accesso e la ricezione delle credenziali di revisione o inviare i log raccolti a un backend per utilizzarli in un secondo momento e analisi. Ad esempio, informational:showauth2use salva l'origine e l'URL in un chiave di archiviazione della sessione denominata showauth2use.

Per verificare il comportamento dell'app quando il modulo gapi.auth2 non è più caricato, imposta il valore del cookie G_AUTH2_MIGRATION in enforced. Ciò consente di testare comportamento successivo al ritiro prima della data di applicazione.

Possibili valori dei cookie G_AUTH2_MIGRATION:

  • enforced Non caricare il modulo gapi.auth2.
  • informational Registra l'utilizzo delle funzionalità deprecate nella console JS. Registra anche allo spazio di archiviazione della sessione quando è impostato un nome di chiave facoltativo: informational:key-name.

Per ridurre al minimo l'impatto sugli utenti, ti consigliamo di impostare prima questo cookie localmente durante lo sviluppo e il test, prima di utilizzarlo in ambienti di produzione.

Librerie e moduli

Il modulo gapi.auth2 gestisce l'autenticazione utente per l'accesso e le informazioni per l'autorizzazione, sostituire questo modulo deprecato e i relativi oggetti con la libreria Servizi di identità Google.

Aggiungi la libreria Servizi di identità all'app web includendola nel documento:

<script src="https://accounts.google.com/gsi/client" async defer></script>

Rimuovi eventuali istanze di caricamento del modulo auth2 utilizzando gapi.load('auth2', function).

La libreria dei Servizi di identità Google sostituisce l'utilizzo del modulo gapi.auth2. Puoi continuare a utilizzare il modulo gapi.client dall'API di Google libreria client per JavaScript e sfrutta la sua creazione automatica. di metodi JS richiamabili da un documento di rilevamento, raggruppando più chiamate API in batch, e la funzionalità di gestione CORS.

Cookie

L'autorizzazione dell'utente non richiede l'uso di cookie.

Per informazioni dettagliate su come l'autenticazione utente, vedi Eseguire la migrazione da Accedi con Google utilizza i cookie e In che modo Google utilizza i cookie per l'utilizzo dei cookie da parte di altri Prodotti e servizi Google.

Credenziali

Google Identity Services separa l'autenticazione e l'autorizzazione degli utenti due operazioni distinte e credenziali utente sono separate: il token ID utilizzato che un utente viene restituito separatamente dal token di accesso usato autorizzazione.

Per visualizzare queste modifiche, vedi credenziali di esempio.

Flusso implicito

Separa autenticazione e autorizzazione dell'utente rimuovendo il profilo utente e la gestione dei flussi di autorizzazione.

Rimuovi questi riferimenti del client JavaScript di Accedi con Google:

Metodi

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

Flusso del codice di autorizzazione

Identity Services separa le credenziali nel browser in token ID e accesso di accesso. Questa modifica non si applica alle credenziali ottenute tramite Chiamate agli endpoint Google OAuth 2.0 dalla piattaforma di backend o librerie in esecuzione su un server sicuro sulla tua piattaforma come Google Cloud API Node.js.

Stato sessione

In precedenza, Accedi con Google ti aiutava a gestire lo stato di accesso dell'utente utilizzando:

Sei responsabile della gestione dello stato di accesso e delle sessioni utente al tuo dell'app.

Rimuovi questi riferimenti del client JavaScript di Accedi con Google:

Oggetti:

  • gapi.auth2.SignInOptions

Metodi:

  • GoogleAuth.attachClickHandler()
  • GoogleAuth.isSignedIn()
  • GoogleAuth.isSignedIn.get()
  • GoogleAuth.isSignedIn.listen()
  • GoogleAuth.signIn()
  • GoogleAuth.signOut()
  • GoogleAuth.currentUser.get()
  • GoogleAuth.currentUser.listen()
  • GoogleUser.isSignedIn()

Configurazione client

Aggiorna l'app web per inizializzare un client token per i valori impliciti o del codice di autorizzazione.

Rimuovi questi riferimenti del client JavaScript di Accedi con Google:

Oggetti:

  • gapi.auth2.ClientConfig
  • gapi.auth2.OfflineAccessOptions

Metodi:

  • gapi.auth2.getAuthInstance()

  • GoogleUser.grant()

Flusso implicito

Aggiungi un oggetto TokenClientConfig e una chiamata initTokenClient() a configurare l'app web, seguendo l'esempio in inizializzare un token di rete.

Sostituisci i riferimenti del client JavaScript di Accedi con Google con Google Servizi di identità:

Oggetti:

  • gapi.auth2.AuthorizeConfig con TokenClientConfig

Metodi:

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

Parametri:

  • gapi.auth2.AuthorizeConfig.login_hint con TokenClientConfig.login_hint.
  • gapi.auth2.GoogleUser.getHostedDomain() con TokenClientConfig.hd.

Flusso del codice di autorizzazione

Aggiungi un oggetto CodeClientConfig e una chiamata initCodeClient() da configurare nell'app web, seguendo l'esempio in inizializzare un client di codice.

Quando passi dal flusso implicito al flusso del codice di autorizzazione:

Rimuovere i riferimenti del client JavaScript di Accedi con Google

Oggetti:

  • gapi.auth2.AuthorizeConfig

Metodi:

  • gapi.auth2.init()

Parametri:

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

Richiesta di token

Un gesto dell'utente, ad esempio il clic su un pulsante, genera una richiesta che genera il token di accesso che viene restituito direttamente al browser dell'utente con o alla tua piattaforma di backend dopo aver scambiato un codice di autorizzazione per utente un token di accesso e un token di aggiornamento.

Flusso implicito

È possibile ottenere e utilizzare token di accesso nel browser mentre l'utente ha eseguito l'accesso e ha una sessione attiva con Google. Per la modalità implicita, un utente è necessario un gesto per richiedere un token di accesso, anche se si è verificato richiesta.

Sostituisci i riferimenti del client JavaScript di Accedi con Google: con Google Servizi di identità:

Metodi:

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

Aggiungi un link o un pulsante per chiamare requestAccessToken() e avviare la flusso popup UX per richiedere un token di accesso o per ottenere un nuovo token del token esistente.

Aggiorna il codebase per:

  • Attiva il flusso del token OAuth 2.0 con requestAccessToken().
  • Supporta l'autorizzazione incrementale utilizzando requestAccessToken e OverridableTokenClientConfig per separare una richiesta per più ambiti in più richieste più piccole.
  • Richiedi un nuovo token quando quello esistente scade o viene revocato.

L'uso di più ambiti può richiedere modifiche strutturali al codebase richiedere l'accesso agli ambiti solo quando sono necessari, anziché tutti in una volta, questa è nota come autorizzazione incrementale. Ogni richiesta deve contenere il maggior numero possibile di ambiti e idealmente un singolo ambito. Scopri come gestire l'utente Consenso per saperne di più su come aggiornare l'app per autorizzazione.

Alla scadenza di un token di accesso, il modulo gapi.auth2 ottiene automaticamente un nuovo token di accesso valido per la tua app web. Per una maggiore sicurezza degli utenti, il processo di aggiornamento automatico dei token non è supportato dall'identità Google Libreria di servizi. L'app web deve essere aggiornata per rilevare un accesso scaduto e richiederne uno nuovo. Per ulteriori informazioni, consulta la sezione Gestione dei token riportata di seguito.

Flusso del codice di autorizzazione

Aggiungi un link o un pulsante per chiamare requestCode() e richiedere un'autorizzazione un codice fornito da Google. Per un esempio, vedi Attivare il flusso di codice OAuth 2.0.

Per ulteriori informazioni su come rispondere a un avviso, consulta la sezione Gestione dei token riportata di seguito. token di accesso scaduto o revocato.

Gestione dei token

Aggiungi la gestione degli errori per rilevare le chiamate API di Google non riuscite quando un codice è scaduto di accesso revocato e per richiedere un nuovo token di accesso valido.

Un codice di stato HTTP 401 Unauthorized e un messaggio di errore invalid_token sono restituiti dalle API di Google quando viene utilizzato un token di accesso scaduto o revocato. Per un Ad esempio, consulta Risposta di token non valido.

Token scaduti

I token di accesso sono di breve durata e spesso sono validi solo per pochi minuti.

Revoca del token

In qualsiasi momento, il proprietario di un Account Google può revocare il consenso concesso in precedenza. Attività in modo da invalidare i token di accesso e di aggiornamento esistenti. La revoca può essere attivato dalla tua piattaforma utilizzando revoke() o tramite un Account.

Sostituisci i riferimenti del client JavaScript di Accedi con Google: con Google Servizi di identità:

Metodi:

  • getAuthInstance().disconnect() con google.accounts.oauth2.revoke()
  • GoogleUser.disconnect() con google.accounts.oauth2.revoke()

Chiamare revoke quando un utente elimina il proprio account sulla tua piattaforma oppure vuole rimuovere il consenso alla condivisione dei dati con la tua app.

Google mostra una finestra di dialogo per il consenso all'utente quando si utilizza l'app web o il backend la piattaforma richiede un token di accesso. Guarda alcuni esempi di finestre di dialogo per il consenso mostrate da Google agli utenti.

Prima di emettere un token di accesso all'app, viene utilizzato un token Google esistente per richiedere il consenso dell'utente e registrare il risultato. L'utente potrebbe essere necessario accedere a un Account Google se una sessione esistente non ha sono già stati definiti.

Accesso utente

Gli utenti possono aver eseguito l'accesso a un Account Google in una scheda del browser separata oppure in modo nativo tramite un browser o un sistema operativo. Ti consigliamo di aggiungere Accedi con Google al tuo sito per stabilire una sessione attiva tra un Account Google e il browser quando l'utente apre per la prima volta la tua app. In questo modo puoi offrire vantaggi:

  • Riduce al minimo il numero di volte in cui un utente deve eseguire l'accesso, richiedendo un accesso avvia la procedura di accesso all'Account Google se una sessione attiva non esistono già.
  • Utilizza direttamente il campo email del token ID JWT credential come valore di il parametro login_hint in CodeClientConfig o TokenClientConfig di oggetti strutturati. Ciò è particolarmente utile se la tua piattaforma non mantiene una di gestione degli account utente.
  • Cerca e associa un Account Google a un account utente locale esistente su la piattaforma, contribuendo a ridurre al minimo gli account duplicati.
  • Quando viene creato un nuovo account locale, le finestre di dialogo di registrazione e il flusso possono essere chiaramente separate dalle finestre di dialogo e dai flussi di autenticazione degli utenti, il numero di passaggi necessari e il miglioramento del tasso di abbandono.

Dopo l'accesso e prima che venga emesso un token di accesso, gli utenti devono fornire il consenso della tua applicazione per gli ambiti richiesti.

Dopo il consenso, viene restituito un token di accesso insieme a un elenco di ambiti approvati o rifiutato dall'utente.

Le autorizzazioni granulari consentono agli utenti di approvare o negare singoli ambiti. Quando richiedendo l'accesso a più ambiti, ogni ambito viene concesso o rifiutato indipendenti dagli altri ambiti. In base alla scelta dell'utente, l'app viene scelta in modo selettivo abilita caratteristiche e funzionalità che dipendono da un singolo ambito.

Flusso implicito

Sostituisci i riferimenti del client JavaScript di Accedi con Google con Google Servizi di identità:

Oggetti:

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

Metodi:

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

Rimuovi i riferimenti del client JavaScript di Accedi con Google:

Metodi:

  • GoogleUser.getAuthResponse()

Aggiorna l'app web con hasGrantedAllScopes() e hasGrantedAnyScope() seguendo questo esempio di autorizzazioni granulari.

Flusso del codice di autorizzazione

Aggiorna o aggiungi un endpoint del codice di autorizzazione al tuo backend seguendo le istruzioni riportate nella sezione relativa alla gestione del codice di autorizzazione.

Aggiorna la piattaforma per seguire i passaggi descritti nella sezione Utilizzare il codice Guida ai modelli per convalidare la richiesta, ottenere un token di accesso e aggiornare di accesso.

Aggiornare la piattaforma per attivare o disattivare selettivamente le funzionalità e di funzionalità in base ai singoli ambiti approvati dall'utente seguendo le istruzioni per l'autorizzazione incrementale ed esaminare gli ambiti di accesso concessi dall'utente.

Esempi di flussi impliciti

La vecchia maniera

Libreria client GAPI

Esempio della libreria client dell'API di Google per JavaScript in esecuzione nel browser utilizzando una finestra di dialogo popup per il consenso dell'utente.

Il modulo gapi.auth2 viene caricato e utilizzato automaticamente da gapi.client.init() e così via.

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

Libreria client JS

OAuth 2.0 per le applicazioni web lato client in esecuzione nel browser utilizzando una finestra di dialogo popup per il consenso dell'utente.

Il modulo gapi.auth2 viene caricato manualmente.

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

Endpoint OAuth 2.0

OAuth 2.0 per le applicazioni web lato client in esecuzione nel browser utilizzando reindirizza a Google per il consenso degli utenti.

Questo esempio mostra le chiamate dirette agli endpoint OAuth 2.0 di Google dalla browser dell'utente e non utilizza il modulo gapi.auth2 o un codice JavaScript libreria.

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

Il nuovo modo

Solo GIS

Questo esempio mostra solo la libreria JavaScript di Google Identity Service utilizzando il modello di token e una finestra di dialogo popup per il consenso dell'utente. È fornita per illustrare il numero minimo di passaggi necessari per configurare richiedere un token di accesso e chiamare un'API di 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 asincrono/in attesa

Questo esempio mostra come aggiungere la libreria di Google Identity Service utilizzando di token, rimuovi il modulo gapi.auth2 e chiama un'API utilizzando Libreria client dell'API di Google per JavaScript.

Le promesse, l'asinc e l'attesa vengono utilizzate per applicare l'ordine di caricamento della libreria e per intercettare e riprovare a eseguire l'autorizzazione. Una chiamata API viene effettuata solo dopo che di accesso a Google Cloud.

Gli utenti devono premere il pulsante "Mostra calendario" quando il token di accesso non è presente al primo caricamento della pagina o in un secondo momento dopo il token di accesso è scaduto.

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

Callback GAPI

Questo esempio mostra come aggiungere la libreria di Google Identity Service utilizzando di token, rimuovi il modulo gapi.auth2 e chiama un'API utilizzando Libreria client dell'API di Google per JavaScript.

Le variabili vengono utilizzate per applicare l'ordine di caricamento della libreria. Le chiamate GAPI vengono effettuate dal callback dopo che è stato restituito un token di accesso valido.

Gli utenti devono premere il pulsante Mostra calendario alla prima visualizzazione della pagina vengono caricati e nuovamente aggiornati quando desiderano aggiornare le informazioni del proprio calendario.

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

Esempi di flusso del codice di autorizzazione

L'esperienza utente popup della libreria di Google Identity Service può utilizzare un reindirizzamento URL a restituire un codice di autorizzazione direttamente all'endpoint del token di backend oppure Gestore di callback JavaScript in esecuzione nel browser dell'utente che esegue il proxy della la risposta alla tua piattaforma. In entrambi i casi, la piattaforma di backend completerà il flusso OAuth 2.0 per ottenere un token di aggiornamento e di accesso validi.

La vecchia maniera

App web lato server

Accedi con Google per le app lato server in esecuzione sulla piattaforma di backend utilizzando un reindirizzamento a Google per il consenso dell'utente.

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

Utilizzo di OAuth 2.0 per applicazioni server web per inviare il codice di autorizzazione dal browser dell'utente alla tua piattaforma di backend. Consenso degli utenti gestito da reindirizzando il browser dell'utente a 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 &lt;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();
}

Il nuovo modo

UX popup GIS

Questo esempio mostra solo la libreria JavaScript di Google Identity Service utilizzando il modello del codice di autorizzazione, una finestra di dialogo popup per il consenso dell'utente e di callback per ricevere il codice di autorizzazione da Google. È fornita per illustrare il numero minimo di passaggi necessari per configurare client, ottieni il consenso e invia un codice di autorizzazione al tuo backend completamente gestita.

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

UX con reindirizzamento GIS

Il modello del codice di autorizzazione supporta le modalità popup e di reindirizzamento UX alle Inviare un codice di autorizzazione per utente all'endpoint ospitato dalla tua piattaforma. La modalità UX di reindirizzamento è mostrata qui:

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

Librerie JavaScript

I servizi di identità Google sono una singola libreria JavaScript utilizzata per l'utente di autenticazione e autorizzazione che consolida e sostituisce funzioni e presenti in più librerie e moduli diversi:

Azioni da intraprendere durante la migrazione ai Servizi di identità:

Libreria JS esistente Nuova libreria JS Note
apis.google.com/js/api.js accounts.google.com/gsi/client Aggiungi una nuova libreria e segui il flusso implicito.
apis.google.com/js/client.js accounts.google.com/gsi/client Aggiungi una nuova libreria e il flusso del codice di autorizzazione.

Riferimento rapido per le librerie

Confronto di oggetti e metodi tra il vecchio JavaScript di Accedi con Google nella libreria client e nella nuova libreria Servizi di identità Google e Note con informazioni aggiuntive e azioni da intraprendere durante la migrazione.

Vecchio Nuovo Note
Oggetto GoogleAuth e metodi associati:
GoogleAuth.attachClickHandler() Rimuovi
GoogleAuth.currentUser.get() Rimuovi
GoogleAuth.currentUser.listen() Rimuovi
GoogleAuth.disconnect() google.accounts.oauth2.revoke Sostituisci il vecchio con quello nuovo. La revoca può avvenire anche all'indirizzo https://myaccount.google.com/permissions
GoogleAuth.grantOfflineAccess() Rimuovilo e segui il flusso del codice di autorizzazione.
GoogleAuth.isSignedIn.get() Rimuovi
GoogleAuth.isSignedIn.listen() Rimuovi
GoogleAuth.signIn() Rimuovi
GoogleAuth.signOut() Rimuovi
GoogleAuth.then() Rimuovi
Oggetto GoogleUser e metodi associati:
GoogleUser.disconnect() google.accounts.id.revoke Sostituisci il vecchio con quello nuovo. La revoca può avvenire anche all'indirizzo https://myaccount.google.com/permissions
GoogleUser.getAuthResponse() requestCode() or requestAccessToken() Sostituisci vecchio con nuovo
GoogleUser.getBasicProfile() Rimuovi. Utilizza il token ID, consulta l'articolo Eseguire la migrazione da Accedi con Google.
GoogleUser.getGrantedScopes() hasGrantedAnyScope() Sostituisci vecchio con nuovo
GoogleUser.getHostedDomain() Rimuovi
GoogleUser.getId() Rimuovi
GoogleUser.grantOfflineAccess() Rimuovilo e segui il flusso del codice di autorizzazione.
GoogleUser.grant() Rimuovi
GoogleUser.hasGrantedScopes() hasGrantedAnyScope() Sostituisci vecchio con nuovo
GoogleUser.isSignedIn() Rimuovi
GoogleUser.reloadAuthResponse() requestAccessToken() Rimuovi il vecchio, chiama il nuovo per sostituire il token di accesso scaduto o revocato.
Oggetto gapi.auth2 e metodi associati:
Oggetto gapi.auth2.PermissionsConfig TokenClientConfig o CodeClientConfig Sostituisci vecchio con nuovo
Oggetto gapi.auth2.AuthorizedResponse Rimuovi
Oggetto gapi.auth2.AuthResponse Rimuovi
gapi.auth2.authorize() requestCode() or requestAccessToken() Sostituisci vecchio con nuovo
gapi.auth2.ClientConfig() TokenClientConfig o CodeClientConfig Sostituisci vecchio con nuovo
gapi.auth2.getAuthInstance() Rimuovi
gapi.auth2.init() initTokenClient() or initCodeClient() Sostituisci vecchio con nuovo
Oggetto gapi.auth2.OfflineAccessOptions Rimuovi
Oggetto gapi.auth2.SignInOptions Rimuovi
Oggetto gapi.signin2 e metodi associati:
gapi.signin2.render() Rimuovi. Caricamento del DOM HTML della classe g_id_signin o una chiamata JS google.accounts.id.renderButton attiva l'accesso dell'utente a un Account Google.

Credenziali di esempio

Credenziali esistenti

La libreria della piattaforma Accedi con Google e la libreria client dell'API di Google per di codice JavaScript o le chiamate dirette agli endpoint Google Auth 2.0 sia un token di accesso OAuth 2.0 sia un token ID OpenID Connect in un unico la risposta corretta.

Esempio di risposta contenente sia access_token sia 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"
  }

Credenziale Google Identity Services

La libreria dei Servizi di identità Google restituisce:

  • o un token di accesso quando viene utilizzato per l'autorizzazione:

    {
  "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"
}

  • oppure un token ID se utilizzato per l'autenticazione:

    {
  "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"
}

Risposta del token non valida

Esempio di risposta da parte di Google quando si tenta di effettuare una richiesta API utilizzando un token di accesso scaduto, revocato o non valido:

Intestazioni delle risposte HTTP

  www-authenticate: Bearer realm="https://accounts.google.com/", error="invalid_token"

Corpo della risposta

  {
    "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"
    }
  }