Google uses AI technology to translate content into your preferred language. AI translations can contain errors.

JavaScript के साथ GitHub का इस्तेमाल करके पुष्टि करें

अपने ऐप्लिकेशन में GitHub से पुष्टि करने की सुविधा इंटिग्रेट करके, उपयोगकर्ताओं को अपने GitHub खातों का इस्तेमाल करके Firebase से पुष्टि करने की अनुमति दी जा सकती है. GitHub से पुष्टि करने की सुविधा को दो तरीकों से इंटिग्रेट किया जा सकता है. पहला, साइन-इन फ़्लो को पूरा करने के लिए Firebase SDK का इस्तेमाल करना. दूसरा, GitHub OAuth 2.0 फ़्लो को मैन्युअल तरीके से पूरा करना और Firebase को ऐक्सेस टोकन पास करना.

शुरू करने से पहले

अपने JavaScript प्रोजेक्ट में Firebase जोड़ें.
Firebase कंसोल में, सुरक्षा > पुष्टि करना पर जाएं.
साइन-इन करने का तरीका टैब में, GitHub साइन-इन प्रोवाइडर को चालू करें.
प्रोवाइडर के कॉन्फ़िगरेशन में, उस प्रोवाइडर के डेवलपर कंसोल से क्लाइंट आईडी और क्लाइंट सीक्रेट जोड़ें:
1. अपने ऐप्लिकेशन को रजिस्टर करें GitHub पर डेवलपर ऐप्लिकेशन के तौर पर और अपने ऐप्लिकेशन के लिए OAuth 2.0 क्लाइंट आईडी और क्लाइंट सीक्रेट पाएं.
2. पक्का करें कि आपका Firebase OAuth रीडायरेक्ट यूआरआई (उदाहरण के लिए, my-app-12345.firebaseapp.com/__/auth/handler) आपके GitHub ऐप्लिकेशन के कॉन्फ़िगरेशन में, आपके ऐप्लिकेशन की सेटिंग वाले पेज पर ऑथराइज़ेशन कॉलबैक यूआरएल के तौर पर सेट हो.
सेव करें पर क्लिक करें.

Firebase SDK की मदद से साइन-इन फ़्लो को मैनेज करना

अगर कोई वेब ऐप्लिकेशन बनाया जा रहा है, तो उपयोगकर्ताओं को उनके GitHub खातों का इस्तेमाल करके Firebase से पुष्टि करने की अनुमति देने का सबसे आसान तरीका है कि Firebase JavaScript SDK की मदद से साइन-इन फ़्लो को मैनेज किया जाए. (अगर आपको Node.js या ब्राउज़र के अलावा किसी अन्य एनवायरमेंट में किसी उपयोगकर्ता की पुष्टि करनी है, तो आपको साइन-इन फ़्लो को मैन्युअल तरीके से मैनेज करना होगा.)

Firebase JavaScript SDK की मदद से साइन-इन फ़्लो को मैनेज करने के लिए, यह तरीका अपनाएं:

GitHub प्रोवाइडर ऑब्जेक्ट का इंस्टेंस बनाएं:

Web

import { GithubAuthProvider } from "firebase/auth";

const provider = new GithubAuthProvider();auth_github_provider_create.js

Web

var provider = new firebase.auth.GithubAuthProvider();github.js

ज़रूरी नहीं: OAuth 2.0 के वे अतिरिक्त स्कोप तय करें जिनका अनुरोध आपको पुष्टि करने वाले प्रोवाइडर से करना है. कोई स्कोप जोड़ने के लिए, कॉल करें addScope. उदाहरण के लिए:
Web
```
provider.addScope('repo');auth_github_provider_scopes.js
```
Web
```
provider.addScope('repo');github.js
```
पुष्टि करने वाले प्रोवाइडर का दस्तावेज़ देखें.
ज़रूरी नहीं: OAuth के वे अतिरिक्त कस्टम पैरामीटर तय करें जिन्हें आपको OAuth के अनुरोध के साथ भेजना है. कोई कस्टम पैरामीटर जोड़ने के लिए, शुरू किए गए प्रोवाइडर पर setCustomParameters को कॉल करें. इसके साथ, एक ऐसा ऑब्जेक्ट इस्तेमाल करें जिसमें OAuth प्रोवाइडर के दस्तावेज़ में बताई गई कुंजी और उससे जुड़ी वैल्यू शामिल हो. उदाहरण के लिए:
Web
```
provider.setCustomParameters({
  'allow_signup': 'false'
});auth_github_provider_params.js
```
Web
```
provider.setCustomParameters({
  'allow_signup': 'false'
});github.js
```
OAuth के ज़रूरी पैरामीटर रिज़र्व नहीं किए जा सकते. इसलिए, उन्हें अनदेखा कर दिया जाएगा. ज़्यादा जानकारी के लिए, पुष्टि करने वाले प्रोवाइडर का रेफ़रंस देखें.

