Estendi Cloud Firestore con Cloud Functions (2a generazione)

Con Cloud Functions, puoi eseguire il deployment del codice per gestire gli eventi attivati da modifiche nel database Cloud Firestore. In questo modo puoi aggiungere facilmente funzionalità lato server alla tua app senza dover eseguire i tuoi server.

Cloud Functions (2ª gen.)

Basata su Cloud Run e Eventarc, Cloud Functions for Firebase (2ª gen.) offre un'infrastruttura più potente, un controllo avanzato su prestazioni e scalabilità e un maggiore controllo sul runtime delle funzioni. Per saperne di più sulla versione 2, consulta Cloud Functions per Firebase (2ª gen.). Per saperne di più sulla versione 1, consulta Estendere Cloud Firestore con Cloud Functions.

Attivatori di funzioni Cloud Firestore

L'SDK Cloud Functions for Firebase esporta i seguenti trigger di evento Cloud Firestore per consentirti di creare gestori legati a eventi Cloud Firestore specifici:

Node.js

Tipo di evento	Trigger
onDocumentCreated	Si attiva quando viene scritto per la prima volta in un documento.
onDocumentUpdated	Viene attivato quando esiste già un documento e un valore è stato modificato.
onDocumentDeleted	Si attiva quando un documento viene eliminato.
onDocumentWritten	Si attiva quando viene attivato onDocumentCreated, onDocumentUpdated o onDocumentDeleted.
onDocumentCreatedWithAuthContext	onDocumentCreated con informazioni di autenticazione aggiuntive
onDocumentWrittenWithAuthContext	onDocumentWritten con informazioni di autenticazione aggiuntive
onDocumentDeletedWithAuthContext	onDocumentDeleted con informazioni di autenticazione aggiuntive
onDocumentUpdatedWithAuthContext	onDocumentUpdated con informazioni di autenticazione aggiuntive

Python (anteprima)

Tipo di evento	Trigger
on_document_created	Si attiva quando viene scritto per la prima volta in un documento.
on_document_updated	Viene attivato quando esiste già un documento e un valore è stato modificato.
on_document_deleted	Si attiva quando un documento viene eliminato.
on_document_written	Si attiva quando viene attivato on_document_created, on_document_updated o on_document_deleted.
on_document_created_with_auth_context	on_document_created con informazioni di autenticazione aggiuntive
on_document_updated_with_auth_context	on_document_updated con informazioni di autenticazione aggiuntive
on_document_deleted_with_auth_context	on_document_deleted con informazioni di autenticazione aggiuntive
on_document_written_with_auth_context	on_document_written con informazioni di autenticazione aggiuntive

Gli eventi Cloud Firestore vengono attivati solo in seguito alle modifiche del documento. Un aggiornamento a un documento Cloud Firestore in cui i dati rimangono invariati (una scrittura senza operazioni) non genera un evento di aggiornamento o scrittura. Non è possibile aggiungere eventi a campi specifici.

Se non hai ancora un progetto abilitato per Cloud Functions for Firebase, leggi Iniziare a utilizzare Cloud Functions for Firebase (2ª gen.) per configurare il tuo progetto Cloud Functions for Firebase.

Scrivere funzioni attivate da Cloud Firestore

Definire un attivatore di funzione

Per definire un attivatore Cloud Firestore, specifica un percorso del documento e un tipo di evento:

Node.js

import {
  onDocumentWritten,
  onDocumentCreated,
  onDocumentUpdated,
  onDocumentDeleted,
  Change,
  FirestoreEvent
} from "firebase-functions/v2/firestore";

exports.myfunction = onDocumentWritten("my-collection/{docId}", (event) => {
   /* ... */ 
});

Python (anteprima)

from firebase_functions.firestore_fn import (
  on_document_created,
  on_document_deleted,
  on_document_updated,
  on_document_written,
  Event,
  Change,
  DocumentSnapshot,
)

@on_document_created(document="users/{userId}")
def myfunction(event: Event[DocumentSnapshot]) -> None:

I percorsi dei documenti possono fare riferimento a un documento specifico o a un pattern con caratteri jolly.

Specifica un singolo documento

Se vuoi attivare un evento per qualsiasi modifica a un documento specifico, puoi utilizzare la seguente funzione.

Node.js

import {
  onDocumentWritten,
  Change,
  FirestoreEvent
} from "firebase-functions/v2/firestore";

