Remote Config in Serverumgebungen verwenden

Firebase Remote Config unterstützt die serverseitige Konfiguration mit den Firebase Admin SDKs für Node.js (Version 12.1.0 und höher), Python (Version 6.7.0 und höher), Java (Version 9.7.0 und höher) und Go (Version 4.17.0 und höher).

Mit dieser Funktion können Sie das Verhalten und die Konfiguration von serverseitigen Anwendungen mithilfe von Remote Config dynamisch verwalten. Dazu gehören serverlose Implementierungen wie Cloud Functions for Firebase und containerisierte Dienste auf Cloud Run.

Im Gegensatz zu Firebase-Client-SDKs, die eine clientspezifische Konfiguration abrufen, die aus der Remote Config-Vorlage abgeleitet wird, laden oder rufen serverseitige Remote Config -SDKs eine vollständige Remote Config-Vorlage aus Firebase herunter. Ihr Server kann die Vorlage dann mit jeder eingehenden Anfrage auswerten und mit seiner eigenen Logik eine benutzerdefinierte Antwort mit sehr geringer Latenz bereitstellen. Mit Bedingungen können Sie Antworten basierend auf zufälligen Prozentsätzen und Clientattributen, die in benutzerdefinierten Signalen definiert sind, steuern und anpassen.

Mit serverseitigem Remote Config haben Sie folgende Möglichkeiten:

  • Konfigurationsparameter für Anwendungen definieren, die auf Ihrem Server ausgeführt werden oder über Ihren Server aufgerufen werden. So können Sie beispielsweise KI-Modellparameter und Prompts sowie andere Integrationen remote konfigurieren und Ihre API-Schlüssel schützen.
  • Parameter dynamisch an Änderungen in Ihrer Umgebung oder an andere Anwendungsänderungen anpassen, z. B. LLM-Parameter und Modellendpunkte aktualisieren.
  • Kosten lassen sich senken, indem Sie die APIs, die Ihr Server aufruft, per Fernzugriff aktualisieren.
  • Benutzerdefinierte Konfigurationen für Clients, die auf Ihren Server zugreifen, werden spontan generiert.
  • Erfassen Sie, welche Clients einen Parameterwert erhalten haben, und verwenden Sie diese Informationen in Cloud Functions for Firebase als Teil eines Berechtigungsüberprüfungssystems.

Sie können serverseitiges Remote Config in Cloud Run, Cloud Functions for Firebase oder selbst gehosteten Serverumgebungen bereitstellen.

Hinweis

Folgen Sie der Anleitung unter Firebase Admin SDK auf Ihrem Server hinzufügen, um ein Firebase-Projekt zu erstellen, ein Dienstkonto einzurichten und das Firebase Admin SDK auf Ihrem Server hinzuzufügen. Achten Sie darauf, dass Sie eine unterstützte Version des Admin SDK für Ihre Plattform verwenden:

  • Node.js: Firebase Admin Node.js SDK v12.1.0 oder höher
  • Python: Firebase Admin Python SDK v6.7.0 oder höher
  • Java: Firebase Admin Java SDK v9.7.0 oder höher
  • Go: Firebase Admin Go SDK v4.17.0 oder höher

Schritt 1: Firebase Admin SDK initialisieren und API-Anfragen autorisieren

Wenn Sie das Admin SDK ohne Parameter initialisieren, verwendet das SDK Standardanmeldedaten für Anwendungen und liest Optionen aus der Umgebungsvariable GOOGLE_APPLICATION_CREDENTIALS. Initialisieren Sie das SDK und konfigurieren Sie Remote Config für Ihre Plattform:

Node.js

Importieren Sie initializeApp und getRemoteConfig und initialisieren Sie dann Ihre Firebase-Anwendungsinstanz:

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

// Initialize Firebase
const firebaseApp = initializeApp();

Python

Importieren Sie firebase_admin (zusammen mit asyncio und json für das asynchrone Laden von Vorlagen und das JSON-Parsing) und initialisieren Sie dann die Anwendung:

