Menggunakan OAuth 2.0 untuk Aplikasi Server Web

PHP

Untuk menjalankan contoh kode PHP dalam dokumen ini, Anda akan membutuhkan:

• PHP 5.6 atau yang lebih baru dengan antarmuka command line (CLI) dan ekstensi JSON yang diinstal.
• Alat pengelolaan dependensi Composer.

• Library Klien Google API untuk PHP:

  composer require google/apiclient:^2.10

Python

Untuk menjalankan contoh kode Python dalam dokumen ini, Anda akan membutuhkan:

• Python 2.6 atau yang lebih baru
• Alat pengelolaan paket pip.
• Library Klien Google API untuk Python:

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

• google-auth, google-auth-oauthlib, dan google-auth-httplib2 untuk otorisasi pengguna.

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

• Framework aplikasi web Flask Python.

  pip install --upgrade flask

• Library HTTP requests.

  pip install --upgrade requests

Ruby

Untuk menjalankan contoh kode Ruby dalam dokumen ini, Anda akan membutuhkan:

• Ruby 2.6 atau yang lebih baru

• Library Google Auth untuk Ruby:

  gem install googleauth

• Framework aplikasi web Sinatra Ruby.

  gem install sinatra

Node.js

Untuk menjalankan contoh kode Node.js dalam dokumen ini, Anda memerlukan:

• LTS pemeliharaan, LTS aktif, atau rilis Node.js saat ini.

• Klien Node.js Google API:

  npm install googleapis

HTTP/REST

Anda tidak perlu menginstal library apa pun agar dapat langsung memanggil endpoint OAuth 2.0.

PHP

Cuplikan kode di bawah membuat objek Google\Client(), yang menentukan parameter dalam permintaan otorisasi.

Objek tersebut menggunakan informasi dari file client_secret.json Anda untuk mengidentifikasi aplikasi Anda. (Lihat membuat kredensial otorisasi untuk informasi selengkapnya tentang file tersebut.) Objek ini juga mengidentifikasi cakupan yang diminta oleh aplikasi Anda untuk diakses dan URL ke endpoint autentikasi aplikasi Anda, yang akan menangani respons dari server OAuth 2.0 Google. Terakhir, kode ini menetapkan parameter access_type dan include_granted_scopes opsional.

Misalnya, kode berikut meminta akses hanya baca dan offline ke Google Drive pengguna:

$client = new Google\Client();
$client->setAuthConfig('client_secret.json');
$client->addScope(Google\Service\Drive::DRIVE_METADATA_READONLY);
$client->setRedirectUri('http://' . $_SERVER['HTTP_HOST'] . '/oauth2callback.php');
// offline access will give you both an access and refresh token so that
// your app can refresh the access token without user interaction.
$client->setAccessType('offline');
// Using "consent" will prompt the user for consent
$client->setPrompt('consent');
$client->setIncludeGrantedScopes(true);   // incremental auth

Permintaan tersebut menetapkan informasi berikut:

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

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

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

$client->setAccessType('offline');

$client->setState($sample_passthrough_value);

$client->setIncludeGrantedScopes(true);

$client->setLoginHint('None');

$client->setPrompt('consent');

Python

Cuplikan kode berikut menggunakan modul google-auth-oauthlib.flow untuk membuat permintaan otorisasi.

Kode tersebut membuat objek Flow, yang mengidentifikasi aplikasi Anda menggunakan informasi dari file client_secret.json yang Anda download setelah membuat kredensial otorisasi. Objek tersebut juga mengidentifikasi cakupan yang diminta untuk diakses oleh aplikasi Anda, dan URL ke endpoint autentikasi aplikasi Anda, yang akan menangani respons dari server OAuth 2.0 Google. Terakhir, kode ini menetapkan parameter access_type dan include_granted_scopes opsional.

Misalnya, kode berikut meminta akses hanya baca dan offline ke Google Drive pengguna:

import google.oauth2.credentials
import google_auth_oauthlib.flow

# Use the client_secret.json file to identify the application requesting
# authorization. The client ID (from that file) and access scopes are required.
flow = google_auth_oauthlib.flow.Flow.from_client_secrets_file(
    'client_secret.json',
    scopes=['https://www.googleapis.com/auth/drive.metadata.readonly'])

