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

फायरबेस सुरक्षा नियमों के साथ अपने फायरस्टोर डेटा को सुरक्षित रखें

1. शुरू करने से पहले

क्लाउड फायरस्टोर, फायरबेस के लिए क्लाउड स्टोरेज और रीयलटाइम डेटाबेस पढ़ने और लिखने की पहुंच प्रदान करने के लिए आपके द्वारा लिखी गई कॉन्फ़िगरेशन फ़ाइलों पर निर्भर करते हैं। वह कॉन्फ़िगरेशन, जिसे सुरक्षा नियम कहा जाता है, आपके ऐप के लिए एक प्रकार की स्कीमा के रूप में भी कार्य कर सकता है। यह आपके एप्लिकेशन को विकसित करने के सबसे महत्वपूर्ण भागों में से एक है। और यह कोडलैब आपको इसके बारे में बताएगा।

आवश्यक शर्तें

एक साधारण संपादक जैसे विज़ुअल स्टूडियो कोड, एटम, या सबलाइम टेक्स्ट
Node.js 8.6.0 या उच्चतर (Node.js स्थापित करने के लिए, nvm का उपयोग करें ; अपने संस्करण की जांच करने के लिए, node --version चलाएं)
जावा 7 या उच्चतर (जावा स्थापित करने के लिए इन निर्देशों का उपयोग करें ; अपने संस्करण की जांच करने के लिए, java -version चलाएँ)

आप क्या करोगे

इस कोडलैब में, आप फायरस्टोर पर निर्मित एक सरल ब्लॉग प्लेटफ़ॉर्म सुरक्षित करेंगे। आप सुरक्षा नियमों के विरुद्ध यूनिट परीक्षण चलाने के लिए फायरस्टोर एमुलेटर का उपयोग करेंगे, और यह सुनिश्चित करेंगे कि नियम आपके द्वारा अपेक्षित पहुंच की अनुमति दें और न दें।

आप सीखेंगे कि कैसे:

विस्तृत अनुमतियाँ प्रदान करें
डेटा और प्रकार सत्यापन लागू करें
विशेषता आधारित अभिगम नियंत्रण लागू करें
प्रमाणीकरण पद्धति के आधार पर पहुंच प्रदान करें
कस्टम फ़ंक्शन बनाएं
समय-आधारित सुरक्षा नियम बनाएं
एक अस्वीकृत सूची और सॉफ्ट डिलीट लागू करें
समझें कि एकाधिक एक्सेस पैटर्न को पूरा करने के लिए डेटा को कब असामान्य बनाना है

2. सेटअप

यह एक ब्लॉगिंग एप्लीकेशन है. यहां एप्लिकेशन कार्यक्षमता का उच्च स्तरीय सारांश दिया गया है:

ड्राफ्ट ब्लॉग पोस्ट:

उपयोगकर्ता ड्राफ्ट ब्लॉग पोस्ट बना सकते हैं, जो drafts संग्रह में रहते हैं।
लेखक ड्राफ्ट को तब तक अपडेट करना जारी रख सकता है जब तक वह प्रकाशित होने के लिए तैयार न हो जाए।
जब यह प्रकाशित होने के लिए तैयार होता है, तो एक फायरबेस फ़ंक्शन ट्रिगर हो जाता है जो published संग्रह में एक नया दस्तावेज़ बनाता है।
ड्राफ्ट को लेखक या साइट मॉडरेटर द्वारा हटाया जा सकता है

प्रकाशित ब्लॉग पोस्ट:

प्रकाशित पोस्ट उपयोगकर्ताओं द्वारा केवल एक फ़ंक्शन के माध्यम से नहीं बनाई जा सकती हैं।
उन्हें केवल सॉफ्ट-डिलीट किया जा सकता है, जो visible विशेषता को गलत में अपडेट करता है।

टिप्पणियाँ

प्रकाशित पोस्ट टिप्पणियों की अनुमति देती हैं, जो प्रत्येक प्रकाशित पोस्ट पर एक उपसंग्रह है।
दुरुपयोग को कम करने के लिए, उपयोगकर्ताओं के पास एक सत्यापित ईमेल पता होना चाहिए और कोई टिप्पणी छोड़ने के लिए इनकार करने वाले पर नहीं होना चाहिए।
टिप्पणियाँ पोस्ट होने के एक घंटे के भीतर ही अपडेट की जा सकती हैं।
टिप्पणियों को टिप्पणी लेखक, मूल पोस्ट के लेखक या मॉडरेटर द्वारा हटाया जा सकता है।

एक्सेस नियमों के अलावा, आप सुरक्षा नियम बनाएंगे जो आवश्यक फ़ील्ड और डेटा सत्यापन लागू करते हैं।

फायरबेस एमुलेटर सूट का उपयोग करके सब कुछ स्थानीय रूप से होगा।

स्रोत कोड प्राप्त करें

इस कोडलैब में, आप सुरक्षा नियमों के लिए परीक्षणों के साथ शुरुआत करेंगे, लेकिन न्यूनतम सुरक्षा नियम स्वयं, इसलिए पहली चीज़ जो आपको करने की ज़रूरत है वह है परीक्षण चलाने के लिए स्रोत को क्लोन करना:

$ git clone https://github.com/FirebaseExtended/codelab-rules.git

फिर आरंभिक-स्थिति निर्देशिका में जाएँ, जहाँ आप इस कोडलैब के शेष भाग के लिए काम करेंगे:

$ cd codelab-rules/initial-state

अब, निर्भरताएँ स्थापित करें ताकि आप परीक्षण चला सकें। यदि आप धीमे इंटरनेट कनेक्शन पर हैं तो इसमें एक या दो मिनट लग सकते हैं:

# Move into the functions directory, install dependencies, jump out.
$ cd functions && npm install && cd -

