वेब सर्वर ऐप्लिकेशन के लिए OAuth 2.0 का इस्तेमाल करना

PHP

इस दस्तावेज़ में PHP कोड के नमूने चलाने के लिए, आपको इनकी ज़रूरत होगी:

• कमांड-लाइन इंटरफ़ेस (CLI) और JSON एक्सटेंशन के साथ PHP 5.6 या इससे बाद का वर्शन.
• Composer डिपेंडेंसी मैनेजमेंट टूल.

• PHP के लिए Google API क्लाइंट लाइब्रेरी:

  composer require google/apiclient:^2.10

Python

इस दस्तावेज़ में Python कोड के सैंपल चलाने के लिए, आपको इनकी ज़रूरत होगी:

• Python 2.6 या इससे नया वर्शन
• पीआईपी पैकेज मैनेजमेंट टूल.
• 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

• Flusk Python वेब ऐप्लिकेशन फ़्रेमवर्क.

  pip install --upgrade flask

• requests एचटीटीपी लाइब्रेरी.

  pip install --upgrade requests

Ruby

इस दस्तावेज़ में Ruby कोड के सैंपल चलाने के लिए, आपको इनकी ज़रूरत होगी:

• Ruby 2.6 या इससे नया वर्शन

• Ruby के लिए Google पुष्टि लाइब्रेरी:

  gem install googleauth

• Ciatra Ruby वेब ऐप्लिकेशन का फ़्रेमवर्क.

  gem install sinatra

Node.js

इस दस्तावेज़ में Node.js कोड के सैंपल चलाने के लिए, आपको इनकी ज़रूरत होगी:

• रखरखाव एलटीएस, चालू एलटीएस या Node.js की मौजूदा रिलीज़.

• Google API Node.js क्लाइंट:

  npm install googleapis crypto express express-session

एचटीटीपी/REST

सीधे OAuth 2.0 को कॉल करने के लिए, आपको कोई लाइब्रेरी इंस्टॉल करने की ज़रूरत नहीं है एंडपॉइंट के बारे में भी बताएंगे.

PHP

नीचे दिया गया कोड स्निपेट एक Google\Client() ऑब्जेक्ट बनाता है, जो पैरामीटर को अनुमति देने के अनुरोध में शामिल कर सकते हैं.

यह ऑब्जेक्ट आपकी client_secret.json फ़ाइल में मौजूद जानकारी का इस्तेमाल करता है, ताकि का इस्तेमाल करें. (इसके बारे में ज़्यादा जानने के लिए अनुमति देने के क्रेडेंशियल बनाना देखें फ़ाइल से मेल खाना चाहिए.) ऑब्जेक्ट उन दायरों की पहचान भी करता है जिनके लिए आपका ऐप्लिकेशन अनुमति का अनुरोध कर रहा है आपके ऐप्लिकेशन के पुष्टि करने वाले एंडपॉइंट के यूआरएल को ऐक्सेस करने और उसके यूआरएल को ऐक्सेस करने के लिए, जो Google का OAuth 2.0 सर्वर. आखिर में, कोड, वैकल्पिक access_type सेट करता है और include_granted_scopes पैरामीटर.

उदाहरण के लिए, यह कोड किसी उपयोगकर्ता के YouTube को मैनेज करने के लिए, उसे बिना इंटरनेट के इस्तेमाल करने का अनुरोध करता है खाता:

$client = new Google\Client();

// Required, call the setAuthConfig function to load authorization credentials from
// client_secret.json file.
$client->setAuthConfig('client_secret.json');

// Required, to set the scope value, call the addScope function
$client->addScope(GOOGLE_SERVICE_YOUTUBE::YOUTUBE_FORCE_SSL);

// Required, call the setRedirectUri function to specify a valid redirect URI for the
// provided client_id
$client->setRedirectUri('http://' . $_SERVER['HTTP_HOST'] . '/oauth2callback.php');

// Recommended, offline access will give you both an access and refresh token so that
// your app can refresh the access token without user interaction.
$client->setAccessType('offline');

// Recommended, call the setState function. Using a state value can increase your assurance that
// an incoming connection is the result of an authentication request.
$client->setState($sample_passthrough_value);

// Optional, if your application knows which user is trying to authenticate, it can use this
// parameter to provide a hint to the Google Authentication Server.
$client->setLoginHint('hint@example.com');

// Optional, call the setPrompt function to set "consent" will prompt the user for consent
$client->setPrompt('consent');

// Optional, call the setIncludeGrantedScopes function with true to enable incremental
// authorization
$client->setIncludeGrantedScopes(true);

Python

नीचे दिया गया कोड स्निपेट इन्हें बनाने के लिए, google-auth-oauthlib.flow मॉड्यूल का इस्तेमाल करता है अनुमति देने का अनुरोध है.

