สร้างโทเค็นที่กำหนดเอง

Firebase ให้คุณควบคุมการตรวจสอบสิทธิ์ได้อย่างเต็มที่โดยอนุญาตให้คุณ ตรวจสอบสิทธิ์ผู้ใช้หรืออุปกรณ์ที่ใช้โทเค็นเว็บ JSON ที่ปลอดภัย (JWT) คุณสร้าง โทเค็นเหล่านี้บนเซิร์ฟเวอร์ แล้วส่งกลับไปยังอุปกรณ์ไคลเอ็นต์ จากนั้นใช้ เพื่อตรวจสอบสิทธิ์ผ่านทางเมธอด signInWithCustomToken()

คุณต้องสร้างปลายทางเซิร์ฟเวอร์ที่ยอมรับการลงชื่อเข้าใช้ ข้อมูลเข้าสู่ระบบ เช่น ชื่อผู้ใช้และรหัสผ่าน และหากข้อมูลเข้าสู่ระบบ ถูกต้อง แสดงผล JWT ที่กำหนดเอง JWT ที่กำหนดเองที่แสดงผลจากเซิร์ฟเวอร์ของคุณสามารถ จะใช้โดยอุปกรณ์ไคลเอ็นต์เพื่อตรวจสอบสิทธิ์กับ Firebase (iOS+, Android, เว็บ) เมื่อตรวจสอบสิทธิ์แล้ว ข้อมูลประจำตัวนี้จะถูก ที่ใช้เมื่อเข้าถึงบริการ Firebase อื่นๆ เช่น Firebase Realtime Database และ Cloud Storage นอกจากนี้ เนื้อหาของ JWT จะ ที่มีอยู่ในออบเจ็กต์ auth ใน Realtime Database Security Rules และ ออบเจ็กต์ request.auth รายการใน Cloud Storage Security Rules

คุณจะสร้างโทเค็นที่กำหนดเองด้วย Firebase Admin SDK หรือ ใช้ไลบรารี JWT ของบุคคลที่สาม ถ้าเซิร์ฟเวอร์ของคุณเขียนด้วย ภาษาที่ Firebase ไม่รองรับโดยค่าเริ่มต้น

ก่อนเริ่มต้น

โทเค็นที่กำหนดเองจะเป็น JWT ที่ลงนามแล้ว โดยที่คีย์ส่วนตัวที่ใช้สำหรับการลงนามเป็นของ บัญชีบริการของ Google การระบุบริการของ Google ทำได้หลายวิธี บัญชีที่ Firebase Admin SDK ควรใช้สำหรับการรับรองที่กำหนดเอง โทเค็น:

• การใช้ไฟล์ JSON ของบัญชีบริการ -- วิธีการนี้สามารถใช้ใน สภาพแวดล้อมของคุณ แต่กำหนดให้คุณต้องทำแพ็กเกจไฟล์ JSON ของบัญชีบริการ พร้อมกับรหัสของคุณ คุณต้องระมัดระวังเป็นพิเศษเพื่อให้แน่ใจว่า ไฟล์ JSON ของบัญชีบริการไม่เปิดเผยต่อบุคคลภายนอก
• การอนุญาตให้ Admin SDK ค้นพบบัญชีบริการ -- วิธีการนี้ สามารถใช้ในสภาพแวดล้อมที่จัดการโดย Google เช่น Google Cloud ฟังก์ชันและ App Engine คุณอาจต้องกำหนดค่า สิทธิ์เพิ่มเติมผ่านคอนโซล Google Cloud
• การใช้รหัสบัญชีบริการ -- เมื่อใช้ในสภาพแวดล้อมที่ Google จัดการ เมธอดนี้จะลงนามโทเค็นโดยใช้ คีย์ของบัญชีบริการที่ระบุ แต่ระบบจะใช้บริการเว็บระยะไกล และคุณอาจต้องกำหนดค่า สิทธิ์เพิ่มเติมสำหรับบัญชีบริการนี้ผ่านทาง คอนโซล Google Cloud

การใช้ไฟล์ JSON ของบัญชีบริการ