exports.myfunction = onDocumentWritten("users/marie", (event) => {
  // Your code here
});

Python (anteprima)

from firebase_functions.firestore_fn import (
  on_document_written,
  Event,
  Change,
  DocumentSnapshot,
)

@on_document_written(document="users/marie")
def myfunction(event: Event[Change[DocumentSnapshot]]) -> None:

Specificare un gruppo di documenti utilizzando i caratteri jolly

Se vuoi associare un attivatore a un gruppo di documenti, ad esempio un documento di una determinata raccolta, utilizza un {wildcard} al posto dell'ID documento:

Node.js

import {
  onDocumentWritten,
  Change,
  FirestoreEvent
} from "firebase-functions/v2/firestore";

exports.myfunction = onDocumentWritten("users/{userId}", (event) => {
  // If we set `/users/marie` to {name: "Marie"} then
  // event.params.userId == "marie"
  // ... and ...
  // event.data.after.data() == {name: "Marie"}
});

Python (anteprima)

from firebase_functions.firestore_fn import (
  on_document_written,
  Event,
  Change,
  DocumentSnapshot,
)

@on_document_written(document="users/{userId}")
def myfunction(event: Event[Change[DocumentSnapshot]]) -> None:
  # If we set `/users/marie` to {name: "Marie"} then
  event.params["userId"] == "marie"  # True
  # ... and ...
  event.data.after.to_dict() == {"name": "Marie"}  # True

In questo esempio, quando un campo di qualsiasi documento in users viene modificato, corrisponde a un carattere jolly chiamato userId.

Se un documento in users ha sottocollezioni e un campo in uno di questi documenti viene modificato, il carattere jolly userId non viene attivato.

Le corrispondenze con caratteri jolly vengono estratte dal percorso del documento e memorizzate in event.params. Puoi definire tutti i caratteri jolly che vuoi per sostituire ID raccolta o documento espliciti, ad esempio:

Node.js

import {
  onDocumentWritten,
  Change,
  FirestoreEvent
} from "firebase-functions/v2/firestore";

exports.myfunction = onDocumentWritten("users/{userId}/{messageCollectionId}/{messageId}", (event) => {
    // If we set `/users/marie/incoming_messages/134` to {body: "Hello"} then
    // event.params.userId == "marie";
    // event.params.messageCollectionId == "incoming_messages";
    // event.params.messageId == "134";
    // ... and ...
    // event.data.after.data() == {body: "Hello"}
});

Python (anteprima)

from firebase_functions.firestore_fn import (
  on_document_written,
  Event,
  Change,
  DocumentSnapshot,
)

@on_document_written(document="users/{userId}/{messageCollectionId}/{messageId}")
def myfunction(event: Event[Change[DocumentSnapshot]]) -> None:
  # If we set `/users/marie/incoming_messages/134` to {body: "Hello"} then
  event.params["userId"] == "marie"  # True
  event.params["messageCollectionId"] == "incoming_messages"  # True
  event.params["messageId"] == "134"  # True
  # ... and ...
  event.data.after.to_dict() == {"body": "Hello"}

L'attivatore deve sempre puntare a un documento, anche se utilizzi un'espressione generica. Ad esempio, users/{userId}/{messageCollectionId} non è valido perché {messageCollectionId} è una raccolta. Tuttavia, users/{userId}/{messageCollectionId}/{messageId} è valido perché {messageId} indicherà sempre un documento.

Trigger evento

Attivare una funzione quando viene creato un nuovo documento

Puoi attivare una funzione da eseguire ogni volta che viene creato un nuovo documento in una raccolta. Questa funzione di esempio si attiva ogni volta che viene aggiunto un nuovo profilo utente:

Node.js

import {
  onDocumentCreated,
  Change,
  FirestoreEvent
} from "firebase-functions/v2/firestore";

exports.createuser = onDocumentCreated("users/{userId}", (event) => {
    // Get an object representing the document
    // e.g. {'name': 'Marie', 'age': 66}
    const snapshot = event.data;
    if (!snapshot) {
        console.log("No data associated with the event");
        return;
    }
    const data = snapshot.data();

    // access a particular field as you would any JS property
    const name = data.name;

    // perform more operations ...
});

Per ulteriori informazioni sull'autenticazione, utilizza onDocumentCreatedWithAuthContext.

Python (anteprima)

from firebase_functions.firestore_fn import (
  on_document_created,
  Event,
  DocumentSnapshot,
)

