ウェブサーバー アプリケーションに OAuth 2.0 を使用する

PHP

このドキュメントの PHP コードサンプルを実行するには、次のものが必要です。

• PHP 5.6 以降（コマンドライン インターフェース（CLI）と JSON 拡張機能がインストール済み）
• Composer 依存関係管理ツール。

• PHP の Google API クライアント ライブラリ:

  composer require google/apiclient:^2.10

Python

このドキュメントの Python コードサンプルを実行するには、次のものが必要です。

• Python 2.6 以降
• pip パッケージ管理ツール。
• Python 用の Google API クライアント ライブラリ:

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

• google-auth、google-auth-oauthlib、 google-auth-httplib2（ユーザー承認用）。

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

• Flask Python ウェブ アプリケーション フレームワーク。

  pip install --upgrade flask

• requests HTTP ライブラリ。

  pip install --upgrade requests

Ruby

このドキュメントの Ruby コードサンプルを実行するには、次のものが必要です。

• Ruby 2.6 以降

• Ruby 用 Google 認証ライブラリ:

  gem install googleauth

• Sinatra Ruby ウェブ アプリケーション フレームワーク。

  gem install sinatra

Node.js

このドキュメントの Node.js コードサンプルを実行するには、次のものが必要です。

• メンテナンスの LTS、アクティブな LTS、または Node.js の現在のリリース。

• Google API Node.js クライアント:

  npm install googleapis crypto express express-session

HTTP/REST

ライブラリをインストールしなくても、OAuth 2.0 を直接呼び出すことができます 提供します

PHP

以下のコード スニペットでは、Google\Client() オブジェクトを作成します。このオブジェクトは、 パラメータを指定します。

このオブジェクトは、client_secret.json ファイルの情報を使用してクライアントを識別します。 説明します。（詳細については、認証情報の作成をご覧ください）。 表示されます）。このオブジェクトは、アプリが権限をリクエストしているスコープも特定します。 アプリケーションの認証エンドポイントへの URL を指定します。このエンドポイントは、 Google の OAuth 2.0 サーバーです。最後に、オプションの access_type と include_granted_scopes パラメータ。

たとえば、このコードはユーザーの IP アドレスへの読み取り専用のオフライン アクセスを Google ドライブ:

$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\Drive::DRIVE_METADATA_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 ファイル内の情報について、 認証情報の作成。また、このオブジェクトは スコープと、アプリケーションの URL が関連付けられています。 認証エンドポイントを指定します。最後に、 オプションの access_type パラメータと include_granted_scopes パラメータを設定します。

たとえば、このコードはユーザーの IP アドレスへの読み取り専用のオフライン アクセスを Google ドライブ:

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/drive.metadata.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 ファイルを使用して、 説明します。クライアント オブジェクトを構成するときに、アプリケーションに必要なスコープを指定します。 レスポンスを処理するアプリケーションの認証エンドポイントへの URL とともに、 OAuth 2.0 サーバーから返されます。

たとえば、このコードはユーザーの IP アドレスへの読み取り専用のオフライン アクセスを Google ドライブ:

require 'google/apis/drive_v3'
require "googleauth"
require 'googleauth/stores/redis_token_store'

client_id = Google::Auth::ClientId.from_file('/path/to/client_secret.json')
scope = 'https://www.googleapis.com/auth/drive.metadata.readonly'
token_store = Google::Auth::Stores::RedisTokenStore.new(redis: Redis.new)
authorizer = Google::Auth::WebUserAuthorizer.new(client_id, scope, token_store, '/oauth2callback')

アプリケーションはこのクライアント オブジェクトを使用して、OAuth 2.0 のオペレーションを実行します。たとえば、 認証リクエスト URL へのアクセスと、HTTP リクエストへのアクセス トークンの適用について説明します。

Node.js

次のコード スニペットは、google.auth.OAuth2 オブジェクトを作成します。このオブジェクトは、 パラメータを指定します。

