बदलावों की स्ट्रीम की मदद से रीयल-टाइम डेटा पढ़ना

MongoDB के साथ काम करने वाले Firestore के लिए, Change Streams की सुविधा उपलब्ध है. इसकी मदद से, ऐप्लिकेशन, किसी कलेक्शन या पूरे डेटाबेस में किए गए रीयल-टाइम बदलावों (इंसर्ट, अपडेट, और मिटाए गए डेटा) को ऐक्सेस कर सकते हैं. Change Stream, बदलाव के समय के हिसाब से अपडेट को क्रम में लगाता है.

MongoDB के साथ काम करने वाले एपीआई और MongoDB के पुराने ड्राइवर की मदद से, Change Streams को ऐक्सेस किया जा सकता है. MongoDB के साथ काम करने वाले Firestore में, Change Streams को लागू करने पर, लिखने और पढ़ने की किसी भी थ्रूपुट को हैंडल किया जा सकता है. ऐसा, लिखने के लिए अपने-आप पार्टीशन करने और पढ़ने के लिए पैरललिज़्म की यूनीक सुविधा की मदद से किया जाता है. इससे, ज़्यादा थ्रूपुट वाले वर्कलोड बनाए जा सकते हैं. इसके अलावा, Cloud Firestore और स्टोरेज के अन्य समाधानों के बीच, माइग्रेशन और डेटा सिंक करने के इन्फ़्रास्ट्रक्चर को बेहतर बनाया जा सकता है.

MongoDB के ड्राइवर के साथ काम करने के अलावा, का इस्तेमाल करके,Cloud Firestore Change Streams को पैरलल में पढ़ा जा सकता है. इससे, ज़्यादा थ्रूपुट वाले वर्कलोड को पैरलल में पढ़ा जा सकता है. हर स्ट्रीम, नतीजों के अच्छी तरह से डिस्ट्रिब्यूट किए गए पार्टीशन को दिखाती है.

Change Streams में इन सुविधाओं का इस्तेमाल किया जा सकता है:

  • डेटाबेस या कलेक्शन के दायरे के साथ, कॉन्फ़िगर की जा सकने वाली Change Streams.
  • Change Stream के लिए, डेटा के रखरखाव की अवधि तय की जा सकती है. यह अवधि, स्ट्रीम बनाते समय तय की जाती है. डिफ़ॉल्ट तौर पर, डेटा के रखरखाव की अवधि सात दिन होती है. वहीं, कम से कम अवधि एक दिन होती है. डेटा के रखरखाव की अवधि, एक दिन के मल्टीपल में होनी चाहिए. यह अवधि, ज़्यादा से ज़्यादा सात दिन हो सकती है. स्ट्रीम बनाने के बाद, डेटा के रखरखाव की अवधि में बदलाव नहीं किया जा सकता. डेटा के रखरखाव की अवधि में बदलाव करने के लिए, आपको Change Stream को हटाकर फिर से बनाना होगा.
  • delete, insert, update, और drop के लिए, बदलाव के इवेंट देखे जा सकते हैं. इसके लिए, db.collection.watch() और db.watch() का इस्तेमाल किया जा सकता है.
  • updateDescription.updatedFields में, अपडेट के अंतर शामिल होते हैं.
  • सभी fullDocument और fullDocumentBeforeChange विकल्प.
    • अपडेट के लिए, पूरे दस्तावेज़ को देखना.
    • दस्तावेज़ को बदलने, अपडेट करने या मिटाने से पहले की इमेज.
    • दस्तावेज़ को बदलने या अपडेट करने के बाद की इमेज.
    • एक घंटे से ज़्यादा पुरानी, पहले और बाद की इमेज देखने के लिए, पॉइंट-इन-टाइम रिकवरी (पीआईटीआर) की सुविधा चालू करनी होगी.
  • resumeAfter और startAfter सहित, फिर से शुरू करने के सभी विकल्प.
  • बदलावों को देखने के लिए, watch() का इस्तेमाल करते समय, एग्रीगेशन स्टेज को चेन किया जा सकता है. जैसे, $addFields, $match, $project, $replaceRoot, $replaceWith, $set, और $unset.

Change Streams कॉन्फ़िगर करना

किसी डेटाबेस के लिए, मौजूदा Change Streams को बनाने, हटाने या देखने के लिए, Google Cloud Console का इस्तेमाल करें.

