Utiliser OAuth 2.0 pour les applications de serveur Web

PHP

Pour exécuter les exemples de code PHP de ce document, vous avez besoin des éléments suivants:

• PHP 5.6 ou version ultérieure avec l'interface de ligne de commande (CLI) et l'extension JSON installés
• L'outil de gestion des dépendances Composer

• La bibliothèque cliente des API Google pour PHP:

  composer require google/apiclient:^2.10

Python

Pour exécuter les exemples de code Python présentés dans ce document, vous avez besoin des éléments suivants:

• Python 2.6 ou version ultérieure
• L'outil de gestion de packages pip.
• Bibliothèque cliente des API Google pour Python :

  pip install --upgrade google-api-python-client

• google-auth, google-auth-oauthlib et google-auth-httplib2 pour l'autorisation de l'utilisateur.

  pip install --upgrade google-auth google-auth-oauthlib google-auth-httplib2

• Framework d'application Web Python de Flask.

  pip install --upgrade flask

• La bibliothèque HTTP requests.

  pip install --upgrade requests

Ruby

Pour exécuter les exemples de code Ruby présentés dans ce document, vous avez besoin des éléments suivants:

• Ruby 2.6 ou version ultérieure

• Bibliothèque Google Auth pour Ruby:

  gem install googleauth

• Framework d'application Web Ruby de Sinatra

  gem install sinatra

Node.js

Pour exécuter les exemples de code Node.js présentés dans ce document, vous avez besoin des éléments suivants:

• Le LTS de maintenance, le LTS actif ou la version actuelle de Node.js

• Le client Node.js des API Google:

  npm install googleapis

HTTP/REST

Vous n'avez pas besoin d'installer des bibliothèques pour pouvoir appeler directement les points de terminaison OAuth 2.0.

PHP

L'extrait de code ci-dessous crée un objet Google\Client(), qui définit les paramètres de la requête d'autorisation.

Cet objet identifie votre application à l'aide des informations du fichier client_secret.json. (Consultez la section Créer des identifiants d'autorisation pour en savoir plus sur ce fichier.) L'objet identifie également les champs d'application auxquels votre application demande l'autorisation d'accéder, ainsi que l'URL du point de terminaison d'authentification de votre application, qui gérera la réponse du serveur OAuth 2.0 de Google. Enfin, le code définit les paramètres facultatifs (access_type et include_granted_scopes).

Par exemple, pour demander un accès hors connexion afin de récupérer les rapports YouTube Analytics d'un utilisateur:

$client = new Google\Client();
$client->setAuthConfig('client_secret.json');
$client->addScope(Google_Service_YouTubeAnalytics::YT_ANALYTICS_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 requête fournit les informations suivantes:

$client = new Google\Client();
$client->setAuthConfig('client_secret.json');

$client->setRedirectUri('https://oauth2.example.com/code');

$client->addScope(Google_Service_YouTubeAnalytics::YT_ANALYTICS_READONLY);

$client->setAccessType('offline');

$client->setState($sample_passthrough_value);

$client->setIncludeGrantedScopes(true);

$client->setLoginHint('None');

$client->setPrompt('consent');

Python

L'extrait de code suivant utilise le module google-auth-oauthlib.flow pour créer la requête d'autorisation.

Le code construit un objet Flow qui identifie votre application à l'aide des informations du fichier client_secret.json que vous avez téléchargé après avoir créé des identifiants d'autorisation. Cet objet identifie également les champs d'application auxquels votre application demande l'autorisation d'accéder, ainsi que l'URL du point de terminaison d'authentification de votre application, qui gérera la réponse du serveur OAuth 2.0 de Google. Enfin, le code définit les paramètres facultatifs (access_type et include_granted_scopes).

Par exemple, pour demander un accès hors connexion afin de récupérer les rapports YouTube Analytics d'un utilisateur:

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/yt-analytics.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 requête fournit les informations suivantes:

flow = google_auth_oauthlib.flow.Flow.from_client_secrets_file(
    'client_secret.json',
    scopes=['https://www.googleapis.com/auth/yt-analytics.readonly'])

flow.redirect_uri = 'https://oauth2.example.com/code'

flow = google_auth_oauthlib.flow.Flow.from_client_secrets_file(
    'client_secret.json',
    scopes=['https://www.googleapis.com/auth/yt-analytics.readonly'])

authorization_url, state = flow.authorization_url(
    access_type='offline',
    include_granted_scopes='true')

authorization_url, state = flow.authorization_url(
    access_type='offline',
    state=sample_passthrough_value,
    include_granted_scopes='true')

authorization_url, state = flow.authorization_url(
    access_type='offline',
    include_granted_scopes='true')

authorization_url, state = flow.authorization_url(
    access_type='offline',
    login_hint='None',
    include_granted_scopes='true')

authorization_url, state = flow.authorization_url(
      access_type='offline',
      prompt='consent',
      include_granted_scopes='true')

Ruby

Utilisez le fichier client_secrets.json que vous avez créé pour configurer un objet client dans votre application. Lorsque vous configurez un objet client, vous spécifiez les champs d'application auxquels votre application doit accéder, ainsi que l'URL du point de terminaison d'authentification de votre application, qui gérera la réponse du serveur OAuth 2.0.

Par exemple, pour demander un accès hors connexion afin de récupérer les rapports YouTube Analytics d'un utilisateur:

require 'google/apis/youtube_analytics_v1'
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/yt-analytics.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
});