# Indicate where the API server will redirect the user after the user completes
# the authorization flow. The redirect URI is required. The value must exactly
# match one of the authorized redirect URIs for the OAuth 2.0 client, which you
# configured in the API Console. If this value doesn't match an authorized URI,
# you will get a 'redirect_uri_mismatch' error.
flow.redirect_uri = 'https://www.example.com/oauth2callback'

# Generate URL for request to Google's OAuth 2.0 server.
# Use kwargs to set optional request parameters.
authorization_url, state = flow.authorization_url(
    # Enable offline access so that you can refresh an access token without
    # re-prompting the user for permission. Recommended for web server apps.
    access_type='offline',
    # Enable incremental authorization. Recommended as a best practice.
    include_granted_scopes='true')

Permintaan tersebut menetapkan informasi berikut:

flow = google_auth_oauthlib.flow.Flow.from_client_secrets_file(
    'client_secret.json',
    scopes=['https://www.googleapis.com/auth/drive.metadata.readonly'])

flow.redirect_uri = 'https://oauth2.example.com/code'

flow = google_auth_oauthlib.flow.Flow.from_client_secrets_file(
    'client_secret.json',
    scopes=['https://www.googleapis.com/auth/drive.metadata.readonly'])

authorization_url, state = flow.authorization_url(
    access_type='offline',
    include_granted_scopes='true')

authorization_url, state = flow.authorization_url(
    access_type='offline',
    state=sample_passthrough_value,
    include_granted_scopes='true')

authorization_url, state = flow.authorization_url(
    access_type='offline',
    include_granted_scopes='true')

authorization_url, state = flow.authorization_url(
    access_type='offline',
    login_hint='None',
    include_granted_scopes='true')

authorization_url, state = flow.authorization_url(
      access_type='offline',
      prompt='consent',
      include_granted_scopes='true')

Ruby

Gunakan file client_secrets.json yang Anda buat untuk mengonfigurasi objek klien di aplikasi Anda. Saat mengonfigurasi objek klien, tentukan cakupan yang perlu diakses aplikasi Anda, beserta URL ke endpoint autentikasi aplikasi Anda, yang akan menangani respons dari server OAuth 2.0.

Misalnya, kode berikut meminta akses hanya baca dan offline ke Google Drive pengguna:

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

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

Your application uses the client object to perform OAuth 2.0 operations, such as generating
  authorization request URLs and applying access tokens to HTTP requests.

      

Node.js

The code snippet below creates a google.auth.OAuth2 object, which defines the parameters in the authorization request.

That object uses information from your client_secret.json file to identify your application. To ask for permissions from a user to retrieve an access token, you redirect them to a consent page. To create a consent page URL:

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

/**
 * To use OAuth2 authentication, we need access to a CLIENT_ID, CLIENT_SECRET, AND REDIRECT_URI
 * from the client_secret.json file. To get these credentials for your application, visit
 * https://console.cloud.google.com/apis/credentials.
 */
const oauth2Client = new google.auth.OAuth2(
  YOUR_CLIENT_ID,
  YOUR_CLIENT_SECRET,
  YOUR_REDIRECT_URL
);

// Access scopes for read-only Drive activity.
const scopes = [
  'https://www.googleapis.com/auth/drive.metadata.readonly'
];

// Generate a url that asks permissions for the Drive activity scope
const authorizationUrl = oauth2Client.generateAuthUrl({
  // 'online' (default) or 'offline' (gets refresh_token)
  access_type: 'offline',
  /** Pass in the scopes array defined above.
    * Alternatively, if only one scope is needed, you can pass a scope URL as a string */
  scope: scopes,
  // Enable incremental authorization. Recommended as a best practice.
  include_granted_scopes: true
});

Catatan Penting - refresh_token hanya ditampilkan pada otorisasi pertama. Lihat detail selengkapnya di sini.

HTTP/REST

Endpoint OAuth 2.0 Google ada di https://accounts.google.com/o/oauth2/v2/auth. Endpoint ini hanya dapat diakses melalui HTTPS. Koneksi HTTP biasa ditolak.

Server otorisasi Google mendukung parameter string kueri berikut untuk aplikasi server web:

PHP

1. Buat URL untuk meminta akses dari server OAuth 2.0 Google:

   $auth_url = $client->createAuthUrl();

2. Alihkan pengguna ke $auth_url:

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

Python

Contoh ini menunjukkan cara mengalihkan pengguna ke URL otorisasi menggunakan framework aplikasi web Flask:

return flask.redirect(authorization_url)

Ruby

