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 को कॉल करता है. इसके लिए, उपयोगकर्ताओं को उनके मौजूद होने की ज़रूरत नहीं होती. इसे ऑफ़लाइन मोड भी कहा जाता है.

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

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

ऑथराइज़ेशन फ़्लो चुनें

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

दोनों फ़्लो के बीच के मुख्य अंतर और ट्रेड-ऑफ़ को समझने के लिए, ऑथराइज़ेशन फ़्लो चुनने की समीक्षा करें.

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

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

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

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

इंप्लिसिट फ़्लो के उदाहरण में, पहचान सेवाओं पर माइग्रेट करने से पहले और बाद में, वेब ऐप्लिकेशन दिखाए जाते हैं.

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

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 लाइब्रेरी से बदल देता है.

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

<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 मेथड अपने-आप बनाने की सुविधा का फ़ायदा लें, कई एपीआई कॉल के बैच बनाएं, और सीओआरएस मैनेजमेंट की सुविधा दें.

कुकी

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

उपयोगकर्ता की पुष्टि करने वाले टूल और कुकी का इस्तेमाल कैसे किया जाता है, इस बारे में जानने के लिए 'Google साइन-इन' से डेटा दूसरी जगह भेजना देखें. साथ ही, यह देखें कि Google के दूसरे प्रॉडक्ट और सेवाओं में कुकी का इस्तेमाल करने के लिए, Google, कुकी का इस्तेमाल कैसे करता है.

क्रेडेंशियल

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

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

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

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

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

तरीके

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

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

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

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

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

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

ये '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 साइन-इन' JavaScript क्लाइंट रेफ़रंस को Google Identity Services से बदलें:

ऑब्जेक्ट:

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

तरीके:

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

पैरामीटर:

  • TokenClientConfig.login_hint के साथ gapi.auth2.AuthorizeConfig.login_hint.
  • TokenClientConfig.hd के साथ gapi.auth2.GoogleUser.getHostedDomain().

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

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

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

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

ऑब्जेक्ट:

  • gapi.auth2.AuthorizeConfig

तरीके:

  • gapi.auth2.init()

पैरामीटर:

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

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

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

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

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

'Google साइन-इन' JavaScript क्लाइंट रेफ़रंस बदलें: Google पहचान सेवाओं से:

तरीके:

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

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

अपने कोड बेस को इसमें अपडेट करें:

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

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

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

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

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

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

टोकन हैंडलिंग

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

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

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

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

टोकन निरस्त करना

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

'Google साइन-इन' JavaScript क्लाइंट रेफ़रंस बदलें: Google पहचान सेवाओं से:

तरीके:

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

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

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

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

उपयोगकर्ता साइन इन

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

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

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

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

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

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

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

ऑब्जेक्ट:

  • 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 क्लाइंट लाइब्रेरी

JavaScript के लिए Google एपीआई क्लाइंट लाइब्रेरी का उदाहरण. यह उपयोगकर्ता की सहमति के लिए पॉप-अप डायलॉग का इस्तेमाल करके, ब्राउज़र में चल रहा है.

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

<!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 API 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>

नया तरीका

सिर्फ़ GIS

इस उदाहरण में, उपयोगकर्ता की सहमति के लिए सिर्फ़ टोकन मॉडल का इस्तेमाल करने और पॉप-अप डायलॉग का इस्तेमाल करने वाली 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 सेवा लाइब्रेरी को जोड़ने, gapi.auth2 मॉड्यूल हटाने, और एपीआई को कॉल करने के लिए, JavaScript के लिए Google API क्लाइंट लाइब्रेरी का इस्तेमाल करने का तरीका बताया गया है.

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

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

