שימוש ב'הגדרת תצורה מרחוק' בסביבות שרת

‫Firebase Remote Config תומך בהגדרה בצד השרת באמצעות ה-SDK של Firebase לאדמינים ב-Node.js (גרסה 12.1.0 ואילך), ב-Python (גרסה 6.7.0 ואילך), ב-Java (גרסה 9.7.0 ואילך) וב-Go (גרסה 4.17.0 ואילך).

היכולת הזו מאפשרת לכם לנהל באופן דינמי את ההתנהגות וההגדרות של אפליקציות בצד השרת באמצעות Remote Config. זה כולל הטמעות ללא שרת (serverless) כמו Cloud Functions for Firebase ושירותים בקונטיינרים ב-Cloud Run.

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

בעזרת Remote Config בצד השרת, אתם יכולים:

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

אתם יכולים לפרוס את Remote Config בצד השרת ב-Cloud Run, ב-Cloud Functions for Firebase או בסביבות שרת באירוח עצמי.

לפני שמתחילים

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

  • ‫Node.js: ‏Firebase Admin Node.js SDK בגרסה 12.1.0 ואילך
  • ‫Python: ‏Firebase Admin Python SDK בגרסה 6.7.0 ואילך
  • ‫Java: גרסה 9.7.0 ומעלה של Firebase Admin Java SDK
  • ‫Go: ‏Firebase Admin Go SDK בגרסה 4.17.0 ואילך

שלב 1: הפעלת ה-SDK של Firebase לאדמינים ואישור בקשות API

כשמאתחלים את SDK לאדמינים בלי פרמטרים, ה-SDK משתמש בApplication Default Credentials וקורא אפשרויות ממשתנה הסביבה GOOGLE_APPLICATION_CREDENTIALS. מפעילים את ה-SDK ומגדירים את Remote Config לפלטפורמה:

Node.js

מייבאים את initializeApp ואת getRemoteConfig, ואז מפעילים את המכונה של אפליקציית Firebase:

import { initializeApp } from "firebase-admin/app";
import { getRemoteConfig } from "firebase-admin/remote-config";

// Initialize Firebase
const firebaseApp = initializeApp();

Python

מייבאים את firebase_admin (יחד עם asyncio ו-json לטעינת תבניות אסינכרונית וניתוח JSON), ואז מאתחלים את האפליקציה:

import firebase_admin
import asyncio
import json

firebase_admin.initialize_app()

Java

מפעילים את ה-SDK של Firebase לאדמינים באמצעות FirebaseOptions ופרטי הכניסה לחשבון השירות:

// Initialize the Firebase Admin SDK
FirebaseOptions options = new FirebaseOptions.Builder()
    .setCredentials(GoogleCredentials.fromStream(serviceAccount))
    .build();
FirebaseApp.initializeApp(options);

המשך

מפעילים את אפליקציית Firebase ויוצרים מכונה של לקוח RemoteConfig:

ctx := context.Background()

// Initialize Firebase
app, err := firebase.NewApp(ctx, nil)
if err != nil {
    log.Fatalln("Error initializing app:", err)
}

remoteConfig, err := app.RemoteConfig(ctx)
if err != nil {
    log.Fatalln("Error initializing remote config client:", err)
}

שלב 2: מזהים את ערכי ברירת המחדל של הפרמטרים באפליקציית השרת

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

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

שם הפרמטר תיאור סוג ערך ברירת המחדל
model_name שם ה-API של המודל מחרוזת gemini-3.8-flash
preamble_prompt הנחיה שתוצג לפני השאילתה של המשתמש מחרוזת I'm a developer who wants to learn about Firebase and you are a helpful assistant who knows everything there is to know about Firebase!
generation_config פרמטרים לשליחה למודל JSON {"stopSequences": ["I hope this helps"], "maxOutputTokens": 512}

