הגדרת הסביבה

לעתים קרובות תזדקק לתצורה נוספת עבור הפונקציות שלך, כגון מפתחות API של צד שלישי או הגדרות ניתנות לכיוונון. Firebase SDK for Cloud Functions מציע תצורת סביבה מובנית כדי להקל על אחסון ושליפה של סוג זה של נתונים עבור הפרויקט שלך.

אתה יכול לבחור בין שלוש אפשרויות:

• תצורה עם פרמטרים (מומלץ עבור רוב התרחישים). זה מספק תצורת סביבה מוקפדת היטב עם פרמטרים המאומתים בזמן הפריסה, מה שמונע שגיאות ומפשט את ניפוי הבאגים.
• תצורה מבוססת קבצים של משתני סביבה . עם גישה זו, אתה יוצר באופן ידני קובץ dotenv לטעינת משתני סביבה.
• תצורת סביבת זמן ריצה עם Firebase CLI ו- functions.config (פונקציות ענן (דור ראשון) בלבד).

עבור רוב מקרי השימוש, מומלצת תצורה עם פרמטרים. גישה זו הופכת ערכי תצורה לזמינים הן בזמן הריצה והן בזמן הפריסה, והפריסה חסומה אלא אם לכל הפרמטרים יש ערך חוקי. לעומת זאת, תצורה עם משתני סביבה אינה זמינה בזמן הפריסה.

תצורה עם פרמטרים

Cloud Functions for Firebase מספק ממשק להגדרת פרמטרי תצורה באופן הצהרתי בתוך בסיס הקוד שלך. הערך של פרמטרים אלה זמין הן במהלך פריסת הפונקציות, בעת הגדרת אפשרויות פריסה וזמן ריצה, והן במהלך ביצוע. המשמעות היא שה-CLI יחסום את הפריסה אלא אם לכל הפרמטרים יש ערך חוקי.

כדי להגדיר פרמטרים בקוד שלך, עקוב אחר המודל הזה:

const functions = require('firebase-functions');
const { defineInt, defineString } = require('firebase-functions/params');

// Define some parameters
const minInstancesConfig = defineInt('HELLO_WORLD_MININSTANCES');
const welcomeMessage = defineString('WELCOME_MESSAGE');

// To use configured parameters inside the config for a function, provide them
// directly. To use them at runtime, call .value() on them.
export const helloWorld = functions.runWith({ minInstances: minInstancesConfig}).https.onRequest(
  (req, res) => {
    res.send(`${welcomeMessage.value()}! I am a function.`);
  }
);

בעת פריסת פונקציה עם משתני תצורה עם פרמטרים, ה-CLI של Firebase מנסה תחילה לטעון את הערכים שלהם מקובצי .env מקומיים. אם הם אינם קיימים בקבצים אלה ולא default , ה-CLI יבקש את הערכים במהלך הפריסה, ולאחר מכן ישמור אוטומטית את הערכים שלהם בקובץ .env בשם .env.<project_ID> בספריית functions/ שלך:

$ firebase deploy
i  functions: preparing codebase default for deployment
? Enter a string value for ENVIRONMENT: prod
i  functions: Writing new parameter values to disk: .env.projectId
…
$ firebase deploy
i  functions: Loaded environment variables from .env.projectId

בהתאם לזרימת העבודה בפיתוח שלך, ייתכן שיהיה שימושי להוסיף את קובץ .env.<project_ID> שנוצר לבקרת הגירסה.

הגדר התנהגות CLI

ניתן להגדיר פרמטרים עם אובייקט Options השולט כיצד ה-CLI יבקש ערכים. הדוגמה הבאה מגדירה אפשרויות לאימות הפורמט של מספר טלפון, לספק אפשרות בחירה פשוטה ולאכלוס אפשרות בחירה אוטומטית מפרויקט Firebase:

const { defineString } = require('firebase-functions/params');