@on_document_created(document="users/{userId}")
def myfunction(event: Event[DocumentSnapshot]) -> None:
  # Get a dictionary representing the document
  # e.g. {'name': 'Marie', 'age': 66}
  new_value = event.data.to_dict()

  # Access a particular field as you would any dictionary
  name = new_value["name"]

  # Perform more operations ...

Attivare una funzione quando un documento viene aggiornato

Puoi anche attivare l'esecuzione di una funzione quando un documento viene aggiornato. Questa funzione di esempio viene attivata se un utente modifica il proprio profilo:

Node.js

import {
  onDocumentUpdated,
  Change,
  FirestoreEvent
} from "firebase-functions/v2/firestore";

exports.updateuser = onDocumentUpdated("users/{userId}", (event) => {
    // Get an object representing the document
    // e.g. {'name': 'Marie', 'age': 66}
    const newValue = event.data.after.data();

    // access a particular field as you would any JS property
    const name = newValue.name;

    // perform more operations ...
});

Per ulteriori informazioni sull'autenticazione, utilizza onDocumentUpdatedWithAuthContext.

Python (anteprima)

from firebase_functions.firestore_fn import (
  on_document_updated,
  Event,
  Change,
  DocumentSnapshot,
)

@on_document_updated(document="users/{userId}")
def myfunction(event: Event[Change[DocumentSnapshot]]) -> None:
  # Get a dictionary representing the document
  # e.g. {'name': 'Marie', 'age': 66}
  new_value = event.data.after.to_dict()

  # Access a particular field as you would any dictionary
  name = new_value["name"]

  # Perform more operations ...

Attivare una funzione quando viene eliminato un documento

Puoi anche attivare una funzione quando un documento viene eliminato. Questa funzione di esempio viene attivata quando un utente elimina il proprio profilo utente:

Node.js

import {
  onDocumentDeleted,
  Change,
  FirestoreEvent
} from "firebase-functions/v2/firestore";

exports.deleteuser = onDocumentDeleted("users/{userId}", (event) => {
    // Get an object representing the document
    // e.g. {'name': 'Marie', 'age': 66}
    const snap =  event.data;
    const data =  snap.data();

    // perform more operations ...
});

Per ulteriori informazioni sull'autenticazione, utilizza onDocumentDeletedWithAuthContext.

Python (anteprima)

from firebase_functions.firestore_fn import (
  on_document_deleted,
  Event,
  DocumentSnapshot,
)

@on_document_deleted(document="users/{userId}")
def myfunction(event: Event[DocumentSnapshot|None]) -> None:
  # Perform more operations ...

Attivare una funzione per tutte le modifiche apportate a un documento

Se non ti interessa il tipo di evento attivato, puoi monitorare tutte le modifiche in un documento Cloud Firestore utilizzando l'attivatore evento "documento scritto". Questa funzione di esempio viene attivata se un utente viene creato, aggiornato o eliminato:

Node.js

import {
  onDocumentWritten,
  Change,
  FirestoreEvent
} from "firebase-functions/v2/firestore";

exports.modifyuser = onDocumentWritten("users/{userId}", (event) => {
    // Get an object with the current document values.
    // If the document does not exist, it was deleted
    const document =  event.data.after.data();

    // Get an object with the previous document values
    const previousValues =  event.data.before.data();

    // perform more operations ...
});

Per ulteriori informazioni sull'autenticazione, utilizza onDocumentWrittenWithAuthContext.

Python (anteprima)

from firebase_functions.firestore_fn import (
  on_document_written,
  Event,
  Change,
  DocumentSnapshot,
)

@on_document_written(document="users/{userId}")
def myfunction(event: Event[Change[DocumentSnapshot | None]]) -> None:
  # Get an object with the current document values.
  # If the document does not exist, it was deleted.
  document = (event.data.after.to_dict()
              if event.data.after is not None else None)

  # Get an object with the previous document values.
  # If the document does not exist, it was newly created.
  previous_values = (event.data.before.to_dict()
                     if event.data.before is not None else None)

  # Perform more operations ...

Lettura e scrittura dei dati

Quando viene attivata, una funzione fornisce un'istantanea dei dati relativi all'evento. Puoi utilizzare questo snapshot per leggere o scrivere nel documento che ha attivato l'evento oppure utilizzare l'SDK Admin Firebase per accedere ad altre parti del database.

