पाइपलाइन के ऑपरेशन के लिए सुरक्षा के नियम

पाइपलाइन ऑपरेशन में कई तरह की सुविधाएं मिलती हैं. हालांकि, नियमों का इंजन सिर्फ़ तुलना करने वाले (जैसे, >) और लॉजिकल (जैसे, or) फ़िल्टर को पहचान सकता है. इससे, पाबंदियों को पूरा करने और सुरक्षा को पक्का करने में मदद मिलती है.

साथ काम करने वाले फ़िल्टर एक्सप्रेशन

पाइपलाइन ऑपरेशन को आपके नियमों के मुताबिक सेट की गई सीमाओं तक सीमित रखने के लिए, कॉन्स्टेंट के लिए लॉजिकल और कंपैरिज़न ऑपरेटर का इस्तेमाल करना ज़रूरी है. नियम इंजन, फ़िल्टर के इन टाइप को पहचानता है:

  • तुलना: eq, neq, gt, gte, lt, lte, in, arrayContains.
  • लॉजिकल: and, or.

यहां कुछ उदाहरण दिए गए हैं:

  • where(eq("foo", 2))
  • where(lt("foo", 2))
  • documents("/user/1", "/user/2").where(...)

अनुरोध की प्रॉपर्टी

पुष्टि करने और क्वेरी के संदर्भ की पुष्टि करने के लिए, request ऑब्जेक्ट का इस्तेमाल जारी रखा जा सकता है. हालांकि, स्टैंडर्ड क्वेरी में उपलब्ध कुछ प्रॉपर्टी, पाइपलाइन ऑपरेशन में काम नहीं करती हैं.

इस्तेमाल की जा सकने वाली प्रॉपर्टी

नए इंजन में ये प्रॉपर्टी काम करती रहेंगी:

  • request.auth: उपयोगकर्ता के यूआईडी और टोकन डेटा को ऐक्सेस करना.
  • request.method: इससे कार्रवाई की पहचान होती है. उदाहरण के लिए, get, list.
  • request.path: ऐक्सेस किए जा रहे संसाधन का पाथ.
  • request.time: अनुरोध का सर्वर-साइड टाइमस्टैंप.

इस्तेमाल न की जा सकने वाली प्रॉपर्टी

request.query प्रॉपर्टी, जैसे कि limit, offset, और orderBy, पाइपलाइन ऑपरेशन के नियम की जांच के लिए काम नहीं करती हैं. इसकी वजह यह है कि कई चरणों वाली क्वेरी में इन वैल्यू को तय करना मुश्किल होता है.

पाइपलाइन स्टेज को मैनेज करना और अनुमतियां देना

पाइपलाइन के अलग-अलग चरण होते हैं, जो सुरक्षा नियमों में खास तौर पर बारीकी से की जाने वाली कार्रवाइयों से मैप होते हैं:

  • allow list अनुमतियां: collection(), collectionGroup(), और database() स्टेज से ट्रिगर होती हैं.
  • allow get अनुमतियां: documents() स्टेज से ट्रिगर होती हैं. इसे बैच get ऑपरेशन की तरह ही माना जाता है.
  • allow create अनुमतियां: नए दस्तावेज़ बनाते समय, insert() स्टेज और upsert() स्टेज से ट्रिगर होती हैं.
  • allow update अनुमतियां: मौजूदा दस्तावेज़ों को अपडेट करते समय, update() स्टेज और upsert() स्टेज से ट्रिगर होती हैं.
  • allow delete अनुमतियां: delete() स्टेज से ट्रिगर की गई हैं.
  • allow write अनुमतियां: यह सभी डीएमएल ऑपरेशन (insert(), update(), upsert(), और delete()) पर लागू होता है.
  • लिटरल स्टेज: literals() स्टेज, डेटाबेस से डेटा नहीं पढ़ता. हालांकि, इसमें शुल्क लग सकता है. गलत इस्तेमाल को रोकने के लिए, इसे किसी अन्य चरण (जैसे, collection()) के साथ जोड़ना ज़रूरी है. इसकी पुष्टि नियमों के हिसाब से की जा सकती है.

फ़ील्ड में बदलाव करने के चरण

नियम सिर्फ़ सेव किए गए डेटा पर लागू होते हैं, न कि उससे मिली वैल्यू पर. अगर किसी पाइपलाइन में ऐसे चरण शामिल हैं जो फ़ील्ड में बदलाव करते हैं (उदाहरण के लिए, add_fields(...), replace_with(...), select(...), remove_fields(...)), तो उस चरण के बाद, नियमों का इंजन फ़िल्टर की पाबंदियां लागू करना बंद कर देता है. यह पक्का करने के लिए कि नियम उम्मीद के मुताबिक काम करें, फ़िल्टर के चरणों (जैसे, where) को उन चरणों से पहले रखें जो सेव किए गए ओरिजनल दस्तावेज़ों में बदलाव कर सकते हैं.

उदाहरण के लिए, सुरक्षा से जुड़ा यह नियम देखें:

match /databases/{database}/documents {
  match /cities/{city} {
    // Allow the user to read data if the document has the 'visibility'
    // field set to 'public'
    allow read: if resource.data.visibility == 'public';
  }
}