שלב 3: מגדירים את אפליקציית השרת

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

  1. ניגשים לתבנית השרת של Remote Config וטוענים אותה.

    Node.js

    מאתחלים את תבנית השרת באמצעות initServerTemplate() וקוראים ל-load() כדי לאחזר את התבנית מה-backend:

    // Initialize server-side Remote Config
const rc = getRemoteConfig(firebaseApp);
const template = rc.initServerTemplate();

// Load Remote Config
await template.load();

    אם אתם משתמשים ב-Node.js ב-Cloud Functions for Firebase, אתם יכולים להשתמש בפונקציה האסינכרונית getServerTemplate() כדי לאתחל ולטעון את התבנית בשלב אחד:

    // Initialize server-side Remote Config
const rc = getRemoteConfig(firebaseApp);
const template = await rc.getServerTemplate();

    Python

    מאתחלים את תבנית השרת באמצעות init_server_template() וקוראים ל-load() כדי לאחזר את התבנית מה-backend:

    from firebase_admin import remote_config

# Initialize server-side Remote Config
template = remote_config.init_server_template()

# Load the template from the backend
asyncio.run(template.load())

    לחלופין, אם אתם משתמשים ב-Python עם Cloud Functions for Firebase, אתם יכולים להשתמש בפונקציה האסינכרונית get_server_template() כדי לאתחל ולטעון את התבנית בשלב אחד:

    # Initialize server-side Remote Config
template = await remote_config.get_server_template()

    Java

    מפעילים את הלקוח Remote Config בצד השרת באמצעות FirebaseRemoteConfig.getInstance():

    // Initialize server-side Remote Config client
FirebaseRemoteConfig rc = FirebaseRemoteConfig.getInstance();

    לחלופין, אם אתם משתמשים ב-Java עם Cloud Functions for Firebase, אתם יכולים להשתמש ב-getServerTemplate() כדי לאתחל ולטעון את התבנית בשלב אחד:

    ServerTemplate template = rc.getServerTemplate();

    המשך

    מאתחלים את תבנית השרת באמצעות InitServerTemplate() וקוראים ל-Load() כדי לאחזר את התבנית מה-backend:

    // Initialize server-side Remote Config
defaultConfig := make(map[string]any)
templateDataJSON := ""
template, err := remoteConfig.InitServerTemplate(defaultConfig, templateDataJSON)
if err != nil {
    log.Fatalln("Error initializing server template:", err)
}

// Load Remote Config
err = template.Load(ctx)
if err != nil {
    log.Fatalln("Error fetching server template:", err)
}

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

  2. כדי לוודא שהאפליקציה תפעל בהצלחה גם אם החיבור שלה לשרת בק-אנד של Remote Config יופסק, צריך להוסיף ערכי ברירת מחדל לכל פרמטר באפליקציה.

    Node.js

    מוסיפים אובייקט defaultConfig בתוך פונקציית התבנית initServerTemplate או getServerTemplate:

    const template = rc.initServerTemplate({
  defaultConfig: {
    model_name: "gemini-3.8-flash",
    generation_config: '{"stopSequences": [], "maxOutputTokens": 512}',
    preamble_prompt: "I'm a developer who wants to learn about Firebase and you are a helpful assistant who knows everything there is to know about Firebase!"
  },
});

// Load Remote Config
await template.load();

    Python

    מוסיפים מילון default_config בתוך פונקציית התבנית init_server_template או get_server_template:

    template = remote_config.init_server_template({
  'default_config': {
    'model_name': "gemini-3.8-flash",
    'generation_config': '{"stopSequences": [], "maxOutputTokens": 512}',
    'preamble_prompt': "I'm a developer who wants to learn about Firebase and you are a helpful assistant who knows everything there is to know about Firebase!"
  },
})

