Cloud Firestore के सुरक्षा नियमों का स्ट्रक्चर तैयार करना

Cloud Firestore Security Rules की मदद से, डेटाबेस में मौजूद दस्तावेज़ों और कलेक्शन के ऐक्सेस को कंट्रोल किया जा सकता है. नियमों के फ़्लेक्सिबल सिंटैक्स की मदद से, ऐसे नियम बनाए जा सकते हैं जो किसी भी चीज़ से मैच हो सकते हैं. जैसे, सभी राइट ऑपरेशन, पूरे डेटाबेस या किसी खास दस्तावेज़ पर की जाने वाली कार्रवाइयां.

इस गाइड में, सुरक्षा नियमों के बुनियादी सिंटैक्स और स्ट्रक्चर के बारे में बताया गया है. नियमों के पूरे सेट बनाने के लिए, इस सिंटैक्स को सुरक्षा नियमों की शर्तों के साथ मिलाएं.

सेवा और डेटाबेस का एलान

Cloud Firestore Security Rules हमेशा इस एलान से शुरू होते हैं:

service cloud.firestore {
  // The {database} wildcard allows the rules to reference any database,
  // but these rules are only active on databases where they are explicitly deployed.
  match /databases/{database}/documents {
    // ...
  }
}

The service cloud.firestore एलान, नियमों को Cloud Firestore तक सीमित रखता है. इससे Cloud Firestore Security Rules और Cloud Storage जैसे अन्य प्रॉडक्ट के नियमों के बीच टकराव नहीं होता.

The match /databases/{database}/documents एलान से पता चलता है कि नियम प्रोजेक्ट में मौजूद किसी भी Cloud Firestore डेटाबेस से मैच होने चाहिए. किसी प्रोजेक्ट में ज़्यादा से ज़्यादा 100 डेटाबेस हो सकते हैं. हालांकि, सिर्फ़ पहले बनाए गए डेटाबेस को डिफ़ॉल्ट के तौर पर तय किया जाता है.

Cloud Firestore Security Rules आपके प्रोजेक्ट में मौजूद हर नाम वाले डेटाबेस पर अलग-अलग लागू होते हैं. इसका मतलब है कि अगर आपने एक से ज़्यादा डेटाबेस बनाए हैं, तो आपको हर डेटाबेस के लिए नियमों को अलग-अलग मैनेज और डिप्लॉय करना होगा. अपडेट डिप्लॉय करने के बारे में ज़्यादा जानने के लिए, अपने अपडेट डिप्लॉय करना लेख पढ़ें.

पढ़ने/लिखने के बुनियादी नियम

बुनियादी नियमों में, match स्टेटमेंट शामिल होता है. इसमें दस्तावेज़ का पाथ तय किया जाता है. साथ ही, allow एक्सप्रेशन में यह बताया जाता है कि तय किया गया डेटा कब पढ़ा जा सकता है:

service cloud.firestore {
  match /databases/{database}/documents {

    // Match any document in the 'cities' collection
    match /cities/{city} {
      allow read: if <condition>;
      allow write: if <condition>;
    }
  }
}

सभी मैच स्टेटमेंट, कलेक्शन के बजाय दस्तावेज़ों की ओर इशारा करने चाहिए. कोई मैच स्टेटमेंट, किसी खास दस्तावेज़ की ओर इशारा कर सकता है. जैसे, match /cities/SF. इसके अलावा, वाइल्डकार्ड का इस्तेमाल करके, तय किए गए पाथ में मौजूद किसी भी दस्तावेज़ की ओर इशारा किया जा सकता है. जैसे, match /cities/{city}.

ऊपर दिए गए उदाहरण में, मैच स्टेटमेंट में {city} वाइल्डकार्ड सिंटैक्स का इस्तेमाल किया गया है. इसका मतलब है कि यह नियम, cities कलेक्शन में मौजूद किसी भी दस्तावेज़ पर लागू होता है. जैसे, /cities/SF या /cities/NYC. मैच स्टेटमेंट में मौजूद allow एक्सप्रेशन का आकलन करने पर, city वैरिएबल, शहर के दस्तावेज़ के नाम में बदल जाएगा. जैसे, SF या NYC.

बेहतर कार्रवाइयां

कुछ मामलों में, read और write को ज़्यादा बेहतर कार्रवाइयों में बांटना काम का होता है. उदाहरण के लिए, हो सकता है कि आपका ऐप्लिकेशन, दस्तावेज़ बनाने के लिए अलग शर्तें और दस्तावेज़ मिटाने के लिए अलग शर्तें लागू करना चाहे. इसके अलावा, हो सकता है कि आपको सिर्फ़ एक दस्तावेज़ को पढ़ने की अनुमति देनी हो, लेकिन बड़ी क्वेरी की अनुमति न देनी हो.

read नियम को get और list में बांटा जा सकता है. वहीं, write नियम को create, update, और delete में बांटा जा सकता है:

service cloud.firestore {
  match /databases/{database}/documents {
    // A read rule can be divided into get and list rules

    match /cities/{city} {
      // Applies to single document read requests
      allow get: if <condition>;

      // Applies to queries and collection read requests
      allow list: if <condition>;
    }
    // A write rule can be divided into create, update, and delete rules
    match /cities/{city} {
      // Applies to writes to nonexistent documents
      allow create: if <condition>;

      // Applies to writes to existing documents
      allow update: if <condition>;

      // Applies to delete operations
      allow delete: if <condition>;
    }
  }
}

