將 OAuth 2.0 用於網路伺服器應用程式

PHP

如要執行本文件中的 PHP 程式碼範例，您需要：

• 已安裝指令列介面 (CLI) 和 JSON 擴充功能的 PHP 5.6 以上版本。
• Composer 依附元件管理工具。

• PHP 適用的 Google API 用戶端程式庫：

  composer require google/apiclient:^2.10

Python

如要執行本文件中的 Python 程式碼範例，您需要：

• Python 2.6 以上版本
• pip 套件管理工具。
• Python 適用的 Google API 用戶端程式庫：

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

• 用於使用者授權的 google-auth、google-auth-oauthlib 和 google-auth-httplib2。

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

• Flask Python 網頁應用程式架構。

  pip install --upgrade flask

• requests HTTP 程式庫。

  pip install --upgrade requests

Ruby

如要執行本文件中的 Ruby 程式碼範例，您需要：

• Ruby 2.6 以上版本

• Ruby 適用的 Google 驗證程式庫：

  gem install googleauth

• Sinatra Ruby 網頁應用程式架構。

  gem install sinatra

Node.js

如要執行本文件中的 Node.js 程式碼範例，您需要：

• 維護 LTS、使用中的 LTS，或是 Node.js 的目前版本。

• Google API Node.js 用戶端：

  npm install googleapis

HTTP/REST

您不需要安裝任何程式庫，就能直接呼叫 OAuth 2.0 端點。

PHP

下列程式碼片段會建立 Google\Client() 物件，用來定義授權要求中的參數。

這個物件會使用 client_secret.json 檔案中的資訊來識別應用程式。(如要進一步瞭解該檔案，請參閱「建立授權憑證」一節)。這個物件也會識別應用程式要求存取的權限範圍，以及用於處理 Google OAuth 2.0 伺服器回應的應用程式驗證端點網址。最後，程式碼會設定選用的 access_type 和 include_granted_scopes 參數。

舉例來說，以下程式碼會要求取得使用者 Google 雲端硬碟的唯讀存取權：

$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

這項要求會指定以下資訊：

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

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

$client->addScope(Google\Service\Drive::DRIVE_METADATA_READONLY);

$client->setAccessType('offline');

$client->setState($sample_passthrough_value);

$client->setIncludeGrantedScopes(true);

$client->setLoginHint('None');

$client->setPrompt('consent');

Python

下列程式碼片段使用 google-auth-oauthlib.flow 模組建構授權要求。

程式碼會建構 Flow 物件，該物件會使用您在建立授權憑證後下載的 client_secret.json 檔案中的資訊。這個物件也會識別應用程式要求存取的權限範圍，以及用於處理 Google OAuth 2.0 伺服器回應的應用程式驗證端點網址。最後，程式碼會設定選用的 access_type 和 include_granted_scopes 參數。

舉例來說，以下程式碼會要求取得使用者 Google 雲端硬碟的唯讀存取權：

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

這項要求會指定以下資訊：

