इस पेज का अनुवाद Cloud Translation API से किया गया है.

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

अपने उपयोगकर्ताओं को Apple आईडी का इस्तेमाल करके Firebase से पुष्टि करने की अनुमति दी जा सकती है. इसके लिए, Firebase SDK टूल का इस्तेमाल करके, OAuth 2.0 के साइन-इन फ़्लो को पूरा करें.

अहम जानकारी: Apple खाते से साइन इन करने के लिए, उपयोगकर्ताओं को यह करना होगा:

आपके पास Apple आईडी होना चाहिए. साथ ही, उस पर दो तरीकों से पुष्टि करने की सुविधा (2FA) चालू होनी चाहिए.
Apple डिवाइस पर iCloud में साइन इन किया गया हो.

Apple से साइन इन करने का तरीका देखें. आपको 'Sign In with Apple' के साथ इंटिग्रेशन की जांच करने के लिए, ये ज़रूरी शर्तें भी पूरी करनी होंगी.

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

Apple का इस्तेमाल करके उपयोगकर्ताओं को साइन इन करने की सुविधा देने के लिए, सबसे पहले Apple की डेवलपर साइट पर जाकर, 'Apple से साइन इन करें' सुविधा कॉन्फ़िगर करें. इसके बाद, अपने Firebase प्रोजेक्ट के लिए, Apple को साइन-इन प्रोवाइडर के तौर पर चालू करें.

Apple Developer Program में शामिल हों

'Apple से साइन इन करें' सुविधा को सिर्फ़ Apple Developer Program के सदस्य कॉन्फ़िगर कर सकते हैं.

Apple Developer साइट पर जाकर, यह तरीका अपनाएं:

अपनी वेबसाइट को अपने ऐप्लिकेशन से जोड़ें. इसके लिए, वेब के लिए 'Apple से साइन इन करें' सुविधा को कॉन्फ़िगर करना लेख के पहले सेक्शन में दिया गया तरीका अपनाएं. जब आपसे कहा जाए, तब इस यूआरएल को रिटर्न यूआरएल के तौर पर रजिस्टर करें:
```
https://YOUR_FIREBASE_PROJECT_ID.firebaseapp.com/__/auth/handler
```
आपको Firebase प्रोजेक्ट आईडी, Firebase कंसोल के सेटिंग पेज पर मिल सकता है.

इसके बाद, अपने नए सेवा आईडी को नोट करें. आपको अगले सेक्शन में इसकी ज़रूरत पड़ेगी.
Apple से साइन इन करने के लिए, निजी पासकोड बनाएं. आपको अगले सेक्शन में, अपनी नई निजी कुंजी और कुंजी आईडी की ज़रूरत पड़ेगी.
अगर Firebase Authentication की ऐसी सुविधाओं का इस्तेमाल किया जाता है जो लोगों को ईमेल भेजती हैं, तो Apple की निजी ईमेल रिले सेवा को कॉन्फ़िगर करें. इन सुविधाओं में, ईमेल लिंक से साइन इन करने की सुविधा, ईमेल पते की पुष्टि करने की सुविधा, खाता बदलने की सुविधा, और अन्य सुविधाएं शामिल हैं. साथ ही, noreply@YOUR_FIREBASE_PROJECT_ID.firebaseapp.com या अपने पसंद के ईमेल टेंप्लेट डोमेन को रजिस्टर करें, ताकि Apple, Firebase Authentication से भेजे गए ईमेल को Apple के ऐसे ईमेल पतों पर रिले कर सके जिनकी पहचान ज़ाहिर नहीं की गई है.

अपने प्रोजेक्ट में Firebase जोड़ें.
Firebase कंसोल में, Auth सेक्शन खोलें. साइन इन करने का तरीका टैब पर जाकर, Apple सेवा देने वाली कंपनी को चालू करें. पिछले सेक्शन में बनाया गया सर्विस आईडी डालें. इसके अलावा, OAuth कोड फ़्लो कॉन्फ़िगरेशन सेक्शन में, अपना Apple Team ID, निजी कुंजी, और पिछले सेक्शन में बनाया गया कुंजी आईडी डालें.

