Wersjonowanie szablonów za pomocą Zdalnej konfiguracji


Gdy używasz szablonów promptów serwera, możesz aktualizować wartości w ramach danego szablonu bez publikowania nowej wersji aplikacji. Jednak ponieważ wszelkie zmiany w szablonie będą niemal natychmiast wykorzystywane przez żądania z aplikacji, musisz zachować ostrożność przy wprowadzaniu zmian, które mogłyby spowodować nieprawidłowe działanie aplikacji lub nieoczekiwane zmiany w jej zachowaniu.

Jeśli chcesz wprowadzić większe zmiany lub wdrażać je stopniowo, nie zmieniaj szablonu używanego w kodzie produkcyjnym.

Zamiast tego zalecamy używanie parametru Firebase Remote Config do kontrolowania wartości identyfikatora szablonu używanego w żądaniu wysyłanym do modelu.

Firebase Remote Config umożliwia dynamiczne i zdalne aktualizowanie wartości parametrów w aplikacji (np. identyfikatora szablonu) z poziomu Firebasekonsoli bez konieczności publikowania nowej wersji aplikacji. Ma też uproszczone funkcje i integracje do wdrażania zmian oraz testów A/B.

Z tego przewodnika dowiesz się, jak zaimplementować Remote Config w aplikacji, a w szczególności jak kontrolować identyfikator szablonu używany w aplikacji.

Krok 1. Ustaw wartość parametru w konsoli Firebase.

Utwórz Remote Configszablon klientatemplate_id i skonfiguruj template_idparametr oraz jego wartość, aby pobrać je i użyć w aplikacji.

  1. Otwórz projekt Firebase w Firebasekonsoli. Następnie w menu nawigacyjnym rozwiń Uruchom i wybierz Remote Config.

  2. Sprawdź, czy w selektorze Klient/Serwer u góry strony wybrano Klient.

  3. Aby rozpocząć tworzenie szablonu klienta, kliknij Utwórz konfigurację (lub Dodaj parametr, jeśli szablonów klientów używasz już wcześniej).

  4. Zdefiniuj parametr template_id:

    Nazwa parametru Opis Typ Wartość domyślna
    template_id Identyfikator szablonu. Ciąg znaków my-first-template-v1-0-0

  5. Po dodaniu tego parametru kliknij Opublikuj zmiany. Jeśli to nie jest nowy szablon Remote Config, sprawdź zmiany i ponownie kliknij Opublikuj zmiany.

Krok 2. Dodaj i zainicjuj Remote Config w aplikacji

Dodaj bibliotekę Remote Config i skonfiguruj Remote Config w aplikacji.

Swift

W ramach Firebase AI Logickonfiguracji pakiet SDK Firebase został już dodany do aplikacji, ale musisz też dodać Remote Config.

  1. Po otwarciu projektu w Xcode kliknij File > Add Package Dependencies (Plik > Dodaj zależności pakietu).

  2. Wybierz firebase-ios-sdk, a następnie kliknij Add package (Dodaj pakiet).

  3. W nawigatorze projektu wybierz aplikację > Cele > aplikację.

  4. Na karcie Ogólne przewiń do sekcji Frameworki, biblioteki i treści osadzone.

  5. Kliknij + i wybierz FirebaseRemoteConfig, a potem kliknij Dodaj.

  6. Dodaj do kodu import FirebaseRemoteConfig:

    import FirebaseRemoteConfig

  7. W odpowiedniej klasie aplikacji zainicjuj Firebase i dodajRemote Config do głównej logiki aplikacji.

    W tym miejscu dodasz Remote Config i Remote Config odbiornik w czasie rzeczywistym jako importy, aby aplikacja mogła pobierać nowe wartości w czasie rzeczywistym, oraz dodasz minimalny interwał pobierania:

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

Kotlin

  1. Dodaj zależność Remote Config do pliku Gradle modułu (na poziomie aplikacji) (zwykle app/build.gradle.kts lub app/build.gradle):

    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. Dodaj Remote Config do głównej logiki aplikacji. Tutaj zainicjujesz Remote Config i dodasz minimalny interwał pobierania:

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

Java

  1. Dodaj zależność Remote Config do pliku Gradle modułu (na poziomie aplikacji) (zwykle app/build.gradle.kts lub app/build.gradle):

    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. Dodaj Remote Config do głównej logiki aplikacji. Tutaj zainicjujesz Remote Config i dodasz minimalny interwał pobierania:

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

