Google Identity Services पर माइग्रेट करें

खास जानकारी

Google API को कॉल करने के लिए, हर उपयोगकर्ता के हिसाब से ऐक्सेस टोकन पाने के लिए, Google कई JavaScript लाइब्रेरी उपलब्ध कराता है:

इस गाइड में, इन लाइब्रेरी से Google Identity Services लाइब्रेरी पर माइग्रेट करने के निर्देश दिए गए हैं.

इस गाइड को पढ़कर, आपको इन बातों के बारे में जानकारी मिलेगी:

  • अब काम न करने वाली प्लैटफ़ॉर्म लाइब्रेरी की जगह Identity Services लाइब्रेरी का इस्तेमाल करें.
  • अगर एपीआई क्लाइंट लाइब्रेरी का इस्तेमाल किया जा रहा है, तो बंद किए गए gapi.auth2 मॉड्यूल, उसके तरीकों, और ऑब्जेक्ट को हटा दें. इसके बजाय, Identity Services के बराबर के मॉड्यूल का इस्तेमाल करें.

Identity Services JavaScript लाइब्रेरी में क्या बदलाव हुए हैं, इसके बारे में जानने के लिए खास जानकारी पढ़ें. साथ ही, उपयोगकर्ता की अनुमति कैसे काम करती है लेख पढ़ें, ताकि मुख्य शर्तों और कॉन्सेप्ट की समीक्षा की जा सके.

अगर आपको उपयोगकर्ता के साइन-अप और साइन-इन के लिए पुष्टि करने की सुविधा चाहिए, तो 'Google साइन-इन' से माइग्रेट करना लेख पढ़ें.

अनुमति देने की प्रोसेस की पहचान करना

उपयोगकर्ता के ऑथराइज़ेशन के लिए दो तरह के फ़्लो उपलब्ध हैं: इंप्लिसिट और ऑथराइज़ेशन कोड.

अपने वेब ऐप्लिकेशन की समीक्षा करें, ताकि यह पता चल सके कि किस तरह के अनुमति फ़्लो का इस्तेमाल किया जा रहा है.

आपके वेब ऐप्लिकेशन में इंप्लिसिट फ़्लो का इस्तेमाल किया जा रहा है, इसके ये संकेत हैं:

  • आपका वेब ऐप्लिकेशन पूरी तरह से ब्राउज़र पर आधारित है. इसमें कोई बैकएंड प्लैटफ़ॉर्म नहीं है.
  • Google API को कॉल करने के लिए, उपयोगकर्ता का मौजूद होना ज़रूरी है. आपका ऐप्लिकेशन सिर्फ़ ऐक्सेस टोकन का इस्तेमाल करता है और इसे रीफ़्रेश टोकन की ज़रूरत नहीं होती.
  • आपका वेब ऐप्लिकेशन apis.google.com/js/api.js लोड होता है.
  • आपका ऐप्लिकेशन, क्लाइंट-साइड वेब ऐप्लिकेशन के लिए OAuth 2.0 पर आधारित है.
  • आपका ऐप्लिकेशन, JavaScript के लिए Google API क्लाइंट लाइब्रेरी में मौजूद gapi.client या gapi.auth2 मॉड्यूल का इस्तेमाल करता है.

इनसे पता चलता है कि आपका वेब ऐप्लिकेशन, ऑथराइज़ेशन कोड फ़्लो का इस्तेमाल कर रहा है:

  • आपका कॉन्फ़िगरेशन इन बातों पर आधारित है:

  • आपका ऐप्लिकेशन, उपयोगकर्ता के ब्राउज़र और आपके बैकएंड प्लैटफ़ॉर्म, दोनों पर काम करता है.

  • आपका बैकएंड प्लैटफ़ॉर्म, ऑथराइज़ेशन कोड एंडपॉइंट को होस्ट करता है.

  • आपका बैकएंड प्लैटफ़ॉर्म, उपयोगकर्ताओं की ओर से Google API को कॉल करता है. इसके लिए, उपयोगकर्ताओं का मौजूद होना ज़रूरी नहीं है. इसे ऑफ़लाइन मोड भी कहा जाता है.

  • रीफ़्रेश टोकन को आपका बैकएंड प्लैटफ़ॉर्म मैनेज और सेव करता है.

कुछ मामलों में, आपके कोडबेस में दोनों फ़्लो काम कर सकते हैं.

apis.google.com/js/api:client.js

अनुमति देने की प्रोसेस चुनना

माइग्रेशन शुरू करने से पहले, आपको यह तय करना होगा कि मौजूदा फ़्लो का इस्तेमाल जारी रखना है या किसी दूसरे फ़्लो को अपनाना है.

दोनों फ़्लो के बीच के मुख्य अंतर और फ़ायदों/नुकसानों को समझने के लिए, अनुमति देने का फ़्लो चुनना लेख पढ़ें.

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

चुनने वाले टूल का इस्तेमाल करके, अनुमति देने का कोई फ़्लो चुनें.

इंप्लिसिट फ़्लो

उपयोगकर्ता के मौजूद रहने के दौरान, ब्राउज़र में इस्तेमाल करने के लिए ऐक्सेस टोकन पाएं.

इंप्लिसिट फ़्लो के उदाहरण में, वेब ऐप्लिकेशन को Identity Services पर माइग्रेट करने से पहले और बाद में दिखाया गया है.

ऑथराइज़ेशन कोड का फ़्लो

Google की ओर से जारी किया गया, हर उपयोगकर्ता के लिए ऑथराइज़ेशन कोड, आपके बैकएंड प्लैटफ़ॉर्म को डिलीवर किया जाता है. यहां इसे ऐक्सेस टोकन और रीफ़्रेश टोकन के बदले में एक्सचेंज किया जाता है.

ऑथराइज़ेशन कोड फ़्लो के उदाहरण में, वेब ऐप्लिकेशन को आइडेंटिटी सेवाओं पर माइग्रेट करने से पहले और बाद में दिखाया गया है.

इस गाइड में, मौजूदा फ़ंक्शन को जोड़ने, हटाने, अपडेट करने या बदलने के लिए, बोल्ड किए गए निर्देशों का पालन करें.

आपके इन-ब्राउज़र वेब ऐप्लिकेशन में होने वाले बदलाव

इस सेक्शन में, Google Identity Services JavaScript लाइब्रेरी पर माइग्रेट करते समय, ब्राउज़र में मौजूद वेब ऐप्लिकेशन में किए जाने वाले बदलावों की समीक्षा की गई है.

समस्या वाले कोड का पता लगाना और उसकी जांच करना

डीबग कुकी की मदद से, उस कोड का पता लगाया जा सकता है जिस पर असर पड़ा है. साथ ही, डेप्रिकेट किए जाने के बाद के व्यवहार को टेस्ट किया जा सकता है.

बड़े या जटिल ऐप्लिकेशन में, gapi.auth2 मॉड्यूल के बंद होने से प्रभावित सभी कोड ढूंढना मुश्किल हो सकता है. जल्द ही बंद होने वाली सुविधा के मौजूदा इस्तेमाल को कंसोल में लॉग करने के लिए, G_AUTH2_MIGRATION कुकी की वैल्यू को informational पर सेट करें. इसके अलावा, सेशन स्टोरेज में भी लॉग करने के लिए, कोलन के बाद कुंजी की वैल्यू जोड़ें. साइन इन करने के बाद, क्रेडेंशियल की समीक्षा करना या इकट्ठा किए गए लॉग को बैकएंड में भेजना, ताकि बाद में उनका विश्लेषण किया जा सके. उदाहरण के लिए, informational:showauth2use, ऑरिजिन और यूआरएल को showauth2use नाम की सेशन स्टोरेज की में सेव करता है.

gapi.auth2 मॉड्यूल लोड न होने पर, ऐप्लिकेशन के व्यवहार की पुष्टि करने के लिए, G_AUTH2_MIGRATION कुकी की वैल्यू को enforced पर सेट करें. इससे, नीति के उल्लंघन को ठीक करने की समयसीमा खत्म होने के बाद होने वाले बदलावों को लागू होने की तारीख से पहले ही टेस्ट किया जा सकता है.

G_AUTH2_MIGRATION कुकी की संभावित वैल्यू:

  • enforced gapi.auth2 मॉड्यूल को लोड न करें.
  • informational JS कंसोल में, बंद हो चुकी सुविधा के इस्तेमाल का लॉग करें. जब वैकल्पिक कुंजी का नाम सेट किया जाता है, तब सेशन स्टोरेज में भी लॉग करें: informational:key-name.

