웹 서버 애플리케이션용 OAuth 2.0 사용

2,399필리핀

이 문서의 PHP 코드 샘플을 실행하려면 다음이 필요합니다.

• 명령줄 인터페이스 (CLI) 및 JSON 확장 프로그램이 설치된 PHP 5.6 이상
• Composer 종속 항목 관리 도구

• PHP용 Google API 클라이언트 라이브러리:

  composer require google/apiclient:^2.10

Python

이 문서의 Python 코드 샘플을 실행하려면 다음이 필요합니다.

• Python 2.6 이상
• pip 패키지 관리 도구.
• Python용 Google API 클라이언트 라이브러리:

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

• 사용자 승인을 위한 google-auth, google-auth-oauthlib, google-auth-httplib2입니다.

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

• Flask Python 웹 애플리케이션 프레임워크입니다.

  pip install --upgrade flask

• requests HTTP 라이브러리

  pip install --upgrade requests

루비

이 문서의 Ruby 코드 샘플을 실행하려면 다음이 필요합니다.

• Ruby 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 엔드포인트를 직접 호출하기 위해 라이브러리를 설치할 필요는 없습니다.

2,399필리핀

아래의 코드 스니펫은 승인 요청에서 매개변수를 정의하는 Google\Client() 객체를 만듭니다.

이 객체는 client_secret.json 파일의 정보를 사용하여 애플리케이션을 식별합니다. 이 파일에 대한 자세한 내용은 승인 사용자 인증 정보 만들기를 참조하세요. 또한 이 객체는 애플리케이션이 액세스 권한을 요청하는 범위와 Google OAuth 2.0 서버의 응답을 처리하는 애플리케이션의 인증 엔드포인트 URL을 식별합니다. 마지막으로 선택적 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 모듈을 사용하여 승인 요청을 구성합니다.

이 코드는 승인 사용자 인증 정보를 만든 후 다운로드한 client_secret.json 파일의 정보를 사용하여 애플리케이션을 식별하는 Flow 객체를 생성합니다. 또한 이 객체는 애플리케이션이 액세스 권한을 요청하는 범위와 Google OAuth 2.0 서버의 응답을 처리하는 애플리케이션의 인증 엔드포인트 URL을 식별합니다. 마지막으로, 코드는 선택적 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')

루비

만든 client_secrets.json 파일을 사용하여 애플리케이션에서 클라이언트 객체를 구성합니다. 클라이언트 객체를 구성할 때 OAuth 2.0 서버의 응답을 처리할 애플리케이션의 인증 엔드포인트 URL과 함께 애플리케이션에서 액세스해야 하는 범위를 지정합니다.

예를 들어 다음 코드는 사용자의 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')

애플리케이션은 클라이언트 객체를 사용하여 승인 요청 URL을 생성하고 HTTP 요청에 액세스 토큰을 적용하는 등의 OAuth 2.0 작업을 수행합니다.

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 연결은 거부됩니다.

2,399필리핀

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)

루비

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단계 generateAuthUrl 메서드에서 생성된 URL authorizationUrl을 사용하여 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

요청 URL을 만든 후 사용자를 이 URL로 리디렉션합니다.

2,399필리핀

승인 코드를 액세스 토큰과 교환하려면 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}

루비

콜백 페이지에서 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 객체를 반환하여 이 요청에 응답합니다. 새로고침 토큰은 애플리케이션이 Google 승인 서버에 대한 초기 요청에서 access_type 매개변수를 offline로 설정한 경우에만 반환됩니다.

응답에는 다음 필드가 포함됩니다.

다음 스니펫은 샘플 응답을 보여줍니다.

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

2,399필리핀

액세스 토큰을 사용하여 Google API를 호출하려면 다음 단계를 따르세요.

1. 새 Google\Client 객체에 액세스 토큰을 적용해야 하는 경우(예: 사용자 세션에 액세스 토큰을 저장한 경우) setAccessToken 메서드를 사용합니다.

   $client->setAccessToken($access_token);