import firebase_admin
import asyncio
import json

firebase_admin.initialize_app()

Java

Initialisieren Sie das Firebase Admin SDK mit FirebaseOptions und den Anmeldedaten Ihres Dienstkontos:

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

Go

Initialisieren Sie die Firebase-Anwendung und erstellen Sie eine RemoteConfig-Clientinstanz:

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

Schritt 2: Standardparameterwerte für Ihre Serveranwendung ermitteln

Ermitteln Sie die Variablen in Ihrer App, die Sie dynamisch mit Remote Config aktualisieren möchten. Überlegen Sie dann, welche Variablen standardmäßig in Ihrer Anwendung festgelegt werden müssen und welche Standardwerte sie haben sollten. So wird sichergestellt, dass Ihre Anwendung auch dann erfolgreich ausgeführt wird, wenn die Verbindung zum Remote Config-Backend-Server unterbrochen wird.

Wenn Sie beispielsweise eine Serveranwendung schreiben, die eine generative KI-Funktion verwaltet, können Sie einen Standardmodellnamen, eine Prompt-Präambel und eine generative KI-Konfiguration wie die folgende festlegen:

Parametername Beschreibung Typ Standardwert
model_name Name der Modell-API String gemini-2.0-flash
preamble_prompt Prompt, der der Anfrage des Nutzers vorangestellt werden soll String 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 Parameter, die an das Modell gesendet werden sollen JSON {"stopSequences": ["I hope this helps"], "temperature": 0.7, "maxOutputTokens": 512, "topP": 0.1, "topK": 20}

Schritt 3: Serveranwendung konfigurieren

