Utiliser Remote Config dans des environnements de serveur

Firebase Remote Config est compatible avec la configuration côté serveur à l'aide des SDK Admin Firebase pour Node.js (v12.1.0+), Python (v6.7.0+), Java (v9.7.0+) et Go (v4.17.0+).

Cette fonctionnalité vous permet de gérer de manière dynamique le comportement et la configuration des applications côté serveur à l'aide de Remote Config. Cela inclut les implémentations sans serveur telles que Cloud Functions for Firebase et les services conteneurisés sur Cloud Run.

Contrairement aux SDK client Firebase, qui récupèrent une configuration spécifique au client dérivée du modèle Remote Config, le SDK Remote Config côté serveur télécharge ou récupère un modèle Remote Config complet depuis Firebase. Votre serveur peut ensuite évaluer le modèle avec chaque requête entrante et utiliser sa propre logique pour fournir une réponse personnalisée avec une latence très faible. Vous pouvez utiliser des conditions pour contrôler et personnaliser les réponses en fonction de pourcentages aléatoires et d'attributs client définis dans les signaux personnalisés.

Avec Remote Config côté serveur, vous pouvez :

  • Définissez des paramètres de configuration pour les applications exécutées sur votre serveur ou accessibles via celui-ci. Cela permet des cas d'utilisation tels que la configuration à distance des paramètres et des invites de modèles d'IA, ainsi que d'autres intégrations, afin de garantir la sécurité de vos clés API.
  • Ajustez dynamiquement les paramètres en réponse aux modifications de votre environnement ou d'autres modifications d'application, comme la mise à jour des paramètres LLM et des points de terminaison du modèle.
  • Contrôlez les coûts en mettant à jour à distance les API appelées par votre serveur.
  • Générez des configurations personnalisées à la volée pour les clients qui accèdent à votre serveur.
  • Enregistrez les clients qui ont reçu une valeur de paramètre et utilisez-la dans Cloud Functions for Firebase dans le cadre d'un système de validation des droits d'accès.

Vous pouvez déployer Remote Config côté serveur sur des environnements Cloud Run, Cloud Functions for Firebase ou de serveur auto-hébergé.

Avant de commencer

Suivez les instructions de la section Ajouter le SDK Admin Firebase à votre serveur pour créer un projet Firebase, configurer un compte de service et ajouter le SDK Admin Firebase à votre serveur. Assurez-vous d'utiliser une version compatible du SDK Admin pour votre plate-forme :

  • Node.js : SDK Admin Firebase pour Node.js v12.1.0 ou version ultérieure
  • Python : SDK Admin Firebase pour Python v6.7.0 ou version ultérieure
  • Java : SDK Admin Firebase pour Java v9.7.0 ou version ultérieure
  • Go : SDK Admin Firebase pour Go v4.17.0 ou version ultérieure

Étape 1 : Initialiser le SDK Admin Firebase et autoriser les requêtes API

Lorsque vous initialisez le SDK Admin sans aucun paramètre, il utilise les identifiants par défaut de l'application Google et lit les options à partir de la variable d'environnement GOOGLE_APPLICATION_CREDENTIALS. Initialisez le SDK et configurez Remote Config pour votre plate-forme :

Node.js

Importez initializeApp et getRemoteConfig, puis initialisez votre instance d'application Firebase :

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

// Initialize Firebase
const firebaseApp = initializeApp();

Python

Importez firebase_admin (ainsi que asyncio et json pour l'analyse JSON et le chargement asynchrone des modèles), puis initialisez l'application :

import firebase_admin
import asyncio
import json

firebase_admin.initialize_app()

Java

Initialisez le SDK Admin Firebase à l'aide de FirebaseOptions et des identifiants de votre compte de service :

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

Accéder

Initialisez l'application Firebase et créez une instance client 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)
}

Étape 2 : Identifiez les valeurs de paramètre par défaut pour votre application serveur

Identifiez les variables de votre application que vous souhaitez mettre à jour de manière dynamique avec Remote Config. Ensuite, réfléchissez aux variables qui doivent être définies par défaut dans votre application et à leurs valeurs par défaut. Cela garantit que votre application s'exécute correctement même si sa connexion au serveur backend Remote Config est interrompue.

Par exemple, si vous écrivez une application serveur qui gère une fonction d'IA générative, vous pouvez définir un nom de modèle par défaut, un préambule d'invite et une configuration d'IA générative, comme suit :