Apple के पहचान छिपाकर रखे गए डेटा से जुड़ी ज़रूरी शर्तों का पालन करना

Sign In with Apple की सुविधा का इस्तेमाल करने वाले लोगों के पास, साइन इन करते समय अपने डेटा को गुमनाम बनाने का विकल्प होता है. इसमें उनका ईमेल पता भी शामिल है. इस विकल्प को चुनने वाले उपयोगकर्ताओं के ईमेल पते में privaterelay.appleid.com डोमेन होता है. अपने ऐप्लिकेशन में 'Apple से साइन इन करें' सुविधा का इस्तेमाल करते समय, आपको Apple की डेवलपर नीतियों या शर्तों का पालन करना होगा. ये नीतियां या शर्तें, Apple आईडी को गुमनाम बनाए रखने से जुड़ी होती हैं.

इसमें, उपयोगकर्ता की पहचान ज़ाहिर करने वाली किसी भी निजी जानकारी को गुमनाम किए गए Apple आईडी से जोड़ने से पहले, उपयोगकर्ता की ज़रूरी सहमति लेना शामिल है. Firebase Authentication का इस्तेमाल करते समय, ये कार्रवाइयां की जा सकती हैं:

किसी ईमेल पते को ऐसे Apple आईडी से लिंक करें जिससे उपयोगकर्ता की पहचान छिपी रहती है या इसके उलट करें.
किसी फ़ोन नंबर को छद्म नाम वाले Apple आईडी से लिंक करना या इसके उलट करना
पहचान छिपाकर इस्तेमाल की जाने वाली सोशल क्रेडेंशियल (Facebook, Google वगैरह) को पहचान छिपाकर इस्तेमाल किए जाने वाले Apple आईडी से लिंक करना या इसका उल्टा करना.

ऊपर दी गई सूची पूरी नहीं है. पक्का करें कि आपका ऐप्लिकेशन, Apple की ज़रूरी शर्तों को पूरा करता हो. इसके लिए, अपने डेवलपर खाते के सदस्यता सेक्शन में जाकर, Apple Developer Program के लाइसेंस समझौते को पढ़ें.

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

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

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

apple.com के लिए, OAuthProvider का इंस्टेंस बनाएं.

Web

import { OAuthProvider } from "firebase/auth";

const provider = new OAuthProvider('apple.com');auth_apple_provider_create.js

Web

var provider = new firebase.auth.OAuthProvider('apple.com');apple.js

ज़रूरी नहीं: डिफ़ॉल्ट के अलावा, OAuth 2.0 के अन्य स्कोप तय करें. ये वे स्कोप होने चाहिए जिनके लिए आपको पुष्टि करने की सेवा देने वाली कंपनी से अनुरोध करना है.
Web
```
provider.addScope('email');
provider.addScope('name');auth_apple_provider_scopes.js
```
Web
```
provider.addScope('email');
provider.addScope('name');apple.js
```
एक ईमेल पते से एक खाता सुविधा चालू होने पर, Firebase डिफ़ॉल्ट रूप से ईमेल और नाम के स्कोप का अनुरोध करता है. इस सेटिंग को एक ईमेल पते से कई खाते पर सेट करने पर, Firebase, Apple से कोई स्कोप का अनुरोध नहीं करता है. हालांकि, ऐसा तब तक होता है, जब तक कि आपने स्कोप तय न किए हों.
ज़रूरी नहीं: अगर आपको Apple की साइन-इन स्क्रीन को अंग्रेज़ी के अलावा किसी दूसरी भाषा में दिखाना है, तो locale पैरामीटर सेट करें. जिन भाषाओं में यह सुविधा उपलब्ध है उनके लिए, Sign In with Apple के दस्तावेज़ देखें.
Web
```
provider.setCustomParameters({
  // Localize the Apple authentication screen in French.
  locale: 'fr'
});auth_apple_provider_params.js
```
Web
```
provider.setCustomParameters({
  // Localize the Apple authentication screen in French.
  locale: 'fr'
});apple.js
```

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

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