फायरबेस सीएलआई प्राप्त करें

परीक्षण चलाने के लिए आप जिस एमुलेटर सूट का उपयोग करेंगे वह फायरबेस सीएलआई (कमांड-लाइन इंटरफ़ेस) का हिस्सा है जिसे निम्नलिखित कमांड के साथ आपकी मशीन पर स्थापित किया जा सकता है:

$ npm install -g firebase-tools

इसके बाद, पुष्टि करें कि आपके पास सीएलआई का नवीनतम संस्करण है। इस कोडलैब को संस्करण 8.4.0 या उच्चतर के साथ काम करना चाहिए लेकिन बाद के संस्करणों में अधिक बग फिक्स शामिल हैं।

$ firebase --version
9.10.2

3. परीक्षण चलाएँ

इस अनुभाग में, आप स्थानीय स्तर पर परीक्षण चलाएंगे। इसका मतलब यह है कि एम्यूलेटर सुइट को बूट करने का समय आ गया है।

एम्यूलेटर प्रारंभ करें

आप जिस एप्लिकेशन के साथ काम करेंगे, उसमें तीन मुख्य फायरस्टोर संग्रह हैं: drafts में ब्लॉग पोस्ट शामिल हैं जो प्रगति पर हैं, published संग्रह में वे ब्लॉग पोस्ट शामिल हैं जो प्रकाशित हो चुके हैं, और comments प्रकाशित पोस्ट पर एक उपसंग्रह हैं। रेपो सुरक्षा नियमों के लिए यूनिट परीक्षणों के साथ आता है जो drafts , published और comments संग्रह में दस्तावेज़ बनाने, पढ़ने, अपडेट करने और हटाने के लिए उपयोगकर्ता की विशेषताओं और अन्य शर्तों को परिभाषित करता है। आप उन परीक्षणों को पास कराने के लिए सुरक्षा नियम लिखेंगे।

शुरू करने के लिए, आपका डेटाबेस लॉक कर दिया गया है: डेटाबेस को पढ़ने और लिखने से सार्वभौमिक रूप से इनकार कर दिया गया है, और सभी परीक्षण विफल हो गए हैं। जैसे ही आप सुरक्षा नियम लिखेंगे, परीक्षण पास हो जायेंगे। परीक्षण देखने के लिए, अपने संपादक में functions/test.js खोलें।

कमांड लाइन पर, emulators:exec उपयोग करके एमुलेटर प्रारंभ करें और परीक्षण चलाएँ:

$ firebase emulators:exec --project=codelab --import=.seed "cd functions; npm test"

आउटपुट के शीर्ष तक स्क्रॉल करें:

$ firebase emulators:exec --project=codelab --import=.seed "cd functions; npm test"
i  emulators: Starting emulators: functions, firestore, hosting
⚠  functions: The following emulators are not running, calls to these services from the Functions emulator will affect production: auth, database, pubsub
⚠  functions: Unable to fetch project Admin SDK configuration, Admin SDK behavior in Cloud Functions emulator may be incorrect.
i  firestore: Importing data from /Users/user/src/firebase/rules-codelab/initial-state/.seed/firestore_export/firestore_export.overall_export_metadata
i  firestore: Firestore Emulator logging to firestore-debug.log
⚠  hosting: Authentication error when trying to fetch your current web app configuration, have you run firebase login?
⚠  hosting: Could not fetch web app configuration and there is no cached configuration on this machine. Check your internet connection and make sure you are authenticated. To continue, you must call firebase.initializeApp({...}) in your code before using Firebase.
i  hosting: Serving hosting files from: public
✔  hosting: Local server: http://localhost:5000
i  functions: Watching "/Users/user/src/firebase/rules-codelab/initial-state/functions" for Cloud Functions...
✔  functions[publishPost]: http function initialized (http://localhost:5001/codelab/us-central1/publishPost).
✔  functions[softDelete]: http function initialized (http://localhost:5001/codelab/us-central1/softDelete).
i  Running script: pushd functions; npm test
~/src/firebase/rules-codelab/initial-state/functions ~/src/firebase/rules-codelab/initial-state

> functions@ test /Users/user/src/firebase/rules-codelab/initial-state/functions
> mocha

(node:76619) ExperimentalWarning: Conditional exports is an experimental feature. This feature could change at any time


  Draft blog posts
    1) can be created with required fields by the author
    2) can be updated by author if immutable fields are unchanged
    3) can be read by the author and moderator

  Published blog posts
    4) can be read by everyone; created or deleted by no one
    5) can be updated by author or moderator

  Comments on published blog posts
    6) can be read by anyone with a permanent account
    7) can be created if email is verfied and not blocked
    8) can be updated by author for 1 hour after creation
    9) can be deleted by an author or moderator


  0 passing (848ms)
  9 failing

...

यह आदेश एक बनी-बनाई परियोजना आईडी में गुजरता है; इस आईडी के साथ कोई वास्तविक फायरबेस प्रोजेक्ट नहीं है। वास्तविक प्रोजेक्ट आईडी आमतौर पर एमुलेटर के लिए आवश्यक नहीं होती हैं, लेकिन कम संख्या में उपयोग के मामलों के लिए आवश्यक होती हैं।

चूँकि एमुलेटर एक बनी-बनाई प्रोजेक्ट आईडी के साथ शुरू किए गए थे, इसलिए आपको सीमित कार्यक्षमता के बारे में चेतावनियाँ दिखनी चाहिए। यह ठीक है; आपको इस कोडलैब के लिए उस अतिरिक्त कार्यक्षमता की आवश्यकता नहीं होगी।

अभी 9 असफलताएं हैं. जैसे ही आप नियम फ़ाइल बनाते हैं, आप अधिक परीक्षणों को पास होते देखकर प्रगति को माप सकते हैं।