Remarque importante : La valeur refresh_token n'est renvoyée que lors de la première autorisation. En savoir plus

HTTP/REST

Le point de terminaison OAuth 2.0 de Google se trouve à https://accounts.google.com/o/oauth2/v2/auth. Ce point de terminaison n'est accessible que via HTTPS. Les connexions HTTP simples sont refusées.

Le serveur d'autorisation Google accepte les paramètres de chaîne de requête suivants pour les applications de serveur Web:

PHP

1. Générez une URL pour demander l'accès depuis le serveur OAuth 2.0 de Google :

   $auth_url = $client->createAuthUrl();

2. Rediriger l'utilisateur vers $auth_url :

   header('Location: ' . filter_var($auth_url, FILTER_SANITIZE_URL));

Python

Cet exemple montre comment rediriger l'utilisateur vers l'URL d'autorisation à l'aide du framework d'application Web Flask:

return flask.redirect(authorization_url)

Ruby

1. Générez une URL pour demander l'accès depuis le serveur OAuth 2.0 de Google :

   auth_uri = authorizer.get_authorization_url(login_hint: user_id, request: request)

2. Redirigez l'utilisateur vers auth_uri.

Node.js

1. Utilisez l'URL générée authorizationUrl à l'étape 1 de la méthode generateAuthUrl pour demander l'accès à partir du serveur OAuth 2.0 de Google.
2. Redirigez l'utilisateur vers authorizationUrl.

   res.writeHead(301, { "Location": authorizationUrl });

HTTP/REST

Sample redirect to Google's authorization server

The sample URL below requests offline access (access_type=offline) to a scope that permits access to retrieve the user's YouTube Analytics reports. It uses incremental authorization to ensure that the new access token covers any scopes to which the user previously granted the application access. The URL also sets values for the required redirect_uri, response_type, and client_id parameters as well as for the state parameter. The URL contains line breaks and spaces for readability.

https://accounts.google.com/o/oauth2/v2/auth?
 scope=https%3A%2F%2Fwww.googleapis.com%2Fauth%2Fyt-analytics.readonly&
 access_type=offline&
 include_granted_scopes=true&
 state=state_parameter_passthrough_value&
 redirect_uri=http%3A%2F%2Flocalhost%2Foauth2callback&
 response_type=code&
 client_id=client_id

Une fois l'URL de requête créée, redirigez l'utilisateur vers elle.

PHP

Pour échanger un code d'autorisation contre un jeton d'accès, utilisez la méthode authenticate:

$client->authenticate($_GET['code']);

Vous pouvez récupérer le jeton d'accès avec la méthode getAccessToken:

$access_token = $client->getAccessToken();

Python