Web

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

const auth = getAuth();
signInWithPopup(auth, provider)
  .then((result) => {
    // The signed-in user info.
    const user = result.user;

    // Apple credential
    const credential = OAuthProvider.credentialFromResult(result);
    const accessToken = credential.accessToken;
    const idToken = credential.idToken;

    // 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 credential that was used.
    const credential = OAuthProvider.credentialFromError(error);

    // ...
  });auth_apple_signin_popup.js

Web

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

    // The signed-in user info.
    var user = result.user;

    // You can also get the Apple OAuth Access and ID Tokens.
    var accessToken = credential.accessToken;
    var idToken = credential.idToken;

    // IdP data available using getAdditionalUserInfo(result)
  // ...
  })
  .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;

    // ...
  });apple.js

साइन-इन पेज पर रीडायरेक्ट करके साइन इन करने के लिए, signInWithRedirect() को कॉल करें:

signInWithRedirect, linkWithRedirect या reauthenticateWithRedirect का इस्तेमाल करते समय, सबसे सही तरीके अपनाएं.

Web

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

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

Web

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

जब उपयोगकर्ता साइन इन कर लेता है और पेज पर वापस आ जाता है, तब getRedirectResult() को कॉल करके साइन-इन का नतीजा पाया जा सकता है:

Web

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

// Result from Redirect auth flow.
const auth = getAuth();
getRedirectResult(auth)
  .then((result) => {
    const credential = OAuthProvider.credentialFromResult(result);
    if (credential) {
      // You can also get the Apple OAuth Access and ID Tokens.
      const accessToken = credential.accessToken;
      const idToken = credential.idToken;
    }
    // The signed-in user info.
    const user = result.user;
  })
  .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 credential that was used.
    const credential = OAuthProvider.credentialFromError(error);

    // ...
  });auth_apple_signin_redirect_result.js

Web

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

      // You can get the Apple OAuth Access and ID Tokens.
      var accessToken = credential.accessToken;
      var idToken = credential.idToken;

      // IdP data available in result.additionalUserInfo.profile.
      // ...
    }
    // The signed-in user info.
    var user = result.user;
  })
  .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;

    // ...
  });apple.js

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

Firebase Auth के साथ काम करने वाली अन्य कंपनियों के उलट, Apple फ़ोटो का यूआरएल नहीं देता है.

इसके अलावा, जब उपयोगकर्ता ऐप्लिकेशन के साथ अपना ईमेल पता शेयर नहीं करता है, तो Apple उस उपयोगकर्ता के लिए एक यूनीक ईमेल पता (xyz@privaterelay.appleid.com के फ़ॉर्म में) उपलब्ध कराता है. इसे वह आपके ऐप्लिकेशन के साथ शेयर करता है. अगर आपने निजी ईमेल रिले सेवा कॉन्फ़िगर की है, तो Apple, ईमेल पते को छिपाकर बनाए गए पते पर भेजे गए ईमेल को उपयोगकर्ता के असली ईमेल पते पर फ़ॉरवर्ड करता है.

Apple, उपयोगकर्ता के साइन इन करने पर पहली बार ही ऐप्लिकेशन के साथ उपयोगकर्ता की जानकारी शेयर करता है. जैसे, डिसप्ले नेम. आम तौर पर, Firebase उस डिसप्ले नेम को सेव करता है जिसका इस्तेमाल उपयोगकर्ता ने पहली बार Apple से साइन इन करते समय किया था. इसे firebase.auth().currentUser.displayName की मदद से पाया जा सकता है. हालांकि, अगर आपने पहले Firebase का इस्तेमाल किए बिना, Apple से किसी उपयोगकर्ता को ऐप्लिकेशन में साइन इन करने की सुविधा दी थी, तो Apple, Firebase को उपयोगकर्ता का डिसप्ले नेम नहीं देगा.

फिर से पुष्टि करना और खाता लिंक करना