हमारा सुझाव है कि आप इस कुकी को प्रोडक्शन एनवायरमेंट में इस्तेमाल करने से पहले, डेवलपमेंट और टेस्टिंग के दौरान इसे स्थानीय तौर पर सेट करें, ताकि उपयोगकर्ता पर इसका असर कम से कम हो.

लाइब्रेरी और मॉड्यूल

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

अपने वेब ऐप्लिकेशन में Identity Services लाइब्रेरी जोड़ें. इसके लिए, इसे अपने दस्तावेज़ में शामिल करें:

<script src="https://accounts.google.com/gsi/client" async defer></script>

gapi.load('auth2', function) का इस्तेमाल करके, auth2 मॉड्यूल को लोड करने के सभी इंस्टेंस हटाएं.

Google Identity Services लाइब्रेरी, gapi.auth2 मॉड्यूल के इस्तेमाल की जगह लेती है. JavaScript के लिए Google API क्लाइंट लाइब्रेरी के gapi.client मॉड्यूल का इस्तेमाल जारी रखा जा सकता है. साथ ही, इसके इन फ़ायदों का इस्तेमाल किया जा सकता है: डिस्कवरी दस्तावेज़ से कॉल किए जा सकने वाले JS तरीके अपने-आप बन जाते हैं, कई एपीआई कॉल को बैच किया जा सकता है, और CORS को मैनेज किया जा सकता है.

कुकी

उपयोगकर्ता की पुष्टि करने के लिए, कुकी का इस्तेमाल करना ज़रूरी नहीं है.

उपयोगकर्ता की पुष्टि करने के लिए कुकी का इस्तेमाल कैसे किया जाता है, इस बारे में जानने के लिए Google खाते से साइन इन करने की सुविधा से माइग्रेट करना लेख पढ़ें. साथ ही, Google के अन्य प्रॉडक्ट और सेवाएं कुकी का इस्तेमाल कैसे करती हैं, इस बारे में जानने के लिए Google कुकी का इस्तेमाल कैसे करता है लेख पढ़ें.

क्रेडेंशियल

Google Identity Services, उपयोगकर्ता की पुष्टि करने और उसे अनुमति देने की प्रोसेस को दो अलग-अलग चरणों में बांटता है. साथ ही, उपयोगकर्ता के क्रेडेंशियल अलग-अलग होते हैं: उपयोगकर्ता की पहचान करने के लिए इस्तेमाल किया गया आईडी टोकन, अनुमति देने के लिए इस्तेमाल किए गए ऐक्सेस टोकन से अलग होता है.

इन बदलावों को देखने के लिए, क्रेडेंशियल का उदाहरण देखें.

इंप्लिसिट फ़्लो

उपयोगकर्ता की प्रोफ़ाइल को हटाने के लिए, उपयोगकर्ता की पुष्टि करने और उसे अनुमति देने की प्रोसेस को अलग करें.

Google साइन इन की सुविधा वाले JavaScript क्लाइंट के इन रेफ़रंस को हटाएं:

तरीके

  • GoogleUser.getBasicProfile()
  • GoogleUser.getId()

ऑथराइज़ेशन कोड का फ़्लो

Identity Services, ब्राउज़र में मौजूद क्रेडेंशियल को आईडी टोकन और ऐक्सेस टोकन में अलग करता है. यह बदलाव, उन क्रेडेंशियल पर लागू नहीं होता जिन्हें आपके बैकएंड प्लैटफ़ॉर्म से Google OAuth 2.0 एंडपॉइंट पर सीधे कॉल करके या आपके प्लैटफ़ॉर्म पर सुरक्षित सर्वर पर चल रही लाइब्रेरी के ज़रिए हासिल किया गया है. जैसे, Google APIs Node.js Client.

सेशन की स्थिति

पहले, Google Sign-In की मदद से, साइन इन किए गए उपयोगकर्ता की स्थिति को मैनेज किया जाता था. इसके लिए, इन तरीकों का इस्तेमाल किया जाता था:

आपके पास अपने वेब ऐप्लिकेशन में साइन-इन की स्थिति और उपयोगकर्ता सेशन को मैनेज करने की ज़िम्मेदारी होती है.

Google साइन इन की सुविधा वाले JavaScript क्लाइंट के इन रेफ़रंस को हटाएं:

ऑब्जेक्ट:

  • gapi.auth2.SignInOptions

तरीके:

  • GoogleAuth.attachClickHandler()
  • GoogleAuth.isSignedIn()
  • GoogleAuth.isSignedIn.get()
  • GoogleAuth.isSignedIn.listen()
  • GoogleAuth.signIn()
  • GoogleAuth.signOut()
  • GoogleAuth.currentUser.get()
  • GoogleAuth.currentUser.listen()
  • GoogleUser.isSignedIn()

क्लाइंट कॉन्फ़िगरेशन

इंप्लिसिट या ऑथराइज़ेशन कोड फ़्लो के लिए टोकन क्लाइंट शुरू करने के लिए, अपने वेब ऐप्लिकेशन को अपडेट करें.

Google साइन इन की सुविधा वाले JavaScript क्लाइंट के इन रेफ़रंस को हटाएं:

ऑब्जेक्ट:

  • gapi.auth2.ClientConfig
  • gapi.auth2.OfflineAccessOptions

तरीके:

  • gapi.auth2.getAuthInstance()

  • GoogleUser.grant()

इंप्लिसिट फ़्लो

अपने वेब ऐप्लिकेशन को कॉन्फ़िगर करने के लिए, TokenClientConfig ऑब्जेक्ट जोड़ें और initTokenClient() कॉल करें. इसके लिए, टोकन क्लाइंट को शुरू करें में दिए गए उदाहरण का पालन करें.

Google Identity Services के साथ Google साइन-इन JavaScript क्लाइंट के रेफ़रंस बदलें:

ऑब्जेक्ट:

  • TokenClientConfig के साथ gapi.auth2.AuthorizeConfig

तरीके:

  • google.accounts.oauth2.initTokenClient() के साथ gapi.auth2.init()

पैरामीटर:

  • TokenClientConfig.login_hint वाला gapi.auth2.AuthorizeConfig.login_hint.
  • gapi.auth2.GoogleUser.getHostedDomain() में TokenClientConfig.hd की सदस्यता लें.

ऑथराइज़ेशन कोड का फ़्लो

अपने वेब ऐप्लिकेशन को कॉन्फ़िगर करने के लिए, CodeClientConfig ऑब्जेक्ट और initCodeClient() कॉल जोड़ें. इसके लिए, कोड क्लाइंट को शुरू करना में दिया गया उदाहरण देखें.

इंप्लिसिट फ़्लो से ऑथराइज़ेशन कोड फ़्लो पर स्विच करते समय:

Google साइन-इन के JavaScript क्लाइंट के रेफ़रंस हटाएं

ऑब्जेक्ट:

  • gapi.auth2.AuthorizeConfig

तरीके:

  • gapi.auth2.init()

पैरामीटर:

  • gapi.auth2.AuthorizeConfig.login_hint
  • gapi.auth2.GoogleUser.getHostedDomain()

टोकन का अनुरोध

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

इंप्लिसिट फ़्लो

उपयोगकर्ता के साइन इन होने और Google के साथ उसका सेशन चालू होने पर, ब्राउज़र में ऐक्सेस टोकन पाए और इस्तेमाल किए जा सकते हैं. इम्प्लिसिट मोड में, ऐक्सेस टोकन का अनुरोध करने के लिए उपयोगकर्ता के जेस्चर की ज़रूरत होती है. भले ही, पहले कोई अनुरोध किया गया हो.

Google साइन-इन के JavaScript क्लाइंट के रेफ़रंस को Google Identity Services से बदलें:

तरीके:

  • TokenClient.requestAccessToken() के साथ gapi.auth2.authorize()
  • TokenClient.requestAccessToken() वाला GoogleUser.reloadAuthResponse()

requestAccessToken() को कॉल करने के लिए लिंक या बटन जोड़ें, ताकि ऐक्सेस टोकन का अनुरोध करने के लिए पॉप-अप यूज़र एक्सपीरियंस फ़्लो शुरू किया जा सके. इसके अलावा, मौजूदा टोकन की समयसीमा खत्म होने पर नया टोकन पाने के लिए भी ऐसा किया जा सकता है.

