Używaj Zdalnej konfiguracji w środowiskach serwera

Firebase Remote Config obsługuje konfigurację po stronie serwera za pomocą pakietów SDK Firebase Admin dla Node.js (wersja 12.1.0 lub nowsza), Pythona (wersja 6.7.0 lub nowsza), Javy (wersja 9.7.0 lub nowsza) i Go (wersja 4.17.0 lub nowsza).

Ta funkcja umożliwia dynamiczne zarządzanie działaniem i konfiguracją aplikacji po stronie serwera za pomocą Remote Config. Obejmuje to implementacje bezserwerowe, takie jak Cloud Functions for Firebase, oraz usługi skonteneryzowane w Cloud Run.

W przeciwieństwie do pakietów SDK klienta Firebase, które pobierają konfigurację klienta pochodzącą z szablonu Remote Config, pakiet SDK Remote Config po stronie serwera pobiera z Firebase cały szablon Remote Config. Serwer może następnie oceniać szablon przy każdym przychodzącym żądaniu i używać własnej logiki do wyświetlania dostosowanej odpowiedzi z bardzo niskim opóźnieniem. Możesz używać warunków, aby kontrolować i dostosowywać odpowiedzi na podstawie losowych wartości procentowych i atrybutów klienta zdefiniowanych w sygnałach niestandardowych.

Dzięki Remote Config po stronie serwera możesz:

  • Zdefiniuj parametry konfiguracji aplikacji działających na serwerze lub dostępnych za jego pośrednictwem, aby umożliwić takie przypadki użycia jak zdalna konfiguracja parametrów i promptów modelu AI oraz inne integracje, co zapewni bezpieczeństwo kluczy interfejsu API.
  • dynamicznie dostosowywać parametry w odpowiedzi na zmiany w środowisku lub inne zmiany w aplikacji, takie jak aktualizowanie parametrów LLM i punktów końcowych modelu;
  • Kontroluj koszty, zdalnie aktualizując interfejsy API wywoływane przez serwer.
  • generować niestandardowe konfiguracje na bieżąco dla klientów, którzy uzyskują dostęp do Twojego serwera;
  • Zapisuj, którzy klienci otrzymali wartość parametru, i używaj tych informacji w Cloud Functions for Firebase w ramach systemu weryfikacji uprawnień.

Możesz wdrożyć Remote Config po stronie serwera w środowiskach serwerowych Cloud Run, Cloud Functions for Firebase lub hostowanych samodzielnie.

Zanim zaczniesz

Postępuj zgodnie z instrukcjami podanymi w artykule Dodawanie pakietu Firebase Admin SDK do serwera, aby utworzyć projekt w Firebase, skonfigurować konto usługi i dodać pakiet Firebase Admin SDK do serwera. Upewnij się, że używasz obsługiwanej wersji pakietu Admin SDK na swojej platformie:

  • Node.js: pakiet SDK Firebase Admin Node.js w wersji 12.1.0 lub nowszej.
  • Python: Firebase Admin Python SDK w wersji 6.7.0 lub nowszej
  • Java: pakiet Admin Java SDK Firebase w wersji 9.7.0 lub nowszej
  • Go: pakiet SDK Firebase Admin Go w wersji 4.17.0 lub nowszej

Krok 1. Zainicjuj pakiet Firebase Admin SDK i autoryzuj żądania do interfejsu API

Gdy inicjujesz pakiet Admin SDK bez parametrów, używa on domyślnych danych logowania aplikacji Google i odczytuje opcje ze zmiennej środowiskowej GOOGLE_APPLICATION_CREDENTIALS. Zainicjuj pakiet SDK i skonfiguruj Remote Config na swojej platformie:

Node.js

Zaimportuj initializeApp i getRemoteConfig, a następnie zainicjuj instancję aplikacji Firebase:

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

// Initialize Firebase
const firebaseApp = initializeApp();

Python

Zaimportuj firebase_admin (oraz asyncio i json na potrzeby asynchronicznego wczytywania szablonów i analizowania plików JSON), a następnie zainicjuj aplikację:

import firebase_admin
import asyncio
import json

firebase_admin.initialize_app()

Java

Zainicjuj pakiet Firebase Admin SDK, używając FirebaseOptions i danych logowania konta usługi:

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

Go

Zainicjuj aplikację Firebase i utwórz instancję klienta 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)
}

Krok 2. Określ domyślne wartości parametrów dla aplikacji serwerowej

Określ zmienne w aplikacji, które chcesz dynamicznie aktualizować za pomocą Remote Config. Następnie zastanów się, które zmienne muszą być domyślnie ustawione w aplikacji i jakie powinny być ich wartości domyślne. Dzięki temu aplikacja działa prawidłowo, nawet jeśli połączenie z serwerem backendu Remote Config zostanie przerwane.