कोड एक Flow ऑब्जेक्ट बनाता है, जो इसका इस्तेमाल करके आपके ऐप्लिकेशन की पहचान करता है client_secret.json फ़ाइल से मिली जानकारी, जिसे आपने इसके बाद डाउनलोड किया है ऑथराइज़ेशन क्रेडेंशियल बनाना. वह ऑब्जेक्ट उन दायरों और उनके URL के बारे में जहां आपका ऐप्लिकेशन ऐक्सेस की अनुमति का अनुरोध कर रहा है auth एंडपॉइंट, जो कि Google के OAuth 2.0 सर्वर से रिस्पॉन्स को हैंडल करेगा. आखिर में, कोड वैकल्पिक access_type और include_granted_scopes पैरामीटर सेट करता है.

उदाहरण के लिए, यह कोड किसी उपयोगकर्ता के YouTube को मैनेज करने के लिए, उसे बिना इंटरनेट के इस्तेमाल करने का अनुरोध करता है खाता:

import google.oauth2.credentials
import google_auth_oauthlib.flow

# Required, call the from_client_secrets_file method to retrieve the client ID from a
# client_secret.json file. The client ID (from that file) and access scopes are required. (You can
# also use the from_client_config method, which passes the client configuration as it originally
# appeared in a client secrets file but doesn't access the file itself.)
flow = google_auth_oauthlib.flow.Flow.from_client_secrets_file(
    'client_secret.json',
    scopes=['https://www.googleapis.com/auth/youtube.force-ssl'])

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

# Generate URL for request to Google's OAuth 2.0 server.
# Use kwargs to set optional request parameters.
authorization_url, state = flow.authorization_url(
    # Recommended, enable offline access so that you can refresh an access token without
    # re-prompting the user for permission. Recommended for web server apps.
    access_type='offline',
    # Optional, enable incremental authorization. Recommended as a best practice.
    include_granted_scopes='true',
    # Optional, if your application knows which user is trying to authenticate, it can use this
    # parameter to provide a hint to the Google Authentication Server.
    login_hint='hint@example.com',
    # Optional, set prompt to 'consent' will prompt the user for consent
    prompt='consent')

Ruby

उस client_secrets.json फ़ाइल का इस्तेमाल करें जिसे आपने अपने का इस्तेमाल करें. क्लाइंट ऑब्जेक्ट को कॉन्फ़िगर करने पर, आपके ऐप्लिकेशन के लिए ज़रूरी दायरे तय किए जाते हैं आपके ऐप्लिकेशन के पुष्टि करने वाले एंडपॉइंट के यूआरएल के साथ-साथ ऐक्सेस करता है, जो रिस्पॉन्स को हैंडल करेगा से डाउनलोड कर सकते हैं.

उदाहरण के लिए, यह कोड किसी उपयोगकर्ता के YouTube को मैनेज करने के लिए, उसे बिना इंटरनेट के इस्तेमाल करने का अनुरोध करता है खाता:

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

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

आपका ऐप्लिकेशन, OAuth 2.0 से जुड़ी कार्रवाइयां करने के लिए क्लाइंट ऑब्जेक्ट का इस्तेमाल करता है, जैसे कि जनरेट करना की अनुमति देने के अनुरोध के यूआरएल और एचटीटीपी अनुरोधों पर ऐक्सेस टोकन लागू करना शामिल है.

Node.js

यह कोड स्निपेट एक google.auth.OAuth2 ऑब्जेक्ट बनाता है, जो पैरामीटर को अनुमति देने के अनुरोध में शामिल कर सकते हैं.

वह ऑब्जेक्ट आपके ऐप्लिकेशन की पहचान करने के लिए, आपकी client_secret.json फ़ाइल की जानकारी का इस्तेमाल करता है. यहां की यात्रा पर हूं ऐक्सेस टोकन फिर से पाने के लिए, उपयोगकर्ता से अनुमतियां मांगें. सहमति वाले पेज का यूआरएल बनाने के लिए:

const {google} = require('googleapis');
const crypto = require('crypto');
const express = require('express');
const session = require('express-session');

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

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

// Generate a secure random state value.
const state = crypto.randomBytes(32).toString('hex');

// Store state in the session
req.session.state = state;

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

अहम जानकारी - refresh_token सिर्फ़ पहले अनुमति. ज़्यादा जानकारी यहां पढ़ें.

एचटीटीपी/REST

Google का OAuth 2.0 एंडपॉइंट https://accounts.google.com/o/oauth2/v2/auth पर है. यह एंडपॉइंट को सिर्फ़ एचटीटीपीएस से ऐक्सेस किया जा सकता है. सामान्य एचटीटीपी कनेक्शन अस्वीकार कर दिए गए हैं.

PHP