अपने कोडबेस को अपडेट करें, ताकि:

  • requestAccessToken() की मदद से, OAuth 2.0 टोकन फ़्लो ट्रिगर करें.
  • requestAccessToken और OverridableTokenClientConfig का इस्तेमाल करके, इंक्रीमेंटल ऑथराइज़ेशन की सुविधा उपलब्ध कराई गई है. इससे कई स्कोप के लिए एक अनुरोध को छोटे-छोटे अनुरोधों में बांटा जा सकता है.
  • मौजूदा टोकन की समयसीमा खत्म होने या उसे रद्द किए जाने पर, नए टोकन का अनुरोध करें.

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

ऐक्सेस टोकन की समयसीमा खत्म होने पर, gapi.auth2 मॉड्यूल आपके वेब ऐप्लिकेशन के लिए अपने-आप एक नया और मान्य ऐक्सेस टोकन हासिल कर लेता है. उपयोगकर्ता की सुरक्षा को बेहतर बनाने के लिए, टोकन को अपने-आप रीफ़्रेश करने की इस प्रोसेस को Google Identity Services लाइब्रेरी से इस्तेमाल नहीं किया जा सकता. आपके वेब ऐप्लिकेशन को अपडेट किया जाना चाहिए, ताकि वह समयसीमा खत्म हो चुके ऐक्सेस टोकन का पता लगा सके और नए टोकन का अनुरोध कर सके. ज़्यादा जानकारी के लिए, टोकन मैनेज करने से जुड़ा सेक्शन देखें.

ऑथराइज़ेशन कोड का फ़्लो

Google से अनुमति कोड का अनुरोध करने के लिए, requestCode() को कॉल करने के लिए लिंक या बटन जोड़ें. उदाहरण के लिए, OAuth 2.0 कोड फ़्लो ट्रिगर करना देखें.

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

टोकन मैनेज करना

जोड़ें गड़बड़ी को ठीक करने की सुविधा. इससे, समयसीमा खत्म हो चुके या रद्द किए गए ऐक्सेस टोकन का इस्तेमाल करने पर, Google API कॉल का पता लगाया जा सकेगा. साथ ही, नया और मान्य ऐक्सेस टोकन पाने का अनुरोध किया जा सकेगा.

जब किसी ऐसे ऐक्सेस टोकन का इस्तेमाल किया जाता है जिसकी समयसीमा खत्म हो चुकी है या जिसे रद्द कर दिया गया है, तब Google API, 401 Unauthorized एचटीटीपी स्टेटस कोड और invalid_token गड़बड़ी का मैसेज दिखाता है. उदाहरण के लिए, अमान्य टोकन रिस्पॉन्स देखें.

ऐसे टोकन जिनकी समयसीमा खत्म हो गई है

ऐक्सेस टोकन की अवधि कम होती है. ये अक्सर कुछ ही मिनटों के लिए मान्य होते हैं.

टोकन रद्द करना

Google खाते का मालिक, पहले दी गई सहमति को कभी भी वापस ले सकता है. ऐसा करने से, मौजूदा ऐक्सेस टोकन और रीफ़्रेश टोकन अमान्य हो जाते हैं. revoke() का इस्तेमाल करके या Google खाते के ज़रिए, आपके प्लैटफ़ॉर्म से सदस्यता रद्द करने का अनुरोध किया जा सकता है.

Google साइन-इन के JavaScript क्लाइंट के रेफ़रंस को Google Identity Services से बदलें:

तरीके:

  • google.accounts.oauth2.revoke() के साथ getAuthInstance().disconnect()
  • google.accounts.oauth2.revoke() के साथ GoogleUser.disconnect()

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

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

आपके ऐप्लिकेशन को ऐक्सेस टोकन जारी करने से पहले, Google का मौजूदा और चालू सेशन ज़रूरी है. इससे उपयोगकर्ता की सहमति लेने और नतीजे को रिकॉर्ड करने का अनुरोध किया जा सकता है. अगर मौजूदा सेशन पहले से सेट अप नहीं किया गया है, तो उपयोगकर्ता को Google खाते में साइन इन करना पड़ सकता है.

उपयोगकर्ता के साइन-इन करने से जुड़ी सेटिंग

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

  • इससे उपयोगकर्ता को कम से कम बार साइन इन करना पड़ता है. ऐक्सेस टोकन का अनुरोध करने पर, Google खाते में साइन इन करने की प्रोसेस शुरू हो जाती है. ऐसा तब होता है, जब कोई चालू सेशन पहले से मौजूद न हो.
  • CodeClientConfig या TokenClientConfig ऑब्जेक्ट में, login_hint पैरामीटर की वैल्यू के तौर पर, JWT आईडी टोकन के credential email फ़ील्ड का सीधे तौर पर इस्तेमाल करें. यह खास तौर पर तब मददगार होता है, जब आपका प्लैटफ़ॉर्म उपयोगकर्ता खाता मैनेजमेंट सिस्टम को बनाए नहीं रखता है.
  • अपने प्लैटफ़ॉर्म पर मौजूद लोकल यूज़र खाते से Google खाते को ढूंढना और उसे जोड़ना. इससे आपके प्लैटफ़ॉर्म पर डुप्लीकेट खातों की संख्या कम करने में मदद मिलती है.
  • नया लोकल खाता बनाते समय, साइन-अप डायलॉग और फ़्लो को उपयोगकर्ता की पुष्टि करने वाले डायलॉग और फ़्लो से अलग किया जा सकता है. इससे ज़रूरी चरणों की संख्या कम हो जाती है और ड्रॉप-ऑफ़ रेट में सुधार होता है.

साइन इन करने के बाद और ऐक्सेस टोकन जारी होने से पहले, उपयोगकर्ताओं को अनुरोध किए गए स्कोप के लिए, आपके ऐप्लिकेशन को सहमति देनी होगी.

सहमति मिलने के बाद, ऐक्सेस टोकन वापस कर दिया जाता है. साथ ही, उन स्कोप की सूची भी वापस कर दी जाती है जिन्हें उपयोगकर्ता ने स्वीकार या अस्वीकार किया है.

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

इंप्लिसिट फ़्लो

Google Identity Services के साथ Google साइन-इन JavaScript क्लाइंट के रेफ़रंस बदलें:

ऑब्जेक्ट:

  • TokenClient.TokenResponse के साथ gapi.auth2.AuthorizeResponse
  • TokenClient.TokenResponse के साथ gapi.auth2.AuthResponse

तरीके:

  • google.accounts.oauth2.hasGrantedAllScopes() वाला GoogleUser.hasGrantedScopes()
  • google.accounts.oauth2.hasGrantedAllScopes() वाला GoogleUser.getGrantedScopes()

Google साइन-इन के JavaScript क्लाइंट के रेफ़रंस हटाएं:

तरीके:

  • GoogleUser.getAuthResponse()

अनुमति देने के इस उदाहरण का पालन करके, अपने वेब ऐप्लिकेशन को hasGrantedAllScopes() और hasGrantedAnyScope() के साथ अपडेट करें.

ऑथराइज़ेशन कोड का फ़्लो

ऑथराइज़ेशन कोड को मैनेज करने से जुड़े निर्देशों का पालन करके, अपने बैकएंड प्लैटफ़ॉर्म में ऑथराइज़ेशन कोड एंडपॉइंट को अपडेट करें या जोड़ें.

अनुरोध की पुष्टि करने के लिए, कोड मॉडल का इस्तेमाल करना गाइड में बताए गए तरीके अपनाएं. साथ ही, ऐक्सेस टोकन और रीफ़्रेश टोकन पाने के लिए, अपने प्लैटफ़ॉर्म को अपडेट करें.

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

इंप्लिसिट फ़्लो के उदाहरण

पुराना तरीका

GAPI क्लाइंट लाइब्रेरी

उपयोगकर्ता की सहमति लेने के लिए, पॉप-अप डायलॉग का इस्तेमाल करके ब्राउज़र में चल रही Google API Client Library for JavaScript का उदाहरण.

gapi.auth2 मॉड्यूल अपने-आप लोड हो जाता है और gapi.client.init() इसका इस्तेमाल करता है. इसलिए, यह छिपा होता है.

