本文說明網路伺服器應用程式如何使用 Google API 用戶端程式庫或 Google OAuth 2.0 端點,執行 OAuth 2.0 授權來存取 YouTube Analytics API 或 YouTube Reporting API。
OAuth 2.0 可讓使用者與應用程式共用特定資料,同時保有使用者名稱、密碼和其他資訊的私密性。 舉例來說,應用程式可透過 OAuth 2.0 取得權限,藉此擷取頻道的 YouTube 數據分析資料。
這個 OAuth 2.0 流程是專為使用者授權所設計。這種設計適用於可以儲存機密資訊並維持狀態的應用程式。經過適當授權的網路伺服器應用程式可在使用者與應用程式互動時或使用者離開應用程式後存取 API。
網路伺服器應用程式經常會使用 服務帳戶來授權 API 要求,特別是在呼叫 Cloud API 以存取專案資料,而非使用者特定資料時。網路伺服器應用程式可將服務帳戶與使用者授權搭配使用。
- YouTube Analytics API 不支援服務帳戶流程。
- 對於擁有及管理多個 YouTube 頻道的 YouTube 內容擁有者,YouTube Reporting API 僅支援服務帳戶流程。具體而言,內容擁有者可以在設定
onBehalfOfContentOwner
要求參數值的 API 要求中使用服務帳戶。
用戶端程式庫
本頁各語言適用的範例是使用 Google API 用戶端程式庫實作 OAuth 2.0 授權。如要執行程式碼範例,請先安裝適用於您語言的用戶端程式庫。
使用 Google API 用戶端程式庫處理應用程式的 OAuth 2.0 流程時,用戶端程式庫會執行應用程式需要自行處理的許多動作。例如,判斷應用程式何時可以使用或重新整理儲存的存取權杖,以及應用程式必須重新取得同意聲明的時機。用戶端程式庫也會產生正確的重新導向網址,並協助實作重新導向處理常式,以交換存取權杖的授權碼。
伺服器端應用程式適用的 Google API 用戶端程式庫支援下列語言:
必要條件
為專案啟用 API
呼叫 Google API 的所有應用程式都必須在 API Console中啟用這些 API。
如要在專案中啟用 API,請按照下列步驟操作:
- Open the API Library (位於 Google API Console中)。
- If prompted, select a project, or create a new one.
- 在資料庫頁面中,您可以找到並啟用 YouTube Analytics API 和 YouTube Reporting API。許多擷取 YouTube Analytics (分析) 資料的應用程式也會透過 YouTube Data API 介面使用。找出應用程式要使用的任何其他 API,並啟用這些 API。
建立授權憑證
凡是使用 OAuth 2.0 存取 Google API 的應用程式,都必須具備授權憑證,用來向 Google 的 OAuth 2.0 伺服器識別應用程式。下列步驟說明如何為專案建立憑證。接著,您的應用程式就能使用憑證存取您為該專案啟用的 API。
- Go to the Credentials page.
- 按一下 [Create credentials] (建立憑證) > [OAuth client ID] (OAuth 用戶端 ID)。
- 選取「Web application」(網頁應用程式) 應用程式類型。
- 填寫表單並按一下「Create」。使用 PHP、Java、Python、Ruby 和 .NET 等語言和架構的應用程式,必須指定已授權的重新導向 URI。重新導向 URI 是 OAuth 2.0 伺服器可以傳送回應的端點。這些端點必須遵循 Google 的驗證規則。
如要進行測試,您可以指定參照本機電腦的 URI,例如
http://localhost:8080
。因此請注意,本文件中的所有範例均使用http://localhost:8080
做為重新導向 URI。我們建議您設計應用程式的驗證端點,以讓應用程式不會向該頁面上的其他資源顯示授權碼。
建立憑證後,請從 API Console下載 client_secret.json 檔案。將檔案安全地存放在應用程式可存取的位置。
識別存取權範圍
範圍可讓應用程式僅要求存取所需的資源,也能讓使用者控管自己授予應用程式的存取權量。因此,要求的範圍數量與取得使用者同意聲明的可能性之間存在反向關係。
開始實作 OAuth 2.0 授權之前,建議您先找出應用程式需要權限存取的範圍。
我們也建議您的應用程式透過漸進式授權程序,要求存取授權範圍,因為應用程式會在相關情境下要求存取使用者資料。這項最佳做法可方便使用者瞭解應用程式需要其存取權的原因。
YouTube Analytics API 使用的範圍如下:
範圍 | |
---|---|
https://www.googleapis.com/auth/youtube | 管理您的YouTube帳戶 |
https://www.googleapis.com/auth/youtube.readonly | 查看您的YouTube帳戶 |
https://www.googleapis.com/auth/youtubepartner | 在YouTube上查看和管理您的資產和相關內容 |
https://www.googleapis.com/auth/yt-analytics-monetary.readonly | 查看您的YouTube內容的貨幣和非貨幣YouTube分析報告 |
https://www.googleapis.com/auth/yt-analytics.readonly | 查看有關您的YouTube內容的YouTube分析報告 |
YouTube Reporting API 使用的範圍如下:
範圍 | |
---|---|
https://www.googleapis.com/auth/yt-analytics-monetary.readonly | 查看您的YouTube內容的貨幣和非貨幣YouTube分析報告 |
https://www.googleapis.com/auth/yt-analytics.readonly | 查看有關YouTube內容的YouTube分析報告 |
OAuth 2.0 API 範圍文件內含存取 Google API 時可能使用的完整範圍清單。
語言相關規定
您必須擁有 Google 帳戶、存取網際網路和網路瀏覽器,才能執行本文件中的任何程式碼範例。如果您使用其中一個 API 用戶端程式庫,請一併參閱下方的語言專屬規定。
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 程式碼範例,您需要:
- Node.js 維護 LTS、使用中的 LTS 或目前版本的 Node.js。
-
Google API Node.js 用戶端:
npm install googleapis crypto express express-session
HTTP/REST
您不必安裝任何程式庫即可直接呼叫 OAuth 2.0 端點。
取得 OAuth 2.0 存取權杖
下列步驟顯示您的應用程式如何與 Google 的 OAuth 2.0 伺服器互動,以取得使用者的同意,並代表使用者執行 API 要求。您的應用程式必須取得這項同意聲明,才能執行需要使用者授權的 Google API 要求。
下方清單簡要列出這些步驟:
- 應用程式會識別其需要的權限。
- 您的應用程式會將使用者重新導向 Google 以及要求的權限清單。
- 使用者會決定是否要將權限授予您的應用程式。
- 您的應用程式會決定使用者決定的決定。
- 如果使用者已授予要求的權限,應用程式就會擷取代表使用者提出 API 要求所需的權杖。
步驟 1:設定授權參數
第一步是建立授權要求。該要求會設定參數以識別您的應用程式,並定義使用者必須授予應用程式的權限。
- 如果您使用 Google 用戶端程式庫進行 OAuth 2.0 驗證和授權,請建立並設定定義這些參數的物件。
- 如果您直接呼叫 Google OAuth 2.0 端點,會產生一個網址並設定該網址的參數。
以下標籤定義了網路伺服器應用程式支援的授權參數。這些語言專用的範例也說明如何使用用戶端程式庫或授權程式庫設定物件,以設定這些參數。
PHP
下列程式碼片段會建立 Google\Client()
物件,以定義授權要求中的參數。
這個物件會使用 client_secret.json 檔案中的資訊來識別應用程式。(如要進一步瞭解該檔案,請參閱「建立授權憑證」一文)。這個物件也會識別應用程式要求存取權限的範圍,以及應用程式驗證端點的網址,該端點會處理來自 Google OAuth 2.0 伺服器的回應。最後,程式碼會設定選用的 access_type
和 include_granted_scopes
參數。
舉例來說,如要要求離線存取,以便擷取使用者的 YouTube 數據分析報表:
$client = new Google\Client(); // Required, call the setAuthConfig function to load authorization credentials from // client_secret.json file. $client->setAuthConfig('client_secret.json'); // Required, to set the scope value, call the addScope function $client->addScope(Google_Service_YouTubeAnalytics::YT_ANALYTICS_READONLY); // Required, call the setRedirectUri function to specify a valid redirect URI for the // provided client_id $client->setRedirectUri('http://' . $_SERVER['HTTP_HOST'] . '/oauth2callback.php'); // Recommended, 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'); // Recommended, call the setState function. Using a state value can increase your assurance that // an incoming connection is the result of an authentication request. $client->setState($sample_passthrough_value); // Optional, if your application knows which user is trying to authenticate, it can use this // parameter to provide a hint to the Google Authentication Server. $client->setLoginHint('hint@example.com'); // Optional, call the setPrompt function to set "consent" will prompt the user for consent $client->setPrompt('consent'); // Optional, call the setIncludeGrantedScopes function with true to enable incremental // authorization $client->setIncludeGrantedScopes(true);
Python
下列程式碼片段使用 google-auth-oauthlib.flow
模組建構授權要求。
程式碼會建構 Flow
物件,該物件會使用您在建立授權憑證後下載的 client_secret.json 檔案中的資訊來識別您的應用程式。該物件也會識別應用程式要求存取權限的範圍,以及應用程式驗證端點的網址,該端點會處理來自 Google OAuth 2.0 伺服器的回應。最後,程式碼會設定選用的 access_type
和 include_granted_scopes
參數。
舉例來說,如要要求離線存取,以便擷取使用者的 YouTube 數據分析報表:
import google.oauth2.credentials import google_auth_oauthlib.flow # Required, call the from_client_secrets_file method to retrieve the client ID from a # client_secret.json file. The client ID (from that file) and access scopes are required. (You can # also use the from_client_config method, which passes the client configuration as it originally # appeared in a client secrets file but doesn't access the file itself.) flow = google_auth_oauthlib.flow.Flow.from_client_secrets_file( 'client_secret.json', scopes=['https://www.googleapis.com/auth/yt-analytics.readonly']) # Required, 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( # Recommended, 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', # Optional, enable incremental authorization. Recommended as a best practice. include_granted_scopes='true', # Optional, if your application knows which user is trying to authenticate, it can use this # parameter to provide a hint to the Google Authentication Server. login_hint='hint@example.com', # Optional, set prompt to 'consent' will prompt the user for consent prompt='consent')
Ruby
使用您建立的 client_secrets.json 檔案設定應用程式中的用戶端物件。設定用戶端物件時,您需要指定應用程式需要存取的範圍,以及應用程式驗證端點的網址;該端點會處理來自 OAuth 2.0 伺服器的回應。
舉例來說,如要要求離線存取,以便擷取使用者的 YouTube 數據分析報表:
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')
您的應用程式使用用戶端物件執行 OAuth 2.0 作業,例如產生授權要求網址以及將存取權杖套用至 HTTP 要求。
Node.js
下列程式碼片段會建立 google.auth.OAuth2
物件,以定義授權要求中的參數。
這個物件會使用 client_secret.json 檔案中的資訊來識別您的應用程式。如要向使用者要求取得存取權杖的權限,請將他們重新導向至同意頁面。建立同意聲明頁面網址的步驟如下:
const {google} = require('googleapis'); const crypto = require('crypto'); const express = require('express'); const session = require('express-session'); /** * 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 secure random state value. const state = crypto.randomBytes(32).toString('hex'); // Store state in the session req.session.state = state; // 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, // Include the state parameter to reduce the risk of CSRF attacks. state: state });
重要注意事項 - refresh_token
只會在第一次授權時傳回。詳情請參閱
這篇文章。
HTTP/REST
Google 的 OAuth 2.0 端點位於 https://accounts.google.com/o/oauth2/v2/auth
。這個端點只能透過 HTTPS 存取。系統會拒絕純 HTTP 連線。
Google 授權伺服器支援下列網路伺服器應用程式專用的查詢字串參數:
參數 | |||||||||||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
client_id |
必填
應用程式的用戶端 ID。您可以在 API Console Credentials page中找到這個值。 |
||||||||||||||||||
redirect_uri |
必填
決定 API 伺服器在使用者完成授權流程後將使用者重新導向的位置。這個值必須與您在用戶端的 API Console
Credentials page中設定的 OAuth 2.0 用戶端其中一個已授權重新導向 URI 完全相符。如果這個值與所提供 請注意, |
||||||||||||||||||
response_type |
必填
決定 Google OAuth 2.0 端點是否傳回授權碼。 將網路伺服器應用程式的參數值設為 |
||||||||||||||||||
scope |
必填
以空格分隔的範圍清單,用來識別應用程式可以代表使用者存取的資源。這些值會告知 Google 向使用者顯示的同意畫面。 範圍可讓應用程式僅要求存取所需的資源,也能讓使用者控管自己授予應用程式的存取權量。因此,要求的範圍數量與取得使用者同意聲明的可能性之間存在反向關係。 YouTube Analytics API 使用的範圍如下:
YouTube Reporting API 使用的範圍如下:
OAuth 2.0 API 範圍文件提供了可用於存取 Google API 的完整範圍清單。 建議您讓應用程式盡可能在情境下要求授權範圍的存取權。您可以透過漸進式授權,在相關情境下要求使用者資料存取,讓使用者更容易瞭解應用程式需要其存取權限的原因。 |
||||||||||||||||||
access_type |
建議
指出當瀏覽器中沒有使用者時,應用程式能否重新整理存取權杖。有效參數值包括 如果您的應用程式需要重新整理存取權杖,但瀏覽器未開啟,請將值設為 |
||||||||||||||||||
state |
建議
指定應用程式用來在授權要求和授權伺服器回應之間維持狀態的任何字串值。在使用者同意或拒絕應用程式存取要求後,伺服器會傳回您在 這項參數的用途很多,例如將使用者導向應用程式中的正確資源、傳送 Nonce,以及減輕偽造跨網站要求偽造要求。由於 |
||||||||||||||||||
include_granted_scopes |
選用
讓應用程式使用漸進式授權,在相關情境下要求其他範圍的存取權。如果將此參數值設為 |
||||||||||||||||||
enable_granular_consent |
選用
預設為 |
||||||||||||||||||
login_hint |
選用
如果應用程式知道要驗證的使用者,就能使用這項參數向 Google 驗證伺服器提供提示。伺服器會使用提示來簡化登入流程,方法是在登入表單中預先填入電子郵件欄位,或是選取適當的多帳戶登入工作階段。 將參數值設為電子郵件地址或 |
||||||||||||||||||
prompt |
選用
以空格分隔、區分大小寫的提示清單。如未指定這個參數,系統只會在專案首次要求存取權時提示使用者。詳情請參閱「 提示重新同意」。 可能的值為:
|
步驟 2:重新導向至 Google 的 OAuth 2.0 伺服器
將使用者重新導向至 Google 的 OAuth 2.0 伺服器,以便啟動驗證和授權程序。一般而言,如果應用程式首次需要存取使用者資料,就會發生這種情況。以漸進式授權來說,當應用程式首次需要存取尚未取得存取權限的其他資源時,也會執行這個步驟。
PHP
- 產生網址,以便向 Google 的 OAuth 2.0 伺服器要求存取權:
$auth_url = $client->createAuthUrl();
- 將使用者重新導向至
$auth_url
:header('Location: ' . filter_var($auth_url, FILTER_SANITIZE_URL));
Python
以下範例說明如何使用 Flask 網頁應用程式架構,將使用者重新導向至授權網址:
return flask.redirect(authorization_url)
Ruby
- 產生網址,向 Google 的 OAuth 2.0 伺服器要求存取權:
auth_uri = authorizer.get_authorization_url(login_hint: user_id, request: request)
- 將使用者重新導向至
auth_uri
。
Node.js
-
使用步驟 1
generateAuthUrl
方法中產生的網址authorizationUrl
,向 Google 的 OAuth 2.0 伺服器要求存取權。 -
將使用者重新導向至
authorizationUrl
。res.redirect(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
建立要求網址後,請將使用者重新導向至該網址。
Google 的 OAuth 2.0 伺服器會驗證使用者身分,並徵得使用者的同意,才能讓應用程式存取要求的範圍。系統會使用您指定的重新導向網址,將回應傳回應用程式。
步驟 3:Google 提示使用者提供同意聲明
在這個步驟中,使用者決定是否授予應用程式所要求的存取權。在這個階段,Google 會顯示同意視窗,其中會顯示應用程式名稱和要求存取權的 Google API 服務,並提供使用者的授權憑證,以及要授予何種存取權範圍的摘要。接著,使用者可選擇同意授予一或多個應用程式要求的存取權,或拒絕要求。
在這個階段,應用程式不需要採取任何行動,因為會等候 Google OAuth 2.0 伺服器的回應,說明是否已授予任何存取權。詳細說明請參閱下列步驟。
錯誤
向 Google OAuth 2.0 授權端點發出的要求可能會顯示向使用者顯示的錯誤訊息,而非預期的驗證和授權流程。以下列出常見的錯誤代碼和建議解決方法。
admin_policy_enforced
Google 帳戶無法依據 Google Workspace 管理員的政策,授權給一或多個要求的範圍。請參閱 Google Workspace 管理員說明文章「 控管哪些第三方應用程式和內部應用程式可存取 Google Workspace 資料」,進一步瞭解管理員如何限制所有範圍或敏感/受限制範圍的存取權,直到明確授予 OAuth 用戶端 ID 存取權為止。
disallowed_useragent
授權端點顯示在嵌入式使用者代理程式中,而 Google 的 OAuth 2.0 政策不允許使用。
Android
Android 開發人員在 android.webkit.WebView
中開啟授權要求時,可能會看見這則錯誤訊息。開發人員應改用 Android 程式庫,例如 Android 版 Google 登入或 OpenID Foundation 的 AppAuth for Android。
如果 Android 應用程式是在嵌入式使用者代理程式中開啟一般網頁連結,當使用者從您的網站前往 Google 的 OAuth 2.0 授權端點時,就可能會遇到這個錯誤。開發人員應允許在作業系統的預設連結處理常式中開啟一般連結,包括 Android 應用程式連結處理常式或預設瀏覽器應用程式。此外,您也可以使用「Android 自訂分頁」程式庫。
iOS
iOS 和 macOS 開發人員在 WKWebView
中開啟授權要求時,可能會遇到這個錯誤。開發人員應改用 iOS 程式庫,例如 iOS 適用的 Google 登入或 OpenID Foundation 的 AppAuth。
如果 iOS 或 macOS 應用程式在嵌入式使用者代理程式中開啟一般網頁連結,當使用者從您的網站前往 Google 的 OAuth 2.0 授權端點時,就可能會遇到這個錯誤。開發人員應允許在作業系統的預設連結處理常式中開啟一般連結,包括通用連結處理常式或預設瀏覽器應用程式。此外,您也可以使用 SFSafariViewController
程式庫。
org_internal
要求中的 OAuth 用戶端 ID 屬於專案的一部分,其作用將限制特定 Google Cloud 機構的 Google 帳戶存取權。如要進一步瞭解這項設定選項,請參閱「設定 OAuth 同意畫面」說明文章中的「使用者類型」一節。
invalid_client
OAuth 用戶端密鑰不正確。查看 OAuth 用戶端設定,包括此要求使用的用戶端 ID 和密鑰。
invalid_grant
更新存取權杖或使用漸進式授權功能時,權杖可能已過期或失效。再次驗證使用者,並要求使用者同意取得新的權杖。如果持續看到這個錯誤,請確認應用程式設定正確無誤,且在要求中使用了正確的權杖和參數。否則,使用者帳戶可能已遭刪除或停用。
redirect_uri_mismatch
授權要求中傳遞的 redirect_uri
與 OAuth 用戶端 ID 的授權重新導向 URI 不符。在 Google API Console Credentials page中查看已授權的重新導向 URI。
redirect_uri
參數可能代表已淘汰且不再受支援的 OAuth 頻外 (OOB) 流程。請參閱遷移指南來更新整合作業。
invalid_request
您提出的要求出現錯誤。可能的原因包括:
- 要求的格式不正確
- 要求缺少必要參數
- 該要求使用 Google 不支援的授權方法。確認 OAuth 整合作業使用建議的整合方法
步驟 4:處理 OAuth 2.0 伺服器回應
OAuth 2.0 伺服器會使用要求中指定的網址回應應用程式的存取要求。
如果使用者核准了存取要求,回應內便會提供授權碼。如果使用者並未核准要求,回應內便會提供錯誤訊息。傳回至網路伺服器的授權碼或錯誤訊息會顯示在查詢字串中,如下所示:
錯誤回應:
https://oauth2.example.com/auth?error=access_denied
授權碼回應:
https://oauth2.example.com/auth?code=4/P7q7W91a-oMsCeLvIaQm6bTrgtp7
OAuth 2.0 伺服器回應範例
如要測試這個流程,請點選下列範例網址,該網址會要求讀取您 Google 雲端硬碟中檔案中繼資料的唯讀存取權:
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
完成 OAuth 2.0 流程後,您應該會重新導向至 http://localhost/oauth2callback
。除非本機電腦提供位於該位址的檔案,否則這可能會產生 404 NOT FOUND
錯誤。下一個步驟將提供更多詳細資料,讓您瞭解當使用者重新導向至您的應用程式時,URI 中傳回的資訊。
步驟 5:交換用於重新整理和存取權杖的授權碼
網路伺服器收到授權碼後,就可以用授權碼交換存取權杖。
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/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
在回呼頁面上,使用 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. app.get('/oauth2callback', async (req, res) => { 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 if (q.state !== req.session.state) { //check state value console.log('State mismatch. Possible CSRF attack'); res.end('State mismatch. Possible CSRF attack'); } else { // 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
端點並設定下列參數:
欄位 | |
---|---|
client_id |
從 Credentials page API Console取得的用戶端 ID。 |
client_secret |
從 Credentials page API Console取得的用戶端密鑰。 |
code |
初始要求傳回的授權碼。 |
grant_type |
根據 OAuth 2.0 規格的定義,這個欄位的值必須設為 authorization_code 。 |
redirect_uri |
針對指定的 client_id ,在 API Console
Credentials page 中為專案列出的其中一個重新導向 URI。 |
以下程式碼片段為要求範例:
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 |
應用程式傳送的憑證以授權 Google API 要求。 |
expires_in |
存取權杖的剩餘生命週期 (以秒為單位)。 |
refresh_token |
可用來取得新存取權杖的權杖。重新整理權杖的效力直到使用者撤銷存取權為止。再次提醒您,只有在向 Google 授權伺服器初次要求時將 access_type 參數設為 offline 時,此回應中才會顯示這個欄位。
|
scope |
access_token 授予的存取權範圍,以以空格分隔且區分大小寫的字串清單表示。 |
token_type |
傳回的權杖類型。目前,這個欄位的值一律會設為 Bearer 。 |
以下程式碼片段為回應範例:
{ "access_token": "1/fFAGRNJru1FTz70BzhT3Zg", "expires_in": 3920, "token_type": "Bearer", "scope": "https://www.googleapis.com/auth/yt-analytics.readonly", "refresh_token": "1//xEoDL4iW3cxlI7yDbSRFYNG01kVKM2C-259HOF2aQbI" }
錯誤
為存取權杖交換授權碼時,可能會遇到下列錯誤,而非預期的回應。以下列出常見的錯誤代碼和建議解決方法。
invalid_grant
提供的授權碼無效或格式錯誤。請重新啟動 OAuth 程序索取新的代碼,再次提示使用者同意。
呼叫 Google API
PHP
如要使用存取權杖呼叫 Google API,請完成下列步驟:
- 如果需要將存取權杖套用至新的
Google\Client
物件 (例如將存取權杖儲存在使用者工作階段中),請使用setAccessToken
方法:$client->setAccessToken($access_token);
- 為要呼叫的 API 建構服務物件。您可以為要呼叫的 API 的建構函式,提供已授權的
Google\Client
物件,藉此建構服務物件。例如呼叫 YouTube Analytics API:$youtube = new Google_Service_YouTubeAnalytics($client);
- 使用服務物件提供的介面向 API 服務發出要求。舉例來說,如要針對已驗證使用者的頻道擷取 YouTube 數據分析報表,請按照下列步驟操作:
$report = $youtube->reports->query('channel==MINE', '2016-05-01', '2016-06-30', 'views');
Python
取得存取權杖後,應用程式就能使用該權杖,代表指定使用者帳戶或服務帳戶授權 API 要求。以使用者專屬的授權憑證為您要呼叫的 API 建構服務物件,然後使用該物件提出已授權的 API 要求。
- 為要呼叫的 API 建構服務物件。您可以使用 API 名稱和使用者憑證來呼叫
googleapiclient.discovery
程式庫的build
方法,藉此建構服務物件: 例如,呼叫 YouTube Analytics API 的第 1 版:from googleapiclient.discovery import build youtube = build('youtubeAnalytics', 'v1', credentials=credentials)
- 使用服務物件提供的介面向 API 服務發出要求。舉例來說,如要針對已驗證使用者的頻道擷取 YouTube 數據分析報表,請按照下列步驟操作:
report = youtube.reports().query(ids='channel==MINE', start_date='2016-05-01', end_date='2016-06-30', metrics='views').execute()
Ruby
取得存取權杖後,應用程式就能使用該權杖,代表指定使用者帳戶或服務帳戶提出 API 要求。以使用者專屬的授權憑證為您要呼叫的 API 建構服務物件,然後使用該物件提出已授權的 API 要求。
- 為要呼叫的 API 建構服務物件。舉例來說,如要呼叫 YouTube Analytics API 第 1 版,請按照下列步驟操作:
youtube = Google::Apis::YoutubeAnalyticsV1::YouTubeAnalyticsService.new
- 為服務設定憑證:
youtube.authorization = credentials
- 使用服務物件提供的介面向 API 服務發出要求。舉例來說,如要擷取已驗證使用者頻道的 YouTube 數據分析報表,請按照下列步驟操作:
report = youtube.query_report('channel==MINE', '2016-05-01', '2016-06-30', 'views')
或者,您也可以將 options
參數提供給方法,依方法提供每個方法的授權:
report = youtube.query_report('channel==MINE', '2016-05-01', '2016-06-30', 'views', 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 的呼叫 (例如呼叫 YouTube Analytics API 時)。
請注意,YouTube Analytics API 不支援服務帳戶流程。YouTube Reporting API 僅支援擁有及管理多個 YouTube 頻道的 YouTube 內容擁有者,例如唱片公司和電影工作室。
您可以試用所有 Google API,並前往 OAuth 2.0 Playground 查看其範圍。
HTTP GET 範例
使用 Authorization: Bearer
HTTP 標頭呼叫
reports.query
端點 (YouTube Analytics API) 時,應會如下所示。請注意,您必須指定自己的存取權杖:
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
以下是使用 access_token
查詢字串參數對已驗證使用者的呼叫相同 API:
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
curl
範例
您可以使用 curl
指令列應用程式測試這些指令。以下是使用 HTTP 標頭選項 (建議) 的範例:
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
或者,您也可以使用查詢字串參數選項:
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
完整範例
以下範例會輸出 JSON 格式的物件,在使用者授權應用程式擷取 YouTube 數據分析報表後,顯示已驗證使用者 YouTube 頻道的觀看次數資料。
PHP
要執行這個範例:
- 在 API Console中,將本機電腦的網址加入重新導向網址清單,例如加入
http://localhost:8080
。 - 建立新目錄並變更為該目錄。例如:
mkdir ~/php-oauth2-example cd ~/php-oauth2-example
- 使用 Composer 安裝 PHP 適用的 Google API 用戶端程式庫:
composer require google/apiclient:^2.10
- 使用下列內容建立
index.php
和oauth2callback.php
檔案。 - 使用設定為提供 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_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'])) { // Generate and set state value $state = bin2hex(random_bytes(16)); $client->setState($state); $_SESSION['state'] = $state; $auth_url = $client->createAuthUrl(); header('Location: ' . filter_var($auth_url, FILTER_SANITIZE_URL)); } else { // Check the state value if (!isset($_GET['state']) || $_GET['state'] !== $_SESSION['state']) { die('State mismatch. Possible CSRF attack.'); } $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/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
本範例使用 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
要執行這個範例:
-
在 API Console中,將本機電腦的網址加入重新導向網址清單,例如加入
http://localhost
。 - 請確認您已安裝維護 LTS、使用中的 LTS 或 Node.js 當前版本。
-
建立新目錄並變更為該目錄。例如:
mkdir ~/nodejs-oauth2-example cd ~/nodejs-oauth2-example
-
Install the
Google API Client
Library
for Node.js using npm:
npm install googleapis
-
建立含有以下內容的檔案
main.js
。 -
執行範例:
node .\main.js
main.js
const http = require('http'); const https = require('https'); const url = require('url'); const { google } = require('googleapis'); const crypto = require('crypto'); const express = require('express'); const session = require('express-session'); /** * 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' ]; /* 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 app = express(); app.use(session({ secret: 'your_secure_secret_key', // Replace with a strong secret resave: false, saveUninitialized: false, })); // Example on redirecting user to Google's OAuth 2.0 server. app.get('/', async (req, res) => { // Generate a secure random state value. const state = crypto.randomBytes(32).toString('hex'); // Store state in the session req.session.state = state; // 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, // Include the state parameter to reduce the risk of CSRF attacks. state: state }); res.redirect(authorizationUrl); }); // Receive the callback from Google's OAuth 2.0 server. app.get('/oauth2callback', async (req, res) => { // 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 if (q.state !== req.session.state) { //check state value console.log('State mismatch. Possible CSRF attack'); res.end('State mismatch. Possible CSRF attack'); } 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 app.get('/revoke', async (req, res) => { // 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(); }); const server = http.createServer(app); server.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/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: state = str(uuid.uuid4()) flask.session['state'] = state auth_uri = ('https://accounts.google.com/o/oauth2/v2/auth?response_type=code' '&client_id={}&redirect_uri={}&scope={}&state={}').format(CLIENT_ID, REDIRECT_URI, SCOPE, state) return flask.redirect(auth_uri) else: if 'state' not in flask.request.args or flask.request.args['state'] != flask.session['state']: return 'State mismatch. Possible CSRF attack.', 400 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()
重新導向 URI 驗證規則
Google 會套用下列驗證規則來重新導向 URI,協助開發人員確保應用程式安全無虞。重新導向 URI 必須遵守這些規則。如要瞭解下述網域、主機、路徑、查詢、配置和使用者資訊的定義,請參閱 RFC 3986 第 3 節。
驗證規則 | |
---|---|
配置 |
重新導向 URI 必須使用 HTTPS 配置,而非純文字。本機主機 URI (包括 localhost IP 位址 URI) 不受這項規則影響。 |
主機 |
主機不得為原始 IP 位址。本機主機 IP 位址則不受這項規則影響。 |
網域 |
“googleusercontent.com” 。goo.gl )。此外,如果擁有縮短網域的應用程式選擇重新導向至該網域,則重新導向 URI 的路徑中必須包含 “/google-callback/” ,或以 “/google-callback” 結尾。 |
使用者資訊 |
重新導向 URI 不得包含 userinfo 子元件。 |
路徑 |
重新導向 URI 不得包含路徑週遊 (也稱為目錄反向追蹤),該路徑以 |
查詢 |
重新導向 URI 不得含有開放式重新導向。 |
Fragment |
重新導向 URI 不得包含片段元件。 |
字元 |
重新導向 URI 不得包含某些字元,包括:
|
增量授權
在 OAuth 2.0 通訊協定中,應用程式會要求存取資源的授權,而這些資源會依據範圍識別。對使用者體驗而言,最好在需要時要求資源授權,是最佳的使用者體驗。Google 的授權伺服器支援漸進式授權,因此您可以採取這項做法。這項功能可讓您視需要要求範圍,如果使用者授予新範圍的權限,系統會傳回授權碼來交換憑證,該代碼會包含使用者已授予專案的所有範圍。
舉例來說,假設應用程式擷取 YouTube 數據分析報表,其中一些是金錢報表,需要存取其他報表不需要的範圍。在這種情況下,在登入時,應用程式可能只會要求 https://www.googleapis.com/auth/yt-analytics.readonly
範圍的存取權。不過,如果使用者嘗試擷取金錢報表,應用程式也可以要求 https://www.googleapis.com/auth/yt-analytics-monetary.readonly
範圍的存取權。
如要實作漸進式授權,請完成要求存取權杖的一般流程,但請確保授權要求包含先前授予的範圍。這種做法可讓應用程式省去管理多個存取權杖的麻煩。
下列規則適用於透過漸進式授權取得的存取權杖:
- 此權杖可用於存取匯總至新的合併授權範圍內的任何範圍資源。
- 當您使用更新權杖進行合併授權來取得存取權杖時,存取權杖代表合併的授權,並可用於回應中包含的任何
scope
值。 - 合併的授權包括使用者授予 API 專案的所有範圍,即使授權是從不同的用戶端要求也是如此。舉例來說,如果使用者透過應用程式的桌面用戶端授予某個範圍的存取權,然後透過行動用戶端將另一個範圍授予同一個應用程式,則合併的授權將包含這兩個範圍。
- 如果您撤銷代表合併授權的權杖,代表關聯使用者存取該授權的所有範圍都會同時撤銷。
我們在步驟 1:設定授權參數和步驟 2:重新導向至 Google 的 OAuth 2.0 伺服器中的範例 HTTP/REST 重新導向網址範例,全都使用漸進式授權。以下程式碼範例也顯示您必須新增以使用漸進式授權的方式。
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
在這個範例中,除了使用者已授予應用程式的其他存取權外,呼叫應用程式也會要求擷取使用者的 YouTube Analytics (分析) 資料。
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
Refreshing an access token (offline access)
Access tokens periodically expire and become invalid credentials for a related API request. You can refresh an access token without prompting the user for permission (including when the user is not present) if you requested offline access to the scopes associated with the token.
- If you use a Google API Client Library, the client object refreshes the access token as needed as long as you configure that object for offline access.
- If you are not using a client library, you need to set the
access_type
HTTP query parameter tooffline
when redirecting the user to Google's OAuth 2.0 server. In that case, Google's authorization server returns a refresh token when you exchange an authorization code for an access token. Then, if the access token expires (or at any other time), you can use a refresh token to obtain a new access token.
Requesting offline access is a requirement for any application that needs to access a Google
API when the user is not present. For example, an app that performs backup services or
executes actions at predetermined times needs to be able to refresh its access token when the
user is not present. The default style of access is called online
.
Server-side web applications, installed applications, and devices all obtain refresh tokens during the authorization process. Refresh tokens are not typically used in client-side (JavaScript) web applications.
PHP
If your application needs offline access to a Google API, set the API client's access type to
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
),其中包含下列參數:
欄位 | |
---|---|
client_id |
從 API Console取得的用戶端 ID。 |
client_secret |
從 API Console取得的用戶端密鑰。 |
grant_type |
根據 OAuth 2.0 規格所定義,這個欄位的值必須設為 refresh_token 。 |
refresh_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" }
請注意,可核發的更新權杖數量設有限制,每個用戶端/使用者組合都有一個限制;所有用戶端中每位使用者的權杖數量皆有上限。建議您將更新權杖儲存至長期儲存空間,只要這些權杖仍然有效,即可繼續使用。如果您的應用程式要求過多更新權杖,可能會超過這些限制,在這種情況下,舊的更新權杖會停止運作。
撤銷權杖
在某些情況下,使用者可能會想撤銷應用程式的存取權。使用者可以前往 帳戶設定撤銷存取權。詳情請參閱「在具有帳戶存取權的第三方網站和應用程式中移除網站或應用程式存取權」支援文件。
應用程式也可以透過程式撤銷獲得的存取權。當使用者取消訂閱、移除應用程式,或應用程式所需的 API 資源發生大幅變更時,程式輔助撤銷功能就相當重要。換句話說,移除程序的一環都可包含 API 要求,確保先前授予應用程式的權限已移除。
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
,以及錯誤代碼。