Nachdem Sie die Parameter festgelegt haben, die Sie mit Remote Config verwenden möchten, konfigurieren Sie Ihre Anwendung so, dass Standardwerte festgelegt, die serverspezifische Remote Config-Vorlage abgerufen und ihre Werte ausgewertet werden.

  1. Greifen Sie auf die Remote Config-Servervorlage zu und laden Sie sie.

    Node.js

    Initialisieren Sie die Servervorlage mit initServerTemplate() und rufen Sie load() auf, um die Vorlage aus dem Backend abzurufen:

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

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

    Wenn Sie Node.js in Cloud Functions for Firebase verwenden, können Sie die asynchrone Funktion getServerTemplate() verwenden, um die Vorlage in einem einzigen Schritt zu initialisieren und zu laden:

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

    Python

    Initialisieren Sie die Servervorlage mit init_server_template() und rufen Sie load() auf, um die Vorlage aus dem Backend abzurufen:

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

    Wenn Sie Python mit Cloud Functions for Firebase verwenden, können Sie die asynchrone Funktion get_server_template() verwenden, um die Vorlage in einem einzigen Schritt zu initialisieren und zu laden:

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

    Java

    Initialisieren Sie den serverseitigen Remote Config-Client mit FirebaseRemoteConfig.getInstance():

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

    Wenn Sie Java mit Cloud Functions for Firebase verwenden, können Sie die Vorlage alternativ in einem einzigen Schritt mit getServerTemplate() initialisieren und laden:

    ServerTemplate template = rc.getServerTemplate();

    Go

    Initialisieren Sie die Servervorlage mit InitServerTemplate() und rufen Sie Load() auf, um die Vorlage aus dem Backend abzurufen:

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

    Eine weitere Möglichkeit, die Vorlage zu initialisieren, ist die Verwendung der Funktion GetServerTemplate, um die erforderliche Servervorlage abzurufen. Sie können diese Vorlage in ein JSON-Format konvertieren, das lokal gespeichert werden kann, und sie dann mit der Funktion InitServerTemplate initialisieren.

  2. Damit Ihre Anwendung auch dann erfolgreich ausgeführt wird, wenn die Verbindung zum Remote Config-Backend-Server unterbrochen wird, fügen Sie in Ihrer App Standardwerte für jeden Parameter hinzu.

    Node.js

    Fügen Sie in der Vorlagenfunktion initServerTemplate oder getServerTemplate ein defaultConfig-Objekt hinzu:

    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

    Fügen Sie in der Vorlagenfunktion init_server_template oder get_server_template ein default_config-Wörterbuch hinzu:

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

    Eine weitere Möglichkeit zum Initialisieren einer Vorlage ist die Verwendung der Funktion get_server_template zum Abrufen der erforderlichen Servervorlage. Sie können diese Vorlage mit der Funktion template.to_json in ein JSON-Format konvertieren. Diese JSON-Vorlage kann lokal gespeichert und anschließend mit der Funktion init_server_template initialisiert werden.

    Java

    Fügen Sie mit KeysAndValues ein defaultConfig-Objekt in Ihre getServerTemplate-Funktion ein:

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

    Alternativ können Sie beim Initialisieren von Remote Config eine standardmäßige im Cache gespeicherte Vorlage übergeben, die auch dann verwendet werden kann, wenn die Verbindung zum Remote Config-Server unterbrochen wird:

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

    Go

    Fügen Sie in der Vorlagenfunktion InitServerTemplate oder GetServerTemplate eine defaultConfig-Karte ein:

    // 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. Nachdem die Vorlage geladen wurde, werten Sie sie aus, um Parameter und Werte aus der Vorlage zu importieren:

    Node.js

    So verwenden Sie template.evaluate():

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

    Python

    So verwenden Sie template.evaluate():

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

    Java

    So verwenden Sie template.evaluate():

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

    Go

    Verwenden Sie template.Evaluate() mit einem leeren Auswertungskontext, wenn keine Bedingungen angewendet werden:

    // 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. Wenn Sie in Ihrer Remote Config-Vorlage optional Bedingungen festlegen, definieren und geben Sie die gewünschten Kontextwerte an:

    • Wenn Sie Prozentbedingungen verwenden, fügen Sie der Vorlagenbewertungsfunktion die Randomisierungs-ID (randomizationId, randomization_id oder randomizationID) hinzu, die Sie zum Auswerten der Bedingungen verwenden möchten.
    • Wenn Sie benutzerdefinierte Signale verwenden, definieren Sie die Attribute und ihre Werte. Benutzerdefinierte Signale sind mit dem Firebase Admin Node.js SDK ab Version 12.5.0, dem Python SDK ab Version 6.7.0, dem Java SDK ab Version 9.7.0 und dem Go SDK ab Version 4.17.0 verfügbar.

    Sie können beispielsweise eine Firebase-Installations-ID oder eine Nutzer-ID als Randomisierungs-ID festlegen, damit jeder Nutzer, der Ihren Server kontaktiert, der richtigen randomisierten Gruppe hinzugefügt wird. version kann als benutzerdefiniertes Signal verwendet werden, um bestimmte Clientversionen anzusprechen, und platform als benutzerdefiniertes Signal, um Clientplattformen anzusprechen.

    Weitere Informationen zu Bedingungen finden Sie unter Bedingungsregeltypen.

    Node.js

    Übergeben Sie ein Bewertungskontextobjekt mit randomizationId und allen benutzerdefinierten Signalen an 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

    Übergeben Sie ein Dictionary mit randomization_id und allen benutzerdefinierten Signalen an 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

    Erstellen Sie einen KeysAndValues-Kontext mit randomizationId und allen benutzerdefinierten Signalen und übergeben Sie ihn an 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);

    Go

    Übergeben Sie eine Karte mit dem Bewertungskontext, die randomizationID und alle benutzerdefinierten Signale enthält, an 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. Als Nächstes extrahieren Sie die benötigten Parameterwerte aus dem ausgewerteten Konfigurationsobjekt. Verwenden Sie Getter-Methoden, um Werte aus Remote Config in das erwartete Format umzuwandeln.

    Wenn Sie beispielsweise Agent Platform auf Ihrem Server implementieren und das Modell und die Modellparameter ändern möchten, können Sie Parameter für model_name und generation_config konfigurieren. Hier sind die unterstützten Getter-Methoden und ein Beispiel für den Zugriff auf Remote Config-Werte für jede Plattform:

    Node.js

    Unterstützte Getter-Methoden:

    • Boolesch: getBoolean
    • Objekt: getValue
    • Nummer: getNumber
    • String: 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

    Unterstützte Getter-Methoden:

    • Boolesch: get_bool
    • Ganzzahl: get_int
    • Gleitkommazahl: get_float
    • String: get_string
    • Quelle des Werts: 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

    Unterstützte Getter-Methoden:

    • Boolesch: getBoolean
    • String: getString
    • Doppelt: getDouble
    • Lang: getLong
    • Quelle des Werts: 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");

    Die Methode getValueSource gibt einen ValueSource zurück, der angibt, ob die Wertquelle des Parameters STATIC, REMOTE oder DEFAULT ist.

    Go

    Unterstützte Getter-Methoden:

    • Boolesch: GetBoolean
    • Ganzzahl: GetInt
    • Gleitkommazahl: GetFloat
    • String: GetString
    • Quelle des Werts: 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. Wenn Ihr Server lange ausgeführt wird (im Gegensatz zu einer serverlosen Umgebung), laden Sie die Vorlage regelmäßig neu (z. B. mit setInterval in Node.js oder java.util.Timer in Java), um sicherzugehen, dass Sie die aktuelle Vorlage vom Remote Config-Server abrufen.