1. Google के OAuth 2.0 सर्वर से ऐक्सेस का अनुरोध करने के लिए यूआरएल जनरेट करें:

   $auth_url = $client->createAuthUrl();

   अभी तक किसी भी व्यक्ति ने चेक इन नहीं किया है
2. उपयोगकर्ता को $auth_url पर रीडायरेक्ट करें:

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

Python

इस उदाहरण में, फ़्लास्क वेब का इस्तेमाल करके उपयोगकर्ता को अनुमति वाले यूआरएल पर रीडायरेक्ट करने का तरीका बताया गया है ऐप्लिकेशन का फ़्रेमवर्क:

return flask.redirect(authorization_url)

Ruby

1. Google के OAuth 2.0 सर्वर से ऐक्सेस का अनुरोध करने के लिए यूआरएल जनरेट करें:

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

   अभी तक किसी भी व्यक्ति ने चेक इन नहीं किया है
2. उपयोगकर्ता को auth_uri पर रीडायरेक्ट करें.

Node.js

1. पहले चरण में जनरेट किए गए यूआरएल authorizationUrl का इस्तेमाल करें Google के OAuth 2.0 सर्वर से ऐक्सेस का अनुरोध करने के लिए, generateAuthUrl तरीका.
2. उपयोगकर्ता को authorizationUrl पर रीडायरेक्ट करें.

   res.redirect(authorizationUrl);

HTTP/REST

Sample redirect to Google's authorization server

The sample URL below requests offline access (access_type=offline) to a scope that permits access to view the user's YouTube account. It uses incremental authorization to ensure that the new access token covers any scopes to which the user previously granted the application access. The URL also sets values for the required redirect_uri, response_type, and client_id parameters as well as for the state parameter. The URL contains line breaks and spaces for readability.

https://accounts.google.com/o/oauth2/v2/auth?
 scope=https%3A%2F%2Fwww.googleapis.com%2Fauth%2Fyoutube.readonly&
 access_type=offline&
 include_granted_scopes=true&
 state=state_parameter_passthrough_value&
 redirect_uri=http%3A%2F%2Flocalhost%2Foauth2callback&
 response_type=code&
 client_id=client_id

अनुरोध यूआरएल बनाने के बाद, उपयोगकर्ता को उस पर रीडायरेक्ट करें.

PHP

ऐक्सेस टोकन से ऑथराइज़ेशन कोड को बदलने के लिए, authenticate का इस्तेमाल करें तरीका:

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

getAccessToken तरीके की मदद से, ऐक्सेस टोकन फिर से पाया जा सकता है:

$access_token = $client->getAccessToken();

Python

अनुमति की पुष्टि करने के लिए, अपने कॉलबैक पेज पर google-auth लाइब्रेरी का इस्तेमाल करें सर्वर प्रतिक्रिया. इसके बाद, अनुमति को बदलने के लिए flow.fetch_token तरीके का इस्तेमाल करें ऐक्सेस टोकन के लिए उस रिस्पॉन्स में कोड:

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

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

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

Ruby

अपने कॉलबैक पेज पर, अनुमति देने वाले सर्वर की पुष्टि करने के लिए, googleauth लाइब्रेरी का इस्तेमाल करें जवाब. सेव करने के लिए authorizer.handle_auth_callback_deferred तरीके का इस्तेमाल करें ऑथराइज़ेशन कोड को सबमिट करें और उस यूआरएल पर वापस रीडायरेक्ट करें जिससे मूल रूप से अनुमति पाने का अनुरोध किया गया था. यह उपयोगकर्ता के सेशन में, नतीजों को कुछ समय के लिए छिपाकर कोड को शेयर करने की प्रोसेस को रोकता है.

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

Node.js

ऐक्सेस टोकन से ऑथराइज़ेशन कोड को बदलने के लिए, getToken का इस्तेमाल करें तरीका:

const url = require('url');

// Receive the callback from Google's OAuth 2.0 server.
app.get('/oauth2callback', async (req, res) => {
  let q = url.parse(req.url, true).query;

  if (q.error) { // An error response e.g. error=access_denied
    console.log('Error:' + q.error);
  } else if (q.state !== req.session.state) { //check state value
    console.log('State mismatch. Possible CSRF attack');
    res.end('State mismatch. Possible CSRF attack');
  } else { // Get access and refresh tokens (if access_type is offline)

    let { tokens } = await oauth2Client.getToken(q.code);
    oauth2Client.setCredentials(tokens);
});

एचटीटीपी/REST

ऐक्सेस टोकन से ऑथराइज़ेशन कोड को बदलने के लिए, https://oauth2.googleapis.com/token एंडपॉइंट और ये पैरामीटर सेट करें:

नीचे दिए गए स्निपेट में, अनुरोध का एक सैंपल दिखाया गया है:

POST /token HTTP/1.1
Host: oauth2.googleapis.com
Content-Type: application/x-www-form-urlencoded

code=4/P7q7W91a-oMsCeLvIaQm6bTrgtp7&
client_id=your_client_id&
client_secret=your_client_secret&
redirect_uri=https%3A//oauth2.example.com/code&
grant_type=authorization_code

इस अनुरोध का जवाब देने के लिए, Google एक JSON ऑब्जेक्ट दिखाता है. इसमें कुछ समय के लिए उपलब्ध रहने वाला ऐक्सेस होता है टोकन और रीफ़्रेश टोकन. ध्यान दें कि रीफ़्रेश टोकन सिर्फ़ तब मिलता है, जब आपका ऐप्लिकेशन access_type को सेट करता है Google को किए गए शुरुआती अनुरोध में 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"
}