भूमिकाएं और अनुमतियां

Change Streams बनाने, मिटाने, और उनकी सूची देखने के लिए, किसी प्रिंसिपल के पास, पहचान और ऐक्सेस मैनेजमेंट (आईएएम) की ये अनुमतियां होनी चाहिए: datastore.schemas.create, datastore.schemas.delete, और datastore.schemas.list.

उदाहरण के लिए, Datastore इंडेक्स एडमिन (roles/datastore.indexAdmin) की भूमिका से, ये अनुमतियां मिलती हैं.

Change Stream बनाना

इससे जुड़ा Change Stream कर्सर खोलने से पहले, आपको Change Stream बनाना होगा. कलेक्शन या डेटाबेस बनाते समय, Change Stream को अपने-आप चालू करने की सुविधा उपलब्ध नहीं है.

Change Stream बनाने के लिए, Google Cloud Console का इस्तेमाल करें.

  1. Google Cloud Console में, डेटाबेस पेज पर जाएं.

    डेटाबेस पर जाएं

  2. सूची में से, MongoDB के साथ काम करने वाला Firestore डेटाबेस चुनें. Firestore Studio पैनल खुलता है.
  3. एक्सप्लोरर पैनल में, Change Streams नोड ढूंढें. इसके बाद, ज़्यादा कार्रवाइयां पर क्लिक करें. फिर, Change Stream बनाएं को चुनें.
  4. Change Stream का कोई यूनीक नाम, दायरा, और डेटा के रखरखाव की अवधि डालें. इसके बाद, सेव करें पर क्लिक करें

Change Streams देखना

Google Cloud Console में, Change Streams के बारे में जानकारी देखी जा सकती है.

  1. Google Cloud Console में, डेटाबेस पेज पर जाएं.

    डेटाबेस पर जाएं

  2. सूची में से, MongoDB के साथ काम करने वाला Firestore डेटाबेस चुनें. Firestore Studio पैनल खुलता है.
  3. एक्सप्लोरर पैनल में, Change Streams नोड ढूंढें.
  4. नोड को खोलने या बंद करने के लिए, नोड टॉगल करें पर क्लिक करें.

Change Stream मिटाना

Change Stream मिटाने के लिए, Google Cloud Console का इस्तेमाल करें.

  1. Google Cloud Console में, डेटाबेस पेज पर जाएं.

    डेटाबेस पर जाएं

  2. सूची में से, MongoDB के साथ काम करने वाला Firestore डेटाबेस चुनें. Firestore Studio पैनल खुलता है.
  3. एक्सप्लोरर पैनल में, Change Streams नोड ढूंढें.
  4. नोड को खोलने या बंद करने के लिए, नोड टॉगल करें पर क्लिक करें.
  5. एक्सप्लोरर में, वह Change Stream ढूंढें जिसे मिटाना है.
  6. ज़्यादा कार्रवाइयां पर क्लिक करें. इसके बाद, Change Stream मिटाएं को चुनें.
  7. डायलॉग में, मिटाने की पुष्टि करने के लिए, Change Stream का नाम डालें. इसके बाद, मिटाएं पर क्लिक करें.

Change Stream कर्सर खोलना या फिर से शुरू करना

यहां दिए गए उदाहरणों में, Change Stream कर्सर बनाने, फिर से शुरू करने, और कॉन्फ़िगर करने का तरीका बताया गया है.

Change Stream कर्सर बनाने से पहले, आपको डेटाबेस या कलेक्शन के लिए, साफ़ तौर पर Change Stream बनाना होगा.

Change Stream कर्सर बनाना

नया Change Stream कर्सर बनाने के लिए, MongoDB के ड्राइवर में watch तरीके का इस्तेमाल करें. किसी डेटाबेस में होने वाले सभी बदलावों को सुनने के लिए, डेटाबेस के दायरे वाला Change Stream बनाएं. इसके बाद, db ऑब्जेक्ट पर watch तरीके को कॉल करें.

let cursor = db.watch()

किसी कलेक्शन के दायरे वाला कर्सर बनाने के लिए, आपको पहले उस कलेक्शन के लिए Change Stream बनाना होगा. इसके बाद, उससे जुड़े कलेक्शन पर watch तरीके को कॉल करें.

let cursor = db.my_collection.watch()