इसी पैटर्न का इस्तेमाल reauthenticateWithPopup() और reauthenticateWithRedirect() के साथ किया जा सकता है. इसका इस्तेमाल, संवेदनशील कार्रवाइयों के लिए नया क्रेडेंशियल पाने के लिए किया जा सकता है. इन कार्रवाइयों के लिए, हाल ही में साइन इन करना ज़रूरी होता है:

Web

import { getAuth, reauthenticateWithPopup, OAuthProvider } from "firebase/auth";

// Result from Redirect auth flow.
const auth = getAuth();
const provider = new OAuthProvider('apple.com');

reauthenticateWithPopup(auth.currentUser, provider)
  .then((result) => {
    // User is re-authenticated with fresh tokens minted and can perform
    // sensitive operations like account deletion, or updating their email
    // address or password.

    // The signed-in user info.
    const user = result.user;

    // You can also get the Apple OAuth Access and ID Tokens.
    const credential = OAuthProvider.credentialFromResult(result);
    const accessToken = credential.accessToken;
    const idToken = credential.idToken;

    // ...
  })
  .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 credential that was used.
    const credential = OAuthProvider.credentialFromError(error);

    // ...
  });auth_apple_reauthenticate_popup.js

Web

const provider = new firebase.auth.OAuthProvider('apple.com');

firebase
  .auth()
  .currentUser
  .reauthenticateWithPopup(provider)
  .then((result) => {
    // User is re-authenticated with fresh tokens minted and can perform
    // sensitive operations like account deletion, or updating their email
    // address or password.
    /** @type {firebase.auth.OAuthCredential} */
    var credential = result.credential;

    // The signed-in user info.
    var user = result.user;
     // You can also get the Apple OAuth Access and ID Tokens.
    var accessToken = credential.accessToken;
    var idToken = credential.idToken;

    // 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;

    // ...
  });apple.js

इसके अलावा, linkWithPopup() और linkWithRedirect() का इस्तेमाल करके, अलग-अलग पहचान देने वाली कंपनियों को मौजूदा खातों से लिंक किया जा सकता है.

ध्यान दें कि Apple के मुताबिक, आपको उपयोगकर्ताओं के Apple खातों को अन्य डेटा से लिंक करने से पहले, उनसे साफ़ तौर पर सहमति लेनी होगी.

उदाहरण के लिए, किसी Facebook खाते को मौजूदा Firebase खाते से लिंक करने के लिए, उस ऐक्सेस टोकन का इस्तेमाल करें जो आपको Facebook में उपयोगकर्ता के साइन इन करने पर मिला था:

Web

import { getAuth, linkWithPopup, FacebookAuthProvider } from "firebase/auth";

const auth = getAuth();
const provider = new FacebookAuthProvider();
provider.addScope('user_birthday');

// Assuming the current user is an Apple user linking a Facebook provider.
linkWithPopup(auth.currentUser, provider)
    .then((result) => {
      // Facebook credential is linked to the current Apple user.
      // ...

      // The user can now sign in to the same account
      // with either Apple or Facebook.
    })
    .catch((error) => {
      // Handle error.
    });auth_apple_link_facebook.js

Web

const provider = new firebase.auth.FacebookAuthProvider();
provider.addScope('user_birthday');

// Assuming the current user is an Apple user linking a Facebook provider.
firebase.auth().currentUser.linkWithPopup(provider)
    .then((result) => {
      // Facebook credential is linked to the current Apple user.
      // Facebook additional data available in result.additionalUserInfo.profile,

      // Additional Facebook OAuth access token can also be retrieved.
      // result.credential.accessToken

      // The user can now sign in to the same account
      // with either Apple or Facebook.
    })
    .catch((error) => {
      // Handle error.
    });apple.js

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

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

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

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

अपने सबडोमेन को दिखने से रोकने के लिए, Firebase Hosting की मदद से कस्टम डोमेन सेट अप करें:

Hosting के लिए अपना डोमेन सेट अप करना में दिए गए पहले से तीसरे चरण तक का तरीका अपनाएं. डोमेन के मालिकाना हक की पुष्टि करने पर, Hosting आपके कस्टम डोमेन के लिए एसएसएल सर्टिफ़िकेट उपलब्ध कराता है.
Firebase कंसोल में, अनुमति वाले डोमेन की सूची में अपना कस्टम डोमेन जोड़ें: auth.custom.domain.com.
Apple Developer Console या 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);

