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

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

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

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

Change Streams की सुविधा में, ये सुविधाएं उपलब्ध हैं:

• डेटाबेस या कलेक्शन के दायरे के साथ, कॉन्फ़िगर की जा सकने वाली Change Streams.
• Change Streams के लिए, डेटा के रखरखाव की अवधि तय की जा सकती है. यह अवधि, स्ट्रीम बनाते समय तय की जाती है. डिफ़ॉल्ट तौर पर, डेटा के रखरखाव की अवधि सात दिन होती है. वहीं, कम से कम अवधि एक दिन होती है. डेटा के रखरखाव की अवधि, एक दिन के मल्टीपल में होनी चाहिए. यह अवधि, ज़्यादा से ज़्यादा सात दिन हो सकती है. स्ट्रीम बनाने के बाद, डेटा के रखरखाव की अवधि में बदलाव नहीं किया जा सकता. डेटा के रखरखाव की अवधि में बदलाव करने के लिए, आपको Change Streams को हटाकर फिर से बनाना होगा.
• 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 Streams बनाना

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

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

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

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

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

Change Streams देखना

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

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

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

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

Change Streams मिटाना

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

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

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

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

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

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

Change Streams कर्सर बनाने से पहले, आपको डेटाबेस या कलेक्शन के लिए, Change Streams बनाना होगा.

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

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

let cursor = db.watch()

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

let cursor = db.my_collection.watch()

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

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

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

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 Streams फिर से शुरू करना

Change Streams को फिर से शुरू करने के लिए, 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 फ़ील्ड शामिल होता है. यह फ़ील्ड, अपडेट की कार्रवाई से बदले गए फ़ील्ड का डेल्टा होता है.

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

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 Streams की क्वेरी को कई वर्कर में बांटा जा सकता है. हर वर्कर, दस्तावेज़ों के अलग-अलग सेट के लिए, बदलावों को दिखाने की ज़िम्मेदारी लेता है. runCommand या aggregate क्वेरी की मदद से, पैरलल कर्सर बनाना होगा.

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

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 Streams का कॉन्फ़िगरेशन और न ही Change Streams का डेटा उपलब्ध होता है. अगर Change Streams वाले किसी डेटाबेस को रीस्टोर किया जाता है, तो उस डेटाबेस के कर्सर खोलने के लिए, आपको डेस्टिनेशन डेटाबेस में, उन Change Streams को फिर से बनाना होगा.

बिलिंग

• 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: []
}

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

• बड़े पैमाने पर, डेटा को पढ़ने और लिखने के तरीके के बारे में जानना
• क्वेरी के एक्ज़ीक्यूशन को ऑप्टिमाइज़ करना