Cloud Functions की मदद से Cloud Firestore का दायरा बढ़ाना (2nd gen)

Cloud Functions की मदद से, आपके Cloud Firestore डेटाबेस में हुए बदलावों की वजह से ट्रिगर हुए इवेंट को मैनेज करने के लिए कोड का इस्तेमाल किया जा सकता है. इससे, अपने सर्वर चलाए बिना ही, अपने ऐप्लिकेशन में सर्वर-साइड की सुविधाएं आसानी से जोड़ी जा सकती हैं.

Cloud Functions (2nd gen)

Cloud Run और Eventarc की मदद से काम करने वाले, Cloud Functions for Firebase (दूसरी जनरेशन) में आपको बेहतर इन्फ़्रास्ट्रक्चर, परफ़ॉर्मेंस और स्केलेबिलिटी पर बेहतर कंट्रोल, और फ़ंक्शन के रनटाइम पर ज़्यादा कंट्रोल मिलता है. दूसरे जनरेशन के बारे में ज़्यादा जानकारी के लिए, Firebase के लिए Cloud Functions (दूसरा जनरेशन) लेख पढ़ें. इसके बजाय, पहले जनरेशन के बारे में ज़्यादा जानने के लिए, Cloud Functions की मदद से Cloud Firestore को एक्सटेंड़ करना लेख पढ़ें.

Cloud Firestore फ़ंक्शन ट्रिगर

Cloud Functions for Firebase SDK टूल, यहां दिए गए Cloud Firestore इवेंट ट्रिगर एक्सपोर्ट करता है, ताकि आप खास Cloud Firestore इवेंट से जुड़े हैंडलर बना सकें:

Node.js

इवेंट टाइप	ट्रिगर
onDocumentCreated	जब किसी दस्तावेज़ में पहली बार लिखा जाता है, तब यह ट्रिगर होता है.
onDocumentUpdated	यह तब ट्रिगर होता है, जब कोई दस्तावेज़ पहले से मौजूद हो और उसकी किसी वैल्यू में बदलाव किया गया हो.
onDocumentDeleted	दस्तावेज़ मिटाए जाने पर ट्रिगर होता है.
onDocumentWritten	onDocumentCreated, onDocumentUpdated या onDocumentDeleted ट्रिगर होने पर ट्रिगर होता है.
onDocumentCreatedWithAuthContext	onDocumentCreated, जिसमें पुष्टि करने के लिए ज़्यादा जानकारी हो
onDocumentWrittenWithAuthContext	onDocumentWritten, जिसमें पुष्टि करने के लिए ज़्यादा जानकारी हो
onDocumentDeletedWithAuthContext	onDocumentDeleted, जिसमें पुष्टि करने के लिए ज़्यादा जानकारी हो
onDocumentUpdatedWithAuthContext	onDocumentUpdated, जिसमें पुष्टि करने के लिए ज़्यादा जानकारी हो

Python (झलक)

इवेंट टाइप	ट्रिगर
on_document_created	जब किसी दस्तावेज़ में पहली बार लिखा जाता है, तब यह ट्रिगर होता है.
on_document_updated	यह तब ट्रिगर होता है, जब कोई दस्तावेज़ पहले से मौजूद हो और उसकी किसी वैल्यू में बदलाव किया गया हो.
on_document_deleted	तब ट्रिगर होता है, जब कोई दस्तावेज़ मिटा दिया जाता है.
on_document_written	on_document_created, on_document_updated या on_document_deleted ट्रिगर होने पर ट्रिगर होता है.
on_document_created_with_auth_context	on_document_created, जिसमें पुष्टि करने के लिए ज़्यादा जानकारी हो
on_document_updated_with_auth_context	on_document_updated, जिसमें पुष्टि करने के लिए ज़्यादा जानकारी हो
on_document_deleted_with_auth_context	on_document_deleted, जिसमें पुष्टि करने के लिए ज़्यादा जानकारी हो
on_document_written_with_auth_context	on_document_written, जिसमें पुष्टि करने के लिए ज़्यादा जानकारी हो

Cloud Firestore इवेंट सिर्फ़ दस्तावेज़ में बदलाव होने पर ट्रिगर होते हैं. Cloud Firestore दस्तावेज़ में कोई अपडेट होने पर, अपडेट या लिखने का इवेंट जनरेट नहीं होता. ऐसा तब होता है, जब दस्तावेज़ में मौजूद डेटा में कोई बदलाव न हुआ हो. खास फ़ील्ड में इवेंट नहीं जोड़े जा सकते.