flow = google_auth_oauthlib.flow.Flow.from_client_secrets_file(
    'client_secret.json',
    scopes=['https://www.googleapis.com/auth/drive.metadata.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/drive.metadata.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

使用您建立的 client_secrets.json 檔案來設定應用程式中的用戶端物件。設定用戶端物件時，您必須指定應用程式需要存取的範圍，以及應用程式的驗證端點網址，以便處理 OAuth 2.0 伺服器的回應。

舉例來說，以下程式碼會要求取得使用者 Google 雲端硬碟的唯讀存取權：

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

重要事項：只有在第一次授權時才會傳回 refresh_token。詳情請參閱 這裡。

HTTP/REST

Google 的 OAuth 2.0 端點位於 https://accounts.google.com/o/oauth2/v2/auth。這個端點只能透過 HTTPS 存取。拒絕一般 HTTP 連線。

Google 授權伺服器支援下列網路伺服器應用程式：

PHP

1. 產生網址，以便向 Google 的 OAuth 2.0 伺服器要求存取權：

   $auth_url = $client->createAuthUrl();

2. 將使用者重新導向至 $auth_url：

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

Python

以下範例說明如何使用 Flask 網頁應用程式架構，將使用者重新導向至授權網址：

return flask.redirect(authorization_url)

Ruby

1. 產生網址，以便向 Google 的 OAuth 2.0 伺服器要求存取權：

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

2. 將使用者重新導向至 auth_uri。

Node.js

1. 使用步驟 1 generateAuthUrl 方法產生的網址 authorizationUrl，向 Google 的 OAuth 2.0 伺服器要求存取權。
2. 將使用者重新導向至 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

建立要求網址後，將使用者重新導向至該網址。

PHP

如要交換存取權杖的授權碼，請使用 authenticate 方法：

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

您可以使用 getAccessToken 方法擷取存取權杖：

$access_token = $client->getAccessToken();

Python

在回呼頁面上，使用 google-auth 程式庫驗證授權伺服器回應。接著，使用 flow.fetch_token 方法交換該回應中的授權碼，換取存取權杖：

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

在回呼頁面上，使用 googleauth 程式庫驗證授權伺服器回應。請使用 authorizer.handle_auth_callback_deferred 方法儲存授權碼，並重新導向回原先要求授權的網址。這會暫時將結果貼到使用者的工作階段，藉此延後交換程式碼。

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

Node.js

如要交換存取權杖的授權碼，請使用 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

如要交換存取權杖的授權碼，請呼叫 https://oauth2.googleapis.com/token 端點，並設定下列參數：

以下程式碼片段為要求範例：

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 會傳回包含短期存取權杖和更新權杖的 JSON 物件來回應這項要求。請注意，只有在應用程式向 Google 授權伺服器發出的初始要求中，將 access_type 參數設為 offline 時，系統才會傳回更新權杖。

回應包含下列欄位：

以下程式碼片段為回應範例：

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

PHP

完成下列步驟，即可使用存取權杖呼叫 Google API：

1. 如果需要將存取權杖套用至新的 Google\Client 物件 (例如，如果您將存取權杖儲存在使用者工作階段)，請使用 setAccessToken 方法：

   $client->setAccessToken($access_token);

2. 為要呼叫的 API 建構服務物件。您可以將授權的 Google\Client 物件提供給您要呼叫的 API 的建構函式，藉此建構服務物件。例如，如要呼叫 Drive API：

   $drive = new Google\Service\Drive($client);

3. 使用服務物件提供的介面向 API 服務傳送要求。舉例來說，如要列出已驗證使用者的 Google 雲端硬碟中的檔案：

   $files = $drive->files->listFiles(array())->getItems();

Python

取得存取權杖後，應用程式就能使用該權杖來代表指定的使用者帳戶或服務帳戶授權 API 要求。使用使用者專屬的授權憑證為要呼叫的 API 建構服務物件，然後使用該物件提出已獲授權的 API 要求。

1. 為要呼叫的 API 建構服務物件。您可以呼叫 googleapiclient.discovery 程式庫的 build 方法，並提供 API 的名稱和版本以及使用者憑證，藉此建構服務物件：例如呼叫 Drive API 第 3 版：

   from googleapiclient.discovery import build
   
   drive = build('drive', 'v2', credentials=credentials)

2. 使用服務物件提供的介面向 API 服務傳送要求。舉例來說，如要列出已驗證使用者的 Google 雲端硬碟中的檔案：

   files = drive.files().list().execute()

Ruby

取得存取權杖後，應用程式就能使用該憑證，代表指定的使用者帳戶或服務帳戶提出 API 要求。使用使用者專屬的授權憑證為要呼叫的 API 建構服務物件，然後使用該物件提出已獲授權的 API 要求。

1. 為要呼叫的 API 建構服務物件。 舉例來說，如要呼叫 Drive API 第 3 版：

   drive = Google::Apis::DriveV3::DriveService.new

2. 設定服務的憑證：

   drive.authorization = credentials

3. 使用服務物件提供的介面向 API 服務發出要求。舉例來說，如要列出已驗證使用者的 Google 雲端硬碟中的檔案：

   files = drive.list_files

或者，您也可以將 options 參數提供給方法，依個別方法提供授權：

files = drive.list_files(options: { authorization: credentials })

Node.js

取得存取權杖並將其設為 OAuth2 物件後，請使用該物件呼叫 Google API。應用程式可使用該權杖，代表指定的使用者帳戶或服務帳戶授權 API 要求。為要呼叫的 API 建構服務物件。

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

應用程式取得存取權杖後，如果您已獲得 API 所需的存取權範圍，就能使用權杖代表指定使用者帳戶呼叫 Google API。方法是加入 access_token 查詢參數或 Authorization HTTP 標頭 Bearer 值，在向 API 發出的要求中加入存取權杖。請盡可能使用 HTTP 標頭，因為查詢字串通常會顯示在伺服器記錄中。在多數情況下，您可以使用用戶端程式庫設定對 Google API 的呼叫 (例如呼叫 Drive Files API 時)。

您可以在 OAuth 2.0 Playground 試用所有 Google API 並查看其範圍。

HTTP GET 範例

使用 Authorization: Bearer HTTP 標頭呼叫 drive.files 端點 (Drive Files API) 時，看起來可能如下所示。請注意，您必須指定自己的存取權杖：

GET /drive/v2/files HTTP/1.1
Host: www.googleapis.com
Authorization: Bearer access_token

以下示範使用 access_token 查詢字串參數，為已驗證使用者呼叫同一個 API：

GET https://www.googleapis.com/drive/v2/files?access_token=access_token

curl 範例

您可以使用 curl 指令列應用程式測試這些指令。以下提供使用 HTTP 標頭選項的範例 (建議選項)：

curl -H "Authorization: Bearer access_token" https://www.googleapis.com/drive/v2/files

或者，您也可以使用查詢字串參數選項：

curl https://www.googleapis.com/drive/v2/files?access_token=access_token

PHP

如要執行這個範例，請按照下列指示操作：

1. 在 API Console中，將本機電腦的網址加入重新導向網址的清單。例如，加入 http://localhost:8080。
2. 建立新目錄，然後變更為該目錄。例如：

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

3. 使用 Composer 安裝 PHP 適用的 Google API 用戶端程式庫：

   composer require google/apiclient:^2.10

4. 使用下列內容建立 index.php 和 oauth2callback.php 檔案。
5. 使用設定為提供 PHP 的網路伺服器執行範例。如果您使用的是 PHP 5.6 以上版本，可以使用 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

本範例使用 Flask 架構。它會在 http://localhost:8080 執行網頁應用程式，可讓您測試 OAuth 2.0 流程。如果您前往該網址，就會看到 4 個連結：

• 測試 API 要求：這個連結會指向嘗試執行範例 API 要求的網頁。必要時，系統會啟動授權流程。如果成功，頁面會顯示 API 回應。
• 直接測試驗證流程：這個連結會指向嘗試透過授權流程傳送使用者的頁面。應用程式會代表使用者要求取得授權 API 要求的權限。
• 撤銷目前的憑證：這個連結指向的網頁會 撤銷使用者已授予應用程式的權限。
• 清除 Flask 工作階段憑證：這個連結會清除儲存在 Flask 工作階段中的授權憑證。這可讓您瞭解如果已授予應用程式權限的使用者嘗試在新的工作階段中執行 API 要求，會發生什麼情況。此外，如果使用者已撤銷授予應用程式的權限，但應用程式仍嘗試透過已撤銷的存取權杖授權要求，則應用程式也會收到這個 API 回應。

# -*- 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

本範例使用 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

如要執行這個範例，請按照下列指示操作：

1. 在 API Console中，將本機電腦的網址加入重新導向網址清單中，例如加入 http://localhost。
2. 請確認已安裝 LTS、使用中的 LTS，或是已安裝的 Node.js 目前版本。
3. 建立新目錄，然後變更為該目錄。例如：

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

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

   npm install googleapis

5. 使用以下內容建立 main.js 檔案。
6. 執行範例：

   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

這個 Python 範例使用 Flask 架構和 Requests 程式庫來示範 OAuth 2.0 網路流程。建議您使用 Python 適用的 Google API 用戶端程式庫來進行這個流程。(Python 分頁中的範例使用用戶端程式庫)。

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

PHP

$client->setIncludeGrantedScopes(true);

Python

在 Python 中，將 include_granted_scopes 關鍵字引數設為 true，確保授權要求包含先前授予的範圍。include_granted_scopes 很有可能不是您設定的「唯一」關鍵字引數，如以下範例所示。

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

PHP

如果應用程式需要離線存取 Google API，請將 API 用戶端的存取權類型設為 offline：

$client->setAccessType("offline");

在使用者離線授予要求範圍後，您可以繼續使用 API 用戶端，在使用者離線時代表使用者存取 Google API。用戶端物件會視需要更新存取權杖。

Python

在 Python 中，將 access_type 關鍵字引數設為 offline，這樣您才能更新存取權杖，而無須重新提示使用者授予權限。access_type 很有可能不是您設定的「唯一」關鍵字引數，如以下範例所示。

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

在使用者離線授予要求範圍後，您可以繼續使用 API 用戶端，在使用者離線時代表使用者存取 Google API。用戶端物件會視需要更新存取權杖。

Ruby

如果應用程式需要離線存取 Google API，請將 API 用戶端的存取權類型設為 offline：

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

在使用者離線授予要求範圍後，您可以繼續使用 API 用戶端，在使用者離線時代表使用者存取 Google API。用戶端物件會視需要更新存取權杖。

Node.js

如果應用程式需要離線存取 Google API，請將 API 用戶端的存取權類型設為 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
});