1. Buat URL untuk meminta akses dari server OAuth 2.0 Google:

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

2. Alihkan pengguna ke auth_uri.

Node.js

1. Gunakan URL yang dihasilkan authorizationUrl dari metode generateAuthUrl Langkah 1 untuk meminta akses dari server OAuth 2.0 Google.
2. Alihkan pengguna ke authorizationUrl.

   res.writeHead(301, { "Location": authorizationUrl });

HTTP/REST

Sample redirect to Google's authorization server

An example URL is shown below, with line breaks and spaces for readability.

https://accounts.google.com/o/oauth2/v2/auth?
 scope=https%3A//www.googleapis.com/auth/drive.metadata.readonly&
 access_type=offline&
 include_granted_scopes=true&
 response_type=code&
 state=state_parameter_passthrough_value&
 redirect_uri=https%3A//oauth2.example.com/code&
 client_id=client_id

Setelah Anda membuat URL permintaan, alihkan pengguna ke URL tersebut.

PHP

Untuk menukar kode otorisasi dengan token akses, gunakan metode authenticate:

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

Anda dapat mengambil token akses dengan metode getAccessToken:

$access_token = $client->getAccessToken();

Python

Di halaman callback Anda, gunakan library google-auth untuk memverifikasi respons server otorisasi. Kemudian, gunakan metode flow.fetch_token untuk menukar kode otorisasi dalam respons tersebut dengan token akses:

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

Di halaman callback Anda, gunakan library googleauth untuk memverifikasi respons server otorisasi. Gunakan metode authorizer.handle_auth_callback_deferred untuk menyimpan kode otorisasi dan mengalihkan kembali ke URL yang awalnya meminta otorisasi. Tindakan ini menunda pertukaran kode dengan menyembunyikan hasilnya untuk sementara dalam sesi pengguna.

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

Node.js

Untuk menukar kode otorisasi dengan token akses, gunakan metode getToken:

const url = require('url');

// Receive the callback from Google's OAuth 2.0 server.
if (req.url.startsWith('/oauth2callback')) {
  // Handle the OAuth 2.0 server response
  let q = url.parse(req.url, true).query;

  // Get access and refresh tokens (if access_type is offline)
  let { tokens } = await oauth2Client.getToken(q.code);
  oauth2Client.setCredentials(tokens);
}

HTTP/REST

Untuk menukar kode otorisasi dengan token akses, panggil endpoint https://oauth2.googleapis.com/token dan tetapkan parameter berikut:

Cuplikan berikut menunjukkan contoh permintaan:

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 merespons permintaan ini dengan menampilkan objek JSON yang berisi token akses berumur pendek dan token refresh. Perhatikan bahwa token refresh hanya ditampilkan jika aplikasi Anda menetapkan parameter access_type ke offline dalam permintaan awal ke server otorisasi Google.

Respons berisi kolom berikut:

Cuplikan berikut menunjukkan contoh respons:

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

Gunakan token akses untuk memanggil Google API dengan menyelesaikan langkah-langkah berikut:

1. Jika Anda perlu menerapkan token akses ke objek Google\Client baru, misalnya jika Anda menyimpan token akses dalam sesi pengguna, gunakan metode setAccessToken:

   $client->setAccessToken($access_token);

2. Buat objek layanan untuk API yang ingin Anda panggil. Anda membuat objek layanan dengan memberikan objek Google\Client yang diotorisasi ke konstruktor untuk API yang ingin Anda panggil. Misalnya, untuk memanggil Drive API:

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

3. Buat permintaan ke layanan API menggunakan antarmuka yang disediakan oleh objek layanan. Misalnya, untuk menampilkan daftar file dalam Google Drive pengguna yang diautentikasi:

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

Python

Setelah mendapatkan token akses, aplikasi Anda dapat menggunakan token tersebut untuk mengizinkan permintaan API atas nama akun pengguna atau akun layanan tertentu. Gunakan kredensial otorisasi spesifik per pengguna untuk membuat objek layanan untuk API yang ingin Anda panggil, lalu gunakan objek tersebut untuk membuat permintaan API yang diotorisasi.

1. Buat objek layanan untuk API yang ingin Anda panggil. Anda membuat objek layanan dengan memanggil metode build library googleapiclient.discovery beserta nama dan versi API serta kredensial pengguna: Misalnya, untuk memanggil Drive API versi 3:

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