Nom du paramètre Description Type Valeur par défaut
model_name Nom de l'API du modèle Chaîne gemini-2.0-flash
preamble_prompt Requête à ajouter avant la requête de l'utilisateur Chaîne 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 Paramètres à envoyer au modèle JSON {"stopSequences": ["I hope this helps"], "temperature": 0.7, "maxOutputTokens": 512, "topP": 0.1, "topK": 20}

Étape 3 : Configurez votre application serveur

Une fois que vous avez déterminé les paramètres que vous souhaitez utiliser avec Remote Config, configurez votre application pour définir des valeurs par défaut, extraire le modèle Remote Config spécifique au serveur et évaluer ses valeurs.

  1. Accédez au modèle de serveur Remote Config et chargez-le.

    Node.js

    Initialisez le modèle de serveur à l'aide de initServerTemplate() et appelez load() pour récupérer le modèle à partir du backend :

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

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

    Si vous utilisez Node.js dans Cloud Functions for Firebase, vous pouvez utiliser la fonction asynchrone getServerTemplate() pour initialiser et charger le modèle en une seule étape :

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

    Python

    Initialisez le modèle de serveur à l'aide de init_server_template() et appelez load() pour récupérer le modèle à partir du 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())

    Si vous utilisez Python avec Cloud Functions for Firebase, vous pouvez également utiliser la fonction asynchrone get_server_template() pour initialiser et charger le modèle en une seule étape :

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

    Java

    Initialisez le client Remote Config côté serveur à l'aide de FirebaseRemoteConfig.getInstance() :

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

    Si vous utilisez Java avec Cloud Functions for Firebase, vous pouvez également utiliser getServerTemplate() pour initialiser et charger le modèle en une seule étape :

    ServerTemplate template = rc.getServerTemplate();

    Accéder

    Initialisez le modèle de serveur à l'aide de InitServerTemplate() et appelez Load() pour récupérer le modèle à partir du 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)
}

    Vous pouvez également initialiser le modèle en utilisant la fonction GetServerTemplate pour récupérer le modèle de serveur requis. Vous pouvez convertir ce modèle au format JSON, qui peut être stocké localement, puis initialiser ce modèle JSON à l'aide de la fonction InitServerTemplate.

  2. Pour vous assurer que votre application s'exécute correctement même si sa connexion au serveur backend Remote Config est interrompue, ajoutez des valeurs par défaut pour chaque paramètre de votre application.

    Node.js

    Ajoutez un objet defaultConfig dans votre fonction de modèle initServerTemplate ou 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

    Ajoutez un dictionnaire default_config dans votre fonction de modèle init_server_template ou 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())

    Vous pouvez également initialiser un modèle en utilisant la fonction get_server_template pour récupérer le modèle de serveur requis. Vous pouvez convertir ce modèle au format JSON à l'aide de la fonction template.to_json. Ce modèle JSON peut être stocké localement. Vous pouvez ensuite l'initialiser à l'aide de la fonction init_server_template.

    Java

    Ajoutez un objet defaultConfig à l'aide de KeysAndValues dans votre fonction 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);

    Vous pouvez également transmettre un modèle mis en cache par défaut lors de l'initialisation de Remote Config, qui peut être utilisé même lorsque la connexion au serveur Remote Config est interrompue :

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

    Accéder

    Ajoutez une carte defaultConfig dans votre fonction de modèle InitServerTemplate ou 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. Une fois le modèle chargé, évaluez-le pour importer les paramètres et les valeurs :

    Node.js

    Utiliser template.evaluate() :

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

    Python

    Utiliser template.evaluate() :

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

    Java

    Utiliser template.evaluate() :

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

    Accéder

    Utilisez template.Evaluate() avec un contexte d'évaluation vide lorsqu'aucune condition n'est appliquée :

    // 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. Si vous définissez des conditions dans votre modèle Remote Config, définissez et fournissez les valeurs de contexte souhaitées :

    • Si vous utilisez des conditions de pourcentage, ajoutez l'ID de randomisation (randomizationId, randomization_id ou randomizationID) que vous souhaitez utiliser pour évaluer vos conditions dans la fonction d'évaluation du modèle.
    • Si vous utilisez des signaux personnalisés, définissez les attributs et leurs valeurs. Les signaux personnalisés sont disponibles avec les SDK Firebase Admin Node.js v12.5.0+, Python v6.7.0+, Java v9.7.0+ et Go v4.17.0+.

    Par exemple, vous pouvez définir un ID d'installationFirebase ou un ID utilisateur comme ID de randomisation pour vous assurer que chaque utilisateur qui contacte votre serveur est ajouté au bon groupe randomisé, version comme signal personnalisé pour cibler des versions de client spécifiques et platform comme signal personnalisé pour cibler des plates-formes client.

    Pour en savoir plus sur les conditions, consultez Types de règles de condition.

    Node.js

    Transmettez un objet de contexte d'évaluation contenant randomizationId et tous les signaux personnalisés à 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

    Transmettez un dictionnaire contenant randomization_id et tous les signaux personnalisés à 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

    Créez un contexte KeysAndValues contenant randomizationId et tous les signaux personnalisés, puis transmettez-le à 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);

    Accéder

    Transmettez une carte de contexte d'évaluation contenant randomizationID et tous les signaux personnalisés à 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. Ensuite, extrayez les valeurs de paramètre dont vous avez besoin à partir de l'objet de configuration évalué. Utilisez des méthodes getter pour caster les valeurs de Remote Config dans le format attendu.

    Par exemple, si vous implémentez Agent Platform sur votre serveur et que vous souhaitez modifier le modèle et ses paramètres, vous pouvez configurer les paramètres de model_name et generation_config. Voici les méthodes getter compatibles et un exemple d'accès aux valeurs Remote Config pour chaque plate-forme :

    Node.js

    Méthodes getter acceptées :

    • Booléen : getBoolean
    • Objet : getValue
    • Numéro : getNumber
    • Chaîne : 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

    Méthodes getter acceptées :

    • Booléen : get_bool
    • Entier : get_int
    • Flottant : get_float
    • Chaîne : get_string
    • Source de la valeur : 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

    Méthodes getter acceptées :

    • Booléen : getBoolean
    • Chaîne : getString
    • Double : getDouble
    • Longue : getLong
    • Source de la valeur : 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");

    La méthode getValueSource renvoie un ValueSource qui indique si la source de la valeur du paramètre est STATIC, REMOTE ou DEFAULT.

    Accéder

    Méthodes getter acceptées :

    • Booléen : GetBoolean
    • Entier : GetInt
    • Flottant : GetFloat
    • Chaîne : GetString
    • Source de la valeur : 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. Si votre serveur est de longue durée, contrairement à un environnement sans serveur, rechargez régulièrement le modèle (par exemple, en utilisant setInterval dans Node.js ou java.util.Timer dans Java) pour vérifier que vous récupérez le modèle le plus récent à partir du serveur Remote Config.