在使用者離線授予要求範圍後，您可以繼續使用 API 用戶端，在使用者離線時代表使用者存取 Google API。用戶端物件會視需要更新存取權杖。

存取權杖過期。如果存取權杖即將到期，這個程式庫會自動使用更新權杖取得新的存取權杖。想要確保一律儲存最新的權杖，最簡單的方法是使用權杖事件：

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

這個權杖事件只會在第一個授權發生，而您需要在呼叫 generateAuthUrl 方法接收更新權杖時，將 access_type 設為 offline。如果您已為應用程式授予必備權限，但未設定接收更新權杖的適當限制，則必須重新授權應用程式接收更新版權杖。

如要稍後再設定 refresh_token，可以使用 setCredentials 方法：

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

用戶端擁有更新權杖後，系統就會取得存取權杖，並在下次呼叫 API 時自動重新整理。

HTTP/REST

如要更新存取權杖，應用程式會將 HTTPS POST 要求傳送至 Google 的授權伺服器 (https://oauth2.googleapis.com/token)，其中包含下列參數：

以下程式碼片段為要求範例：

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

只要使用者尚未撤銷授予應用程式的存取權，憑證伺服器就會傳回包含新存取權杖的 JSON 物件。下列程式碼片段顯示回應範例：

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

請注意，發送的更新權杖有數量限制；每個用戶端/使用者組合各有一個限制，而所有用戶端上每位使用者只能有一項限制。您應該長期將更新權杖儲存在長期儲存空間中，並在權杖有效期間繼續使用。如果您的應用程式要求的更新權杖過多，可能會超過這些限制，屆時舊的更新權杖會停止運作。

PHP

如要透過程式輔助方式撤銷權杖，請呼叫 revokeToken()：

$client->revokeToken();

Python

如要透過程式輔助方式撤銷權杖，請向 https://oauth2.googleapis.com/revoke 發出要求，並將權杖做為參數，並設定 Content-Type 標頭：

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

Ruby

如要透過程式撤銷權杖，請向 oauth2.revoke 端點發出 HTTP 要求：

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

可以是存取權杖或更新權杖。如果權杖是存取權杖，且具有對應的更新權杖，系統會一併撤銷更新權杖。

如果撤銷成功處理完畢，回應的狀態碼就會是 200。如果是錯誤狀況，系統會傳回狀態碼 400 和錯誤代碼。

Node.js

如要透過程式撤銷權杖，請向 /revoke 端點發出 HTTPS POST 要求：

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

權杖參數可以是存取權杖或更新權杖。如果權杖是存取權杖，且具有對應的更新權杖，系統會一併撤銷更新權杖。

如果撤銷成功處理完畢，回應的狀態碼就會是 200。如果是錯誤狀況，系統會傳回狀態碼 400 和錯誤代碼。

HTTP/REST

如要透過程式撤銷權杖，應用程式會向 https://oauth2.googleapis.com/revoke 發出要求，並加入權杖做為參數：

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

可以是存取權杖或更新權杖。如果權杖是存取權杖，且具有對應的更新權杖，系統會一併撤銷更新權杖。

如果撤銷成功處理完畢，回應的 HTTP 狀態碼為 200。如果是錯誤狀況，系統會傳回 HTTP 狀態碼 400，以及錯誤代碼。