4. ब्लॉग पोस्ट ड्राफ्ट बनाएं.

क्योंकि ड्राफ्ट ब्लॉग पोस्ट की पहुंच प्रकाशित ब्लॉग पोस्ट की पहुंच से बहुत अलग है, यह ब्लॉगिंग ऐप ड्राफ्ट ब्लॉग पोस्ट को एक अलग संग्रह, /drafts में संग्रहीत करता है। ड्राफ्ट को केवल लेखक या मॉडरेटर द्वारा ही एक्सेस किया जा सकता है, और इसमें आवश्यक और अपरिवर्तनीय फ़ील्ड के लिए सत्यापन होता है।

firestore.rules फ़ाइल खोलने पर, आपको एक डिफ़ॉल्ट नियम फ़ाइल मिलेगी:

rules_version = '2';
service cloud.firestore {
  match /databases/{database}/documents {
    match /{document=**} {
      allow read, write: if false;
    }
  }
}

मिलान विवरण, match /{document=**} , उपसंग्रह में सभी दस्तावेज़ों पर पुनरावर्ती रूप से लागू करने के लिए ** सिंटैक्स का उपयोग कर रहा है। और क्योंकि यह शीर्ष स्तर पर है, अभी सभी अनुरोधों पर एक ही व्यापक नियम लागू होता है, इससे कोई फर्क नहीं पड़ता कि अनुरोध कौन कर रहा है या वे कौन सा डेटा पढ़ने या लिखने की कोशिश कर रहे हैं।

सबसे अंदरूनी मिलान विवरण को हटाकर और उसे match /drafts/{draftID} से प्रतिस्थापित करके प्रारंभ करें। (दस्तावेज़ों की संरचना की टिप्पणियाँ नियमों में सहायक हो सकती हैं, और इस कोडलैब में शामिल की जाएंगी; वे हमेशा वैकल्पिक होती हैं।)

rules_version = '2';
service cloud.firestore {
  match /databases/{database}/documents {
    match /drafts/{draftID} {
      // `authorUID`: string, required
      // `content`: string, optional
      // `createdAt`: timestamp, required
      // `title`: string, < 50 characters, required
      // `url`: string, optional
    }
  }
}

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

नियमों में, दो महत्वपूर्ण वस्तुएं हैं जिनका आप बार-बार उपयोग करेंगे। पहला resource है, ऑपरेशन होने से पहले का दस्तावेज़। क्रिएट के मामले में, अभी तक कुछ भी नहीं लिखा गया है, इसलिए resource शून्य है।

अन्य महत्वपूर्ण वस्तु request है, और इसमें दो महत्वपूर्ण फ़ील्ड हैं: request.auth ऑब्जेक्ट वह उपयोगकर्ता है जो पहुंच चाहता है। update और अनुरोध create के लिए, request.resource ऑब्जेक्ट दस्तावेज़ है क्योंकि यह लिखा जाएगा यदि उनका ऑपरेशन सफल होता है; यह पढ़ने के अनुरोधों के लिए मौजूद नहीं है।

निर्माण के लिए पहली शर्त होगी:

request.resource.data.authorUID == request.auth.uid

इसके बाद, दस्तावेज़ केवल तभी बनाए जा सकते हैं जब उनमें तीन आवश्यक फ़ील्ड, authorUID , createdAt और title शामिल हों। (उपयोगकर्ता createdAt फ़ील्ड की आपूर्ति नहीं करता है; यह लागू कर रहा है कि ऐप को दस्तावेज़ बनाने का प्रयास करने से पहले इसे जोड़ना होगा।) चूंकि आपको केवल यह जांचना है कि विशेषताएँ बनाई जा रही हैं, आप देख सकते हैं कि request.resource में सभी हैं वे कुंजियाँ:

request.resource.data.keys().hasAll([
  "authorUID",
  "createdAt",
  "title"
])

ब्लॉग पोस्ट बनाने की अंतिम आवश्यकता यह है कि शीर्षक 50 अक्षरों से अधिक लंबा नहीं हो सकता:

request.resource.data.title.size() < 50

चूँकि ये सभी स्थितियाँ सत्य होनी चाहिए, इन्हें तार्किक AND ऑपरेटर, && के साथ संयोजित करें। पहला नियम बनता है:

rules_version = '2';
service cloud.firestore {
  match /databases/{database}/documents {
    match /drafts/{draftID} {
      // `authorUID`: string, required
      // `content`: string, optional
      // `createdAt`: timestamp, required
      // `title`: string, < 50 characters, required
      // `url`: string, optional

      allow create: if
        // User creating document is draft author
        request.auth.uid == request.resource.data.authorUID &&
        // Must include title, author, and url fields
        request.resource.data.keys().hasAll([
          "authorUID",
          "createdAt",
          "title"
        ]) &&
        // Title must be < 50 characters long
        request.resource.data.title.size() < 50;
    }
  }
}

टर्मिनल में, परीक्षण दोबारा चलाएँ और पुष्टि करें कि पहला परीक्षण पास हो गया है।

5. ब्लॉग पोस्ट ड्राफ्ट अपडेट करें.

इसके बाद, जैसे-जैसे लेखक अपने ड्राफ्ट ब्लॉग पोस्ट को परिष्कृत करेंगे, वे ड्राफ्ट दस्तावेज़ों को संपादित करेंगे। उन शर्तों के लिए एक नियम बनाएं जब किसी पोस्ट को अपडेट किया जा सकता है। सबसे पहले, केवल लेखक ही अपने ड्राफ्ट को अपडेट कर सकते हैं। ध्यान दें कि यहां आप पहले से लिखे गए UID की जांच करें, resource.data.authorUID :

resource.data.authorUID == request.auth.uid