ไฟล์ JSON ของบัญชีบริการมีข้อมูลทั้งหมดที่เกี่ยวข้องกับบริการ (รวมถึงคีย์ส่วนตัว RSA ด้วย) สามารถดาวน์โหลดได้จาก คอนโซล Firebase ทําตามการตั้งค่า Admin SDK วิธีการเพื่อดูข้อมูลเพิ่มเติมเกี่ยวกับวิธี เริ่มต้น Admin SDK ด้วยไฟล์ JSON ของบัญชีบริการ

การเริ่มต้นวิธีนี้เหมาะสำหรับ Admin SDK ที่หลากหลาย การใช้งานจริง นอกจากนี้ ยังช่วยให้ Admin SDK สร้างและลงนามโทเค็นที่กำหนดเองได้ด้วย ในเครื่อง โดยไม่ต้องเรียก API จากระยะไกล ข้อเสียหลักของการดำเนินการนี้ วิธีการคือคุณต้องสร้างแพ็กเกจไฟล์ JSON ของบัญชีบริการ พร้อมกับรหัสของคุณ นอกจากนี้ โปรดทราบว่าคีย์ส่วนตัวในบัญชีบริการ ไฟล์ JSON เป็นข้อมูลที่ละเอียดอ่อน และต้องมีความระมัดระวังเป็นพิเศษเพื่อเก็บรักษา เป็นความลับ กล่าวอย่างเจาะจงคือ อย่าเพิ่มไฟล์ JSON ของบัญชีบริการ ลงในการควบคุมเวอร์ชันสาธารณะ

การให้ Admin SDK ค้นพบบัญชีบริการ

หากใช้งานโค้ดในสภาพแวดล้อมที่ Google เป็นผู้จัดการ Admin SDK สามารถช่วยค้นหาวิธีการโดยอัตโนมัติในการลงนามโทเค็นที่กำหนดเองได้ดังนี้

• หากมีการทำให้โค้ดใช้งานได้ในสภาพแวดล้อมมาตรฐานของ App Engine สำหรับ Java, Python หรือ Go, Admin SDK สามารถใช้ บริการ App Identity ที่มีอยู่ในสภาพแวดล้อมดังกล่าวเพื่อลงนามโทเค็นที่กำหนดเอง บริการ App Identity ลงนามข้อมูลโดยใช้บัญชีบริการที่แอป Google จัดสรรไว้สำหรับแอปของคุณ เครื่องมือ

• การติดตั้งใช้งานโค้ดในสภาพแวดล้อมที่มีการจัดการอื่นๆ หรือไม่ (เช่น Google Cloud ฟังก์ชัน, Google Compute Engine), Firebase Admin SDK สามารถค้นพบ สตริงรหัสบัญชีบริการจากในเครื่อง เซิร์ฟเวอร์ข้อมูลเมตา จากนั้นระบบจะใช้รหัสบัญชีบริการที่ค้นพบร่วมกับ IAM เพื่อลงนามโทเค็นจากระยะไกล

หากต้องการใช้วิธีการลงนามเหล่านี้ ให้เริ่มต้น 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();

หากต้องการทดสอบโค้ดเดียวกันในเครื่อง ให้ดาวน์โหลดไฟล์ JSON ของบัญชีบริการและตั้งค่า ตัวแปรสภาพแวดล้อม GOOGLE_APPLICATION_CREDENTIALS ที่จะชี้ไป

หาก Firebase Admin SDK ต้องค้นพบสตริงรหัสบัญชีบริการ ดังนั้นเมื่อโค้ดของคุณสร้างโทเค็นที่กำหนดเองเป็นครั้งแรก ผลลัพธ์จะได้รับการแคชและนำมาใช้ซ้ำสำหรับการดำเนินการลงนามโทเค็นครั้งต่อๆ ไป รหัสบัญชีบริการที่ค้นพบโดยอัตโนมัติมักจะเป็นหนึ่งในบริการเริ่มต้น บัญชีจาก Google Cloud:

• บัญชีบริการ Compute Engine เริ่มต้น
• บัญชีบริการ Cloud Functions เริ่มต้น

