कस्टम टोकन बनाएं

Firebase आपको पुष्टि करने की प्रोसेस पर पूरा कंट्रोल देता है. इसके लिए, आपको सुरक्षित JSON वेब टोकन (JWT) का इस्तेमाल करके, उपयोगकर्ताओं या डिवाइसों की पुष्टि करने की अनुमति मिलती है. इन टोकन को अपने सर्वर पर जनरेट किया जाता है और क्लाइंट डिवाइस पर वापस भेजा जाता है. इसके बाद, signInWithCustomToken() तरीके से पुष्टि करने के लिए इनका इस्तेमाल किया जाता है.

इसके लिए, आपको एक सर्वर एंडपॉइंट बनाना होगा, जो साइन-इन क्रेडेंशियल स्वीकार करता हो. जैसे, उपयोगकर्ता नाम और पासवर्ड. साथ ही, अगर क्रेडेंशियल मान्य हैं, तो कस्टम JWT दिखाता हो. इसके बाद, आपके सर्वर से मिले कस्टम JWT का इस्तेमाल, क्लाइंट डिवाइस से Firebase के साथ पुष्टि करने के लिए किया जा सकता है (iOS+, Android, वेब). पहचान की पुष्टि होने के बाद, इसका इस्तेमाल Firebase की अन्य सेवाओं को ऐक्सेस करने के लिए किया जाएगा. जैसे, Firebase Realtime Database और Cloud Storage. इसके अलावा, JWT का कॉन्टेंट आपके Realtime Database Security Rules में auth ऑब्जेक्ट और Cloud Storage Security Rules में request.auth ऑब्जेक्ट में उपलब्ध होगा.

Firebase Admin SDK की मदद से, कस्टम टोकन बनाया जा सकता है. इसके अलावा, अगर आपका सर्वर ऐसी भाषा में लिखा गया है जो Firebase के साथ काम नहीं करती, तो तीसरे पक्ष की JWT लाइब्रेरी का इस्तेमाल किया जा सकता है.

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

कस्टम टोकन, साइन किए गए JWT होते हैं. इनमें साइन करने के लिए इस्तेमाल किया जाने वाला निजी पासकोड, Google सेवा खाते का होता है. कस्टम टोकन पर हस्ताक्षर करने के लिए, Firebase Admin SDK को Google सेवा खाते का इस्तेमाल करना चाहिए. इस खाते की जानकारी देने के कई तरीके हैं:

• Admin SDK को सेवा खाते का पता लगाने की अनुमति देना -- इस तरीके का इस्तेमाल, Google Cloud Functions और App Engine जैसे Google के मैनेज किए जा रहे एनवायरमेंट में किया जा सकता है. आपको Google Cloud कंसोल की मदद से, कुछ और अनुमतियां कॉन्फ़िगर करनी पड़ सकती हैं.
• सेवा खाते के आईडी का इस्तेमाल करना -- इस तरीके में, Google की ओर से मैनेज की जाने वाली कुंजियों का इस्तेमाल करके टोकन पर हस्ताक्षर किए जाते हैं. ये कुंजियां, सेवा खाते के लिए तय की गई होती हैं. इसलिए, आपको किसी भी निजी कुंजी को खुद मैनेज करने की ज़रूरत नहीं होती. यह रिमोट वेब सेवा का इस्तेमाल करता है. आपको Google Cloud कंसोल की मदद से, इस सेवा खाते के लिए अतिरिक्त अनुमतियां कॉन्फ़िगर करनी पड़ सकती हैं.
• सेवा खाते की कुंजी वाली फ़ाइल का इस्तेमाल करना -- इस तरीके का इस्तेमाल सिर्फ़ तब करें, जब आपका कोड Google के मैनेज किए जा रहे एनवायरमेंट से बाहर चल रहा हो और ऊपर दिए गए दोनों तरीकों का इस्तेमाल न किया जा सकता हो. इसके लिए, आपको एक निजी पासकोड बनाना, सेव करना, और सुरक्षित रखना होगा. यह पासकोड लंबे समय तक इस्तेमाल किया जा सकता है.