अद्यतन के लिए दूसरी आवश्यकता यह है कि दो विशेषताएँ, authorUID और createdAt नहीं बदलनी चाहिए:

request.resource.data.diff(resource.data).unchangedKeys().hasAll([
    "authorUID",
    "createdAt"
]);

और अंत में, शीर्षक 50 अक्षर या उससे कम होना चाहिए:

request.resource.data.title.size() < 50;

चूँकि इन सभी शर्तों को पूरा करना आवश्यक है, उन्हें && के साथ संयोजित करें:

allow update: if
  // User is the author, and
  resource.data.authorUID == request.auth.uid &&
  // `authorUID` and `createdAt` are unchanged
  request.resource.data.diff(resource.data).unchangedKeys().hasAll([
    "authorUID",
    "createdAt"
  ]) &&
  // Title must be < 50 characters long
  request.resource.data.title.size() < 50;

संपूर्ण नियम बन गए:

rules_version = '2';
service cloud.firestore {
  match /databases/{database}/documents {
    match /drafts/{draftID} {
      // `authorUID`: string, required
      // `content`: string, optional
      // `createdAt`: timestamp, required
      // `title`: string, < 50 characters, required
      // `url`: string, optional

      allow create: if
        // User creating document is draft author
        request.auth.uid == request.resource.data.authorUID &&
        // Must include title, author, and url fields
        request.resource.data.keys().hasAll([
          "authorUID",
          "createdAt",
          "title"
        ]) &&
        // Title must be < 50 characters long
        request.resource.data.title.size() < 50;

      allow update: if
        // User is the author, and
        resource.data.authorUID == request.auth.uid &&
        // `authorUID` and `createdAt` are unchanged
        request.resource.data.diff(resource.data).unchangedKeys().hasAll([
          "authorUID",
          "createdAt"
        ]) &&
        // Title must be < 50 characters long
        request.resource.data.title.size() < 50;
    }
  }
}

अपने परीक्षण दोबारा चलाएँ और पुष्टि करें कि दूसरा परीक्षण पास हो गया है।

6. ड्राफ्ट हटाएं और पढ़ें: विशेषता आधारित पहुंच नियंत्रण

जिस तरह लेखक ड्राफ्ट बना और अपडेट कर सकते हैं, उसी तरह वे ड्राफ्ट हटा भी सकते हैं।

resource.data.authorUID == request.auth.uid

इसके अतिरिक्त, जिन लेखकों के पास उनके ऑथ टोकन पर isModerator विशेषता है, उन्हें ड्राफ्ट हटाने की अनुमति है:

request.auth.token.isModerator == true

चूँकि इनमें से कोई भी शर्त हटाने के लिए पर्याप्त है, उन्हें तार्किक OR ऑपरेटर, || के साथ संयोजित करें :

allow delete: if resource.data.authorUID == request.auth.uid || request.auth.token.isModerator == true

वही शर्तें पढ़ने पर लागू होती हैं, ताकि अनुमति को नियम में जोड़ा जा सके:

allow read, delete: if resource.data.authorUID == request.auth.uid || request.auth.token.isModerator == true

पूर्ण नियम अब हैं:

rules_version = '2';
service cloud.firestore {
  match /databases/{database}/documents {
    match /drafts/{draftID} {
      // `authorUID`: string, required
      // `content`: string, optional
      // `createdAt`: timestamp, required
      // `title`: string, < 50 characters, required
      // `url`: string, optional

      allow create: if
        // User creating document is draft author
        request.auth.uid == request.resource.data.authorUID &&
        // Must include title, author, and url fields
        request.resource.data.keys().hasAll([
          "authorUID",
          "createdAt",
          "title"
        ]) &&
        // Title must be < 50 characters long
        request.resource.data.title.size() < 50;

      allow update: if
        // User is the author, and
        resource.data.authorUID == request.auth.uid &&
        // `authorUID` and `createdAt` are unchanged
        request.resource.data.diff(resource.data).unchangedKeys().hasAll([
          "authorUID",
          "createdAt"
        ]) &&
        // Title must be < 50 characters long
        request.resource.data.title.size() < 50;

      allow read, delete: if
        // User is draft author
        resource.data.authorUID == request.auth.uid ||
        // User is a moderator
        request.auth.token.isModerator == true;
    }
  }
}

अपने परीक्षण दोबारा चलाएँ और पुष्टि करें कि अब एक और परीक्षण पास हो गया है।

7. प्रकाशित पोस्ट को पढ़ता है, बनाता है और हटाता है: विभिन्न एक्सेस पैटर्न के लिए असामान्यकरण

चूँकि प्रकाशित पोस्ट और ड्राफ्ट पोस्ट के लिए एक्सेस पैटर्न बहुत अलग हैं, इसलिए यह ऐप पोस्ट को अलग-अलग draft और published संग्रह में बदल देता है। उदाहरण के लिए, प्रकाशित पोस्ट को कोई भी पढ़ सकता है लेकिन हार्ड-डिलीट नहीं किया जा सकता है, जबकि ड्राफ्ट को हटाया जा सकता है लेकिन केवल लेखक और मॉडरेटर ही पढ़ सकते हैं। इस ऐप में, जब कोई उपयोगकर्ता ड्राफ्ट ब्लॉग पोस्ट प्रकाशित करना चाहता है, तो एक फ़ंक्शन ट्रिगर हो जाता है जो नई प्रकाशित पोस्ट बनाएगा।

इसके बाद, आप प्रकाशित पोस्ट के लिए नियम लिखेंगे। लिखने का सबसे सरल नियम यह है कि प्रकाशित पोस्ट को कोई भी पढ़ सकता है, और कोई भी इसे बना या हटा नहीं सकता है। ये नियम जोड़ें:

