Versionen mit Remote Config konfigurieren


Wenn Sie Server-Prompt-Vorlagen verwenden, können Sie Werte innerhalb einer bestimmten Vorlage aktualisieren, ohne eine neue Version Ihrer App zu veröffentlichen. Da jedoch alle Änderungen an der Vorlage fast sofort für Anfragen aus Ihrer App verwendet werden, müssen Sie vorsichtig sein, wenn Sie Änderungen vornehmen, die Ihre App beschädigen oder unerwartete Verhaltensänderungen verursachen könnten.

Wenn Sie also größere Änderungen vornehmen oder Änderungen schrittweise einführen möchten, sollten Sie die Vorlage, die im Produktionscode verwendet wird, nicht ändern.

Stattdessen empfehlen wir, Firebase Remote Config zu verwenden, um den Wert der Vorlagen-ID zu steuern, der in der Anfrage an das Modell verwendet wird.

Mit Firebase Remote Config können Sie Parameterwerte in Ihrer App (z. B. die Vorlagen-ID) dynamisch und remote über die Firebase-Konsole aktualisieren, ohne eine neue Version Ihrer App veröffentlichen zu müssen. Außerdem bietet es optimierte Funktionen und Integrationen für die Einführung von Änderungen sowie A/B-Tests.

In diesem Leitfaden wird beschrieben, wie Sie Remote Config in Ihrer App implementieren, insbesondere um die in Ihrer App verwendete Vorlagen-ID zu steuern.

Schritt 1: Parameterwert in der Firebase-Konsole festlegen

Erstellen Sie eine Remote Config-Clientvorlage und konfigurieren Sie einen template_id-Parameter und seinen Wert, der in der App abgerufen und verwendet werden soll.

  1. Öffnen Sie Ihr Firebase-Projekt in der Firebase Console. Maximieren Sie dann im Navigationsmenü Ausführen und wählen Sie Remote Config aus.

  2. Achten Sie darauf, dass oben auf der Seite in der Auswahl Client/Server die Option Client ausgewählt ist.

  3. Klicken Sie auf Konfiguration erstellen (oder auf Parameter hinzufügen, wenn Sie bereits Clientvorlagen verwendet haben), um eine Clientvorlage zu erstellen.

  4. Definieren Sie den Parameter template_id:

    Parametername Beschreibung Typ Standardwert
    template_id Vorlagen-ID. String my-first-template-v1-0-0

  5. Klicken Sie nach dem Hinzufügen dieses Parameters auf Änderungen veröffentlichen. Wenn es sich nicht um eine neue Remote Config-Vorlage handelt, überprüfen Sie die Änderungen und klicken Sie noch einmal auf Änderungen veröffentlichen.

Schritt 2: Remote Config in Ihre App einfügen und initialisieren

Fügen Sie die Remote Config-Bibliothek hinzu und richten Sie Remote Config in Ihrer App ein.

Swift

Im Rahmen der Firebase AI Logic-Einrichtung haben Sie das Firebase SDK bereits in Ihre App eingefügt. Sie müssen aber auch Remote Config hinzufügen.

  1. Öffnen Sie das Projekt in Xcode und gehen Sie zu File > Add Package Dependencies (Datei > Paketabhängigkeiten hinzufügen).

  2. Wählen Sie firebase-ios-sdk aus und klicken Sie dann auf Paket hinzufügen.

  3. Wählen Sie im Project Navigator Ihre App > Ziele > Ihre App aus.

  4. Scrollen Sie auf dem Tab Allgemein zu Frameworks, Bibliotheken und eingebettete Inhalte.

  5. Klicken Sie auf +, wählen Sie FirebaseRemoteConfig aus und klicken Sie dann auf Hinzufügen.

  6. Fügen Sie den FirebaseRemoteConfig-Import in Ihren Code ein:

    import FirebaseRemoteConfig

  7. Initialisieren Sie Firebase in der entsprechenden Klasse für Ihre App und fügen Sie Remote Config in Ihre Hauptanwendungslogik ein.

    Hier fügen Sie Remote Config und den Remote Config-Echtzeit-Listener als Importe hinzu, damit die App neue Werte in Echtzeit abrufen kann. Außerdem fügen Sie ein minimales Abrufintervall hinzu:

    let remoteConfig = RemoteConfig.remoteConfig()