Dati evento

Lettura dei dati

Quando viene attivata una funzione, potresti voler recuperare i dati da un documento aggiornato o prima dell'aggiornamento. Puoi recuperare i dati precedenti utilizzando event.data.before, che contiene lo snapshot del documento prima dell'aggiornamento. Analogamente, event.data.after contiene lo stato dello snapshot del documento dopo l'aggiornamento.

Node.js

exports.updateuser2 = onDocumentUpdated("users/{userId}", (event) => {
    // Get an object with the current document values.
    // If the document does not exist, it was deleted
    const newValues =  event.data.after.data();

    // Get an object with the previous document values
    const previousValues =  event.data.before.data();
});

Python (anteprima)

@on_document_updated(document="users/{userId}")
def myfunction(event: Event[Change[DocumentSnapshot]]) -> None:
  # Get an object with the current document values.
  new_value = event.data.after.to_dict()

  # Get an object with the previous document values.
  prev_value = event.data.before.to_dict()

Puoi accedere alle proprietà come faresti in qualsiasi altro oggetto. In alternativa, puoi utilizzare la funzione get per accedere a campi specifici:

Node.js

// Fetch data using standard accessors
const age = event.data.after.data().age;
const name = event.data.after.data()['name'];

// Fetch data using built in accessor
const experience = event.data.after.data.get('experience');

Python (anteprima)

# Get the value of a single document field.
age = event.data.after.get("age")

# Convert the document to a dictionary.
age = event.data.after.to_dict()["age"]

Scrittura dei dati

Ogni chiamata di funzione è associata a un documento specifico nel databaseCloud Firestore. Puoi accedere al documento nell'istantanea restituita alla funzione.

Il riferimento al documento include metodi come update(), set() e remove() in modo da poter modificare il documento che ha attivato la funzione.

Node.js

import { onDocumentUpdated } from "firebase-functions/v2/firestore";

exports.countnamechanges = onDocumentUpdated('users/{userId}', (event) => {
  // Retrieve the current and previous value
  const data = event.data.after.data();
  const previousData = event.data.before.data();

  // We'll only update if the name has changed.
  // This is crucial to prevent infinite loops.
  if (data.name == previousData.name) {
    return null;
  }

  // Retrieve the current count of name changes
  let count = data.name_change_count;
  if (!count) {
    count = 0;
  }

  // Then return a promise of a set operation to update the count
  return data.after.ref.set({
    name_change_count: count + 1
  }, {merge: true});

});

Python (anteprima)

@on_document_updated(document="users/{userId}")
def myfunction(event: Event[Change[DocumentSnapshot]]) -> None:
  # Get the current and previous document values.
  new_value = event.data.after
  prev_value = event.data.before

  # We'll only update if the name has changed.
  # This is crucial to prevent infinite loops.
  if new_value.get("name") == prev_value.get("name"):
      return

  # Retrieve the current count of name changes
  count = new_value.to_dict().get("name_change_count", 0)

  # Update the count
  new_value.reference.update({"name_change_count": count + 1})

Avviso: ogni volta che scrivi nello stesso documento che ha attivato una funzione, rischia di creare un ciclo infinito. Fai attenzione e assicurati di uscire in sicurezza dalla funzione quando non è necessaria alcuna modifica.

Accedere alle informazioni di autenticazione utente

Se utilizzi uno dei seguenti tipi di eventi, puoi accedere alle informazioni di autenticazione utente relative al principale che ha attivato l'evento. Queste informazioni si aggiungono a quelle restituite nell'evento base.

Node.js

• onDocumentCreatedWithAuthContext
• onDocumentWrittenWithAuthContext
• onDocumentDeletedWithAuthContext
• onDocumentUpdatedWithAuthContext

Python (anteprima)

• on_document_created_with_auth_context
• on_document_updated_with_auth_context
• on_document_deleted_with_auth_context
• on_document_written_with_auth_context

Per informazioni sui dati disponibili nel contesto di autenticazione, consulta Contesto di autenticazione. L'esempio seguente mostra come recuperare le informazioni di autenticazione:

Node.js

import { onDocumentWrittenWithAuthContext } from "firebase-functions/v2/firestore"