Sur votre page de rappel, utilisez la bibliothèque google-auth pour vérifier la réponse du serveur d'autorisation. Ensuite, utilisez la méthode flow.fetch_token pour échanger le code d'autorisation de cette réponse contre un jeton d'accès:

state = flask.session['state']
flow = google_auth_oauthlib.flow.Flow.from_client_secrets_file(
    'client_secret.json',
    scopes=['https://www.googleapis.com/auth/yt-analytics.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

Sur votre page de rappel, utilisez la bibliothèque googleauth pour vérifier la réponse du serveur d'autorisation. Utilisez la méthode authorizer.handle_auth_callback_deferred pour enregistrer le code d'autorisation et rediriger les utilisateurs vers l'URL qui a initialement demandé l'autorisation. Cette action diffère l'échange du code en stockant temporairement les résultats dans la session de l'utilisateur.

  target_url = Google::Auth::WebUserAuthorizer.handle_auth_callback_deferred(request)
  redirect target_url

Node.js

Pour échanger un code d'autorisation contre un jeton d'accès, utilisez la méthode 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

Pour échanger un code d'autorisation contre un jeton d'accès, appelez le point de terminaison https://oauth2.googleapis.com/token et définissez les paramètres suivants:

L'extrait de code suivant présente un exemple de requête:

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 répond à cette requête en renvoyant un objet JSON contenant un jeton d'accès de courte durée et un jeton d'actualisation. Notez que le jeton d'actualisation n'est renvoyé que si votre application a défini le paramètre access_type sur offline dans la requête initiale adressée au serveur d'autorisation de Google.

La réponse contient les champs suivants :

L'extrait de code suivant montre un exemple de réponse:

{
  "access_token": "1/fFAGRNJru1FTz70BzhT3Zg",
  "expires_in": 3920,
  "token_type": "Bearer",
  "scope": "https://www.googleapis.com/auth/yt-analytics.readonly",
  "refresh_token": "1//xEoDL4iW3cxlI7yDbSRFYNG01kVKM2C-259HOF2aQbI"
}

PHP

Utilisez le jeton d'accès pour appeler les API Google en procédant comme suit:

1. Si vous devez appliquer un jeton d'accès à un nouvel objet Google\Client (par exemple, si vous avez stocké le jeton d'accès dans une session utilisateur), utilisez la méthode setAccessToken :

   $client->setAccessToken($access_token);

2. Créez un objet de service pour l'API que vous souhaitez appeler. Pour créer un objet de service, fournissez un objet Google\Client autorisé au constructeur de l'API que vous souhaitez appeler. Par exemple, pour appeler l'API YouTube Analytics :

   $youtube = new Google_Service_YouTubeAnalytics($client);

3. Envoyez des requêtes au service d'API à l'aide de l'interface fournie par l'objet de service. Par exemple, pour récupérer un rapport YouTube Analytics sur la chaîne de l'utilisateur authentifié :

   $report = $youtube->reports->query('channel==MINE', '2016-05-01', '2016-06-30', 'views');

Python

Après avoir obtenu un jeton d'accès, votre application peut l'utiliser pour autoriser des requêtes API au nom d'un compte utilisateur ou d'un compte de service donné. Utilisez les identifiants d'autorisation propres à l'utilisateur pour créer un objet de service pour l'API que vous souhaitez appeler, puis utilisez cet objet pour effectuer des requêtes API autorisées.

1. Créez un objet de service pour l'API que vous souhaitez appeler. Pour créer un objet de service, appelez la méthode build de la bibliothèque googleapiclient.discovery avec le nom et la version de l'API, ainsi que les identifiants utilisateur. Par exemple, pour appeler la version 1 de l'API YouTube Analytics :

   from googleapiclient.discovery import build
   
   youtube = build('youtubeAnalytics', 'v1', credentials=credentials)

2. Envoyez des requêtes au service d'API à l'aide de l'interface fournie par l'objet de service. Par exemple, pour récupérer un rapport YouTube Analytics sur la chaîne de l'utilisateur authentifié :

   report = youtube.reports().query(ids='channel==MINE', start_date='2016-05-01', end_date='2016-06-30', metrics='views').execute()

Ruby

Après avoir obtenu un jeton d'accès, votre application peut l'utiliser pour effectuer des requêtes API au nom d'un compte utilisateur ou d'un compte de service donné. Utilisez les identifiants d'autorisation propres à l'utilisateur pour créer un objet de service pour l'API que vous souhaitez appeler, puis utilisez cet objet pour effectuer des requêtes API autorisées.

1. Créez un objet de service pour l'API que vous souhaitez appeler. Par exemple, pour appeler la version 1 de l'API YouTube Analytics :

   youtube = Google::Apis::YoutubeAnalyticsV1::YouTubeAnalyticsService.new

2. Définissez les identifiants sur le service :

   youtube.authorization = credentials

3. Envoyez des requêtes au service d'API à l'aide de l'interface fournie par l'objet de service. Par exemple, pour récupérer un rapport YouTube Analytics sur la chaîne de l'utilisateur authentifié :

   report = youtube.query_report('channel==MINE', '2016-05-01', '2016-06-30', 'views')

Vous pouvez également fournir une autorisation pour chaque méthode en fournissant le paramètre options à une méthode:

report = youtube.query_report('channel==MINE', '2016-05-01', '2016-06-30', 'views', options: { authorization: auth_client })

Node.js

Après avoir obtenu un jeton d'accès et l'avoir défini sur l'objet OAuth2, utilisez l'objet pour appeler les API Google. Votre application peut utiliser ce jeton pour autoriser des requêtes API au nom d'un compte utilisateur ou d'un compte de service donné. Créez un objet de service pour l'API que vous souhaitez appeler.

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

Une fois que votre application a obtenu un jeton d'accès, vous pouvez l'utiliser pour appeler une API Google au nom d'un compte utilisateur donné, à condition que le ou les champs d'application requis par l'API aient été accordés. Pour ce faire, incluez le jeton d'accès dans une requête adressée à l'API en incluant un paramètre de requête access_token ou une valeur Bearer de l'en-tête HTTP Authorization. Dans la mesure du possible, il est préférable d'utiliser l'en-tête HTTP, car les chaînes de requête ont tendance à être visibles dans les journaux du serveur. Dans la plupart des cas, vous pouvez utiliser une bibliothèque cliente pour configurer vos appels aux API Google (par exemple, lorsque vous appelez l'API YouTube Analytics).

Notez que l'API YouTube Analytics n'est pas compatible avec le flux de compte de service. L'API YouTube Reporting n'est compatible qu'avec les comptes de service pour les propriétaires de contenu YouTube qui possèdent et gèrent plusieurs chaînes YouTube, telles que les maisons de disques et les studios de cinéma.

Vous pouvez essayer toutes les API Google et consulter leur champ d'application sur OAuth 2.0 Playground.

Exemples HTTP GET

Un appel au point de terminaison reports.query (l'API YouTube Analytics) à l'aide de l'en-tête HTTP Authorization: Bearer peut se présenter comme suit. Notez que vous devez spécifier votre propre jeton d'accès:

GET /youtube/analytics/v1/reports?ids=channel%3D%3DMINE&start-date=2016-05-01&end-date=2016-06-30&metrics=views HTTP/1.1
Host: www.googleapis.com
Authorization: Bearer access_token

Voici un appel vers la même API pour l'utilisateur authentifié à l'aide du paramètre de chaîne de requête access_token:

GET https://www.googleapis.com/youtube/analytics/v1/reports?access_token=access_token&ids=channel%3D%3DMINE&start-date=2016-05-01&end-date=2016-06-30&metrics=views

Exemples curl

Vous pouvez tester ces commandes avec l'application de ligne de commande curl. Voici un exemple qui utilise l'option d'en-tête HTTP (recommandée):

curl -H "Authorization: Bearer access_token" https://www.googleapis.com/youtube/analytics/v1/reports?ids=channel%3D%3DMINE&start-date=2016-05-01&end-date=2016-06-30&metrics=views

Vous pouvez également utiliser l'option de paramètre de chaîne de requête:

curl https://www.googleapis.com/youtube/analytics/v1/reports?access_token=access_token&ids=channel%3D%3DMINE&start-date=2016-05-01&end-date=2016-06-30&metrics=views

PHP

Pour exécuter cet exemple:

1. Dans API Console, ajoutez l'URL de la machine locale à la liste des URL de redirection. Par exemple, ajoutez http://localhost:8080.
2. Créez un répertoire et accédez-y. Exemple :

   mkdir ~/php-oauth2-example
   cd ~/php-oauth2-example

3. Installez la bibliothèque cliente des API Google pour PHP à l'aide de Composer :

   composer require google/apiclient:^2.10

4. Créez les fichiers index.php et oauth2callback.php avec le contenu ci-dessous.
5. Exécutez l'exemple avec un serveur Web configuré pour diffuser du contenu PHP. Si vous utilisez PHP 5.6 ou une version ultérieure, vous pouvez utiliser le serveur Web de test intégré de 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_YouTubeAnalytics::YT_ANALYTICS_READONLY);

if (isset($_SESSION['access_token']) && $_SESSION['access_token']) {
  $client->setAccessToken($_SESSION['access_token']);
  $youtube = new Google_Service_YouTubeAnalytics($client);
  $report = $youtube->reports->query('channel==MINE', '2016-05-01', '2016-06-30', 'views');
  echo json_encode($report);
} 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_YouTubeAnalytics::YT_ANALYTICS_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

Cet exemple utilise le framework Flask. Il exécute une application Web à l'adresse http://localhost:8080 qui vous permet de tester le flux OAuth 2.0. Si vous accédez à cette URL, vous devriez voir quatre liens:

• Tester une requête API:ce lien redirige vers une page qui tente d'exécuter un exemple de requête API. Si nécessaire, il lance le flux d'autorisation. Si l'opération réussit, la page affiche la réponse de l'API.
• Tester le flux d'authentification directement:ce lien redirige vers une page qui tente de rediriger l'utilisateur via le flux d'autorisation. L'application demande l'autorisation d'envoyer des requêtes API autorisées au nom de l'utilisateur.
• Révoquer les identifiants actuels:ce lien redirige vers une page qui révoque les autorisations que l'utilisateur a déjà accordées à l'application.
• Effacer les identifiants de la session Flask:ce lien efface les identifiants d'autorisation stockés dans la session Flask. Vous pouvez ainsi voir ce qui se passerait si un utilisateur ayant déjà accordé l'autorisation à votre application tentait d'exécuter une requête API dans une nouvelle session. Il vous permet également de voir la réponse de l'API que votre application obtiendrait si un utilisateur avait révoqué des autorisations accordées à votre application et que votre application tentait toujours d'autoriser une requête avec un jeton d'accès révoqué.

# -*- 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/yt-analytics.readonly']
API_SERVICE_NAME = 'youtubeAnalytics'
API_VERSION = 'v1'

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'])

  youtube = googleapiclient.discovery.build(
      API_SERVICE_NAME, API_VERSION, credentials=credentials)

  report = youtube.reports().query(ids='channel==MINE', start_date='2016-05-01', end_date='2016-06-30', metrics='views').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(**report)


@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

Cet exemple utilise le framework Sinatra.

require 'google/apis/youtube_analytics_v1'
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
  youtube = Google::Apis::YoutubeAnalyticsV1::YouTubeAnalyticsService.new
  report = youtube.query_report('channel==MINE', '2016-05-01', '2016-06-30', 'views', options: { authorization: auth_client })
  
  "<pre>#{JSON.pretty_generate(report.to_h)}</pre>"
end

get '/oauth2callback' do
  target_url = Google::Auth::WebUserAuthorizer.handle_auth_callback_deferred(request)
  redirect target_url
end

Node.js

Pour exécuter cet exemple:

1. Dans API Console, ajoutez l'URL de la machine locale à la liste des URL de redirection. Par exemple, ajoutez http://localhost.
2. Assurez-vous d'avoir installé une version LTS de maintenance, une version LTS active ou la version actuelle de Node.js.
3. Créez un répertoire et accédez-y. Exemple :

   mkdir ~/nodejs-oauth2-example
   cd ~/nodejs-oauth2-example

4. Install the Google API Client Library for Node.js using npm:

   npm install googleapis

5. Créez les fichiers main.js avec le contenu ci-dessous.
6. Exécutez l'exemple :

   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

Cet exemple Python utilise le framework Flask et la bibliothèque Requests pour illustrer le flux Web OAuth 2.0. Pour ce flux, nous vous recommandons d'utiliser la bibliothèque cliente des API Google pour Python. (L'exemple dans l'onglet Python utilise la bibliothèque cliente.)

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/yt-analytics.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/youtube/analytics/v1/reports'
    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()

PHP

$client->setIncludeGrantedScopes(true);

Python

En Python, définissez l'argument de mot clé include_granted_scopes sur true pour vous assurer qu'une requête d'autorisation inclut des champs d'application précédemment accordés. Il est très possible que include_granted_scopes ne soit pas le seul argument de mot clé que vous définissez, comme illustré dans l'exemple ci-dessous.

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

Dans cet exemple, l'application appelante demande l'accès pour récupérer les données YouTube Analytics de l'utilisateur, en plus de tout autre accès que celui-ci a déjà accordé à l'application.

GET https://accounts.google.com/o/oauth2/v2/auth?
  scope=https%3A%2F%2Fwww.googleapis.com%2Fauth%2Fyt-analytics.readonly&
  access_type=offline&
  state=security_token%3D138rk%3Btarget_url%3Dhttp...index&
  redirect_uri=http%3A%2F%2Flocalhost%2Foauth2callback&
  response_type=code&
  client_id=client_id&
  include_granted_scopes=true

      

PHP

If your application needs offline access to a Google API, set the API client's access type to offline:

$client->setAccessType("offline");

Une fois qu'un utilisateur a accordé un accès hors connexion aux champs d'application demandés, vous pouvez continuer à utiliser le client API pour accéder aux API Google en son nom lorsque celui-ci est hors connexion. L'objet client actualisera le jeton d'accès si nécessaire.

Python

En Python, définissez l'argument de mot clé access_type sur offline pour vous assurer de pouvoir actualiser le jeton d'accès sans avoir à demander à nouveau l'autorisation de l'utilisateur. Il est très possible que access_type ne soit pas le seul argument de mot clé que vous définissez, comme illustré dans l'exemple ci-dessous.

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')

Une fois qu'un utilisateur a accordé un accès hors connexion aux champs d'application demandés, vous pouvez continuer à utiliser le client API pour accéder aux API Google en son nom lorsque celui-ci est hors connexion. L'objet client actualisera le jeton d'accès si nécessaire.

Ruby

Si votre application a besoin d'un accès hors connexion à une API Google, définissez le type d'accès du client API sur offline:

auth_client.update!(
  :additional_parameters => {"access_type" => "offline"}
)

Une fois qu'un utilisateur a accordé un accès hors connexion aux champs d'application demandés, vous pouvez continuer à utiliser le client API pour accéder aux API Google en son nom lorsque celui-ci est hors connexion. L'objet client actualisera le jeton d'accès si nécessaire.

Node.js

Si votre application a besoin d'un accès hors connexion à une API Google, définissez le type d'accès du client API sur 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
});

Une fois qu'un utilisateur a accordé un accès hors connexion aux champs d'application demandés, vous pouvez continuer à utiliser le client API pour accéder aux API Google en son nom lorsque celui-ci est hors connexion. L'objet client actualisera le jeton d'accès si nécessaire.

Les jetons d'accès ont une date d'expiration. Cette bibliothèque utilisera automatiquement un jeton d'actualisation pour obtenir un nouveau jeton d'accès s'il est sur le point d'expirer. Pour vous assurer de toujours stocker les jetons les plus récents, utilisez l'événement de jetons:

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);
});