अगर आपने अब तक Cloud Functions for Firebase के लिए कोई प्रोजेक्ट चालू नहीं किया है, तो Cloud Functions for Firebase प्रोजेक्ट को कॉन्फ़िगर और सेट अप करने के लिए, Cloud Functions for Firebase (दूसरी जनरेशन) का इस्तेमाल शुरू करना लेख पढ़ें.

Cloud Firestore से ट्रिगर होने वाले फ़ंक्शन लिखना

फ़ंक्शन ट्रिगर तय करना

Cloud Firestore ट्रिगर तय करने के लिए, दस्तावेज़ का पाथ और इवेंट टाइप तय करें:

Node.js

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

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

Python (झलक)

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:

दस्तावेज़ के पाथ, किसी खास दस्तावेज़ या वाइल्डकार्ड पैटर्न का रेफ़रंस दे सकते हैं.

कोई एक दस्तावेज़ चुनना

अगर आपको किसी दस्तावेज़ में किसी भी बदलाव के लिए इवेंट ट्रिगर करना है, तो यहां दिए गए फ़ंक्शन का इस्तेमाल करें.

Node.js

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

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

Python (झलक)

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:

वाइल्डकार्ड का इस्तेमाल करके दस्तावेज़ों का ग्रुप तय करना

अगर आपको दस्तावेज़ों के ग्रुप (जैसे कि किसी कलेक्शन के किसी दस्तावेज़) में ट्रिगर अटैच करना है, तो दस्तावेज़ आईडी की जगह {wildcard} का इस्तेमाल करें:

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 (झलक)

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

इस उदाहरण में, जब users में मौजूद किसी भी दस्तावेज़ का कोई फ़ील्ड बदला जाता है, तो यह userId नाम के वाइल्डकार्ड से मैच होता है.

अगर users में मौजूद किसी दस्तावेज़ में सब-कलेक्शन हैं और उनमें से किसी एक सब-कलेक्शन के दस्तावेज़ में कोई फ़ील्ड बदला जाता है, तो userId वाइल्डकार्ड ट्रिगर नहीं होता.

वाइल्डकार्ड से मेल खाने वाले नतीजे, दस्तावेज़ के पाथ से हासिल किए जाते हैं और event.params में सेव किए जाते हैं. साफ़ तौर पर इकट्ठा किए गए कलेक्शन या दस्तावेज़ के आईडी को बदलने के लिए, जितने चाहें उतने वाइल्डकार्ड तय किए जा सकते हैं. उदाहरण के लिए:

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 (झलक)

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"}

आपका ट्रिगर हमेशा किसी दस्तावेज़ पर ले जाना चाहिए. भले ही, आपने वाइल्डकार्ड का इस्तेमाल किया हो. उदाहरण के लिए, users/{userId}/{messageCollectionId} अमान्य है, क्योंकि {messageCollectionId} एक कलेक्शन है. हालांकि, users/{userId}/{messageCollectionId}/{messageId} मान्य है, क्योंकि {messageId} हमेशा किसी दस्तावेज़ पर ले जाएगा.

इवेंट ट्रिगर

नया दस्तावेज़ बनाए जाने पर फ़ंक्शन ट्रिगर करें

कलेक्शन में नया दस्तावेज़ बनने पर, फ़ंक्शन को ट्रिगर किया जा सकता है. यह उदाहरण फ़ंक्शन, हर बार नई उपयोगकर्ता प्रोफ़ाइल जोड़ने पर ट्रिगर होता है:

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 ...
});

पुष्टि करने के बारे में ज़्यादा जानकारी के लिए, onDocumentCreatedWithAuthContext का इस्तेमाल करें.

Python (झलक)

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 ...

दस्तावेज़ अपडेट होने पर कोई फ़ंक्शन ट्रिगर करना

किसी दस्तावेज़ के अपडेट होने पर, फ़ंक्शन को ट्रिगर भी किया जा सकता है. यह उदाहरण फ़ंक्शन तब ट्रिगर होता है, जब कोई उपयोगकर्ता अपनी प्रोफ़ाइल बदलता है:

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 ...
});

पुष्टि करने के बारे में ज़्यादा जानकारी के लिए, onDocumentUpdatedWithAuthContext का इस्तेमाल करें.

Python (झलक)

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 ...

दस्तावेज़ मिटाए जाने पर फ़ंक्शन ट्रिगर करें

किसी दस्तावेज़ के मिटाए जाने पर भी फ़ंक्शन को ट्रिगर किया जा सकता है. यह उदाहरण वाला फ़ंक्शन तब ट्रिगर होता है, जब कोई उपयोगकर्ता अपनी उपयोगकर्ता प्रोफ़ाइल मिटाता है:

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 ...
});

