Gatilhos do Configuração remota


Você pode acionar uma função em resposta a eventos de Firebase Remote Config, incluindo a publicação de uma nova versão de configuração ou a reversão para uma versão mais antiga. Neste guia, descrevemos como criar uma função em segundo plano de Remote Config que executa uma comparação entre duas versões de modelo.

Acionar uma função de Remote Config

Para acionar uma função de Remote Config, primeiro importe os módulos necessários:

Node.js

 // The Cloud Functions for Firebase SDK to set up triggers and logging.
const {onConfigUpdated} = require("firebase-functions/v2/remoteConfig");
const logger = require("firebase-functions/logger");
// The Firebase Admin SDK to obtain access tokens.
const admin = require("firebase-admin");
const app = admin.initializeApp();
const fetch = require("node-fetch");
const jsonDiff = require("json-diff");
index.js

Python

 # The Cloud Functions for Firebase SDK to set up triggers and logging.
from firebase_functions import remote_config_fn

# The Firebase Admin SDK to obtain access tokens.
import firebase_admin

app = firebase_admin.initialize_app()

import deepdiff
import requests
main.py

Em seguida, defina um gerenciador para o evento de atualização. O objeto do evento enviado para essa função contém metadados sobre uma atualização de modelo, como o novo número de versão e o horário da atualização. Você também pode recuperar o e-mail do usuário que fez a atualização, com um nome e uma imagem, se disponível.

Confira um exemplo de uma função de Remote Config que registra uma comparação entre cada uma das versões atualizadas e as versões que foram substituídas por elas. A função examina o campo número da versão do objeto de modelo e recupera a versão atual (recém-atualizada) junto com a versão imediatamente anterior:

Node.js

 exports.showconfigdiff = onConfigUpdated(async (event) => {
  try {
    // Obtain the access token from the Admin SDK
    const accessTokenObj = await admin.credential.applicationDefault()
        .getAccessToken();
    const accessToken = accessTokenObj.access_token;

    // Get the version number from the event object
    const remoteConfigApi = "https://firebaseremoteconfig.googleapis.com/v1/" +
        `projects/${app.options.projectId}/remoteConfig`;
    const currentVersion = event.data.versionNumber;
    const prevVersion = currentVersion - 1;
    const templatePromises = [];
    templatePromises.push(fetch(
        remoteConfigApi,
        {
          method: "POST",
          body: new URLSearchParams([["versionNumber", currentVersion + ""]]),
          headers: {Authorization: "Bearer " + accessToken},
        },
    ));
    templatePromises.push(fetch(
        remoteConfigApi,
        {
          method: "POST",
          body: new URLSearchParams([["versionNumber", prevVersion + ""]]),
          headers: {Authorization: "Bearer " + accessToken},
        },
    ));

    // Get the templates
    const responses = await Promise.all(templatePromises);
    const results = responses.map((r) => r.json());
    const currentTemplate = results[0];
    const previousTemplate = results[1];
    // Figure out the differences of the templates
    const diff = jsonDiff.diffString(previousTemplate, currentTemplate);
    // Log the difference
    logger.log(diff);
  } catch (error) {
    logger.error(error);
  }
});
index.js

Neste exemplo, usamos os módulos json-diff e request-promise para criar a comparação e desenvolver a solicitação a fim de receber o objeto de modelo.

Python

 @remote_config_fn.on_config_updated()
def showconfigdiff(event: remote_config_fn.CloudEvent[remote_config_fn.ConfigUpdateData]) -> None:
    """Log the diff of the most recent Remote Config template change."""

    # Obtain an access token from the Admin SDK
    access_token = app.credential.get_access_token().access_token

    # Get the version number from the event object
    current_version = int(event.data.version_number)

    # Figure out the differences between templates
    remote_config_api = ("https://firebaseremoteconfig.googleapis.com/v1/"
                         f"projects/{app.project_id}/remoteConfig")
    current_template = requests.get(remote_config_api,
                                    params={"versionNumber": current_version},
                                    headers={"Authorization": f"Bearer {access_token}"})
    previous_template = requests.get(remote_config_api,
                                     params={"versionNumber": current_version - 1},
                                     headers={"Authorization": f"Bearer {access_token}"})
    diff = deepdiff.DeepDiff(previous_template, current_template)

    # Log the difference
    print(diff.pretty())
main.py

Neste exemplo, usamos deepdiff para criar a comparação e requests para criar e desenvolver e enviar a solicitação a fim de receber o objeto de modelo.