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

Firebase, पुष्टि करने की प्रोसेस को पूरी तरह से कंट्रोल करने की सुविधा देता है. इसके लिए, वह आपको सुरक्षित JSON Web Token (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 सेवा खाते को तय करने के कई तरीके हैं:

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

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

सेवा खाते की JSON फ़ाइलों में, सेवा खातों से जुड़ी सारी जानकारी होती है. इसमें आरएसए की निजी कुंजी भी शामिल है. इन्हें Firebase कंसोल से डाउनलोड किया जा सकता है. सेवा खाते की JSON फ़ाइल के साथ Admin SDK को शुरू करने के तरीके के बारे में ज़्यादा जानने के लिए, Admin SDK सेट अप करने के निर्देश पढ़ें.

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

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

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

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

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

साइन इन करने के इन तरीकों का इस्तेमाल करने के लिए, 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();

उसी कोड को स्थानीय तौर पर टेस्ट करने के लिए, सेवा खाते की JSON फ़ाइल डाउनलोड करें. इसके बाद, GOOGLE_APPLICATION_CREDENTIALS एनवायरमेंट वैरिएबल को सेट करके, उसे इस फ़ाइल पर पॉइंट करें.

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

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

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

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

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

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

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

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

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 बनाएं. इसमें ये दावे शामिल होने चाहिए:

यहां कुछ भाषाओं में कस्टम टोकन बनाने के तरीके के उदाहरण दिए गए हैं. ये ऐसी भाषाएं हैं जिनमें Firebase Admin SDK काम नहीं करता:

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

// Get your service account's email address and private key from the JSON key file
$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"

# Get your service account's email address and private key from the JSON key file
$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 प्रोजेक्ट के लिए IAM API चालू नहीं है. वेब ब्राउज़र में, गड़बड़ी के मैसेज में दिया गया लिंक खोलें. इसके बाद, अपने प्रोजेक्ट के लिए इसे चालू करने के लिए, "API चालू करें" बटन पर क्लिक करें.

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

अगर 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}.

इस समस्या को हल करने का सबसे आसान तरीका यह है कि सेवा खाते को "सेवा खाता टोकन क्रिएटर" IAM भूमिका असाइन करें. आम तौर पर, ऐसा {project-name}@appspot.gserviceaccount.com में किया जाता है:

1. Google Cloud Console में, IAM और एडमिन पेज खोलें.
2. अपना प्रोजेक्ट चुनें और "जारी रखें" पर क्लिक करें.
3. जिस सेवा खाते को अपडेट करना है उसके बगल में मौजूद, बदलाव करें आइकॉन पर क्लिक करें.
4. "दूसरी भूमिका जोड़ें" पर क्लिक करें.
5. खोज फ़िल्टर में "Service Account Token Creator" टाइप करें और नतीजों में से इसे चुनें.
6. भूमिका असाइन करने की पुष्टि करने के लिए, "सेव करें" पर क्लिक करें.

इस प्रोसेस के बारे में ज़्यादा जानने के लिए, आईएएम दस्तावेज़ पढ़ें. इसके अलावा, 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 के मैनेज किए गए ऐसे एनवायरमेंट में डिप्लॉय किया गया हो जिसमें मेटाडेटा सर्वर मौजूद हो. अगर ऐसा नहीं है, तो एसडीके को शुरू करते समय, सेवा खाते की JSON फ़ाइल या सेवा खाते का आईडी ज़रूर डालें.