บริการที่ค้นพบอัตโนมัติเช่นเดียวกันกับรหัสบัญชีบริการที่ระบุไว้อย่างชัดเจน รหัสบัญชีต้องมีสิทธิ์ iam.serviceAccounts.signBlob สำหรับ การสร้างโทเค็นที่กำหนดเองเพื่อให้ใช้งานได้ คุณอาจต้องใช้ ส่วน IAM และผู้ดูแลระบบ ของคอนโซล Google Cloud เพื่อให้สิทธิ์บัญชีบริการเริ่มต้น สิทธิ์ที่จำเป็น ดูรายละเอียดเพิ่มเติมได้ในส่วนการแก้ปัญหาด้านล่าง

การใช้รหัสบัญชีบริการ

หากต้องการรักษาความสอดคล้องกันระหว่างส่วนต่างๆ ของแอปพลิเคชัน คุณสามารถ ระบุรหัสบัญชีบริการที่ใช้คีย์ในการรับรองโทเค็นเมื่อเรียกใช้ ในสภาพแวดล้อมที่จัดการโดย Google ซึ่งจะทำให้นโยบาย IAM ง่ายขึ้นและปลอดภัยขึ้น รวมถึงช่วยให้คุณไม่ต้องดำเนินการต่อไปนี้ รวมไฟล์ JSON ของบัญชีบริการไว้ในโค้ด

รหัสบัญชีบริการจะอยู่ใน คอนโซล Google Cloud, หรือในช่อง client_email ของไฟล์ JSON ของบัญชีบริการที่ดาวน์โหลดมา รหัสบัญชีบริการคืออีเมลในรูปแบบต่อไปนี้ <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 นั้น ที่ใช้เพื่อทำการโทรนี้ —โดยปกติคือ {project-name}@appspot.gserviceaccount.com— มี iam.serviceAccounts.signBlob สิทธิ์ ดูรายละเอียดเพิ่มเติมได้ในส่วนการแก้ปัญหาด้านล่าง

สร้างโทเค็นที่กำหนดเองโดยใช้ Firebase Admin SDK

Firebase Admin SDK มีเมธอดในตัวสำหรับการสร้างโทเค็นที่กำหนดเอง ที่ คุณต้องระบุ uid ซึ่งเป็นสตริงใดก็ได้ แต่ควรเป็นสตริงใดก็ได้ ระบุผู้ใช้หรืออุปกรณ์ที่คุณกำลังตรวจสอบสิทธิ์โดยไม่ซ้ำกัน โทเค็นเหล่านี้หมดอายุ หลังผ่านไป 1 ชั่วโมง

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()) ออบเจ็กต์ auth ใน Realtime Database Security Rules และ ออบเจ็กต์ request.auth ในไฟล์ Cloud Storage Security Rules จะ เติมด้วย 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 อย่างเป็นทางการ SDK คุณยังคงสร้างโทเค็นที่กำหนดเองได้ อันดับแรก ค้นหาไลบรารี JWT ของบุคคลที่สามสำหรับภาษาของคุณ จากนั้นใช้ ไลบรารี 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 เพื่อลงนามโทเค็น ข้อผิดพลาดนี้บ่งบอกว่าไม่ได้เปิดใช้ IAM API อยู่ในขณะนี้ สำหรับ โปรเจ็กต์ Firebase เปิดลิงก์ในข้อความแสดงข้อผิดพลาดในเว็บเบราว์เซอร์ และ ให้คลิก "เปิดใช้ 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. เปิด IAM และผู้ดูแลระบบ ในคอนโซล Google Cloud
2. เลือกโปรเจ็กต์แล้วคลิก "ต่อไป"
3. คลิกไอคอนแก้ไขที่ตรงกับบัญชีบริการที่คุณต้องการอัปเดต
4. คลิกที่ "เพิ่มบทบาทอื่น"
5. พิมพ์ "Service Account Token Creator" ลงในตัวกรองการค้นหา แล้วเลือก จากผลการค้นหา
6. คลิก "บันทึก" เพื่อยืนยันการให้สิทธิ์บทบาท

ดูเอกสารประกอบ IAM สำหรับรายละเอียดเพิ่มเติมเกี่ยวกับกระบวนการนี้ หรือดูวิธีอัปเดตบทบาทโดยใช้ เครื่องมือบรรทัดคำสั่ง 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 ของบัญชีบริการหรือรหัสบัญชีบริการ ตั้งแต่การเริ่มต้น SDK