<!DOCTYPE html>
  <html>
    <head>
      <script src="https://apis.google.com/js/api.js"></script>
      <script>
        function start() {
          gapi.client.init({
            'apiKey': 'YOUR_API_KEY',
            'clientId': 'YOUR_CLIENT_ID',
            'scope': 'https://www.googleapis.com/auth/cloud-translation',
            'discoveryDocs': ['https://www.googleapis.com/discovery/v1/apis/translate/v2/rest'],
          }).then(function() {
            // Execute an API request which is returned as a Promise.
            // The method name language.translations.list comes from the API discovery.
            return gapi.client.language.translations.list({
              q: 'hello world',
              source: 'en',
              target: 'de',
            });
          }).then(function(response) {
            console.log(response.result.data.translations[0].translatedText);
          }, function(reason) {
            console.log('Error: ' + reason.result.error.message);
          });
        };

        // Load the JavaScript client library and invoke start afterwards.
        gapi.load('client', start);
      </script>
    </head>
    <body>
      <div id="results"></div>
    </body>
  </html>

JS क्लाइंट लाइब्रेरी

क्लाइंट-साइड वेब ऐप्लिकेशन के लिए OAuth 2.0, जो ब्राउज़र में चलता है. इसमें उपयोगकर्ता की सहमति लेने के लिए पॉप-अप डायलॉग का इस्तेमाल किया जाता है.

gapi.auth2 मॉड्यूल को मैन्युअल तरीके से लोड किया जाता है.

<!DOCTYPE html>
<html><head></head><body>
<script>
  var GoogleAuth;
  var SCOPE = 'https://www.googleapis.com/auth/drive.metadata.readonly';
  function handleClientLoad() {
    // Load the API's client and auth2 modules.
    // Call the initClient function after the modules load.
    gapi.load('client:auth2', initClient);
  }

  function initClient() {
    // In practice, your app can retrieve one or more discovery documents.
    var discoveryUrl = 'https://www.googleapis.com/discovery/v1/apis/drive/v3/rest';

    // Initialize the gapi.client object, which app uses to make API requests.
    // Get API key and client ID from Google Cloud console.
    // 'scope' field specifies space-delimited list of access scopes.
    gapi.client.init({
        'apiKey': 'YOUR_API_KEY',
        'clientId': 'YOUR_CLIENT_ID',
        'discoveryDocs': [discoveryUrl],
        'scope': SCOPE
    }).then(function () {
      GoogleAuth = gapi.auth2.getAuthInstance();

      // Listen for sign-in state changes.
      GoogleAuth.isSignedIn.listen(updateSigninStatus);

      // Handle initial sign-in state. (Determine if user is already signed in.)
      var user = GoogleAuth.currentUser.get();
      setSigninStatus();

      // Call handleAuthClick function when user clicks on
      //      "Sign In/Authorize" button.
      $('#sign-in-or-out-button').click(function() {
        handleAuthClick();
      });
      $('#revoke-access-button').click(function() {
        revokeAccess();
      });
    });
  }

  function handleAuthClick() {
    if (GoogleAuth.isSignedIn.get()) {
      // User is authorized and has clicked "Sign out" button.
      GoogleAuth.signOut();
    } else {
      // User is not signed in. Start Google auth flow.
      GoogleAuth.signIn();
    }
  }

  function revokeAccess() {
    GoogleAuth.disconnect();
  }

  function setSigninStatus() {
    var user = GoogleAuth.currentUser.get();
    var isAuthorized = user.hasGrantedScopes(SCOPE);
    if (isAuthorized) {
      $('#sign-in-or-out-button').html('Sign out');
      $('#revoke-access-button').css('display', 'inline-block');
      $('#auth-status').html('You are currently signed in and have granted ' +
          'access to this app.');
    } else {
      $('#sign-in-or-out-button').html('Sign In/Authorize');
      $('#revoke-access-button').css('display', 'none');
      $('#auth-status').html('You have not authorized this app or you are ' +
          'signed out.');
    }
  }

  function updateSigninStatus() {
    setSigninStatus();
  }
</script>

<button id="sign-in-or-out-button"
        style="margin-left: 25px">Sign In/Authorize</button>
<button id="revoke-access-button"
        style="display: none; margin-left: 25px">Revoke access</button>

<div id="auth-status" style="display: inline; padding-left: 25px"></div><hr>

<script src="https://ajax.googleapis.com/ajax/libs/jquery/1.11.3/jquery.min.js"></script>
<script async defer src="https://apis.google.com/js/api.js"
        onload="this.onload=function(){};handleClientLoad()"
        onreadystatechange="if (this.readyState === 'complete') this.onload()">
</script>
</body></html>

OAuth 2.0 एंडपॉइंट

क्लाइंट-साइड वेब ऐप्लिकेशन के लिए OAuth 2.0, ब्राउज़र में चलता है. यह उपयोगकर्ता की सहमति लेने के लिए, Google पर रीडायरेक्ट करता है.

इस उदाहरण में, उपयोगकर्ता के ब्राउज़र से Google के OAuth 2.0 एंडपॉइंट को सीधे तौर पर कॉल किया गया है. इसमें gapi.auth2 मॉड्यूल या JavaScript लाइब्रेरी का इस्तेमाल नहीं किया गया है.

<!DOCTYPE html>
<html><head></head><body>
<script>
  var YOUR_CLIENT_ID = 'REPLACE_THIS_VALUE';
  var YOUR_REDIRECT_URI = 'REPLACE_THIS_VALUE';
  var fragmentString = location.hash.substring(1);

  // Parse query string to see if page request is coming from OAuth 2.0 server.
  var params = {};
  var regex = /([^&=]+)=([^&]*)/g, m;
  while (m = regex.exec(fragmentString)) {
    params[decodeURIComponent(m[1])] = decodeURIComponent(m[2]);
  }
  if (Object.keys(params).length > 0) {
    localStorage.setItem('oauth2-test-params', JSON.stringify(params) );
    if (params['state'] && params['state'] == 'try_sample_request') {
      trySampleRequest();
    }
  }

  // If there's an access token, try an API request.
  // Otherwise, start OAuth 2.0 flow.
  function trySampleRequest() {
    var params = JSON.parse(localStorage.getItem('oauth2-test-params'));
    if (params && params['access_token']) {
      var xhr = new XMLHttpRequest();
      xhr.open('GET',
          'https://www.googleapis.com/drive/v3/about?fields=user&' +
          'access_token=' + params['access_token']);
      xhr.onreadystatechange = function (e) {
        if (xhr.readyState === 4 && xhr.status === 200) {
          console.log(xhr.response);
        } else if (xhr.readyState === 4 && xhr.status === 401) {
          // Token invalid, so prompt for user permission.
          oauth2SignIn();
        }
      };
      xhr.send(null);
    } else {
      oauth2SignIn();
    }
  }

  /*

    *   Create form to request access token from Google's OAuth 2.0 server.
 */
function oauth2SignIn() {
  // Google's OAuth 2.0 endpoint for requesting an access token
  var oauth2Endpoint = 'https://accounts.google.com/o/oauth2/v2/auth';

    // Create element to open OAuth 2.0 endpoint in new window.
    var form = document.createElement('form');
    form.setAttribute('method', 'GET'); // Send as a GET request.
    form.setAttribute('action', oauth2Endpoint);

    // Parameters to pass to OAuth 2.0 endpoint.
    var params = {'client_id': YOUR_CLIENT_ID,
                  'redirect_uri': YOUR_REDIRECT_URI,
                  'scope': 'https://www.googleapis.com/auth/drive.metadata.readonly',
                  'state': 'try_sample_request',
                  'include_granted_scopes': 'true',
                  'response_type': 'token'};

    // Add form parameters as hidden input values.
    for (var p in params) {
      var input = document.createElement('input');
      input.setAttribute('type', 'hidden');
      input.setAttribute('name', p);
      input.setAttribute('value', params[p]);
      form.appendChild(input);
    }

    // Add form to page and submit it to open the OAuth 2.0 endpoint.
    document.body.appendChild(form);
    form.submit();
  }
</script>

<button onclick="trySampleRequest();">Try sample request</button>
</body></html>

नया तरीका

सिर्फ़ जीआईएस

इस उदाहरण में, सिर्फ़ Google Identity Service JavaScript लाइब्रेरी दिखाई गई है. इसमें टोकन मॉडल का इस्तेमाल किया गया है और उपयोगकर्ता की सहमति के लिए पॉप-अप डायलॉग दिखाया गया है. यह सिर्फ़ यह दिखाने के लिए दिया गया है कि क्लाइंट को कॉन्फ़िगर करने, ऐक्सेस टोकन का अनुरोध करने और उसे पाने, और Google API को कॉल करने के लिए कम से कम कितने चरणों की ज़रूरत होती है.

