Con Cloud Functions, puoi eseguire il deployment del codice per gestire gli eventi attivati in base a modifiche nel database Cloud Firestore. In questo modo puoi aggiungere facilmente nella tua app senza eseguire i tuoi server.
Cloud Functions (2a generazione)
Con tecnologia Cloud Run e Eventarc, Cloud Functions for Firebase (2a generazione) ti offre più potenza dell'infrastruttura, controllo avanzato su prestazioni e scalabilità e altro ancora del runtime delle funzioni. Per ulteriori informazioni su 2a gen., vedi Cloud Functions for Firebase (2a generazione). Per vedere di più sulla 1a generazione, vedi Estendi Cloud Firestore con Cloud Functions.
Cloud Firestore trigger di funzione
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 un documento viene scritto per la prima volta. |
onDocumentUpdated |
Si attiva quando un documento esiste già e presenta un valore modificato. |
onDocumentDeleted |
Si attiva quando un documento viene eliminato. |
onDocumentWritten |
Si attiva quando vengono attivati 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 un documento viene scritto per la prima volta. |
on_document_updated |
Si attiva quando un documento esiste già e presenta un valore modificato. |
on_document_deleted |
Si attiva quando un documento viene eliminato. |
on_document_written |
Si attiva quando vengono attivati 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 |
Solo trigger di eventi Cloud Firestore sulle modifiche ai documenti. Un aggiornamento a un documento Cloud Firestore in cui i dati non è modificato (una scrittura autonoma) non genera un evento di aggiornamento o scrittura. È impossibile 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.
Scrittura di funzioni attivate da Cloud Firestore
Definisci un trigger 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 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
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:
Specifica un gruppo di documenti utilizzando caratteri jolly
Se vuoi allegare un attivatore a un gruppo di documenti, ad esempio qualsiasi documento in
una determinata raccolta, quindi usa un valore {wildcard}
al posto di
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 viene modificato qualsiasi campo di qualsiasi documento in users
, viene restituito
un carattere jolly denominato userId
.
Se un documento in users
contiene sottoraccolte e un campo in una di queste
sottoraccolte documenti vengono modificati, il carattere jolly userId
non viene attivato.
Le corrispondenze con caratteri jolly vengono estratte dal percorso del documento e archiviate in event.params
.
Puoi definire quanti caratteri jolly vuoi sostituire la raccolta esplicita
o ID documento, 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 usi un carattere jolly.
Ad esempio, users/{userId}/{messageCollectionId}
non è valido perché {messageCollectionId}
è una raccolta. Tuttavia, users/{userId}/{messageCollectionId}/{messageId}
è
valida perché {messageId}
rimanderà sempre a un documento.
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. Questo esempio di funzione viene attivato 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 ...
Attiva una funzione quando un documento viene aggiornato
Puoi anche attivare una funzione da eseguire quando un documento viene aggiornato. Questa funzione di esempio viene attivata se un utente cambia 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, usa 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. Questo esempio si attiva 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 ...
Attiva una funzione per tutte le modifiche 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, usa 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 . Puoi utilizzare questa istantanea per leggere o scrivere nel documento hanno attivato l'evento o utilizzare l'SDK Admin Firebase per accedere ad altre parti del tuo 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 ottenere i dati precedenti utilizzando
event.data.before
, che contiene l'istantanea 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 per 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 Cloud Firestore database. Puoi accedere al documento in lo snapshot restituito alla funzione.
Il riferimento al documento include metodi come update()
, set()
e remove()
per consentirti di 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})
Accesso alle informazioni di autenticazione degli utenti
Se utilizzi uno dei seguenti tipi di evento, puoi accedere le informazioni di autenticazione utente relative all'entità che ha attivato l'evento. Queste informazioni si aggiungono a quelle restituite nell'evento di 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, vedi Contesto 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 scritture 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({
# ...
})
Limitazioni
Tieni presente 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 supportare i database denominati Cloud Firestore o la modalità Datastore. Usa Cloud Functions (2ª generazione) 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 pubblicati almeno una volta, ma un singolo evento può comportare più chiamate di funzione. Da evitare in base a la meccanica "exactly-once" e scrivere funzioni idempotenti:
- Cloud Firestore in modalità Datastore richiede Cloud Functions (2a generazione). Cloud Functions (1ª gen.) non supporta 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 elimina automaticamente alcun trigger per quel database. La interrompe la pubblicazione degli eventi, ma continua a esistere finché non elimini l'attivatore.
- 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 consegnati a causa delle dimensioni della richiesta vengono registrati nei log della piattaforma e verranno conteggiate ai fini dell'utilizzo dei log da parte del progetto.
- Puoi trovare questi log in Esplora log con il messaggio "L'evento non può recapitare a
Funzione Cloud Functions a causa del superamento del limite per le dimensioni di 1ª generazione..." di
error
gravità. Puoi trovare il nome della funzione sotto il campofunctionName
. Se Se il camporeceiveTimestamp
si trova ancora a meno di un'ora da adesso, puoi dedurre i contenuti dell'evento effettivo leggendo il documento in questione con una uno snapshot prima e dopo il timestamp. - Per evitare questa frequenza, puoi:
- Esegui la migrazione e l'upgrade a Cloud Functions (2ª gen.)
- Riduci le dimensioni del documento
- Elimina Cloud Functions in questione
- Puoi disattivare il logging utilizzando le esclusioni ma tieni presente che gli eventi offensivi non verranno comunque pubblicati.