let settings = RemoteConfigSettings()
settings.minimumFetchInterval = 3600
remoteConfig.configSettings = settings

Kotlin

  1. Fügen Sie die Remote Config-Abhängigkeit der Gradle-Datei Ihres Moduls (auf App-Ebene, in der Regel app/build.gradle.kts oder app/build.gradle) hinzu:

    dependencies {
    implementation(platform("com.google.firebase:firebase-bom:34.5.0"))
    implementation("com.google.firebase:firebase-ai")
    implementation("com.google.firebase:firebase-config")
    // ... other dependencies
}

  2. Fügen Sie Remote Config in Ihre Hauptanwendungslogik ein. Hier initialisieren Sie Remote Config und fügen ein minimales Abrufintervall hinzu:

    val remoteConfig: FirebaseRemoteConfig = Firebase.remoteConfig
val configSettings = remoteConfigSettings {
minimumFetchIntervalInSeconds = 3600
}
remoteConfig.setConfigSettingsAsync(configSettings)

Java

  1. Fügen Sie die Remote Config-Abhängigkeit der Gradle-Datei Ihres Moduls (auf App-Ebene, in der Regel app/build.gradle.kts oder app/build.gradle) hinzu:

    dependencies {
    implementation(platform("com.google.firebase:firebase-bom:34.5.0"))
    implementation("com.google.firebase:firebase-ai")
    implementation("com.google.firebase:firebase-config")
    // ... other dependencies
}

  2. Fügen Sie Remote Config in Ihre Hauptanwendungslogik ein. Hier initialisieren Sie Remote Config und fügen ein minimales Abrufintervall hinzu:

    FirebaseRemoteConfig mFirebaseRemoteConfig = FirebaseRemoteConfig.getInstance();
FirebaseRemoteConfigSettings configSettings = new FirebaseRemoteConfigSettings.Builder()
    .setMinimumFetchIntervalInSeconds(3600)
    .build();
mFirebaseRemoteConfig.setConfigSettingsAsync(configSettings);

Web

  1. Öffnen Sie Ihren Code in einem Texteditor und importieren Sie Remote Config:

    import { getRemoteConfig } from 'firebase/remote-config';

  2. Initialisieren Sie Remote Config in Ihrer primären Funktion und nachdem die Firebase-App für das Firebase AI Logic SDK initialisiert wurde:

      // Initialize Remote Config and get a reference to the service
  const remoteConfig = getRemoteConfig(app);

  3. Mindestabrufintervall festlegen:

    remoteConfig.settings.minimumFetchIntervalMillis = 3600000;

Schritt 3: In-App-Parameterwert festlegen

Sie sollten In-App-Standardparameterwerte im Remote Config-Objekt festlegen. So wird sichergestellt, dass sich Ihre App wie erwartet verhält, auch wenn sie keine Werte vom Remote Config-Dienst abrufen kann.

Swift

  1. Öffnen Sie in der Firebase-Konsole Remote Config.

  2. Öffnen Sie auf dem Tab Parameter das Menü und wählen Sie Standardwerte herunterladen aus.

  3. Aktivieren Sie bei Aufforderung .plist für iOS und klicken Sie dann auf Datei herunterladen.

  4. Speichern Sie die Datei im Anwendungsverzeichnis.

  5. Klicken Sie in Xcode mit der rechten Maustaste auf Ihre App und wählen Sie Dateien hinzufügen aus.

  6. Wählen Sie remote_config_defaults.plist aus und klicken Sie auf Hinzufügen.

  7. Aktualisieren Sie Ihren App-Code, damit er auf die Standarddatei verweist:

    // Set default values for Remote Config parameters.
remoteConfig.setDefaults(fromPlist: "remote_config_defaults")

Kotlin

  1. Öffnen Sie Remote Config in der Firebase-Konsole.

  2. Öffnen Sie auf dem Tab Parameter das Menü und wählen Sie Standardwerte herunterladen aus.

  3. Aktivieren Sie bei Aufforderung .xml für Android und klicken Sie dann auf Datei herunterladen.

  4. Speichern Sie die Datei im XML-Ressourcenverzeichnis Ihrer App.

  5. Aktualisieren Sie Ihre Hauptaktivitätsdatei, um die Standardwerte nach dem configSettings hinzuzufügen, das Sie zuvor hinzugefügt haben:

    // Set default values for Remote Config parameters.