हम पहले दो तरीकों का सुझाव देते हैं, क्योंकि इनमें आपको सेवा खाते की कुंजियां डाउनलोड या मैनेज करने की ज़रूरत नहीं होती.

Admin SDK को सेवा खाते का पता लगाने की अनुमति देना

अगर आपका कोड, Google के मैनेज किए जा रहे एनवायरमेंट में डिप्लॉय किया गया है, तो Admin SDK, कस्टम टोकन पर हस्ताक्षर करने का तरीका अपने-आप ढूंढने की कोशिश कर सकता है:

• अगर आपका कोड Java, Python या Go के लिए App Engine स्टैंडर्ड एनवायरमेंट में डिप्लॉय किया गया है, तो Admin SDK, कस्टम टोकन पर हस्ताक्षर करने के लिए उस एनवायरमेंट में मौजूद ऐप्लिकेशन आइडेंटिटी सेवा का इस्तेमाल कर सकता है. ऐप्लिकेशन की पहचान करने वाली सेवा, Google App Engine की ओर से आपके ऐप्लिकेशन के लिए उपलब्ध कराए गए सेवा खाते का इस्तेमाल करके, डेटा पर हस्ताक्षर करती है.

• अगर आपका कोड किसी अन्य मैनेज किए जा रहे एनवायरमेंट (जैसे, Google Cloud Functions, Google Compute Engine) में डिप्लॉय किया गया है, तो Firebase Admin SDK, लोकल मेटाडेटा सर्वर से सेवा खाते की आईडी स्ट्रिंग का अपने-आप पता लगा सकता है. इसके बाद, खोजे गए सेवा खाते के आईडी का इस्तेमाल, आईएएम सेवा के साथ किया जाता है, ताकि टोकन पर रिमोट तरीके से हस्ताक्षर किए जा सकें.

साइन इन करने के इन तरीकों का इस्तेमाल करने के लिए, Google ऐप्लिकेशन के डिफ़ॉल्ट क्रेडेंशियल के साथ एसडीके को शुरू करें. साथ ही, सेवा खाते के आईडी की स्ट्रिंग की जानकारी न दें:

initializeApp();

FirebaseApp.initializeApp();

default_app = firebase_admin.initialize_app()

app, err := firebase.NewApp(context.Background(), nil)
if err != nil {
	log.Fatalf("error initializing app: %v\n", err)
}
init.go

FirebaseApp.Create();

सेवा खाते की कुंजी डाउनलोड किए बिना, उसी कोड को स्थानीय तौर पर टेस्ट करने के लिए, Google Cloud सीएलआई का इस्तेमाल करके अपने उपयोगकर्ता क्रेडेंशियल से साइन इन करें:

gcloud auth application-default login

आपकी लोकल मशीन पर कोई मेटाडेटा सर्वर नहीं होता. इसलिए, Admin SDK वहां सेवा खाते के आईडी का अपने-आप पता नहीं लगा सकता. इसके बजाय, SDK टूल को शुरू करते समय सेवा खाते का आईडी बताएं. साथ ही, पक्का करें कि आपके उपयोगकर्ता खाते के पास उस सेवा खाते पर सेवा खाता टोकन क्रिएटर की भूमिका हो.

अगर Firebase Admin SDK को सेवा खाते के आईडी की स्ट्रिंग का पता लगाना है, तो वह ऐसा तब करता है, जब आपका कोड पहली बार कोई कस्टम टोकन बनाता है. नतीजे को कैश मेमोरी में सेव किया जाता है और बाद में टोकन साइन करने की प्रोसेस के लिए फिर से इस्तेमाल किया जाता है. अपने-आप खोजा गया सेवा खाता आईडी, आम तौर पर Google Cloud से मिले डिफ़ॉल्ट सेवा खातों में से एक होता है:

