Questo documento spiega in che modo le applicazioni server web utilizzano le librerie client delle API di Google o gli endpoint Google OAuth 2.0 per implementare l'autorizzazione OAuth 2.0 per accedere alle API di Google.
OAuth 2.0 consente agli utenti di condividere dati specifici con un'applicazione, mantenendo privati i nomi utente, le password e altre informazioni. Ad esempio, un'applicazione può utilizzare OAuth 2.0 per ottenere l'autorizzazione degli utenti ad archiviare i file nei propri Google Drive.
Questo flusso OAuth 2.0 è specifico per l'autorizzazione degli utenti. È progettata per applicazioni che possono archiviare informazioni riservate e mantenere lo stato. Un'applicazione server web opportunamente autorizzata può accedere a un'API mentre l'utente interagisce con l'applicazione o dopo che l'utente ha abbandonato l'applicazione.
Le applicazioni server web spesso usano anche gli account di servizio per autorizzare le richieste API, in particolare quando vengono chiamate alle API Cloud l'accesso a dati basati sui progetti anziché a dati specifici dell'utente. Le applicazioni server web possono utilizzare gli account di servizio in combinazione con l'autorizzazione utente.
Librerie client
Gli esempi specifici per le lingue in questa pagina utilizzano le librerie client delle API di Google per implementare l'autorizzazione OAuth 2.0. Per eseguire gli esempi di codice, devi prima installare la libreria client per il tuo linguaggio.
Se utilizzi una libreria client dell'API di Google per gestire il flusso OAuth 2.0 dell'applicazione, la libreria client esegue molte azioni che altrimenti l'applicazione dovrebbe gestire autonomamente. Ad esempio, determina quando l'applicazione può utilizzare o aggiornare i token di accesso archiviati, nonché quando l'applicazione deve riacquisire il consenso. La libreria client genera inoltre URL di reindirizzamento corretti e aiuta a implementare gestori dei reindirizzamenti che scambiano codici di autorizzazione per i token di accesso.
Le librerie client delle API di Google per le applicazioni lato server sono disponibili per i seguenti linguaggi:
Prerequisiti
Abilita le API per il tuo progetto
Qualsiasi applicazione che chiama le API di Google deve abilitare queste API in API Console.
Per abilitare un'API per il tuo progetto:
- Open the API Library in Google API Console.
- If prompted, select a project, or create a new one.
- L' API Library elenco contiene tutte le API disponibili, raggruppate per famiglia di prodotti e popolarità. Se l'API che vuoi attivare non è visibile nell'elenco, utilizza la ricerca per trovarla oppure fai clic su Visualizza tutto nella famiglia di prodotti a cui appartiene.
- Seleziona l'API da attivare, poi fai clic sul pulsante Abilita.
- If prompted, enable billing.
- If prompted, read and accept the API's Terms of Service.
Crea credenziali di autorizzazione
Qualsiasi applicazione che utilizza OAuth 2.0 per accedere alle API di Google deve disporre di credenziali di autorizzazione che identificano l'applicazione per il server OAuth 2.0 di Google. I passaggi seguenti spiegano come creare le credenziali per il tuo progetto. Le applicazioni possono quindi utilizzare le credenziali per accedere alle API che hai abilitato per il progetto.
- Go to the Credentials page.
- Fai clic su Crea credenziali > ID client OAuth.
- Seleziona il tipo di applicazione Applicazione web.
- Compila il modulo e fai clic su Crea. Le applicazioni che utilizzano linguaggi e framework come PHP, Java, Python, Ruby e .NET devono specificare URI di reindirizzamento autorizzati. Gli URI di reindirizzamento sono gli endpoint a cui il server OAuth 2.0 può inviare risposte. Questi endpoint devono rispettare le regole di convalida di Google.
Per i test, puoi specificare gli URI che fanno riferimento alla macchina locale, ad esempio
http://localhost:8080
. Tieni presente che tutti gli esempi in questo documento utilizzanohttp://localhost:8080
come URI di reindirizzamento.Ti consigliamo di progettare gli endpoint di autenticazione dell'app in modo che l'applicazione non esponga i codici di autorizzazione ad altre risorse nella pagina.
Dopo aver creato le credenziali, scarica il file client_secret.json da API Console. Archivia in modo sicuro il file in una posizione accessibile solo alla tua applicazione.
Identificare gli ambiti di accesso
Gli ambiti consentono alla tua applicazione di richiedere l'accesso solo alle risorse di cui ha bisogno, consentendo al contempo agli utenti di controllare la quantità di accesso che concede all'applicazione. Pertanto, potrebbe esserci una relazione inversa tra il numero di ambiti richiesti e la probabilità di ottenere il consenso dell'utente.
Prima di iniziare a implementare l'autorizzazione OAuth 2.0, ti consigliamo di identificare gli ambiti a cui la tua app avrà bisogno dell'autorizzazione per accedere.
Ti consigliamo inoltre di fare in modo che la tua applicazione richieda l'accesso agli ambiti di autorizzazione tramite un processo di autorizzazione incrementale, in cui l'applicazione richiede l'accesso ai dati utente nel contesto. Questa best practice aiuta gli utenti a comprendere più facilmente perché la tua applicazione ha bisogno dell'accesso che richiede.
Il documento Ambiti API OAuth 2.0 contiene un elenco completo degli ambiti che potresti utilizzare per accedere alle API di Google.
Requisiti specifici per lingua
Per eseguire uno degli esempi di codice presenti in questo documento, devi disporre di un Account Google, dell'accesso a internet e di un browser web. Se utilizzi una delle librerie client API, consulta anche i requisiti specifici per il linguaggio riportati di seguito.
PHP
Per eseguire gli esempi di codice PHP in questo documento, sono necessari:
- PHP 5.6 o versioni successive con interfaccia a riga di comando (CLI) e estensione JSON installata.
- Lo strumento di gestione delle dipendenze Composer.
-
Libreria client delle API di Google per PHP:
composer require google/apiclient:^2.10
Python
Per eseguire gli esempi di codice Python in questo documento, ti serviranno:
- Python 2.6 o versioni successive
- Lo strumento di gestione dei pacchetti pip.
- Libreria client delle API di Google per Python:
pip install --upgrade google-api-python-client
google-auth
,google-auth-oauthlib
egoogle-auth-httplib2
per l'autorizzazione dell'utente.pip install --upgrade google-auth google-auth-oauthlib google-auth-httplib2
- Il framework dell'applicazione web Python Flask.
pip install --upgrade flask
- La libreria HTTP
requests
.pip install --upgrade requests
Ruby
Per eseguire gli esempi di codice Ruby in questo documento, sono necessari:
- Ruby 2.6 o versioni successive
-
La libreria di autenticazione di Google per Ruby:
gem install googleauth
-
Il framework per applicazioni web Sinatra Ruby.
gem install sinatra
Node.js
Per eseguire gli esempi di codice Node.js in questo documento, devi disporre di:
- L'LTS di manutenzione, LTS attivo o la release corrente di Node.js.
-
Il client Node.js delle API di Google:
npm install googleapis
HTTP/REST
Non è necessario installare alcuna libreria per poter chiamare direttamente gli endpoint OAuth 2.0.
Ottenere token di accesso OAuth 2.0
I passaggi seguenti mostrano in che modo la tua applicazione interagisce con il server OAuth 2.0 di Google per ottenere il consenso di un utente a eseguire una richiesta API per suo conto. L'applicazione deve avere questo consenso prima di poter eseguire una richiesta API di Google che richiede l'autorizzazione dell'utente.
L'elenco riportato di seguito riassume rapidamente questi passaggi:
- L'applicazione identifica le autorizzazioni di cui ha bisogno.
- L'applicazione reindirizza l'utente a Google insieme all'elenco delle autorizzazioni richieste.
- L'utente decide se concedere o meno le autorizzazioni alla tua applicazione.
- La tua applicazione scopre cosa ha deciso l'utente.
- Se l'utente ha concesso le autorizzazioni richieste, l'applicazione recupera i token necessari per effettuare richieste API per conto dell'utente.
Passaggio 1: imposta i parametri di autorizzazione
Il primo passaggio consiste nel creare la richiesta di autorizzazione. Questa richiesta imposta i parametri che identificano l'applicazione e definiscono le autorizzazioni che all'utente verrà chiesto di concedere all'applicazione.
- Se utilizzi una libreria client di Google per l'autenticazione e l'autorizzazione OAuth 2.0, puoi creare e configurare un oggetto che definisce questi parametri.
- Se chiami direttamente l'endpoint OAuth 2.0 di Google, genererai un URL e imposterai i parametri su quell'URL.
Le schede riportate di seguito definiscono i parametri di autorizzazione supportati per le applicazioni server web. Gli esempi specifici per il linguaggio mostrano inoltre come utilizzare una libreria client o una libreria di autorizzazione per configurare un oggetto che imposta quei parametri.
PHP
Lo snippet di codice riportato di seguito crea un oggetto Google\Client()
, che definisce i parametri nella richiesta di autorizzazione.
Questo oggetto utilizza le informazioni del file client_secret.json per identificare l'applicazione. Per ulteriori informazioni sul file, consulta Creazione di credenziali di autorizzazione. L'oggetto identifica inoltre gli ambiti a cui l'applicazione richiede l'autorizzazione per accedere e l'URL dell'endpoint di autenticazione dell'applicazione, che gestirà la risposta del server OAuth 2.0 di Google. Infine, il codice imposta i parametri facoltativi access_type
e include_granted_scopes
.
Ad esempio, questo codice richiede l'accesso offline di sola lettura al Google Drive di un utente:
$client = new Google\Client(); $client->setAuthConfig('client_secret.json'); $client->addScope(Google\Service\Drive::DRIVE_METADATA_READONLY); $client->setRedirectUri('http://' . $_SERVER['HTTP_HOST'] . '/oauth2callback.php'); // offline access will give you both an access and refresh token so that // your app can refresh the access token without user interaction. $client->setAccessType('offline'); // Using "consent" will prompt the user for consent $client->setPrompt('consent'); $client->setIncludeGrantedScopes(true); // incremental auth
La richiesta specifica le seguenti informazioni:
Parametri | |||||||
---|---|---|---|---|---|---|---|
client_id |
Obbligatorio
L'ID client della tua applicazione. Puoi trovare questo valore in API Console Credentials page. In PHP, chiama la funzione $client = new Google\Client(); $client->setAuthConfig('client_secret.json'); |
||||||
redirect_uri |
Obbligatorio
Determina dove il server API reindirizza l'utente dopo che l'utente completa il flusso di autorizzazione. Il valore deve corrispondere esattamente a uno degli URI di reindirizzamento autorizzati per il client OAuth 2.0, che hai configurato in API Console
Credentials pagedel client. Se questo valore non corrisponde a un URI di reindirizzamento autorizzato per il Tieni presente che lo schema Per impostare questo valore in PHP, chiama la funzione $client->setRedirectUri('https://oauth2.example.com/code'); |
||||||
scope |
Obbligatorio
Un elenco di ambiti delimitati da spazi che identificano le risorse a cui l'applicazione potrebbe accedere per conto dell'utente. Questi valori determinano la schermata di consenso che Google mostra all'utente. Gli ambiti consentono all'applicazione di richiedere l'accesso solo alle risorse di cui ha bisogno, permettendo al contempo agli utenti di controllare la quantità di accesso che concede alla tua applicazione. Esiste quindi una relazione inversa tra il numero di ambiti richiesti e la probabilità di ottenere il consenso dell'utente. Per impostare questo valore in PHP, chiama la funzione $client->addScope(Google\Service\Drive::DRIVE_METADATA_READONLY); Ti consigliamo che la tua applicazione richieda l'accesso agli ambiti di autorizzazione nel contesto, se possibile. Richiedendo l'accesso ai dati utente nel contesto, tramite l'autorizzazione incrementale, aiuti gli utenti a capire più facilmente perché la tua applicazione ha bisogno dell'accesso che richiede. |
||||||
access_type |
Consigliato
Indica se l'applicazione può aggiornare i token di accesso quando l'utente non è presente nel browser. I valori validi del parametro sono Imposta il valore su Per impostare questo valore in PHP, chiama la funzione $client->setAccessType('offline'); |
||||||
state |
Consigliato
Specifica qualsiasi valore stringa utilizzato dall'applicazione per mantenere lo stato tra la richiesta di autorizzazione e la risposta del server di autorizzazione.
Il server restituisce il valore esatto che invii come coppia Puoi utilizzare questo parametro per diversi scopi, ad esempio indirizzare l'utente alla risorsa corretta nell'applicazione, inviare nonce e mitigare la falsificazione delle richieste tra siti. Poiché il valore Per impostare questo valore in PHP, chiama la funzione $client->setState($sample_passthrough_value); |
||||||
include_granted_scopes |
Facoltativo
Consente alle applicazioni di utilizzare l'autorizzazione incrementale per richiedere l'accesso ad ambiti aggiuntivi nel contesto. Se imposti il valore di questo parametro su Per impostare questo valore in PHP, chiama la funzione $client->setIncludeGrantedScopes(true); |
||||||
enable_granular_consent |
Facoltativo
Il valore predefinito è |
||||||
login_hint |
Facoltativo
Se l'applicazione sa quale utente sta tentando di eseguire l'autenticazione, può utilizzare questo parametro per fornire un suggerimento al server di autenticazione di Google. Il server utilizza il suggerimento per semplificare il flusso di accesso precompilando il campo dell'email nel modulo di accesso o selezionando la sessione di accesso multiplo appropriata. Imposta il valore del parametro su un indirizzo email o su un identificatore Per impostare questo valore in PHP, chiama la funzione $client->setLoginHint('None'); |
||||||
prompt |
Facoltativo
Un elenco di prompt, delimitati da spazi e maiuscole, da presentare all'utente. Se non specifichi questo parametro, all'utente verrà richiesto solo la prima volta che il tuo progetto richiede l'accesso. Per maggiori informazioni, consulta Richiesta di un nuovo consenso. Per impostare questo valore in PHP, chiama la funzione $client->setPrompt('consent'); I valori possibili sono:
|
Python
Il seguente snippet di codice utilizza il modulo google-auth-oauthlib.flow
per creare la richiesta di autorizzazione.
Il codice crea un oggetto Flow
, che identifica l'applicazione utilizzando le informazioni del file client_secret.json scaricato dopo la creazione delle credenziali di autorizzazione. Questo oggetto identifica inoltre gli ambiti a cui l'applicazione richiede l'autorizzazione per accedere e l'URL dell'endpoint di autenticazione dell'applicazione, che gestirà la risposta del server OAuth 2.0 di Google. Infine, il codice imposta i parametri facoltativi access_type
e include_granted_scopes
.
Ad esempio, questo codice richiede l'accesso offline di sola lettura al Google Drive di un utente:
import google.oauth2.credentials import google_auth_oauthlib.flow # Use the client_secret.json file to identify the application requesting # authorization. The client ID (from that file) and access scopes are required. flow = google_auth_oauthlib.flow.Flow.from_client_secrets_file( 'client_secret.json', scopes=['https://www.googleapis.com/auth/drive.metadata.readonly']) # Indicate where the API server will redirect the user after the user completes # the authorization flow. The redirect URI is required. The value must exactly # match one of the authorized redirect URIs for the OAuth 2.0 client, which you # configured in the API Console. If this value doesn't match an authorized URI, # you will get a 'redirect_uri_mismatch' error. flow.redirect_uri = 'https://www.example.com/oauth2callback' # Generate URL for request to Google's OAuth 2.0 server. # Use kwargs to set optional request parameters. authorization_url, state = flow.authorization_url( # Enable offline access so that you can refresh an access token without # re-prompting the user for permission. Recommended for web server apps. access_type='offline', # Enable incremental authorization. Recommended as a best practice. include_granted_scopes='true')
La richiesta specifica le seguenti informazioni:
Parametri | |||||||
---|---|---|---|---|---|---|---|
client_id |
Obbligatorio
L'ID client della tua applicazione. Puoi trovare questo valore in API Console Credentials page. In Python, chiama il metodo flow = google_auth_oauthlib.flow.Flow.from_client_secrets_file( 'client_secret.json', scopes=['https://www.googleapis.com/auth/drive.metadata.readonly']) |
||||||
redirect_uri |
Obbligatorio
Determina dove il server API reindirizza l'utente dopo che l'utente completa il flusso di autorizzazione. Il valore deve corrispondere esattamente a uno degli URI di reindirizzamento autorizzati per il client OAuth 2.0, che hai configurato in API Console
Credentials pagedel client. Se questo valore non corrisponde a un URI di reindirizzamento autorizzato per il Tieni presente che lo schema Per impostare questo valore in Python, imposta la proprietà flow.redirect_uri = 'https://oauth2.example.com/code' |
||||||
scope |
Obbligatorio
Un elenco di ambiti che identificano le risorse a cui l'applicazione potrebbe accedere per conto dell'utente. Questi valori determinano la schermata di consenso che Google mostra all'utente. Gli ambiti consentono all'applicazione di richiedere l'accesso solo alle risorse di cui ha bisogno, permettendo al contempo agli utenti di controllare la quantità di accesso che concede alla tua applicazione. Esiste quindi una relazione inversa tra il numero di ambiti richiesti e la probabilità di ottenere il consenso dell'utente. In Python, utilizza lo stesso metodo utilizzato per impostare flow = google_auth_oauthlib.flow.Flow.from_client_secrets_file( 'client_secret.json', scopes=['https://www.googleapis.com/auth/drive.metadata.readonly']) Ti consigliamo che la tua applicazione richieda l'accesso agli ambiti di autorizzazione nel contesto, se possibile. Richiedendo l'accesso ai dati utente nel contesto, tramite l'autorizzazione incrementale, aiuti gli utenti a capire più facilmente perché la tua applicazione ha bisogno dell'accesso che richiede. |
||||||
access_type |
Consigliato
Indica se l'applicazione può aggiornare i token di accesso quando l'utente non è presente nel browser. I valori validi del parametro sono Imposta il valore su In Python, imposta il parametro authorization_url, state = flow.authorization_url( access_type='offline', include_granted_scopes='true') |
||||||
state |
Consigliato
Specifica qualsiasi valore stringa utilizzato dall'applicazione per mantenere lo stato tra la richiesta di autorizzazione e la risposta del server di autorizzazione.
Il server restituisce il valore esatto che invii come coppia Puoi utilizzare questo parametro per diversi scopi, ad esempio indirizzare l'utente alla risorsa corretta nell'applicazione, inviare nonce e mitigare la falsificazione delle richieste tra siti. Poiché il valore In Python, imposta il parametro authorization_url, state = flow.authorization_url( access_type='offline', state=sample_passthrough_value, include_granted_scopes='true') |
||||||
include_granted_scopes |
Facoltativo
Consente alle applicazioni di utilizzare l'autorizzazione incrementale per richiedere l'accesso ad ambiti aggiuntivi nel contesto. Se imposti il valore di questo parametro su In Python, imposta il parametro authorization_url, state = flow.authorization_url( access_type='offline', include_granted_scopes='true') |
||||||
enable_granular_consent |
Facoltativo
Il valore predefinito è |
||||||
login_hint |
Facoltativo
Se l'applicazione sa quale utente sta tentando di eseguire l'autenticazione, può utilizzare questo parametro per fornire un suggerimento al server di autenticazione di Google. Il server utilizza il suggerimento per semplificare il flusso di accesso precompilando il campo dell'email nel modulo di accesso o selezionando la sessione di accesso multiplo appropriata. Imposta il valore del parametro su un indirizzo email o su un identificatore In Python, imposta il parametro authorization_url, state = flow.authorization_url( access_type='offline', login_hint='None', include_granted_scopes='true') |
||||||
prompt |
Facoltativo
Un elenco di prompt, delimitati da spazi e maiuscole, da presentare all'utente. Se non specifichi questo parametro, all'utente verrà richiesto solo la prima volta che il tuo progetto richiede l'accesso. Per maggiori informazioni, consulta Richiesta di un nuovo consenso. In Python, imposta il parametro authorization_url, state = flow.authorization_url( access_type='offline', prompt='consent', include_granted_scopes='true') I valori possibili sono:
|
Ruby
Utilizza il file client_secrets.json che hai creato per configurare un oggetto client nella tua applicazione. Quando configuri un oggetto client, devi specificare gli ambiti a cui l'applicazione deve accedere, insieme all'URL dell'endpoint di autenticazione dell'applicazione, che gestirà la risposta del server OAuth 2.0.
Ad esempio, questo codice richiede l'accesso offline di sola lettura al Google Drive di un utente:
require 'google/apis/drive_v3' require "googleauth" require 'googleauth/stores/redis_token_store' client_id = Google::Auth::ClientId.from_file('/path/to/client_secret.json') scope = 'https://www.googleapis.com/auth/drive.metadata.readonly' token_store = Google::Auth::Stores::RedisTokenStore.new(redis: Redis.new) authorizer = Google::Auth::WebUserAuthorizer.new(client_id, scope, token_store, '/oauth2callback')Your application uses the client object to perform OAuth 2.0 operations, such as generating authorization request URLs and applying access tokens to HTTP requests.
Node.js
The code snippet below creates a google.auth.OAuth2
object, which defines the
parameters in the authorization request.
That object uses information from your client_secret.json file to identify your application. To ask for permissions from a user to retrieve an access token, you redirect them to a consent page. To create a consent page URL:
const {google} = require('googleapis'); /** * To use OAuth2 authentication, we need access to a CLIENT_ID, CLIENT_SECRET, AND REDIRECT_URI * from the client_secret.json file. To get these credentials for your application, visit * https://console.cloud.google.com/apis/credentials. */ const oauth2Client = new google.auth.OAuth2( YOUR_CLIENT_ID, YOUR_CLIENT_SECRET, YOUR_REDIRECT_URL ); // Access scopes for read-only Drive activity. const scopes = [ 'https://www.googleapis.com/auth/drive.metadata.readonly' ]; // Generate a url that asks permissions for the Drive activity scope const authorizationUrl = oauth2Client.generateAuthUrl({ // 'online' (default) or 'offline' (gets refresh_token) access_type: 'offline', /** Pass in the scopes array defined above. * Alternatively, if only one scope is needed, you can pass a scope URL as a string */ scope: scopes, // Enable incremental authorization. Recommended as a best practice. include_granted_scopes: true });
Nota importante: refresh_token
viene restituito solo alla prima
autorizzazione. Ulteriori dettagli
qui.
HTTP/REST
L'endpoint OAuth 2.0 di Google si trova all'indirizzo https://accounts.google.com/o/oauth2/v2/auth
. Questo endpoint è accessibile solo tramite HTTPS. Le connessioni HTTP semplici vengono rifiutate.
Il server di autorizzazione di Google supporta i seguenti parametri della stringa di query per le applicazioni del server web:
Parametri | |||||||
---|---|---|---|---|---|---|---|
client_id |
Obbligatorio
L'ID client della tua applicazione. Puoi trovare questo valore in API Console Credentials page. |
||||||
redirect_uri |
Obbligatorio
Determina dove il server API reindirizza l'utente dopo che l'utente completa il flusso di autorizzazione. Il valore deve corrispondere esattamente a uno degli URI di reindirizzamento autorizzati per il client OAuth 2.0, che hai configurato in API Console
Credentials pagedel client. Se questo valore non corrisponde a un URI di reindirizzamento autorizzato per il Tieni presente che lo schema |
||||||
response_type |
Obbligatorio
Determina se l'endpoint OAuth 2.0 di Google restituisce un codice di autorizzazione. Imposta il valore del parametro su |
||||||
scope |
Obbligatorio
Un elenco di ambiti delimitati da spazi che identificano le risorse a cui l'applicazione potrebbe accedere per conto dell'utente. Questi valori determinano la schermata di consenso che Google mostra all'utente. Gli ambiti consentono all'applicazione di richiedere l'accesso solo alle risorse di cui ha bisogno, permettendo al contempo agli utenti di controllare la quantità di accesso che concede alla tua applicazione. Esiste quindi una relazione inversa tra il numero di ambiti richiesti e la probabilità di ottenere il consenso dell'utente. Ti consigliamo che la tua applicazione richieda l'accesso agli ambiti di autorizzazione nel contesto, se possibile. Richiedendo l'accesso ai dati utente nel contesto, tramite l'autorizzazione incrementale, aiuti gli utenti a capire più facilmente perché la tua applicazione ha bisogno dell'accesso che richiede. |
||||||
access_type |
Consigliato
Indica se l'applicazione può aggiornare i token di accesso quando l'utente non è presente nel browser. I valori validi del parametro sono Imposta il valore su |
||||||
state |
Consigliato
Specifica qualsiasi valore stringa utilizzato dall'applicazione per mantenere lo stato tra la richiesta di autorizzazione e la risposta del server di autorizzazione.
Il server restituisce il valore esatto che invii come coppia Puoi utilizzare questo parametro per diversi scopi, ad esempio indirizzare l'utente alla risorsa corretta nell'applicazione, inviare nonce e mitigare la falsificazione delle richieste tra siti. Poiché il valore |
||||||
include_granted_scopes |
Facoltativo
Consente alle applicazioni di utilizzare l'autorizzazione incrementale per richiedere l'accesso ad ambiti aggiuntivi nel contesto. Se imposti il valore di questo parametro su |
||||||
enable_granular_consent |
Facoltativo
Il valore predefinito è |
||||||
login_hint |
Facoltativo
Se l'applicazione sa quale utente sta tentando di eseguire l'autenticazione, può utilizzare questo parametro per fornire un suggerimento al server di autenticazione di Google. Il server utilizza il suggerimento per semplificare il flusso di accesso precompilando il campo dell'email nel modulo di accesso o selezionando la sessione di accesso multiplo appropriata. Imposta il valore del parametro su un indirizzo email o su un identificatore |
||||||
prompt |
Facoltativo
Un elenco di prompt, delimitati da spazi e maiuscole, da presentare all'utente. Se non specifichi questo parametro, all'utente verrà richiesto solo la prima volta che il tuo progetto richiede l'accesso. Per maggiori informazioni, consulta Richiesta di un nuovo consenso. I valori possibili sono:
|
Passaggio 2: reindirizza al server OAuth 2.0 di Google
Reindirizza l'utente al server OAuth 2.0 di Google per avviare il processo di autenticazione e autorizzazione. In genere, ciò si verifica quando l'applicazione deve accedere per la prima volta ai dati dell'utente. Nel caso di autorizzazione incrementale, questo passaggio si verifica anche quando l'applicazione deve accedere per la prima volta a risorse aggiuntive a cui non dispone ancora dell'autorizzazione per accedere.
PHP
- Genera un URL per richiedere l'accesso dal server OAuth 2.0 di Google:
$auth_url = $client->createAuthUrl();
- Reindirizza l'utente a
$auth_url
:header('Location: ' . filter_var($auth_url, FILTER_SANITIZE_URL));
Python
Questo esempio mostra come reindirizzare l'utente all'URL di autorizzazione utilizzando il framework di applicazioni web Flask:
return flask.redirect(authorization_url)
Ruby
- Genera un URL per richiedere l'accesso dal server OAuth 2.0 di Google:
auth_uri = authorizer.get_authorization_url(login_hint: user_id, request: request)
- Reindirizza l'utente a
auth_uri
.
Node.js
-
Utilizza l'URL
authorizationUrl
generato nel Passaggio 1 metodogenerateAuthUrl
per richiedere l'accesso al server OAuth 2.0 di Google. -
Reindirizza l'utente a
authorizationUrl
.res.writeHead(301, { "Location": authorizationUrl });
HTTP/REST
Sample redirect to Google's authorization server
An example URL is shown below, with line breaks and spaces for readability.
https://accounts.google.com/o/oauth2/v2/auth? scope=https%3A//www.googleapis.com/auth/drive.metadata.readonly& access_type=offline& include_granted_scopes=true& response_type=code& state=state_parameter_passthrough_value& redirect_uri=https%3A//oauth2.example.com/code& client_id=client_id
Dopo aver creato l'URL della richiesta, reindirizza l'utente all'URL.
Il server OAuth 2.0 di Google autentica l'utente e ottiene il consenso dell'utente affinché la tua applicazione possa accedere agli ambiti richiesti. La risposta viene inviata all'applicazione utilizzando l'URL di reindirizzamento specificato.
Passaggio 3: Google chiede all'utente il consenso
In questo passaggio, l'utente decide se concedere all'applicazione l'accesso richiesto. In questa fase, Google mostra una finestra per il consenso che mostra il nome della tua applicazione e i servizi API di Google per i quali richiede l'autorizzazione ad accedere con le credenziali di autorizzazione dell'utente, oltre a un riepilogo degli ambiti di accesso da concedere. L'utente può quindi acconsentire a concedere l'accesso a uno o più ambiti richiesti dalla tua applicazione oppure rifiutare la richiesta.
In questa fase l'applicazione non deve fare nulla perché attende la risposta del server OAuth 2.0 di Google che indica se l'accesso è stato concesso. Questa risposta è spiegata nel passaggio seguente.
Errori
Le richieste all'endpoint di autorizzazione OAuth 2.0 di Google potrebbero mostrare messaggi di errore rivolti agli utenti anziché i flussi di autenticazione e autorizzazione previsti. Di seguito sono elencati i codici di errore comuni e le soluzioni suggerite.
admin_policy_enforced
L'Account Google non è in grado di autorizzare uno o più ambiti richiesti a causa delle norme dell'amministratore di Google Workspace. Consulta l'articolo del Centro assistenza per amministratori di Google Workspace Stabilire quali app di terze parti e interne possono accedere ai dati di Google Workspace per maggiori informazioni su come un amministratore può limitare l'accesso a tutti gli ambiti o a tutti gli ambiti sensibili e con restrizioni finché l'accesso non viene concesso esplicitamente all'ID client OAuth.
disallowed_useragent
L'endpoint di autorizzazione viene visualizzato all'interno di uno user agent incorporato non consentito dai criteri OAuth 2.0 di Google.
Android
Gli sviluppatori Android potrebbero visualizzare questo messaggio di errore durante l'apertura delle richieste di autorizzazione in android.webkit.WebView
.
Gli sviluppatori dovrebbero usare librerie Android come Accedi con Google per Android o AppAuth per Android di OpenID Foundation.
Gli sviluppatori web potrebbero riscontrare questo errore quando un'app per Android apre un link web generale in uno user agent incorporato e un utente accede all'endpoint di autorizzazione OAuth 2.0 di Google dal tuo sito. Gli sviluppatori dovrebbero consentire l'apertura di link generali nel gestore di link predefinito del sistema operativo, che include sia i gestori Link per app Android sia l'app browser predefinita. Anche la libreria Schede personalizzate di Android è un'opzione supportata.
iOS
Gli sviluppatori iOS e macOS potrebbero riscontrare questo errore durante l'apertura delle richieste di autorizzazione in
WKWebView
.
Gli sviluppatori dovrebbero usare invece librerie iOS come Accedi con Google per iOS o AppAuth per iOS di OpenID Foundation.
Gli sviluppatori web possono riscontrare questo errore quando un'app per iOS o macOS apre un link web generale in uno user agent incorporato e un utente accede all'endpoint di autorizzazione OAuth 2.0 di Google dal tuo sito. Gli sviluppatori dovrebbero consentire l'apertura di link generali nel gestore dei link predefinito del sistema operativo, che include sia i gestori dei link universali sia l'app browser predefinita. Anche la libreria SFSafariViewController
è un'opzione supportata.
org_internal
L'ID client OAuth nella richiesta fa parte di un progetto che limita l'accesso agli Account Google in una organizzazione Google Cloud specifica. Per ulteriori informazioni su questa opzione di configurazione, consulta la sezione Tipo di utente nell'articolo della guida Configurare la schermata per il consenso OAuth.
invalid_client
Il client secret OAuth non è corretto. Esamina la configurazione del client OAuth, inclusi l'ID client e il secret utilizzati per questa richiesta.
invalid_grant
Quando aggiorni un token di accesso o utilizzi l'autorizzazione incrementale, il token potrebbe essere scaduto o essere stato invalidato. Autentica di nuovo l'utente e chiedi il suo consenso per ottenere nuovi token. Se continui a visualizzare questo errore, assicurati che l'applicazione sia stata configurata correttamente e che la richiesta utilizzi i token e i parametri corretti. In caso contrario, l'account utente potrebbe essere stato eliminato o disattivato.
redirect_uri_mismatch
Il valore redirect_uri
trasmesso nella richiesta di autorizzazione non corrisponde a un URI di reindirizzamento
autorizzato per l'ID client OAuth. Esamina gli URI di reindirizzamento autorizzati in
Google API Console Credentials page.
Il parametro redirect_uri
può fare riferimento al flusso OAuth out-of-band (OOB) che è stato
deprecato e non è più supportato. Consulta la
guida alla migrazione per aggiornare l'integrazione.
invalid_request
Si è verificato un problema con la richiesta che hai inviato. Ciò potrebbe essere dovuto a una serie di motivi:
- La richiesta non è stata formattata correttamente
- Nella richiesta mancavano i parametri obbligatori
- La richiesta utilizza un metodo di autorizzazione non supportato da Google. Verifica che l'integrazione OAuth utilizzi un metodo di integrazione consigliato
Passaggio 4: gestisci la risposta del server OAuth 2.0
Il server OAuth 2.0 risponde alla richiesta di accesso della tua applicazione utilizzando l'URL specificato nella richiesta.
Se l'utente approva la richiesta di accesso, la risposta contiene un codice di autorizzazione. Se l'utente non approva la richiesta, la risposta contiene un messaggio di errore. Il codice di autorizzazione o il messaggio di errore restituito al server web viene visualizzato nella stringa di query, come mostrato di seguito:
Una risposta di errore:
https://oauth2.example.com/auth?error=access_denied
Una risposta del codice di autorizzazione:
https://oauth2.example.com/auth?code=4/P7q7W91a-oMsCeLvIaQm6bTrgtp7
Esempio di risposta del server OAuth 2.0
Puoi testare questo flusso facendo clic sul seguente URL di esempio, che richiede l'accesso di sola lettura per visualizzare i metadati dei file su Google Drive:
https://accounts.google.com/o/oauth2/v2/auth? scope=https%3A//www.googleapis.com/auth/drive.metadata.readonly& access_type=offline& include_granted_scopes=true& response_type=code& state=state_parameter_passthrough_value& redirect_uri=https%3A//oauth2.example.com/code& client_id=client_id
Dopo aver completato il flusso OAuth 2.0, il sistema ti reindirizzerà a http://localhost/oauth2callback
, che probabilmente restituirà un errore 404 NOT FOUND
a meno che la tua macchina locale non pubblichi un file a quell'indirizzo. Il passaggio successivo fornisce ulteriori dettagli sulle informazioni restituite nell'URI quando l'utente viene reindirizzato alla tua applicazione.
Passaggio 5: scambia il codice di autorizzazione con i token di aggiornamento e accesso
Dopo aver ricevuto il codice di autorizzazione, il server web può scambiarlo con un token di accesso.
PHP
Per scambiare un codice di autorizzazione con un token di accesso, utilizza il metodo authenticate
:
$client->authenticate($_GET['code']);
Puoi recuperare il token di accesso con il metodo getAccessToken
:
$access_token = $client->getAccessToken();
Python
Nella pagina di callback, utilizza la libreria google-auth
per verificare la risposta del server di autorizzazione. Quindi, utilizza il metodo flow.fetch_token
per scambiare il codice di autorizzazione nella risposta con un token di accesso:
state = flask.session['state'] flow = google_auth_oauthlib.flow.Flow.from_client_secrets_file( 'client_secret.json', scopes=['https://www.googleapis.com/auth/drive.metadata.readonly'], state=state) flow.redirect_uri = flask.url_for('oauth2callback', _external=True) authorization_response = flask.request.url flow.fetch_token(authorization_response=authorization_response) # Store the credentials in the session. # ACTION ITEM for developers: # Store user's access and refresh tokens in your data store if # incorporating this code into your real app. credentials = flow.credentials flask.session['credentials'] = { 'token': credentials.token, 'refresh_token': credentials.refresh_token, 'token_uri': credentials.token_uri, 'client_id': credentials.client_id, 'client_secret': credentials.client_secret, 'scopes': credentials.scopes}
Ruby
Nella pagina di callback, utilizza la libreria googleauth
per verificare la risposta del server di autorizzazione. Utilizza il metodo authorizer.handle_auth_callback_deferred
per salvare il codice di autorizzazione e reindirizzare all'URL che ha richiesto in origine l'autorizzazione. Questo
facilita lo scambio del codice, archiviando temporaneamente i risultati nella sessione dell'utente.
target_url = Google::Auth::WebUserAuthorizer.handle_auth_callback_deferred(request) redirect target_url
Node.js
Per scambiare un codice di autorizzazione con un token di accesso, utilizza il metodo getToken
:
const url = require('url'); // Receive the callback from Google's OAuth 2.0 server. if (req.url.startsWith('/oauth2callback')) { // Handle the OAuth 2.0 server response let q = url.parse(req.url, true).query; // Get access and refresh tokens (if access_type is offline) let { tokens } = await oauth2Client.getToken(q.code); oauth2Client.setCredentials(tokens); }
HTTP/REST
Per scambiare un codice di autorizzazione con un token di accesso, chiama l'endpoint
https://oauth2.googleapis.com/token
e imposta i seguenti parametri:
Campi | |
---|---|
client_id |
L'ID client ottenuto da API Console Credentials page. |
client_secret |
Il client secret ottenuto da API Console Credentials page. |
code |
Il codice di autorizzazione restituito dalla richiesta iniziale. |
grant_type |
Come definito nella specifica OAuth 2.0, il valore di questo campo deve essere impostato su authorization_code . |
redirect_uri |
Uno degli URI di reindirizzamento elencati per il progetto in
API Console
Credentials page per il
client_id specificato. |
Il seguente snippet mostra una richiesta di esempio:
POST /token HTTP/1.1 Host: oauth2.googleapis.com Content-Type: application/x-www-form-urlencoded code=4/P7q7W91a-oMsCeLvIaQm6bTrgtp7& client_id=your_client_id& client_secret=your_client_secret& redirect_uri=https%3A//oauth2.example.com/code& grant_type=authorization_code
Google risponde a questa richiesta restituendo un oggetto JSON che contiene un token di accesso di breve durata e un token di aggiornamento.
Tieni presente che il token di aggiornamento viene restituito solo se l'applicazione ha impostato il parametro access_type
su offline
nella richiesta iniziale al server di autorizzazione di Google.
La risposta contiene i seguenti campi:
Campi | |
---|---|
access_token |
Il token inviato dalla tua applicazione per autorizzare una richiesta API di Google. |
expires_in |
La durata rimanente del token di accesso in secondi. |
refresh_token |
Un token che puoi utilizzare per ottenere un nuovo token di accesso. I token di aggiornamento sono validi finché l'utente
non revoca l'accesso.
Anche in questo caso, il campo è presente in questa risposta solo se imposti il parametro access_type su offline nella richiesta iniziale al server di autorizzazione di Google.
|
scope |
Gli ambiti di accesso concessi da access_token espressi come elenco di stringhe
sensibili alle maiuscole e delimitate da spazi. |
token_type |
Il tipo di token restituito. Al momento, il valore di questo campo è sempre impostato su Bearer . |
Il seguente snippet mostra un esempio di risposta:
{ "access_token": "1/fFAGRNJru1FTz70BzhT3Zg", "expires_in": 3920, "token_type": "Bearer", "scope": "https://www.googleapis.com/auth/drive.metadata.readonly", "refresh_token": "1//xEoDL4iW3cxlI7yDbSRFYNG01kVKM2C-259HOF2aQbI" }
Errori
Quando scambi il codice di autorizzazione con un token di accesso, potresti riscontrare il seguente errore anziché la risposta prevista. Di seguito sono elencati i codici di errore comuni e le soluzioni suggerite.
invalid_grant
Il codice di autorizzazione fornito non è valido o ha un formato errato. Richiedi un nuovo codice riavviando la procedura OAuth per richiedere nuovamente all'utente il consenso.
Chiamata alle API di Google
PHP
Utilizza il token di accesso per chiamare le API di Google svolgendo i seguenti passaggi:
- Se devi applicare un token di accesso a un nuovo oggetto
Google\Client
, ad esempio se lo hai archiviato in una sessione utente, utilizza il metodosetAccessToken
:$client->setAccessToken($access_token);
- Crea un oggetto di servizio per l'API che vuoi chiamare. Puoi creare un oggetto di servizio fornendo un oggetto
Google\Client
autorizzato al costruttore per l'API che vuoi chiamare. Ad esempio, per chiamare l'API Drive:$drive = new Google\Service\Drive($client);
- Effettua le richieste al servizio API utilizzando l'interfaccia fornita dall'oggetto di servizio.
Ad esempio, per elencare i file nel Google Drive dell'utente autenticato:
$files = $drive->files->listFiles(array())->getItems();
Python
Dopo aver ottenuto un token di accesso, l'applicazione può utilizzarlo per autorizzare le richieste API per conto di un determinato account utente o account di servizio. Utilizza le credenziali di autorizzazione specifiche dell'utente per creare un oggetto di servizio per l'API da chiamare, quindi utilizza l'oggetto per effettuare richieste API autorizzate.
- Crea un oggetto di servizio per l'API che vuoi chiamare. Puoi creare un oggetto di servizio chiamando il metodo
build
della libreriagoogleapiclient.discovery
con il nome e la versione dell'API e le credenziali utente: Ad esempio, per chiamare la versione 3 dell'API Drive:from googleapiclient.discovery import build drive = build('drive', 'v2', credentials=credentials)
- Effettua le richieste al servizio API utilizzando l'interfaccia fornita dall'oggetto di servizio.
Ad esempio, per elencare i file nel Google Drive dell'utente autenticato:
files = drive.files().list().execute()
Ruby
Dopo aver ottenuto un token di accesso, l'applicazione può utilizzarlo per effettuare richieste API per conto di un determinato account utente o account di servizio. Utilizza le credenziali di autorizzazione specifiche dell'utente per creare un oggetto di servizio per l'API da chiamare, quindi utilizza l'oggetto per effettuare richieste API autorizzate.
- Crea un oggetto di servizio per l'API che vuoi chiamare.
Ad esempio, per chiamare la versione 3 dell'API Drive:
drive = Google::Apis::DriveV3::DriveService.new
- Imposta le credenziali nel servizio:
drive.authorization = credentials
- Effettua le richieste al servizio API utilizzando
l'interfaccia
fornita dall'oggetto di servizio.
Ad esempio, per elencare i file nel Google Drive dell'utente autenticato:
files = drive.list_files
In alternativa, l'autorizzazione può essere fornita in base al metodo fornendo il parametro options
a un metodo:
files = drive.list_files(options: { authorization: credentials })
Node.js
Dopo aver ottenuto un token di accesso e averlo impostato sull'oggetto OAuth2
, utilizza l'oggetto per chiamare le API di Google. L'applicazione può utilizzare il token per autorizzare le richieste API per conto di un determinato account utente o account di servizio. Crea un oggetto di servizio per l'API che vuoi chiamare.
const { google } = require('googleapis'); // Example of using Google Drive API to list filenames in user's Drive. const drive = google.drive('v3'); drive.files.list({ auth: oauth2Client, pageSize: 10, fields: 'nextPageToken, files(id, name)', }, (err1, res1) => { if (err1) return console.log('The API returned an error: ' + err1); const files = res1.data.files; if (files.length) { console.log('Files:'); files.map((file) => { console.log(`${file.name} (${file.id})`); }); } else { console.log('No files found.'); } });
HTTP/REST
Dopo che l'applicazione ha ottenuto un token di accesso, puoi utilizzarlo per effettuare chiamate a un'API di Google per conto di un determinato account utente, nel caso in cui siano stati concessi gli ambiti di accesso richiesti dall'API. A questo scopo, includi il token di accesso in una richiesta all'API includendo un parametro di query access_token
o un valore Bearer
di intestazione HTTP Authorization
. Quando possibile, è preferibile utilizzare l'intestazione HTTP, perché le stringhe di query tendono a essere visibili nei log del server. Nella maggior parte dei casi, puoi utilizzare una libreria client per configurare le chiamate alle API di Google (ad esempio, quando chiami l'API Drive Files).
Puoi provare tutte le API di Google e visualizzarne gli ambiti nello spazio pubblico OAuth 2.0.
Esempi di GET HTTP
Una chiamata all'endpoint
drive.files
(l'API Drive Files) utilizzando l'intestazione HTTP Authorization: Bearer
potrebbe avere il seguente aspetto. Tieni presente che devi specificare il tuo token di accesso:
GET /drive/v2/files HTTP/1.1 Host: www.googleapis.com Authorization: Bearer access_token
Ecco una chiamata alla stessa API per l'utente autenticato utilizzando il parametro della stringa di query access_token
:
GET https://www.googleapis.com/drive/v2/files?access_token=access_token
Esempi di curl
Puoi testare questi comandi con l'applicazione a riga di comando curl
. Ecco un esempio che utilizza l'opzione dell'intestazione HTTP (opzione preferita):
curl -H "Authorization: Bearer access_token" https://www.googleapis.com/drive/v2/files
In alternativa, l'opzione del parametro della stringa di query:
curl https://www.googleapis.com/drive/v2/files?access_token=access_token
Esempio completo
L'esempio seguente stampa un elenco in formato JSON di file nel Google Drive di un utente dopo che quest'ultimo ha eseguito l'autenticazione e ha dato il consenso all'applicazione per accedere ai metadati di Drive dell'utente.
PHP
Per eseguire questo esempio:
- In API Console, aggiungi l'URL della macchina locale all'elenco di URL di reindirizzamento. Ad esempio, aggiungi
http://localhost:8080
. - Crea una nuova directory e passa alla directory. Ad esempio:
mkdir ~/php-oauth2-example cd ~/php-oauth2-example
- Installa la libreria client delle API di Google per PHP utilizzando Composer:
composer require google/apiclient:^2.10
- Crea i file
index.php
eoauth2callback.php
con i contenuti riportati di seguito. - Esegui l'esempio con un server web configurato per la pubblicazione di PHP. Se usi PHP 5.6 o versioni successive, puoi usare il server web di test integrato di PHP:
php -S localhost:8080 ~/php-oauth2-example
index.php
<?php require_once __DIR__.'/vendor/autoload.php'; session_start(); $client = new Google\Client(); $client->setAuthConfig('client_secrets.json'); $client->addScope(Google\Service\Drive::DRIVE_METADATA_READONLY); if (isset($_SESSION['access_token']) && $_SESSION['access_token']) { $client->setAccessToken($_SESSION['access_token']); $drive = new Google\Service\Drive($client); $files = $drive->files->listFiles(array())->getItems(); echo json_encode($files); } else { $redirect_uri = 'http://' . $_SERVER['HTTP_HOST'] . '/oauth2callback.php'; header('Location: ' . filter_var($redirect_uri, FILTER_SANITIZE_URL)); }
oauth2callback.php
<?php require_once __DIR__.'/vendor/autoload.php'; session_start(); $client = new Google\Client(); $client->setAuthConfigFile('client_secrets.json'); $client->setRedirectUri('http://' . $_SERVER['HTTP_HOST'] . '/oauth2callback.php'); $client->addScope(Google\Service\Drive::DRIVE_METADATA_READONLY); if (! isset($_GET['code'])) { $auth_url = $client->createAuthUrl(); header('Location: ' . filter_var($auth_url, FILTER_SANITIZE_URL)); } else { $client->authenticate($_GET['code']); $_SESSION['access_token'] = $client->getAccessToken(); $redirect_uri = 'http://' . $_SERVER['HTTP_HOST'] . '/'; header('Location: ' . filter_var($redirect_uri, FILTER_SANITIZE_URL)); }
Python
In questo esempio viene utilizzato il framework Flask. Esegue
un'applicazione web su http://localhost:8080
che ti consente di testare il flusso
OAuth 2.0. Se accedi a quell'URL, dovresti vedere quattro link:
- Testa una richiesta API: questo link rimanda a una pagina che tenta di eseguire una richiesta API di esempio. Se necessario, avvia il flusso di autorizzazione. In caso di esito positivo, la pagina visualizza la risposta dell'API.
- Testa direttamente il flusso di autorizzazione: questo link rimanda a una pagina che tenta di inviare l'utente tramite il flusso di autorizzazione. L'app richiede l'autorizzazione per inviare richieste API autorizzate per conto dell'utente.
- Revoca le credenziali attuali:questo link rimanda a una pagina che revoca le autorizzazioni che l'utente ha già concesso all'applicazione.
- Cancella credenziali sessione Flask: questo link cancella le credenziali di autorizzazione archiviate nella sessione Flask. In questo modo puoi vedere cosa succede se un utente che ha già concesso l'autorizzazione alla tua app tenta di eseguire una richiesta API in una nuova sessione. Consente inoltre di visualizzare la risposta API che riceverebbe la tua app se un utente avesse revocato le autorizzazioni concesse alla tua app e l'app cercasse comunque di autorizzare una richiesta con un token di accesso revocato.
# -*- coding: utf-8 -*- import os import flask import requests import google.oauth2.credentials import google_auth_oauthlib.flow import googleapiclient.discovery # This variable specifies the name of a file that contains the OAuth 2.0 # information for this application, including its client_id and client_secret. CLIENT_SECRETS_FILE = "client_secret.json" # This OAuth 2.0 access scope allows for full read/write access to the # authenticated user's account and requires requests to use an SSL connection. SCOPES = ['https://www.googleapis.com/auth/drive.metadata.readonly'] API_SERVICE_NAME = 'drive' API_VERSION = 'v2' app = flask.Flask(__name__) # Note: A secret key is included in the sample so that it works. # If you use this code in your application, replace this with a truly secret # key. See https://flask.palletsprojects.com/quickstart/#sessions. app.secret_key = 'REPLACE ME - this value is here as a placeholder.' @app.route('/') def index(): return print_index_table() @app.route('/test') def test_api_request(): if 'credentials' not in flask.session: return flask.redirect('authorize') # Load credentials from the session. credentials = google.oauth2.credentials.Credentials( **flask.session['credentials']) drive = googleapiclient.discovery.build( API_SERVICE_NAME, API_VERSION, credentials=credentials) files = drive.files().list().execute() # Save credentials back to session in case access token was refreshed. # ACTION ITEM: In a production app, you likely want to save these # credentials in a persistent database instead. flask.session['credentials'] = credentials_to_dict(credentials) return flask.jsonify(**files) @app.route('/authorize') def authorize(): # Create flow instance to manage the OAuth 2.0 Authorization Grant Flow steps. flow = google_auth_oauthlib.flow.Flow.from_client_secrets_file( CLIENT_SECRETS_FILE, scopes=SCOPES) # The URI created here must exactly match one of the authorized redirect URIs # for the OAuth 2.0 client, which you configured in the API Console. If this # value doesn't match an authorized URI, you will get a 'redirect_uri_mismatch' # error. flow.redirect_uri = flask.url_for('oauth2callback', _external=True) authorization_url, state = flow.authorization_url( # Enable offline access so that you can refresh an access token without # re-prompting the user for permission. Recommended for web server apps. access_type='offline', # Enable incremental authorization. Recommended as a best practice. include_granted_scopes='true') # Store the state so the callback can verify the auth server response. flask.session['state'] = state return flask.redirect(authorization_url) @app.route('/oauth2callback') def oauth2callback(): # Specify the state when creating the flow in the callback so that it can # verified in the authorization server response. state = flask.session['state'] flow = google_auth_oauthlib.flow.Flow.from_client_secrets_file( CLIENT_SECRETS_FILE, scopes=SCOPES, state=state) flow.redirect_uri = flask.url_for('oauth2callback', _external=True) # Use the authorization server's response to fetch the OAuth 2.0 tokens. authorization_response = flask.request.url flow.fetch_token(authorization_response=authorization_response) # Store credentials in the session. # ACTION ITEM: In a production app, you likely want to save these # credentials in a persistent database instead. credentials = flow.credentials flask.session['credentials'] = credentials_to_dict(credentials) return flask.redirect(flask.url_for('test_api_request')) @app.route('/revoke') def revoke(): if 'credentials' not in flask.session: return ('You need to <a href="/authorize">authorize</a> before ' + 'testing the code to revoke credentials.') credentials = google.oauth2.credentials.Credentials( **flask.session['credentials']) revoke = requests.post('https://oauth2.googleapis.com/revoke', params={'token': credentials.token}, headers = {'content-type': 'application/x-www-form-urlencoded'}) status_code = getattr(revoke, 'status_code') if status_code == 200: return('Credentials successfully revoked.' + print_index_table()) else: return('An error occurred.' + print_index_table()) @app.route('/clear') def clear_credentials(): if 'credentials' in flask.session: del flask.session['credentials'] return ('Credentials have been cleared.<br><br>' + print_index_table()) def credentials_to_dict(credentials): return {'token': credentials.token, 'refresh_token': credentials.refresh_token, 'token_uri': credentials.token_uri, 'client_id': credentials.client_id, 'client_secret': credentials.client_secret, 'scopes': credentials.scopes} def print_index_table(): return ('<table>' + '<tr><td><a href="/test">Test an API request</a></td>' + '<td>Submit an API request and see a formatted JSON response. ' + ' Go through the authorization flow if there are no stored ' + ' credentials for the user.</td></tr>' + '<tr><td><a href="/authorize">Test the auth flow directly</a></td>' + '<td>Go directly to the authorization flow. If there are stored ' + ' credentials, you still might not be prompted to reauthorize ' + ' the application.</td></tr>' + '<tr><td><a href="/revoke">Revoke current credentials</a></td>' + '<td>Revoke the access token associated with the current user ' + ' session. After revoking credentials, if you go to the test ' + ' page, you should see an <code>invalid_grant</code> error.' + '</td></tr>' + '<tr><td><a href="/clear">Clear Flask session credentials</a></td>' + '<td>Clear the access token currently stored in the user session. ' + ' After clearing the token, if you <a href="/test">test the ' + ' API request</a> again, you should go back to the auth flow.' + '</td></tr></table>') if __name__ == '__main__': # When running locally, disable OAuthlib's HTTPs verification. # ACTION ITEM for developers: # When running in production *do not* leave this option enabled. os.environ['OAUTHLIB_INSECURE_TRANSPORT'] = '1' # Specify a hostname and port that are set as a valid redirect URI # for your API project in the Google API Console. app.run('localhost', 8080, debug=True)
Ruby
In questo esempio viene utilizzato il framework Sinatra.
require 'google/apis/drive_v3' require 'sinatra' require 'googleauth' require 'googleauth/stores/redis_token_store' configure do enable :sessions set :client_id, Google::Auth::ClientId.from_file('/path/to/client_secret.json') set :scope, Google::Apis::DriveV3::AUTH_DRIVE_METADATA_READONLY set :token_store, Google::Auth::Stores::RedisTokenStore.new(redis: Redis.new) set :authorizer, Google::Auth::WebUserAuthorizer.new(settings.client_id, settings.scope, settings.token_store, '/oauth2callback') end get '/' do user_id = settings.client_id.id credentials = settings.authorizer.get_credentials(user_id, request) if credentials.nil? redirect settings.authorizer.get_authorization_url(login_hint: user_id, request: request) end drive = Google::Apis::DriveV3::DriveService.new files = drive.list_files(options: { authorization: credentials }) "<pre>#{JSON.pretty_generate(files.to_h)}</pre>" end get '/oauth2callback' do target_url = Google::Auth::WebUserAuthorizer.handle_auth_callback_deferred(request) redirect target_url end
Node.js
Per eseguire questo esempio:
-
In API Console, aggiungi l'URL della
macchina locale all'elenco di URL di reindirizzamento. Ad esempio, aggiungi
http://localhost
. - Assicurati di avere installato l'LTS di manutenzione, l'LTS attivo o la release attuale di Node.js.
-
Crea una nuova directory e passa alla directory. Ad esempio:
mkdir ~/nodejs-oauth2-example cd ~/nodejs-oauth2-example
-
Install the
Google API Client
Library
for Node.js using npm:
npm install googleapis
-
Crea i file
main.js
con i contenuti seguenti. -
Esegui l'esempio:
node .\main.js
main.js
const http = require('http'); const https = require('https'); const url = require('url'); const { google } = require('googleapis'); /** * To use OAuth2 authentication, we need access to a CLIENT_ID, CLIENT_SECRET, AND REDIRECT_URI. * To get these credentials for your application, visit * https://console.cloud.google.com/apis/credentials. */ const oauth2Client = new google.auth.OAuth2( YOUR_CLIENT_ID, YOUR_CLIENT_SECRET, YOUR_REDIRECT_URL ); // Access scopes for read-only Drive activity. const scopes = [ 'https://www.googleapis.com/auth/drive.metadata.readonly' ]; // Generate a url that asks permissions for the Drive activity scope const authorizationUrl = oauth2Client.generateAuthUrl({ // 'online' (default) or 'offline' (gets refresh_token) access_type: 'offline', /** Pass in the scopes array defined above. * Alternatively, if only one scope is needed, you can pass a scope URL as a string */ scope: scopes, // Enable incremental authorization. Recommended as a best practice. include_granted_scopes: true }); /* Global variable that stores user credential in this code example. * ACTION ITEM for developers: * Store user's refresh token in your data store if * incorporating this code into your real app. * For more information on handling refresh tokens, * see https://github.com/googleapis/google-api-nodejs-client#handling-refresh-tokens */ let userCredential = null; async function main() { const server = http.createServer(async function (req, res) { // Example on redirecting user to Google's OAuth 2.0 server. if (req.url == '/') { res.writeHead(301, { "Location": authorizationUrl }); } // Receive the callback from Google's OAuth 2.0 server. if (req.url.startsWith('/oauth2callback')) { // Handle the OAuth 2.0 server response let q = url.parse(req.url, true).query; if (q.error) { // An error response e.g. error=access_denied console.log('Error:' + q.error); } else { // Get access and refresh tokens (if access_type is offline) let { tokens } = await oauth2Client.getToken(q.code); oauth2Client.setCredentials(tokens); /** Save credential to the global variable in case access token was refreshed. * ACTION ITEM: In a production app, you likely want to save the refresh token * in a secure persistent database instead. */ userCredential = tokens; // Example of using Google Drive API to list filenames in user's Drive. const drive = google.drive('v3'); drive.files.list({ auth: oauth2Client, pageSize: 10, fields: 'nextPageToken, files(id, name)', }, (err1, res1) => { if (err1) return console.log('The API returned an error: ' + err1); const files = res1.data.files; if (files.length) { console.log('Files:'); files.map((file) => { console.log(`${file.name} (${file.id})`); }); } else { console.log('No files found.'); } }); } } // Example on revoking a token if (req.url == '/revoke') { // Build the string for the POST request let postData = "token=" + userCredential.access_token; // Options for POST request to Google's OAuth 2.0 server to revoke a token let postOptions = { host: 'oauth2.googleapis.com', port: '443', path: '/revoke', method: 'POST', headers: { 'Content-Type': 'application/x-www-form-urlencoded', 'Content-Length': Buffer.byteLength(postData) } }; // Set up the request const postReq = https.request(postOptions, function (res) { res.setEncoding('utf8'); res.on('data', d => { console.log('Response: ' + d); }); }); postReq.on('error', error => { console.log(error) }); // Post the request with data postReq.write(postData); postReq.end(); } res.end(); }).listen(80); } main().catch(console.error);
HTTP/REST
Questo esempio di Python utilizza il framework Flask e la libreria Requests per dimostrare il flusso web OAuth 2.0. Consigliamo di utilizzare la libreria client delle API di Google per Python per questo flusso. (l'esempio nella scheda Python utilizza la libreria client).
import json import flask import requests app = flask.Flask(__name__) CLIENT_ID = '123456789.apps.googleusercontent.com' CLIENT_SECRET = 'abc123' # Read from a file or environmental variable in a real app SCOPE = 'https://www.googleapis.com/auth/drive.metadata.readonly' REDIRECT_URI = 'http://example.com/oauth2callback' @app.route('/') def index(): if 'credentials' not in flask.session: return flask.redirect(flask.url_for('oauth2callback')) credentials = json.loads(flask.session['credentials']) if credentials['expires_in'] <= 0: return flask.redirect(flask.url_for('oauth2callback')) else: headers = {'Authorization': 'Bearer {}'.format(credentials['access_token'])} req_uri = 'https://www.googleapis.com/drive/v2/files' r = requests.get(req_uri, headers=headers) return r.text @app.route('/oauth2callback') def oauth2callback(): if 'code' not in flask.request.args: auth_uri = ('https://accounts.google.com/o/oauth2/v2/auth?response_type=code' '&client_id={}&redirect_uri={}&scope={}').format(CLIENT_ID, REDIRECT_URI, SCOPE) return flask.redirect(auth_uri) else: auth_code = flask.request.args.get('code') data = {'code': auth_code, 'client_id': CLIENT_ID, 'client_secret': CLIENT_SECRET, 'redirect_uri': REDIRECT_URI, 'grant_type': 'authorization_code'} r = requests.post('https://oauth2.googleapis.com/token', data=data) flask.session['credentials'] = r.text return flask.redirect(flask.url_for('index')) if __name__ == '__main__': import uuid app.secret_key = str(uuid.uuid4()) app.debug = False app.run()
Regole di convalida dell'URI di reindirizzamento
Google applica le seguenti regole di convalida per reindirizzare gli URI al fine di aiutare gli sviluppatori a proteggere le loro applicazioni. Gli URI di reindirizzamento devono rispettare queste regole. Consulta la sezione 3 di RFC 3986 per la definizione di dominio, host, percorso, query, schema e info utente, menzionate di seguito.
Regole di convalida | |
---|---|
Schema |
Gli URI di reindirizzamento devono utilizzare lo schema HTTPS, non il semplice HTTP. Gli URI Localhost (inclusi gli URI degli indirizzi IP localhost) sono esenti da questa regola. |
Host |
Gli host non possono essere indirizzi IP non elaborati. Gli indirizzi IP Localhost sono esenti da questa regola. |
Dominio |
“googleusercontent.com” .goo.gl ), a meno che il dominio non sia di proprietà dell'app. Inoltre, se un'app che possiede un dominio abbreviato sceglie di
reindirizzare a quel dominio, l'URI di reindirizzamento deve contenere
“/google-callback/” nel suo percorso o terminare con
“/google-callback” . |
Info utente |
Gli URI di reindirizzamento non possono contenere il sottocomponente userinfo. |
Percorso |
Gli URI di reindirizzamento non possono contenere un attraversamento percorso (chiamato anche backtracking della directory), rappresentato da un |
Query |
Gli URI di reindirizzamento non possono contenere reindirizzamenti aperti. |
Frammento |
Gli URI di reindirizzamento non possono contenere il componente frammento. |
Caratteri |
Gli URI di reindirizzamento non possono contenere determinati caratteri, tra cui:
|
Autorizzazione incrementale
Nel protocollo OAuth 2.0, la tua app richiede l'autorizzazione ad accedere alle risorse, che sono identificate da ambiti. È considerata una best practice per l'esperienza utente richiedere l'autorizzazione per le risorse nel momento in cui ne hai bisogno. Per abilitare questa pratica, il server di autorizzazione di Google supporta l'autorizzazione incrementale. Questa funzionalità consente di richiedere gli ambiti in base alle necessità e, se l'utente concede l'autorizzazione per il nuovo ambito, restituisce un codice di autorizzazione che può essere scambiato con un token contenente tutti gli ambiti che l'utente ha concesso al progetto.
Ad esempio, un'app che consente agli utenti di campionare tracce musicali e creare mix potrebbe richiedere pochissime risorse al momento dell'accesso, magari solo il nome della persona che esegue l'accesso. Tuttavia, il salvataggio di un mix completato richiederebbe l'accesso a Google Drive. La maggior parte delle persone riterrebbe naturale se gli fosse stato chiesto l'accesso a Google Drive solo nel momento in cui l'app ne aveva effettivamente bisogno.
In questo caso, al momento dell'accesso l'app potrebbe richiedere gli ambiti openid
e profile
per eseguire l'accesso di base, per poi richiedere in un secondo momento l'ambito https://www.googleapis.com/auth/drive.file
al momento della prima richiesta di salvare una combinazione.
Per implementare l'autorizzazione incrementale, completa la procedura normale per richiedere un token di accesso, ma assicurati che la richiesta di autorizzazione includa gli ambiti concessi in precedenza. Questo approccio consente alla tua app di evitare di dover gestire più token di accesso.
Le seguenti regole si applicano a un token di accesso ottenuto da un'autorizzazione incrementale:
- Il token può essere utilizzato per accedere alle risorse corrispondenti a qualsiasi ambito inserito nella nuova autorizzazione combinata.
- Quando utilizzi il token di aggiornamento per l'autorizzazione combinata al fine di ottenere un token di accesso, quest'ultimo rappresenta l'autorizzazione combinata e può essere utilizzato per qualsiasi valore
scope
incluso nella risposta. - L'autorizzazione combinata include tutti gli ambiti che l'utente ha concesso al progetto API anche se le concessioni sono state richieste da client diversi. Ad esempio, se un utente ha concesso l'accesso a un ambito utilizzando il client desktop di un'applicazione e poi un altro ambito alla stessa applicazione tramite un client mobile, l'autorizzazione combinata includerà entrambi gli ambiti.
- Se revochi un token che rappresenta un'autorizzazione combinata, l'accesso a tutti gli ambiti di tale autorizzazione per conto dell'utente associato viene revocato contemporaneamente.
Gli esempi di codice specifici per le lingue del Passaggio 1: imposta i parametri di autorizzazione e l'URL di reindirizzamento HTTP/REST di esempio nel Passaggio 2: reindirizzamento al server OAuth 2.0 di Google utilizzano tutti l'autorizzazione incrementale. Gli esempi di codice riportati di seguito mostrano anche il codice che è necessario aggiungere per utilizzare l'autorizzazione incrementale.
PHP
$client->setIncludeGrantedScopes(true);
Python
In Python, imposta l'argomento parola chiave include_granted_scopes
su true
per assicurarti che una richiesta di autorizzazione includa gli ambiti concessi in precedenza. È molto possibile che include_granted_scopes
non sia l'unico argomento della parola chiave che hai impostato, come mostrato nell'esempio riportato di seguito.
authorization_url, state = flow.authorization_url( # Enable offline access so that you can refresh an access token without # re-prompting the user for permission. Recommended for web server apps. access_type='offline', # Enable incremental authorization. Recommended as a best practice. include_granted_scopes='true')
Ruby
auth_client.update!( :additional_parameters => {"include_granted_scopes" => "true"} )
Node.js
const authorizationUrl = oauth2Client.generateAuthUrl({ // 'online' (default) or 'offline' (gets refresh_token) access_type: 'offline', /** Pass in the scopes array defined above. * Alternatively, if only one scope is needed, you can pass a scope URL as a string */ scope: scopes, // Enable incremental authorization. Recommended as a best practice. include_granted_scopes: true });
HTTP/REST
GET https://accounts.google.com/o/oauth2/v2/auth? client_id=your_client_id& response_type=code& state=state_parameter_passthrough_value& scope=https%3A//www.googleapis.com/auth/drive.file& redirect_uri=https%3A//oauth2.example.com/code& prompt=consent& include_granted_scopes=true
Aggiornamento di un token di accesso (accesso offline)
I token di accesso scadono periodicamente e diventano credenziali non valide per una richiesta API correlata. Puoi aggiornare un token di accesso senza richiedere l'autorizzazione all'utente (anche quando l'utente non è presente) se hai richiesto l'accesso offline agli ambiti associati al token.
- Se utilizzi una libreria client dell'API di Google, l'oggetto client aggiorna il token di accesso in base alle esigenze, a condizione che l'oggetto venga configurato per l'accesso offline.
- Se non utilizzi una libreria client, devi impostare il parametro di query HTTP
access_type
suoffline
quando reindirizzi l'utente al server OAuth 2.0 di Google. In questo caso, il server di autorizzazione di Google restituisce un token di aggiornamento quando scambia un codice di autorizzazione con un token di accesso. Quindi, se il token di accesso scade (o in un altro momento), puoi utilizzare un token di aggiornamento per ottenere un nuovo token di accesso.
La richiesta dell'accesso offline è un requisito per qualsiasi applicazione che deve accedere a un'API di Google quando l'utente non è presente. Ad esempio, un'app che esegue servizi di backup o
esegue azioni in orari predeterminati deve essere in grado di aggiornare il token di accesso quando
l'utente non è presente. Lo stile di accesso predefinito è denominato online
.
Le applicazioni web lato server, le applicazioni installate e i dispositivi ricevono tutti token di aggiornamento durante il processo di autorizzazione. I token di aggiornamento in genere non vengono utilizzati nelle applicazioni web lato client (JavaScript).
PHP
Se la tua applicazione richiede l'accesso offline a un'API di Google, imposta il tipo di accesso del client API su
offline
:
$client->setAccessType("offline");
Dopo che un utente ha concesso l'accesso offline agli ambiti richiesti, puoi continuare a utilizzare il client API per accedere alle API di Google per conto dell'utente quando è offline. L'oggetto client aggiornerà il token di accesso in base alle esigenze.
Python
In Python, imposta l'argomento parola chiave access_type
su offline
per assicurarti di poter aggiornare il token di accesso senza dover richiedere nuovamente l'autorizzazione all'utente. È molto possibile che access_type
non sia l'unico argomento per parola chiave che hai impostato, come mostrato nell'esempio riportato di seguito.
authorization_url, state = flow.authorization_url( # Enable offline access so that you can refresh an access token without # re-prompting the user for permission. Recommended for web server apps. access_type='offline', # Enable incremental authorization. Recommended as a best practice. include_granted_scopes='true')
Dopo che un utente ha concesso l'accesso offline agli ambiti richiesti, puoi continuare a utilizzare il client API per accedere alle API di Google per conto dell'utente quando è offline. L'oggetto client aggiornerà il token di accesso in base alle esigenze.
Ruby
Se la tua applicazione richiede l'accesso offline a un'API di Google, imposta il tipo di accesso del client API su
offline
:
auth_client.update!( :additional_parameters => {"access_type" => "offline"} )
Dopo che un utente ha concesso l'accesso offline agli ambiti richiesti, puoi continuare a utilizzare il client API per accedere alle API di Google per conto dell'utente quando è offline. L'oggetto client aggiornerà il token di accesso in base alle esigenze.
Node.js
Se la tua applicazione richiede l'accesso offline a un'API di Google, imposta il tipo di accesso del client API su
offline
:
const authorizationUrl = oauth2Client.generateAuthUrl({ // 'online' (default) or 'offline' (gets refresh_token) access_type: 'offline', /** Pass in the scopes array defined above. * Alternatively, if only one scope is needed, you can pass a scope URL as a string */ scope: scopes, // Enable incremental authorization. Recommended as a best practice. include_granted_scopes: true });
Dopo che un utente ha concesso l'accesso offline agli ambiti richiesti, puoi continuare a utilizzare il client API per accedere alle API di Google per conto dell'utente quando è offline. L'oggetto client aggiornerà il token di accesso in base alle esigenze.
I token di accesso hanno una scadenza. Questa libreria utilizzerà automaticamente un token di aggiornamento per ottenere un nuovo token di accesso se sta per scadere. Un modo semplice per assicurarti di archiviare sempre i token più recenti è utilizzare l'evento dei token:
oauth2Client.on('tokens', (tokens) => { if (tokens.refresh_token) { // store the refresh_token in your secure persistent database console.log(tokens.refresh_token); } console.log(tokens.access_token); });
Questo evento dei token si verifica solo nella prima autorizzazione e devi aver impostato access_type
su offline
quando chiami il metodo generateAuthUrl
per ricevere il token di aggiornamento. Se hai già concesso alla tua app le autorizzazioni necessarie senza impostare i vincoli appropriati per la ricezione di un token di aggiornamento, dovrai autorizzare nuovamente l'applicazione in modo che riceva un nuovo token di aggiornamento.
Per impostare refresh_token
in un secondo momento, puoi utilizzare il metodo setCredentials
:
oauth2Client.setCredentials({ refresh_token: `STORED_REFRESH_TOKEN` });
Quando il client dispone di un token di aggiornamento, i token di accesso verranno acquisiti e aggiornati automaticamente nella chiamata successiva all'API.
HTTP/REST
Per aggiornare un token di accesso, la tua applicazione invia una richiesta POST
HTTPS al server di autorizzazione di Google (https://oauth2.googleapis.com/token
) che
include i seguenti parametri:
Campi | |
---|---|
client_id |
L'ID client ottenuto da API Console. |
client_secret |
Il client secret ottenuto da API Console. |
grant_type |
Come definito nella specifica OAuth 2.0, il valore di questo campo deve essere impostato su refresh_token . |
refresh_token |
Il token di aggiornamento restituito dallo scambio del codice di autorizzazione. |
Il seguente snippet mostra una richiesta di esempio:
POST /token HTTP/1.1 Host: oauth2.googleapis.com Content-Type: application/x-www-form-urlencoded client_id=your_client_id& client_secret=your_client_secret& refresh_token=refresh_token& grant_type=refresh_token
Se l'utente non ha revocato l'accesso concesso all'applicazione, il server token restituisce un oggetto JSON contenente un nuovo token di accesso. Il seguente snippet mostra un esempio di risposta:
{ "access_token": "1/fFAGRNJru1FTz70BzhT3Zg", "expires_in": 3920, "scope": "https://www.googleapis.com/auth/drive.metadata.readonly", "token_type": "Bearer" }
Tieni presente che sono previsti limiti al numero di token di aggiornamento che verranno emessi: un limite per combinazione client/utente e un altro per utente in tutti i client. Devi salvare i token di aggiornamento nello spazio di archiviazione a lungo termine e continuare a utilizzarli finché rimangono validi. Se la tua applicazione richiede troppi token di aggiornamento, potrebbe raggiungere questi limiti, nel qual caso i token di aggiornamento meno recenti smetteranno di funzionare.
Revoca di un token
In alcuni casi, un utente potrebbe voler revocare l'accesso concesso a un'applicazione. Un utente può revocare l'accesso visitando le impostazioni dell'account. Per saperne di più, consulta la sezione relativa alla rimozione dell'accesso di siti o app del documento di assistenza Siti e app di terze parti con accesso al tuo account.
È anche possibile per un'applicazione revocare in modo programmatico l'accesso concesso. La revoca programmatica è importante nei casi in cui un utente annulla l'iscrizione, rimuove un'applicazione o le risorse API richieste da un'app sono cambiate in modo significativo. In altre parole, parte del processo di rimozione può includere una richiesta API per garantire che le autorizzazioni concesse in precedenza all'applicazione vengano rimosse.
PHP
Per revocare in modo programmatico un token, chiama revokeToken()
:
$client->revokeToken();
Python
Per revocare in modo programmatico un token, effettua una richiesta a
https://oauth2.googleapis.com/revoke
che includa il token come parametro e imposti l'intestazione Content-Type
:
requests.post('https://oauth2.googleapis.com/revoke', params={'token': credentials.token}, headers = {'content-type': 'application/x-www-form-urlencoded'})
Ruby
Per revocare un token in modo programmatico, effettua una richiesta HTTP all'endpoint
oauth2.revoke
:
uri = URI('https://oauth2.googleapis.com/revoke') response = Net::HTTP.post_form(uri, 'token' => auth_client.access_token)
Il token può essere un token di accesso o di aggiornamento. Se il token è un token di accesso e ha un token di aggiornamento corrispondente, verrà revocato anche il token di aggiornamento.
Se la revoca viene elaborata correttamente, il codice di stato della risposta è 200
. Per le condizioni di errore, viene restituito un codice di stato 400
insieme a un codice di errore.
Node.js
Per revocare un token in modo programmatico, effettua una richiesta POST HTTPS all'endpoint /revoke
:
const https = require('https'); // Build the string for the POST request let postData = "token=" + userCredential.access_token; // Options for POST request to Google's OAuth 2.0 server to revoke a token let postOptions = { host: 'oauth2.googleapis.com', port: '443', path: '/revoke', method: 'POST', headers: { 'Content-Type': 'application/x-www-form-urlencoded', 'Content-Length': Buffer.byteLength(postData) } }; // Set up the request const postReq = https.request(postOptions, function (res) { res.setEncoding('utf8'); res.on('data', d => { console.log('Response: ' + d); }); }); postReq.on('error', error => { console.log(error) }); // Post the request with data postReq.write(postData); postReq.end();
Il parametro token può essere un token di accesso o un token di aggiornamento. Se il token è un token di accesso e ha un token di aggiornamento corrispondente, verrà revocato anche il token di aggiornamento.
Se la revoca viene elaborata correttamente, il codice di stato della risposta è 200
. Per le condizioni di errore, viene restituito un codice di stato 400
insieme a un codice di errore.
HTTP/REST
Per revocare in modo programmatico un token, la tua applicazione invia una richiesta a https://oauth2.googleapis.com/revoke
e include il token come parametro:
curl -d -X -POST --header "Content-type:application/x-www-form-urlencoded" \ https://oauth2.googleapis.com/revoke?token={token}
Il token può essere un token di accesso o di aggiornamento. Se il token è un token di accesso e ha un token di aggiornamento corrispondente, verrà revocato anche il token di aggiornamento.
Se la revoca viene elaborata correttamente, il codice di stato HTTP della risposta è 200
. Per le condizioni di errore, viene restituito un codice di stato HTTP 400
insieme a un codice di errore.