Déclencheurs Firebase Remote Config

Cloud Run Functions peut être déclenché en réponse aux modifications de Firebase Remote Config dans le même projet Google Cloud contenant la fonction. Vous pouvez ainsi modifier le comportement et l'apparence de votre application sans publier de mise à jour.

Types d'événement

Firebase Remote Config peut déclencher des fonctions en réponse à l'événement remoteconfig.update.

Type d'événement Déclencheur
remoteconfig.update Déclenché lorsque le modèle Remote Config est mis à jour.

Structure de l'événement

Les données d'événement sont fournies en tant qu'objet remoteConfig transformé.

Exemple :

{
  "updateType": "FORCED_UPDATE",
  "updateOrigin": "CONSOLE",
  "versionNumber": 1
}

Exemple de code

Node.js

/**
 * Background Function triggered by a change to a Firebase Remote Config value.
 *
 * @param {object} event The Cloud Functions event.
 */
exports.helloRemoteConfig = event => {
  console.log(`Update type: ${event.updateType}`);
  console.log(`Origin: ${event.updateOrigin}`);
  console.log(`Version: ${event.versionNumber}`);
};

Python

def hello_remote_config(data, context):
    """Triggered by a change to a Firebase Remote Config value.
    Args:
           data (dict): The event payload.
           context (google.cloud.functions.Context): Metadata for the event.
    """
    print(f'Update type: {data["updateType"]}')
    print(f'Origin: {data["updateOrigin"]}')
    print(f'Version: {data["versionNumber"]}')

Go


// Package helloworld provides a set of Cloud Functions samples.
package helloworld

import (
	"context"
	"log"
)

// A RemoteConfigEvent is an event triggered by Firebase Remote Config.
type RemoteConfigEvent struct {
	UpdateOrigin string `json:"updateOrigin"`
	UpdateType   string `json:"updateType"`
	UpdateUser   struct {
		Email    string `json:"email"`
		ImageURL string `json:"imageUrl"`
		Name     string `json:"name"`
	} `json:"updateUser"`
	VersionNumber string `json:"versionNumber"`
}

// HelloRemoteConfig handles Firebase Remote Config events.
func HelloRemoteConfig(ctx context.Context, e RemoteConfigEvent) error {
	log.Printf("Update type: %v", e.UpdateType)
	log.Printf("Origin: %v", e.UpdateOrigin)
	log.Printf("Version: %v", e.VersionNumber)
	return nil
}

Java

import com.google.cloud.functions.Context;
import com.google.cloud.functions.RawBackgroundFunction;
import com.google.gson.Gson;
import com.google.gson.JsonObject;
import java.util.logging.Logger;

public class FirebaseRemoteConfig implements RawBackgroundFunction {
  private static final Logger logger = Logger.getLogger(FirebaseRemoteConfig.class.getName());

  // Use GSON (https://github.com/google/gson) to parse JSON content.
  private static final Gson gson = new Gson();

  @Override
  public void accept(String json, Context context) {
    JsonObject body = gson.fromJson(json, JsonObject.class);

    if (body != null) {
      if (body.has("updateType")) {
        logger.info("Update type: " + body.get("updateType").getAsString());
      }
      if (body.has("updateOrigin")) {
        logger.info("Origin: " + body.get("updateOrigin").getAsString());
      }
      if (body.has("versionNumber")) {
        logger.info("Version: " + body.get("versionNumber").getAsString());
      }
    }
  }
}

C#

using CloudNative.CloudEvents;
using Google.Cloud.Functions.Framework;
using Google.Events.Protobuf.Firebase.RemoteConfig.V1;
using Microsoft.Extensions.Logging;
using System.Threading;
using System.Threading.Tasks;

namespace FirebaseRemoteConfig;

public class Function : ICloudEventFunction<RemoteConfigEventData>
{
    private readonly ILogger _logger;

    public Function(ILogger<Function> logger) =>
        _logger = logger;

    public Task HandleAsync(CloudEvent cloudEvent, RemoteConfigEventData data, CancellationToken cancellationToken)
    {
        _logger.LogInformation("Update type: {origin}", data.UpdateType);
        _logger.LogInformation("Update origin: {origin}", data.UpdateOrigin);
        _logger.LogInformation("Version number: {version}", data.VersionNumber);

        // In this example, we don't need to perform any asynchronous operations, so the
        // method doesn't need to be declared async.
        return Task.CompletedTask;
    }
}

Ruby

require "functions_framework"

# Triggered by a change to a Firebase Remote Config value
FunctionsFramework.cloud_event "hello_remote_config" do |event|
  # Event-triggered Ruby functions receive a CloudEvents::Event::V1 object.
  # See https://cloudevents.github.io/sdk-ruby/latest/CloudEvents/Event/V1.html
  # The Firebase event payload can be obtained from the event data.
  payload = event.data

  logger.info "Update type: #{payload['updateType']}"
  logger.info "Origin: #{payload['updateOrigin']}"
  logger.info "Version: #{payload['versionNumber']}"
end

PHP


use Google\CloudFunctions\CloudEvent;

function firebaseRemoteConfig(CloudEvent $cloudevent)
{
    $log = fopen(getenv('LOGGER_OUTPUT') ?: 'php://stderr', 'wb');

    $data = $cloudevent->getData();

    fwrite($log, 'Update type: ' . $data['updateType'] . PHP_EOL);
    fwrite($log, 'Origin: ' . $data['updateOrigin'] . PHP_EOL);
    fwrite($log, 'Version: ' . $data['versionNumber'] . PHP_EOL);
}

Déployer votre fonction

Pour déployer votre fonction, vous devez spécifier le type d'événement google.firebase.remoteconfig.update.

La commande gcloud suivante déploie une fonction qui est déclenchée par un événement Firebase Remote Config :

gcloud functions deploy FUNCTION_NAME \
  --no-gen2 \
  --entry-point ENTRY_POINT \
  --trigger-event google.firebase.remoteconfig.update \
  --runtime RUNTIME
Argument Description
FUNCTION_NAME Nom enregistré de la fonction Cloud Run que vous déployez. Il peut s'agir du nom d'une fonction dans votre code source ou d'une chaîne arbitraire. Si FUNCTION_NAME est une chaîne arbitraire, vous devez alors inclure l'option --entry-point.
--entry-point ENTRY_POINT Nom d'une fonction ou d'une classe dans votre code source. Ce paramètre est facultatif, sauf si vous n'avez pas utilisé FUNCTION_NAME pour spécifier quelle fonction de votre code source exécuter lors du déploiement. Dans ce cas, vous devez utiliser --entry-point pour fournir le nom de la fonction exécutable.
--trigger-event google.firebase.remoteconfig.update Déclenchez la fonction lors des événements de mise à jour de Firebase Remote Config.
--runtime RUNTIME Nom de l'environnement d'exécution que vous utilisez. Pour obtenir une liste complète, consultez la documentation de référence sur gcloud.