पुष्टि करने के बारे में ज़्यादा जानकारी के लिए, onDocumentDeletedWithAuthContext का इस्तेमाल करें.

Python (झलक)

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 ...

दस्तावेज़ में किए गए सभी बदलावों के लिए कोई फ़ंक्शन ट्रिगर करना

अगर आपको ट्रिगर किए जा रहे इवेंट के टाइप की परवाह नहीं है, तो "दस्तावेज़ लिखा गया" इवेंट ट्रिगर का इस्तेमाल करके, Cloud Firestore दस्तावेज़ में हुए सभी बदलावों को ट्रैक किया जा सकता है. यह उदाहरण फ़ंक्शन, उपयोगकर्ता बनाने, अपडेट करने या मिटाने पर ट्रिगर होता है:

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 ...
});

पुष्टि करने के बारे में ज़्यादा जानकारी के लिए, onDocumentWrittenWithAuthContext का इस्तेमाल करें.

Python (झलक)

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 ...

डेटा पढ़ना और उसमें बदलाव करना

जब कोई फ़ंक्शन ट्रिगर किया जाता है, तो वह इवेंट से जुड़े डेटा का स्नैपशॉट देता है. इस स्नैपशॉट का इस्तेमाल, इवेंट को ट्रिगर करने वाले दस्तावेज़ से पढ़ने या उसमें लिखने के लिए किया जा सकता है. इसके अलावा, अपने डेटाबेस के अन्य हिस्सों को ऐक्सेस करने के लिए Firebase एडमिन SDK टूल का इस्तेमाल किया जा सकता है.

इवेंट का डेटा

डेटा पढ़ना

फ़ंक्शन ट्रिगर होने पर, हो सकता है कि आप अपडेट किए गए दस्तावेज़ से डेटा पाना चाहें या अपडेट से पहले का डेटा पाना चाहें. event.data.before का इस्तेमाल करके, पिछला डेटा देखा जा सकता है. इसमें अपडेट से पहले का दस्तावेज़ का स्नैपशॉट होता है. इसी तरह, event.data.after में अपडेट के बाद दस्तावेज़ के स्नैपशॉट की स्थिति शामिल होती है.

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 (झलक)

@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()

प्रॉपर्टी को उसी तरह ऐक्सेस किया जा सकता है जैसे किसी दूसरे ऑब्जेक्ट में किया जाता है. इसके अलावा, चुनिंदा फ़ील्ड ऐक्सेस करने के लिए, get फ़ंक्शन का इस्तेमाल किया जा सकता है:

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 (झलक)

# 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"]

डेटा लिखना

हर फ़ंक्शन का इस्तेमाल, आपके Cloud Firestore डेटाबेस में मौजूद किसी खास दस्तावेज़ से जुड़ा होता है. आपके फ़ंक्शन में दिखाए गए स्नैपशॉट में, उस दस्तावेज़ को ऐक्सेस किया जा सकता है.

दस्तावेज़ के रेफ़रंस में update(), set(), और remove() जैसे तरीके शामिल होते हैं, ताकि आप उस दस्तावेज़ में बदलाव कर सकें जिसकी वजह से फ़ंक्शन ट्रिगर हुआ है.

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 (झलक)

@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})

चेतावनी: जब भी किसी ऐसे दस्तावेज़ में लिखा जाता है जिसने फ़ंक्शन को ट्रिगर किया है, तो अनलिमिटेड लूप बनने का खतरा होता है. सावधानी बरतें और पक्का करें कि जब कोई बदलाव ज़रूरी न हो, तब फ़ंक्शन से सुरक्षित तरीके से बाहर निकला जाए.

उपयोगकर्ता की पुष्टि करने से जुड़ी जानकारी ऐक्सेस करना

अगर इवेंट के इनमें से किसी टाइप का इस्तेमाल किया जाता है, तो इवेंट को ट्रिगर करने वाले प्रिंसिपल के बारे में, उपयोगकर्ता की पुष्टि करने वाली जानकारी को ऐक्सेस किया जा सकता है. यह जानकारी, बेस इवेंट में मिली जानकारी से अलग होती है.

Node.js

• onDocumentCreatedWithAuthContext
• onDocumentWrittenWithAuthContext
• onDocumentDeletedWithAuthContext
• onDocumentUpdatedWithAuthContext

Python (झलक)

• on_document_created_with_auth_context
• on_document_updated_with_auth_context
• on_document_deleted_with_auth_context
• on_document_written_with_auth_context

पुष्टि करने के कॉन्टेक्स्ट में उपलब्ध डेटा के बारे में जानकारी पाने के लिए, पुष्टि करने का कॉन्टेक्स्ट देखें. नीचे दिए गए उदाहरण में, पुष्टि करने की जानकारी वापस पाने का तरीका बताया गया है:

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 (झलक)

