Con Cloud Functions, puoi eseguire il deployment di codice per gestire gli eventi attivati dalle modifiche del database Cloud Firestore. In questo modo puoi aggiungere facilmente funzionalità lato server alla tua app senza dover eseguire i tuoi server.
Cloud Functions (2a generazione)
Basato su Cloud Run e Eventarc, Cloud Functions for Firebase (2a generazione) offre un'infrastruttura più potente, un controllo avanzato su prestazioni e scalabilità e un maggiore controllo sul runtime delle funzioni. Per maggiori informazioni sulla seconda generazione, consulta Cloud Functions for Firebase (2a generazione). Per saperne di più sulla 1a generazione, consulta Estendi Cloud Firestore con Cloud Functions.
Trigger delle funzioni di Cloud Firestore
L'SDK Cloud Functions for Firebase esporta i seguenti trigger di evento Cloud Firestore per consentirti di creare gestori collegati a specifici eventi Cloud Firestore:
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 ha un valore modificato. |
onDocumentDeleted |
Si attiva quando viene eliminato un documento. |
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 ha un valore modificato. |
on_document_deleted |
Si attiva quando viene eliminato un documento. |
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 |
Gli eventi di Cloud Firestore vengono attivati solo in caso di modifiche ai documenti. Un aggiornamento di un documento Cloud Firestore in cui i dati non sono stati modificati (scrittura no-op) non genera un evento di aggiornamento o scrittura. Non è possibile aggiungere eventi a campi specifici.
Se ancora non hai un progetto abilitato per Cloud Functions for Firebase, leggi Iniziare a utilizzare Cloud Functions for Firebase (2a generazione) per configurare e impostare il tuo progetto Cloud Functions for Firebase.
Scrittura delle funzioni attivate da Cloud Firestore
Definisci un attivatore di funzione
Per definire un trigger di Cloud Firestore, specifica un percorso 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 funzione riportata di seguito.
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 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 un documento in users
viene modificato, corrisponde a un carattere jolly chiamato userId
.
Se un documento in users
contiene sottoraccolte 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 archiviate in event.params
.
Puoi definire tutti i caratteri jolly che vuoi per sostituire gli 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 puntare sempre a un documento, anche se utilizzi un carattere jolly.
Ad esempio, users/{userId}/{messageCollectionId}
non è valido perché {messageCollectionId}
è una raccolta. Tuttavia, users/{userId}/{messageCollectionId}/{messageId}
è
valido perché {messageId}
punterà sempre a un documento.
Trigger di eventi
Attiva una funzione quando viene creato un nuovo documento
Puoi attivare una funzione ogni volta che viene creato un nuovo documento in una raccolta. Questa funzione di esempio viene attivata 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 di autenticazione, utilizza il criterio 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 una funzione quando viene aggiornato un documento. Questa funzione di esempio viene attivata se un utente cambia il 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 di autenticazione, utilizza il criterio 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 attivare una funzione anche quando viene eliminato un documento. Questa funzione di 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 di autenticazione, utilizza il criterio 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 il tipo di evento attivato non ti interessa, puoi rimanere in ascolto per tutte le modifiche apportate a un documento Cloud Firestore utilizzando l'attivatore di evento "document write". 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 di autenticazione, utilizza il criterio 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 di dati
Quando viene attivata, una funzione fornisce uno snapshot dei dati relativi all'evento. Puoi utilizzare questo snapshot per leggere o scrivere sul documento che ha attivato l'evento oppure utilizzare l'SDK Firebase Admin per accedere ad altre parti del database.
Dati evento
Lettura dei dati
Quando viene attivata una funzione, è possibile che tu voglia recuperare i dati da un documento che è stato aggiornato o ottenere i dati prima dell'aggiornamento. Puoi ottenere i dati precedenti utilizzando
event.data.before
, che contiene l'istantanea del documento prima dell'aggiornamento.
Analogamente, event.data.after
contiene lo stato dell'istantanea 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 con 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 dati
Ogni chiamata di funzione è associata a un documento specifico nel tuo database Cloud Firestore. Puoi accedere a questo documento nello snapshot restituito alla funzione.
Il riferimento del documento include metodi come update()
, set()
e remove()
, quindi puoi 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})
Accedere alle informazioni di autenticazione degli utenti
Se utilizzi uno dei seguenti tipi di eventi, puoi accedere alle informazioni di autenticazione utente sull'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, 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 trigger
Le funzioni Cloud Functions vengono eseguite in un ambiente affidabile. Sono autorizzati come account di servizio del 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 i trigger di Cloud Firestore per Cloud Functions:
- L'ordine non è garantito. Le modifiche rapide possono attivare chiamate di funzioni in modo imprevisto.
- Gli eventi vengono recapitati almeno una volta, ma un singolo evento potrebbe comportare più chiamate di funzioni. Evita di dipendere dalla meccanica "exactly-once" e scrivi funzioni idempotenti.
- Cloud Firestore in modalità Datastore richiede Cloud Functions (2a generazione). Cloud Functions (1a gen.) non supporta la modalità Datastore.
- Cloud Functions (1a gen.) funziona solo con il database "(default)" e non supporta i database denominati Cloud Firestore. Utilizza Cloud Functions (2a generazione) per configurare gli eventi per i database denominati.
- Un trigger è associato a un singolo database. Non puoi creare un trigger corrispondente a più database.
- L'eliminazione di un database non elimina automaticamente i trigger per quel database. L'attivatore smette di pubblicare eventi, ma continua a esistere finché non lo elimini.
- Se un evento con corrispondenza supera la dimensione massima della richiesta, l'evento potrebbe non essere consegnato a Cloud Functions (1a generazione).
- Gli eventi non recapitati a causa delle dimensioni della richiesta vengono registrati nei log della piattaforma e vengono conteggiati ai fini dell'utilizzo dei log per il progetto.
- Puoi trovare questi log in Esplora log con il messaggio "L'evento non può essere recapitato alla funzione Cloud Functions a causa del superamento del limite per la 1a generazione..." con gravità
error
. Puoi trovare il nome della funzione sotto il campofunctionName
. Se il camporeceiveTimestamp
è ancora entro un'ora da adesso, puoi dedurre i contenuti effettivi dell'evento leggendo il documento in questione con un'istantanea prima e dopo il timestamp. - Per evitare questo ritmo, puoi:
- Migrazione a Cloud Functions (2a generazione) ed upgrade
- Ridimensiona il documento
- Elimina la funzione Cloud Functions in questione
- Puoi disattivare il logging stesso utilizzando le esclusioni, ma tieni presente che gli eventi offensivi non verranno comunque recapitati.