2. Buat permintaan ke layanan API menggunakan antarmuka yang disediakan oleh objek layanan. Misalnya, untuk menampilkan daftar file dalam Google Drive pengguna yang diautentikasi:

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

Ruby

Setelah mendapatkan token akses, aplikasi Anda dapat menggunakan token tersebut untuk membuat permintaan API atas nama akun pengguna atau akun layanan tertentu. Gunakan kredensial otorisasi spesifik per pengguna untuk membuat objek layanan untuk API yang ingin Anda panggil, lalu gunakan objek tersebut untuk membuat permintaan API yang diotorisasi.

1. Buat objek layanan untuk API yang ingin Anda panggil. Misalnya, untuk memanggil Drive API versi 3:

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

2. Tetapkan kredensial di layanan:

   drive.authorization = credentials

3. Buat permintaan ke layanan API menggunakan antarmuka yang disediakan oleh objek layanan. Misalnya, untuk menampilkan daftar file dalam Google Drive pengguna yang diautentikasi:

   files = drive.list_files

Atau, otorisasi dapat diberikan per metode dengan menyediakan parameter options ke suatu metode:

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

Node.js

Setelah mendapatkan token akses dan menyetelnya ke objek OAuth2, gunakan objek tersebut untuk memanggil Google API. Aplikasi Anda dapat menggunakan token tersebut untuk mengizinkan permintaan API atas nama akun pengguna atau akun layanan tertentu. Buat objek layanan untuk API yang ingin Anda panggil.

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

Setelah aplikasi mendapatkan token akses, Anda dapat menggunakan token tersebut untuk melakukan panggilan ke Google API atas nama akun pengguna tertentu jika cakupan akses yang diperlukan oleh API telah diberikan. Untuk melakukannya, sertakan token akses dalam permintaan ke API dengan menyertakan parameter kueri access_token atau nilai Bearer header HTTP Authorization. Jika memungkinkan, sebaiknya gunakan header HTTP, karena string kueri cenderung terlihat dalam log server. Pada umumnya, Anda dapat menggunakan library klien untuk menyiapkan panggilan ke Google API (misalnya, saat memanggil Drive Files API).

Anda dapat mencoba semua Google API dan melihat cakupannya di OAuth 2.0 Playground.

Contoh HTTP GET

Panggilan ke endpoint drive.files (Drive Files API) menggunakan header HTTP Authorization: Bearer mungkin terlihat seperti berikut. Perhatikan bahwa Anda perlu menentukan token akses Anda sendiri:

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

Berikut adalah panggilan ke API yang sama untuk pengguna terautentikasi menggunakan parameter string kueri access_token:

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

Contoh curl

Anda dapat menguji perintah ini dengan aplikasi command line curl. Berikut ini contoh yang menggunakan opsi header HTTP (lebih disarankan):

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

Atau, sebagai alternatif, opsi parameter string kueri:

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

PHP

Untuk menjalankan contoh ini:

1. Di API Console, tambahkan URL komputer lokal ke daftar URL alihan. Misalnya, tambahkan http://localhost:8080.
2. Membuat direktori baru dan mengubahnya. Contoh:

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

3. Instal Library Klien Google API untuk PHP menggunakan Composer:

   composer require google/apiclient:^2.10

4. Buat file index.php dan oauth2callback.php dengan konten di bawah ini.
5. Jalankan contoh dengan server web yang dikonfigurasi untuk menyalurkan PHP. Jika menggunakan PHP 5.6 atau yang lebih baru, Anda dapat menggunakan server web pengujian bawaan 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));
}

{i>oauth2callback.php<i}

<?php
require_once __DIR__.'/vendor/autoload.php';

session_start();

$client = new Google\Client();
$client->setAuthConfigFile('client_secrets.json');
$client->setRedirectUri('http://' . $_SERVER['HTTP_HOST'] . '/oauth2callback.php');
$client->addScope(Google\Service\Drive::DRIVE_METADATA_READONLY);

if (! isset($_GET['code'])) {
  $auth_url = $client->createAuthUrl();
  header('Location: ' . filter_var($auth_url, FILTER_SANITIZE_URL));
} else {
  $client->authenticate($_GET['code']);
  $_SESSION['access_token'] = $client->getAccessToken();
  $redirect_uri = 'http://' . $_SERVER['HTTP_HOST'] . '/';
  header('Location: ' . filter_var($redirect_uri, FILTER_SANITIZE_URL));
}

Python