Jeśli na przykład piszesz aplikację serwerową, która zarządza funkcją AI, możesz ustawić domyślną nazwę modelu, wprowadzenie do prompta i konfigurację generatywnej AI, na przykład:

Nazwa parametru Opis Typ Wartość domyślna
model_name Nazwa interfejsu API modelu Ciąg znaków gemini-3.8-flash
preamble_prompt Prompt, który ma zostać dodany na początku zapytania użytkownika Ciąg znaków 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 Parametry do wysłania do modelu JSON {"stopSequences": ["I hope this helps"], "maxOutputTokens": 512}

Krok 3. Skonfiguruj aplikację serwera

Po określeniu parametrów, których chcesz używać z usługą Remote Config, skonfiguruj aplikację tak, aby ustawiała wartości domyślne, pobierała szablon Remote Config z serwera i oceniała jego wartości.

  1. Uzyskaj dostęp do szablonu serwera Remote Config i go wczytaj.

    Node.js

    Zainicjuj szablon serwera za pomocą initServerTemplate() i wywołaj load(), aby pobrać szablon z backendu:

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

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

    Jeśli używasz Node.js w Cloud Functions for Firebase, możesz użyć asynchronicznej funkcji getServerTemplate(), aby zainicjować i wczytać szablon w jednym kroku:

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

    Python

    Zainicjuj szablon serwera za pomocą init_server_template() i wywołaj load(), aby pobrać szablon z backendu:

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

    Jeśli używasz Pythona z Cloud Functions for Firebase, możesz też użyć funkcji asynchronicznej get_server_template(), aby zainicjować i wczytać szablon w jednym kroku:

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

    Java

    Zainicjuj klienta Remote Config po stronie serwera za pomocą FirebaseRemoteConfig.getInstance():

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

    Jeśli używasz Javy z Cloud Functions for Firebase, możesz też użyć getServerTemplate(), aby zainicjować i wczytać szablon w jednym kroku:

    ServerTemplate template = rc.getServerTemplate();

    Go

    Zainicjuj szablon serwera za pomocą InitServerTemplate() i wywołaj Load(), aby pobrać szablon z backendu:

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

    Innym sposobem zainicjowania szablonu jest użycie funkcji GetServerTemplate do pobrania wymaganego szablonu serwera. Możesz przekonwertować ten szablon na format JSON, który można przechowywać lokalnie, a następnie zainicjować ten szablon JSON za pomocą funkcji InitServerTemplate.

  2. Aby mieć pewność, że aplikacja będzie działać prawidłowo nawet wtedy, gdy połączenie z serwerem backendu Remote Config zostanie przerwane, dodaj wartości domyślne dla każdego parametru w aplikacji.

    Node.js

    Dodaj obiekt defaultConfig do funkcji szablonu initServerTemplate lub 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

    Dodaj słownik default_config do funkcji szablonu init_server_template lub 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())

    Innym sposobem na zainicjowanie szablonu jest użycie funkcji get_server_template do pobrania wymaganego szablonu serwera. Możesz przekonwertować ten szablon na format JSON za pomocą funkcji template.to_json. Ten szablon JSON można zapisać lokalnie, a następnie zainicjować za pomocą funkcji init_server_template.

    Java

    Dodaj obiekt defaultConfig za pomocą KeysAndValues w funkcji 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);

    Możesz też przekazać domyślny szablon z pamięci podręcznej podczas inicjowania Remote Config, który może być używany nawet wtedy, gdy połączenie z serwerem Remote Config zostanie przerwane:

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

    Go

    Dodaj mapę defaultConfig wewnątrz funkcji szablonu InitServerTemplate lub 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. Po wczytaniu szablonu sprawdź go, aby zaimportować z niego parametry i wartości:

    Node.js

    Użyj template.evaluate():

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

    Python

    Użyj template.evaluate():

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

    Java

    Użyj template.evaluate():

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

    Go

    Użyj template.Evaluate() z pustym kontekstem oceny, gdy nie są stosowane żadne warunki:

    // 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. Opcjonalnie, jeśli w szablonie Remote Config ustawisz warunki, zdefiniuj i podaj odpowiednie wartości kontekstu:

    • Jeśli używasz warunków procentowych, dodaj identyfikator randomizacji (randomizationId, randomization_id lub randomizationID), którego chcesz użyć do oceny warunków w funkcji oceny szablonu.
    • Jeśli używasz sygnałów niestandardowych, zdefiniuj atrybuty i ich wartości. Sygnały niestandardowe są dostępne w pakiecie Firebase Admin Node.js SDK w wersji 12.5.0 lub nowszej, Python SDK w wersji 6.7.0 lub nowszej, Java SDK w wersji 9.7.0 lub nowszej oraz Go SDK w wersji 4.17.0 lub nowszej.

    Możesz na przykład ustawić identyfikator instalacji Firebase lub identyfikator użytkownika jako identyfikator randomizacji, aby mieć pewność, że każdy użytkownik, który skontaktuje się z Twoim serwerem, zostanie dodany do odpowiedniej grupy randomizowanej, version jako sygnał niestandardowy do kierowania na określone wersje klienta oraz platform jako sygnał niestandardowy do kierowania na platformy klienta.

    Więcej informacji o warunkach znajdziesz w artykule Typy reguł warunkowych.

    Node.js

    Przekaż obiekt kontekstu oceny zawierający randomizationId i dowolne sygnały niestandardowe do 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

    Przekaż słownik zawierający randomization_id i dowolne sygnały niestandardowe do 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

    Utwórz kontekst KeysAndValues zawierający randomizationId i dowolne sygnały niestandardowe, a następnie przekaż go do 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

    Przekaż do template.Evaluate() mapę kontekstu oceny zawierającą randomizationID i dowolne sygnały niestandardowe:

    // 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. Następnie wyodrębnij potrzebne wartości parametrów z ocenionego obiektu konfiguracji. Użyj metod pobierających, aby przekonwertować wartości z Remote Config na oczekiwany format.

    Jeśli na przykład wdrażasz Agent Platform na serwerze i chcesz zmienić model oraz jego parametry, możesz skonfigurować parametry dla model_name i generation_config. Oto obsługiwane metody pobierania i przykład uzyskiwania dostępu do wartości Remote Config na każdej platformie:

    Node.js

    Obsługiwane metody pobierania:

    • Wartość logiczna: getBoolean
    • Obiekt: getValue
    • Numer: getNumber
    • Ciąg znaków: 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

    Obsługiwane metody pobierania:

    • Wartość logiczna: get_bool
    • Liczba całkowita: get_int
    • Pływak: get_float
    • Ciąg znaków: get_string
    • Źródło wartości: 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

    Obsługiwane metody pobierania:

    • Wartość logiczna: getBoolean
    • Ciąg znaków: getString
    • Double: getDouble
    • Długi: getLong
    • Źródło wartości: 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");

    Metoda getValueSource zwraca wartość ValueSource, która wskazuje, czy źródłem wartości parametru jest STATIC, REMOTE czy DEFAULT.

    Go

    Obsługiwane metody pobierania:

    • Wartość logiczna: GetBoolean
    • Liczba całkowita: GetInt
    • Pływak: GetFloat
    • Ciąg znaków: GetString
    • Źródło wartości: 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. Jeśli Twój serwer działa przez długi czas, w przeciwieństwie do środowiska bezserwerowego, okresowo ponownie wczytuj szablon (np. za pomocą setInterval w Node.js lub java.util.Timer w Java), aby mieć pewność, że pobierasz najbardziej aktualny szablon z serwera Remote Config.