<!DOCTYPE html>
<html>
  <head>
    <script src="https://accounts.google.com/gsi/client" onload="initClient()" async defer></script>
  </head>
  <body>
    <script>
      var client;
      var access_token;

      function initClient() {
        client = google.accounts.oauth2.initTokenClient({
          client_id: 'YOUR_CLIENT_ID',
          scope: 'https://www.googleapis.com/auth/calendar.readonly \
                  https://www.googleapis.com/auth/contacts.readonly',
          callback: (tokenResponse) => {
            access_token = tokenResponse.access_token;
          },
        });
      }
      function getToken() {
        client.requestAccessToken();
      }
      function revokeToken() {
        google.accounts.oauth2.revoke(access_token, () => {console.log('access token revoked')});
      }
      function loadCalendar() {
        var xhr = new XMLHttpRequest();
        xhr.open('GET', 'https://www.googleapis.com/calendar/v3/calendars/primary/events');
        xhr.setRequestHeader('Authorization', 'Bearer ' + access_token);
        xhr.send();
      }
    </script>
    <h1>Google Identity Services Authorization Token model</h1>
    <button onclick="getToken();">Get access token</button><br><br>
    <button onclick="loadCalendar();">Load Calendar</button><br><br>
    <button onclick="revokeToken();">Revoke token</button>
  </body>
</html>

GAPI async/await

इस उदाहरण में, टोकन मॉडल का इस्तेमाल करके Google Identity Services लाइब्रेरी जोड़ने, gapi.auth2 मॉड्यूल हटाने, और JavaScript के लिए Google API क्लाइंट लाइब्रेरी का इस्तेमाल करके एपीआई को कॉल करने का तरीका दिखाया गया है.

लाइब्रेरी को लोड करने के क्रम को लागू करने के लिए, Promises, async, और await का इस्तेमाल किया जाता है. साथ ही, इनका इस्तेमाल अनुमति से जुड़ी गड़बड़ियों को पकड़ने और फिर से कोशिश करने के लिए भी किया जाता है. एपीआई कॉल सिर्फ़ तब किया जाता है, जब मान्य ऐक्सेस टोकन उपलब्ध हो.

जब पेज पहली बार लोड होता है, तब ऐक्सेस टोकन मौजूद न होने पर या ऐक्सेस टोकन की समयसीमा खत्म होने के बाद, उपयोगकर्ताओं को 'कैलेंडर दिखाएं' बटन दबाना होगा.

<!DOCTYPE html>
<html>
<head>
    <title>GAPI and GIS Example</title>
    <script async defer src="https://apis.google.com/js/api.js" onload="gapiLoad()"></script>
    <script async defer src="https://accounts.google.com/gsi/client" onload="gisLoad()"></script>
</head>
<body>
    <h1>GAPI Client with GIS Authorization</h1>
    <button id="authorizeBtn" style="visibility:hidden;">Authorize and Load Events</button>
    <button id="revokeBtn" style="visibility:hidden;">Revoke Access</button>
    <div id="content"></div>

    <script>
        const YOUR_CLIENT_ID = "YOUR_CLIENT_ID";
        const YOUR_API_KEY = 'YOUR_API_KEY';
        const CALENDAR_SCOPE = 'https://www.googleapis.com/auth/calendar.readonly';

        let tokenClient;
        let libsLoaded = 0;

        function gapiLoad() {
            gapi.load('client', initGapiClient);
        }

        async function initGapiClient() {
            try {
                await gapi.client.init({ apiKey: YOUR_API_KEY });
                await gapi.client.load('https://www.googleapis.com/discovery/v1/apis/calendar/v3/rest');
                console.log('GAPI client initialized.');
                checkAllLoaded();
            } catch (err) {
                handleError('GAPI initialization failed:', err);
            }
        }

        function gisLoad() {
            try {
                tokenClient = google.accounts.oauth2.initTokenClient({
                    client_id: YOUR_CLIENT_ID,
                    scope: CALENDAR_SCOPE,
                    callback: '', // Will be set dynamically
                    error_callback: handleGisError,
                });
                console.log('GIS TokenClient initialized.');
                checkAllLoaded();
            } catch (err) {
                handleError('GIS initialization failed:', err);
            }
        }

        function checkAllLoaded() {
            libsLoaded++;
            if (libsLoaded === 2) {
                document.getElementById('authorizeBtn').style.visibility = 'visible';
                document.getElementById('revokeBtn').style.visibility = 'visible';
                document.getElementById('authorizeBtn').onclick = makeApiCall;
                document.getElementById('revokeBtn').onclick = revokeAccess;
                console.log('Ready to authorize.');
            }
        }

        function handleGisError(err) {
            console.error('GIS Error:', err);
            let message = 'An error occurred during authorization.';
            if (err && err.type === 'popup_failed_to_open') {
                message = 'Failed to open popup. Please disable popup blockers.';
            } else if (err && err.type === 'popup_closed') {
                message = 'Authorization popup was closed.';
            }
            document.getElementById('content').textContent = message;
        }

        function handleError(message, error) {
            console.error(message, error);
            document.getElementById('content').textContent = `${message} ${error.message || JSON.stringify(error)}`;
        }

        async function makeApiCall() {
            document.getElementById('content').textContent = 'Processing...';
            try {
                let token = gapi.client.getToken();
                if (!token || !token.access_token) {
                    console.log('No token, fetching one...');
                    await getToken();
                }

                console.log('Calling Calendar API...');
                const response = await gapi.client.calendar.events.list({ 'calendarId': 'primary' });
                displayEvents(response.result);
            } catch (err) {
                console.error('API call failed:', err);
                const errorInfo = err.result && err.result.error;
                if (errorInfo && (errorInfo.code === 401 || (errorInfo.code === 403 && errorInfo.status === "PERMISSION_DENIED"))) {
                    console.log('Auth error on API call, refreshing token...');
                    try {
                        await getToken({ prompt: 'consent' }); // Force refresh
                        const retryResponse = await gapi.client.calendar.events.list({ 'calendarId': 'primary' });
                        displayEvents(retryResponse.result);
                    } catch (refreshErr) {
                        handleError('Failed to refresh token or retry API call:', refreshErr);
                    }
                } else {
                    handleError('Error loading events:', err.result ? err.result.error : err);
                }
            }
        }

        async function getToken(options = { prompt: '' }) {
            return new Promise((resolve, reject) => {
                if (!tokenClient) return reject(new Error("GIS TokenClient not initialized."));
                tokenClient.callback = (tokenResponse) => {
                    if (tokenResponse.error) {
                        reject(new Error(`Token Error: ${tokenResponse.error} - ${tokenResponse.error_description}`));
                    } else {
                        console.log('Token acquired.');
                        resolve(tokenResponse);
                    }
                };
                tokenClient.requestAccessToken(options);
            });
        }

        function displayEvents(result) {
            const events = result.items;
            if (events && events.length > 0) {
                let eventList = '<h3>Upcoming Events:</h3><ul>' + events.map(event =>
                    `<li>${event.summary} (${event.start.dateTime || event.start.date})</li>`
                ).join('') + '</ul>';
                document.getElementById('content').innerHTML = eventList;
            } else {
                document.getElementById('content').textContent = 'No upcoming events found.';
            }
        }

        function revokeAccess() {
            const token = gapi.client.getToken();
            if (token && token.access_token) {
                google.accounts.oauth2.revoke(token.access_token, () => {
                    console.log('Access revoked.');
                    document.getElementById('content').textContent = 'Access has been revoked.';
                    gapi.client.setToken(null);
                });
            } else {
                document.getElementById('content').textContent = 'No token to revoke.';
            }
        }
    </script>
</body>
</html>

GAPI कॉलबैक

इस उदाहरण में, टोकन मॉडल का इस्तेमाल करके Google Identity Services लाइब्रेरी जोड़ने, gapi.auth2 मॉड्यूल हटाने, और JavaScript के लिए Google API क्लाइंट लाइब्रेरी का इस्तेमाल करके एपीआई को कॉल करने का तरीका दिखाया गया है.

वैरिएबल का इस्तेमाल, लाइब्रेरी लोड करने का क्रम लागू करने के लिए किया जाता है. GAPI कॉल, मान्य ऐक्सेस टोकन मिलने के बाद कॉलबैक के अंदर से किए जाते हैं.

जब पेज पहली बार लोड होता है, तब उपयोगकर्ताओं को 'कैलेंडर दिखाएं' बटन दबाना होता है. इसके बाद, जब उन्हें कैलेंडर की जानकारी रीफ़्रेश करनी होती है, तब उन्हें यह बटन फिर से दबाना होता है.