Étape 4 : Définissez les valeurs de paramètre spécifiques au serveur dans Remote Config

Ensuite, créez un modèle Remote Config de serveur et configurez les paramètres et les valeurs à utiliser dans votre application.

Voici comment créer un modèle Remote Config spécifique à un serveur :

  1. Dans la console Firebase, accédez à DevOps et engagement > Remote Config > Page "Paramètres".

  2. Dans le sélecteur Client/Server (Client/Serveur) en haut de la page, sélectionnez Server (Serveur).

  3. Définissez les paramètres Remote Config avec les mêmes noms et types de données que ceux que vous avez définis dans votre application, puis fournissez des valeurs. Ces valeurs remplaceront la configuration par défaut (defaultConfig ou default_config) que vous avez définie dans Configurer votre application serveur lorsque vous récupérerez et évaluerez le modèle, et que vous attribuerez ces valeurs à vos variables.

  4. Vous pouvez également définir des conditions pour appliquer des valeurs de manière persistante à un échantillon aléatoire d'instances ou à des signaux personnalisés que vous définissez. Pour en savoir plus sur les conditions, consultez Types de règles de condition.

  5. Lorsque vous avez terminé d'ajouter des paramètres, cliquez sur Publier les modifications.

  6. Examinez les modifications, puis cliquez à nouveau sur Publier les modifications.

Étape 5 : Déployer avec Cloud Functions for Firebase ou Cloud Run

Si votre application serveur est légère et basée sur des événements, vous devriez envisager de déployer votre code à l'aide de Cloud Functions for Firebase. Par exemple, supposons que vous ayez une application qui inclut des dialogues de personnages optimisés par une API d'IA générative (par exemple, Google AI ou Agent Platform). Dans ce cas, vous pouvez héberger votre logique de diffusion de LLM dans une fonction que votre application appelle à la demande.

Si vous créez une application Web avec rendu côté serveur, App Hosting est compatible avec les frameworks Web populaires.

Sinon, vous pouvez envisager d'utiliser Cloud Run. Pour déployer votre application serveur avec Cloud Run, suivez le guide de démarrage rapide pour votre langage :

Pour en savoir plus sur les cas d'utilisation les plus adaptés à Cloud Run et Cloud Functions for Firebase, consultez Cloud Functions for Firebase vs Cloud Run : quand utiliser l'un ou l'autre.

Étapes suivantes