• डिफ़ॉल्ट Compute Engine सेवा खाता
• Cloud Functions का डिफ़ॉल्ट सेवा खाता

साफ़ तौर पर बताए गए सेवा खाते के आईडी की तरह ही, अपने-आप खोजे गए सेवा खाते के आईडी के पास भी iam.serviceAccounts.signBlob अनुमति होनी चाहिए, ताकि कस्टम टोकन बनाने की सुविधा काम कर सके. डिफ़ॉल्ट सेवा खातों को ज़रूरी अनुमतियां देने के लिए, आपको Google Cloud कंसोल के आईएएम और एडमिन सेक्शन का इस्तेमाल करना पड़ सकता है. ज़्यादा जानकारी के लिए, नीचे दिया गया 'समस्या का हल' सेक्शन देखें.

सेवा खाता आईडी का इस्तेमाल करना

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

सेवा खाता आईडी, Google Cloud कंसोल में देखा जा सकता है. सेवा खाता आईडी, ईमेल पते होते हैं. इनका फ़ॉर्मैट इस तरह का होता है: <client-id>@<project-id>.iam.gserviceaccount.com. ये Firebase और Google Cloud प्रोजेक्ट में सेवा खातों की खास तौर पर पहचान करते हैं.

किसी अलग सेवा खाते के आईडी का इस्तेमाल करके कस्टम टोकन बनाने के लिए, SDK टूल को शुरू करें. इसके लिए, यहां दिया गया तरीका अपनाएं:

initializeApp({
  serviceAccountId: 'my-client-id@my-project-id.iam.gserviceaccount.com',
});

FirebaseOptions options = FirebaseOptions.builder()
    .setCredentials(GoogleCredentials.getApplicationDefault())
    .setServiceAccountId("my-client-id@my-project-id.iam.gserviceaccount.com")
    .build();
FirebaseApp.initializeApp(options);

options = {
    'serviceAccountId': 'my-client-id@my-project-id.iam.gserviceaccount.com',
}
firebase_admin.initialize_app(options=options)

conf := &firebase.Config{
	ServiceAccountID: "my-client-id@my-project-id.iam.gserviceaccount.com",
}
app, err := firebase.NewApp(context.Background(), conf)
if err != nil {
	log.Fatalf("error initializing app: %v\n", err)
}
init.go

FirebaseApp.Create(new AppOptions()
{
    Credential = GoogleCredential.GetApplicationDefault(),
    ServiceAccountId = "my-client-id@my-project-id.iam.gserviceaccount.com",
});

सेवा खाते के आईडी संवेदनशील जानकारी नहीं होते. इसलिए, इनके दिखने से कोई असर नहीं पड़ता. हालांकि, तय किए गए सेवा खाते से कस्टम टोकन पर हस्ताक्षर करने के लिए, Firebase Admin SDK को किसी रिमोट सेवा को शुरू करना होगा. इसके अलावा, आपको यह भी पक्का करना होगा कि Admin SDK, इस कॉल को करने के लिए जिस आइडेंटिटी का इस्तेमाल कर रहा है उसके पास iam.serviceAccounts.signBlob अनुमति हो. आम तौर पर, प्रोडक्शन में {project-name}@appspot.gserviceaccount.com या लोकल डेवलपमेंट के दौरान आपके उपयोगकर्ता खाते का इस्तेमाल किया जाता है. ज़्यादा जानकारी के लिए, नीचे दिया गया 'समस्या का हल' सेक्शन देखें.

सेवा खाते की कुंजी वाली फ़ाइल का इस्तेमाल करना

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