2. 호출하려는 API의 서비스 객체를 빌드합니다. 호출하려는 API의 생성자에 승인된 Google\Client 객체를 제공하여 서비스 객체를 빌드합니다. 예를 들어 YouTube Data API를 호출하려면 다음을 실행합니다.

   $youtube = new Google_Service_YouTube($client);

3. 서비스 객체가 제공하는 인터페이스를 사용하여 API 서비스에 요청합니다. 예를 들어 승인된 사용자의 YouTube 채널에 대한 데이터를 검색하려면 다음 안내를 따르세요.

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

Python

액세스 토큰을 얻은 후 애플리케이션은 이 토큰을 사용하여 지정된 사용자 계정 또는 서비스 계정 대신 API 요청을 승인할 수 있습니다. 사용자별 승인 사용자 인증 정보를 사용하여 호출하려는 API의 서비스 객체를 빌드한 다음 해당 객체를 사용하여 승인된 API 요청을 만듭니다.

1. 호출하려는 API의 서비스 객체를 빌드합니다. API의 이름 및 버전 및 사용자 인증 정보를 사용하여 googleapiclient.discovery 라이브러리의 build 메서드를 호출하여 서비스 객체를 빌드합니다. 예를 들어 다음과 같이 YouTube Data API 버전 3을 호출합니다.

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

2. 서비스 객체가 제공하는 인터페이스를 사용하여 API 서비스에 요청합니다. 예를 들어 승인된 사용자의 YouTube 채널에 대한 데이터를 검색하려면 다음 안내를 따르세요.

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

루비

액세스 토큰을 가져온 후 애플리케이션은 해당 토큰을 사용하여 지정된 사용자 계정 또는 서비스 계정 대신 API 요청을 할 수 있습니다. 사용자별 승인 사용자 인증 정보를 사용하여 호출하려는 API의 서비스 객체를 빌드한 다음 해당 객체를 사용하여 승인된 API 요청을 만듭니다.

1. 호출하려는 API의 서비스 객체를 빌드합니다. 예를 들어 YouTube Data API의 버전 3을 호출하려면 다음을 실행합니다.

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

2. 서비스의 사용자 인증 정보를 설정합니다.

   youtube.authorization = credentials

3. 서비스 객체가 제공하는 인터페이스를 사용하여 API 서비스에 요청합니다. 예를 들어 승인된 사용자의 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

애플리케이션이 액세스 토큰을 획득한 후 API에 필요한 액세스 범위가 부여된 경우 이 토큰을 사용하여 지정된 사용자 계정을 대신하여 Google API를 호출할 수 있습니다. 이렇게 하려면 access_token 쿼리 매개변수 또는 Authorization HTTP 헤더 Bearer 값을 포함하여 API에 대한 요청에 액세스 토큰을 포함하세요. 쿼리 문자열은 서버 로그에 표시되는 경향이 있으므로 가능하면 HTTP 헤더를 사용하는 것이 좋습니다. 대부분의 경우 클라이언트 라이브러리를 사용하여 Google API 호출을 설정할 수 있습니다 (예: YouTube Data API를 호출하는 경우).

YouTube Data API는 음반사, 영화 스튜디오 등 여러 YouTube 채널을 소유하고 관리하는 YouTube 콘텐츠 소유자의 서비스 계정만 지원합니다.

모든 Google API를 사용해 보고 OAuth 2.0 플레이그라운드에서 범위를 확인할 수 있습니다.

HTTP GET 예시

Authorization: Bearer HTTP 헤더를 사용하는 youtube.channels 엔드포인트 (YouTube Data API)에 대한 호출은 다음과 같을 수 있습니다. 자체 액세스 토큰을 지정해야 합니다.

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

2,399필리핀

이 예시를 실행하려면 다음 안내를 따르세요.

1. API Console에서 로컬 머신의 URL을 리디렉션 URL 목록에 추가합니다. 예를 들어 http://localhost:8080를 추가합니다.
2. 새 디렉터리를 만들어 해당 디렉터리로 변경합니다. 예를 들면 다음과 같습니다.

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

