इस पेज का अनुवाद Cloud Translation API से किया गया है.

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

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

Cloud Functions (2nd gen)

Cloud Run और Eventarc की मदद से, Cloud Functions for Firebase (2nd gen) की मदद से, आपको ज़्यादा असरदार इंफ़्रास्ट्रक्चर, परफ़ॉर्मेंस और बढ़ाए जा सकने की बेहतर क्षमता, और फ़ंक्शन रनटाइम को ज़्यादा कंट्रोल करने की सुविधा मिलती है. 2nd gen के बारे में ज़्यादा जानकारी के लिए, Firebase के लिए Cloud Functions (2nd gen) देखें. इसके बजाय, 1st gen के बारे में ज़्यादा जानने के लिए 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 (preview)

इवेंट टाइप	ट्रिगर
`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 दस्तावेज़ में होने वाला एक अपडेट, जिसमें डेटा में कोई बदलाव नहीं होता (नो-ऑप राइटिंग) कोई अपडेट या राइट इवेंट जनरेट नहीं करता. खास फ़ील्ड में इवेंट नहीं जोड़े जा सकते.

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

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

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

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

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

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

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

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

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

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

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

# 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 (preview)

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

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

@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 एडमिन 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 (preview)

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 Firestore ट्रिगर की इन सीमाओं का ध्यान रखें:

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