Web

  1. Otwórz kod w edytorze tekstu i zaimportuj Remote Config:

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

  2. W funkcji głównej i po zainicjowaniu aplikacji Firebase na potrzeby pakietu SDK Firebase AI Logic zainicjuj Remote Config:

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

  3. Ustaw minimalny odstęp czasu pobierania:

    remoteConfig.settings.minimumFetchIntervalMillis = 3600000;

Krok 3. Ustaw wartość parametru w aplikacji

Wartości domyślne parametrów w aplikacji należy ustawić w obiekcie Remote Config. Dzięki temu aplikacja będzie działać zgodnie z oczekiwaniami nawet wtedy, gdy nie będzie mogła pobrać wartości z usługi Remote Config.

Swift

  1. W konsoli Firebase otwórz Remote Config.

  2. Na karcie Parametry otwórz Menu i kliknij Pobierz wartości domyślne.

  3. Gdy pojawi się odpowiedni komunikat, włącz .plist na iOS, a następnie kliknij Pobierz plik.

  4. Zapisz plik w katalogu aplikacji.

  5. W Xcode kliknij prawym przyciskiem myszy aplikację i wybierz Add Files (Dodaj pliki).

  6. Wybierz remote_config_defaults.plist, a potem kliknij Dodaj.

  7. Zaktualizuj kod aplikacji, aby odwoływał się do pliku domyślnego:

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

Kotlin

  1. Na konsoli Firebase otwórz Remote Config.

  2. Na karcie Parametry otwórz Menu i kliknij Pobierz wartości domyślne.

  3. Gdy pojawi się odpowiedni komunikat, włącz .xml na Androida, a potem kliknij Pobierz plik.

  4. Zapisz plik w katalogu zasobów XML aplikacji.

  5. Zaktualizuj główny plik aktywności, aby dodać wartości domyślne po dodanym wcześniej kodzie configSettings:

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

Java

  1. W konsoli Firebase otwórz Remote Config.

  2. Na karcie Parametry otwórz Menu i kliknij Pobierz wartości domyślne.

  3. Gdy pojawi się odpowiedni komunikat, włącz .xml na Androida, a potem kliknij Pobierz plik.

  4. Zapisz plik w katalogu zasobów XML aplikacji.

  5. Zaktualizuj główny plik aktywności, aby dodać wartości domyślne po dodanym wcześniej kodzie configSettings:

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

Web

Wartość domyślną nazwy modelu możesz ustawić bezpośrednio w kodzie:

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

Krok 4. Pobierz i aktywuj wartość

Po ustawieniu domyślnej wartości nazwy modelu dodaj poniższy kod, aby pobrać i aktywować wartości.

Swift 

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

Powinno to aktualizować obiekt Remote Config za każdym razem, gdy zostanie opublikowany nowy szablon Remote Config.

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. Dodaj do importów getValue i fetchAndActivate:

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

  2. Znajdź kod, w którym określasz wartość domyślną nazwy modelu. Bezpośrednio po tym bloku kodu dodaj ten kod, aby pobrać i aktywować konfigurację oraz przypisać pobraną wartość do stałej templateID.

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

Krok 5. Dodaj słuchacza Remote Config w czasie rzeczywistym

Dodaj do aplikacji odbiornik Remote Config czasu rzeczywistego, aby mieć pewność, że zmiany wprowadzone w Remote Config szablonie są przekazywane do klienta natychmiast po aktualizacji.

Poniższy kod aktualizuje obiekt Remote Config za każdym razem, gdy zmienia się wartość parametru.

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

Opcjonalnie możesz też skonfigurować działanie w ramach aktywacji:addOnCompleteListener

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

Opcjonalnie możesz też skonfigurować działanie w ramach aktywacji:addOnCompleteListener

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

Słuchacze Remote Config w czasie rzeczywistym nie są obsługiwani w przypadku aplikacji internetowych.

Krok 6. Zaktualizuj żądania Gemini API, aby używać wartości Remote Config.

Kliknij Gemini API dostawcę, aby wyświetlić na tej stronie treści i kod specyficzne dla tego dostawcy.

Po pełnym skonfigurowaniu Remote Config zaktualizuj kod, aby zastąpić zakodowane na stałe wartości wartościami pochodzącymi z Remote Config.

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

// ...

Krok 7. Uruchom aplikację.

Skompiluj i uruchom aplikację oraz sprawdź, czy działa. Wprowadź zmiany w konfiguracji na stronie Remote Config w konsoli Firebase, opublikuj je i sprawdź wynik.

Dalsze kroki