remoteConfig.setDefaultsAsync(R.xml.remote_config_defaults)

Java

  1. Öffnen Sie in der Firebase-Konsole Remote Config.

  2. Öffnen Sie auf dem Tab Parameter das Menü und wählen Sie Standardwerte herunterladen aus.

  3. Aktivieren Sie bei Aufforderung .xml für Android und klicken Sie dann auf Datei herunterladen.

  4. Speichern Sie die Datei im XML-Ressourcenverzeichnis Ihrer App.

  5. Aktualisieren Sie Ihre Hauptaktivitätsdatei, um die Standardwerte nach dem configSettings hinzuzufügen, das Sie zuvor hinzugefügt haben:

    // Set default values for Remote Config parameters.
mFirebaseRemoteConfig.setDefaultsAsync(R.xml.remote_config_defaults);

Web

Sie können den Standardwert für den Modellnamen direkt in Ihrem Code festlegen:

// Set default values for Remote Config parameters.
remoteConfig.defaultConfig = {
  template_id: 'my-first-template-v1-0-0',
};

Schritt 4: Wert abrufen und aktivieren

Nachdem Sie den Standardwert für den Modellnamen festgelegt haben, fügen Sie Folgendes hinzu, um Werte abzurufen und zu aktivieren.

Swift 

// Fetch and activate Remote Config values
remoteConfig.fetchAndActivate { status, error in
  if let error = error {
    print("Error fetching Remote Config: \(error.localizedDescription)")
  }
}

Dadurch sollte das Remote Config-Objekt immer dann aktualisiert werden, wenn eine neue Remote Config-Vorlage veröffentlicht wird.

Kotlin 

// Fetch and activate Remote Config values
remoteConfig.fetchAndActivate()
      .addOnCompleteListener(this) { task ->
          if (task.isSuccessful) {
              val updated = task.result
              Log.d(TAG, "Remote Config values fetched and activated: $updated")
          } else {
              Log.e(TAG, "Error fetching Remote Config", task.exception)
          }
      }

Java 

  // Fetch and activate Remote Config values
  mFirebaseRemoteConfig.fetchAndActivate()
    .addOnCompleteListener(this, new OnCompleteListener<Boolean>() {
        @Override
        public void onComplete(@NonNull Task<Boolean> task) {
            if (task.isSuccessful()) {
                boolean updated = task.getResult();
                Log.d(TAG, "Config params updated: " + updated);
            } else {
                Log.e(TAG, "Error fetching Remote Config", task.exception)
            }
          }
    });

Web

  1. Fügen Sie getValue und fetchAndActivate zu Ihren Importen hinzu:

    import { getValue, fetchAndActivate } from 'firebase/remote-config';

  2. Suchen Sie den Code, in dem Sie den Standardwert für den Modellnamen angeben. Fügen Sie direkt nach diesem Codeblock den folgenden Code hinzu, um die Konfiguration abzurufen und zu aktivieren und den abgerufenen Wert der Konstanten templateID zuzuweisen.

    // Fetch and activate Remote Config.
try {
  await fetchAndActivate(remoteConfig);
} catch(err) {
  console.error('Remote Config fetch failed', err);
}

console.log('Remote Config fetched.');

// Assign Remote Config values.
const templateID = getValue(remoteConfig, 'template_id').asString();

Schritt 5: Echtzeit-Remote Config-Listener hinzufügen

Fügen Sie Ihrer App einen Remote Config-Listener in Echtzeit hinzu, damit Änderungen, die Sie an der Remote Config-Vorlage vornehmen, sofort an den Client weitergegeben werden.

Der folgende Code aktualisiert das Remote Config-Objekt, wenn sich ein Parameterwert ändert.

Swift 

// Add real-time Remote Config
remoteConfig.addOnConfigUpdateListener { configUpdate, error in
  guard let configUpdate = configUpdate, error == nil else {
    print("Error listening for config updates: \(error?.localizedDescription ?? "No error available")")
    return
  }

  print("Updated keys: \(configUpdate.updatedKeys)")
  remoteConfig.activate { changed, error in
    guard error == nil else {
      print("Error activating config: \(error?.localizedDescription ?? "No error available")")
      return
    }
    print("Activated config successfully")
  }
}

Kotlin

