หน้านี้ได้รับการแปลโดย Cloud Translation API

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

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

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

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

ก่อนจะเริ่ม

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

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

การใช้ไฟล์ 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 App Engine จัดเตรียมไว้สำหรับแอปของคุณ
หากโค้ดของคุณใช้งานได้ในสภาพแวดล้อมที่มีการจัดการอื่นๆ (เช่น Google Cloud Functions, Google Compute Engine) Firebase Admin SDK สามารถค้นหาสตริงรหัสบัญชีบริการจาก เซิร์ฟเวอร์ข้อมูลเมตา ในเครื่องได้โดยอัตโนมัติ จากนั้นใช้รหัสบัญชีบริการที่ค้นพบร่วมกับบริการ IAM เพื่อลงนามโทเค็นจากระยะไกล

ในการใช้วิธีลงนามเหล่านี้ ให้เริ่มต้น SDK ด้วยข้อมูลรับรองเริ่มต้นของแอปพลิเคชัน Google และอย่าระบุสตริงรหัสบัญชีบริการ:

Node.js

initializeApp();

Java

FirebaseApp.initializeApp();

Python

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 จัดให้:

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

การใช้ ID บัญชีบริการ

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

รหัสบัญชีบริการสามารถพบได้ใน Google Cloud Console หรือในฟิลด์ client_email ของไฟล์ JSON ของบัญชีบริการที่ดาวน์โหลด รหัสบัญชีบริการคือที่อยู่อีเมลที่มีรูปแบบดังนี้: <client-id>@<project-id>.iam.gserviceaccount.com โดยจะระบุบัญชีบริการที่ไม่ซ้ำกันในโปรเจ็กต์ Firebase และ Google Cloud

ในการสร้างโทเค็นที่กำหนดเองโดยใช้รหัสบัญชีบริการแยกต่างหาก ให้เริ่มต้น SDK ดังที่แสดงด้านล่าง:

Node.js

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

Java

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

Python

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 ซึ่งสามารถเป็นสตริงใดก็ได้ แต่ควรระบุผู้ใช้หรืออุปกรณ์ที่คุณกำลังตรวจสอบสิทธิ์โดยไม่ซ้ำกัน โทเค็นเหล่านี้จะหมดอายุหลังจากผ่านไปหนึ่งชั่วโมง

Node.js

const uid = 'some-uid';

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

Java

String uid = "some-uid";

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

Python

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 ในกฎความปลอดภัยของคุณ:

Node.js

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);
  });

Java

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

Python

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() :

iOS+

วัตถุประสงค์-C

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

Swift

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

Android

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.FirebaseUser newUser = task.Result;
  Debug.LogFormat("User signed in successfully: {0} ({1})",
      newUser.DisplayName, newUser.UserId);
});

C++

firebase::Future<firebase::auth::User*> 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;
    // ...
  });

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

ในลักษณะเดียวกับวิธีการลงชื่อเข้าใช้อื่นๆ (เช่น signInWithEmailAndPassword() และ signInWithCredential() ) ออบเจ็กต์ auth ใน Realtime Database 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) หรือ 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 ซึ่งรวมการอ้างสิทธิ์ต่อไปนี้:

การอ้างสิทธิ์โทเค็นที่กำหนดเอง
`alg`	อัลกอริทึม	`"RS256"`
`iss`	ผู้ออก	ที่อยู่อีเมลบัญชีบริการของโปรเจ็กต์ของคุณ
`sub`	เรื่อง	ที่อยู่อีเมลบัญชีบริการของโปรเจ็กต์ของคุณ
`aud`	ผู้ชม	`"https://identitytoolkit.googleapis.com/google.identity.identitytoolkit.v1.IdentityToolkit"`
`iat`	ออกในเวลา	เวลาปัจจุบัน หน่วยเป็นวินาทีนับตั้งแต่ยุค UNIX
`exp`	เวลาหมดอายุ	เวลาเป็นวินาทีนับตั้งแต่ยุค UNIX ที่โทเค็นหมดอายุ อาจช้ากว่า `iat` สูงสุด 3600 วินาที หมายเหตุ: วิธีนี้จะควบคุมเฉพาะเวลา ที่โทเค็นที่กำหนด เองหมดอายุเท่านั้น แต่เมื่อคุณลงชื่อเข้าใช้ผู้ใช้โดยใช้ `signInWithCustomToken()` พวกเขาจะยังคงลงชื่อเข้าใช้อุปกรณ์จนกว่าเซสชันของพวกเขาจะถูกยกเลิกหรือผู้ใช้ออกจากระบบ
`uid`		ตัวระบุเฉพาะของผู้ใช้ที่ลงชื่อเข้าใช้ต้องเป็นสตริงที่มีความยาวระหว่าง 1-36 อักขระ
`claims` (ไม่บังคับ)		ตัวเลือกการอ้างสิทธิ์ที่กำหนดเองเพื่อรวมไว้ในตัวแปร `auth` / `request.auth` ของกฎความปลอดภัย

ตัวอย่างการใช้งานวิธีสร้างโทเค็นที่กำหนดเองในภาษาต่างๆ ที่ Firebase Admin SDK ไม่รองรับมีดังต่อไปนี้

PHP

ใช้ php-jwt :

// 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");
}

ทับทิม

ใช้ ruby-jwt :

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

หากคุณกำลังระบุ ID บัญชีบริการสำหรับการเซ็นชื่อโทเค็น คุณอาจได้รับข้อผิดพลาดที่คล้ายกับต่อไปนี้:

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 :

เปิดหน้า IAM และผู้ดูแลระบบ ใน Google Cloud Console
เลือกโครงการของคุณและคลิก "ดำเนินการต่อ"
คลิกไอคอนแก้ไขที่เกี่ยวข้องกับบัญชีบริการที่คุณต้องการอัปเดต
คลิกที่ "เพิ่มบทบาทอื่น"
พิมพ์ "Service Account Token Creator" ลงในตัวกรองการค้นหา และเลือกจากผลลัพธ์
คลิก "บันทึก" เพื่อยืนยันการมอบบทบาท

โปรดดูรายละเอียดเพิ่มเติมเกี่ยวกับกระบวนการนี้ใน เอกสาร 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