क्रम में व्यवस्थित डेटा

Cloud Firestore में डेटा, दस्तावेज़ों के कलेक्शन में व्यवस्थित होता है. हर दस्तावेज़, सब-कलेक्शन के ज़रिए क्रम में व्यवस्थित डेटा को बढ़ा सकता है. यह समझना ज़रूरी है कि सुरक्षा नियम, क्रम में व्यवस्थित डेटा के साथ कैसे इंटरैक्ट करते हैं.

मान लें कि cities कलेक्शन में मौजूद हर दस्तावेज़ में, landmarks सब-कलेक्शन शामिल है. सुरक्षा नियम सिर्फ़ मैच किए गए पाथ पर लागू होते हैं. इसलिए, cities कलेक्शन पर तय किए गए ऐक्सेस कंट्रोल, landmarks सब-कलेक्शन पर लागू नहीं होते. इसके बजाय, सब-कलेक्शन के ऐक्सेस को कंट्रोल करने के लिए, साफ़ तौर पर नियम लिखें:

service cloud.firestore {
  match /databases/{database}/documents {
    match /cities/{city} {
      allow read, write: if <condition>;

        // Explicitly define rules for the 'landmarks' subcollection
        match /landmarks/{landmark} {
          allow read, write: if <condition>;
        }
    }
  }
}

match स्टेटमेंट को नेस्ट करने पर, अंदरूनी match स्टेटमेंट का पाथ हमेशा बाहरी match स्टेटमेंट के पाथ के हिसाब से होता है. इसलिए, नियमों के ये सेट एक जैसे हैं:

service cloud.firestore {
  match /databases/{database}/documents {
    match /cities/{city} {
      match /landmarks/{landmark} {
        allow read, write: if <condition>;
      }
    }
  }
}

service cloud.firestore {
  match /databases/{database}/documents {
    match /cities/{city}/landmarks/{landmark} {
      allow read, write: if <condition>;
    }
  }
}

बार-बार होने वाले वाइल्डकार्ड

अगर आपको नियमों को किसी भी क्रम में व्यवस्थित डेटा पर लागू करना है, तो बार-बार होने वाले वाइल्डकार्ड सिंटैक्स, {name=**} का इस्तेमाल करें. उदाहरण के लिए:

service cloud.firestore {
  match /databases/{database}/documents {
    // Matches any document in the cities collection as well as any document
    // in a subcollection.
    match /cities/{document=**} {
      allow read, write: if <condition>;
    }
  }
}

बार-बार होने वाले वाइल्डकार्ड सिंटैक्स का इस्तेमाल करने पर, वाइल्डकार्ड वैरिएबल में मैच करने वाला पूरा पाथ सेगमेंट शामिल होगा. भले ही, दस्तावेज़ किसी क्रम में व्यवस्थित सब-कलेक्शन में मौजूद हो. उदाहरण के लिए, ऊपर दिए गए नियम, /cities/SF/landmarks/coit_tower पर मौजूद किसी दस्तावेज़ से मैच होंगे. साथ ही, document वैरिएबल की वैल्यू SF/landmarks/coit_tower होगी.

हालांकि, ध्यान दें कि बार-बार होने वाले वाइल्डकार्ड का व्यवहार, नियमों के वर्शन पर निर्भर करता है.

rules_version = '2';
service cloud.firestore {
 match /databases/{database}/documents {
   // Matches any document in the cities collection as well as any document
   // in a subcollection.
   match /cities/{city}/{document=**} {
     allow read, write: if <condition>;
   }
 }
}

rules_version = '2';
service cloud.firestore {
 match /databases/{database}/documents {
   // Matches any document in the songs collection group
   match /{path=**}/songs/{song} {
     allow read, write: if <condition>;
   }
 }
}

अगर आप कलेक्शन ग्रुप क्वेरी का इस्तेमाल करते हैं, तो आपको वर्शन 2 का इस्तेमाल करना होगा. इसके बारे में ज़्यादा जानने के लिए, कलेक्शन ग्रुप क्वेरी को सुरक्षित करना लेख पढ़ें.

मैच करने वाले स्टेटमेंट का ओवरलैप होना

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

service cloud.firestore {
  match /databases/{database}/documents {
    // Matches any document in the 'cities' collection.
    match /cities/{city} {
      allow read, write: if false;
    }

    // Matches any document in the 'cities' collection or subcollections.
    match /cities/{document=**} {
      allow read, write: if true;
    }
  }
}

ऊपर दिए गए उदाहरण में, cities कलेक्शन के सभी रीड और राइट ऑपरेशन की अनुमति दी जाएगी, क्योंकि दूसरा नियम हमेशा true होता है. भले ही, पहला नियम हमेशा false हो.

सुरक्षा नियमों की सीमाएं

सुरक्षा नियमों के साथ काम करते समय, इन सीमाओं का ध्यान रखें:

अगले चरण

• सुरक्षा नियमों की शर्तें तय करना लेख पढ़ें.
• सुरक्षा नियमों का रेफ़रंस लेख पढ़ें.