PHP

यह तरीका अपनाकर Google API को कॉल करने के लिए, ऐक्सेस टोकन का इस्तेमाल करें:

1. अगर आपको नए Google\Client ऑब्जेक्ट पर ऐक्सेस टोकन लागू करने की ज़रूरत हो — उदाहरण के लिए, अगर आपने किसी उपयोगकर्ता सेशन में ऐक्सेस टोकन सेव किया है — तो setAccessToken तरीका:

   $client->setAccessToken($access_token);

2. जिस एपीआई को कॉल करना है उसके लिए सेवा ऑब्जेक्ट बनाएं. सेवा ऑब्जेक्ट इसके ज़रिए बनाया जाता है एपीआई के लिए, कंस्ट्रक्टर को अनुमति वाला Google\Client ऑब्जेक्ट उपलब्ध कराकर कॉल करना चाहते हैं. उदाहरण के लिए, YouTube Data API को कॉल करने के लिए:

   $youtube = new Google_Service_YouTube($client);

   अभी तक किसी भी व्यक्ति ने चेक इन नहीं किया है
3. एपीआई सेवा से अनुरोध करने के लिए, सर्विस ऑब्जेक्ट से मिला इंटरफ़ेस. उदाहरण के लिए, अनुमति पा चुके उपयोगकर्ता के YouTube चैनल का डेटा वापस पाने के लिए:

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

   अभी तक किसी भी व्यक्ति ने चेक इन नहीं किया है

Python

ऐक्सेस टोकन पाने के बाद, आपका ऐप्लिकेशन उस टोकन का इस्तेमाल करके, एपीआई अनुरोधों को अनुमति दे सकता है: किसी उपयोगकर्ता खाते या सेवा खाते की तरफ़ से. उपयोगकर्ता के हिसाब से अनुमति देने वाले क्रेडेंशियल का इस्तेमाल करना को कॉल करने के लिए एक सर्विस ऑब्जेक्ट बनाया जा सकता है. इसके बाद, उस ऑब्जेक्ट का इस्तेमाल अनुमति वाले एपीआई अनुरोध.

1. जिस एपीआई को कॉल करना है उसके लिए सेवा ऑब्जेक्ट बनाएं. सेवा ऑब्जेक्ट इसके ज़रिए बनाया जाता है googleapiclient.discovery लाइब्रेरी के build तरीके को एपीआई का नाम और वर्शन, और उपयोगकर्ता के क्रेडेंशियल: उदाहरण के लिए, YouTube Data API के वर्शन 3 को कॉल करने के लिए:

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

2. एपीआई सेवा से अनुरोध करने के लिए, सर्विस ऑब्जेक्ट से मिला इंटरफ़ेस. उदाहरण के लिए, अनुमति पा चुके उपयोगकर्ता के YouTube चैनल का डेटा वापस पाने के लिए:

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

   अभी तक किसी भी व्यक्ति ने चेक इन नहीं किया है

Ruby

ऐक्सेस टोकन मिलने के बाद, आपका ऐप्लिकेशन उस टोकन का इस्तेमाल करके एपीआई अनुरोध कर सकता है किसी उपयोगकर्ता खाते या सेवा खाते की तरफ़ से. उपयोगकर्ता के हिसाब से अनुमति देने वाले क्रेडेंशियल का इस्तेमाल करना को कॉल करने के लिए एक सर्विस ऑब्जेक्ट बनाया जा सकता है. इसके बाद, उस ऑब्जेक्ट का इस्तेमाल अनुमति वाले एपीआई अनुरोध.

1. जिस एपीआई को कॉल करना है उसके लिए सेवा ऑब्जेक्ट बनाएं. उदाहरण के लिए, YouTube Data API के वर्शन 3 को कॉल करने के लिए:

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

   अभी तक किसी भी व्यक्ति ने चेक इन नहीं किया है
2. सेवा के लिए क्रेडेंशियल सेट करें:

   youtube.authorization = credentials

   अभी तक किसी भी व्यक्ति ने चेक इन नहीं किया है
