Con Cloud Functions, puoi gestire gli eventi in Cloud Firestore senza dover aggiornare il codice client. Puoi apportare modifiche a Cloud Firestore tramite dell'istantanea documento o tramite SDK Admin.
In un ciclo di vita tipico, una funzione Cloud Firestore esegue le seguenti operazioni:
- Attende le modifiche a un determinato documento.
- Si attiva quando si verifica un evento ed esegue le sue attività.
- Riceve un oggetto dati contenente un'istantanea dei dati archiviati nel documento specificato. Per gli eventi di scrittura o aggiornamento, contiene due snapshot che rappresentano lo stato dei dati prima e dopo l'evento di attivazione.
Distanza tra la località dell'istanza Firestore e la località della funzione può creare una latenza di rete significativa. Per ottimizzare il rendimento, valuta la possibilità di specificare la posizione della funzione, ove applicabile.
Trigger delle funzioni Cloud Firestore
L'SDK Cloud Functions for Firebase esporta un oggetto functions.firestore
che consente di creare gestori legati a eventi Cloud Firestore specifici.
Tipo di evento | Trigger |
---|---|
onCreate |
Si attiva quando un documento viene scritto per la prima volta. |
onUpdate |
Viene attivato quando esiste già un documento e un valore è stato modificato. |
onDelete |
Viene attivato quando viene eliminato un documento con dati. |
onWrite |
Si attiva quando vengono attivati onCreate , onUpdate o onDelete . |
Se non hai ancora un progetto abilitato per Cloud Functions for Firebase, leggi Guida introduttiva: scrivi ed esegui il deployment delle tue prime funzioni per configurare e impostare il tuo progetto Cloud Functions for Firebase.
Scrittura di funzioni attivate da Cloud Firestore
Definire un attivatore della funzione
Per definire un trigger di Cloud Firestore, specifica un percorso del documento e un tipo di evento:
Node.js
const functions = require('firebase-functions');
exports.myFunction = functions.firestore
.document('my-collection/{docId}')
.onWrite((change, context) => { /* ... */ });
I percorsi dei documenti possono fare riferimento a un documento specifico o un pattern con caratteri jolly.
Specifica un singolo documento
Se vuoi attivare un evento per qualsiasi modifica a un documento specifico, puoi usare la funzione che segue.
Node.js
// Listen for any change on document `marie` in collection `users` exports.myFunctionName = functions.firestore .document('users/marie').onWrite((change, context) => { // ... Your code here });
Specifica un gruppo di documenti utilizzando caratteri jolly
Se vuoi associare un attivatore a un gruppo di documenti, ad esempio un documento di una determinata raccolta, utilizza {wildcard}
al posto dell'ID documento:
Node.js
// Listen for changes in all documents in the 'users' collection exports.useWildcard = functions.firestore .document('users/{userId}') .onWrite((change, context) => { // If we set `/users/marie` to {name: "Marie"} then // context.params.userId == "marie" // ... and ... // change.after.data() == {name: "Marie"} });
In questo esempio, quando viene modificato qualsiasi campo di qualsiasi documento in users
, viene restituito
un carattere jolly denominato userId
.
Se un documento in users
ha sottocollezioni e un campo in uno dei documenti di queste sottocollezioni viene modificato, il carattere jolly userId
non viene attivato.
Le corrispondenze con caratteri jolly vengono estratte dal percorso del documento e memorizzate in context.params
.
Puoi definire quanti caratteri jolly vuoi sostituire la raccolta esplicita
o ID documento, ad esempio:
Node.js
// Listen for changes in all documents in the 'users' collection and all subcollections exports.useMultipleWildcards = functions.firestore .document('users/{userId}/{messageCollectionId}/{messageId}') .onWrite((change, context) => { // If we set `/users/marie/incoming_messages/134` to {body: "Hello"} then // context.params.userId == "marie"; // context.params.messageCollectionId == "incoming_messages"; // context.params.messageId == "134"; // ... and ... // change.after.data() == {body: "Hello"} });
Trigger di eventi
Attiva 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 utilizzando un gestore onCreate()
con un carattere jolly.
Questa funzione di esempio chiama createUser
ogni volta che viene aggiunto un nuovo profilo utente:
Node.js
exports.createUser = functions.firestore .document('users/{userId}') .onCreate((snap, context) => { // Get an object representing the document // e.g. {'name': 'Marie', 'age': 66} const newValue = snap.data(); // access a particular field as you would any JS property const name = newValue.name; // perform desired operations ... });
Attivare una funzione quando un documento viene aggiornato
Puoi anche attivare l'esecuzione di una funzione quando un documento viene aggiornato utilizzando la funzione onUpdate()
con un'espressione generica. Questa funzione di esempio chiama updateUser
se un utente cambia il proprio profilo:
Node.js
exports.updateUser = functions.firestore .document('users/{userId}') .onUpdate((change, context) => { // Get an object representing the document // e.g. {'name': 'Marie', 'age': 66} const newValue = change.after.data(); // ...or the previous value before this update const previousValue = change.before.data(); // access a particular field as you would any JS property const name = newValue.name; // perform desired operations ... });
Attivare una funzione quando viene eliminato un documento
Puoi attivare una funzione anche quando un documento viene eliminato utilizzando il metodo
Funzione onDelete()
con un carattere jolly. Questo esempio
La funzione chiama deleteUser
quando un utente elimina il proprio profilo utente:
Node.js
exports.deleteUser = functions.firestore .document('users/{userID}') .onDelete((snap, context) => { // Get an object representing the document prior to deletion // e.g. {'name': 'Marie', 'age': 66} const deletedValue = snap.data(); // perform desired operations ... });
Attivare una funzione per tutte le modifiche apportate a un documento
Se non ti interessa il tipo di evento attivato, puoi ascoltare tutte le modifiche in un documento Cloud Firestore utilizzando la funzione onWrite()
con un carattere jolly. Questa funzione di esempio chiama modifyUser
Se un utente viene creato, aggiornato o eliminato:
Node.js
exports.modifyUser = functions.firestore .document('users/{userID}') .onWrite((change, context) => { // Get an object with the current document value. // If the document does not exist, it has been deleted. const document = change.after.exists ? change.after.data() : null; // Get an object with the previous document value (for update or delete) const oldDocument = change.before.data(); // perform desired 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, potrebbe essere utile ottenere dati da un documento
o recuperare i dati prima di eseguire l'aggiornamento. Puoi recuperare i dati precedenti utilizzando
change.before.data()
, che contiene lo snapshot del documento prima dell'aggiornamento.
Analogamente, change.after.data()
contiene lo stato dello snapshot del documento dopo l'aggiornamento.
Node.js
exports.updateUser2 = functions.firestore .document('users/{userId}') .onUpdate((change, context) => { // Get an object representing the current document const newValue = change.after.data(); // ...or the previous value before this update const previousValue = change.before.data(); });
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 = snap.data().age; const name = snap.data()['name']; // Fetch data using built in accessor const experience = snap.get('experience');
Scrittura dei dati
Ogni chiamata di funzione è associata a un documento specifico nel
un database Cloud Firestore. Puoi accedere a quel documento come
DocumentReference
nella proprietà ref
dello snapshot restituito alla funzione.
Questo DocumentReference
proviene da
SDK Node.js di Cloud Firestore
e include metodi come update()
, set()
e remove()
per permetterti di
modificare il documento che ha attivato la funzione.
Node.js
// Listen for updates to any `user` document. exports.countNameChanges = functions.firestore .document('users/{userId}') .onUpdate((change, context) => { // Retrieve the current and previous value const data = change.after.data(); const previousData = change.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 change.after.ref.set({ name_change_count: count + 1 }, {merge: true}); });
Dati esterni all'evento di attivazione
I Cloud Functions vengono eseguiti in un ambiente attendibile, il che significa che vengono autorizzato come account di servizio nel tuo progetto. Puoi eseguire operazioni di lettura e scrittura Con l'SDK Admin Firebase:
Node.js
const admin = require('firebase-admin');
admin.initializeApp();
const db = admin.firestore();
exports.writeToFirestore = functions.firestore
.document('some/doc')
.onWrite((change, context) => {
db.doc('some/otherdoc').set({ ... });
});
Limitazioni
Tieni presenti le seguenti limitazioni per gli attivatori Cloud Firestore per Cloud Functions:
- Cloud Functions (1a gen.) prepara un prerequisito "(predefinito)" esistente in modalità nativa Firestore. Non supporta i database 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 (2a generazione). Cloud Functions (1a generazione) non supportare la modalità Datastore.
- Un trigger è associato a un singolo database. Non puoi creare un trigger che corrisponde 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 la 1ª gen." di gravità
error
. Puoi trovare il nome della funzione nel campofunctionName
. Se il camporeceiveTimestamp
è 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 utilizzando le esclusioni ma tieni presente che gli eventi offensivi non verranno comunque pubblicati.