为网络服务器应用使用 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 Web 应用框架。

  pip install --upgrade flask

• requests HTTP 库。

  pip install --upgrade requests

Ruby

要运行本文档中的 Ruby 代码示例，您需要：

• Ruby 2.6 或更高版本

• 适用于 Ruby 的 Google Auth 库：

  gem install googleauth

• Sinatra Ruby Web 应用框架。

  gem install sinatra

Node.js

要运行本文档中的 Node.js 代码示例，您需要：

• Node.js 的维护 LTS、有效 LTS 或当前版本。

• Google API Node.js 客户端：

  npm install googleapis crypto express express-session

HTTP/REST

您无需安装任何库即可直接调用 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_YOUTUBE::YOUTUBE_FORCE_SSL);

// 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 文件中的信息 创建授权凭据。该对象还会标识 范围以及应用所请求权限的 auth 端点，用于处理来自 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/youtube.force-ssl'])

# 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_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/youtube.force-ssl'
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 连接会被拒绝。

PHP

1. 生成网址以向 Google 的 OAuth 2.0 服务器请求访问权限：

   $auth_url = $client->createAuthUrl();

2. 将用户重定向到 $auth_url：

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

Python

此示例展示了如何使用 Flask Web 界面将用户重定向到授权网址 应用框架：

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 步中生成的网址 authorizationUrl generateAuthUrl 方法，用于向 Google 的 OAuth 2.0 服务器请求访问权限。
2. 将用户重定向到 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 view the user's YouTube account. 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%2Fyoutube.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

创建请求网址后，将用户重定向到该网址。

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/youtube.force-ssl'],
    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 端点，并设置以下参数：

以下代码段显示了一个示例请求：

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 对象来响应此请求 令牌和刷新令牌 请注意，只有在您的应用设置了 access_type 时，系统才会返回刷新令牌。 参数添加到 offline（在向 Google 的 授权服务器。

响应包含以下字段：

以下代码段显示了一个示例响应：

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

PHP

完成以下步骤，使用访问令牌来调用 Google API：

1. 如果您需要将访问令牌应用于新的 Google\Client 对象，请执行以下操作： 例如，如果您将访问令牌存储在用户会话中，请使用 setAccessToken 方法：

   $client->setAccessToken($access_token);

2. 为要调用的 API 构建服务对象。你可以通过以下方式构建服务对象： 将已获授权的 Google\Client 对象提供给您 API 的构造函数 。 例如，如需调用 YouTube Data API，请使用以下代码：

   $youtube = new Google_Service_YouTube($client);

3. 使用 该服务对象提供的接口。 例如，要检索有关已获授权用户的 YouTube 频道的数据，请使用以下代码：

   $channel = $youtube->channels->listChannels('snippet', array('mine' => $mine));

Python

获得访问令牌后，您的应用程序就可以使用该令牌对 上的 API 请求进行授权， 代表指定的用户账号或服务账号。使用特定于用户的授权凭据 为要调用的 API 构建一个服务对象，然后使用该对象 授权的 API 请求。

1. 为要调用的 API 构建服务对象。你可以通过以下方式构建服务对象： 调用 googleapiclient.discovery 库的 build 方法 API 的名称和版本以及用户凭据： 例如，如需调用 YouTube Data API 版本 3：

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

2. 使用 该服务对象提供的接口。 例如，要检索有关已获授权用户的 YouTube 频道的数据，请使用以下代码：

   channel = youtube.channels().list(mine=True, part='snippet').execute()

Ruby

获得访问令牌后，您的应用程序就可以使用该令牌在 代表指定的用户账号或服务账号。使用特定于用户的授权凭据 为要调用的 API 构建一个服务对象，然后使用该对象 授权的 API 请求。

1. 为要调用的 API 构建服务对象。 例如，如需调用 YouTube Data API 版本 3：

   youtube = Google::Apis::YoutubeV3::YouTubeService.new

2. 设置服务的凭据：

   youtube.authorization = credentials

3. 使用 接口 提供的对象。 例如，要检索有关已获授权用户的 YouTube 频道的数据，请使用以下代码：

   channel = youtube.list_channels(part, :mine => mine)

或者，也可以按方法提供授权，方法为提供 options 参数：

