為網路應用程式應用程式使用 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.2.2 以上版本

• Ruby 專用的 Google API 用戶端程式庫：

  gem install google-api-client

• 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" ensures that your application always receives a refresh token.
// If you are not using offline access, you can omit this.
$client->setApprovalPrompt('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->setApprovalPrompt('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_v2'
require 'google/api_client/client_secrets'

client_secrets = Google::APIClient::ClientSecrets.load
auth_client = client_secrets.to_authorization
auth_client.update!(
  :scope => 'https://www.googleapis.com/auth/drive.metadata.readonly',
  :redirect_uri => 'http://www.example.com/oauth2callback',
  :additional_parameters => {
    "access_type" => "offline",         # offline access
    "include_granted_scopes" => "true"  # incremental auth
  }
)

您的應用程式會使用用戶端物件執行 OAuth 2.0 作業，例如產生授權要求網址，以及將存取權杖套用至 HTTP 要求。

Node.js

下方的程式碼片段會建立 google.auth.OAuth2 物件，該物件定義授權要求中的參數。

該物件使用來自 client_secret.json 檔案的資訊，以識別您的應用程式。 如要要求使用者擷取存取權杖，請將使用者重新導向至同意聲明頁面。 如何建立同意聲明頁面網址：

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 = auth_client.authorization_uri.to_s

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

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

auth_client.code = auth_code
auth_client.fetch_access_token!

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 建構服務物件。您可以為服務呼叫的 API 提供授權的 Google\Client 物件，藉此建構服務物件。比如呼叫 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 第 2 版：

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

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

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

Ruby

完成下列步驟，使用 auth_client 物件呼叫 Google API：

1. 為您要呼叫的 API 建構服務物件。例如，呼叫 Drive API 第 2 版：

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

2. 在服務中設定憑證：

   drive.authorization = auth_client

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

   files = drive.list_files

或者，您也可以為方法提供 options 參數，藉此根據方法提供授權：

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

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。方法是在向 API 發出的要求中加入存取權杖，方法是加入 access_token 查詢參數或 Authorization HTTP 標頭 Bearer 的值。請盡可能使用 HTTP 標頭，因為查詢字串經常出現在伺服器記錄中。在多數情況下，您可以使用用戶端程式庫來設定對 Google API 的呼叫 (例如在呼叫 Drive API 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 流程。如果前往該網址，您會看到四個連結：

• 測試 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_v2'
require 'google/api_client/client_secrets'
require 'json'
require 'sinatra'

enable :sessions
set :session_secret, 'setme'

get '/' do
  unless session.has_key?(:credentials)
    redirect to('/oauth2callback')
  end
  client_opts = JSON.parse(session[:credentials])
  auth_client = Signet::OAuth2::Client.new(client_opts)
  drive = Google::Apis::DriveV2::DriveService.new
  files = drive.list_files(options: { authorization: auth_client })
  "<pre>#{JSON.pretty_generate(files.to_h)}</pre>"
end

get '/oauth2callback' do
  client_secrets = Google::APIClient::ClientSecrets.load
  auth_client = client_secrets.to_authorization
  auth_client.update!(
    :scope => 'https://www.googleapis.com/auth/drive.metadata.readonly',
    :redirect_uri => url('/oauth2callback'))
  if request['code'] == nil
    auth_uri = auth_client.authorization_uri.to_s
    redirect to(auth_uri)
  else
    auth_client.code = request['code']
    auth_client.fetch_access_token!
    auth_client.client_secret = nil
    session[:credentials] = auth_client.to_json
    redirect to('/')
  end
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 以及錯誤代碼。