<!DOCTYPE html>
<html>
<head>
  <script async defer src="https://apis.google.com/js/api.js" onload="gapiLoad()"></script>
  <script async defer src="https://accounts.google.com/gsi/client" onload="gisInit()"></script>
</head>
<body>
  <h1>GAPI with GIS callbacks</h1>
  <button id="showEventsBtn" onclick="showEvents();">Show Calendar</button><br><br>
  <button id="revokeBtn" onclick="revokeToken();">Revoke access token</button>
  <script>
    let tokenClient;
    let gapiInited;
    let gisInited;

    document.getElementById("showEventsBtn").style.visibility="hidden";
    document.getElementById("revokeBtn").style.visibility="hidden";

    function checkBeforeStart() {
       if (gapiInited && gisInited){
          // Start only when both gapi and gis are initialized.
          document.getElementById("showEventsBtn").style.visibility="visible";
          document.getElementById("revokeBtn").style.visibility="visible";
       }
    }

    function gapiInit() {
      gapi.client.init({
        // NOTE: OAuth2 'scope' and 'client_id' parameters have moved to initTokenClient().
      })
      .then(function() {  // Load the Calendar API discovery document.
        gapi.client.load('https://www.googleapis.com/discovery/v1/apis/calendar/v3/rest');
        gapiInited = true;
        checkBeforeStart();
      });
    }

    function gapiLoad() {
        gapi.load('client', gapiInit)
    }

    function gisInit() {
     tokenClient = google.accounts.oauth2.initTokenClient({
                client_id: 'YOUR_CLIENT_ID',
                scope: 'https://www.googleapis.com/auth/calendar.readonly',
                callback: '',  // defined at request time
            });
      gisInited = true;
      checkBeforeStart();
    }

    function showEvents() {

      tokenClient.callback = (resp) => {
        if (resp.error !== undefined) {
          throw(resp);
        }
        // GIS has automatically updated gapi.client with the newly issued access token.
        console.log('gapi.client access token: ' + JSON.stringify(gapi.client.getToken()));

        gapi.client.calendar.events.list({ 'calendarId': 'primary' })
        .then(calendarAPIResponse => console.log(JSON.stringify(calendarAPIResponse)))
        .catch(err => console.log(err));

        document.getElementById("showEventsBtn").innerText = "Refresh Calendar";
      }

      // Conditionally ask users to select the Google Account they'd like to use,
      // and explicitly obtain their consent to fetch their Calendar.
      // NOTE: To request an access token a user gesture is necessary.
      if (gapi.client.getToken() === null) {
        // Prompt the user to select a Google Account and asked for consent to share their data
        // when establishing a new session.
        tokenClient.requestAccessToken({prompt: 'consent'});
      } else {
        // Skip display of account chooser and consent dialog for an existing session.
        tokenClient.requestAccessToken({prompt: ''});
      }
    }

    function revokeToken() {
      let cred = gapi.client.getToken();
      if (cred !== null) {
        google.accounts.oauth2.revoke(cred.access_token, () => {console.log('Revoked: ' + cred.access_token)});
        gapi.client.setToken('');
        document.getElementById("showEventsBtn").innerText = "Show Calendar";
      }
    }
  </script>
</body>
</html>

ऑथराइज़ेशन कोड फ़्लो के उदाहरण

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

पुराना तरीका

सर्वर-साइड वेब ऐप्लिकेशन

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

<!DOCTYPE html>
<html>
  <head>
    <script src="//ajax.googleapis.com/ajax/libs/jquery/1.8.2/jquery.min.js"></script>
    <script src="https://apis.google.com/js/client:platform.js?onload=start" async defer></script>
    <script>
      function start() {
        gapi.load('auth2', function() {
          auth2 = gapi.auth2.init({
            client_id: 'YOUR_CLIENT_ID',
            api_key: 'YOUR_API_KEY',
            discovery_docs: ['https://www.googleapis.com/discovery/v1/apis/translate/v2/rest'],
            // Scopes to request in addition to 'profile' and 'email'
            scope: 'https://www.googleapis.com/auth/cloud-translation',
          });
        });
      }
      function signInCallback(authResult) {
        if (authResult['code']) {
          console.log("sending AJAX request");
          // Send authorization code obtained from Google to backend platform
          $.ajax({
            type: 'POST',
            url: 'YOUR_AUTHORIZATION_CODE_ENDPOINT_URL',
            // Always include an X-Requested-With header to protect against CSRF attacks.
            headers: {
              'X-Requested-With': 'XMLHttpRequest'
            },
            contentType: 'application/octet-stream; charset=utf-8',
            success: function(result) {
              console.log(result);
            },
            processData: false,
            data: authResult['code']
          });
        } else {
          console.log('error: failed to obtain authorization code')
        }
      }
    </script>
  </head>
  <body>
    <button id="signinButton">Sign In With Google</button>
    <script>
      $('#signinButton').click(function() {
        // Obtain an authorization code from Google
        auth2.grantOfflineAccess().then(signInCallback);
      });
    </script>
  </body>
</html>

रीडायरेक्ट का इस्तेमाल करके एचटीटीपी/REST

वेब सर्वर ऐप्लिकेशन के लिए OAuth 2.0 का इस्तेमाल करना, ताकि उपयोगकर्ता के ब्राउज़र से आपकी बैकएंड प्लैटफ़ॉर्म को ऑथराइज़ेशन कोड भेजा जा सके. उपयोगकर्ता की सहमति को मैनेज किया जाता है. इसके लिए, उपयोगकर्ता के ब्राउज़र को Google पर रीडायरेक्ट किया जाता है.

/\*
 \* Create form to request access token from Google's OAuth 2.0 server.
 \*/
function oauthSignIn() {
  // Google's OAuth 2.0 endpoint for requesting an access token
  var oauth2Endpoint = 'https://accounts.google.com/o/oauth2/v2/auth';
  // Create &lt;form> element to submit parameters to OAuth 2.0 endpoint.
  var form = document.createElement('form');
  form.setAttribute('method', 'GET'); // Send as a GET request.
  form.setAttribute('action', oauth2Endpoint);
  // Parameters to pass to OAuth 2.0 endpoint.
  var params = {'client\_id': 'YOUR_CLIENT_ID',
                'redirect\_uri': 'YOUR_AUTHORIZATION_CODE_ENDPOINT_URL',
                'response\_type': 'token',
                'scope': 'https://www.googleapis.com/auth/drive.metadata.readonly',
                'include\_granted\_scopes': 'true',
                'state': 'pass-through value'};
  // Add form parameters as hidden input values.
  for (var p in params) {
    var input = document.createElement('input');
    input.setAttribute('type', 'hidden');
    input.setAttribute('name', p);
    input.setAttribute('value', params[p]);
    form.appendChild(input);
  }

  // Add form to page and submit it to open the OAuth 2.0 endpoint.
  document.body.appendChild(form);
  form.submit();
}

नया तरीका

GIS Popup UX

इस उदाहरण में, सिर्फ़ Google Identity Service JavaScript library दिखाई गई है. इसमें अनुमति कोड मॉडल का इस्तेमाल किया गया है. साथ ही, इसमें उपयोगकर्ता की सहमति के लिए पॉप-अप डायलॉग और Google से अनुमति कोड पाने के लिए कॉलबैक हैंडलर भी दिखाया गया है. इसे इसलिए उपलब्ध कराया गया है, ताकि आपको यह पता चल सके कि क्लाइंट को कॉन्फ़िगर करने, सहमति पाने, और अपने बैकएंड प्लैटफ़ॉर्म को अनुमति देने वाला कोड भेजने के लिए, कम से कम कितने चरणों की ज़रूरत होती है.

<!DOCTYPE html>
<html>
  <head>
    <script src="https://accounts.google.com/gsi/client" onload="initClient()" async defer></script>
  </head>
  <body>
    <script>
      var client;
      function initClient() {
        client = google.accounts.oauth2.initCodeClient({
          client_id: 'YOUR_CLIENT_ID',
          scope: 'https://www.googleapis.com/auth/calendar.readonly',
          ux_mode: 'popup',
          callback: (response) => {
            var code_receiver_uri = 'YOUR_AUTHORIZATION_CODE_ENDPOINT_URI',
            // Send auth code to your backend platform
            const xhr = new XMLHttpRequest();
            xhr.open('POST', code_receiver_uri, true);
            xhr.setRequestHeader('Content-Type', 'application/x-www-form-urlencoded');
            xhr.setRequestHeader('X-Requested-With', 'XMLHttpRequest');
            xhr.onload = function() {
              console.log('Signed in as: ' + xhr.responseText);
            };
            xhr.send('code=' + response.code);
            // After receipt, the code is exchanged for an access token and
            // refresh token, and the platform then updates this web app
            // running in user's browser with the requested calendar info.
          },
        });
      }
      function getAuthCode() {
        // Request authorization code and obtain user consent
        client.requestCode();
      }
    </script>
    <button onclick="getAuthCode();">Load Your Calendar</button>
  </body>