const welcomeMessage = defineString('WELCOME_MESSAGE', {default: 'Hello World',
description: 'The greeting that is returned to the caller of this function'});

const onlyPhoneNumbers = defineString('PHONE_NUMBER', {input: {text:
{validationRegex: /\d{3}-\d{3}-\d{4}/, validationErrorMessage: "Please enter
a phone number in the format XXX-YYY-ZZZZ"}}});

const selectedOption = defineString('PARITY', {input: {select: {options:
[{value: "odd"}, {value: "even"}]}}})

const storageBucket = defineString('BUCKET', {input: {resource: {type:
"storage.googleapis.com/Bucket"}}, description: "This will automatically
populate the selector field with the deploying Cloud Project’s
storage buckets"})

סוגי פרמטרים

תצורה פרמטרית מספקת הקלדה חזקה עבור ערכי פרמטרים, וגם תומכת בסודות מ-Cloud Secret Manager. הסוגים הנתמכים הם:

• סוֹד
• חוּט
• בוליאנית
• מספר שלם
• לָצוּף

ערכי פרמטרים וביטויים

Firebase מעריך את הפרמטרים שלך גם בזמן הפריסה וגם בזמן שהפונקציה שלך מופעלת. בשל הסביבות הכפולות הללו, יש לנקוט משנה זהירות בעת השוואת ערכי פרמטרים, וכאשר משתמשים בהם כדי להגדיר אפשרויות זמן ריצה עבור הפונקציות שלך.

כדי להעביר פרמטר לפונקציה שלך כאפשרות זמן ריצה, העבר אותו ישירות:

const functions = require('firebase-functions');
const { defineInt} = require('firebase-functions/params');
const minInstancesConfig = defineInt('HELLO\_WORLD\_MININSTANCES');

export const helloWorld = functions.runWith({ minInstances: minInstancesConfig}).https.onRequest(
  (req, res) => {
    //…

בנוסף, אם אתה צריך להשוות מול פרמטר כדי לדעת באיזו אפשרות לבחור, תצטרך להשתמש בהשוואות מובנות במקום לבדוק את הערך:

const functions = require('firebase-functions');
const { defineBool } = require('firebase-functions/params');
const environment = params.defineString(‘ENVIRONMENT’, {default: ‘dev’});

// use built-in comparators
const minInstancesConfig =environment.equals('PRODUCTION').thenElse(10, 1);
export const helloWorld = functions.runWith({ minInstances: minInstancesConfig}).https.onRequest(
  (req, res) => {
    //…

ניתן לגשת לפרמטרים וביטויי פרמטרים המשמשים רק בזמן ריצה באמצעות פונקציית value שלהם:

const functions = require('firebase-functions');
const { defineString } = require('firebase-functions/params');
const welcomeMessage = defineString('WELCOME_MESSAGE');

// To use configured parameters inside the config for a function, provide them
// directly. To use them at runtime, call .value() on them.
export const helloWorld = functions.https.onRequest(
 (req, res) => {
    res.send(`${welcomeMessage.value()}! I am a function.`);
  }
);

פרמטרים מובנים

ה-Cloud Functions SDK מציע שלושה פרמטרים מוגדרים מראש, הזמינים מתוך חבילת המשנה של firebase-functions/params :

• projectId - פרויקט הענן שבו הפונקציה פועלת.
• databaseUrl - כתובת האתר של מופע Realtime Database המשויך לפונקציה (אם מופעלת בפרויקט Firebase).
• storageBucket - דלי ה-Cloud Storage המשויך לפונקציה (אם מופעל בפרויקט Firebase).

אלה מתפקדים כמו פרמטרי מחרוזת המוגדרים על ידי המשתמש מכל הבחינות, פרט לכך, מכיוון שהערכים שלהם ידועים תמיד ל-Firebase CLI, לעולם לא יתבקשו לבצע את הערכים שלהם בזמן הפריסה ולא יישמרו בקבצי .env .

פרמטרים סודיים

פרמטרים מסוג Secret , המוגדרים באמצעות defineSecret() , מייצגים פרמטרים של מחרוזת שיש להם ערך המאוחסן ב-Cloud Secret Manager. במקום לבדוק מול קובץ .env מקומי ולכתוב ערך חדש לקובץ אם חסר, פרמטרים סודיים בודקים את קיומם ב-Cloud Secret Manager, ומבקשים באופן אינטראקטיבי את הערך של סוד חדש במהלך הפריסה.

פרמטרים סודיים המוגדרים בדרך זו חייבים להיות קשורים לפונקציות בודדות שאמורות להיות להם גישה אליהם:

const functions = require('firebase-functions');
const { defineSecret } = require('firebase-functions/params');
const discordApiKey = defineSecret('DISCORD_API_KEY');

export const postToDiscord = functions.runWith({ secrets: [discordApiKey] }).https.onRequest(
  (req, res) => {
    const apiKey = discordApiKey.value();
    //…

מכיוון שהערכים של סודות מוסתרים עד לביצוע הפונקציה, אינך יכול להשתמש בהם בזמן קביעת התצורה של הפונקציה שלך.

משתני סביבה

Cloud Functions for Firebase תומך בפורמט הקובץ dotenv לטעינת משתני סביבה שצוינו בקובץ .env לזמן הריצה של האפליקציה שלך. לאחר הפריסה, ניתן לקרוא את משתני הסביבה באמצעות ממשק process.env .

כדי להגדיר את הסביבה שלך כך, צור קובץ .env בפרויקט שלך, הוסף את המשתנים הרצויים ופרוס:

1. צור קובץ .env בספריית functions/ שלך:

   # Directory layout:
   #   my-project/
   #     firebase.json
   #     functions/
   #       .env
   #       package.json
   #       index.js
   

2. פתח את קובץ .env לעריכה והוסף את המפתחות הרצויים. לדוגמה:

   PLANET=Earth
   AUDIENCE=Humans
   

3. פרוס פונקציות וודא שמשתני סביבה נטענו:

   firebase deploy --only functions
   # ...
   # i functions: Loaded environment variables from .env.
   # ...
   

לאחר פריסת משתני הסביבה המותאמים אישית שלך, קוד הפונקציה שלך יכול לגשת אליהם באמצעות תחביר process.env :

// Responds with "Hello Earth and Humans"
exports.hello = functions.https.onRequest((request, response) => {
  response.send(`Hello ${process.env.PLANET} and ${process.env.AUDIENCE}`);
});

פריסת קבוצות מרובות של משתני סביבה

אם אתה צריך קבוצה חלופית של משתני סביבה לפרויקטים שלך ב-Firebase (כגון שלב מול ייצור), צור .env. <project or alias > קובץ וכתוב שם את משתני הסביבה הספציפיים לפרויקט שלך. משתני הסביבה מקובצי .env ו- .env ספציפיים לפרויקט (אם הם קיימים) ייכללו בכל הפונקציות הפרוסות.

לדוגמה, פרויקט יכול לכלול את שלושת הקבצים האלה המכילים ערכים מעט שונים לפיתוח וייצור:

.env	.env.dev	.env.prod
PLANET=כדור הארץ קהל=בני אדם	AUDIENCE=Dev Humans	קהל = אנשים יצרניים

בהתחשב בערכים באותם קבצים נפרדים, קבוצת משתני הסביבה הנפרסת עם הפונקציות שלך תשתנה בהתאם לפרויקט היעד שלך:

$ firebase use dev
$ firebase deploy --only functions
i functions: Loaded environment variables from .env, .env.dev.
# Deploys functions with following user-defined environment variables:
#   PLANET=Earth
#   AUDIENCE=Dev Humans

$ firebase use prod
$ firebase deploy --only functions
i functions: Loaded environment variables from .env, .env.prod.
# Deploys functions with following user-defined environment variables:
#   PLANET=Earth
#   AUDIENCE=Prod Humans

משתני סביבה שמורים

חלק מהמפתחות של משתני סביבה שמורים לשימוש פנימי. אל תשתמש באף אחד מהמפתחות האלה בקבצי .env שלך:

• כל המפתחות מתחילים ב-X_GOOGLE_
• כל המפתחות מתחילים ב-EXT_
• כל המפתחות מתחילים ב-FIREBASE_
• כל מפתח מהרשימה הבאה:
• CLOUD_RUNTIME_CONFIG
• נקודת כניסה
• GCP_PROJECT
• GCLOUD_PROJECT
• GOOGLE_CLOUD_PROJECT
• FUNCTION_TRIGGER_TYPE
• FUNCTION_NAME
• FUNCTION_MEMORY_MB
• FUNCTION_TIMEOUT_SEC
• FUNCTION_IDENTITY
• FUNCTION_REGION
• FUNCTION_TARGET
• FUNCTION_SIGNATURE_TYPE
• K_SERVICE
• K_REVISION
• נמל
• K_CONFIGURATION

אחסן וגישה למידע תצורה רגיש

ניתן להשתמש במשתני סביבה המאוחסנים בקבצי .env עבור תצורת פונקציות, אך אל תתייחס אליהם כדרך בטוחה לאחסון מידע רגיש כגון אישורי מסד נתונים או מפתחות API. זה חשוב במיוחד אם אתה בודק את קובצי .env שלך בבקרת המקור.

כדי לעזור לך לאחסן מידע תצורה רגיש, Cloud Functions for Firebase משתלב עם Google Cloud Secret Manager . שירות מוצפן זה מאחסן ערכי תצורה בצורה מאובטחת, ועדיין מאפשר גישה נוחה מהפונקציות שלך בעת הצורך.

צור סוד והשתמש בו

כדי ליצור סוד, השתמש ב-Firebase CLI.

כדי ליצור סוד ולהשתמש בו:

1. מהשורש של ספריית הפרויקט המקומית שלך, הפעל את הפקודה הבאה:

   firebase functions:secrets:set SECRET_NAME

2. הזן ערך עבור SECRET_NAME .

   ה-CLI מהדהד הודעת הצלחה ומזהיר שעליך לפרוס פונקציות כדי שהשינוי ייכנס לתוקף.

3. לפני הפריסה, ודא שקוד הפונקציות שלך מאפשר לפונקציה לגשת לסוד באמצעות הפרמטר runWith :

   exports.processPayment = functions
     // Make the secret available to this function
     .runWith({ secrets: ["SECRET_NAME"] })
     .onCall((data, context) => {
       const myBillingService = initializeBillingService(
         // reference the secret value
         process.env.SECRET_NAME
       );
       // Process the payment
     });

4. פריסת פונקציות ענן:

   firebase deploy --only functions

כעת תוכל לגשת אליו כמו כל משתנה סביבה אחר. לעומת זאת, אם פונקציה אחרת שאינה מציינת את הסוד ב- runWith מנסה לגשת לסוד, היא מקבלת ערך לא מוגדר:

  exports.anotherEndpoint = functions.https.onRequest((request, response) => {
    response.send(`The secret API key is ${process.env.SECRET_NAME}`);
    // responds with "The secret API key is undefined" because the `runWith` parameter is missing
  });

לאחר פריסת הפונקציה שלך, תהיה לה גישה לערך הסודי. רק לפונקציות שכוללות סוד באופן ספציפי בפרמטר runWith שלהן תהיה גישה לסוד זה כמשתנה סביבה. זה עוזר לך לוודא שערכים סודיים זמינים רק היכן שהם נחוצים, ומפחית את הסיכון של דליפת סוד בטעות.

ניהול סודות

השתמש ב-CLI של Firebase כדי לנהל את הסודות שלך. בזמן ניהול סודות בדרך זו, זכור שחלק משינויי CLI מחייבים אותך לשנות ו/או לפרוס מחדש פונקציות משויכות. באופן ספציפי:

• בכל פעם שאתה מגדיר ערך חדש לסוד, עליך לפרוס מחדש את כל הפונקציות המתייחסות לסוד הזה כדי שהן יקלוט את הערך האחרון.
• אם אתה מוחק סוד, ודא שאף אחת מהפונקציות הפרוסות שלך לא מתייחסת לסוד הזה. פונקציות המשתמשות בערך סודי שנמחק ייכשלו בשקט.

להלן סיכום של פקודות Firebase CLI לניהול סודי:

# Change the value of an existing secret
firebase functions:secrets:set SECRET_NAME

# View the value of a secret
functions:secrets:access SECRET_NAME

# Destroy a secret
functions:secrets:destroy SECRET_NAME

# View all secret versions and their state
functions:secrets:get SECRET_NAME

# Automatically clean up all secrets that aren't referenced by any of your functions
functions:secrets:prune

עבור פקודות access destroy , אתה יכול לספק את פרמטר הגרסה האופציונלי לניהול גרסה מסוימת. לדוגמה:

functions:secrets:access SECRET_NAME[@VERSION]

למידע נוסף על פעולות אלו, העבר -h עם הפקודה כדי להציג את העזרה של CLI.

כיצד מחויבים סודות

Secret Manager מאפשר 6 גרסאות סודיות פעילות ללא עלות. זה אומר שאתה יכול לקבל 6 סודות בחודש בפרויקט Firebase ללא עלות.

כברירת מחדל, ה-CLI של Firebase מנסה להשמיד אוטומטית גרסאות סודיות שאינן בשימוש במידת הצורך, כגון כאשר אתה פורס פונקציות עם גרסה חדשה של הסוד. כמו כן, אתה יכול לנקות באופן פעיל סודות שאינם בשימוש באמצעות functions:secrets:destroy ו- functions:secrets:prune .

Secret Manager מאפשר 10,000 פעולות גישה חודשיות ללא חיוב בסוד. מופעי פונקציות קוראים רק את הסודות שצוינו בפרמטר runWith שלהם בכל פעם שהם מתחילים בקרה. אם יש לך הרבה מופעי פונקציות שקוראים הרבה סודות, הפרויקט שלך עלול לחרוג מהקצבה הזו, ובשלב זה תחויב ב-$0.03 לכל 10,000 פעולות גישה.

למידע נוסף, ראה תמחור מנהל סודי .

תמיכה באמולטור

תצורת הסביבה עם dotenv נועדה לפעול יחד עם אמולטור ענן פונקציות מקומי.

בעת שימוש באמולטור Cloud Functions מקומי, אתה יכול לעקוף משתני סביבה עבור הפרויקט שלך על ידי הגדרת קובץ .env.local . התוכן של .env.local עדיפות על .env וקובץ ה- .env הספציפי לפרויקט.

לדוגמה, פרויקט יכול לכלול את שלושת הקבצים האלה המכילים ערכים מעט שונים לפיתוח ובדיקות מקומיות:

.env	.env.dev	.env.local
PLANET=כדור הארץ קהל=בני אדם	AUDIENCE=Dev Humans	קהל = בני אדם מקומיים

כאשר מופעל בהקשר המקומי, האמולטור טוען את משתני הסביבה כפי שמוצג:

  $ firebase emulators:start
  i  emulators: Starting emulators: functions
  # Starts emulator with following environment variables:
  #  PLANET=Earth
  #  AUDIENCE=Local Humans

סודות ואישורים באמולטור Cloud Functions

אמולטור Cloud Functions תומך בשימוש בסודות לאחסון וגישה למידע תצורה רגיש . כברירת מחדל, האמולטור ינסה לגשת לסודות הייצור שלך באמצעות אישורי ברירת המחדל של היישום . במצבים מסוימים כמו סביבות CI, האמולטור עלול להיכשל בגישה לערכים סודיים עקב הגבלות הרשאה.

בדומה לתמיכה באמולטור Cloud Functions עבור משתני סביבה, אתה יכול לעקוף ערכי סודות על ידי הגדרת קובץ .secret.local . זה מקל עליך לבדוק את הפונקציות שלך באופן מקומי, במיוחד אם אין לך גישה לערך הסודי.

מעבר מתצורת הסביבה

אם השתמשת בתצורת סביבה עם functions.config , תוכל להעביר את התצורה הקיימת שלך כמשתני סביבה (בפורמט dotenv ). ה-CLI של Firebase מספק פקודת ייצוא שמוציאה את התצורה של כל כינוי או פרויקט המופיעים בקובץ .firebaserc של הספרייה שלך (בדוגמה למטה, local , dev ו- prod ) כקובצי .env .

כדי להעביר, ייצא את תצורות הסביבה הקיימות שלך באמצעות הפקודה firebase functions:config:export :

firebase functions:config:export
i  Importing configs from projects: [project-0, project-1]
⚠  The following configs keys could not be exported as environment variables:

⚠  project-0 (dev):
    1foo.a => 1FOO\_A (Key 1FOO\_A must start with an uppercase ASCII letter or underscore, and then consist of uppercase ASCII letters, digits, and underscores.)

Enter a PREFIX to rename invalid environment variable keys: CONFIG\_
✔  Wrote functions/.env.prod
✔  Wrote functions/.env.dev
✔  Wrote functions/.env.local
✔  Wrote functions/.env

שים לב שבמקרים מסוימים תתבקש להזין קידומת כדי לשנות את השם של מפתחות משתני סביבה מיוצאים. הסיבה לכך היא שלא כל התצורות ניתנות לשינוי אוטומטי מכיוון שהן עשויות להיות לא חוקיות או עשויות להיות מפתח משתנה סביבה שמור .

אנו ממליצים שתבדוק בקפידה את התוכן של קבצי .env שנוצרו לפני שתפרוס את הפונקציות שלך או תבדוק את קבצי .env בבקרת המקור. אם ערכים כלשהם רגישים ואסור לדלוף, הסר אותם מקבצי .env שלך ואחסן אותם בצורה מאובטחת במקום זאת ב- Secret Manager .

תצטרך גם לעדכן את קוד הפונקציות שלך. כל הפונקציות המשתמשות functions.config יצטרכו כעת להשתמש process.env במקום זאת, כפי שמוצג בשדרוג לדור שני .

תצורת סביבה

לפני שפורסמה תמיכת משתני סביבה ב- firebase-functions v3.18.0 , שימוש functions.config() היה הגישה המומלצת לתצורת סביבה. גישה זו עדיין נתמכת, אך אנו ממליצים לכל הפרויקטים החדשים להשתמש במשתני סביבה במקום זאת, מכיוון שהם פשוטים יותר לשימוש ומשפרים את הניידות של הקוד שלך.

הגדר תצורת סביבה עם ה-CLI

כדי לאחסן נתוני סביבה, אתה יכול להשתמש בפקודה firebase functions:config:set ב- Firebase CLI . כל מפתח יכול להיות מרווח שמות באמצעות נקודות כדי לקבץ תצורה קשורה יחד. זכור שרק תווים קטנים מתקבלים במקשים ; אסור להשתמש באותיות רישיות.

לדוגמה, כדי לאחסן את מזהה הלקוח ומפתח ה-API עבור "שירות כלשהו", תוכל להפעיל:

firebase functions:config:set someservice.key="THE API KEY" someservice.id="THE CLIENT ID"

אחזר את תצורת הסביבה הנוכחית

כדי לבדוק מה מאוחסן כעת בתצורת הסביבה עבור הפרויקט שלך, אתה יכול להשתמש firebase functions:config:get . זה יוציא JSON משהו כזה:

{
  "someservice": {
    "key":"THE API KEY",
    "id":"THE CLIENT ID"
  }
}

פונקציונליות זו מבוססת על Google Cloud Runtime Configuration API .

השתמש functions.config כדי לגשת לתצורת הסביבה בפונקציה

תצורה מסויימת מסופקת אוטומטית תחת מרחב השמות השמור firebase . תצורת הסביבה זמינה בתוך פונקציית ההפעלה שלך באמצעות functions.config() . כדי להשתמש בתצורה שלמעלה, הקוד שלך עשוי להיראות כך:

const functions = require('firebase-functions');
const request = require('request-promise');

exports.userCreated = functions.database.ref('/users/{id}').onWrite(event => {
  let email = event.data.child('email').val();

  return request({
    url: 'https://someservice.com/api/some/call',
    headers: {
      'X-Client-ID': functions.config().someservice.id,
      'Authorization': `Bearer ${functions.config().someservice.key}`
    },
    body: {email: email}
  });
});

השתמש בתצורת סביבה כדי לאתחל מודול

חלק ממודולי ה-Node מוכנים ללא כל תצורה. מודולים אחרים זקוקים לתצורה נוספת כדי לאתחל כהלכה. אנו ממליצים לאחסן את התצורה הזו במשתני תצורת הסביבה במקום לקודד אותה. זה עוזר לך לשמור על הקוד שלך הרבה יותר נייד, מה שמאפשר לך לפתוח את היישום שלך בקוד קוד או לעבור בקלות בין גרסאות ייצור ל-Staging.

לדוגמה, כדי להשתמש במודול Slack Node SDK , תוכל לכתוב את זה:

const functions = require('firebase-functions');
const IncomingWebhook = require('@slack/client').IncomingWebhook;
const webhook = new IncomingWebhook(functions.config().slack.url);

לפני הפריסה, הגדר את משתנה התצורה של סביבת slack.url :

firebase functions:config:set slack.url=https://hooks.slack.com/services/XXX

פקודות סביבה נוספות

• firebase functions:config:unset key1 key2 מסיר את המפתחות שצוינו מהתצורה
• firebase functions:config:clone --from <fromProject> משבט סביבה של פרויקט אחר לפרוייקט הפעיל כעת.

משתני סביבה מאוכלסים אוטומטית

ישנם משתני סביבה המאוכלסים אוטומטית בזמן ריצה של הפונקציות ובפונקציות המחוות מקומית. אלה כוללים את אלה המאוכלסים על ידי Google Cloud , כמו גם משתנה סביבה ספציפי ל-Firebase:

process.env.FIREBASE_CONFIG : מספק את המידע הבא על תצורת פרויקט Firebase:

{
  databaseURL: 'https://databaseName.firebaseio.com',
  storageBucket: 'projectId.appspot.com',
  projectId: 'projectId'
}

תצורה זו מוחלת באופן אוטומטי כאשר אתה מאתחל את Firebase Admin SDK ללא ארגומנטים. אם אתה כותב פונקציות ב-JavaScript, אתחול כך:

const admin = require('firebase-admin');
admin.initializeApp();

אם אתה כותב פונקציות ב-TypeScript, אתחול כך:

import * as functions from 'firebase-functions';
import * as admin from 'firebase-admin';
import 'firebase-functions';
admin.initializeApp();

אם אתה צריך לאתחל את ה-Admin SDK עם תצורת ברירת המחדל של הפרויקט באמצעות אישורי חשבון שירות, אתה יכול לטעון את האישורים מקובץ ולהוסיף אותם ל- FIREBASE_CONFIG כך:

serviceAccount = require('./serviceAccount.json');

const adminConfig = JSON.parse(process.env.FIREBASE_CONFIG);
adminConfig.credential = admin.credential.cert(serviceAccount);
admin.initializeApp(adminConfig);