Attivatori di Firebase Realtime Database

Con le funzioni Cloud Run, puoi gestire gli eventi in Firebase Realtime Database nello stesso Google Cloud progetto della funzione. Le funzioni Cloud Run consentono di eseguire operazioni di database con privilegi amministrativi completi e garantiscono che ogni modifica al database venga elaborata singolarmente. Puoi apportare modifiche a Firebase Realtime Database tramite l'SDK Firebase Admin.

In un ciclo di vita tipico, una funzione Firebase Realtime Database esegue le seguenti operazioni:

1. Attende le modifiche a una posizione specifica del database.

2. Si attiva quando si verifica un evento ed esegue le attività.

3. Riceve un oggetto dati che contiene un'istantanea dei dati archiviati nel documento specificato.

Tipi di evento

Functions ti consente di gestire gli eventi del database a due livelli di specificità. Puoi ascoltare in modo specifico solo gli eventi di creazione, aggiornamento o eliminazione oppure ascoltare qualsiasi tipo di modifica a un percorso. Le funzioni Cloud Run supportano i seguenti tipi di eventi per Realtime Database:

Specificare il percorso e l'istanza del database

Per controllare quando e dove deve essere attivata la funzione, devi specificare un percorso e, facoltativamente, un'istanza di database.

Percorso

Le specifiche del percorso corrispondono a tutte le scritture che interessano un percorso, incluse quelle che si verificano in qualsiasi punto sottostante. Se imposti il percorso della funzione come /foo/bar, corrisponde agli eventi in entrambe le seguenti posizioni:

 /foo/bar
 /foo/bar/baz/really/deep/path

In entrambi i casi, Firebase interpreta che l'evento si verifica alle ore /foo/bar e i dati dell'evento includono i dati vecchi e nuovi alle ore /foo/bar. Se i dati evento potrebbero essere di grandi dimensioni, valuta la possibilità di utilizzare più funzioni in percorsi più profondi anziché una singola funzione vicino alla radice del database. Per ottenere le prestazioni migliori, richiedi i dati al livello più profondo possibile.

Puoi specificare un componente del percorso come carattere jolly racchiudendolo tra parentesi graffe; foo/{bar} corrisponde a qualsiasi elemento secondario di /foo. I valori di questi componenti del percorso con caratteri jolly sono disponibili nell'oggetto event.params della tua funzione. In questo esempio, il valore è disponibile come event.params.bar.

I percorsi con caratteri jolly possono corrispondere a più eventi di una singola scrittura. Un inserto di:

{
  "foo": {
    "hello": "world",
    "firebase": "functions"
  }
}

corrisponde due volte al percorso /foo/{bar}: una volta con "hello": "world" e una volta con "firebase": "functions".

Istanza

Quando utilizzi la console Google Cloud , devi specificare l'istanza del database.

Quando utilizzi Google Cloud CLI, l'istanza deve essere specificata come parte della stringa --trigger-resource.

Ad esempio, il seguente codice utilizzerebbe quanto segue nella stringa --trigger-resource:

--trigger-resource projects/_/instances/DATABASE_INSTANCE/refs/PATH

Struttura dell'evento

Quando gestisci un evento Realtime Database, l'oggetto data contiene due proprietà fornite in formato oggetto JSON:

• data: uno snapshot dei dati acquisiti prima dell'evento che ha attivato la funzione.

• delta: uno snapshot dei dati acquisiti dopo l'evento che ha attivato la funzione.

Esempio di codice

/**
 * Background Function triggered by a change to a Firebase RTDB reference.
 *
 * @param {!Object} event The Cloud Functions event.
 * @param {!Object} context The Cloud Functions event context.
 */
exports.helloRTDB = (event, context) => {
  const triggerResource = context.resource;

  console.log(`Function triggered by change to: ${triggerResource}`);
  console.log(`Admin?: ${!!context.auth.admin}`);
  console.log('Delta:');
  console.log(JSON.stringify(event.delta, null, 2));
};

import json

def hello_rtdb(data, context):
    """Triggered by a change to a Firebase RTDB reference.
    Args:
        data (dict): The event payload.
        context (google.cloud.functions.Context): Metadata for the event.
    """
    trigger_resource = context.resource

    print("Function triggered by change to: %s" % trigger_resource)
    print("Admin?: %s" % data.get("admin", False))
    print("Delta:")
    print(json.dumps(data["delta"]))

// Package p contains a Cloud Function triggered by a Firebase Realtime Database
// event.
package p

import (
	"context"
	"fmt"
	"log"

	"cloud.google.com/go/functions/metadata"
)

// RTDBEvent is the payload of a RTDB event.
type RTDBEvent struct {
	Data  interface{} `json:"data"`
	Delta interface{} `json:"delta"`
}

// HelloRTDB handles changes to a Firebase RTDB.
func HelloRTDB(ctx context.Context, e RTDBEvent) error {
	meta, err := metadata.FromContext(ctx)
	if err != nil {
		return fmt.Errorf("metadata.FromContext: %w", err)
	}
	log.Printf("Function triggered by change to: %v", meta.Resource)
	log.Printf("%+v", e)
	return nil
}

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 FirebaseRtdb implements RawBackgroundFunction {
  private static final Logger logger = Logger.getLogger(FirebaseRtdb.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) {
    logger.info("Function triggered by change to: " + context.resource());

    JsonObject body = gson.fromJson(json, JsonObject.class);

    boolean isAdmin = false;
    if (body != null && body.has("auth")) {
      JsonObject authObj = body.getAsJsonObject("auth");
      isAdmin = authObj.has("admin") && authObj.get("admin").getAsBoolean();
    }

    logger.info("Admin?: " + isAdmin);

    if (body != null && body.has("delta")) {
      logger.info("Delta:");
      logger.info(body.get("delta").toString());
    }
  }
}

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

namespace FirebaseRtdb;

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

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

    public Task HandleAsync(CloudEvent cloudEvent, ReferenceEventData data, CancellationToken cancellationToken)
    {
        _logger.LogInformation("Function triggered by change to {subject}", cloudEvent.Subject);
        _logger.LogInformation("Delta: {delta}", data.Delta);

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

require "functions_framework"

# Triggered by a change to a Firebase RTDB document.
FunctionsFramework.cloud_event "hello_rtdb" 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 `data` field.
  payload = event.data

  logger.info "Function triggered by change to: #{event.source}"
  logger.info "Admin?: #{payload.fetch 'admin', false}"
  logger.info "Delta: #{payload['delta']}"
end

use Google\CloudFunctions\CloudEvent;

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

    fwrite($log, 'Event: ' . $cloudevent->getId() . PHP_EOL);

    $data = $cloudevent->getData();
    $resource = $data['resource'] ?? '<null>';

    fwrite($log, 'Function triggered by change to: ' . $resource . PHP_EOL);

    $isAdmin = isset($data['auth']['admin']) && $data['auth']['admin'] == true;

    fwrite($log, 'Admin?: ' . var_export($isAdmin, true) . PHP_EOL);
    fwrite($log, 'Delta: ' . json_encode($data['delta'] ?? '') . PHP_EOL);
}

Deployment della funzione

Il seguente comando gcloud esegue il deployment di una funzione che verrà attivata dagli eventi create nel percorso /messages/{pushId}/original:

gcloud functions deploy FUNCTION_NAME \
  --no-gen2 \
  --entry-point ENTRY_POINT \
  --trigger-event providers/google.firebase.database/eventTypes/ref.create \
  --trigger-resource projects/_/instances/DATABASE_INSTANCE/refs/messages/{pushId}/original \
  --runtime RUNTIME