सेवा खाते की कुंजियां, लंबे समय तक इस्तेमाल किए जा सकने वाले क्रेडेंशियल होते हैं. अगर कोई कुंजी लीक हो जाती है, तो जिसके पास भी वह कुंजी है वह सेवा खाते के तौर पर काम कर सकता है. ऐसा तब तक हो सकता है, जब तक कुंजी को मिटा नहीं दिया जाता. वर्शन कंट्रोल के लिए, कुंजी वाली फ़ाइलों को कभी भी कमिट न करें. साथ ही, जहां आपका एनवायरमेंट कुंजी वाली फ़ाइलों के साथ काम करता है वहां कुंजी वाली फ़ाइलों के बजाय, Workload Identity Federation का इस्तेमाल करें. यह भी ध्यान रखें कि कुछ संगठन, सेवा खाते की कुंजी बनाने से रोकने के लिए, संगठन की नीति से जुड़ी पाबंदियों का इस्तेमाल करते हैं. ऐसे में, आपको अन्य तरीकों में से किसी एक का इस्तेमाल करना होगा.

Firebase Admin SDK का इस्तेमाल करके कस्टम टोकन बनाना

Firebase Admin SDK में, कस्टम टोकन बनाने का एक तरीका पहले से मौजूद होता है. आपको कम से कम एक uid देना होगा. यह कोई भी स्ट्रिंग हो सकती है, लेकिन इससे उस उपयोगकर्ता या डिवाइस की खास तौर पर पहचान होनी चाहिए जिसकी पुष्टि की जा रही है. ये टोकन एक घंटे बाद काम नहीं करते.

const uid = 'some-uid';

getAuth()
  .createCustomToken(uid)
  .then((customToken) => {
    // Send token back to client
  })
  .catch((error) => {
    console.log('Error creating custom token:', error);
  });

String uid = "some-uid";

String customToken = FirebaseAuth.getInstance().createCustomToken(uid);
// Send token back to client

uid = 'some-uid'

custom_token = auth.create_custom_token(uid)
index.py

client, err := app.Auth(context.Background())
if err != nil {
	log.Fatalf("error getting Auth client: %v\n", err)
}

token, err := client.CustomToken(ctx, "some-uid")
if err != nil {
	log.Fatalf("error minting custom token: %v\n", err)
}

log.Printf("Got custom token: %v\n", token)
auth.go

var uid = "some-uid";

string customToken = await FirebaseAuth.DefaultInstance.CreateCustomTokenAsync(uid);
// Send token back to client

आपके पास कस्टम टोकन में शामिल किए जाने वाले अतिरिक्त दावों की जानकारी देने का विकल्प भी है. उदाहरण के लिए, यहां कस्टम टोकन में premiumAccount फ़ील्ड जोड़ा गया है. यह आपके सुरक्षा नियमों में auth / request.auth ऑब्जेक्ट में उपलब्ध होगा:

const userId = 'some-uid';
const additionalClaims = {
  premiumAccount: true,
};

getAuth()
  .createCustomToken(userId, additionalClaims)
  .then((customToken) => {
    // Send token back to client
  })
  .catch((error) => {
    console.log('Error creating custom token:', error);
  });

String uid = "some-uid";
Map<String, Object> additionalClaims = new HashMap<String, Object>();
additionalClaims.put("premiumAccount", true);

String customToken = FirebaseAuth.getInstance()
    .createCustomToken(uid, additionalClaims);
// Send token back to client

uid = 'some-uid'
additional_claims = {
    'premiumAccount': True
}

custom_token = auth.create_custom_token(uid, additional_claims)
index.py

client, err := app.Auth(context.Background())
if err != nil {
	log.Fatalf("error getting Auth client: %v\n", err)
}

claims := map[string]interface{}{
	"premiumAccount": true,
}

token, err := client.CustomTokenWithClaims(ctx, "some-uid", claims)
if err != nil {
	log.Fatalf("error minting custom token: %v\n", err)
}

log.Printf("Got custom token: %v\n", token)
auth.go

var uid = "some-uid";
var additionalClaims = new Dictionary<string, object>()
{
    { "premiumAccount", true },
};

string customToken = await FirebaseAuth.DefaultInstance
    .CreateCustomTokenAsync(uid, additionalClaims);