@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

ट्रिगर इवेंट से बाहर का डेटा

Cloud Functions भरोसेमंद एनवायरमेंट में चलाया जा सकता है. उन्हें आपके प्रोजेक्ट पर सेवा खाते के तौर पर अनुमति दी जाती है. साथ ही, Firebase Admin SDK टूल का इस्तेमाल करके, डेटा पढ़ा और लिखा जा सकता है:

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 (झलक)

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({
      # ...
  })

ध्यान दें: Cloud Functions में की गई रीड और राइट, आपके सुरक्षा नियमों से कंट्रोल नहीं की जाती हैं. ये आपके डेटाबेस के किसी भी हिस्से को ऐक्सेस कर सकती हैं.

सीमाएं

Cloud Functions के लिए Cloud Firestore ट्रिगर की इन सीमाओं का ध्यान रखें:

• Cloud Functions (1st gen) के लिए, Firestore नेटिव मोड में पहले से मौजूद "(डिफ़ॉल्ट)" डेटाबेस ज़रूरी है. यह Cloud Firestore नाम वाले डेटाबेस या Datastore मोड के साथ काम नहीं करता. ऐसे मामलों में इवेंट कॉन्फ़िगर करने के लिए, कृपया Cloud Functions (दूसरी जनरेशन) का इस्तेमाल करें.
• ऑर्डर करने की कोई गारंटी नहीं है. तेज़ी से होने वाले बदलावों की वजह से, फ़ंक्शन को अनचाहे क्रम में ट्रिगर किया जा सकता है.
• इवेंट कम से कम एक बार डिलीवर किए जाते हैं, लेकिन किसी एक इवेंट की वजह से कई फ़ंक्शन शुरू किए जा सकते हैं. एक बार इस्तेमाल होने वाली मैकेनिक्स पर निर्भर करने से बचें और idempostent फ़ंक्शन लिखें.
• Datastore मोड में Cloud Firestore के लिए Cloud Functions (2nd gen) की ज़रूरत होती है. Cloud Functions (1st gen) में Datastore मोड काम नहीं करता.
• ट्रिगर, किसी एक डेटाबेस से जुड़ा होता है. एक से ज़्यादा डेटाबेस से मैच करने वाला ट्रिगर नहीं बनाया जा सकता.
• किसी डेटाबेस को मिटाने से, उस डेटाबेस के लिए कोई भी ट्रिगर अपने-आप नहीं मिटता. ट्रिगर, इवेंट डिलीवर करना बंद कर देता है. हालांकि, यह तब तक मौजूद रहता है, जब तक ट्रिगर को मिटाया नहीं जाता.
• अगर मैच होने वाला इवेंट, अनुरोध का ज़्यादा से ज़्यादा साइज़ से ज़्यादा है, तो हो सकता है कि इवेंट को Cloud Functions (पहले जनरेशन) पर डिलीवर न किया जाए.
  • अनुरोध के साइज़ की वजह से डिलीवर नहीं किए गए इवेंट, प्लैटफ़ॉर्म लॉग में लॉग किए जाते हैं और इन्हें प्रोजेक्ट के लिए लॉग के इस्तेमाल में गिना जाता है.
  • आपको ये लॉग, लॉग एक्सप्लोरर में इस मैसेज के साथ मिलेंगे. जैसे, "1st gen..." की तय सीमा से ज़्यादा साइज़ होने की वजह से, Cloud फ़ंक्शन को इवेंट डिलीवर नहीं किया जा सका. यह संख्या error की गंभीर है. आपको फ़ंक्शन का नाम functionName फ़ील्ड में दिखेगा. अगर receiveTimestamp फ़ील्ड अब भी एक घंटे के अंदर है, तो टाइमस्टैंप से पहले और बाद के स्नैपशॉट के साथ, उस दस्तावेज़ को पढ़कर, इवेंट के असल कॉन्टेंट का अनुमान लगाया जा सकता है.
  • इस तरह के कैडेंस से बचने के लिए, ये काम किए जा सकते हैं:
    • Cloud Functions (2nd gen) पर माइग्रेट और अपग्रेड करें
    • दस्तावेज़ का साइज़ कम करना
    • जिस Cloud Functions को मिटाना है उसे मिटाएं
  • बाहर रखे गए यूआरएल का इस्तेमाल करके, लॉगिंग की सुविधा को बंद किया जा सकता है. हालांकि, ध्यान रखें कि समस्या वाले इवेंट अब भी डिलीवर नहीं किए जाएंगे.