Contoh ini menggunakan framework Flask. Alat ini menjalankan aplikasi web di http://localhost:8080 yang memungkinkan Anda menguji alur OAuth 2.0. Jika membuka URL tersebut, Anda akan melihat empat link:

• Menguji permintaan API: Link ini mengarah ke halaman yang mencoba menjalankan contoh permintaan API. Jika perlu, langkah ini akan memulai alur otorisasi. Jika berhasil, halaman akan menampilkan respons API.
• Uji alur autentikasi secara langsung: Link ini mengarah ke halaman yang mencoba mengarahkan pengguna melalui alur otorisasi. Aplikasi meminta izin untuk mengirimkan permintaan API yang diotorisasi atas nama pengguna.
• Mencabut kredensial saat ini: Link ini mengarah ke halaman yang mencabut izin yang telah diberikan pengguna ke aplikasi.
• Hapus kredensial sesi Flask: Link ini menghapus kredensial otorisasi yang disimpan dalam sesi Flask. Hal ini memungkinkan Anda melihat hal yang akan terjadi jika pengguna yang telah memberikan izin ke aplikasi Anda mencoba menjalankan permintaan API dalam sesi baru. Dengan alat ini, Anda juga dapat melihat respons API yang akan diperoleh aplikasi Anda jika pengguna telah mencabut izin yang diberikan ke aplikasi Anda, dan aplikasi Anda masih mencoba mengizinkan permintaan dengan token akses yang dicabut.

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

Contoh ini menggunakan framework 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

Untuk menjalankan contoh ini:

1. Di API Console, tambahkan URL komputer lokal ke daftar URL alihan. Misalnya, tambahkan http://localhost.
2. Pastikan Anda telah menginstal LTS pemeliharaan, LTS aktif, atau rilis Node.js saat ini.
3. Membuat direktori baru dan mengubahnya. Contoh:

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

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

   npm install googleapis

5. Buat file main.js dengan konten di bawah ini.
6. Jalankan contoh:

   node .\main.js

main.js

const http = require('http');
const https = require('https');
const url = require('url');
const { google } = require('googleapis');

/**
 * To use OAuth2 authentication, we need access to a CLIENT_ID, CLIENT_SECRET, AND REDIRECT_URI.
 * To get these credentials for your application, visit
 * https://console.cloud.google.com/apis/credentials.
 */
const oauth2Client = new google.auth.OAuth2(
  YOUR_CLIENT_ID,
  YOUR_CLIENT_SECRET,
  YOUR_REDIRECT_URL
);

// Access scopes for read-only Drive activity.
const scopes = [
  'https://www.googleapis.com/auth/drive.metadata.readonly'
];

// Generate a url that asks permissions for the Drive activity scope
const authorizationUrl = oauth2Client.generateAuthUrl({
  // 'online' (default) or 'offline' (gets refresh_token)
  access_type: 'offline',
  /** Pass in the scopes array defined above.
    * Alternatively, if only one scope is needed, you can pass a scope URL as a string */
  scope: scopes,
  // Enable incremental authorization. Recommended as a best practice.
  include_granted_scopes: true
});

/* Global variable that stores user credential in this code example.
 * ACTION ITEM for developers:
 *   Store user's refresh token in your data store if
 *   incorporating this code into your real app.
 *   For more information on handling refresh tokens,
 *   see https://github.com/googleapis/google-api-nodejs-client#handling-refresh-tokens
 */
let userCredential = null;

