Używaj Zdalnej konfiguracji w środowiskach serwera

Firebase Remote Config obsługuje konfigurację po stronie serwera za pomocą pakietów Firebase Admin SDK 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, i usługi w kontenerach na platformie Cloud Run.

W przeciwieństwie do pakietów SDK klienta Firebase, które pobierają konfigurację pochodną klienta z Remote Config szablonu, pakiet SDK po stronie serwera Remote Config pobiera z Firebase pełny szablon Remote Config. Serwer może następnie oceniać szablon w przypadku każdego przychodzącego żądania i używać własnej logiki, aby wyświetlać spersonalizowane odpowiedzi z bardzo małym 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:

  • Określ parametry konfiguracji aplikacji działających na serwerze lub dostępnych za jego pośrednictwem, co umożliwia korzystanie z przypadków użycia, takich jak zdalne konfigurowanie parametrów i promptów modelu AI oraz innych integracji, aby 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ć na bieżąco niestandardowe konfiguracje dla klientów, którzy uzyskują dostęp do Twojego serwera;
  • Rejestrowanie klientów, którzy otrzymali wartość parametru, i używanie tych informacji w Cloud Functions for Firebase w ramach systemu weryfikacji uprawnień.

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

Zanim zaczniesz

Aby utworzyć projekt w Firebase, skonfigurować konto usługi i dodać pakiet Firebase Admin SDK do serwera, postępuj zgodnie z instrukcjami w artykule Dodawanie pakietu 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: Firebase Admin Java SDK 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 interfejsu API

Gdy zainicjujesz pakiet Admin SDK bez parametrów, użyje on domyślnego uwierzytelniania aplikacji Google i odczyta 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 (wraz z asyncio i json na potrzeby asynchronicznego wczytywania szablonów i parsowania JSON), a następnie zainicjuj aplikację:

import firebase_admin
import asyncio
import json

firebase_admin.initialize_app()

Java

Zainicjuj pakiet Firebase Admin SDK za pomocą 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ę RemoteConfigklienta:

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 aplikacji serwera

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 będzie działać prawidłowo nawet wtedy, gdy połączenie z serwerem backendu Remote Config zostanie przerwane.

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

Nazwa parametru Opis Typ Wartość domyślna
model_name Nazwa interfejsu API modelu Ciąg znaków gemini-2.0-flash
preamble_prompt Prompt do dodania 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"], "temperature": 0.7, "maxOutputTokens": 512, "topP": 0.1, "topK": 20}

Krok 3. Skonfiguruj aplikację serwera

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

  1. Otwórz i wczytaj szablon serwera Remote Config.

    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 użyć asynchronicznej funkcji 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ą tego kodu:FirebaseRemoteConfig.getInstance()

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

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

    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 inicjowania szablonu jest użycie funkcji GetServerTemplate do pobrania wymaganego szablonu serwera. Ten szablon możesz przekonwertować na format JSON, który można przechowywać lokalnie, a następnie zainicjować go za pomocą funkcji InitServerTemplate.

  2. Aby mieć pewność, że aplikacja będzie działać prawidłowo nawet w przypadku przerwania połączenia z serwerem backendu Remote Config, dodaj do niej wartości domyślne każdego parametru.

    Node.js

    Dodaj obiekt defaultConfig wewnątrz funkcji szablonu initServerTemplate lub 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

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

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

    Java

    Dodaj obiekt defaultConfig za pomocą funkcji 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. Można go używać 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 w funkcji szablonu InitServerTemplate lub 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. Po wczytaniu szablonu sprawdź go, aby zaimportować parametry i wartości z szablonu:

    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 funkcji 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 wartości kontekstu, które chcesz:

    • 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 pakietach Firebase Admin SDK na Node.js w wersji 12.5.0 lub nowszej, na Pythona w wersji 6.7.0 lub nowszej, na Javę w wersji 9.7.0 lub nowszej oraz na Go w wersji 4.17.0 lub nowszej.

    Możesz na przykład ustawić Firebaseidentyfikator instalacji lub identyfikator użytkownika jako identyfikator randomizacji, aby mieć pewność, że każdy użytkownik, który kontaktuje się z Twoim serwerem, jest dodawany do odpowiedniej grupy losowej, version jako sygnał niestandardowy do kierowania reklam na określone wersje klienta i platform jako sygnał niestandardowy do kierowania reklam na platformy klienta.

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

    Node.js

    Przekaż do funkcji template.evaluate() obiekt kontekstu oceny zawierający parametr randomizationId i wszystkie sygnały niestandardowe:

    // 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 wszystkie 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 wszystkie sygnały niestandardowe, a następnie przekaż go do funkcji 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ż mapę kontekstu oceny zawierającą randomizationID i wszystkie niestandardowe sygnały do 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. Następnie wyodrębnij z ocenionego obiektu konfiguracji potrzebne wartości parametrów. Użyj metod pobierających, aby przekształcić wartości z Remote Config do oczekiwanego formatu.

    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 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
    • Liczba zmiennoprzecinkowa: 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
    • Podwójny: 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
    • Liczba zmiennoprzecinkowa: 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 długo, w przeciwieństwie do środowiska bezserwerowego, okresowo przeładowuj szablon (np. za pomocą funkcji setInterval w Node.js lub java.util.Timer w Javie), aby mieć pewność, że pobierasz najnowszy szablon z serwera Remote Config.

Krok 4. Ustaw wartości parametrów specyficzne dla serwera w Remote Config

Następnie utwórz szablon serwera Remote Config i skonfiguruj parametry oraz wartości, które będą używane w aplikacji.

Aby utworzyć szablon Remote Configspecyficzny dla 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 Remote Config parametry 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 serwera podczas pobierania i oceniania szablonu oraz przypisywania tych wartości do zmiennych.

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

  5. Po dodaniu parametrów kliknij Opublikuj zmiany.

  6. Sprawdź zmiany i ponownie kliknij Opublikuj zmiany.

Krok 5. Wdróż za pomocą Cloud Functions for Firebase lub Cloud Run

Jeśli aplikacja serwera 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 oparte na interfejsie API generatywnej AI (np. Google AI lub Agent Platform). W takim przypadku możesz umieścić logikę obsługi LLM w funkcji, którą aplikacja wywołuje na żądanie.

Jeśli tworzysz aplikację internetową renderowaną na serwerze, App Hosting obsługuje popularne platformy internetowe.

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

Więcej informacji o najlepszych przypadkach użycia funkcji Cloud Run i Cloud Functions for Firebase znajdziesz w artykule Cloud Functions for Firebase a Cloud Run: kiedy używać jednej z nich.

Dalsze kroki