ध्यान दें कि आपको अब भी Apple के साथ कस्टम डोमेन की पुष्टि करनी होगी. यह पुष्टि, डिफ़ॉल्ट firebaseapp.com डोमेन की तरह ही की जाएगी:

http://auth.custom.example.com/.well-known/apple-developer-domain-association.txt

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

Apple का कहना है कि जिन ऐप्लिकेशन में खाता बनाने की सुविधा होती है उन्हें उपयोगकर्ताओं को ऐप्लिकेशन के अंदर ही खाता मिटाने की सुविधा देनी चाहिए. इस बारे में App Store की समीक्षा से जुड़े दिशा-निर्देशों में बताया गया है

इस ज़रूरी शर्त को पूरा करने के लिए, यह तरीका अपनाएं:

पक्का करें कि आपने 'Apple से साइन इन करें' सुविधा देने वाली कंपनी के कॉन्फ़िगरेशन में, सेवाओं का आईडी और OAuth कोड फ़्लो कॉन्फ़िगरेशन सेक्शन भर दिया हो. इसके बारे में 'Apple से साइन इन करें' सुविधा कॉन्फ़िगर करना सेक्शन में बताया गया है.
'Apple से साइन इन करें' सुविधा का इस्तेमाल करके उपयोगकर्ता खाते बनाने पर, Firebase उपयोगकर्ता टोकन सेव नहीं करता. इसलिए, आपको उपयोगकर्ता से उसका टोकन रद्द करने और खाता मिटाने से पहले, फिर से साइन इन करने के लिए कहना होगा.

इसके बाद, OAuthCredential से Apple OAuth ऐक्सेस टोकन पाएं. साथ ही, Apple OAuth ऐक्सेस टोकन को रद्द करने के लिए, revokeAccessToken(auth, token) को कॉल करने के लिए इसका इस्तेमाल करें.
```
const provider = new OAuthProvider('apple.com');
provider.addScope('email');
provider.addScope('name');

const auth = getAuth();
signInWithPopup(auth, provider).then(result => {
  // Get the Apple OAuth access token.
  const credential = OAuthProvider.credentialFromResult(result);
  const accessToken = credential.accessToken;

  // Revoke the Apple OAuth access token.
  revokeAccessToken(auth, accessToken)
    .then(() => {
      // Token revoked.

      // Delete the user account.
      // ...
    })
    .catch(error => {
      // An error happened.
      // ...
    });
});
```
आखिर में, उपयोगकर्ता का खाता मिटाएं और उससे जुड़ा सारा डेटा भी मिटाएं.

ऐडवांस: Node.js में Firebase की मदद से पुष्टि करना

Node.js ऐप्लिकेशन में Firebase से पुष्टि करने के लिए:

उपयोगकर्ता को उसके Apple खाते से साइन इन करें और उपयोगकर्ता का Apple ID टोकन पाएं. ऐसा कई तरीकों से किया जा सकता है. उदाहरण के लिए, अगर आपके Node.js ऐप्लिकेशन में ब्राउज़र फ़्रंट एंड है, तो:

अपने बैकएंड पर, कोई रैंडम स्ट्रिंग ("nonce") जनरेट करें और उसके SHA256 हैश का हिसाब लगाएं. नॉन्स एक ऐसी वैल्यू होती है जिसका इस्तेमाल सिर्फ़ एक बार किया जा सकता है. इसका इस्तेमाल, आपके बैकएंड और Apple के पुष्टि करने वाले सर्वर के बीच एक राउंड ट्रिप की पुष्टि करने के लिए किया जाता है.

Web

const crypto = require("crypto");
const string_decoder = require("string_decoder");

// Generate a new random string for each sign-in
const generateNonce = (length) => {
  const decoder = new string_decoder.StringDecoder("ascii");
  const buf = Buffer.alloc(length);
  let nonce = "";
  while (nonce.length < length) {
    crypto.randomFillSync(buf);
    nonce = decoder.write(buf);
  }
  return nonce.slice(0, length);
};