अस्वीकार किया गया: यह नियम, इस पाइपलाइन को अस्वीकार करता है, क्योंकि addFields स्टेज, उन दस्तावेज़ों को फ़िल्टर करने से पहले होती है जिनमें visibility की वैल्यू public है:

const results = await db.pipeline()
  .collection("/cities")
  // Filters after a modification stage are ignored by Rules.
  .addFields(constant(1000).as("population"))
  .where(eq(field("visibility"), constant("public")))
  .execute();

अनुमति है: यह नियम, इस पाइपलाइन को अनुमति देता है, क्योंकि where(eq(field("visibility"), constant("public"))) स्टेज, बदलाव करने वाली किसी भी स्टेज से पहले होती है:

const results = await db.pipeline()
  .collection("/cities")
  .where(eq(field("visibility"), constant("public")))
  .addFields(constant(1000).as("population"))
  .execute();

डेटा में बदलाव करने वाली कंप्यूटर प्रोग्राम की भाषा (डीएमएल) के स्टेज और सुरक्षा के नियम

डेटा में बदलाव करने वाली कंप्यूटर प्रोग्राम की भाषा (डीएमएल) के चरणों (insert(), update(), upsert(), और delete()) को लागू करते समय, सुरक्षा के नियम, क्वेरी को पढ़ने के मुकाबले अनुमतियों का आकलन अलग तरीके से करते हैं:

  • हर दस्तावेज़ के लिए नियम का आकलन: रीड पाइपलाइन के लिए, फ़िल्टर एक्सप्रेशन की ज़रूरत पहले से होती है, ताकि प्लानिंग के समय क्वेरी को सीमित किया जा सके. हालांकि, डीएमएल ऑपरेशन, हर दस्तावेज़ में किए गए बदलाव के लिए सुरक्षा नियमों का आकलन करते हैं.
  • नियम के वैरिएबल:
    • request.resource: इसमें insert(), update(), और upsert() कार्रवाइयों के लिए, सुझाए गए दस्तावेज़ का डेटा शामिल होता है.
    • resource: इसमें बदलाव करने से पहले, डेटाबेस में सेव किया गया मौजूदा दस्तावेज़ डेटा शामिल होता है. यह मौजूदा दस्तावेज़ों के update(), delete(), और upsert() के लिए उपलब्ध होता है.

डीएमएल के साथ सिस्टम की सीमाएं और एक्ज़ीक्यूशन का तरीका

सुरक्षा नियमों के साथ डीएमएल ऑपरेशन चलाते समय, सिस्टम की इन सीमाओं और एक्ज़ीक्यूशन के व्यवहारों को ध्यान में रखें:

get() और exists() पर, 20 बार लुकअप करने की सीमा

Firebase Security Rules, पूरे अनुरोध में ज़्यादा से ज़्यादा 20 दस्तावेज़ लुकअप (get() या exists()) की अनुमति देता है.

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

भले ही, आपके सुरक्षा नियम किसी एक स्टैटिक दस्तावेज़ के हिसाब से जांच करते हों (उदाहरण के लिए, यह जांचना कि कोई उपयोगकर्ता एडमिन है या नहीं):

rules_version = '2';
service cloud.firestore {
  match /databases/{database}/documents {
    match /posts/{postId} {
      allow write: if get(/databases/$(database)/documents/users/$(request.auth.uid)).data.isAdmin == true;
    }
  }
}

10 दस्तावेज़ों का हर राइट बैच, एक लुकअप करता है. इस वजह से, सभी संभावित दस्तावेज़ लिखने के बाद, अनुरोध के लिए 20-लुकअप की सीमा पूरी हो जाती है. साथ ही, पाइपलाइन PERMISSION_DENIED गड़बड़ी के साथ काम करना बंद कर देती है. इसके अलावा, हर राइट बैच के लिए किए गए हर लुकअप के लिए, रीड बिलिंग अलग से होती है.

कुछ हद तक पूरा हुआ और PERMISSION_DENIED

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

हालांकि, पहले से कमिट किए गए बैच वापस नहीं लिए जाते. डेटाबेस, कुछ हद तक अपडेट की गई स्थिति में रहता है. क्लाइंट को बदलाव किए गए दस्तावेज़ों की सूची के बिना गड़बड़ी का मैसेज मिलता है. इसलिए, आपको अपने डेटा की क्वेरी करनी होगी, ताकि यह पता लगाया जा सके कि कौनसे राइट ऑपरेशन सफल रहे.

Cloud ऑडिट लॉग की मदद से, नियम लागू न होने की वजह का पता लगाना

सुरक्षा से जुड़ी वजहों से, क्लाइंट को दिखने वाली PERMISSION_DENIED गड़बड़ियों से यह ज़ाहिर नहीं होता कि सुरक्षा से जुड़ी किस नियम की शर्त पूरी नहीं हुई या 20 लुकअप की सीमा पूरी हो गई है.

नियम के आकलन में होने वाली गड़बड़ियों का पता लगाने के लिए, प्रोजेक्ट एडमिन Google Cloud Console में Cloud ऑडिट लॉग की जांच कर सकते हैं. इसके लिए, उन्हें Firestore > मॉनिटरिंग या लॉग एक्सप्लोरर में जाना होगा. यहां उन्हें EvaluationError की पूरी जानकारी वाली एंट्री दिखेंगी.