GitHub प्रोवाइडर ऑब्जेक्ट का इस्तेमाल करके, Firebase से पुष्टि करें. उपयोगकर्ताओं को उनके GitHub खातों से साइन इन करने के लिए, पॉप-अप विंडो खोलकर या साइन-इन पेज पर रीडायरेक्ट करके प्रॉम्प्ट किया जा सकता है. मोबाइल डिवाइसों पर, रीडायरेक्ट करने का तरीका बेहतर होता है.

पॉप-अप विंडो की मदद से साइन इन करने के लिए, signInWithPopup को कॉल करें:

Web

import { getAuth, signInWithPopup, GithubAuthProvider } from "firebase/auth";

const auth = getAuth();
signInWithPopup(auth, provider)
  .then((result) => {
    // This gives you a GitHub Access Token. You can use it to access the GitHub API.
    const credential = GithubAuthProvider.credentialFromResult(result);
    const token = credential.accessToken;

    // The signed-in user info.
    const user = result.user;
    // IdP data available using getAdditionalUserInfo(result)
    // ...
  }).catch((error) => {
    // Handle Errors here.
    const errorCode = error.code;
    const errorMessage = error.message;
    // The email of the user's account used.
    const email = error.customData.email;
    // The AuthCredential type that was used.
    const credential = GithubAuthProvider.credentialFromError(error);
    // ...
  });auth_github_signin_popup.js

Web

firebase
  .auth()
  .signInWithPopup(provider)
  .then((result) => {
    /** @type {firebase.auth.OAuthCredential} */
    var credential = result.credential;

    // This gives you a GitHub Access Token. You can use it to access the GitHub API.
    var token = credential.accessToken;

    // The signed-in user info.
    var user = result.user;
    // IdP data available in result.additionalUserInfo.profile.
      // ...
  }).catch((error) => {
    // Handle Errors here.
    var errorCode = error.code;
    var errorMessage = error.message;
    // The email of the user's account used.
    var email = error.email;
    // The firebase.auth.AuthCredential type that was used.
    var credential = error.credential;
    // ...
  });github.js

इसके अलावा, ध्यान दें कि GitHub प्रोवाइडर का OAuth टोकन वापस पाया जा सकता है. इसका इस्तेमाल, GitHub के एपीआई की मदद से अतिरिक्त डेटा फ़ेच करने के लिए किया जा सकता है.

यहां गड़बड़ियों को पकड़ा और ठीक भी किया जा सकता है. गड़बड़ी कोड की सूची देखने के लिए, Auth रेफ़रंस के दस्तावेज़ देखें.

साइन-इन पेज पर रीडायरेक्ट करके साइन इन करने के लिए, signInWithRedirect को कॉल करें: `signInWithRedirect` का इस्तेमाल करते समय, सबसे सही तरीकों का पालन करें.

Web

import { getAuth, signInWithRedirect } from "firebase/auth";

const auth = getAuth();
signInWithRedirect(auth, provider);auth_signin_redirect.js

Web

firebase.auth().signInWithRedirect(provider);index.js

इसके बाद, पेज लोड होने पर getRedirectResult को कॉल करके, GitHub प्रोवाइडर का OAuth टोकन भी वापस पाया जा सकता है:

Web

import { getAuth, getRedirectResult, GithubAuthProvider } from "firebase/auth";

const auth = getAuth();
getRedirectResult(auth)
  .then((result) => {
    const credential = GithubAuthProvider.credentialFromResult(result);
    if (credential) {
      // This gives you a GitHub Access Token. You can use it to access the GitHub API.
      const token = credential.accessToken;
      // ...
    }

    // The signed-in user info.
    const user = result.user;
    // IdP data available using getAdditionalUserInfo(result)
    // ...
  }).catch((error) => {
    // Handle Errors here.
    const errorCode = error.code;
    const errorMessage = error.message;
    // The email of the user's account used.
    const email = error.customData.email;
    // The AuthCredential type that was used.
    const credential = GithubAuthProvider.credentialFromError(error);
    // ...
  });auth_github_signin_redirect_result.js

Web