<!DOCTYPE html>
<html>
<head></head>
<body>
  <h1>GAPI with GIS async/await</h1>
  <button id="showEventsBtn" onclick="showEvents();">Show Calendar</button><br><br>
  <button id="revokeBtn" onclick="revokeToken();">Revoke access token</button>

  <script>

    const gapiLoadPromise = new Promise((resolve, reject) => {
      gapiLoadOkay = resolve;
      gapiLoadFail = reject;
    });
    const gisLoadPromise = new Promise((resolve, reject) => {
      gisLoadOkay = resolve;
      gisLoadFail = reject;
    });

    var tokenClient;

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

      // First, load and initialize the gapi.client
      await gapiLoadPromise;
      await new Promise((resolve, reject) => {
        // NOTE: the 'auth2' module is no longer loaded.
        gapi.load('client', {callback: resolve, onerror: reject});
      });
      await 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');
      });

      // Now load the GIS client
      await gisLoadPromise;
      await new Promise((resolve, reject) => {
        try {
          tokenClient = google.accounts.oauth2.initTokenClient({
              client_id: 'YOUR_CLIENT_ID',
              scope: 'https://www.googleapis.com/auth/calendar.readonly',
              prompt: 'consent',
              callback: '',  // defined at request time in await/promise scope.
          });
          resolve();
        } catch (err) {
          reject(err);
        }
      });

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

    async function getToken(err) {

      if (err.result.error.code == 401 || (err.result.error.code == 403) &&
          (err.result.error.status == "PERMISSION_DENIED")) {

        // The access token is missing, invalid, or expired, prompt for user consent to obtain one.
        await new Promise((resolve, reject) => {
          try {
            // Settle this promise in the response callback for requestAccessToken()
            tokenClient.callback = (resp) => {
              if (resp.error !== undefined) {
                reject(resp);
              }
              // GIS has automatically updated gapi.client with the newly issued access token.
              console.log('gapi.client access token: ' + JSON.stringify(gapi.client.getToken()));
              resolve(resp);
            };
            tokenClient.requestAccessToken();
          } catch (err) {
            console.log(err)
          }
        });
      } else {
        // Errors unrelated to authorization: server errors, exceeding quota, bad requests, and so on.
        throw new Error(err);
      }
    }

    function showEvents() {

      // Try to fetch a list of Calendar events. If a valid access token is needed,
      // prompt to obtain one and then retry the original request.
      gapi.client.calendar.events.list({ 'calendarId': 'primary' })
      .then(calendarAPIResponse => console.log(JSON.stringify(calendarAPIResponse)))
      .catch(err  => getToken(err))  // for authorization errors obtain an access token
      .then(retry => gapi.client.calendar.events.list({ 'calendarId': 'primary' }))
      .then(calendarAPIResponse => console.log(JSON.stringify(calendarAPIResponse)))
      .catch(err  => console.log(err)); // cancelled by user, timeout, etc.
    }

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

  </script>

  <script async defer src="https://apis.google.com/js/api.js" onload="gapiLoadOkay()" onerror="gapiLoadFail(event)"></script>
  <script async defer src="https://accounts.google.com/gsi/client" onload="gisLoadOkay()" onerror="gisLoadFail(event)"></script>

</body>
</html>

GAPI कॉलबैक

इस उदाहरण में, टोकन मॉडल का इस्तेमाल करके, Google Identity सेवा लाइब्रेरी को जोड़ने, 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 सेवा लाइब्रेरी का पॉप-अप UX, सीधे अपने बैकएंड टोकन एंडपॉइंट पर ऑथराइज़ेशन कोड दिखाने के लिए, यूआरएल रीडायरेक्ट का इस्तेमाल कर सकता है. इसके अलावा, यह उपयोगकर्ता के ब्राउज़र में चल रहे 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 पॉप-अप UX

इस उदाहरण में सिर्फ़ ऑथराइज़ेशन कोड मॉडल का इस्तेमाल करके, 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 रीडायरेक्ट UX

ऑथराइज़ेशन कोड मॉडल, पॉप-अप और रीडायरेक्ट UX मोड के साथ काम करता है. इससे आपके प्लैटफ़ॉर्म पर होस्ट किए गए एंडपॉइंट पर, हर उपयोगकर्ता का ऑथराइज़ेशन कोड भेजा जाता है. रीडायरेक्ट 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 साइन-इन JavaScript क्लाइंट लाइब्रेरी और नई Google Identity Services लाइब्रेरी और Notes के बीच ऑब्जेक्ट और उनके तरीकों की तुलना. इसमें माइग्रेशन के दौरान की जाने वाली अतिरिक्त जानकारी और कार्रवाई की जानकारी शामिल है.

ओल्ड नए दर्शक ज़रूरी जानकारी
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 एलिमेंट की एचटीएमएल DOM लोडिंग या google.accounts.id.renderButton से JS कॉल, उपयोगकर्ता के Google खाते में साइन इन को ट्रिगर करता है.

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

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

Google साइन-इन प्लैटफ़ॉर्म लाइब्रेरी, JavaScript के लिए Google एपीआई क्लाइंट लाइब्रेरी या Google Auth 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"
    }
  }