Change Stream कर्सर बनाने के बाद, स्ट्रीमिंग शुरू की जा सकती है. उदाहरण के लिए, अगर कोई दस्तावेज़ इंसर्ट किया जाता है और कर्सर पर tryNext को कॉल किया जाता है, तो आपको Change Stream पर बदलाव दिखता है.

let doc = db.my_collection.insertOne({value: "hello world"})
console.log(cursor.tryNext())

अगर दस्तावेज़ को अपडेट और मिटाया जाता है, तो आपको वे बदलाव, Change Stream पर दिखते हैं:

db.my_collection.updateOne({"_id": doc.insertedId}, {$set: {value: "hello world!"}})
db.my_collection.deleteOne({"_id": doc.insertedId}})

// Prints the update event
console.log(cursor.tryNext())

// Prints the delete event
console.log(cursor.tryNext())

Change Stream फिर से शुरू करना

Change Stream को फिर से शुरू करने के लिए, resumeAfter या startAfter विकल्पों का इस्तेमाल करें. resumeAfter और startAfter से, बदलाव लॉग में कहां से फिर से शुरू करना है, यह तय करने के लिए, फिर से शुरू करने के टोकन का इस्तेमाल करें.

// Create a cursor and add one event to the change stream.
let cursor = db.my_collection.watch();
db.my_collection.insertOne({value: "hello world"});
let event = cursor.tryNext();

// Get the resume token from the event.
let resumeToken = event._id;

// Add a new event to the change stream.
db.my_collection.insertOne({value: "foobar"});

// Create a new cursor by using the resume token as a starting point.
let newCursor = db.my_collection.watch({resumeAfter: resumeToken})

// Log the change event containing the "foobar" value.
console.log(newCursor.tryNext())

startAfter का इस्तेमाल करने के लिए:

// Start after the resume token.
let startAfterCursor = db.my_collection.watch({startAfter: resumeToken})

अपडेट और मिटाने की कार्रवाइयों में, पहले और बाद की इमेज शामिल करना

ज़रूरत पड़ने पर, अपडेट और मिटाने की कार्रवाइयों के लिए, बदलाव के इवेंट में दस्तावेज़ों की पहले और बाद की इमेज शामिल की जा सकती हैं. इमेज की उपलब्धता, पॉइंट-इन-टाइम रिकवरी (पीआईटीआर) विंडो पर निर्भर करती है. साथ ही, एक घंटे से ज़्यादा पुरानी दस्तावेज़ की इमेज पढ़ने के लिए, आपको पीआईटीआर की सुविधा चालू करनी होगी.

Change Streams, पीआईटीआर विंडो का फ़ायदा उठाकर, बदलाव के दिए गए इवेंट से पहले और बाद में दस्तावेज़ का व्यू उपलब्ध कराती हैं. डिफ़ॉल्ट तौर पर, अपडेट इवेंट में updateDescription फ़ील्ड शामिल होता है. यह फ़ील्ड, अपडेट की कार्रवाई से बदले गए फ़ील्ड का डेल्टा होता है.

बदलाव के इवेंट में, पहले और बाद की इमेज शामिल करने के लिए, आपको fullDocumentBeforeChange और fullDocument विकल्प Change Stream क्वेरी में तय करने होंगे.

let cursor = db.my_collection.watch({
  "fullDocument": "required",
  "fullDocumentBeforeChange": "required"
})

अगर क्वेरी, पीआईटीआर के तहत डेटा के रखरखाव की अवधि से बाहर के किसी दस्तावेज़ को पढ़ने की कोशिश करती है या अगर पीआईटीआर की सुविधा चालू नहीं है, तो required वैल्यू, सर्वर-साइड गड़बड़ी का मैसेज दिखाती है.

गड़बड़ी दिखाने के बजाय, whenAvailable वैल्यू का इस्तेमाल करके, null वैल्यू दिखाई जा सकती है. ऐसा तब किया जाता है, जब इमेज उपलब्ध न हों.

let cursor = db.my_collection.watch({
  "fullDocument": "whenAvailable",
  "fullDocumentBeforeChange": "whenAvailable"
})

अपडेट में, मौजूदा इमेज शामिल करना

डिफ़ॉल्ट तौर पर, अपडेट इवेंट में updateDescription फ़ील्ड शामिल होता है. यह फ़ील्ड, अपडेट की कार्रवाई से बदले गए फ़ील्ड का डेल्टा होता है. इसके बजाय, पूरे दस्तावेज़ का सबसे नया वर्शन देखने के लिए, fullDocument विकल्प में updateLookup वैल्यू का इस्तेमाल करें.