async function main() {
  const server = http.createServer(async function (req, res) {
    // Example on redirecting user to Google's OAuth 2.0 server.
    if (req.url == '/') {
      res.writeHead(301, { "Location": authorizationUrl });
    }

    // Receive the callback from Google's OAuth 2.0 server.
    if (req.url.startsWith('/oauth2callback')) {
      // Handle the OAuth 2.0 server response
      let q = url.parse(req.url, true).query;

      if (q.error) { // An error response e.g. error=access_denied
        console.log('Error:' + q.error);
      } else { // Get access and refresh tokens (if access_type is offline)
        let { tokens } = await oauth2Client.getToken(q.code);
        oauth2Client.setCredentials(tokens);

        /** Save credential to the global variable in case access token was refreshed.
          * ACTION ITEM: In a production app, you likely want to save the refresh token
          *              in a secure persistent database instead. */
        userCredential = tokens;

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

    // Example on revoking a token
    if (req.url == '/revoke') {
      // Build the string for the POST request
      let postData = "token=" + userCredential.access_token;

      // Options for POST request to Google's OAuth 2.0 server to revoke a token
      let postOptions = {
        host: 'oauth2.googleapis.com',
        port: '443',
        path: '/revoke',
        method: 'POST',
        headers: {
          'Content-Type': 'application/x-www-form-urlencoded',
          'Content-Length': Buffer.byteLength(postData)
        }
      };

      // Set up the request
      const postReq = https.request(postOptions, function (res) {
        res.setEncoding('utf8');
        res.on('data', d => {
          console.log('Response: ' + d);
        });
      });

      postReq.on('error', error => {
        console.log(error)
      });

      // Post the request with data
      postReq.write(postData);
      postReq.end();
    }
    res.end();
  }).listen(80);
}
main().catch(console.error);

HTTP/REST

Contoh Python ini menggunakan framework Flask dan library Requests untuk mendemonstrasikan alur web OAuth 2.0. Sebaiknya gunakan Library Klien Google API untuk Python untuk alur ini. (Contoh di tab Python menggunakan library klien.)

import json

import flask
import requests


app = flask.Flask(__name__)

CLIENT_ID = '123456789.apps.googleusercontent.com'
CLIENT_SECRET = 'abc123'  # Read from a file or environmental variable in a real app
SCOPE = 'https://www.googleapis.com/auth/drive.metadata.readonly'
REDIRECT_URI = 'http://example.com/oauth2callback'


@app.route('/')
def index():
  if 'credentials' not in flask.session:
    return flask.redirect(flask.url_for('oauth2callback'))
  credentials = json.loads(flask.session['credentials'])
  if credentials['expires_in'] <= 0:
    return flask.redirect(flask.url_for('oauth2callback'))
  else:
    headers = {'Authorization': 'Bearer {}'.format(credentials['access_token'])}
    req_uri = 'https://www.googleapis.com/drive/v2/files'
    r = requests.get(req_uri, headers=headers)
    return r.text


@app.route('/oauth2callback')
def oauth2callback():
  if 'code' not in flask.request.args:
    auth_uri = ('https://accounts.google.com/o/oauth2/v2/auth?response_type=code'
                '&client_id={}&redirect_uri={}&scope={}').format(CLIENT_ID, REDIRECT_URI, SCOPE)
    return flask.redirect(auth_uri)
  else:
    auth_code = flask.request.args.get('code')
    data = {'code': auth_code,
            'client_id': CLIENT_ID,
            'client_secret': CLIENT_SECRET,
            'redirect_uri': REDIRECT_URI,
            'grant_type': 'authorization_code'}
    r = requests.post('https://oauth2.googleapis.com/token', data=data)
    flask.session['credentials'] = r.text
    return flask.redirect(flask.url_for('index'))


if __name__ == '__main__':
  import uuid
  app.secret_key = str(uuid.uuid4())
  app.debug = False
  app.run()

PHP

$client->setIncludeGrantedScopes(true);

Python

Di Python, tetapkan argumen kata kunci include_granted_scopes ke true untuk memastikan bahwa permintaan otorisasi menyertakan cakupan yang telah diberikan sebelumnya. Sangat mungkin bahwa include_granted_scopes tidak akan menjadi argumen kata kunci satu-satunya yang Anda tetapkan, seperti yang ditunjukkan dalam contoh di bawah.

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

Jika aplikasi Anda memerlukan akses offline ke Google API, tetapkan jenis akses klien API ke offline:

$client->setAccessType("offline");

Setelah pengguna memberikan akses offline ke cakupan yang diminta, Anda dapat terus menggunakan klien API untuk mengakses Google API atas nama pengguna saat pengguna sedang offline. Objek klien akan memperbarui token akses sesuai kebutuhan.

Python

Di Python, tetapkan argumen kata kunci access_type ke offline untuk memastikan bahwa Anda dapat memuat ulang token akses tanpa harus meminta izin kembali kepada pengguna. Sangat mungkin bahwa access_type tidak akan menjadi satu-satunya argumen kata kunci yang Anda tetapkan, seperti yang ditunjukkan dalam contoh di bawah.

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

Setelah pengguna memberikan akses offline ke cakupan yang diminta, Anda dapat terus menggunakan klien API untuk mengakses Google API atas nama pengguna saat pengguna sedang offline. Objek klien akan memperbarui token akses sesuai kebutuhan.

Ruby

Jika aplikasi Anda memerlukan akses offline ke Google API, tetapkan jenis akses klien API ke offline:

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

Setelah pengguna memberikan akses offline ke cakupan yang diminta, Anda dapat terus menggunakan klien API untuk mengakses Google API atas nama pengguna saat pengguna sedang offline. Objek klien akan memperbarui token akses sesuai kebutuhan.

Node.js

Jika aplikasi Anda memerlukan akses offline ke Google API, tetapkan jenis akses klien API ke 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
});