# Load Remote Config
asyncio.run(template.load())

    דרך נוספת להפעיל תבנית היא להשתמש בפונקציה get_server_template כדי לאחזר את תבנית השרת הנדרשת. אפשר להמיר את התבנית הזו לפורמט JSON באמצעות הפונקציה template.to_json. אפשר לשמור את תבנית ה-JSON הזו באופן מקומי, ואז להפעיל אותה באמצעות הפונקציה init_server_template.

    Java

    מוסיפים אובייקט defaultConfig באמצעות KeysAndValues בתוך הפונקציה getServerTemplate:

    // Initialize default config using KeysAndValues
KeysAndValues defaultConfig = new KeysAndValues.Builder()
                                  .put("rc_param_1", "default value 1")
                                  .put("rc_param_2", "default value 2")
                                  .build();
ServerTemplate template = rc.getServerTemplate(defaultConfig);

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

    String templateDataJSON = "{}"; // add your default template as JSON
ServerTemplate template = rc.serverTemplateBuilder()
                    .defaultConfig(defaultConfig)
                    .cachedTemplate(templateDataJSON)
                    .build();

    המשך

    מוסיפים מפה של defaultConfig בתוך פונקציית התבנית InitServerTemplate או GetServerTemplate:

    // Initialize server-side Remote Config
defaultConfig := make(map[string]any)
defaultConfig["model_name"] = "gemini-3.8-flash"

// Assume the type generationConfig has been defined
defaultConfig["generation_config"] = &generationConfig{
    StopSequences:   []string{"I hope this helps"},
    MaxOutputTokens: 512,
}

defaultConfig["preamble_prompt"] = "I'm a developer who wants to learn about Firebase and you are a helpful assistant who knows everything there is to know about Firebase!"

templateDataJSON := ""
template, err := remoteConfig.InitServerTemplate(defaultConfig, templateDataJSON)
if err != nil {
    log.Fatalln("Error initializing server template:", err)
}

// Load Remote Config
err = template.Load(ctx)
if err != nil {
    log.Fatalln("Error fetching server template:", err)
}

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

    Node.js

    שימוש ב-template.evaluate():

    // Add template parameters to config
const config = template.evaluate();

    Python

    שימוש ב-template.evaluate():

    # Add template parameters to config
config = template.evaluate()

    Java

    שימוש ב-template.evaluate():

    // Add template parameters to config
ServerConfig config = template.evaluate();

    המשך

    כדי להשתמש ב-template.Evaluate() עם הקשר הערכה ריק כשלא מחילים תנאים:

    // An empty evaluation context means no conditions are applied.
evaluationContext := make(map[string]any)
config, err := template.Evaluate(evaluationContext)
if err != nil {
    log.Fatalln("Error evaluating template:", err)
}

  4. אם הגדרתם תנאים בתבנית Remote Config, אתם יכולים להגדיר ולספק את ערכי ההקשר הרצויים:

    • אם משתמשים בתנאי אחוזים, מוסיפים את מזהה האקראיות (randomizationId,‏ randomization_id או randomizationID) שרוצים להשתמש בו כדי להעריך את התנאים בפונקציית ההערכה של התבנית.
    • אם משתמשים באותות בהתאמה אישית, מגדירים את המאפיינים והערכים שלהם. אותות בהתאמה אישית זמינים ב-Firebase Admin Node.js SDK בגרסה 12.5.0 ואילך, ב-Python SDK בגרסה 6.7.0 ואילך, ב-Java SDK בגרסה 9.7.0 ואילך וב-Go SDK בגרסה 4.17.0 ואילך.

    לדוגמה, אפשר להגדיר מזהה התקנה של Firebase או מזהה משתמש בתור מזהה אקראי, כדי לוודא שכל משתמש שיוצר קשר עם השרת יתווסף לקבוצה האקראית המתאימה, version בתור אות מותאם אישית לטירגוט גרסאות ספציפיות של לקוחות, ו-platform בתור אות מותאם אישית לטירגוט פלטפורמות של לקוחות.

    בסוגי כללים של תנאים תוכלו לקרוא בהרחבה על תנאים.

    Node.js

    מעבירים אובייקט של הקשר הערכה שמכיל את randomizationId ואותות בהתאמה אישית אל template.evaluate():

    // Add template parameters to `config`. Evaluates the