3. एपीआई सेवा से अनुरोध करने के लिए, इंटरफ़ेस सेवा ऑब्जेक्ट से मिलता है. उदाहरण के लिए, अनुमति पा चुके उपयोगकर्ता के YouTube चैनल का डेटा वापस पाने के लिए:

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

   अभी तक किसी भी व्यक्ति ने चेक इन नहीं किया है

वैकल्पिक रूप से, किसी तरीके के लिए options पैरामीटर:

channel = youtube.list_channels(part, :mine => mine, options: { authorization: auth_client })

Node.js

ऐक्सेस टोकन पाने और उसे OAuth2 ऑब्जेक्ट पर सेट करने के बाद, ऑब्जेक्ट का इस्तेमाल करें का इस्तेमाल करें. आपका ऐप्लिकेशन उस टोकन का इस्तेमाल करके, उसकी तरफ़ से एपीआई अनुरोधों को अनुमति दे सकता है कोई उपयोगकर्ता खाता या सेवा खाता. जिस एपीआई को कॉल करना है उसके लिए सेवा ऑब्जेक्ट बनाएं.

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

एचटीटीपी/REST

जब आपके ऐप्लिकेशन को ऐक्सेस टोकन मिल जाता है, तब आपके पास इस टोकन का इस्तेमाल करके, Google को कॉल करने का विकल्प होता है किसी दिए गए प्रतिनिधि की ओर से API उपयोगकर्ता खाते के लिए. ऐसा करने के लिए, शामिल करें एपीआई को किए गए अनुरोध में access_token क्वेरी शामिल करके, ऐक्सेस टोकन पैरामीटर या Authorization एचटीटीपी हेडर Bearer वैल्यू. जब मुमकिन हो, एचटीटीपी हेडर को प्राथमिकता दी जाती है, क्योंकि सर्वर लॉग में क्वेरी स्ट्रिंग अक्सर दिखती हैं. ज़्यादातर मामलों में आप Google API पर अपने कॉल सेट अप करने के लिए क्लाइंट लाइब्रेरी का उपयोग कर सकते हैं (उदाहरण के लिए, YouTube Data API को कॉल करते हैं).

ध्यान दें कि YouTube Data API, सिर्फ़ YouTube के सेवा खातों के साथ काम करता है ऐसे कॉन्टेंट मालिक जो एक से ज़्यादा YouTube चैनलों के मालिक हैं और उन्हें मैनेज करते हैं. जैसे, रिकॉर्ड लेबल और फ़िल्म स्टूडियो शामिल हैं.

आप सभी Google API को आज़मा सकते हैं और यहां पर उनके दायरे देख सकते हैं OAuth 2.0 Playground.

एचटीटीपी जीईटी के उदाहरण

एक कॉल youtube.channels Authorization: Bearer एचटीटीपी का इस्तेमाल करने वाला एंडपॉइंट (YouTube Data API) हेडर ऐसा दिख सकता है. ध्यान दें कि आपको अपना ऐक्सेस टोकन बताना होगा:

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

यहां access_token का इस्तेमाल करके, पुष्टि किए गए उपयोगकर्ता के लिए उसी एपीआई को कॉल किया गया है क्वेरी स्ट्रिंग पैरामीटर:

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

curl के उदाहरण

curl कमांड-लाइन ऐप्लिकेशन का इस्तेमाल करके, इन कमांड की जांच की जा सकती है. यह रही उदाहरण के लिए, जो एचटीटीपी हेडर विकल्प का इस्तेमाल करता है (प्राथमिकता दी जाती है):

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

इसके अलावा, क्वेरी स्ट्रिंग पैरामीटर विकल्प:

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

PHP

इस उदाहरण को चलाने के लिए:

1. API Consoleमें, लोकल मशीन का यूआरएल दिए गए हैं. उदाहरण के लिए, http://localhost:8080 जोड़ें.
2. नई डायरेक्ट्री बनाएं और उसमें बदलाव करें. जैसे:

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

   अभी तक किसी भी व्यक्ति ने चेक इन नहीं किया है
3. Google API क्लाइंट इंस्टॉल करें कंपोज़र का इस्तेमाल करने वाले PHP के लिए:

   composer require google/apiclient:^2.10

4. कॉन्टेंट का इस्तेमाल करके index.php और oauth2callback.php फ़ाइलें बनाएं देखें.
5. उदाहरण को PHP सेवा के लिए कॉन्फ़िगर किए गए वेब सर्वर के साथ चलाएं. अगर PHP 5.6 या इसके बाद के वर्शन का इस्तेमाल किया जाता है, तो PHP के बिल्ट-इन टेस्ट वेब सर्वर का इस्तेमाल कर सकता है:

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

   अभी तक किसी भी व्यक्ति ने चेक इन नहीं किया है

index.php

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

session_start();