3. Composer를 사용하여 PHP용 Google API 클라이언트 라이브러리를 설치합니다.

   composer require google/apiclient:^2.10

4. 아래 콘텐츠로 index.php 및 oauth2callback.php 파일을 만듭니다.
5. PHP를 제공하도록 구성된 웹 서버에서 예제를 실행합니다. PHP 5.6 이상을 사용하는 경우 PHP의 기본 제공 테스트 웹 서버(

   php -S localhost:8080 ~/php-oauth2-example

   )를 사용할 수 있습니다.

index.php

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

session_start();

$client = new Google\Client();
$client->setAuthConfig('client_secrets.json');
$client->addScope(GOOGLE_SERVICE_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에서 웹 애플리케이션을 실행하므로 OAuth 2.0 흐름을 테스트할 수 있습니다. 해당 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/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)

루비

이 예에서는 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에서 로컬 머신의 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 웹 흐름을 보여줍니다. 이 흐름에는 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()

2,399필리핀

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

루비

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에 액세스할 수 있습니다. 클라이언트 객체는 필요에 따라 액세스 토큰을 새로고침합니다.

루비

애플리케이션에서 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"
}

발급되는 갱신 토큰 수에는 한도가 있습니다. 클라이언트/사용자 조합당 하나, 모든 클라이언트의 사용자당 다른 한도가 있습니다. 갱신 토큰은 장기 저장소에 저장한 후 유효할 때까지 계속 사용해야 합니다. 애플리케이션이 너무 많은 갱신 토큰을 요청하면 이러한 한도에 도달할 수 있으며, 이 경우 이전 갱신 토큰은 작동이 중지됩니다.

2,399필리핀

프로그래매틱 방식으로 토큰을 취소하려면 revokeToken()를 호출합니다.

$client->revokeToken();

Python

프로그래매틱 방식으로 토큰을 취소하려면 토큰을 매개변수로 포함하고 Content-Type 헤더를 설정하는 https://oauth2.googleapis.com/revoke에 요청합니다.

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

루비

프로그래매틱 방식으로 토큰을 취소하려면 oauth2.revoke 엔드포인트에 HTTP 요청을 실행합니다.

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

토큰은 액세스 토큰 또는 갱신 토큰일 수 있습니다. 토큰이 액세스 토큰이며 해당하는 갱신 토큰이 있는 경우 갱신 토큰도 취소됩니다.

취소가 성공적으로 처리되면 응답의 상태 코드는 200입니다. 오류 조건의 경우 상태 코드 400가 오류 코드와 함께 반환됩니다.

Node.js

프로그래매틱 방식으로 토큰을 취소하려면 /revoke 엔드포인트에 HTTPS POST 요청을 실행합니다.

const https = require('https');

// Build the string for the POST request
let postData = "token=" + userCredential.access_token;

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

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

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

// Post the request with data
postReq.write(postData);
postReq.end();

토큰 매개변수는 액세스 토큰 또는 갱신 토큰일 수 있습니다. 토큰이 액세스 토큰이며 해당하는 갱신 토큰이 있는 경우 갱신 토큰도 취소됩니다.

취소가 성공적으로 처리되면 응답의 상태 코드는 200입니다. 오류 조건의 경우 상태 코드 400가 오류 코드와 함께 반환됩니다.

HTTP/REST

프로그래매틱 방식으로 토큰을 취소하기 위해 애플리케이션은 https://oauth2.googleapis.com/revoke에 요청하고 토큰을 매개변수로 포함합니다.

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

토큰은 액세스 토큰 또는 갱신 토큰일 수 있습니다. 토큰이 액세스 토큰이며 해당하는 갱신 토큰이 있는 경우 갱신 토큰도 취소됩니다.

취소가 성공적으로 처리되면 응답의 HTTP 상태 코드는 200입니다. 오류 조건의 경우 HTTP 상태 코드 400가 오류 코드와 함께 반환됩니다.