// template and returns the parameter value assigned to
// the group assigned to the {randomizationId} and version.
const config = template.evaluate({
  randomizationId: "2ac93c28-c459-4760-963d-a3974ec26c04",
  version: "1.0",
  platform: "Android"
});

    Python

    מעבירים מילון שמכיל את randomization_id ואותות בהתאמה אישית אל template.evaluate():

    # Add template parameters to `config`. Evaluates the
# template and returns the parameter value assigned to
# the group assigned to the {randomization_id} and version.
config = template.evaluate({
  'randomization_id': "2ac93c28-c459-4760-963d-a3974ec26c04",
  'version': "1.0",
  'platform': "Android"
})

    Java

    יוצרים הקשר של KeysAndValues שמכיל את randomizationId ואת כל האותות בהתאמה אישית, ומעבירים אותו אל template.evaluate():

    // Add custom signals and randomizationId
KeysAndValues context = new KeysAndValues.Builder()
                                .put("custom_signal_key", "99")
                                .put("randomizationId", "2ac93c28")
                                .build();

// Evaluate the template with signals
ServerConfig config = template.evaluate(context);

    המשך

    מעבירים מפת הקשר של הערכה שמכילה את randomizationID ואותות בהתאמה אישית אל template.Evaluate():

    // Add template parameters to `config`. Evaluates the
// template and returns the parameter value assigned to
// the group assigned to the {randomizationID}, version, and platform.
evaluationContext := make(map[string]any)
evaluationContext["randomizationID"] = "2ac93c28-c459-4760-963d-a3974ec26c04"
evaluationContext["version"] = "1.0"
evaluationContext["platform"] = "Android"

config, err := template.Evaluate(evaluationContext)
if err != nil {
    log.Fatalln("Error evaluating template:", err)
}

  5. בשלב הבא, מחלצים את ערכי הפרמטרים שצריך מאובייקט ההגדרות שהוערך. משתמשים בשיטות getter כדי להמיר ערכים מ-Remote Config לפורמט הצפוי.

    לדוגמה, אם אתם מטמיעים את Agent Platform בשרת ורוצים לשנות את המודל ואת הפרמטרים שלו, אתם יכולים להגדיר פרמטרים ל-model_name ול-generation_config. אלה שיטות ה-getter הנתמכות ודוגמה לאופן הגישה לערכי Remote Config בכל פלטפורמה:

    Node.js

    שיטות getter נתמכות:

    • ערך בוליאני: getBoolean
    • אובייקט: getValue
    • מספר: getNumber
    • מחרוזת: getString

    // Replace defaults with values from Remote Config.
const generationConfig =
  JSON.parse(
    config.getString('generation_config'));

const is_ai_enabled = config.getBoolean('is_ai_enabled');

const model = config.getString('model_name');

// Generates a prompt comprised of the Remote Config
// parameter and prepends it to the user prompt
const prompt = `${config.getString('preamble_prompt')} ${req.query.prompt}`;

    Python

    שיטות getter נתמכות:

    • ערך בוליאני: get_bool
    • מספר שלם: get_int
    • חופש תנועה: get_float
    • מחרוזת: get_string
    • מקור הערך: get_value_source

    # Replace defaults with values from Remote Config.
generation_config = json.loads(config.get_string('generation_config'))
is_ai_enabled = config.get_bool('is_ai_enabled')
model = config.get_string('model_name')

# Generates a prompt comprised of the Remote Config
# parameter and prepends it to the user prompt.
prompt = f"{config.get_string('preamble_prompt')}{req.args.get('prompt')}"

    Java

    שיטות getter נתמכות:

    • ערך בוליאני: getBoolean
    • מחרוזת: getString
    • כפול: getDouble
    • תאריך בפורמט ארוך: getLong
    • מקור הערך: getValueSource

    // Get the model name