// Send token back to client

कस्टम टोकन के रिज़र्व किए गए नाम

क्लाइंट पर कस्टम टोकन का इस्तेमाल करके साइन इन करना

कस्टम टोकन बनाने के बाद, आपको उसे अपने क्लाइंट ऐप्लिकेशन पर भेजना चाहिए. क्लाइंट ऐप्लिकेशन, signInWithCustomToken() को कॉल करके कस्टम टोकन की मदद से पुष्टि करता है:

[[FIRAuth auth] signInWithCustomToken:customToken
                           completion:^(FIRAuthDataResult * _Nullable authResult,
                                        NSError * _Nullable error) {
  // ...
}];

Auth.auth().signIn(withCustomToken: customToken ?? "") { user, error in
  // ...
}

mAuth.signInWithCustomToken(mCustomToken)
        .addOnCompleteListener(this, new OnCompleteListener<AuthResult>() {
            @Override
            public void onComplete(@NonNull Task<AuthResult> task) {
                if (task.isSuccessful()) {
                    // Sign in success, update UI with the signed-in user's information
                    Log.d(TAG, "signInWithCustomToken:success");
                    FirebaseUser user = mAuth.getCurrentUser();
                    updateUI(user);
                } else {
                    // If sign in fails, display a message to the user.
                    Log.w(TAG, "signInWithCustomToken:failure", task.getException());
                    Toast.makeText(CustomAuthActivity.this, "Authentication failed.",
                            Toast.LENGTH_SHORT).show();
                    updateUI(null);
                }
            }
        });

auth.SignInWithCustomTokenAsync(custom_token).ContinueWith(task => {
  if (task.IsCanceled) {
    Debug.LogError("SignInWithCustomTokenAsync was canceled.");
    return;
  }
  if (task.IsFaulted) {
    Debug.LogError("SignInWithCustomTokenAsync encountered an error: " + task.Exception);
    return;
  }

  Firebase.Auth.AuthResult result = task.Result;
  Debug.LogFormat("User signed in successfully: {0} ({1})",
      result.User.DisplayName, result.User.UserId);
});

firebase::Future<firebase::auth::AuthResult> result =
    auth->SignInWithCustomToken(custom_token);

firebase.auth().signInWithCustomToken(token)
  .then((userCredential) => {
    // Signed in
    var user = userCredential.user;
    // ...
  })
  .catch((error) => {
    var errorCode = error.code;
    var errorMessage = error.message;
    // ...
  });
custom.js

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

const auth = getAuth();
signInWithCustomToken(auth, token)
  .then((userCredential) => {
    // Signed in
    const user = userCredential.user;
    // ...
  })
  .catch((error) => {
    const errorCode = error.code;
    const errorMessage = error.message;
    // ...
  });
auth_sign_in_custom.js

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

साइन-इन करने के अन्य तरीकों (जैसे, signInWithEmailAndPassword() और signInWithCredential()) की तरह ही, आपके Realtime Database Security Rules में मौजूद auth ऑब्जेक्ट और आपके Cloud Storage Security Rules में मौजूद request.auth ऑब्जेक्ट में, उपयोगकर्ता का uid भर जाएगा. इस मामले में, uid वह होगा जो आपने कस्टम टोकन जनरेट करते समय तय किया था.

{
  "rules": {
    "adminContent": {
      ".read": "auth.uid === 'some-uid'"
    }
  }
}

service firebase.storage {
  match /b/<your-firebase-storage-bucket>/o {
    match /adminContent/{filename} {
      allow read, write: if request.auth != null && request.auth.uid == "some-uid";
    }
  }
}

अगर कस्टम टोकन में अतिरिक्त दावे शामिल हैं, तो उन्हें आपके नियमों में auth.token (Firebase Realtime Database) या request.auth.token (Cloud Storage) ऑब्जेक्ट से रेफ़रंस दिया जा सकता है:

