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

‫Firebase Remote Config תומך בהגדרה בצד השרת באמצעות Firebase Admin SDK ל-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 לאדמינים לשרת. חשוב לוודא שאתם משתמשים בגרסה נתמכת של Admin SDK לפלטפורמה שלכם:

  • ‫Node.js: Firebase Admin Node.js SDK גרסה 12.1.0 ואילך
  • ‫Python: Firebase Admin Python SDK גרסה 6.7.0 ואילך
  • ‫Java: Firebase Admin Java SDK גרסה 9.7.0 ואילך
  • ‫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-2.0-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"], "temperature": 0.7, "maxOutputTokens": 512, "topP": 0.1, "topK": 20}

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

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

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

    Node.js

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

    // 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() כדי לאחזר את התבנית מהקצה העורפי:

    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() כדי לאחזר את התבנית מהקצה העורפי:

    // 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-pro",
    generation_config: '{"stopSequences": [], "temperature": 0.7, "maxOutputTokens": 512, "topP": 0.1, "topK": 20}',
    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-pro",
    'generation_config': '{"stopSequences": [], "temperature": 0.7, "maxOutputTokens": 512, "topP": 0.1, "topK": 20}',
    '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-2.0-flash"

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

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 methods נתמכים:

    • ערך בוליאני: 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 methods נתמכים:

    • ערך בוליאני: 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 methods נתמכים:

    • ערך בוליאני: getBoolean
    • מחרוזת: getString
    • ‫Double: 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");

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

    המשך

    ‫getter methods נתמכים:

    • ערך בוליאני: 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. אם השרת שלכם פועל לאורך זמן, בניגוד לסביבה ללא שרתים, צריך לטעון מחדש את התבנית באופן תקופתי (למשל, באמצעות setInterval ב-Node.js או java.util.Timer ב-Java) כדי לוודא שאתם מאחזרים את התבנית העדכנית ביותר משרת Remote Config.

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

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

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

  1. במסוף Firebase, עוברים אל DevOps & Engagement (פיתוח אפליקציות ואינטראקציה עם משתמשים) > הגדרת תצורה מרחוק > הדף Parameters (פרמטרים).

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

  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 תומך במסגרות אינטרנט פופולריות.

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

מידע נוסף על תרחישי השימוש המומלצים ל-Cloud Run ול-Cloud Functions for Firebase זמין במאמר Cloud Functions for Firebase לעומת Cloud Run: מתי כדאי להשתמש באחד מהם.

השלבים הבאים