इस दस्तावेज़ में बताया गया है कि YouTube Analytics API या YouTube Reporting API को ऐक्सेस करने के लिए, OAuth 2.0 की अनुमति लागू करने के लिए वेब सर्वर ऐप्लिकेशन, Google API क्लाइंट लाइब्रेरी या Google OAuth 2.0 एंडपॉइंट का इस्तेमाल कैसे करते हैं.
OAuth 2.0 की मदद से, उपयोगकर्ता किसी ऐप्लिकेशन के साथ खास डेटा शेयर कर सकते हैं. हालांकि, इस दौरान उनके उपयोगकर्ता नाम, पासवर्ड, और अन्य जानकारी को निजी रखा जाता है. उदाहरण के लिए, किसी चैनल के YouTube Analytics डेटा को वापस पाने की अनुमति पाने के लिए, ऐप्लिकेशन OAuth 2.0 का इस्तेमाल कर सकता है.
यह OAuth 2.0 फ़्लो, खास तौर पर उपयोगकर्ता की अनुमति के लिए है. इसे ऐसे ऐप्लिकेशन के लिए डिज़ाइन किया गया है जो गोपनीय जानकारी सेव कर सकते हैं और स्थिति बनाए रख सकते हैं. उपयोगकर्ता के ऐप्लिकेशन से इंटरैक्ट करने या ऐप्लिकेशन छोड़ने के बाद, एक सही तरीके से अनुमति वाला वेब सर्वर ऐप्लिकेशन, एपीआई को ऐक्सेस कर सकता है.
वेब सर्वर ऐप्लिकेशन, एपीआई अनुरोधों को अनुमति देने के लिए अक्सर सेवा खातों का भी इस्तेमाल करते हैं. खास तौर पर, ऐसा तब होता है, जब उपयोगकर्ता के खास डेटा के बजाय प्रोजेक्ट-आधारित डेटा को ऐक्सेस करने के लिए Cloud API को कॉल किया जाता है. वेब सर्वर ऐप्लिकेशन, उपयोगकर्ता की अनुमति के साथ सेवा खातों का इस्तेमाल कर सकते हैं.
- YouTube Analytics API, सेवा खाते के फ़्लो के साथ काम नहीं करता.
- YouTube Reporting API, YouTube पर कॉन्टेंट के सिर्फ़ उन मालिकों के लिए सेवा खाता फ़्लो के साथ काम करता है जो एक से ज़्यादा YouTube चैनलों के मालिक हैं और उन्हें मैनेज करते हैं.
खास तौर पर, कॉन्टेंट के मालिक एपीआई अनुरोधों में सेवा खातों का इस्तेमाल कर सकते हैं. ये खाते,
onBehalfOfContentOwner
अनुरोध के पैरामीटर के लिए वैल्यू सेट करते हैं.
क्लाइंट लाइब्रेरी
इस पेज पर अलग-अलग भाषा के हिसाब से दिए गए उदाहरणों में, OAuth 2.0 की अनुमति लागू करने के लिए, Google API क्लाइंट लाइब्रेरी का इस्तेमाल किया गया है. कोड के सैंपल चलाने के लिए, आपको पहले अपनी भाषा के लिए क्लाइंट लाइब्रेरी इंस्टॉल करनी होगी.
अपने ऐप्लिकेशन के OAuth 2.0 फ़्लो को मैनेज करने के लिए, Google API क्लाइंट लाइब्रेरी का इस्तेमाल करने पर, क्लाइंट लाइब्रेरी ऐसी कई कार्रवाइयां करती है जिन्हें ऐप्लिकेशन को खुद मैनेज करना पड़ता है. उदाहरण के लिए, यह तय करता है कि ऐप्लिकेशन कब सेव किए गए ऐक्सेस टोकन को इस्तेमाल या रीफ़्रेश कर सकता है. साथ ही, यह भी तय करता है कि ऐप्लिकेशन को कब सहमति लेनी होगी. क्लाइंट लाइब्रेरी सही रीडायरेक्ट यूआरएल भी जनरेट करती है. साथ ही, इससे ऐसे रीडायरेक्ट हैंडलर लागू करने में मदद मिलती है जो ऐक्सेस टोकन के लिए ऑथराइज़ेशन कोड एक्सचेंज करते हैं.
सर्वर-साइड ऐप्लिकेशन के लिए Google API क्लाइंट लाइब्रेरी इन भाषाओं में उपलब्ध है:
ज़रूरी शर्तें
अपने प्रोजेक्ट के लिए एपीआई चालू करना
Google API को कॉल करने वाले किसी भी ऐप्लिकेशन को, API Consoleमें उन एपीआई को चालू करना होगा.
अपने प्रोजेक्ट के लिए एपीआई चालू करने के लिए:
- Google API Consoleमें Open the API Library .
- If prompted, select a project, or create a new one.
- YouTube Analytics API और YouTube Reporting API को ढूंढने और चालू करने के लिए, लाइब्रेरी पेज का इस्तेमाल करें. YouTube Analytics का डेटा हासिल करने वाले कई ऐप्लिकेशन, YouTube Data API की मदद से भी काम करते हैं. ऐसे कोई दूसरे एपीआई ढूंढें जिनका इस्तेमाल आपका ऐप्लिकेशन करेगा और उन्हें भी चालू करें.
अनुमति देने वाले क्रेडेंशियल बनाएं
Google API को ऐक्सेस करने के लिए OAuth 2.0 का इस्तेमाल करने वाले किसी भी ऐप्लिकेशन में, ऐसे ऑथराइज़ेशन क्रेडेंशियल होने चाहिए जिनसे Google के OAuth 2.0 सर्वर पर ऐप्लिकेशन की पहचान की जा सके. अपने प्रोजेक्ट के लिए क्रेडेंशियल बनाने का तरीका यहां बताया गया है. इसके बाद, आपके ऐप्लिकेशन उन एपीआई को ऐक्सेस करने के लिए क्रेडेंशियल का इस्तेमाल कर सकते हैं जिन्हें आपने उस प्रोजेक्ट के लिए चालू किया है.
- Go to the Credentials page.
- क्रेडेंशियल बनाएं > OAuth क्लाइंट आईडी पर क्लिक करें.
- वेब ऐप्लिकेशन ऐप्लिकेशन का प्रकार चुनें.
- फ़ॉर्म भरें और बनाएं पर क्लिक करें. PHP, Java, Python, Ruby, और .NET जैसी भाषाओं और फ़्रेमवर्क का इस्तेमाल करने वाले ऐप्लिकेशन में, अनुमति वाले रीडायरेक्ट यूआरआई की जानकारी देनी होगी. रीडायरेक्ट यूआरआई ऐसे एंडपॉइंट होते हैं जिन पर OAuth 2.0 सर्वर जवाब भेज सकता है. इन एंडपॉइंट को
पुष्टि करने के लिए Google के नियमों का पालन करना होगा.
जांच के लिए, ऐसे यूआरआई तय किए जा सकते हैं जो लोकल मशीन से जुड़े होते हैं, जैसे कि
http://localhost:8080
. इसे ध्यान में रखते हुए, कृपया ध्यान दें कि इस दस्तावेज़ में दिए गए सभी उदाहरणों में, रीडायरेक्ट यूआरआई के तौर परhttp://localhost:8080
का इस्तेमाल किया गया है.हमारा सुझाव है कि आप अपने ऐप्लिकेशन के पुष्टि करने वाले एंडपॉइंट डिज़ाइन करें, ताकि आपका ऐप्लिकेशन पेज पर मौजूद दूसरे संसाधनों को अनुमति कोड न दिखाए.
अपने क्रेडेंशियल बनाने के बाद, API Consoleसे client_secret.json फ़ाइल डाउनलोड करें. फ़ाइल को ऐसी जगह पर सुरक्षित रूप से सेव करें जहां सिर्फ़ आपका ऐप्लिकेशन उसे ऐक्सेस कर सके.
ऐक्सेस के दायरों की पहचान करना
स्कोप की सुविधा का इस्तेमाल करके आपका ऐप्लिकेशन, सिर्फ़ उन संसाधनों का ऐक्सेस मांग सकता है जिनकी उसे ज़रूरत है. साथ ही, उपयोगकर्ता आपके ऐप्लिकेशन को दिए गए ऐक्सेस की सीमा को कंट्रोल कर सकते हैं. इसलिए, अनुरोध किए गए दायरों की संख्या और उपयोगकर्ता की सहमति लेने की संभावना, अलग-अलग हो सकती है.
हमारा सुझाव है कि OAuth 2.0 की अनुमति देने की सुविधा लागू करने से पहले, आप उन दायरों का पता लगा लें जिन्हें ऐक्सेस करने के लिए आपके ऐप्लिकेशन को अनुमति की ज़रूरत होगी.
हम यह भी सुझाव देते हैं कि आपका ऐप्लिकेशन, इंक्रीमेंटल ऑथराइज़ेशन प्रोसेस के ज़रिए, अनुमति के स्कोप के ऐक्सेस का अनुरोध करे. इस प्रोसेस में आपका ऐप्लिकेशन, उपयोगकर्ता के डेटा के ऐक्सेस का अनुरोध करता है. इस सबसे सही तरीके से, उपयोगकर्ताओं को यह समझने में मदद मिलती है कि आपके ऐप्लिकेशन को जिस ऐक्सेस का अनुरोध करना है उसकी ज़रूरत क्यों है.
YouTube Analytics API इन दायरों का इस्तेमाल करता है:
कार्यक्षेत्र | |
---|---|
https://www.googleapis.com/auth/youtube | अपना YouTube खाता प्रबंधित करें |
https://www.googleapis.com/auth/youtube.readonly | अपना YouTube खाता देखें |
https://www.googleapis.com/auth/youtubepartner | YouTube पर अपनी संपत्ति और संबंधित सामग्री देखें और प्रबंधित करें |
https://www.googleapis.com/auth/yt-analytics-monetary.readonly | अपनी YouTube सामग्री के लिए मौद्रिक और गैर-मौद्रिक YouTube Analytics रिपोर्ट देखें |
https://www.googleapis.com/auth/yt-analytics.readonly | अपनी YouTube सामग्री के लिए YouTube Analytics रिपोर्ट देखें |
YouTube Reporting API, इन दायरों का इस्तेमाल करता है:
कार्यक्षेत्र | |
---|---|
https://www.googleapis.com/auth/yt-analytics-monetary.readonly | अपनी YouTube सामग्री के लिए मौद्रिक और गैर-मौद्रिक YouTube Analytics रिपोर्ट देखें |
https://www.googleapis.com/auth/yt-analytics.readonly | अपनी YouTube सामग्री के लिए YouTube Analytics रिपोर्ट देखें |
OAuth 2.0 एपीआई के दायरे दस्तावेज़ में, उन दायरों की पूरी सूची है जिनका इस्तेमाल Google API को ऐक्सेस करने के लिए किया जा सकता है.
भाषा के हिसाब से ज़रूरी शर्तें
इस दस्तावेज़ में मौजूद किसी भी कोड सैंपल को चलाने के लिए, आपके पास Google खाता, इंटरनेट, और वेब ब्राउज़र होना ज़रूरी है. अगर किसी एपीआई क्लाइंट लाइब्रेरी का इस्तेमाल किया जा रहा है, तो भाषा के हिसाब से नीचे दी गई ज़रूरी शर्तें भी देखें.
PHP
इस दस्तावेज़ में PHP कोड के नमूने चलाने के लिए, आपको इनकी ज़रूरत होगी:
- कमांड-लाइन इंटरफ़ेस (CLI) और JSON एक्सटेंशन के साथ PHP 5.6 या इससे बड़ा वर्शन.
- Composer डिपेंडेंसी मैनेजमेंट टूल.
-
PHP के लिए Google API क्लाइंट लाइब्रेरी:
composer require google/apiclient:^2.10
Python
इस दस्तावेज़ में Python कोड के सैंपल चलाने के लिए, आपको इनकी ज़रूरत होगी:
- Python 2.6 या इससे नया वर्शन
- pip पैकेज मैनेजमेंट टूल.
- Python के लिए Google API क्लाइंट लाइब्रेरी:
pip install --upgrade google-api-python-client
- उपयोगकर्ता की अनुमति के लिए
google-auth
,google-auth-oauthlib
, औरgoogle-auth-httplib2
.pip install --upgrade google-auth google-auth-oauthlib google-auth-httplib2
- 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 एंडपॉइंट को कॉल करने के लिए, आपको कोई लाइब्रेरी इंस्टॉल करने की ज़रूरत नहीं है.
OAuth 2.0 ऐक्सेस टोकन पाना
यहां दिए गए चरण में बताया गया है कि आपका ऐप्लिकेशन, Google के OAuth 2.0 सर्वर के साथ कैसे इंटरैक्ट करता है. इससे, उपयोगकर्ता की ओर से एपीआई अनुरोध करने के लिए, उपयोगकर्ता की सहमति ली जा सकती है. आपके ऐप्लिकेशन के पास यह सहमति होनी चाहिए. इसके बाद ही वह Google API के किसी ऐसे अनुरोध पर कार्रवाई कर सकता है जिसके लिए उपयोगकर्ता की अनुमति की ज़रूरत होती है.
नीचे दी गई सूची में इन चरणों का तुरंत सारांश दिया गया है:
- आपका ऐप्लिकेशन उन अनुमतियों की पहचान करता है जिनकी उसे ज़रूरत होती है.
- आपका ऐप्लिकेशन, अनुरोध की गई अनुमतियों की सूची के साथ, उपयोगकर्ता को Google पर रीडायरेक्ट करता है.
- उपयोगकर्ता तय करता है कि आपके ऐप्लिकेशन को अनुमतियां देनी हैं या नहीं.
- आपके ऐप्लिकेशन से पता चलता है कि उपयोगकर्ता ने क्या फ़ैसला लिया.
- अगर उपयोगकर्ता ने अनुरोध की गई अनुमतियां दी हैं, तो आपका ऐप्लिकेशन, उपयोगकर्ता की ओर से एपीआई अनुरोध करने के लिए ज़रूरी टोकन फिर से हासिल करता है.
पहला चरण: अनुमति देने वाले पैरामीटर सेट करना
सबसे पहले, अनुमति पाने के लिए अनुरोध करें. वह अनुरोध ऐसे पैरामीटर सेट करता है जो आपके ऐप्लिकेशन की पहचान करते हैं और उन अनुमतियों को तय करते हैं जो उपयोगकर्ता से आपके ऐप्लिकेशन के लिए देने के लिए कहा जाएगा.
- अगर OAuth 2.0 की पुष्टि करने और अनुमति देने के लिए, Google क्लाइंट लाइब्रेरी का इस्तेमाल किया जाता है, तो इन पैरामीटर के बारे में बताने वाला कोई ऑब्जेक्ट बनाया और कॉन्फ़िगर किया जा सकता है.
- अगर Google OAuth 2.0 एंडपॉइंट को सीधे कॉल किया जाता है, तो आपको एक यूआरएल जनरेट करना होगा और उस यूआरएल के लिए पैरामीटर सेट करने होंगे.
नीचे दिए गए टैब, वेब सर्वर ऐप्लिकेशन के लिए काम करने वाले ऑथराइज़ेशन पैरामीटर को तय करते हैं. किसी खास भाषा के लिए बने उदाहरणों में, यह भी दिखाया गया है कि क्लाइंट लाइब्रेरी या अनुमति वाली लाइब्रेरी का इस्तेमाल करके, उन पैरामीटर को सेट करने वाले ऑब्जेक्ट को कैसे कॉन्फ़िगर किया जाए.
PHP
नीचे दिया गया कोड स्निपेट एक Google\Client()
ऑब्जेक्ट बनाता है, जो अनुमति देने के अनुरोध में मौजूद पैरामीटर के बारे में बताता है.
वह ऑब्जेक्ट, आपके ऐप्लिकेशन की पहचान करने के लिए, आपकी client_secret.json फ़ाइल में मौजूद जानकारी
का इस्तेमाल करता है. (उस फ़ाइल के बारे में ज़्यादा जानने के लिए, अनुमति देने के क्रेडेंशियल बनाना देखें.) ऑब्जेक्ट उन दायरों की पहचान करता है जिनके लिए आपका ऐप्लिकेशन, ऐक्सेस करने की अनुमति
का अनुरोध कर रहा है. साथ ही, यह आपके ऐप्लिकेशन के पुष्टि करने वाले एंडपॉइंट के यूआरएल की भी पहचान करता है, जो Google के OAuth 2.0 सर्वर से रिस्पॉन्स को हैंडल करेगा. आखिर में, कोड, वैकल्पिक access_type
और
include_granted_scopes
पैरामीटर सेट करता है.
उदाहरण के लिए, किसी उपयोगकर्ता की YouTube Analytics रिपोर्ट को फिर से पाने के लिए, उसे ऑफ़लाइन ऐक्सेस करने का अनुरोध करने के लिए:
$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_YouTubeAnalytics::YT_ANALYTICS_READONLY); // Required, call the setRedirectUri function to specify a valid redirect URI for the // provided client_id $client->setRedirectUri('http://' . $_SERVER['HTTP_HOST'] . '/oauth2callback.php'); // Recommended, offline access will give you both an access and refresh token so that // your app can refresh the access token without user interaction. $client->setAccessType('offline'); // Recommended, call the setState function. Using a state value can increase your assurance that // an incoming connection is the result of an authentication request. $client->setState($sample_passthrough_value); // Optional, if your application knows which user is trying to authenticate, it can use this // parameter to provide a hint to the Google Authentication Server. $client->setLoginHint('hint@example.com'); // Optional, call the setPrompt function to set "consent" will prompt the user for consent $client->setPrompt('consent'); // Optional, call the setIncludeGrantedScopes function with true to enable incremental // authorization $client->setIncludeGrantedScopes(true);
Python
नीचे दिया गया कोड स्निपेट, अनुमति देने का अनुरोध करने के लिए google-auth-oauthlib.flow
मॉड्यूल का इस्तेमाल करता है.
यह कोड एक Flow
ऑब्जेक्ट बनाता है. यह आपके ऐप्लिकेशन की पहचान करने के लिए, उस client_secret.json फ़ाइल में मौजूद जानकारी का इस्तेमाल करता है जिसे आपने ऑथराइज़ेशन क्रेडेंशियल बनाने के बाद
डाउनलोड किया था. यह ऑब्जेक्ट उन दायरों की पहचान करता है जिनके लिए आपका ऐप्लिकेशन, ऐक्सेस करने की अनुमति मांग रहा है. साथ ही, यह आपके ऐप्लिकेशन के पुष्टि करने वाले एंडपॉइंट के यूआरएल की भी पहचान करता है, जो Google के OAuth 2.0 सर्वर से रिस्पॉन्स को हैंडल करेगा. आखिर में, कोड
वैकल्पिक access_type
और include_granted_scopes
पैरामीटर सेट करता है.
उदाहरण के लिए, किसी उपयोगकर्ता की YouTube Analytics रिपोर्ट को फिर से पाने के लिए, उसे ऑफ़लाइन ऐक्सेस करने का अनुरोध करने के लिए:
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/yt-analytics.readonly']) # Required, indicate where the API server will redirect the user after the user completes # the authorization flow. The redirect URI is required. The value must exactly # match one of the authorized redirect URIs for the OAuth 2.0 client, which you # configured in the API Console. If this value doesn't match an authorized URI, # you will get a 'redirect_uri_mismatch' error. flow.redirect_uri = 'https://www.example.com/oauth2callback' # Generate URL for request to Google's OAuth 2.0 server. # Use kwargs to set optional request parameters. authorization_url, state = flow.authorization_url( # Recommended, enable offline access so that you can refresh an access token without # re-prompting the user for permission. Recommended for web server apps. access_type='offline', # Optional, enable incremental authorization. Recommended as a best practice. include_granted_scopes='true', # Optional, if your application knows which user is trying to authenticate, it can use this # parameter to provide a hint to the Google Authentication Server. login_hint='hint@example.com', # Optional, set prompt to 'consent' will prompt the user for consent prompt='consent')
Ruby
उस client_secrets.json फ़ाइल का इस्तेमाल करें जिसे आपने अपने ऐप्लिकेशन में क्लाइंट ऑब्जेक्ट को कॉन्फ़िगर करने के लिए बनाया था. किसी क्लाइंट ऑब्जेक्ट को कॉन्फ़िगर करने पर, आपको अपने ऐप्लिकेशन के ऐक्सेस के लिए ज़रूरी दायरे तय करने होते हैं. साथ ही, आपको अपने ऐप्लिकेशन के पुष्टि करने वाले एंडपॉइंट का यूआरएल भी देना होता है, जो OAuth 2.0 सर्वर से रिस्पॉन्स को हैंडल करेगा.
उदाहरण के लिए, किसी उपयोगकर्ता की YouTube Analytics रिपोर्ट को फिर से पाने के लिए, उसे ऑफ़लाइन ऐक्सेस करने का अनुरोध करने के लिए:
require 'google/apis/youtube_analytics_v1' 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/yt-analytics.readonly' token_store = Google::Auth::Stores::RedisTokenStore.new(redis: Redis.new) authorizer = Google::Auth::WebUserAuthorizer.new(client_id, scope, token_store, '/oauth2callback')
आपका ऐप्लिकेशन, OAuth 2.0 से जुड़ी कार्रवाइयां करने के लिए, क्लाइंट ऑब्जेक्ट का इस्तेमाल करता है. जैसे, अनुमति के अनुरोध के लिए यूआरएल जनरेट करना और एचटीटीपी अनुरोधों पर ऐक्सेस टोकन लागू करना.
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
पर है. इस एंडपॉइंट को सिर्फ़ एचटीटीपीएस से ऐक्सेस किया जा सकता है. सामान्य एचटीटीपी कनेक्शन अस्वीकार कर दिए गए हैं.
Google ऑथराइज़ेशन सर्वर, वेब सर्वर ऐप्लिकेशन के लिए इन क्वेरी स्ट्रिंग पैरामीटर के साथ काम करता है:
पैरामीटर | |||||||||||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
client_id |
ज़रूरी
आपके ऐप्लिकेशन का क्लाइंट आईडी. यह वैल्यू, आपको API Console Credentials pageमें मिलेगी. |
||||||||||||||||||
redirect_uri |
ज़रूरी
यह नीति तय करती है कि उपयोगकर्ता के ऑथराइज़ेशन फ़्लो को पूरा करने के बाद, एपीआई सर्वर, उपयोगकर्ता को कहां रीडायरेक्ट करता है. वैल्यू, उस OAuth 2.0 क्लाइंट के लिए, अनुमति वाले रीडायरेक्ट यूआरआई में से किसी एक
से पूरी तरह मेल खानी चाहिए. आपने इसे अपने क्लाइंट के
API Console
Credentials pageमें कॉन्फ़िगर किया है. अगर यह वैल्यू, दिए गए ध्यान दें कि |
||||||||||||||||||
response_type |
ज़रूरी
इससे यह तय होता है कि Google OAuth 2.0 एंडपॉइंट, ऑथराइज़ेशन कोड दिखाता है या नहीं. वेब सर्वर ऐप्लिकेशन के लिए, पैरामीटर की वैल्यू को |
||||||||||||||||||
scope |
ज़रूरी
दायरों की स्पेस-डीलिमिटेड सूची, जो उन संसाधनों की पहचान करती है जिन्हें आपका ऐप्लिकेशन, उपयोगकर्ता की ओर से ऐक्सेस कर सकता है. इन वैल्यू से उस स्क्रीन के बारे में पता चलता है जो Google, उपयोगकर्ता को दिखाता है. स्कोप की सुविधा का इस्तेमाल करके आपका ऐप्लिकेशन, सिर्फ़ उन संसाधनों का ऐक्सेस मांग सकता है जिनकी उसे ज़रूरत है. साथ ही, उपयोगकर्ता आपके ऐप्लिकेशन को दिए गए ऐक्सेस के लेवल को कंट्रोल कर सकते हैं. इसलिए, अनुरोध किए गए दायरों की संख्या और उपयोगकर्ता की सहमति पाने की संभावना, दोनों में बिलकुल उलट होता है. YouTube Analytics API इन दायरों का इस्तेमाल करता है:
YouTube Reporting API, इन दायरों का इस्तेमाल करता है:
OAuth 2.0 एपीआई के दायरे दस्तावेज़ में, उन दायरों की पूरी सूची मिलती है जिनका इस्तेमाल Google API को ऐक्सेस करने के लिए किया जा सकता है. हमारा सुझाव है कि जब भी मुमकिन हो, तब अपना ऐप्लिकेशन, अनुमति के दायरों के ऐक्सेस का अनुरोध करें. इंक्रीमेंटल ऑथराइज़ेशन के ज़रिए, ज़रूरत के हिसाब से उपयोगकर्ता के डेटा के ऐक्सेस का अनुरोध करें. इससे उपयोगकर्ताओं को यह समझने में मदद मिलती है कि आपके ऐप्लिकेशन को जिस ऐक्सेस का अनुरोध किया जा रहा है उसकी ज़रूरत क्यों है. |
||||||||||||||||||
access_type |
सुझाया गया
यह बताता है कि उपयोगकर्ता के ब्राउज़र में मौजूद न होने पर, आपका ऐप्लिकेशन ऐक्सेस टोकन को रीफ़्रेश कर सकता है या नहीं. मान्य पैरामीटर वैल्यू हैं: अगर उपयोगकर्ता के ब्राउज़र पर मौजूद न होने पर, आपके ऐप्लिकेशन को ऐक्सेस टोकन रीफ़्रेश करने की ज़रूरत पड़ती है, तो इसकी वैल्यू को |
||||||||||||||||||
state |
सुझाया गया
ऐसी किसी भी स्ट्रिंग वैल्यू के बारे में बताता है जिसका इस्तेमाल आपका ऐप्लिकेशन, अनुमति देने के आपके अनुरोध और उसके रिस्पॉन्स के बीच की स्थिति को बनाए रखने के लिए करता है.
सर्वर वही वैल्यू दिखाता है जिसे उपयोगकर्ता,
इस पैरामीटर का इस्तेमाल कई कामों के लिए किया जा सकता है. जैसे, अपने आवेदन में
उपयोगकर्ता को सही संसाधन पर ले जाना, नॉन्स भेजना, और दूसरी साइटों से किए जाने वाले जालसाज़ी के अनुरोधों को
कम करना. आपके |
||||||||||||||||||
include_granted_scopes |
ज़रूरी नहीं
ऐप्लिकेशन को अतिरिक्त दायरों के ऐक्सेस का अनुरोध करने के लिए,
इंंक्रीमेंटल अनुमति का इस्तेमाल करने की अनुमति देता है. अगर इस पैरामीटर की वैल्यू |
||||||||||||||||||
enable_granular_consent |
ज़रूरी नहीं
डिफ़ॉल्ट तौर पर, यह जब Google किसी ऐप्लिकेशन के लिए विस्तृत अनुमतियां चालू करता है, तो इस पैरामीटर का कोई असर नहीं होगा. |
||||||||||||||||||
login_hint |
ज़रूरी नहीं
अगर आपके ऐप्लिकेशन को पता है कि कौनसा उपयोगकर्ता पुष्टि करने की कोशिश कर रहा है, तो वह इस पैरामीटर का इस्तेमाल करके, Google के पुष्टि करने वाले सर्वर को संकेत दे सकता है. सर्वर इस संकेत का इस्तेमाल, लॉगिन फ़्लो को आसान बनाने के लिए या तो साइन-इन फ़ॉर्म में ईमेल फ़ील्ड को पहले से भरकर या एक से ज़्यादा लॉगिन वाले सही सेशन को चुनकर करता है. पैरामीटर की वैल्यू को किसी ईमेल पते या |
||||||||||||||||||
prompt |
ज़रूरी नहीं
उपयोगकर्ता को दिखाने के लिए प्रॉम्प्ट की स्पेस-डीलिमिटेड, केस-सेंसिटिव (बड़े और छोटे अक्षरों में अंतर) सूची. अगर इस पैरामीटर की जानकारी नहीं दी जाती है, तो उपयोगकर्ता को सिर्फ़ तब सूचना दी जाएगी, जब आपके प्रोजेक्ट के ऐक्सेस का अनुरोध किया जाएगा. ज़्यादा जानकारी के लिए, फिर से सहमति देने का प्रॉम्प्ट देखें. आपको ये वैल्यू दिख सकती हैं:
|
दूसरा चरण: Google के OAuth 2.0 सर्वर पर रीडायरेक्ट करना
पुष्टि करने और अनुमति देने की प्रोसेस शुरू करने के लिए, उपयोगकर्ता को Google के OAuth 2.0 सर्वर पर रीडायरेक्ट करें. आम तौर पर, ऐसा तब होता है, जब आपके ऐप्लिकेशन को पहली बार उपयोगकर्ता के डेटा को ऐक्सेस करने की ज़रूरत होती है. इंक्रीमेंटल ऑथराइज़ेशन के मामले में, यह चरण तब भी होता है, जब आपके ऐप्लिकेशन को पहली बार ऐसे अतिरिक्त संसाधनों को ऐक्सेस करने की ज़रूरत होती है जिन्हें ऐक्सेस करने की अनुमति उसके पास अभी तक नहीं है.
PHP
- Google के OAuth 2.0 सर्वर से ऐक्सेस का अनुरोध करने के लिए, एक यूआरएल जनरेट करें:
$auth_url = $client->createAuthUrl();
- उपयोगकर्ता को
$auth_url
पर रीडायरेक्ट करें:header('Location: ' . filter_var($auth_url, FILTER_SANITIZE_URL));
Python
इस उदाहरण में बताया गया है कि फ़्लास्क वेब ऐप्लिकेशन फ़्रेमवर्क का इस्तेमाल करके, उपयोगकर्ता को अनुमति वाले यूआरएल पर कैसे रीडायरेक्ट किया जाता है:
return flask.redirect(authorization_url)
Ruby
- Google के OAuth 2.0 सर्वर से ऐक्सेस का अनुरोध करने के लिए, एक यूआरएल जनरेट करें:
auth_uri = authorizer.get_authorization_url(login_hint: user_id, request: request)
- उपयोगकर्ता को
auth_uri
पर रीडायरेक्ट करें.
Node.js
-
Google के OAuth 2.0 सर्वर से ऐक्सेस का अनुरोध करने के लिए, पहले चरण के
generateAuthUrl
तरीके से जनरेट किए गए यूआरएलauthorizationUrl
का इस्तेमाल करें. -
उपयोगकर्ता को
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 retrieve
the user's YouTube Analytics reports. 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%2Fyt-analytics.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
अनुरोध यूआरएल बनाने के बाद, उपयोगकर्ता को उस पर रीडायरेक्ट करें.
Google का OAuth 2.0 सर्वर, उपयोगकर्ता की पुष्टि करता है. साथ ही, अनुरोध किए गए दायरों को ऐक्सेस करने के लिए, आपके ऐप्लिकेशन को उपयोगकर्ता की सहमति देता है. आपके दिए गए दूसरे वेबलिंक का इस्तेमाल करके, रिस्पॉन्स को आपके ऐप्लिकेशन पर वापस भेजा जाता है.
तीसरा चरण: Google, उपयोगकर्ता से सहमति लेने का अनुरोध करता है
इस चरण में, उपयोगकर्ता यह तय करता है कि आपके ऐप्लिकेशन को अनुरोध किया गया ऐक्सेस देना है या नहीं. इस चरण में, Google एक सहमति विंडो दिखाता है. इसमें आपके ऐप्लिकेशन और Google API सेवाओं का नाम दिखता है. इन सेवाओं को ऐक्सेस करने के लिए, Google उपयोगकर्ता के ऑथराइज़ेशन क्रेडेंशियल की मदद से अनुरोध करता है. साथ ही, ऐक्सेस के दायरों की खास जानकारी भी दिखाता है. इसके बाद, उपयोगकर्ता आपके ऐप्लिकेशन के अनुरोध किए गए एक या उससे ज़्यादा दायरों का ऐक्सेस देने के लिए सहमति दे सकता है या अनुरोध अस्वीकार कर सकता है.
आपके ऐप्लिकेशन को इस चरण में कुछ भी करने की ज़रूरत नहीं है, क्योंकि वह Google के OAuth 2.0 सर्वर से जवाब मिलने का इंतज़ार करता है. इससे यह पता चलता है कि ऐप्लिकेशन को ऐक्सेस दिया गया है या नहीं. इस जवाब के बारे में अगले चरण में बताया गया है.
गड़बड़ियां
Google के OAuth 2.0 ऑथराइज़ेशन एंडपॉइंट पर किए जाने वाले अनुरोधों की मदद से, उपयोगकर्ताओं को गड़बड़ी के मैसेज दिखाए जा सकते हैं. ऐसा, पुष्टि करने और अनुमति देने के अनुमानित फ़्लो के बजाय किया जाता है. आम तौर पर होने वाली गड़बड़ियों के कोड और उनके समाधान के बारे में यहां बताया गया है.
admin_policy_enforced
Google Workspace एडमिन की नीतियों की वजह से, Google खाता एक या एक से ज़्यादा दायरों की अनुमति नहीं दे सकता. Google Workspace एडमिन का सहायता लेख पढ़ें यह कंट्रोल करें कि तीसरे पक्ष और आपके डोमेन के कौनसे ऐप्लिकेशन, Google Workspace के डेटा को ऐक्सेस कर सकते हैं. इससे आपको इस बारे में ज़्यादा जानकारी मिलेगी कि आपके OAuth क्लाइंट आईडी का ऐक्सेस मिलने तक, एडमिन सभी दायरों या संवेदनशील और प्रतिबंधित दायरों के ऐक्सेस पर कैसे पाबंदी लगा सकता है.
disallowed_useragent
ऑथराइज़ेशन एंडपॉइंट, एम्बेड किए गए उपयोगकर्ता एजेंट के अंदर दिखाया जाता है, जिसे Google की OAuth 2.0 नीतियों के तहत अनुमति नहीं मिलती.
Android
android.webkit.WebView
में अनुमति देने के अनुरोध खोलते समय, Android डेवलपर को गड़बड़ी का यह मैसेज दिख सकता है.
इसके बजाय, डेवलपर को Android लाइब्रेरी का इस्तेमाल करना चाहिए. जैसे, Android के लिए Google साइन-इन या OpenID Foundation का Android के लिए AppAuth.
वेब डेवलपर को यह गड़बड़ी तब दिख सकती है, जब कोई Android ऐप्लिकेशन, एम्बेड किए गए उपयोगकर्ता एजेंट में सामान्य वेब लिंक खोलता है और उपयोगकर्ता आपकी साइट से Google के OAuth 2.0 ऑथराइज़ेशन एंडपॉइंट पर नेविगेट करता है. डेवलपर को ऑपरेटिंग सिस्टम के डिफ़ॉल्ट लिंक हैंडलर में, सामान्य लिंक को खोलने की अनुमति देनी चाहिए. इनमें Android ऐप्लिकेशन के लिंक हैंडलर या डिफ़ॉल्ट ब्राउज़र ऐप्लिकेशन, दोनों शामिल होते हैं. Android के कस्टम टैब लाइब्रेरी भी इस सुविधा का इस्तेमाल कर सकती है.
iOS
WKWebView
में अनुमति देने के अनुरोध खोलते समय, iOS और macOS डेवलपर को यह गड़बड़ी दिख सकती है.
इसके बजाय, डेवलपर को iOS लाइब्रेरी का इस्तेमाल करना चाहिए, जैसे कि
iOS के लिए Google Sign-In या Open Foundation का
iOS के लिए AppAuth.
वेब डेवलपर को यह गड़बड़ी तब दिख सकती है, जब कोई iOS या macOS ऐप्लिकेशन, एम्बेड किए गए उपयोगकर्ता एजेंट में कोई सामान्य वेब लिंक खोलता है और उपयोगकर्ता आपकी साइट से Google के OAuth 2.0 ऑथराइज़ेशन एंडपॉइंट पर
नेविगेट करता है. डेवलपर को ऑपरेटिंग सिस्टम के डिफ़ॉल्ट लिंक हैंडलर में, सामान्य लिंक को खोलने की अनुमति
देनी चाहिए. इनमें,
यूनिवर्सल लिंक
हैंडलर या डिफ़ॉल्ट ब्राउज़र ऐप्लिकेशन, दोनों शामिल होते हैं.
SFSafariViewController
लाइब्रेरी भी इस सुविधा का इस्तेमाल किया जा सकता है.
org_internal
अनुरोध में दिया गया OAuth क्लाइंट आईडी, एक ऐसे प्रोजेक्ट का हिस्सा है जो किसी Google Cloud संगठन के Google खातों का ऐक्सेस सीमित करता है. कॉन्फ़िगरेशन के इस विकल्प के बारे में ज़्यादा जानने के लिए, उस स्क्रीन पर OAuth के लिए सहमति सेट अप करने की प्रक्रिया से जुड़े सहायता लेख में, उपयोगकर्ता का टाइप सेक्शन देखें.
invalid_client
OAuth क्लाइंट सीक्रेट गलत है. OAuth क्लाइंट कॉन्फ़िगरेशन की समीक्षा करें. इसमें, इस अनुरोध के लिए इस्तेमाल किया गया क्लाइंट आईडी और सीक्रेट भी शामिल है.
invalid_grant
किसी ऐक्सेस टोकन को रीफ़्रेश करते समय या इंक्रीमेंटल ऑथराइज़ेशन का इस्तेमाल करने पर, हो सकता है कि टोकन की समयसीमा खत्म हो गई हो या वह अमान्य हो गया हो. उपयोगकर्ता की फिर से पुष्टि करें और नए टोकन पाने के लिए, उपयोगकर्ता की सहमति मांगें. अगर आपको लगातार यह गड़बड़ी दिख रही है, तो पक्का करें कि आपका ऐप्लिकेशन सही तरीके से कॉन्फ़िगर किया गया हो. साथ ही, यह भी पक्का करें कि आपके अनुरोध में सही टोकन और पैरामीटर का इस्तेमाल किया जा रहा हो. ऐसा न करने पर, हो सकता है कि उपयोगकर्ता खाता मिटा दिया गया हो या बंद कर दिया गया हो.
redirect_uri_mismatch
अनुमति देने के अनुरोध में पास किया गया redirect_uri
, OAuth क्लाइंट आईडी के लिए, अनुमति वाले रीडायरेक्ट
यूआरआई से मेल नहीं खाता है. Google API Console Credentials pageमें,
अनुमति वाले रीडायरेक्ट यूआरआई की समीक्षा करें.
redirect_uri
पैरामीटर, OAuth आउट-ऑफ़-बैंड (OOB) फ़्लो को रेफ़र कर सकता है, जो अब काम नहीं करता. अपना इंटिग्रेशन अपडेट करने के लिए,
डेटा को दूसरी जगह भेजने से जुड़ी गाइड
देखें.
invalid_request
आपके किए गए अनुरोध में कोई गड़बड़ी थी. ऐसा कई वजहों से हो सकता है:
- अनुरोध सही तरीके से फ़ॉर्मैट नहीं किया गया था
- अनुरोध में ज़रूरी पैरामीटर मौजूद नहीं थे
- अनुरोध, पुष्टि करने के लिए किसी ऐसे तरीके का इस्तेमाल करता है जो Google पर काम नहीं करता. पुष्टि करें कि आपका OAuth इंटिग्रेशन, सुझाए गए इंटिग्रेशन के तरीके का इस्तेमाल करता है
चौथा चरण: OAuth 2.0 सर्वर रिस्पॉन्स को मैनेज करना
OAuth 2.0 सर्वर आपके ऐप्लिकेशन के ऐक्सेस के अनुरोध का जवाब देता है. इसके लिए, अनुरोध में बताए गए यूआरएल का इस्तेमाल किया जाता है.
अगर उपयोगकर्ता ऐक्सेस के अनुरोध को मंज़ूरी देता है, तो जवाब में एक ऑथराइज़ेशन कोड शामिल होता है. अगर उपयोगकर्ता अनुरोध स्वीकार नहीं करता है, तो जवाब में गड़बड़ी का मैसेज दिखता है. वेब सर्वर को मिलने वाला ऑथराइज़ेशन कोड या गड़बड़ी का मैसेज, क्वेरी स्ट्रिंग पर दिखता है, जैसा कि यहां दिखाया गया है:
गड़बड़ी का जवाब:
https://oauth2.example.com/auth?error=access_denied
ऑथराइज़ेशन कोड से मिला रिस्पॉन्स:
https://oauth2.example.com/auth?code=4/P7q7W91a-oMsCeLvIaQm6bTrgtp7
OAuth 2.0 सर्वर के रिस्पॉन्स का सैंपल
नीचे दिए गए सैंपल यूआरएल पर क्लिक करके, इस फ़्लो की जांच की जा सकती है. यह आपके Google Drive में मौजूद फ़ाइलों का मेटाडेटा देखने के लिए, रीड ओनली ऐक्सेस का अनुरोध करता है:
https://accounts.google.com/o/oauth2/v2/auth? scope=https%3A%2F%2Fwww.googleapis.com%2Fauth%2Fyt-analytics.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
OAuth 2.0 फ़्लो को पूरा करने के बाद, आपको
http://localhost/oauth2callback
पर रीडायरेक्ट किया जाना चाहिए. इस वजह से, आपको
404 NOT FOUND
गड़बड़ी मिल सकती है. ऐसा तब तक होगा, जब तक आपकी लोकल मशीन उस पते पर कोई फ़ाइल अपलोड नहीं करती. अगले चरण में,
उपयोगकर्ता को आपके ऐप्लिकेशन पर वापस रीडायरेक्ट किए जाने पर, यूआरआई में दिखाई गई जानकारी के बारे में
ज़्यादा जानकारी दी जाती है.
पांचवां चरण: टोकन को रीफ़्रेश करने और ऐक्सेस करने के लिए Exchange का ऑथराइज़ेशन कोड
वेब सर्वर को ऑथराइज़ेशन कोड मिलने के बाद, वह ऐक्सेस टोकन से ऑथराइज़ेशन कोड को बदल सकता है.
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/yt-analytics.readonly'], state=state) flow.redirect_uri = flask.url_for('oauth2callback', _external=True) authorization_response = flask.request.url flow.fetch_token(authorization_response=authorization_response) # Store the credentials in the session. # ACTION ITEM for developers: # Store user's access and refresh tokens in your data store if # incorporating this code into your real app. credentials = flow.credentials flask.session['credentials'] = { 'token': credentials.token, 'refresh_token': credentials.refresh_token, 'token_uri': credentials.token_uri, 'client_id': credentials.client_id, 'client_secret': credentials.client_secret, 'scopes': credentials.scopes}
Ruby
अपने कॉलबैक पेज पर, googleauth
लाइब्रेरी का इस्तेमाल करके, ऑथराइज़ेशन सर्वर के रिस्पॉन्स की पुष्टि करें. ऑथराइज़ेशन कोड को सेव करने के लिए,
authorizer.handle_auth_callback_deferred
तरीके का इस्तेमाल करें. साथ ही,
उस यूआरएल पर वापस रीडायरेक्ट करें जिससे आपने अनुमति पाने का अनुरोध किया था. यह
उपयोगकर्ता के सेशन में नतीजों को कुछ समय के लिए रोककर, कोड को एक्सचेंज करने से रोकता है.
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
एंडपॉइंट को कॉल करें और ये पैरामीटर सेट करें:
फ़ील्ड | |
---|---|
client_id |
API Console Credentials pageसे मिला क्लाइंट आईडी. |
client_secret |
क्लाइंट सीक्रेट, जो API Console Credentials pageसे मिला है. |
code |
शुरुआती अनुरोध के बाद, ऑथराइज़ेशन कोड लौटाया गया. |
grant_type |
जैसा कि OAuth 2.0 में बताया गया है, इस फ़ील्ड की वैल्यू authorization_code पर सेट होनी चाहिए. |
redirect_uri |
दिए गए client_id के लिए, API Console
Credentials page में आपके प्रोजेक्ट के लिए दिए गए
रीडायरेक्ट यूआरआई में से एक. |
नीचे दिए गए स्निपेट में, अनुरोध का एक सैंपल दिखाया गया है:
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 |
वह टोकन जो आपका ऐप्लिकेशन, Google API अनुरोध को अनुमति देने के लिए भेजता है. |
expires_in |
ऐक्सेस टोकन की बची हुई अवधि कुछ सेकंड में. |
refresh_token |
ऐसा टोकन जिसका इस्तेमाल करके, नया ऐक्सेस टोकन पाया जा सकता है. रीफ़्रेश टोकन तब तक मान्य रहते हैं, जब तक उपयोगकर्ता
ऐक्सेस रद्द नहीं कर देता.
ध्यान दें, यह फ़ील्ड इस रिस्पॉन्स में सिर्फ़ तब होता है, जब Google के ऑथराइज़ेशन सर्वर के शुरुआती अनुरोध में access_type पैरामीटर को offline पर सेट किया जाता है.
|
scope |
access_token के दिए ऐक्सेस के दायरे, स्पेस-डीलिमिटेड और केस-सेंसिटिव स्ट्रिंग की सूची के तौर पर दिखते हैं. |
token_type |
टोकन टाइप किया गया. फ़िलहाल, इस फ़ील्ड की वैल्यू हमेशा
Bearer पर सेट होती है. |
नीचे दिया गया स्निपेट एक सैंपल रिस्पॉन्स दिखाता है:
{ "access_token": "1/fFAGRNJru1FTz70BzhT3Zg", "expires_in": 3920, "token_type": "Bearer", "scope": "https://www.googleapis.com/auth/yt-analytics.readonly", "refresh_token": "1//xEoDL4iW3cxlI7yDbSRFYNG01kVKM2C-259HOF2aQbI" }
गड़बड़ियां
ऐक्सेस टोकन के लिए ऑथराइज़ेशन कोड की अदला-बदली करते समय, आपको अनुमानित रिस्पॉन्स के बजाय, इस गड़बड़ी का सामना करना पड़ सकता है. आम तौर पर होने वाली गड़बड़ियों के कोड और उन्हें हल करने के सुझाव यहां दिए गए हैं.
invalid_grant
दिया गया ऑथराइज़ेशन कोड अमान्य या गलत फ़ॉर्मैट में है. OAuth की प्रोसेस फिर से शुरू करके, नए कोड का अनुरोध करें. इससे, उपयोगकर्ता से सहमति लेने के लिए दोबारा अनुरोध किया जा सकता है.
Calling Google API
PHP
यह तरीका अपनाकर Google API को कॉल करने के लिए, ऐक्सेस टोकन का इस्तेमाल करें:
- अगर आपको किसी नए
Google\Client
ऑब्जेक्ट पर ऐक्सेस टोकन लागू करने की ज़रूरत है, तोsetAccessToken
तरीके का इस्तेमाल करें. उदाहरण के लिए, अगर आपने किसी उपयोगकर्ता सेशन में ऐक्सेस टोकन सेव किया है, तो यह तरीका अपनाएं:$client->setAccessToken($access_token);
- जिस एपीआई को कॉल करना है उसके लिए सेवा ऑब्जेक्ट बनाएं. आपको जिस एपीआई को कॉल करना है उसके कंस्ट्रक्टर को, अनुमति वाला
Google\Client
ऑब्जेक्ट देकर, सर्विस ऑब्जेक्ट बनाया जाता है. उदाहरण के लिए, YouTube Analytics API को कॉल करने के लिए:$youtube = new Google_Service_YouTubeAnalytics($client);
- सर्विस ऑब्जेक्ट से मिले इंटरफ़ेस का इस्तेमाल करके,
एपीआई सेवा को अनुरोध करें.
उदाहरण के लिए, पुष्टि किए गए उपयोगकर्ता के चैनल की YouTube Analytics रिपोर्ट फिर से पाने के लिए:
$report = $youtube->reports->query('channel==MINE', '2016-05-01', '2016-06-30', 'views');
Python
ऐक्सेस टोकन मिलने के बाद, आपका ऐप्लिकेशन उस टोकन का इस्तेमाल करके, दिए गए उपयोगकर्ता खाते या सेवा खाते की ओर से एपीआई अनुरोधों को मंज़ूरी दे सकता है. जिस एपीआई को कॉल करना है उसके लिए सर्विस ऑब्जेक्ट बनाने के लिए, अनुमति वाले क्रेडेंशियल का इस्तेमाल करें. इसके बाद, उस ऑब्जेक्ट का इस्तेमाल अनुमति वाले एपीआई अनुरोध करने के लिए करें.
- जिस एपीआई को कॉल करना है उसके लिए सेवा ऑब्जेक्ट बनाएं. एपीआई के नाम और वर्शन के साथ-साथ उपयोगकर्ता के क्रेडेंशियल का इस्तेमाल करके,
googleapiclient.discovery
लाइब्रेरी केbuild
तरीके को कॉल करके सर्विस ऑब्जेक्ट बनाया जाता है: उदाहरण के लिए, YouTube Analytics API के वर्शन 1 को कॉल करने के लिए:from googleapiclient.discovery import build youtube = build('youtubeAnalytics', 'v1', credentials=credentials)
- सर्विस ऑब्जेक्ट से मिले इंटरफ़ेस का इस्तेमाल करके,
एपीआई सेवा को अनुरोध करें.
उदाहरण के लिए, पुष्टि किए गए उपयोगकर्ता के चैनल की YouTube Analytics रिपोर्ट फिर से पाने के लिए:
report = youtube.reports().query(ids='channel==MINE', start_date='2016-05-01', end_date='2016-06-30', metrics='views').execute()
Ruby
ऐक्सेस टोकन मिलने के बाद, आपका ऐप्लिकेशन किसी उपयोगकर्ता खाते या सेवा खाते की ओर से एपीआई अनुरोध करने के लिए, उस टोकन का इस्तेमाल कर सकता है. जिस एपीआई को कॉल करना है उसके लिए सर्विस ऑब्जेक्ट बनाने के लिए, अनुमति वाले क्रेडेंशियल का इस्तेमाल करें. इसके बाद, उस ऑब्जेक्ट का इस्तेमाल अनुमति वाले एपीआई अनुरोध करने के लिए करें.
- जिस एपीआई को कॉल करना है उसके लिए सेवा ऑब्जेक्ट बनाएं.
उदाहरण के लिए, YouTube Analytics API के वर्शन 1 को कॉल करने के लिए:
youtube = Google::Apis::YoutubeAnalyticsV1::YouTubeAnalyticsService.new
- सेवा के लिए क्रेडेंशियल सेट करें:
youtube.authorization = credentials
- सर्विस ऑब्जेक्ट से मिले इंटरफ़ेस
का इस्तेमाल करके,
एपीआई सेवा को अनुरोध करें.
उदाहरण के लिए, पुष्टि किए गए उपयोगकर्ता के चैनल की YouTube Analytics रिपोर्ट फिर से पाने के लिए:
report = youtube.query_report('channel==MINE', '2016-05-01', '2016-06-30', 'views')
इसके अलावा, किसी तरीके में options
पैरामीटर देकर, हर तरीके के हिसाब से अनुमति दी जा सकती है:
report = youtube.query_report('channel==MINE', '2016-05-01', '2016-06-30', 'views', options: { authorization: auth_client })
Node.js
ऐक्सेस टोकन पाने और उसे OAuth2
ऑब्जेक्ट पर सेट करने के बाद, Google 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.'); } });
एचटीटीपी/REST
आपके ऐप्लिकेशन को ऐक्सेस टोकन मिल जाने के बाद, किसी उपयोगकर्ता खाते की ओर से Google API को कॉल करने के लिए, टोकन का इस्तेमाल किया जा सकता है. हालांकि, इसके लिए ज़रूरी है कि एपीआई के लिए ज़रूरी ऐक्सेस के दायरे दिए गए हों. ऐसा करने के लिए, एपीआई को किए गए अनुरोध में ऐक्सेस टोकन शामिल करें. इसके लिए, access_token
क्वेरी पैरामीटर या Authorization
एचटीटीपी हेडर Bearer
वैल्यू शामिल करें. जब मुमकिन हो, तब एचटीटीपी हेडर को प्राथमिकता दी जानी चाहिए, क्योंकि सर्वर लॉग में क्वेरी स्ट्रिंग अक्सर दिखती हैं. ज़्यादातर मामलों में,
Google API को कॉल करने की सुविधा सेट अप करने के लिए, क्लाइंट लाइब्रेरी का इस्तेमाल किया जा सकता है. उदाहरण के लिए,
YouTube Analytics API को कॉल करते समय.
ध्यान दें कि YouTube Analytics API, सेवा खाता फ़्लो के साथ काम नहीं करता. YouTube Reporting API, सिर्फ़ YouTube कॉन्टेंट के ऐसे मालिकों के लिए सेवा खातों के साथ काम करता है जो कई YouTube चैनलों के मालिक हैं और उन्हें मैनेज करते हैं. जैसे, रिकॉर्ड लेबल और फ़िल्म स्टूडियो.
OAuth 2.0 प्लेग्राउंड में, सभी Google API को आज़माया जा सकता है और उनके स्कोप देखे जा सकते हैं.
एचटीटीपी जीईटी के उदाहरण
Authorization: Bearer
एचटीटीपी हेडर का इस्तेमाल करके,
reports.query
एंडपॉइंट (YouTube Analytics API)
को कॉल करने पर ऐसा दिख सकता है. ध्यान दें कि आपको अपना ऐक्सेस टोकन बताना होगा:
GET /youtube/analytics/v1/reports?ids=channel%3D%3DMINE&start-date=2016-05-01&end-date=2016-06-30&metrics=views HTTP/1.1 Host: www.googleapis.com Authorization: Bearer access_token
यहां access_token
क्वेरी स्ट्रिंग पैरामीटर का इस्तेमाल करके, पुष्टि किए गए उपयोगकर्ता के लिए उसी एपीआई को कॉल किया गया है:
GET https://www.googleapis.com/youtube/analytics/v1/reports?access_token=access_token&ids=channel%3D%3DMINE&start-date=2016-05-01&end-date=2016-06-30&metrics=views
curl
के उदाहरण
curl
कमांड-लाइन ऐप्लिकेशन का इस्तेमाल करके, इन कमांड की जांच की जा सकती है. यहां एक उदाहरण दिया गया है, जिसमें एचटीटीपी हेडर विकल्प का इस्तेमाल किया जाता है (इसका सुझाव दिया जाता है):
curl -H "Authorization: Bearer access_token" https://www.googleapis.com/youtube/analytics/v1/reports?ids=channel%3D%3DMINE&start-date=2016-05-01&end-date=2016-06-30&metrics=views
इसके अलावा, क्वेरी स्ट्रिंग पैरामीटर विकल्प:
curl https://www.googleapis.com/youtube/analytics/v1/reports?access_token=access_token&ids=channel%3D%3DMINE&start-date=2016-05-01&end-date=2016-06-30&metrics=views
पूरा उदाहरण
यहां दिए गए उदाहरण में, JSON फ़ॉर्मैट में बनाए गए ऑब्जेक्ट को प्रिंट किया जाता है. इसमें पुष्टि किए गए उपयोगकर्ता के YouTube चैनल के व्यू का डेटा दिखाया जाता है. यह डेटा तब दिखाया जाता है, जब उपयोगकर्ता ऐप्लिकेशन को YouTube Analytics की रिपोर्ट फिर से पाने की अनुमति देता है.
PHP
इस उदाहरण को चलाने के लिए:
- API Consoleमें, रीडायरेक्ट यूआरएल की सूची में लोकल मशीन के यूआरएल को
जोड़ें. उदाहरण के लिए,
http://localhost:8080
जोड़ें. - नई डायरेक्ट्री बनाएं और उसमें बदलाव करें. उदाहरण के लिए:
mkdir ~/php-oauth2-example cd ~/php-oauth2-example
- Composer का इस्तेमाल करके PHP के लिए Google API क्लाइंट लाइब्रेरी इंस्टॉल करें:
composer require google/apiclient:^2.10
- नीचे दिए गए कॉन्टेंट का इस्तेमाल करके,
index.php
औरoauth2callback.php
फ़ाइलें बनाएं. - उदाहरण को 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_YouTubeAnalytics::YT_ANALYTICS_READONLY); if (isset($_SESSION['access_token']) && $_SESSION['access_token']) { $client->setAccessToken($_SESSION['access_token']); $youtube = new Google_Service_YouTubeAnalytics($client); $report = $youtube->reports->query('channel==MINE', '2016-05-01', '2016-06-30', 'views'); echo json_encode($report); } 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_YouTubeAnalytics::YT_ANALYTICS_READONLY); if (! isset($_GET['code'])) { // Generate and set state value $state = bin2hex(random_bytes(16)); $client->setState($state); $_SESSION['state'] = $state; $auth_url = $client->createAuthUrl(); header('Location: ' . filter_var($auth_url, FILTER_SANITIZE_URL)); } else { // Check the state value if (!isset($_GET['state']) || $_GET['state'] !== $_SESSION['state']) { die('State mismatch. Possible CSRF attack.'); } $client->authenticate($_GET['code']); $_SESSION['access_token'] = $client->getAccessToken(); $redirect_uri = 'http://' . $_SERVER['HTTP_HOST'] . '/'; header('Location: ' . filter_var($redirect_uri, FILTER_SANITIZE_URL)); }
Python
इस उदाहरण में, Flask फ़्रेमवर्क का इस्तेमाल किया गया है. यह 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/yt-analytics.readonly'] API_SERVICE_NAME = 'youtubeAnalytics' API_VERSION = 'v1' 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) report = youtube.reports().query(ids='channel==MINE', start_date='2016-05-01', end_date='2016-06-30', metrics='views').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(**report) @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_analytics_v1' 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::YoutubeAnalyticsV1::YouTubeAnalyticsService.new report = youtube.query_report('channel==MINE', '2016-05-01', '2016-06-30', 'views', options: { authorization: auth_client }) "<pre>#{JSON.pretty_generate(report.to_h)}</pre>" end get '/oauth2callback' do target_url = Google::Auth::WebUserAuthorizer.handle_auth_callback_deferred(request) redirect target_url end
Node.js
इस उदाहरण को चलाने के लिए:
-
API Consoleमें, रीडायरेक्ट यूआरएल की सूची में लोकल मशीन के यूआरएल को जोड़ें. उदाहरण के लिए,
http://localhost
जोड़ें. - पक्का करें कि आपके पास रखरखाव एलटीएस (एलटीएस), चालू एलटीएस या Node.js की मौजूदा रिलीज़ इंस्टॉल है.
-
नई डायरेक्ट्री बनाएं और उसमें बदलाव करें. उदाहरण के लिए:
mkdir ~/nodejs-oauth2-example cd ~/nodejs-oauth2-example
-
Install the
Google API Client
Library
for Node.js using npm:
npm install googleapis
-
नीचे दिए गए कॉन्टेंट के साथ
main.js
फ़ाइलें बनाएं. -
उदाहरण को चलाएं:
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 के इस उदाहरण में, OAuth 2.0 वेब फ़्लो दिखाने के लिए, Flask फ़्रेमवर्क और Requests लाइब्रेरी का इस्तेमाल किया गया है. हमारा सुझाव है कि इस फ़्लो के लिए, 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/yt-analytics.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/youtube/analytics/v1/reports' 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()
रीडायरेक्ट यूआरआई की पुष्टि के नियम
Google, यूआरआई को रीडायरेक्ट करने के लिए पुष्टि करने के ये नियम लागू करता है, ताकि डेवलपर अपने ऐप्लिकेशन सुरक्षित रख सकें. आपके रीडायरेक्ट यूआरआई को इन नियमों का पालन करना होगा. नीचे बताए गए डोमेन, होस्ट, पाथ, क्वेरी, स्कीम, और userinfo की परिभाषा के लिए RFC 3986 सेक्शन 3 देखें.
सत्यापन नियम | |
---|---|
स्कीम |
रीडायरेक्ट यूआरआई को सामान्य एचटीटीपी के बजाय, एचटीटीपीएस स्कीम का इस्तेमाल करना चाहिए. Localhost यूआरआई (इसमें localhost आईपी पते के यूआरआई शामिल हैं) पर यह नियम लागू नहीं होता. |
होस्ट |
होस्ट, अमान्य आईपी पते नहीं हो सकते. लोकल होस्ट के आईपी पतों पर यह नियम लागू नहीं होता. |
डोमेन |
“googleusercontent.com” नहीं हो सकते.goo.gl ) तब तक नहीं हो सकते, जब तक
ऐप्लिकेशन के पास डोमेन का मालिकाना हक न हो. इसके अलावा, अगर छोटे डोमेन का मालिक कोई ऐप्लिकेशन
उस डोमेन पर रीडायरेक्ट करता है, तो उस रीडायरेक्ट यूआरआई के पाथ में
“/google-callback/” होना चाहिए या
“/google-callback” पर खत्म होना चाहिए. |
उपयोगकर्ता की जानकारी |
रीडायरेक्ट यूआरआई में userinfo सबकॉम्पोनेंट शामिल नहीं हो सकता. |
पाथ |
रीडायरेक्ट यूआरआई में पाथ ट्रेवर्सल (इसे डायरेक्ट्री बैकट्रैकिंग भी कहा जाता है) नहीं हो सकता,
जिसे |
क्वेरी |
रीडायरेक्ट यूआरआई में ओपन रीडायरेक्ट नहीं हो सकते. |
फ़्रैगमेंट |
रीडायरेक्ट यूआरआई में फ़्रैगमेंट कॉम्पोनेंट शामिल नहीं हो सकता. |
वर्ण |
रीडायरेक्ट यूआरआई में कुछ खास वर्ण नहीं हो सकते, जैसे कि:
|
इंक्रीमेंटल अनुमति
OAuth 2.0 प्रोटोकॉल में, आपका ऐप्लिकेशन संसाधनों को ऐक्सेस करने के लिए अनुमति मांगता है. इन संसाधनों की पहचान स्कोप से की जाती है. यह सबसे सही उपयोगकर्ता अनुभव माना जाता है कि जब आपको संसाधनों की ज़रूरत हो, तब उनके लिए अनुमति का अनुरोध करें. इस प्रोसेस को चालू करने के लिए, Google का ऑथराइज़ेशन सर्वर, इंक्रीमेंटल ऑथराइज़ेशन की सुविधा देता है. इस सुविधा से, ज़रूरत के हिसाब से दायरों के लिए अनुरोध किया जा सकता है. अगर उपयोगकर्ता नए दायरे के लिए अनुमति देता है, तो यह ऑथराइज़ेशन कोड दिखाता है. इसे ऐसे टोकन से बदला जा सकता है जिसमें उपयोगकर्ता ने प्रोजेक्ट को दिए सभी स्कोप शामिल हों.
उदाहरण के लिए, मान लें कि कोई ऐप्लिकेशन YouTube Analytics की रिपोर्ट इकट्ठा करता है,
इनमें से कुछ पैसों से जुड़ी रिपोर्ट होती हैं, जिनके लिए किसी ऐसे दायरे का ऐक्सेस होना ज़रूरी है जो
दूसरी रिपोर्ट के लिए ज़रूरी नहीं है. इस मामले में, साइन इन के समय ऐप्लिकेशन सिर्फ़ https://www.googleapis.com/auth/yt-analytics.readonly
स्कोप के ऐक्सेस का अनुरोध कर सकता है.
हालांकि, अगर उपयोगकर्ता ने मॉनेटरी रिपोर्ट को वापस पाने की कोशिश की है, तो ऐप्लिकेशन https://www.googleapis.com/auth/yt-analytics-monetary.readonly
के स्कोप को ऐक्सेस करने का अनुरोध भी कर सकता है.
इंक्रीमेंटल ऑथराइज़ेशन को लागू करने के लिए, आपको ऐक्सेस टोकन के अनुरोध का सामान्य फ़्लो पूरा करना होगा. हालांकि, यह पक्का करना होगा कि अनुमति देने के अनुरोध में, वे दायरे शामिल हों जिन्हें पहले अनुमति दी गई थी. इस तरीके से, आपके ऐप्लिकेशन को एक से ज़्यादा ऐक्सेस टोकन को मैनेज करने की ज़रूरत नहीं पड़ती.
इंक्रीमेंटल अनुमति से मिलने वाले ऐक्सेस टोकन पर, ये नियम लागू होते हैं:
- इस टोकन का इस्तेमाल, अनुमति देने के नए और मिले-जुले तरीके में शामिल किसी भी दायरे से जुड़े संसाधनों को ऐक्सेस करने के लिए किया जा सकता है.
- जब ऐक्सेस टोकन पाने के लिए, एक साथ ऐक्सेस किए जाने की अनुमति के लिए रीफ़्रेश टोकन का इस्तेमाल किया जाता है,
तो ऐक्सेस टोकन, अनुमति वाली मिली-जुली अनुमति को दिखाता है. साथ ही, जवाब में शामिल किसी भी
scope
वैल्यू के लिए इसका इस्तेमाल किया जा सकता है. - एक साथ अनुमति देने में, वे सभी दायरे शामिल होते हैं जो उपयोगकर्ता ने एपीआई प्रोजेक्ट को दिए थे. भले ही, अनुमतियों के लिए अलग-अलग क्लाइंट से अनुरोध किया गया हो. उदाहरण के लिए, अगर कोई उपयोगकर्ता किसी ऐप्लिकेशन के डेस्कटॉप क्लाइंट का इस्तेमाल करके एक स्कोप का ऐक्सेस देता है और फिर किसी मोबाइल क्लाइंट की मदद से उसी ऐप्लिकेशन को दूसरा स्कोप दिया जाता है, तो अनुमति वाले मिले-जुले रूप में दोनों स्कोप शामिल होंगे.
- अगर आप किसी ऐसे टोकन को रद्द करते हैं जो मिली-जुली अनुमति दिखाता है, तो इससे जुड़े उपयोगकर्ता की ओर से उसके सभी दायरों का ऐक्सेस एक साथ रद्द कर दिया जाता है.
पहला चरण: ऑथराइज़ेशन पैरामीटर सेट करें सेक्शन में, भाषा के हिसाब से बने कोड सैंपल और दूसरा चरण: Google के OAuth 2.0 सर्वर पर रीडायरेक्ट करें में मौजूद एचटीटीपी/REST रीडायरेक्ट यूआरएल का सैंपल. ये सभी, इंक्रीमेंटल ऑथराइज़ेशन इस्तेमाल करते हैं. नीचे दिए गए कोड सैंपल में वह कोड भी दिखाया गया है जिसे आपको इंक्रीमेंटल ऑथराइज़ेशन का इस्तेमाल करने के लिए जोड़ना होगा.
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
Refreshing an access token (offline access)
Access tokens periodically expire and become invalid credentials for a related API request. You can refresh an access token without prompting the user for permission (including when the user is not present) if you requested offline access to the scopes associated with the token.
- If you use a Google API Client Library, the client object refreshes the access token as needed as long as you configure that object for offline access.
- If you are not using a client library, you need to set the
access_type
HTTP query parameter tooffline
when redirecting the user to Google's OAuth 2.0 server. In that case, Google's authorization server returns a refresh token when you exchange an authorization code for an access token. Then, if the access token expires (or at any other time), you can use a refresh token to obtain a new access token.
Requesting offline access is a requirement for any application that needs to access a Google
API when the user is not present. For example, an app that performs backup services or
executes actions at predetermined times needs to be able to refresh its access token when the
user is not present. The default style of access is called online
.
Server-side web applications, installed applications, and devices all obtain refresh tokens during the authorization process. Refresh tokens are not typically used in client-side (JavaScript) web applications.
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
किसी ऐक्सेस टोकन को रीफ़्रेश करने के लिए, आपका ऐप्लिकेशन Google के ऑथराइज़ेशन सर्वर (https://oauth2.googleapis.com/token
) को एचटीटीपीएस POST
का अनुरोध भेजता है. इस अनुरोध में ये पैरामीटर शामिल होते हैं:
फ़ील्ड | |
---|---|
client_id |
API Consoleसे मिला क्लाइंट आईडी. |
client_secret |
API Consoleसे मिला क्लाइंट सीक्रेट. |
grant_type |
जैसा कि OAuth 2.0 की खास बातों में बताया गया है, इस फ़ील्ड की वैल्यू refresh_token पर सेट होनी चाहिए. |
refresh_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
दिखाया जाता है.