match /published/{postID} {
  // `authorUID`: string, required
  // `content`: string, required
  // `publishedAt`: timestamp, required
  // `title`: string, < 50 characters, required
  // `url`: string, required
  // `visible`: boolean, required

  // Can be read by everyone
  allow read: if true;

  // Published posts are created only via functions, never by users
  // No hard deletes; soft deletes update `visible` field.
  allow create, delete: if false;
}

यदि कोई नियम निर्दिष्ट नहीं है, तो पहुंच डिफ़ॉल्ट रूप से अस्वीकृत है। इस जैसे नियम, allow create, delete: if false डेवलपर्स के लिए स्पष्टता जोड़ते हैं, लेकिन व्यवहार में बदलाव नहीं करते हैं।

यह सुनिश्चित करना भी महत्वपूर्ण है कि आपके नियमों में कहीं और कोई ओवरलैपिंग नियम न हो; यदि कोई नियम पहुंच प्रदान करता है, तो पहुंच प्रदान की जाएगी। आप अन्यत्र व्यापक allow कथन से दस्तावेज़ों को "बहिष्कृत" करने के लिए इस जैसे नियमों का उपयोग नहीं कर सकते।

इन्हें मौजूदा नियमों में जोड़ने पर, संपूर्ण नियम फ़ाइल बन जाती है:

rules_version = '2';
service cloud.firestore {
  match /databases/{database}/documents {
    match /drafts/{draftID} {
      // `authorUID`: string, required
      // `content`: string, optional
      // `createdAt`: timestamp, required
      // `title`: string, < 50 characters, required
      // `url`: string, optional

      allow create: if
        // User creating document is draft author
        request.auth.uid == request.resource.data.authorUID &&
        // Must include title, author, and url fields
        request.resource.data.keys().hasAll([
          "authorUID",
          "createdAt",
          "title"
        ]) &&
        // Title must be < 50 characters long
        request.resource.data.title.size() < 50;

      allow update: if
        // User is the author, and
        resource.data.authorUID == request.auth.uid &&
        // `authorUID` and `createdAt` are unchanged
        request.resource.data.diff(resource.data).unchangedKeys().hasAll([
          "authorUID",
          "createdAt"
        ]) &&
        // Title must be < 50 characters long
        request.resource.data.title.size() < 50;

      allow read, delete: if
        // User is draft author
        resource.data.authorUID == request.auth.uid ||
        // User is a moderator
        request.auth.token.isModerator == true;
    }

    match /published/{postID} {
      // `authorUID`: string, required
      // `content`: string, required
      // `publishedAt`: timestamp, required
      // `title`: string, < 50 characters, required
      // `url`: string, required
      // `visible`: boolean, required

      // Can be read by everyone
      allow read: if true;

      // Published posts are created only via functions, never by users
      // No hard deletes; soft deletes update `visible` field.
      allow create, delete: if false;
    }
  }
}

परीक्षण दोबारा चलाएँ, और पुष्टि करें कि दूसरा परीक्षण पास हो गया है।

8. प्रकाशित पोस्ट अपडेट करना: कस्टम फ़ंक्शन और स्थानीय चर

प्रकाशित पोस्ट को अपडेट करने की शर्तें हैं:

यह केवल लेखक या मॉडरेटर द्वारा ही किया जा सकता है, और
इसमें सभी आवश्यक फ़ील्ड शामिल होनी चाहिए.

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

एक कस्टम फ़ंक्शन बनाएं

ड्राफ्ट के लिए मैच स्टेटमेंट के ऊपर, isAuthorOrModerator नामक एक नया फ़ंक्शन बनाएं जो एक पोस्ट दस्तावेज़ को तर्क के रूप में लेता है (यह ड्राफ्ट या प्रकाशित पोस्ट के लिए काम करेगा) और उपयोगकर्ता का ऑथ ऑब्जेक्ट:

rules_version = '2';
service cloud.firestore {
  match /databases/{database}/documents {

    // Returns true if user is post author or a moderator
    function isAuthorOrModerator(post, auth) {

    }

    match /drafts/{postID} {
      allow create: ...
      allow update: ...
      ...
    }

    match /published/{postID} {
      allow read: ...
      allow create, delete: ...
    }
  }
}

स्थानीय चर का प्रयोग करें

फ़ंक्शन के अंदर, isAuthor और isModerator वेरिएबल सेट करने के लिए let कीवर्ड का उपयोग करें। सभी फ़ंक्शन एक रिटर्न स्टेटमेंट के साथ समाप्त होने चाहिए, और हमारा एक बूलियन लौटाएगा जो यह दर्शाता है कि कोई भी वेरिएबल सत्य है या नहीं:

function isAuthorOrModerator(post, auth) {
  let isAuthor = auth.uid == post.authorUID;
  let isModerator = auth.token.isModerator == true;
  return isAuthor || isModerator;
}

फ़ंक्शन को कॉल करें

अब आप उस फ़ंक्शन को कॉल करने के लिए ड्राफ्ट के नियम को अपडेट करेंगे, पहले तर्क के रूप में resource.data पास करने में सावधानी बरतेंगे:

  // Draft blog posts
  match /drafts/{draftID} {
    ...
    // Can be deleted by author or moderator
    allow read, delete: if isAuthorOrModerator(resource.data, request.auth);
  }

अब आप प्रकाशित पोस्ट को अपडेट करने के लिए एक शर्त लिख सकते हैं जो नए फ़ंक्शन का भी उपयोग करती है:

allow update: if isAuthorOrModerator(resource.data, request.auth);

सत्यापन जोड़ें