Optional können Sie auch eine Aktion in der addOnCompleteListener-Aktivierung konfigurieren:

      // Add a real-time Remote Config listener
      remoteConfig.addOnConfigUpdateListener(object : ConfigUpdateListener {
          override fun onUpdate(configUpdate : ConfigUpdate) {
              Log.d(ContentValues.TAG, "Updated keys: " + configUpdate.updatedKeys);
              remoteConfig.activate().addOnCompleteListener {
                  // Optionally, add an action to perform on update here.
              }
          }

          override fun onError(error : FirebaseRemoteConfigException) {
              Log.w(ContentValues.TAG, "Config update error with code: " + error.code, error)
          }
      }

Java

Optional können Sie auch eine Aktion in der addOnCompleteListener-Aktivierung konfigurieren:

  // Add a real-time Remote Config listener
  remoteConfig.addOnConfigUpdateListener(new ConfigUpdateListener() {
      @Override
      public void onUpdate(ConfigUpdate configUpdate) {
          Log.d(ContentValues.TAG, "Updated keys: " + configUpdate.getUpdatedKeys());
                remoteConfig.activate().addOnCompleteListener(new OnCompleteListener<Boolean>() {
                  @Override
                  public void onComplete(@NonNull Task<Boolean> task) {
                      // Optionally, add an action to perform on update here.
                  }
              });
          }

      @Override
      public void onError(FirebaseRemoteConfigException error) {
          Log.w(ContentValues.TAG, "Config update error with code: " + error.getCode(), error);
      }
  });

Web

Remote Config-Listener in Echtzeit werden für Web-Apps nicht unterstützt.

Schritt 6: Gemini API-Anfragen aktualisieren, damit der Remote Config-Wert verwendet wird

Klicken Sie auf Ihren Gemini API-Anbieter, um anbieterspezifische Inhalte und Code auf dieser Seite aufzurufen.

Nachdem Remote Config vollständig konfiguriert ist, aktualisieren Sie Ihren Code, um hartcodierte Werte durch Werte aus Remote Config zu ersetzen.

Swift 

import FirebaseAI

let templateID = remoteConfig.configValue(forKey: "template_id").stringValue
let model = FirebaseAI.firebaseAI(backend: .googleAI()).templateGenerativeModel()
let customerName = "Jane"

// When making the `generateContent` call, source the template ID value from Remote Config
let response = try await model.generateContent(
  templateID: templateID,
  // Provide the values for any input variables required by your template.
  inputs: [
    "customerName": customerName
  ]
)

// ...

Kotlin 

// ...

val model = Firebase.ai().templateGenerativeModel()
val customerName = "Jane"

// When making the `generateContent` call, source the template ID value from Remote Config
val response = model.generateContent(
  remoteConfig.getString("template_id"),
  // Provide the values for any input variables required by your template.
  mapOf(
    "customerName" to customerName
  )
)

val text = response.text
println(text)

Java 

// ...

TemplateGenerativeModel ai = FirebaseAI.getInstance()
    .templateGenerativeModel(null /* Request Options */);

TemplateGenerativeModelFutures model = TemplateGenerativeModelFutures.from(ai);
String customerName = "Jane";

// When making the `generateContent` call, source the template ID value from Remote Config
Future<GenerateContentResponse> response = model.generateContent(
    remoteConfig.getString("template_id"),
    // Provide the values for any input variables required by your template.
    mapOf("customerName", customerName)

);
addCallback(response,
      new FutureCallback<GenerateContentResponse>() {
          public void onSuccess(GenerateContentResponse result) {
            System.out.println(result.getText());
          }
          public void onFailure(Throwable t) {
            reportError(t);
          }
    }
executor);

// ...

Web 

// ...

const ai = getAI(firebaseApp, { backend: new GoogleAIBackend() });

const model = getTemplateGenerativeModel(ai);
const templateID = getValue(remoteConfig, 'template_id').asString();
const customerName = 'Jane';

// When making the `generateContent` call, source the template ID value from Remote Config
const result = await model.generateContent(
  templateID,
  // Provide the values for any input variables required by your template
  {
    customerName: customerName,
  }
);

// ...

Schritt 7: App ausführen

Erstellen Sie die App, führen Sie sie aus und prüfen Sie, ob sie funktioniert. Nehmen Sie auf der Seite Remote Config in der Firebase Console Änderungen an der Konfiguration vor, veröffentlichen Sie die Änderungen und prüfen Sie das Ergebnis.

Nächste Schritte