Setelah pengguna memberikan akses offline ke cakupan yang diminta, Anda dapat terus menggunakan klien API untuk mengakses Google API atas nama pengguna saat pengguna sedang offline. Objek klien akan memperbarui token akses sesuai kebutuhan.

Token akses tidak berlaku lagi. Library ini akan otomatis menggunakan token refresh untuk mendapatkan token akses baru jika masa berlakunya akan segera berakhir. Cara mudah untuk memastikan Anda selalu menyimpan token terbaru adalah dengan menggunakan peristiwa token:

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

Peristiwa token ini hanya terjadi pada otorisasi pertama, dan Anda harus menetapkan access_type ke offline saat memanggil metode generateAuthUrl untuk menerima token refresh. Jika telah memberi aplikasi izin yang diperlukan tanpa menetapkan batasan yang sesuai untuk menerima token refresh, Anda perlu memberikan otorisasi ulang ke aplikasi untuk menerima token refresh baru.

Untuk menyetel refresh_token di lain waktu, Anda dapat menggunakan metode setCredentials:

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

Setelah klien memiliki token refresh, token akses akan diperoleh dan dimuat ulang secara otomatis dalam panggilan berikutnya ke API.

HTTP/REST

Untuk me-refresh token akses, aplikasi Anda mengirimkan permintaan POST HTTPS ke server otorisasi Google (https://oauth2.googleapis.com/token) yang menyertakan parameter berikut:

Cuplikan berikut menunjukkan contoh permintaan:

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

Selama pengguna belum mencabut akses yang diberikan untuk aplikasi, server token akan menampilkan objek JSON yang berisi token akses baru. Cuplikan berikut menunjukkan contoh respons:

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

Perhatikan bahwa ada batasan jumlah token refresh yang akan dikeluarkan; satu batas per kombinasi klien/pengguna, dan satu batas per pengguna di seluruh klien. Anda harus menyimpan token refresh dalam penyimpanan jangka panjang dan terus menggunakannya selama token tersebut tetap valid. Jika aplikasi Anda meminta terlalu banyak token refresh, aplikasi tersebut dapat mencapai batas ini, dalam hal ini token refresh yang lebih lama akan berhenti berfungsi.

PHP

Untuk mencabut token secara terprogram, panggil revokeToken():

$client->revokeToken();

Python

Untuk mencabut token secara terprogram, buat permintaan ke https://oauth2.googleapis.com/revoke yang menyertakan token sebagai parameter dan tetapkan header Content-Type:

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

Ruby

Untuk mencabut token secara terprogram, buat permintaan HTTP ke endpoint oauth2.revoke:

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

Token dapat berupa token akses atau token refresh. Jika token adalah token akses dan memiliki token refresh yang sesuai, token refresh juga akan dicabut.

Jika pencabutan berhasil diproses, kode status respons adalah 200. Untuk kondisi error, kode status 400 akan ditampilkan bersama dengan kode error.

Node.js

Untuk mencabut token secara terprogram, buat permintaan POST HTTPS ke endpoint /revoke:

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

Parameter token dapat berupa token akses atau token refresh. Jika token adalah token akses dan memiliki token refresh yang sesuai, token refresh juga akan dicabut.

Jika pencabutan berhasil diproses, kode status respons adalah 200. Untuk kondisi error, kode status 400 akan ditampilkan bersama dengan kode error.

HTTP/REST

Untuk mencabut token secara terprogram, aplikasi Anda membuat permintaan ke https://oauth2.googleapis.com/revoke dan menyertakan token sebagai parameter:

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

Token dapat berupa token akses atau token refresh. Jika token adalah token akses dan memiliki token refresh yang sesuai, token refresh juga akan dicabut.

Jika pencabutan berhasil diproses, kode status HTTP untuk respons adalah 200. Untuk kondisi error, kode status HTTP 400 akan ditampilkan bersama dengan kode error.