{
  "rules": {
    "premiumContent": {
      ".read": "auth.token.premiumAccount === true"
    }
  }
}

service firebase.storage {
  match /b/<your-firebase-storage-bucket>/o {
    match /premiumContent/{filename} {
      allow read, write: if request.auth.token.premiumAccount == true;
    }
  }
}

तीसरे पक्ष की JWT लाइब्रेरी का इस्तेमाल करके कस्टम टोकन बनाना

अगर आपका बैकएंड किसी ऐसी भाषा में है जिसमें आधिकारिक Firebase Admin SDK मौजूद नहीं है, तो भी कस्टम टोकन मैन्युअल तरीके से बनाए जा सकते हैं. सबसे पहले, अपनी भाषा के लिए तीसरे पक्ष की JWT लाइब्रेरी ढूंढें. इसके बाद, उस JWT लाइब्रेरी का इस्तेमाल करके JWT बनाएं. इसमें ये दावे शामिल होने चाहिए:

यहां कुछ उदाहरण दिए गए हैं, जिनसे पता चलता है कि Firebase Admin SDK के साथ काम न करने वाली अलग-अलग भाषाओं में कस्टम टोकन कैसे बनाए जाते हैं. इन उदाहरणों में, सेवा खाते के निजी पासकोड का इस्तेमाल करके, टोकन को स्थानीय तौर पर साइन किया जाता है. इसलिए, सेवा खाते की कुंजी वाली फ़ाइलों के लिए सुरक्षा से जुड़े दिशा-निर्देश लागू होते हैं. निजी पासकोड को मैनेज करने से बचने के लिए, Google से टोकन पेलोड पर रिमोट तरीके से हस्ताक्षर कराया जा सकता है. इसके लिए, आईएएम सेवा खाते के क्रेडेंशियल एपीआई के signJwt तरीके को कॉल करें. कॉलर के पास सेवा खाते में, सेवा खाता टोकन क्रिएटर की भूमिका होनी चाहिए.

// Requires: composer require firebase/php-jwt
use Firebase\JWT\JWT;

// Placeholder values. In production, load your service account's email
// address and private key from a secure secret store. Never hard-code
// private keys in source code.
$service_account_email = "abc-123@a-b-c-123.iam.gserviceaccount.com";
$private_key = "-----BEGIN PRIVATE KEY-----...";

function create_custom_token($uid, $is_premium_account) {
  global $service_account_email, $private_key;

  $now_seconds = time();
  $payload = array(
    "iss" => $service_account_email,
    "sub" => $service_account_email,
    "aud" => "https://identitytoolkit.googleapis.com/google.identity.identitytoolkit.v1.IdentityToolkit",
    "iat" => $now_seconds,
    "exp" => $now_seconds+(60*60),  // Maximum expiration time is one hour
    "uid" => $uid,
    "claims" => array(
      "premium_account" => $is_premium_account
    )
  );
  return JWT::encode($payload, $private_key, "RS256");
}

require "jwt"

# Placeholder values. In production, load your service account's email
# address and private key from a secure secret store. Never hard-code
# private keys in source code.
$service_account_email = "service-account@my-project-abc123.iam.gserviceaccount.com"
$private_key = OpenSSL::PKey::RSA.new "-----BEGIN PRIVATE KEY-----\n..."

def create_custom_token(uid, is_premium_account)
  now_seconds = Time.now.to_i
  payload = {:iss => $service_account_email,
             :sub => $service_account_email,
             :aud => "https://identitytoolkit.googleapis.com/google.identity.identitytoolkit.v1.IdentityToolkit",
             :iat => now_seconds,
             :exp => now_seconds+(60*60), # Maximum expiration time is one hour
             :uid => uid,
             :claims => {:premium_account => is_premium_account}}
  JWT.encode payload, $private_key, "RS256"
end