प्रकाशित पोस्ट के कुछ फ़ील्ड नहीं बदले जाने चाहिए, विशेष रूप से url , authorUID , और publishedAt फ़ील्ड अपरिवर्तनीय हैं। अन्य दो फ़ील्ड, title और content और visible अपडेट के बाद भी मौजूद रहने चाहिए। प्रकाशित पोस्ट के अपडेट के लिए इन आवश्यकताओं को लागू करने के लिए शर्तें जोड़ें:

// Immutable fields are unchanged
request.resource.data.diff(resource.data).unchangedKeys().hasAll([
  "authorUID",
  "publishedAt",
  "url"
]) &&
// Required fields are present
request.resource.data.keys().hasAll([
  "content",
  "title",
  "visible"
])

स्वयं एक कस्टम फ़ंक्शन बनाएं

और अंत में, एक शर्त जोड़ें कि शीर्षक 50 अक्षरों से कम हो। क्योंकि यह पुन: उपयोग किया जाने वाला तर्क है, आप एक नया फ़ंक्शन, titleIsUnder50Chars बनाकर ऐसा कर सकते हैं। नए फ़ंक्शन के साथ, प्रकाशित पोस्ट को अपडेट करने की शर्त बन जाती है:

allow update: if
  isAuthorOrModerator(resource.data, request.auth) &&
  // Immutable fields are unchanged
  request.resource.data.diff(resource.data).unchangedKeys().hasAll([
    "authorUID",
    "publishedAt",
    "url"
  ]) &&
  // Required fields are present
  request.resource.data.keys().hasAll([
    "content",
    "title",
    "visible"
  ]) &&
  titleIsUnder50Chars(request.resource.data);

और पूरी नियम फ़ाइल है:

rules_version = '2';
service cloud.firestore {
  match /databases/{database}/documents {

    // Returns true if user is post author or a moderator
    function isAuthorOrModerator(post, auth) {
      let isAuthor = auth.uid == post.authorUID;
      let isModerator = auth.token.isModerator == true;
      return isAuthor || isModerator;
    }

    function titleIsUnder50Chars(post) {
      return post.title.size() < 50;
    }

    // Draft blog posts
    match /drafts/{draftID} {
      // `authorUID`: string, required
      // `content`: string, optional
      // `createdAt`: timestamp, required
      // `title`: string, < 50 characters, required
      // `url`: string, optional

      allow create: if
        // User creating document is draft author
        request.auth.uid == request.resource.data.authorUID &&
        // Must include title, author, and url fields
        request.resource.data.keys().hasAll([
          "authorUID",
          "createdAt",
          "title"
        ]) &&
        titleIsUnder50Chars(request.resource.data);

      allow update: if
        // User is the author, and
        resource.data.authorUID == request.auth.uid &&
        // `authorUID` and `createdAt` are unchanged
        request.resource.data.diff(resource.data).unchangedKeys().hasAll([
          "authorUID",
          "createdAt"
          ]) &&
        titleIsUnder50Chars(request.resource.data);

      // Can be read or deleted by author or moderator
      allow read, delete: if isAuthorOrModerator(resource.data, request.auth);
    }

    // Published blog posts are denormalized from drafts
    match /published/{postID} {
      // `authorUID`: string, required
      // `content`: string, required
      // `publishedAt`: timestamp, required
      // `title`: string, < 50 characters, required
      // `url`: string, required
      // `visible`: boolean, required

      // Can be read by everyone
      allow read: if true;

      // Published posts are created only via functions, never by users
      // No hard deletes; soft deletes update `visible` field.
      allow create, delete: if false;

      allow update: if
        isAuthorOrModerator(resource.data, request.auth) &&
        // Immutable fields are unchanged
        request.resource.data.diff(resource.data).unchangedKeys().hasAll([
          "authorUID",
          "publishedAt",
          "url"
        ]) &&
        // Required fields are present
        request.resource.data.keys().hasAll([
          "content",
          "title",
          "visible"
        ]) &&
        titleIsUnder50Chars(request.resource.data);
    }
  }
}

परीक्षण पुनः चलाएँ. इस बिंदु पर, आपके पास 5 उत्तीर्ण परीक्षण और 4 असफल परीक्षण होने चाहिए।

9. टिप्पणियाँ: उपसंग्रह और साइन-इन प्रदाता अनुमतियाँ

प्रकाशित पोस्ट टिप्पणियों की अनुमति देती हैं, और टिप्पणियाँ प्रकाशित पोस्ट के उपसंग्रह ( /published/{postID}/comments/{commentID} ) में संग्रहीत की जाती हैं। डिफ़ॉल्ट रूप से संग्रह के नियम उपसंग्रह पर लागू नहीं होते हैं। आप नहीं चाहेंगे कि वही नियम टिप्पणियों पर भी लागू हों जो प्रकाशित पोस्ट के मूल दस्तावेज़ पर लागू होते हैं; आप अलग-अलग चीज़ें तैयार करेंगे।

क्योंकि उपसंग्रह, डिफ़ॉल्ट रूप से, मूल दस्तावेज़ों के नियमों को प्राप्त नहीं करते हैं, उपसंग्रह किसी दस्तावेज़ के हिस्सों को अलग करने के लिए एक अच्छा विकल्प है जिसके लिए अलग-अलग पहुंच की आवश्यकता होती है। यदि आप चाहते हैं कि सभी उपसंग्रह मूल दस्तावेज़ के नियमों को प्राप्त करें, तो मूल दस्तावेज़ के मिलान विवरण में ग्लोब सिंटैक्स का उपयोग करें, यानी, match /published/{postId}/{subDocPath=**} ।

टिप्पणियों तक पहुँचने के नियम लिखने के लिए, मिलान विवरण से प्रारंभ करें:

match /published/{postID}/comments/{commentID} {
  // `authorUID`: string, required
  // `comment`: string, < 500 characters, required
  // `createdAt`: timestamp, required
  // `editedAt`: timestamp, optional

टिप्पणियाँ पढ़ना: गुमनाम नहीं रह सकता

इस ऐप के लिए, केवल वे उपयोगकर्ता जिन्होंने एक स्थायी खाता बनाया है, कोई गुमनाम खाता नहीं, टिप्पणियां पढ़ सकते हैं। उस नियम को लागू करने के लिए, प्रत्येक auth.token ऑब्जेक्ट पर मौजूद sign_in_provider विशेषता को देखें:

allow read: if request.auth.token.firebase.sign_in_provider != "anonymous";

अपने परीक्षण दोबारा चलाएँ, और पुष्टि करें कि एक और परीक्षण पास हो गया है।

टिप्पणियाँ बनाना: अस्वीकृत सूची की जाँच करना

टिप्पणी बनाने के लिए तीन शर्तें हैं:

उपयोगकर्ता के पास एक सत्यापित ईमेल होना चाहिए
टिप्पणी 500 अक्षरों से कम होनी चाहिए, और
वे प्रतिबंधित उपयोगकर्ताओं की सूची में नहीं हो सकते हैं, जो कि bannedUsers संग्रह में फायरस्टोर में संग्रहीत है। इन शर्तों को एक-एक करके लेना:

request.auth.token.email_verified == true

request.resource.data.comment.size() < 500

!exists(/databases/$(database)/documents/bannedUsers/$(request.auth.uid));

टिप्पणियाँ बनाने का अंतिम नियम है:

allow create: if
  // User has verified email
  (request.auth.token.email_verified == true) &&
  // UID is not on bannedUsers list
  !(exists(/databases/$(database)/documents/bannedUsers/$(request.auth.uid));

संपूर्ण नियम फ़ाइल अब है:

For bottom of step 9
rules_version = '2';
service cloud.firestore {
  match /databases/{database}/documents {

    // Returns true if user is post author or a moderator
    function isAuthorOrModerator(post, auth) {
      let isAuthor = auth.uid == post.authorUID;
      let isModerator = auth.token.isModerator == true;
      return isAuthor || isModerator;
    }

    function titleIsUnder50Chars(post) {
      return post.title.size() < 50;
    }

    // Draft blog posts
    match /drafts/{draftID} {
      // `authorUID`: string, required
      // `content`: string, optional
      // `createdAt`: timestamp, required
      // `title`: string, < 50 characters, required
      // `url`: string, optional

      allow create: if
        // User is author
        request.auth.uid == request.resource.data.authorUID &&
        // Must include title, author, and createdAt fields
        request.resource.data.keys().hasAll([
          "authorUID",
          "createdAt",
          "title"
        ]) &&
        titleIsUnder50Chars(request.resource.data);

      allow update: if
        // User is author
        resource.data.authorUID == request.auth.uid &&
        // `authorUID` and `createdAt` are unchanged
        request.resource.data.diff(resource.data).unchangedKeys().hasAll([
          "authorUID",
          "createdAt"
          ]) &&
        titleIsUnder50Chars(request.resource.data);

      // Can be read or deleted by author or moderator
      allow read, delete: if isAuthorOrModerator(resource.data, request.auth);
    }

    // Published blog posts are denormalized from drafts
    match /published/{postID} {
      // `authorUID`: string, required
      // `content`: string, required
      // `publishedAt`: timestamp, required
      // `title`: string, < 50 characters, required
      // `url`: string, required
      // `visible`: boolean, required

      // Can be read by everyone
      allow read: if true;

      // Published posts are created only via functions, never by users
      // No hard deletes; soft deletes update `visible` field.
      allow create, delete: if false;

      allow update: if
        isAuthorOrModerator(resource.data, request.auth) &&
        // Immutable fields are unchanged
        request.resource.data.diff(resource.data).unchangedKeys().hasAll([
          "authorUID",
          "publishedAt",
          "url"
        ]) &&
        // Required fields are present
        request.resource.data.keys().hasAll([
          "content",
          "title",
          "visible"
        ]) &&
        titleIsUnder50Chars(request.resource.data);
    }

    match /published/{postID}/comments/{commentID} {
      // `authorUID`: string, required
      // `createdAt`: timestamp, required
      // `editedAt`: timestamp, optional
      // `comment`: string, < 500 characters, required

      // Must have permanent account to read comments
      allow read: if !(request.auth.token.firebase.sign_in_provider == "anonymous");

      allow create: if
        // User has verified email
        request.auth.token.email_verified == true &&
        // Comment is under 500 characters
        request.resource.data.comment.size() < 500 &&
        // UID is not on the block list
        !exists(/databases/$(database)/documents/bannedUsers/$(request.auth.uid));
    }
  }
}

परीक्षण दोबारा चलाएँ, और सुनिश्चित करें कि एक और परीक्षण पास हो गया है।

10. टिप्पणियाँ अद्यतन करना: समय-आधारित नियम

टिप्पणियों के लिए व्यावसायिक तर्क यह है कि उन्हें टिप्पणी लेखक द्वारा निर्माण के एक घंटे बाद तक संपादित किया जा सकता है। इसे लागू करने के लिए, createdAt टाइमस्टैम्प का उपयोग करें।

सबसे पहले, यह स्थापित करने के लिए कि उपयोगकर्ता लेखक है:

request.auth.uid == resource.data.authorUID

अगला, वह टिप्पणी पिछले घंटे के भीतर बनाई गई थी:

(request.time - resource.data.createdAt) < duration.value(1, 'h');

इन्हें तार्किक AND ऑपरेटर के साथ संयोजित करने पर, टिप्पणियों को अद्यतन करने का नियम बन जाता है:

allow update: if
  // is author
  request.auth.uid == resource.data.authorUID &&
  // within an hour of comment creation
  (request.time - resource.data.createdAt) < duration.value(1, 'h');

परीक्षण दोबारा चलाएँ, और सुनिश्चित करें कि एक और परीक्षण पास हो गया है।

11. टिप्पणियाँ हटाना: मूल स्वामित्व की जाँच करना

टिप्पणियों को टिप्पणी लेखक, मॉडरेटर या ब्लॉग पोस्ट के लेखक द्वारा हटाया जा सकता है।

सबसे पहले, क्योंकि आपके द्वारा पहले जोड़ा गया हेल्पर फ़ंक्शन एक authorUID फ़ील्ड की जांच करता है जो किसी पोस्ट या टिप्पणी पर मौजूद हो सकता है, आप यह जांचने के लिए हेल्पर फ़ंक्शन का पुन: उपयोग कर सकते हैं कि उपयोगकर्ता लेखक या मॉडरेटर है या नहीं:

isAuthorOrModerator(resource.data, request.auth)

यह जांचने के लिए कि क्या उपयोगकर्ता ब्लॉग पोस्ट लेखक है, फायरस्टोर में पोस्ट देखने के लिए get का उपयोग करें:

request.auth.uid == get(/databases/$(database)/documents/published/$(postID)).data.authorUID

चूँकि इनमें से कोई भी शर्त पर्याप्त है, उनके बीच एक तार्किक OR ऑपरेटर का उपयोग करें:

allow delete: if
  // is comment author or moderator
  isAuthorOrModerator(resource.data, request.auth) ||
  // is blog post author
  request.auth.uid == get(/databases/$(database)/documents/published/$(postID)).data.authorUID;

परीक्षण दोबारा चलाएँ, और सुनिश्चित करें कि एक और परीक्षण पास हो गया है।

और संपूर्ण नियम फ़ाइल है:

rules_version = '2';
service cloud.firestore {
  match /databases/{database}/documents {

    // Returns true if user is post author or a moderator
    function isAuthorOrModerator(post, auth) {
      let isAuthor = auth.uid == post.authorUID;
      let isModerator = auth.token.isModerator == true;
      return isAuthor || isModerator;
    }

    function titleIsUnder50Chars(post) {
      return post.title.size() < 50;
    }

    // Draft blog posts
    match /drafts/{draftID} {
      // `authorUID`: string, required
      // `content`: string, optional
      // `createdAt`: timestamp, required
      // `title`: string, < 50 characters, required
      // `url`: string, optional

      allow create: if
        // User is author
        request.auth.uid == request.resource.data.authorUID &&
        // Must include title, author, and createdAt fields
        request.resource.data.keys().hasAll([
          "authorUID",
          "createdAt",
          "title"
        ]) &&
        titleIsUnder50Chars(request.resource.data);

      allow update: if
        // User is author
        resource.data.authorUID == request.auth.uid &&
        // `authorUID` and `createdAt` are unchanged
        request.resource.data.diff(resource.data).unchangedKeys().hasAll([
          "authorUID",
          "createdAt"
          ]) &&
        titleIsUnder50Chars(request.resource.data);

      // Can be read or deleted by author or moderator
      allow read, delete: if isAuthorOrModerator(resource.data, request.auth);
    }

    // Published blog posts are denormalized from drafts
    match /published/{postID} {
      // `authorUID`: string, required
      // `content`: string, required
      // `publishedAt`: timestamp, required
      // `title`: string, < 50 characters, required
      // `url`: string, required
      // `visible`: boolean, required

      // Can be read by everyone
      allow read: if true;

      // Published posts are created only via functions, never by users
      // No hard deletes; soft deletes update `visible` field.
      allow create, delete: if false;

      allow update: if
        isAuthorOrModerator(resource.data, request.auth) &&
        // Immutable fields are unchanged
        request.resource.data.diff(resource.data).unchangedKeys().hasAll([
          "authorUID",
          "publishedAt",
          "url"
        ]) &&
        // Required fields are present
        request.resource.data.keys().hasAll([
          "content",
          "title",
          "visible"
        ]) &&
        titleIsUnder50Chars(request.resource.data);
    }

    match /published/{postID}/comments/{commentID} {
      // `authorUID`: string, required
      // `createdAt`: timestamp, required
      // `editedAt`: timestamp, optional
      // `comment`: string, < 500 characters, required

      // Must have permanent account to read comments
      allow read: if !(request.auth.token.firebase.sign_in_provider == "anonymous");

      allow create: if
        // User has verified email
        request.auth.token.email_verified == true &&
        // Comment is under 500 characters
        request.resource.data.comment.size() < 500 &&
        // UID is not on the block list
        !exists(/databases/$(database)/documents/bannedUsers/$(request.auth.uid));

      allow update: if
        // is author
        request.auth.uid == resource.data.authorUID &&
        // within an hour of comment creation
        (request.time - resource.data.createdAt) < duration.value(1, 'h');

      allow delete: if
        // is comment author or moderator
        isAuthorOrModerator(resource.data, request.auth) ||
        // is blog post author
        request.auth.uid == get(/databases/$(database)/documents/published/$(postID)).data.authorUID;
    }
  }
}

12. अगले चरण

बधाई हो! आपने सुरक्षा नियम लिखे हैं जिससे सभी परीक्षण पास हो गए और आवेदन सुरक्षित हो गया!

आगे जानने के लिए यहां कुछ संबंधित विषय दिए गए हैं:

ब्लॉग पोस्ट : सुरक्षा नियमों की समीक्षा कैसे करें
कोडेलैब : एमुलेटर्स के साथ स्थानीय प्रथम विकास के माध्यम से चलना
वीडियो : GitHub क्रियाओं का उपयोग करके एमुलेटर-आधारित परीक्षणों के लिए सेट अप CI का उपयोग कैसे करें