exports.syncUser = onDocumentWrittenWithAuthContext("users/{userId}", (event) => {
    const snapshot = event.data.after;
    if (!snapshot) {
        console.log("No data associated with the event");
        return;
    }
    const data = snapshot.data();

    // retrieve auth context from event
    const { authType, authId } = event;

    let verified = false;
    if (authType === "system") {
      // system-generated users are automatically verified
      verified = true;
    } else if (authType === "unknown" || authType === "unauthenticated") {
      // admin users from a specific domain are verified
      if (authId.endsWith("@example.com")) {
        verified = true;
      }
    }

    return data.after.ref.set({
        created_by: authId,
        verified,
    }, {merge: true}); 
}); 

Python (anteprima)

@on_document_updated_with_auth_context(document="users/{userId}")
def myfunction(event: Event[Change[DocumentSnapshot]]) -> None:

  # Get the current and previous document values.
  new_value = event.data.after
  prev_value = event.data.before

  # Get the auth context from the event
  user_auth_type = event.auth_type
  user_auth_id = event.auth_id

Dati esterni all'evento di attivazione

Cloud Functions vengono eseguite in un ambiente attendibile. Sono autorizzati come account di servizio nel tuo progetto e puoi eseguire letture e scrittura utilizzando l'SDK Firebase Admin:

Node.js

const { initializeApp } = require('firebase-admin/app');
const { getFirestore, Timestamp, FieldValue } = require('firebase-admin/firestore');

initializeApp();
const db = getFirestore();

exports.writetofirestore = onDocumentWritten("some/doc", (event) => {
    db.doc('some/otherdoc').set({ ... });
  });

  exports.writetofirestore = onDocumentWritten('users/{userId}', (event) => {
    db.doc('some/otherdoc').set({
      // Update otherdoc
    });
  });

Python (anteprima)

from firebase_admin import firestore, initialize_app
import google.cloud.firestore

initialize_app()

@on_document_written(document="some/doc")
def myfunction(event: Event[Change[DocumentSnapshot | None]]) -> None:
  firestore_client: google.cloud.firestore.Client = firestore.client()
  firestore_client.document("another/doc").set({
      # ...
  })

Nota: le letture e le scritture eseguite in Cloud Functions non sono controllate dalle tue regole di sicurezza e possono accedere a qualsiasi parte del database.

Limitazioni

Tieni presenti le seguenti limitazioni per gli attivatori Cloud Firestore per Cloud Functions:

• Cloud Functions (1ª gen.) richiede un database "(default)" esistente in modalità nativa di Firestore. Non supporta i database Cloud Firestore con nome o la modalità Datastore. Utilizza Cloud Functions (2ª gen.) per configurare gli eventi in questi casi.
• L'ordine non è garantito. Le variazioni rapide possono attivare le chiamate di funzione in un ordine imprevisto.
• Gli eventi vengono inviati almeno una volta, ma un singolo evento può comportare più chiamate di funzione. Evita di fare affidamento su meccanismi di esecuzione esattamente una volta e scrivi funzioni idempotenti.
• Cloud Firestore in modalità Datastore richiede Cloud Functions (2ª gen.). Cloud Functions (1ª gen.) non supporta la modalità Datastore.
• Un trigger è associato a un singolo database. Non puoi creare un attivatore che corrisponda a più database.
• L'eliminazione di un database non comporta l'eliminazione automatica degli attivatori per quel database. L'attivatore interrompe l'invio di eventi, ma continua a esistere finché non lo elimini.
• Se un evento con corrispondenza supera le dimensioni massime della richiesta, l'evento potrebbe non essere inviato a Cloud Functions (1ª gen.).
  • Gli eventi non inviati a causa delle dimensioni della richiesta vengono registrati nei log della piattaforma e conteggiati ai fini dell'utilizzo dei log per il progetto.
  • Puoi trovare questi log in Esplora log con il messaggio "Impossibile inviare l'evento alla funzione Cloud perché le dimensioni superano il limite per 1ª generazione." di gravità error. Puoi trovare il nome della funzione nel campo functionName. Se il campo receiveTimestamp è ancora entro un'ora da adesso, puoi dedurre i contenuti effettivi dell'evento leggendo il documento in questione con uno snapshot prima e dopo il timestamp.
  • Per evitare questa cadenza, puoi:
    • Esegui la migrazione e l'upgrade a Cloud Functions (2ª gen.)
    • Riduci le dimensioni del documento
    • Eliminare l'Cloud Functions in questione
  • Puoi disattivare il logging stesso utilizzando le esclusioni, ma tieni presente che gli eventi in violazione non verranno comunque inviati.