इस सुविधा के लिए, पीआईटीआर की ज़रूरत नहीं होती. साथ ही, यह दस्तावेज़ के लिए लुकअप की सुविधा उपलब्ध कराती है.

let cursor = db.my_collection.watch({
  "fullDocument": "updateLookup",
})

पैरलल में पढ़ना

थ्रूपुट बढ़ाने के लिए, firestoreWorkerConfig विकल्प का इस्तेमाल करके, Change Stream क्वेरी को कई वर्कर में बांटा जा सकता है. हर वर्कर, दस्तावेज़ों के अलग-अलग सेट के लिए, बदलावों को दिखाने की ज़िम्मेदारी लेता है. runCommand या aggregate क्वेरी की मदद से, पैरलल कर्सर बनाना होगा.

उदाहरण के लिए, Change Stream को तीन वर्कर में इस तरह डिस्ट्रिब्यूट किया जा सकता है:

let cursor1 = db.my_collection.aggregate([{
    "$changeStream": {
        "firestoreWorkerConfig": {numWorkers: 3, workerId: 0 }}
  }]);

let cursor2 = db.my_collection.aggregate([{
    "$changeStream": {
        "firestoreWorkerConfig": {numWorkers: 3, workerId: 1 }}
  }]);

let cursor3 = db.my_collection.aggregate([{
    "$changeStream": {
        "firestoreWorkerConfig": {numWorkers: 3, workerId: 2 }}
  }]);

Change Streams और बैकअप

बैकअप को रीस्टोर करने की कार्रवाइयों में, न तो Change Stream का कॉन्फ़िगरेशन और न ही Change Stream का डेटा उपलब्ध होता है. अगर Change Streams वाले किसी डेटाबेस को रीस्टोर किया जाता है, तो आपको डेस्टिनेशन डेटाबेस में उन Change Streams को फिर से बनाना होगा, ताकि उस डेटाबेस के कर्सर खोले जा सकें.

बिलिंग

व्यवहार में अंतर

इस सेक्शन में, MongoDB के साथ काम करने वाले Firestore और MongoDB के बीच, Change Streams में अंतर के बारे में बताया गया है.

updateDescription

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

  • updateDescription में, truncatedArrays और disambiguatedPaths फ़ील्ड नहीं भरे जाते.
  • updateDescription.updatedFields , म्यूटेशन लागू करने से पहले और बाद में, किसी दस्तावेज़ की पहले और बाद की इमेज के बीच, कैननिकल अंतर दिखाते हैं.

किसी दस्तावेज़ की शुरुआती स्थिति का यह उदाहरण देखें:

db.my_collection.insertOne({
  _id: 1,
  root: {
    array: [{a: 1}, {b: 2}, {c: 3}]
  }
})

पहली स्थिति: सिर्फ़ कलेक्शन के पहले एलिमेंट में बदलाव करना.

इस स्थिति में, Cloud Firestore का व्यवहार, MongoDB के जैसा होता है.

db.my_collection.updateOne(
  {_id: 1},
  {'$set': {"root.array.0.a": 100}}
)

{
  updatedFields: {"root.array.0.a": 100},
  removedFields: []
}

दूसरी स्थिति: पूरे कलेक्शन को ओवरराइट करना

इस स्थिति में, कार्रवाई से सिर्फ़ पहले कलेक्शन फ़ील्ड को अपडेट किया जाता है. हालांकि, पूरे कलेक्शन को ओवरराइट किया जाता है.

Cloud Firestore में, अपडेट के अंतर में इन दोनों स्थितियों के बीच अंतर नहीं किया जाता. साथ ही, दोनों के लिए एक ही updateDescription.updatedFields दिखाया जाता है:

db.my_collection.updateOne(
  {_id: 1},
  {'$set': {"root.array": [{a: 100}, {b: 2}, {c: 3}]}}
)

// In other implementations, updatedFields reflects the mutation itself
{
  updatedFields: {
    "root.array": [{a: 100}, {b: 2}, {c: 3}]
  },
  removedFields: []
}

// Firestore updatedFields is the diff between the before and after versions of the document
{
  updatedFields: {"root.array.0.a": 100},
  removedFields: []
}

आगे क्या करना है