$client = new Google\Client();
$client->setAuthConfig('client_secrets.json');
$client->addScope(GOOGLE_SERVICE_YOUTUBE::YOUTUBE_FORCE_SSL);

if (isset($_SESSION['access_token']) && $_SESSION['access_token']) {
  $client->setAccessToken($_SESSION['access_token']);
  $youtube = new Google_Service_YouTube($client);
  $channel = $youtube->channels->listChannels('snippet', array('mine' => $mine));
  echo json_encode($channel);
} else {
  $redirect_uri = 'http://' . $_SERVER['HTTP_HOST'] . '/oauth2callback.php';
  header('Location: ' . filter_var($redirect_uri, FILTER_SANITIZE_URL));
}

oauth2callback.php

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

session_start();

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

if (! isset($_GET['code'])) {
  // Generate and set state value
  $state = bin2hex(random_bytes(16));
  $client->setState($state);
  $_SESSION['state'] = $state;

  $auth_url = $client->createAuthUrl();
  header('Location: ' . filter_var($auth_url, FILTER_SANITIZE_URL));
} else {
  // Check the state value
  if (!isset($_GET['state']) || $_GET['state'] !== $_SESSION['state']) {
    die('State mismatch. Possible CSRF attack.');
  }
  $client->authenticate($_GET['code']);
  $_SESSION['access_token'] = $client->getAccessToken();
  $redirect_uri = 'http://' . $_SERVER['HTTP_HOST'] . '/';
  header('Location: ' . filter_var($redirect_uri, FILTER_SANITIZE_URL));
}

Python

इस उदाहरण में, Flask फ़्रेमवर्क का इस्तेमाल किया गया है. यह http://localhost:8080 पर वेब ऐप्लिकेशन चलाता है, जो आपको OAuth 2.0 की जांच करने देता है फ़्लो. अगर आपको उस यूआरएल पर जाना है, तो आपको चार लिंक दिखेंगे:

• एपीआई अनुरोध की जांच करना: यह लिंक, उस पेज पर ले जाता है जो एपीआई के सैंपल को चलाने की कोशिश करता है अनुरोध. ज़रूरत पड़ने पर, पुष्टि करने की प्रोसेस शुरू हो जाती है. सफल होने पर, पेज एपीआई से मिला रिस्पॉन्स.
• सीधे पुष्टि करने के फ़्लो की जांच करना: यह लिंक उस पेज पर ले जाता है जो उपयोगकर्ता को भेजने की कोशिश करता है ऑथराइज़ेशन फ़्लो की मदद से. ऐप्लिकेशन इसके लिए अनुमति का अनुरोध करता है उपयोगकर्ता की ओर से अनुमति वाले एपीआई अनुरोध सबमिट करें.
• मौजूदा क्रेडेंशियल रद्द करना: यह लिंक उस पेज पर ले जाता है जहां उपयोगकर्ता की ओर से ऐप्लिकेशन को पहले से दी गई अनुमतियों को रद्द करता है.
• फ़्लैस्क सेशन क्रेडेंशियल मिटाएं: यह लिंक अनुमति देने वाले वे क्रेडेंशियल हटा देता है जो फ़्लास्क सेशन में सेव हो जाता है. इससे आप यह देख सकेंगे कि यदि कोई उपयोगकर्ता, जो पहले ही ने आपके ऐप्लिकेशन को अनुमति दी है और नए सेशन में एपीआई अनुरोध पर काम करने की कोशिश की है. इसकी मदद से, आपको एपीआई रिस्पॉन्स दिखेगा कि अगर उपयोगकर्ता ने आपकी दी हुई अनुमतियों को वापस ले लिया हो, तो आपके ऐप्लिकेशन को मिलने वाला रिस्पॉन्स डाउनलोड हो चुका है और आपके ऐप्लिकेशन ने अब भी निरस्त ऐक्सेस टोकन वाले अनुरोध को अनुमति देने की कोशिश की है.

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

import os
import flask
import requests

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

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

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

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


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


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

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

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

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

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

  return flask.jsonify(**channel)


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

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

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

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

  return flask.redirect(authorization_url)


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

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

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

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

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


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

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

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

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


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


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

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


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

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

Ruby

इस उदाहरण में, Sinatra फ़्रेमवर्क का इस्तेमाल किया गया है.

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

configure do
  enable :sessions

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

get '/' do
  user_id = settings.client_id.id
  credentials = settings.authorizer.get_credentials(user_id, request)
  if credentials.nil?
    redirect settings.authorizer.get_authorization_url(login_hint: user_id, request: request)
  end
  youtube = Google::Apis::YoutubeV3::YouTubeService.new
  channel = youtube.list_channels(part, :mine => mine, options: { authorization: auth_client })
  
  "<pre>#{JSON.pretty_generate(channel.to_h)}</pre>"
end

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

Node.js