</html>

GIS Redirect UX

ऑथराइज़ेशन कोड मॉडल, पॉप-अप और रीडायरेक्ट यूज़र एक्सपीरियंस (यूएक्स) मोड के साथ काम करता है. इससे, आपके प्लैटफ़ॉर्म पर होस्ट किए गए एंडपॉइंट को हर उपयोगकर्ता के लिए ऑथराइज़ेशन कोड भेजा जा सकता है. रीडायरेक्ट यूज़र एक्सपीरियंस (यूएक्स) मोड यहां दिखाया गया है:

<!DOCTYPE html>
<html>
  <head>
    <script src="https://accounts.google.com/gsi/client" onload="initClient()" async defer></script>
  </head>
  <body>
    <script>
      var client;
      function initClient() {
        client = google.accounts.oauth2.initCodeClient({
          client_id: 'YOUR_CLIENT_ID',
          scope: 'https://www.googleapis.com/auth/calendar.readonly \
                  https://www.googleapis.com/auth/photoslibrary.readonly',
          ux_mode: 'redirect',
          redirect_uri: 'YOUR_AUTHORIZATION_CODE_ENDPOINT_URI'
        });
      }
      // Request an access token
      function getAuthCode() {
        // Request authorization code and obtain user consent
        client.requestCode();
      }
    </script>
    <button onclick="getAuthCode();">Load Your Calendar</button>
  </body>
</html>

JavaScript लाइब्रेरी

Google Identity Services एक JavaScript लाइब्रेरी है. इसका इस्तेमाल उपयोगकर्ता की पुष्टि करने और अनुमति देने के लिए किया जाता है. यह कई अलग-अलग लाइब्रेरी और मॉड्यूल में मौजूद सुविधाओं और फ़ंक्शन को एक साथ जोड़ती है और उनकी जगह लेती है:

Identity Services पर माइग्रेट करते समय ये कार्रवाइयां करें:

मौजूदा JS लाइब्रेरी नई JS लाइब्रेरी नोट
apis.google.com/js/api.js accounts.google.com/gsi/client नई लाइब्रेरी जोड़ें और इंप्लिसिट फ़्लो का पालन करें.
apis.google.com/js/client.js accounts.google.com/gsi/client नई लाइब्रेरी और ऑथराइज़ेशन कोड फ़्लो जोड़ा गया.

लाइब्रेरी के बारे में एक नज़र में जानकारी

पुरानी Google Sign-In JavaScript क्लाइंट लाइब्रेरी और नई Google Identity Services लाइब्रेरी के ऑब्जेक्ट और तरीकों की तुलना. साथ ही, माइग्रेशन के दौरान की जाने वाली कार्रवाई और अतिरिक्त जानकारी के साथ नोट.

पुराना नई सुविधा नोट
GoogleAuth ऑब्जेक्ट और उससे जुड़े तरीके:
GoogleAuth.attachClickHandler() हटाएं
GoogleAuth.currentUser.get() हटाएं
GoogleAuth.currentUser.listen() हटाएं
GoogleAuth.disconnect() google.accounts.oauth2.revoke पुराने को नए से बदलें. https://myaccount.google.com/permissions पर जाकर भी ऐक्सेस वापस लिया जा सकता है
GoogleAuth.grantOfflineAccess() हटाएं और ऑथराइज़ेशन कोड फ़्लो का पालन करें.
GoogleAuth.isSignedIn.get() हटाएं
GoogleAuth.isSignedIn.listen() हटाएं
GoogleAuth.signIn() हटाएं
GoogleAuth.signOut() हटाएं
GoogleAuth.then() हटाएं
GoogleUser ऑब्जेक्ट और उससे जुड़े तरीके:
GoogleUser.disconnect() google.accounts.id.revoke पुराने को नए से बदलें. https://myaccount.google.com/permissions पर जाकर भी ऐक्सेस वापस लिया जा सकता है
GoogleUser.getAuthResponse() requestCode() or requestAccessToken() पुराने डिवाइस की जगह नया डिवाइस इस्तेमाल करना
GoogleUser.getBasicProfile() हटाएं पर टैप करें. इसके बजाय, आईडी टोकन का इस्तेमाल करें. इसके बारे में जानने के लिए, Google साइन-इन से माइग्रेट करना लेख पढ़ें.
GoogleUser.getGrantedScopes() hasGrantedAnyScope() पुराने डिवाइस की जगह नया डिवाइस इस्तेमाल करना
GoogleUser.getHostedDomain() हटाएं
GoogleUser.getId() हटाएं
GoogleUser.grantOfflineAccess() हटाएं और ऑथराइज़ेशन कोड फ़्लो का पालन करें.
GoogleUser.grant() हटाएं
GoogleUser.hasGrantedScopes() hasGrantedAnyScope() पुराने डिवाइस की जगह नया डिवाइस इस्तेमाल करना
GoogleUser.isSignedIn() हटाएं
GoogleUser.reloadAuthResponse() requestAccessToken() पुराने ऐक्सेस टोकन को हटाएं और नया ऐक्सेस टोकन पाने के लिए कॉल करें. ऐसा तब करें, जब ऐक्सेस टोकन की समयसीमा खत्म हो गई हो या उसे रद्द कर दिया गया हो.
gapi.auth2 ऑब्जेक्ट और उससे जुड़े तरीके:
gapi.auth2.AuthorizeConfig ऑब्जेक्ट TokenClientConfig या CodeClientConfig पुराने डिवाइस की जगह नया डिवाइस इस्तेमाल करना
gapi.auth2.AuthorizeResponse ऑब्जेक्ट हटाएं
gapi.auth2.AuthResponse ऑब्जेक्ट हटाएं
gapi.auth2.authorize() requestCode() or requestAccessToken() पुराने डिवाइस की जगह नया डिवाइस इस्तेमाल करना
gapi.auth2.ClientConfig() TokenClientConfig या CodeClientConfig पुराने डिवाइस की जगह नया डिवाइस इस्तेमाल करना
gapi.auth2.getAuthInstance() हटाएं
gapi.auth2.init() initTokenClient() or initCodeClient() पुराने डिवाइस की जगह नया डिवाइस इस्तेमाल करना
gapi.auth2.OfflineAccessOptions ऑब्जेक्ट हटाएं
gapi.auth2.SignInOptions ऑब्जेक्ट हटाएं
gapi.signin2 ऑब्जेक्ट और उससे जुड़े तरीके:
gapi.signin2.render() हटाएं पर टैप करें. g_id_signin एलिमेंट का एचटीएमएल डीओएम लोड होने पर या google.accounts.id.renderButton को JS कॉल करने पर, उपयोगकर्ता को Google खाते में साइन इन करने के लिए ट्रिगर किया जाता है.

क्रेडेंशियल का उदाहरण

मौजूदा क्रेडेंशियल

Google Sign-In प्लैटफ़ॉर्म लाइब्रेरी, JavaScript के लिए Google API Client Library या Google OAuth 2.0 एंडपॉइंट को सीधे तौर पर कॉल करने पर, एक ही जवाब में OAuth 2.0 ऐक्सेस टोकन और OpenID Connect आईडी टोकन, दोनों मिलते हैं.