Cet événement de jeton ne se produit que lors de la première autorisation. Vous devez avoir défini access_type sur offline lorsque vous appelez la méthode generateAuthUrl pour recevoir le jeton d'actualisation. Si vous avez déjà accordé à votre application les autorisations requises sans définir les contraintes appropriées pour la réception d'un jeton d'actualisation, vous devrez autoriser à nouveau l'application à recevoir un nouveau jeton d'actualisation.

Pour définir refresh_token ultérieurement, vous pouvez utiliser la méthode setCredentials:

oauth2Client.setCredentials({
  refresh_token: `STORED_REFRESH_TOKEN`
});

Une fois que le client dispose d'un jeton d'actualisation, les jetons d'accès sont acquis et actualisés automatiquement lors du prochain appel à l'API.

HTTP/REST

Pour actualiser un jeton d'accès, votre application envoie une requête HTTPS POST au serveur d'autorisation de Google (https://oauth2.googleapis.com/token) qui inclut les paramètres suivants:

L'extrait de code suivant présente un exemple de requête:

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

Tant que l'utilisateur n'a pas révoqué l'accès accordé à l'application, le serveur de jetons renvoie un objet JSON contenant un nouveau jeton d'accès. L'extrait de code suivant montre un exemple de réponse:

{
  "access_token": "1/fFAGRNJru1FTz70BzhT3Zg",
  "expires_in": 3920,
  "scope": "https://www.googleapis.com/auth/drive.metadata.readonly",
  "token_type": "Bearer"
}

Notez que le nombre de jetons d'actualisation qui seront émis est limité (une limite par combinaison client/utilisateur et une autre par utilisateur pour tous les clients). Vous devez enregistrer les jetons d'actualisation dans un espace de stockage à long terme et continuer à les utiliser tant qu'ils restent valides. Si votre application demande trop de jetons d'actualisation, elle peut atteindre ces limites, auquel cas les jetons d'actualisation plus anciens cesseront de fonctionner.

PHP

Pour révoquer un jeton de manière programmatique, appelez revokeToken():

$client->revokeToken();

Python

Pour révoquer un jeton de manière programmatique, envoyez une requête à https://oauth2.googleapis.com/revoke en incluant le jeton en tant que paramètre et en définissant l'en-tête Content-Type:

requests.post('https://oauth2.googleapis.com/revoke',
    params={'token': credentials.token},
    headers = {'content-type': 'application/x-www-form-urlencoded'})

Ruby

Pour révoquer un jeton de manière programmatique, envoyez une requête HTTP au point de terminaison oauth2.revoke:

uri = URI('https://oauth2.googleapis.com/revoke')
response = Net::HTTP.post_form(uri, 'token' => auth_client.access_token)

Il peut s'agir d'un jeton d'accès ou d'un jeton d'actualisation. S'il s'agit d'un jeton d'accès associé à un jeton d'actualisation correspondant, le jeton d'actualisation est également révoqué.

Si la révocation est traitée correctement, le code d'état de la réponse est 200. Pour les conditions d'erreur, un code d'état 400 est renvoyé avec un code d'erreur.

Node.js

Pour révoquer un jeton de manière programmatique, envoyez une requête HTTPS POST au point de terminaison /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();

Le paramètre de jeton peut être un jeton d'accès ou un jeton d'actualisation. S'il s'agit d'un jeton d'accès associé à un jeton d'actualisation correspondant, le jeton d'actualisation est également révoqué.

Si la révocation est traitée correctement, le code d'état de la réponse est 200. Pour les conditions d'erreur, un code d'état 400 est renvoyé avec un code d'erreur.

HTTP/REST

Pour révoquer un jeton de manière programmatique, votre application envoie une requête à https://oauth2.googleapis.com/revoke et inclut le jeton en tant que paramètre:

curl -d -X -POST --header "Content-type:application/x-www-form-urlencoded" \
        https://oauth2.googleapis.com/revoke?token={token}

Il peut s'agir d'un jeton d'accès ou d'un jeton d'actualisation. Si le jeton est un jeton d'accès et qu'il est associé à un jeton d'actualisation, le jeton d'actualisation est également révoqué.

Si la révocation est traitée correctement, le code d'état HTTP de la réponse est 200. En cas d'erreur, un code d'état HTTP 400 est renvoyé avec un code d'erreur.