इस उदाहरण को चलाने के लिए:

1. API Consoleमें, इसका यूआरएल जोड़ें स्थानीय मशीन में जोड़ दिया जाएगा. उदाहरण के लिए, जोड़ें http://localhost.
2. पक्का करें कि आपके पास रखरखाव एलटीएस, चालू एलटीएस या मौजूदा रिलीज़ Node.js इंस्टॉल हो गया है.
3. नई डायरेक्ट्री बनाएं और उसमें बदलाव करें. जैसे:

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

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

   npm install googleapis

   अभी तक किसी भी व्यक्ति ने चेक इन नहीं किया है
5. नीचे दिए गए कॉन्टेंट के साथ main.js फ़ाइलें बनाएं.
6. उदाहरण चलाएं:

   node .\main.js

   अभी तक किसी भी व्यक्ति ने चेक इन नहीं किया है

main.js

const http = require('http');
const https = require('https');
const url = require('url');
const { google } = require('googleapis');
const crypto = require('crypto');
const express = require('express');
const session = require('express-session');

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

// Access scopes for read-only Drive activity.
const scopes = [
  'https://www.googleapis.com/auth/drive.metadata.readonly'
];
/* Global variable that stores user credential in this code example.
 * ACTION ITEM for developers:
 *   Store user's refresh token in your data store if
 *   incorporating this code into your real app.
 *   For more information on handling refresh tokens,
 *   see https://github.com/googleapis/google-api-nodejs-client#handling-refresh-tokens
 */
let userCredential = null;