const unhashedNonce = generateNonce(10);

// SHA256-hashed nonce in hex
const hashedNonceHex = crypto.createHash('sha256')
  .update(unhashedNonce).digest().toString('hex');auth_apple_nonce_node.js

Web

const crypto = require("crypto");
const string_decoder = require("string_decoder");

// Generate a new random string for each sign-in
const generateNonce = function(length) {
  const decoder = new string_decoder.StringDecoder("ascii");
  const buf = Buffer.alloc(length);
  var nonce = "";
  while (nonce.length < length) {
    crypto.randomFillSync(buf);
    nonce = decoder.write(buf);
  }
  return nonce.slice(0, length);
};

const unhashedNonce = generateNonce(10);

// SHA256-hashed nonce in hex
const hashedNonceHex = crypto.createHash('sha256')
  .update(unhashedNonce).digest().toString('hex');apple.js

अपने साइन-इन पेज पर, Sign In with Apple कॉन्फ़िगरेशन में हैश किया गया नॉनस डालें:

<script src="https://appleid.cdn-apple.com/appleauth/static/jsapi/appleid/1/en_US/appleid.auth.js"></script>
<div id="appleid-signin" data-color="black" data-border="true" data-type="sign in"></div>
<script>
    AppleID.auth.init({
        clientId: YOUR_APPLE_CLIENT_ID,
        scope: 'name email',
        redirectURI: URL_TO_YOUR_REDIRECT_HANDLER,  // See the next step.
        state: '[STATE]',  // Optional value that Apple will send back to you
                           // so you can return users to the same context after
                           // they sign in.
        nonce: HASHED_NONCE  // The hashed nonce you generated in the previous step.
    });
</script>

सर्वर-साइड पर, POST किए गए ऑथराइज़ेशन के जवाब से Apple ID टोकन पाएं:

app.post('/redirect', (req, res) => {
  const savedState = req.cookies.__session;
  const code = req.body.code;
  const state = req.body.state;
  const appleIdToken = req.body.id_token;
  if (savedState !== state || !code) {
    res.status(403).send('403: Permission denied');
  } else {
    // Sign in with Firebase using appleIdToken. (See next step).
  }
});

'Apple से साइन इन करें' सुविधा के लिए, वेबपेज को कॉन्फ़िगर करना लेख भी पढ़ें.

उपयोगकर्ता का Apple ID टोकन मिलने के बाद, इसका इस्तेमाल करके क्रेडेंशियल ऑब्जेक्ट बनाएं. इसके बाद, क्रेडेंशियल की मदद से उपयोगकर्ता को साइन इन करें:

Web

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

const auth = getAuth();

// Build Firebase credential with the Apple ID token.
const provider = new OAuthProvider('apple.com');
const authCredential = provider.credential({
  idToken: appleIdToken,
  rawNonce: unhashedNonce,
});

// Sign in with credential form the Apple user.
signInWithCredential(auth, authCredential)
  .then((result) => {
    // User signed in.
  })
  .catch((error) => {
    // An error occurred. If error.code == 'auth/missing-or-invalid-nonce',
    // make sure you're sending the SHA256-hashed nonce as a hex string
    // with your request to Apple.
    console.log(error);
  });auth_apple_signin_nonce.js

Web

// Build Firebase credential with the Apple ID token.
const provider = new firebase.auth.OAuthProvider('apple.com');
const authCredential = provider.credential({
  idToken: appleIdToken,
  rawNonce: unhashedNonce,
});

// Sign in with credential form the Apple user.
firebase.auth().signInWithCredential(authCredential)
  .then((result) => {
    // User signed in.
  })
  .catch((error) => {
    // An error occurred. If error.code == 'auth/missing-or-invalid-nonce',
    // make sure you're sending the SHA256-hashed nonce as a hex string
    // with your request to Apple.
    console.log(error);
  });apple.js

अगले चरण

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

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

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

किसी उपयोगकर्ता को साइन आउट करने के लिए, 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