access_token और id_token, दोनों को शामिल करने वाले जवाब का उदाहरण:

  {
    "token_type": "Bearer",
    "access_token": "ya29.A0ARrdaM-SmArZaCIh68qXsZSzyeU-8mxhQERHrP2EXtxpUuZ-3oW8IW7a6D2J6lRnZrRj8S6-ZcIl5XVEqnqxq5fuMeDDH_6MZgQ5dgP7moY-yTiKR5kdPm-LkuPM-mOtUsylWPd1wpRmvw_AGOZ1UUCa6UD5Hg",
    "scope": "https://www.googleapis.com/auth/calendar.readonly",
    "login_hint": "AJDLj6I2d1RH77cgpe__DdEree1zxHjZJr4Q7yOisoumTZUmo5W2ZmVFHyAomUYzLkrluG-hqt4RnNxrPhArd5y6p8kzO0t8xIfMAe6yhztt6v2E-_Bb4Ec3GLFKikHSXNh5bI-gPrsI",
    "expires_in": 3599,
    "id_token": "eyJhbGciOiJSUzI1NiIsImtpZCI6IjkzNDFhYmM0MDkyYjZmYzAzOGU0MDNjOTEwMjJkZDNlNDQ1MzliNTYiLCJ0eXAiOiJKV1QifQ.eyJpc3MiOiJhY2NvdW50cy5nb29nbGUuY29tIiwiYXpwIjoiNTM4MzQ0NjUzMjU1LTc1OGM1aDVpc2M0NXZnazI3ZDhoOGRlYWJvdnBnNnRvLmFwcHMuZ29vZ2xldXNlcmNvbnRlbnQuY29tIiwiYXVkIjoiNTM4MzQ0NjUzMjU1LTc1OGM1aDVpc2M0NXZnazI3ZDhoOGRlYWJvdnBnNnRvLmFwcHMuZ29vZ2xldXNlcmNvbnRlbnQuY29tIiwic3ViIjoiMTE3NzI2NDMxNjUxOTQzNjk4NjAwIiwiaGQiOiJnb29nbGUuY29tIiwiZW1haWwiOiJkYWJyaWFuQGdvb2dsZS5jb20iLCJlbWFpbF92ZXJpZmllZCI6dHJ1ZSwiYXRfaGFzaCI6IkJBSW55TjN2MS1ZejNLQnJUMVo0ckEiLCJuYW1lIjoiQnJpYW4gRGF1Z2hlcnR5IiwicGljdHVyZSI6Imh0dHBzOi8vbGgzLmdvb2dsZXVzZXJjb250ZW50LmNvbS9hLS9BT2gxNEdnenAyTXNGRGZvbVdMX3VDemRYUWNzeVM3ZGtxTE5ybk90S0QzVXNRPXM5Ni1jIiwiZ2l2ZW5fbmFtZSI6IkJyaWFuIiwiZmFtaWx5X25hbWUiOiJEYXVnaGVydHkiLCJsb2NhbGUiOiJlbiIsImlhdCI6MTYzODk5MTYzOCwiZXhwIjoxNjM4OTk1MjM4LCJqdGkiOiI5YmRkZjE1YWFiNzE2ZDhjYmJmNDYwMmM1YWM3YzViN2VhMDQ5OTA5In0.K3EA-3Adw5HA7O8nJVCsX1HmGWxWzYk3P7ViVBb4H4BoT2-HIgxKlx1mi6jSxIUJGEekjw9MC-nL1B9Asgv1vXTMgoGaNna0UoEHYitySI23E5jaMkExkTSLtxI-ih2tJrA2ggfA9Ekj-JFiMc6MuJnwcfBTlsYWRcZOYVw3QpdTZ_VYfhUu-yERAElZCjaAyEXLtVQegRe-ymScra3r9S92TA33ylMb3WDTlfmDpWL0CDdDzby2asXYpl6GQ7SdSj64s49Yw6mdGELZn5WoJqG7Zr2KwIGXJuSxEo-wGbzxNK-mKAiABcFpYP4KHPEUgYyz3n9Vqn2Tfrgp-g65BQ",
    "session_state": {
      "extraQueryParams": {
        "authuser": "0"
      }
    },
    "first_issued_at": 1638991637982,
    "expires_at": 1638995236982,
    "idpId": "google"
  }

Google Identity Services क्रेडेंशियल

Google Identity Services लाइब्रेरी ये वैल्यू दिखाती है:

  • ऑथराइज़ेशन के लिए इस्तेमाल किया जाने वाला ऐक्सेस टोकन:

    {
  "access_token": "ya29.A0ARrdaM_LWSO-uckLj7IJVNSfnUityT0Xj-UCCrGxFQdxmLiWuAosnAKMVQ2Z0LLqeZdeJii3TgULp6hR_PJxnInBOl8UoUwWoqsrGQ7-swxgy97E8_hnzfhrOWyQBmH6zs0_sUCzwzhEr_FAVqf92sZZHphr0g",
  "token_type": "Bearer",
  "expires_in": 3599,
  "scope": "https://www.googleapis.com/auth/calendar.readonly"
}

  • या, पुष्टि करने के लिए इस्तेमाल किया गया आईडी टोकन:

    {
  "clientId": "538344653255-758c5h5isc45vgk27d8h8deabovpg6to.apps.googleusercontent.com",
  "credential": "eyJhbGciOiJSUzI1NiIsImtpZCI6ImMxODkyZWI0OWQ3ZWY5YWRmOGIyZTE0YzA1Y2EwZDAzMjcxNGEyMzciLCJ0eXAiOiJKV1QifQ.eyJpc3MiOiJodHRwczovL2FjY291bnRzLmdvb2dsZS5jb20iLCJuYmYiOjE2MzkxNTcyNjQsImF1ZCI6IjUzODM0NDY1MzI1NS03NThjNWg1aXNjNDV2Z2syN2Q4aDhkZWFib3ZwZzZ0by5hcHBzLmdvb2dsZXVzZXJjb250ZW50LmNvbSIsInN1YiI6IjExNzcyNjQzMTY1MTk0MzY5ODYwMCIsIm5vbmNlIjoiZm9vYmFyIiwiaGQiOiJnb29nbGUuY29tIiwiZW1haWwiOiJkYWJyaWFuQGdvb2dsZS5jb20iLCJlbWFpbF92ZXJpZmllZCI6dHJ1ZSwiYXpwIjoiNTM4MzQ0NjUzMjU1LTc1OGM1aDVpc2M0NXZnazI3ZDhoOGRlYWJvdnBnNnRvLmFwcHMuZ29vZ2xldXNlcmNvbnRlbnQuY29tIiwibmFtZSI6IkJyaWFuIERhdWdoZXJ0eSIsInBpY3R1cmUiOiJodHRwczovL2xoMy5nb29nbGV1c2VyY29udGVudC5jb20vYS0vQU9oMTRHZ3pwMk1zRkRmb21XTF91Q3pkWFFjc3lTN2RrcUxOcm5PdEtEM1VzUT1zOTYtYyIsImdpdmVuX25hbWUiOiJCcmlhbiIsImZhbWlseV9uYW1lIjoiRGF1Z2hlcnR5IiwiaWF0IjoxNjM5MTU3NTY0LCJleHAiOjE2MzkxNjExNjQsImp0aSI6IjRiOTVkYjAyZjU4NDczMmUxZGJkOTY2NWJiMWYzY2VhYzgyMmI0NjUifQ.Cr-AgMsLFeLurnqyGpw0hSomjOCU4S3cU669Hyi4VsbqnAV11zc_z73o6ahe9Nqc26kPVCNRGSqYrDZPfRyTnV6g1PIgc4Zvl-JBuy6O9HhClAK1HhMwh1FpgeYwXqrng1tifmuotuLQnZAiQJM73Gl-J_6s86Buo_1AIx5YAKCucYDUYYdXBIHLxrbALsA5W6pZCqqkMbqpTWteix-G5Q5T8LNsfqIu_uMBUGceqZWFJALhS9ieaDqoxhIqpx_89QAr1YlGu_UO6R6FYl0wDT-nzjyeF5tonSs3FHN0iNIiR3AMOHZu7KUwZaUdHg4eYkU-sQ01QNY_11keHROCRQ",
  "select_by": "user"
}

टोकन का अमान्य जवाब

समयसीमा खत्म हो चुके, रद्द किए गए या अमान्य ऐक्सेस टोकन का इस्तेमाल करके एपीआई अनुरोध करने पर, Google से मिला जवाब:

एचटीटीपी रिस्पॉन्स हेडर

  www-authenticate: Bearer realm="https://accounts.google.com/", error="invalid_token"

जवाब का मुख्य हिस्सा

  {
    "error": {
      "code": 401,
      "message": "Request had invalid authentication credentials. Expected OAuth 2 access token, login cookie or other valid authentication credential. See https://developers.google.com/identity/sign-in/web/devconsole-project.",
      "errors": [
        {
          "message": "Invalid Credentials",
          "domain": "global",
          "reason": "authError",
          "location": "Authorization",
          "locationType": "header"
        }
      ],
      "status": "UNAUTHENTICATED"
    }
  }