Schritt 4: Serverspezifische Parameterwerte in Remote Config festlegen

Als Nächstes erstellen Sie eine Remote Config-Servervorlage und konfigurieren Parameter und Werte, die in Ihrer App verwendet werden sollen.

So erstellen Sie eine serverspezifische Remote Config-Vorlage:

  1. Rufen Sie in der Firebase Console die Seite DevOps & Engagement > Remote Config > Parameter auf.

  2. Wählen Sie oben auf der Seite in der Auswahl Client/Server die Option Server aus.

  3. Definieren Sie Remote Config-Parameter mit denselben Namen und Datentypen wie die Parameter, die Sie in Ihrer App definiert haben, und geben Sie Werte an. Diese Werte überschreiben die Standardkonfiguration (defaultConfig oder default_config), die Sie unter Serveranwendung konfigurieren festgelegt haben, wenn Sie die Vorlage abrufen und auswerten und diese Werte Ihren Variablen zuweisen.

  4. Optional können Sie Bedingungen festlegen, um Werte dauerhaft auf eine zufällige Stichprobe von Instanzen oder benutzerdefinierten Signalen anzuwenden, die Sie definieren. Weitere Informationen zu Bedingungen finden Sie unter Bedingungsregeltypen.

  5. Wenn Sie alle Parameter hinzugefügt haben, klicken Sie auf Änderungen veröffentlichen.

  6. Prüfen Sie die Änderungen und klicken Sie noch einmal auf Änderungen veröffentlichen.

Schritt 5: Mit Cloud Functions for Firebase oder Cloud Run bereitstellen

Wenn Ihre Serveranwendung einfach und ereignisgesteuert ist, sollten Sie Ihren Code mit Cloud Functions for Firebase bereitstellen. Angenommen, Sie haben eine App, die auf einer generativen KI-API (z. B. Google AI oder Agent Platform) basierende Dialoge enthält. In diesem Fall können Sie die Logik für die Bereitstellung des großen Sprachmodells in einer Funktion hosten, die Ihre App bei Bedarf aufruft.

Wenn Sie eine vom Server gerenderte Webanwendung erstellen, unterstützt App Hosting gängige Web-Frameworks.

Andernfalls können Sie Cloud Run in Betracht ziehen. Wenn Sie Ihre Server-App mit Cloud Run bereitstellen möchten, folgen Sie der Kurzanleitung für Ihre Sprache:

Weitere Informationen zu den besten Anwendungsfällen für Cloud Run und Cloud Functions for Firebase finden Sie unter Cloud Functions for Firebase vs. Cloud Run: when to use one over the other.

Nächste Schritte