async function main() {
  const app = express();

  app.use(session({
    secret: 'your_secure_secret_key', // Replace with a strong secret
    resave: false,
    saveUninitialized: false,
  }));

  // Example on redirecting user to Google's OAuth 2.0 server.
  app.get('/', async (req, res) => {
    // Generate a secure random state value.
    const state = crypto.randomBytes(32).toString('hex');
    // Store state in the session
    req.session.state = state;

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

    res.redirect(authorizationUrl);
  });

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

    if (q.error) { // An error response e.g. error=access_denied
      console.log('Error:' + q.error);
    } else if (q.state !== req.session.state) { //check state value
      console.log('State mismatch. Possible CSRF attack');
      res.end('State mismatch. Possible CSRF attack');
    } else { // Get access and refresh tokens (if access_type is offline)
      let { tokens } = await oauth2Client.getToken(q.code);
      oauth2Client.setCredentials(tokens);

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

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

  // Example on revoking a token
  app.get('/revoke', async (req, res) => {
    // Build the string for the POST request
    let postData = "token=" + userCredential.access_token;

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

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

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

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


  const server = http.createServer(app);
  server.listen(80);
}
main().catch(console.error);

एचटीटीपी/REST

Python के इस उदाहरण में Flask फ़्रेमवर्क का इस्तेमाल किया गया है 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()

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

एचटीटीपी/REST

इस उदाहरण में, कॉल करने वाला ऐप्लिकेशन, YouTube Analytics में मौजूद डेटा के अलावा, उपयोगकर्ता को मिलने वाले अन्य ऐक्सेस ने पहले ही एप् लिकेशन को अनुमति दे दी है.

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

      

PHP

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

$client->setAccessType("offline");

जब कोई उपयोगकर्ता, अनुरोध किए गए दायरों का ऑफ़लाइन ऐक्सेस देता है, तब आपके पास एपीआई का इस्तेमाल जारी रखने का विकल्प होता है जब उपयोगकर्ता ऑफ़लाइन हो, तो उपयोगकर्ता की ओर से 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')

जब कोई उपयोगकर्ता, अनुरोध किए गए दायरों का ऑफ़लाइन ऐक्सेस देता है, तब आपके पास एपीआई का इस्तेमाल जारी रखने का विकल्प होता है जब उपयोगकर्ता ऑफ़लाइन हो, तो उपयोगकर्ता की ओर से Google API ऐक्सेस करने के लिए क्लाइंट. क्लाइंट ऑब्जेक्ट ज़रूरत के हिसाब से ऐक्सेस टोकन को रीफ़्रेश करेगा.

Ruby

अगर आपके ऐप्लिकेशन को किसी Google API को ऑफ़लाइन ऐक्सेस करने की ज़रूरत है, तो एपीआई क्लाइंट का ऐक्सेस टाइप इस पर सेट करें offline:

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

जब कोई उपयोगकर्ता, अनुरोध किए गए दायरों का ऑफ़लाइन ऐक्सेस देता है, तब आपके पास एपीआई का इस्तेमाल जारी रखने का विकल्प होता है जब उपयोगकर्ता ऑफ़लाइन हो, तो उपयोगकर्ता की ओर से Google API ऐक्सेस करने के लिए क्लाइंट. क्लाइंट ऑब्जेक्ट ज़रूरत के हिसाब से ऐक्सेस टोकन को रीफ़्रेश करेगा.

Node.js

अगर आपके ऐप्लिकेशन को किसी Google 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
});

जब कोई उपयोगकर्ता, अनुरोध किए गए दायरों का ऑफ़लाइन ऐक्सेस देता है, तब आपके पास एपीआई का इस्तेमाल जारी रखने का विकल्प होता है जब उपयोगकर्ता ऑफ़लाइन हो, तो उपयोगकर्ता की ओर से 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`
});

क्लाइंट को रीफ़्रेश टोकन मिलने के बाद, ऐक्सेस टोकन अपने-आप हासिल और रीफ़्रेश हो जाएंगे एपीआई के अगले कॉल में.

एचटीटीपी/REST

ऐक्सेस टोकन को रीफ़्रेश करने के लिए, आपका ऐप्लिकेशन एचटीटीपीएस POST भेजता है Google के ऑथराइज़ेशन सर्वर (https://oauth2.googleapis.com/token) से अनुरोध करेगा कि इसमें ये पैरामीटर शामिल होते हैं:

नीचे दिए गए स्निपेट में, अनुरोध का एक सैंपल दिखाया गया है:

POST /token HTTP/1.1
Host: oauth2.googleapis.com
Content-Type: application/x-www-form-urlencoded

client_id=your_client_id&
client_secret=your_client_secret&
refresh_token=refresh_token&
grant_type=refresh_token

जब तक उपयोगकर्ता, ऐप्लिकेशन को दिया गया ऐक्सेस रद्द नहीं करता, तब तक टोकन सर्वर JSON ऑब्जेक्ट दिखाता है, जिसमें नया ऐक्सेस टोकन होता है. नीचे दिया गया स्निपेट एक सैंपल दिखाता है जवाब:

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

ध्यान दें कि जारी किए जाने वाले रीफ़्रेश टोकन की संख्या सीमित है; एक सीमा प्रति और सभी क्लाइंट में हर उपयोगकर्ता के हिसाब से एक-दूसरे का इस्तेमाल करना होगा. आपको रीफ़्रेश टोकन सेव करने चाहिए और उनका इस्तेमाल तब तक करते रहें, जब तक वे मान्य हों. अगर आपका आवेदन बहुत ज़्यादा रीफ़्रेश टोकन का अनुरोध करता है, तो वह इन सीमाओं का सामना कर सकता है. इस स्थिति में पुराने रीफ़्रेश टोकन काम करना बंद कर देगी.

PHP

प्रोग्राम के हिसाब से टोकन को रद्द करने के लिए, revokeToken() को कॉल करें:

$client->revokeToken();

Python

किसी टोकन को प्रोग्राम के हिसाब से रद्द करने के लिए, https://oauth2.googleapis.com/revoke, जो पैरामीटर के रूप में टोकन शामिल करता है और Content-Type हेडर:

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

Ruby

किसी टोकन को प्रोग्राम के हिसाब से रद्द करने के लिए, oauth2.revoke को एचटीटीपी अनुरोध करें एंडपॉइंट:

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

टोकन, ऐक्सेस टोकन या रीफ़्रेश टोकन हो सकता है. अगर टोकन एक ऐक्सेस टोकन है और उसमें तो रीफ़्रेश टोकन को भी निरस्त कर दिया जाएगा.

अगर सहमति रद्द हो गई है, तो रिस्पॉन्स का स्टेटस कोड यह होता है 200. गड़बड़ी की शर्तों के लिए, स्टेटस कोड 400 के साथ गड़बड़ी कोड.

Node.js

किसी टोकन को प्रोग्राम के हिसाब से रद्द करने के लिए, /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();

टोकन पैरामीटर, ऐक्सेस टोकन या रीफ़्रेश टोकन हो सकता है. अगर टोकन एक ऐक्सेस टोकन है और उसमें तो रीफ़्रेश टोकन को भी निरस्त कर दिया जाएगा.

अगर सहमति रद्द हो गई है, तो रिस्पॉन्स का स्टेटस कोड यह होता है 200. गड़बड़ी की शर्तों के लिए, स्टेटस कोड 400 के साथ गड़बड़ी कोड.

एचटीटीपी/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}

टोकन, ऐक्सेस टोकन या रीफ़्रेश टोकन हो सकता है. अगर टोकन एक ऐक्सेस टोकन है और उसमें प्रासंगिक रीफ़्रेश टोकन के रूप में, तो रीफ़्रेश टोकन को भी निरस्त कर दिया जाएगा.

अगर सहमति रद्द हो गई है, तो रिस्पॉन्स का एचटीटीपी स्टेटस कोड यह होगा 200. गड़बड़ी की स्थितियों के लिए, एक एचटीटीपी स्टेटस कोड 400 दिखाया जाता है डालें.