このオブジェクトは、client_secret.json ファイルからの情報を使用してアプリケーションを識別します。宛先 アクセス トークンを取得するためにユーザーに権限をリクエストする場合は、同意ページにリダイレクトします。 同意ページの 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
 * 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 サーバーからアクセスをリクエストするための URL を生成します。

   $auth_url = $client->createAuthUrl();

2. ユーザーを $auth_url にリダイレクトします。

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

Python

この例では、Flask ウェブを使用して認証 URL にユーザーをリダイレクトする方法を示します。 アプリケーション フレームワーク:

return flask.redirect(authorization_url)

Ruby

1. Google の OAuth 2.0 サーバーからアクセスをリクエストするための URL を生成します。

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

2. ユーザーを auth_uri にリダイレクトします。

Node.js

1. ステップ 1 で生成された URL authorizationUrl を使用します。 generateAuthUrl メソッドを使用して Google の OAuth 2.0 サーバーからアクセスをリクエストします。
2. ユーザーを authorizationUrl にリダイレクトします。

   res.redirect(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

リクエスト URL を作成したら、ユーザーをその URL にリダイレクトします。

PHP

認証コードをアクセス トークンと交換するには、authenticate を使用します。 メソッド:

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

アクセス トークンは、getAccessToken メソッドを使用して取得できます。

$access_token = $client->getAccessToken();

Python

コールバック ページで、google-auth ライブラリを使用して承認を確認します。 サーバーが応答します。次に、flow.fetch_token メソッドを使用して承認を交換します。 アクセス トークンのレスポンスには、次のコードが記述されています。

state = flask.session['state']
flow = google_auth_oauthlib.flow.Flow.from_client_secrets_file(
    'client_secret.json',
    scopes=['https://www.googleapis.com/auth/drive.metadata.readonly'],
    state=state)
flow.redirect_uri = flask.url_for('oauth2callback', _external=True)

authorization_response = flask.request.url
flow.fetch_token(authorization_response=authorization_response)

# Store the credentials in the session.
# ACTION ITEM for developers:
#     Store user's access and refresh tokens in your data store if
#     incorporating this code into your real app.
credentials = flow.credentials
flask.session['credentials'] = {
    'token': credentials.token,
    'refresh_token': credentials.refresh_token,
    'token_uri': credentials.token_uri,
    'client_id': credentials.client_id,
    'client_secret': credentials.client_secret,
    'scopes': credentials.scopes}

Ruby

コールバック ページで、googleauth ライブラリを使用して認可サーバーを検証する レスポンスが返されます。authorizer.handle_auth_callback_deferred メソッドを使用して、 認証コードを作成し、最初に認証をリクエストした URL にリダイレクトします。この ユーザーのセッションに結果を一時的に保管することで、コードの交換を先延ばしにします。

  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 オブジェクトを返します。 更新トークンの 2 つです 更新トークンは、アプリケーションで access_type が設定されている場合にのみ返されます。 パラメータを offline に指定（ 認可サーバーを構成します。

レスポンスには、次のフィールドが含まれます。

次のスニペットは、レスポンスの例を示しています。

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

PHP

次の手順で、アクセス トークンを使用して Google API を呼び出します。

1. 新しい Google\Client オブジェクトにアクセス トークンを適用する必要がある場合、 たとえば、アクセス トークンをユーザー セッションに保存した場合は、 setAccessToken メソッド:

   $client->setAccessToken($access_token);

2. 呼び出す API のサービス オブジェクトを作成します。サービス オブジェクトを作成するには、 承認済みの Google\Client オブジェクトを API のコンストラクタに提供します。 選択します。 たとえば、Drive API を呼び出すには次のようにします。

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

3. API サービスにリクエストを送信するには、 インターフェースを提供します。 たとえば、認証済みユーザーの Google ドライブ内のファイルを一覧表示するには、次のようにします。

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

Python

アクセス トークンを取得したら、アプリケーションはそのトークンを使用して、 ロールを委任できます。ユーザー固有の認証情報を使用する 呼び出す API のサービス オブジェクトを作成し、そのオブジェクトを使用して リクエストの数を減らします。

1. 呼び出す API のサービス オブジェクトを作成します。サービス オブジェクトを作成するには、 googleapiclient.discovery ライブラリの build メソッドを、 API の名前とバージョン、ユーザー認証情報。 たとえば、Drive API のバージョン 3 を呼び出すには、次のようにします。

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

2. API サービスにリクエストを送信するには、 インターフェースを提供します。 たとえば、認証済みユーザーの Google ドライブ内のファイルを一覧表示するには、次のようにします。

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

Ruby

アクセス トークンを取得したら、アプリケーションはそのトークンを使用して、API リクエストを ロールを委任できます。ユーザー固有の認証情報を使用する 呼び出す API のサービス オブジェクトを作成し、そのオブジェクトを使用して リクエストの数を減らします。

1. 呼び出す API のサービス オブジェクトを作成します。 たとえば、Drive API のバージョン 3 を呼び出すには、次のようにします。

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

2. サービスの認証情報を設定します。

   drive.authorization = credentials

3. API サービスにリクエストを送信するには、 インターフェース サービス オブジェクトによって指定されます。 たとえば、認証済みユーザーの Google ドライブ内のファイルを一覧表示するには、次のようにします。

   files = drive.list_files

または、API に メソッドに options パラメータを追加します。

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

Node.js

アクセス トークンを取得して OAuth2 オブジェクトに設定し、そのオブジェクトを使用します。 Google API を呼び出すことができますアプリケーションはこのトークンを使用して、ユーザーの代わりに API リクエストを承認できます。 サービス アカウントに対する権限を付与できます。呼び出す API のサービス オブジェクトを作成します。

const { google } = require('googleapis');

// Example of using Google Drive API to list filenames in user's Drive.
const drive = google.drive('v3');
drive.files.list({
  auth: oauth2Client,
  pageSize: 10,
  fields: 'nextPageToken, files(id, name)',
}, (err1, res1) => {
  if (err1) return console.log('The API returned an error: ' + err1);
  const files = res1.data.files;
  if (files.length) {
    console.log('Files:');
    files.map((file) => {
      console.log(`${file.name} (${file.id})`);
    });
  } else {
    console.log('No files found.');
  }
});

HTTP/REST

アプリケーションがアクセス トークンを取得したら、そのトークンを使用して Google Cloud API を呼び出すことができます。 API の代理操作です。 ユーザー アカウント（API に必要なアクセス スコープが付与されている場合）そのためには API へのリクエストのアクセス トークン（access_token クエリまたは パラメータまたは Authorization HTTP ヘッダー Bearer 値を指定します。可能であれば クエリ文字列はサーバーログに表示される傾向があるため、HTTP ヘッダーの使用をおすすめします。ほとんどの クライアント ライブラリを使用して Google API の呼び出しを設定できます（例: Drive Files API の呼び出しを参照）。

すべての Google API を試して、 OAuth 2.0 Playground。

HTTP GET の例

呼び出しは、 drive.files エンドポイント（Drive Files API）Authorization: Bearer HTTP を使用 次のようになります。独自のアクセス トークンを指定する必要があります。

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で、ローカルマシンの URL を リダイレクト URL のリスト。たとえば、http://localhost:8080 を追加します。
2. 新しいディレクトリを作成し、そのディレクトリに移動します。次に例を示します。

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

3. Google API クライアントを ライブラリ（Composer を使用）:

   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'])) {
  // 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 フレームワークを使用します。これは、 OAuth 2.0 をテストできるウェブ アプリケーションを http://localhost:8080 で実行します。 できます。この URL にアクセスすると、次の 4 つのリンクが表示されます。

• API リクエストをテストする: このリンクは、サンプル API の実行を試みるページへのリンクです。 リクエストできます。必要に応じて認可フローを開始します。成功すると、ページに API レスポンス。
• 認証フローを直接テストする: このリンクをクリックすると、ユーザーの 認可フローで確認します。アプリが次の操作を行う権限をリクエストしています。 ユーザーの代わりに承認済みの API リクエストを送信できます。
• 現在の認証情報を取り消す: このリンクをクリックすると、 ユーザーがアプリケーションにすでに付与している権限を取り消します。
• Flask セッション認証情報の消去: 次のリンクをクリックすると、 Flask セッションに保存されますこれにより、ログインしたことのあるユーザーが アプリに権限が付与されたアプリが新しいセッションで API リクエストを実行しようとしました。また、 付与されている権限をユーザーが取り消した場合にアプリが受け取る API レスポンスを確認できます。 アクセス トークンが取り消されたリクエストも承認しようとしました。

# -*- coding: utf-8 -*-

import os
import flask
import requests

import google.oauth2.credentials
import google_auth_oauthlib.flow
import googleapiclient.discovery

# This variable specifies the name of a file that contains the OAuth 2.0
# information for this application, including its client_id and client_secret.
CLIENT_SECRETS_FILE = "client_secret.json"

# This OAuth 2.0 access scope allows for full read/write access to the
# authenticated user's account and requires requests to use an SSL connection.
SCOPES = ['https://www.googleapis.com/auth/drive.metadata.readonly']
API_SERVICE_NAME = 'drive'
API_VERSION = 'v2'

app = flask.Flask(__name__)
# Note: A secret key is included in the sample so that it works.
# If you use this code in your application, replace this with a truly secret
# key. See https://flask.palletsprojects.com/quickstart/#sessions.
app.secret_key = 'REPLACE ME - this value is here as a placeholder.'


@app.route('/')
def index():
  return print_index_table()


@app.route('/test')
def test_api_request():
  if 'credentials' not in flask.session:
    return flask.redirect('authorize')

  # Load credentials from the session.
  credentials = google.oauth2.credentials.Credentials(
      **flask.session['credentials'])

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

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

  # Save credentials back to session in case access token was refreshed.
  # ACTION ITEM: In a production app, you likely want to save these
  #              credentials in a persistent database instead.
  flask.session['credentials'] = credentials_to_dict(credentials)

  return flask.jsonify(**files)


@app.route('/authorize')
def authorize():
  # Create flow instance to manage the OAuth 2.0 Authorization Grant Flow steps.
  flow = google_auth_oauthlib.flow.Flow.from_client_secrets_file(
      CLIENT_SECRETS_FILE, scopes=SCOPES)

  # The URI created here must exactly match one of the authorized redirect URIs
  # for the OAuth 2.0 client, which you configured in the API Console. If this
  # value doesn't match an authorized URI, you will get a 'redirect_uri_mismatch'
  # error.
  flow.redirect_uri = flask.url_for('oauth2callback', _external=True)

  authorization_url, state = flow.authorization_url(
      # Enable offline access so that you can refresh an access token without
      # re-prompting the user for permission. Recommended for web server apps.
      access_type='offline',
      # Enable incremental authorization. Recommended as a best practice.
      include_granted_scopes='true')

  # Store the state so the callback can verify the auth server response.
  flask.session['state'] = state

  return flask.redirect(authorization_url)


@app.route('/oauth2callback')
def oauth2callback():
  # Specify the state when creating the flow in the callback so that it can
  # verified in the authorization server response.
  state = flask.session['state']

  flow = google_auth_oauthlib.flow.Flow.from_client_secrets_file(
      CLIENT_SECRETS_FILE, scopes=SCOPES, state=state)
  flow.redirect_uri = flask.url_for('oauth2callback', _external=True)

  # Use the authorization server's response to fetch the OAuth 2.0 tokens.
  authorization_response = flask.request.url
  flow.fetch_token(authorization_response=authorization_response)

  # Store credentials in the session.
  # ACTION ITEM: In a production app, you likely want to save these
  #              credentials in a persistent database instead.
  credentials = flow.credentials
  flask.session['credentials'] = credentials_to_dict(credentials)

  return flask.redirect(flask.url_for('test_api_request'))


@app.route('/revoke')
def revoke():
  if 'credentials' not in flask.session:
    return ('You need to <a href="/authorize">authorize</a> before ' +
            'testing the code to revoke credentials.')

  credentials = google.oauth2.credentials.Credentials(
    **flask.session['credentials'])

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

  status_code = getattr(revoke, 'status_code')
  if status_code == 200:
    return('Credentials successfully revoked.' + print_index_table())
  else:
    return('An error occurred.' + print_index_table())


@app.route('/clear')
def clear_credentials():
  if 'credentials' in flask.session:
    del flask.session['credentials']
  return ('Credentials have been cleared.<br><br>' +
          print_index_table())


def credentials_to_dict(credentials):
  return {'token': credentials.token,
          'refresh_token': credentials.refresh_token,
          'token_uri': credentials.token_uri,
          'client_id': credentials.client_id,
          'client_secret': credentials.client_secret,
          'scopes': credentials.scopes}

def print_index_table():
  return ('<table>' +
          '<tr><td><a href="/test">Test an API request</a></td>' +
          '<td>Submit an API request and see a formatted JSON response. ' +
          '    Go through the authorization flow if there are no stored ' +
          '    credentials for the user.</td></tr>' +
          '<tr><td><a href="/authorize">Test the auth flow directly</a></td>' +
          '<td>Go directly to the authorization flow. If there are stored ' +
          '    credentials, you still might not be prompted to reauthorize ' +
          '    the application.</td></tr>' +
          '<tr><td><a href="/revoke">Revoke current credentials</a></td>' +
          '<td>Revoke the access token associated with the current user ' +
          '    session. After revoking credentials, if you go to the test ' +
          '    page, you should see an <code>invalid_grant</code> error.' +
          '</td></tr>' +
          '<tr><td><a href="/clear">Clear Flask session credentials</a></td>' +
          '<td>Clear the access token currently stored in the user session. ' +
          '    After clearing the token, if you <a href="/test">test the ' +
          '    API request</a> again, you should go back to the auth flow.' +
          '</td></tr></table>')


if __name__ == '__main__':
  # When running locally, disable OAuthlib's HTTPs verification.
  # ACTION ITEM for developers:
  #     When running in production *do not* leave this option enabled.
  os.environ['OAUTHLIB_INSECURE_TRANSPORT'] = '1'

  # Specify a hostname and port that are set as a valid redirect URI
  # for your API project in the Google API Console.
  app.run('localhost', 8080, debug=True)

Ruby

この例では、Sinatra フレームワークを使用します。

require 'google/apis/drive_v3'
require 'sinatra'
require 'googleauth'
require 'googleauth/stores/redis_token_store'

configure do
  enable :sessions

  set :client_id, Google::Auth::ClientId.from_file('/path/to/client_secret.json')
  set :scope, Google::Apis::DriveV3::AUTH_DRIVE_METADATA_READONLY
  set :token_store, Google::Auth::Stores::RedisTokenStore.new(redis: Redis.new)
  set :authorizer, Google::Auth::WebUserAuthorizer.new(settings.client_id, settings.scope, settings.token_store, '/oauth2callback')
end

get '/' do
  user_id = settings.client_id.id
  credentials = settings.authorizer.get_credentials(user_id, request)
  if credentials.nil?
    redirect settings.authorizer.get_authorization_url(login_hint: user_id, request: request)
  end
  drive = Google::Apis::DriveV3::DriveService.new
  files = drive.list_files(options: { authorization: credentials })
  "<pre>#{JSON.pretty_generate(files.to_h)}</pre>"
end

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

Node.js

この例を実行するには:

1. API Consoleに、デバイスの URL を リダイレクト URL のリストに追加します。たとえば、 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');
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 と 2.0 ウェブフロー。このフローでは、Python 用 Google API クライアント ライブラリを使用することをおすすめします。（ クライアント ライブラリを使用しています）。

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:
    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

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"
}

発行される更新トークンの数には上限があります。1 個につき 1 回 全クライアントでユーザーごとに 1 つずつ 異なる組み合わせで作成できます更新トークンを保存する必要がある 保持され、有効な間は継続して使用できます。アプリケーションで リクエストが多すぎると、これらの上限に達する可能性があります。その場合、古い更新トークン 動作しなくなります。

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 リクエストを送信します。 endpoint:

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 リクエストを行います。 endpoint:

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 が返されます。 エラーコードが表示されます