Krok 4. Ustaw wartości parametrów serwera w usłudze Remote Config

Następnie utwórz szablon Remote Config serwera i skonfiguruj parametry oraz wartości do użycia w aplikacji.

Aby utworzyć szablon Remote Config dla konkretnego serwera:

  1. W konsoli Firebase otwórz stronę DevOps i zaangażowanie > Zdalna konfiguracja > Parametry.

  2. W selektorze Klient/Serwer u góry strony wybierz Serwer.

  3. Zdefiniuj parametry Remote Config o takich samych nazwach i typach danych jak parametry zdefiniowane w aplikacji i podaj wartości. Te wartości zastąpią konfigurację domyślną (defaultConfig lub default_config) ustawioną w sekcji Konfigurowanie aplikacji serwerowej, gdy pobierzesz i ocenisz szablon oraz przypiszesz te wartości do zmiennych.

  4. Opcjonalnie możesz ustawić warunki, aby stale stosować wartości do losowej próbki instancji lub zdefiniowanych przez Ciebie sygnałów niestandardowych. Więcej informacji o warunkach znajdziesz w artykule Typy reguł warunkowych.

  5. Po dodaniu parametrów kliknij Opublikuj zmiany.

  6. Sprawdź zmiany i ponownie kliknij Opublikuj zmiany.

Krok 5. Przeprowadź wdrożenie za pomocą Cloud Functions for Firebase lub Cloud Run

Jeśli Twoja aplikacja serwerowa jest lekka i oparta na zdarzeniach, rozważ wdrożenie kodu za pomocą Cloud Functions for Firebase. Załóżmy na przykład, że masz aplikację, która zawiera dialogi postaci obsługiwane przez interfejs API generatywnej AI (np. Google AI lub Agent Platform). W takim przypadku możesz hostować logikę obsługującą LLM w funkcji, którą aplikacja wywołuje na żądanie.

Jeśli tworzysz aplikację internetową renderowaną po stronie serwera, App Hosting obsługuje popularne platformy internetowe.

W przeciwnym razie możesz rozważyć Cloud Run. Aby wdrożyć aplikację serwerową za pomocą Cloud Run, postępuj zgodnie z krótkim przewodnikiem w wybranym języku:

Dalsze kroki