firebase.auth()
  .getRedirectResult()
  .then((result) => {
    if (result.credential) {
      /** @type {firebase.auth.OAuthCredential} */
      var credential = result.credential;

      // This gives you a GitHub Access Token. You can use it to access the GitHub API.
      var token = credential.accessToken;
      // ...
    }

    // The signed-in user info.
    var user = result.user;
    // IdP data available in result.additionalUserInfo.profile.
      // ...
  }).catch((error) => {
    // Handle Errors here.
    var errorCode = error.code;
    var errorMessage = error.message;
    // The email of the user's account used.
    var email = error.email;
    // The firebase.auth.AuthCredential type that was used.
    var credential = error.credential;
    // ...
  });github.js

account-exists-with-different-credential गड़बड़ियों को ठीक करना

अगर आपने हर ईमेल पते के लिए एक खाता सेटिंग Firebase कंसोल में चालू की है, तो जब कोई उपयोगकर्ता किसी ऐसे ईमेल से किसी प्रोवाइडर (जैसे, GitHub) में साइन इन करने की कोशिश करता है जो पहले से ही Firebase के किसी दूसरे उपयोगकर्ता के प्रोवाइडर (जैसे, Google) के लिए मौजूद है, तो auth/account-exists-with-different-credential गड़बड़ी दिखती है. इसके साथ ही, AuthCredential ऑब्जेक्ट (GitHub ऐक्सेस टोकन) भी दिखता है. उपयोगकर्ता को, जिस प्रोवाइडर में साइन इन करना है उसमें साइन इन करने के लिए, पहले मौजूदा प्रोवाइडर (Google) में साइन इन करना होगा. इसके बाद, पहले वाले AuthCredential (GitHub ऐक्सेस टोकन) से लिंक करना होगा.

अगर signInWithPopup का इस्तेमाल किया जाता है, तो auth/account-exists-with-different-credential गड़बड़ियों को ठीक करने के लिए, यहां दिया गया उदाहरण देखें:

import {
  getAuth,
  linkWithCredential,
  signInWithPopup,
  GitHubAuthProvider,
} from "firebase/auth";

try {
  // Step 1: User tries to sign in using GitHub.
  let result = await signInWithPopup(getAuth(), new GitHubAuthProvider());
} catch (error) {
  // Step 2: User's email already exists.
  if (error.code === "auth/account-exists-with-different-credential") {
    // The pending GitHub credential.
    let pendingCred = error.credential;

    // Step 3: Save the pending credential in temporary storage,

    // Step 4: Let the user know that they already have an account
    // but with a different provider, and let them choose another
    // sign-in method.
  }
}

// ...

try {
  // Step 5: Sign the user in using their chosen method.
  let result = await signInWithPopup(getAuth(), userSelectedProvider);

  // Step 6: Link to the GitHub credential.
  // TODO: implement `retrievePendingCred` for your app.
  let pendingCred = retrievePendingCred();

  if (pendingCred !== null) {
    // As you have access to the pending credential, you can directly call the
    // link method.
    let user = await linkWithCredential(result.user, pendingCred);
  }

  // Step 7: Continue to app.
} catch (error) {
  // ...
}

रीडायरेक्ट मोड

रीडायरेक्ट मोड में भी इस गड़बड़ी को ठीक करने का तरीका एक जैसा होता है. हालांकि, इसमें अंतर यह है कि पेज रीडायरेक्ट के बीच, लंबित क्रेडेंशियल को कैश मेमोरी में सेव करना होता है. उदाहरण के लिए, सेशन स्टोरेज का इस्तेमाल करके.

साइन-इन फ़्लो को मैन्युअल तरीके से मैनेज करना

GitHub OAuth 2.0 एंडपॉइंट को कॉल करके, साइन-इन फ़्लो को मैनेज करके भी GitHub खाते का इस्तेमाल करके Firebase से पुष्टि की जा सकती है:

डेवलपर के दस्तावेज़ में दिए गए निर्देशों का पालन करके, अपने ऐप्लिकेशन में GitHub से पुष्टि करने की सुविधा इंटिग्रेट करें. GitHub के साइन-इन फ़्लो के आखिर में, आपको OAuth 2.0 ऐक्सेस टोकन मिलेगा.
अगर आपको Node.js ऐप्लिकेशन में साइन इन करना है, तो OAuth ऐक्सेस टोकन को Node.js ऐप्लिकेशन पर भेजें.
किसी उपयोगकर्ता के GitHub से सही तरीके से साइन इन करने के बाद, OAuth 2.0 ऐक्सेस टोकन को Firebase क्रेडेंशियल के लिए बदलें:
Web
```
import { GithubAuthProvider } from "firebase/auth";

const credential = GithubAuthProvider.credential(token);auth_github_provider_credential.js
```
Web
```
var credential = firebase.auth.GithubAuthProvider.credential(token);github.js
```

Firebase क्रेडेंशियल का इस्तेमाल करके, Firebase से पुष्टि करें:

Web

import { getAuth, signInWithCredential } from "firebase/auth";

// Sign in with the credential from the user.
const auth = getAuth();
signInWithCredential(auth, credential)
  .then((result) => {
    // Signed in 
    // ...
  })
  .catch((error) => {
    // Handle Errors here.
    const errorCode = error.code;
    const errorMessage = error.message;
    // The email of the user's account used.
    const email = error.customData.email;
    // ...
  });auth_signin_credential.js

Web

// Sign in with the credential from the user.
firebase.auth()
  .signInWithCredential(credential)
  .then((result) => {
    // Signed in 
    // ...
  })
  .catch((error) => {
    // Handle Errors here.
    const errorCode = error.code;
    const errorMessage = error.message;
    // The email of the user's account used.
    const email = error.email;
    // ...
  });index.js

Chrome एक्सटेंशन में Firebase से पुष्टि करना

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

प्रोजेक्ट बनाते समय, Firebase आपके प्रोजेक्ट के लिए एक यूनीक सबडोमेन उपलब्ध कराएगा: https://my-app-12345.firebaseapp.com.

इसका इस्तेमाल, OAuth से साइन इन करने के लिए रीडायरेक्ट करने के तरीके के तौर पर भी किया जाएगा. सभी काम करने वाले OAuth प्रोवाइडर के लिए, उस डोमेन को अनुमति वाली सूची में शामिल करना होगा. हालांकि, इसका मतलब है कि उपयोगकर्ता को GitHub में साइन इन करते समय, ऐप्लिकेशन पर वापस रीडायरेक्ट होने से पहले वह डोमेन दिख सकता है: इस पर जारी रखें: https://my-app-12345.firebaseapp.com.

अपने सबडोमेन को दिखने से रोकने के लिए, Firebase Hosting की मदद से कोई कस्टम डोमेन सेट अप किया जा सकता है:

होस्टिंग के लिए अपना डोमेन सेट अप करना में दिए गए पहले से तीसरे चरण तक का पालन करें.Hosting डोमेन के मालिकाना हक की पुष्टि करने पर, Hosting आपके कस्टम डोमेन के लिए एसएसएल प्रमाणपत्र उपलब्ध कराती है.
Firebase कंसोल में, अनुमति वाले डोमेन की सूची में अपना कस्टम डोमेन जोड़ें: Firebase कंसोल: auth.custom.domain.com.
GitHub डेवलपर कंसोल या OAuth सेटअप पेज में, रीडायरेक्ट पेज के यूआरएल को अनुमति वाली सूची में शामिल करें, जिसे आपके कस्टम डोमेन पर ऐक्सेस किया जा सकेगा: https://auth.custom.domain.com/__/auth/handler.

JavaScript लाइब्रेरी को शुरू करते समय, authDomain फ़ील्ड में अपना कस्टम डोमेन तय करें:

var config = {
  apiKey: '...',
  // Changed from 'PROJECT_ID.firebaseapp.com'.
  authDomain: 'auth.custom.domain.com',
  databaseURL: 'https://PROJECT_ID.firebaseio.com',
  projectId: 'PROJECT_ID',
  storageBucket: 'PROJECT_ID.firebasestorage.app',
  messagingSenderId: 'SENDER_ID'
};
firebase.initializeApp(config);

अगले चरण

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

अपने ऐप्लिकेशन में, उपयोगकर्ता की पुष्टि की स्थिति जानने के लिए, Auth ऑब्जेक्ट पर ऑब्ज़र्वर सेट करने का सुझाव दिया जाता है. इसके बाद, User ऑब्जेक्ट से उपयोगकर्ता की बुनियादी प्रोफ़ाइल की जानकारी पाई जा सकती है. उपयोगकर्ताओं को मैनेज करना देखें .
अपने Firebase Realtime Database और Cloud Storage सुरक्षा नियमों में, आप साइन इन किए हुए उपयोगकर्ता की यूनीक उपयोगकर्ता आईडी auth वैरिएबल से पा सकते हैं. इसका इस्तेमाल, यह कंट्रोल करने के लिए किया जा सकता है कि कोई उपयोगकर्ता किस डेटा को ऐक्सेस कर सकता है.

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

किसी उपयोगकर्ता को साइन आउट करने के लिए, signOut को कॉल करें:

Web

import { getAuth, signOut } from "firebase/auth";

const auth = getAuth();
signOut(auth).then(() => {
  // Sign-out successful.
}).catch((error) => {
  // An error happened.
});auth_sign_out.js

Web

firebase.auth().signOut().then(() => {
  // Sign-out successful.
}).catch((error) => {
  // An error happened.
});index.js