String modelName = config.getString("model_name");
// Get the origin of value assigned to param
ValueSource modelNameSource = config.getValueSource("model_name");

    ה-method getValueSource מחזירה ValueSource שמציין אם מקור הערך של הפרמטר הוא STATIC, REMOTE או DEFAULT.

    המשך

    שיטות getter נתמכות:

    • ערך בוליאני: GetBoolean
    • מספר שלם: GetInt
    • חופש תנועה: GetFloat
    • מחרוזת: GetString
    • מקור הערך: GetValueSource

    // Replace defaults with values from Remote Config.

// Assume the type generationConfig has been defined
var genConfig generationConfig
err = json.Unmarshal([]byte(config.GetString("generation_config")), &genConfig)
if err != nil {
    log.Fatalln("Error unmarshaling generation config:", err)
}
model := config.GetString("model_name")

// Parameter created on the console
isAIEnabled := config.GetBoolean("is_ai_enabled")

// Generates a prompt comprised of the Remote Config
// parameter and prepends it to the user prompt (assume it is extracted from the request body)
userPrompt := "What is Remote Config?"
prompt := fmt.Sprintf("%s %s", config.GetString("preamble_prompt"), userPrompt)

  6. אם השרת שלכם פועל לאורך זמן, בניגוד לסביבה בלי שרת (serverless), כדאי לטעון מחדש את התבנית מדי פעם (לדוגמה, באמצעות setInterval ב-Node.js או java.util.Timer ב-Java) כדי לוודא שאתם מאחזרים את התבנית העדכנית ביותר משרת Remote Config.

שלב 4: מגדירים ערכי פרמטרים ספציפיים לשרת ב-Remote Config

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

כך יוצרים תבנית Remote Config ספציפית לשרת:

  1. במסוף Firebase, נכנסים לדף DevOps & Engagement ‏> הגדרת תצורה מרחוק ‏> Parameters.

  2. בבורר Client/Server שבחלק העליון של הדף, בוחרים באפשרות Server.

  3. מגדירים Remote Config פרמטרים עם אותם שמות וסוגי נתונים כמו הפרמטרים שהגדרתם באפליקציה, ומספקים ערכים. הערכים האלה יחליפו את הגדרת ברירת המחדל (defaultConfig או default_config) שקבעתם בהגדרת אפליקציית השרת כשאתם מאחזרים ומעריכים את התבנית ומקצים את הערכים האלה למשתנים.

  4. אפשר גם להגדיר תנאים כדי להחיל ערכים באופן קבוע על מדגם אקראי של מופעים או אותות בהתאמה אישית שאתם מגדירים. בסוגי כללי התנאים תוכלו לקרוא בהרחבה על תנאים.

  5. כשמסיימים להוסיף פרמטרים, לוחצים על פרסום השינויים.

  6. בודקים את השינויים ולוחצים שוב על פרסום השינויים.

שלב 5: פריסה באמצעות Cloud Functions for Firebase או Cloud Run

אם אפליקציית השרת שלכם היא קלת משקל ומבוססת-אירועים, כדאי לפרוס את הקוד באמצעות Cloud Functions for Firebase. לדוגמה, נניח שיש לכם אפליקציה שכוללת דיאלוג בין דמויות שמופעל על ידי API של AI גנרטיבי (לדוגמה, Google AI או Agent Platform). במקרה כזה, אתם יכולים לארח את הלוגיקה של הצגת ה-LLM בפונקציה שהאפליקציה קוראת לה על פי דרישה.

אם אתם מפתחים אפליקציית אינטרנט שעוברת רינדור בצד השרת, ב-App Hosting יש תמיכה ב-frameworks פופולריים לאינטרנט.

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

השלבים הבאים