channel = youtube.list_channels(part, :mine => mine, 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

在您的应用获得访问令牌后，您就可以使用该令牌调用 Google 代表指定的 用户账号（如果已授予 API 所需的访问权限范围）。为此，请添加 通过添加 access_token 查询来获取对 API 的请求中的访问令牌 参数或 Authorization HTTP 标头 Bearer 值。如有可能， 最好使用 HTTP 标头，因为查询字符串通常显示在服务器日志中。大多数 可以使用客户端库来设置对 Google API 的调用（例如， 调用 YouTube Data API）。

请注意，YouTube Data API 仅支持 YouTube 服务账号 拥有和管理多个 YouTube 频道的内容所有者，例如 唱片公司和电影制片厂

您可以访问以下网址，试用所有 Google API 并查看其作用域： OAuth 2.0 Playground。

HTTP GET 示例

对 youtube.channels 端点（YouTube Data API），并使用 Authorization: Bearer HTTP 可能如下所示。请注意，您需要指定自己的访问令牌：

GET /youtube/v3/channels?part=snippet&mine=true HTTP/1.1
Host: www.googleapis.com
Authorization: Bearer access_token

以下是使用 access_token 为经过身份验证的用户对同一 API 的调用 查询字符串参数：

GET https://www.googleapis.com/youtube/v3/channels?access_token=access_token&part=snippet&mine=true

curl 示例

您可以使用 curl 命令行应用测试这些命令。这里有 使用 HTTP 标头选项的示例（首选）：

curl -H "Authorization: Bearer access_token" https://www.googleapis.com/youtube/v3/channels?part=snippet&mine=true

或者，也可以使用查询字符串参数选项：

curl https://www.googleapis.com/youtube/v3/channels?access_token=access_token&part=snippet&mine=true

PHP

如需运行此示例，请执行以下操作：

1. 在 API Console中，将本地机器的网址添加到 重定向网址列表。例如，添加 http://localhost:8080。
2. 创建一个新目录并切换到该目录。例如：

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

3. 安装 Google API 客户端 使用 Composer 的 PHP 库：

   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_YOUTUBE::YOUTUBE_FORCE_SSL);

if (isset($_SESSION['access_token']) && $_SESSION['access_token']) {
  $client->setAccessToken($_SESSION['access_token']);
  $youtube = new Google_Service_YouTube($client);
  $channel = $youtube->channels->listChannels('snippet', array('mine' => $mine));
  echo json_encode($channel);
} 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_YOUTUBE::YOUTUBE_FORCE_SSL);

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 中运行一个 Web 应用，该应用可让您测试 OAuth 2.0 。如果您访问该网址，应该会看到四个链接：

• 测试 API 请求：此链接指向尝试执行示例 API 的页面 请求。如有必要，它会启动授权流程。如果成功，页面会显示 API 响应。
• 直接测试身份验证流程：此链接指向尝试 授权流程。应用请求以下权限： 代表用户提交经过授权的 API 请求。
• 撤消当前凭据：此链接指向的网页 撤消用户已授予应用的权限。
• Clear Flask session credentials（清除 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/youtube.force-ssl']
API_SERVICE_NAME = 'youtube'
API_VERSION = 'v3'

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)

  channel = youtube.channels().list(mine=True, part='snippet').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(**channel)


@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_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
  youtube = Google::Apis::YoutubeV3::YouTubeService.new
  channel = youtube.list_channels(part, :mine => mine, options: { authorization: auth_client })
  
  "<pre>#{JSON.pretty_generate(channel.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. 确保您拥有 已安装 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');
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 Web 流程。对于此流程，我们建议使用 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/youtube.force-ssl'
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/v3/channels/list'
    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()

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 数据分析数据，以及用户执行的任何其他访问权限 已授予该应用的权限。

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

      

PHP

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

$client->setAccessType("offline");

在用户授予对请求范围的离线访问权限后，您可以继续使用 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`
});

客户端拥有刷新令牌后，系统会自动获取并刷新访问令牌 就会出现这种错误

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

token 参数可以是访问令牌或刷新令牌。如果该令牌是访问令牌，且该令牌具有 相应的刷新令牌，该刷新令牌也会被撤消。

如果成功处理了吊销，则响应的状态代码为 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 以及错误代码。