कस्टम टोकन बनाने के बाद, उसे अपने क्लाइंट ऐप्लिकेशन पर भेजें, ताकि Firebase के साथ पुष्टि करने के लिए उसका इस्तेमाल किया जा सके. ऐसा करने का तरीका जानने के लिए, ऊपर दिए गए कोड सैंपल देखें.

समस्या का हल

इस सेक्शन में, कस्टम टोकन बनाते समय डेवलपर को होने वाली कुछ आम समस्याओं के बारे में बताया गया है. साथ ही, उन्हें हल करने का तरीका भी बताया गया है.

IAM API चालू नहीं है

अगर आपने टोकन पर हस्ताक्षर करने के लिए सेवा खाते का आईडी दिया है, तो आपको इस तरह की गड़बड़ी मिल सकती है:

Identity and Access Management (IAM) API has not been used in project
1234567890 before or it is disabled. Enable it by visiting
https://console.developers.google.com/apis/api/iam.googleapis.com/overview?project=1234567890
then retry. If you enabled this API recently, wait a few minutes for the action
to propagate to our systems and retry.

Firebase Admin SDK, टोकन पर हस्ताक्षर करने के लिए IAM API का इस्तेमाल करता है. इस गड़बड़ी का मतलब है कि आपके Firebase प्रोजेक्ट के लिए, आईएएम एपीआई फ़िलहाल चालू नहीं है. गड़बड़ी के मैसेज में दिए गए लिंक को किसी वेब ब्राउज़र में खोलें. इसके बाद, अपने प्रोजेक्ट के लिए एपीआई चालू करने के लिए, "एपीआई चालू करें" बटन पर क्लिक करें.

सेवा खाते के पास ज़रूरी अनुमतियां नहीं हैं

अगर Firebase Admin SDK टूल को चलाने वाले सेवा खाते के पास iam.serviceAccounts.signBlob अनुमति नहीं है, तो आपको गड़बड़ी का यह मैसेज मिल सकता है:

Permission iam.serviceAccounts.signBlob is required to perform this operation
on service account projects/-/serviceAccounts/{your-service-account-id}.

इस समस्या को हल करने के लिए, सही सेवा खाते को सेवा खाता टोकन क्रिएटर की आईएएम भूमिका असाइन करें. इस्तेमाल किया जाने वाला डिफ़ॉल्ट सेवा खाता, एनवायरमेंट और Cloud Functions के वर्शन पर निर्भर करता है:

• Cloud Functions (पहली जनरेशन): यह डिफ़ॉल्ट App Engine सेवा खाते का इस्तेमाल करता है.
• Cloud Functions (दूसरी जनरेशन): इसमें Compute Engine के डिफ़ॉल्ट सेवा खाते का इस्तेमाल किया जाता है.

1. Google Cloud कंसोल में, IAM और एडमिन पर जाएं.

2. आपको जिस सेवा खाते को अपडेट करना है उसके बगल में मौजूद, 'बदलाव करें' आइकॉन पर क्लिक करें.

3. कोई अन्य भूमिका जोड़ें पर क्लिक करें.

4. खोज फ़िल्टर में "Service Account Token Creator" टाइप करें और नतीजों में से इसे चुनें

5. भूमिका असाइन करने की पुष्टि करने के लिए, सेव करें पर क्लिक करें.

इस प्रोसेस के बारे में ज़्यादा जानने के लिए, आईएएम दस्तावेज़ देखें. इसके अलावा, gcloud कमांड-लाइन टूल का इस्तेमाल करके, भूमिकाओं को अपडेट करने का तरीका जानें.

सेवा खाते का पता नहीं लगाया जा सका

अगर आपको यहां दिए गए मैसेज जैसा कोई गड़बड़ी का मैसेज मिलता है, तो इसका मतलब है कि Firebase Admin SDK को सही तरीके से शुरू नहीं किया गया है.

Failed to determine service account ID. Initialize the SDK with service account
credentials or specify a service account ID with iam.serviceAccounts.signBlob
permission.

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