रीयलटाइम डेटाबेस के सुरक्षा नियमों की भाषा का मुख्य सिंटैक्स जानें

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

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

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

सुरक्षा नियमों का स्ट्रक्चर बनाना

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

बुनियादी नियमों से, सुरक्षित किए जाने वाले नोड के सेट, ऐक्सेस करने के तरीकों (जैसे, पढ़ना, लिखना), और उन शर्तों की पहचान की जाती है जिनके तहत ऐक्सेस की अनुमति दी जाती है या नहीं दी जाती. यहां दिए गए उदाहरणों में, हमारी शर्तें आसान true और false स्टेटमेंट होंगी. हालांकि, अगले विषय में हम शर्तों को ज़ाहिर करने के ज़्यादा डाइनैमिक तरीकों के बारे में बताएंगे.

उदाहरण के लिए, अगर हमें parent_node में मौजूद child_node को सुरक्षित रखना है, तो इस सामान्य सिंटैक्स का इस्तेमाल करना होगा:

{
  "rules": {
    "parent_node": {
      "child_node": {
        ".read": <condition>,
        ".write": <condition>,
        ".validate": <condition>,
      }
    }
  }
}

चलिए, इस पैटर्न को लागू करते हैं. उदाहरण के लिए, मान लें कि आपको मैसेज की सूची ट्रैक करनी है और आपके पास इस तरह का डेटा है:

{
  "messages": {
    "message0": {
      "content": "Hello",
      "timestamp": 1405704370369
    },
    "message1": {
      "content": "Goodbye",
      "timestamp": 1405704395231
    },
    ...
  }
}

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

{
  "rules": {
    // For requests to access the 'messages' node...
    "messages": {
      // ...and the individual wildcarded 'message' nodes beneath
      // (we'll cover wildcarding variables more a bit later)....
      "$message": {

        // For each message, allow a read operation if <condition>. In this
        // case, we specify our condition as "true", so read access is always granted.
        ".read": "true",

        // For read-only behavior, we specify that for write operations, our
        // condition is false.
        ".write": "false"
      }
    }
  }
}

बुनियादी नियमों से जुड़े ऑपरेशन

डेटा पर की जा रही कार्रवाई के टाइप के आधार पर, सुरक्षा लागू करने के लिए तीन तरह के नियम होते हैं: .write, .read, और .validate. यहां उनके मकसद की खास जानकारी दी गई है:

नियम के टाइप
.read इससे पता चलता है कि उपयोगकर्ताओं को डेटा पढ़ने की अनुमति है या नहीं. अगर अनुमति है, तो कब है.
.write इससे पता चलता है कि डेटा में बदलाव करने की अनुमति है या नहीं. अगर अनुमति है, तो कब है.
.validate इससे यह तय होता है कि सही तरीके से फ़ॉर्मैट की गई वैल्यू कैसी दिखेगी. साथ ही, यह भी तय होता है कि उसमें चाइल्ड एट्रिब्यूट और डेटा टाइप है या नहीं.

वाइल्डकार्ड कैप्चर वैरिएबल

नियमों के सभी स्टेटमेंट, नोड पर ले जाते हैं. कोई स्टेटमेंट, किसी खास नोड पर ले जा सकता है या $ वाइल्डकार्ड कैप्चर वैरिएबल का इस्तेमाल करके, हैरारकी के लेवल पर नोड के सेट पर ले जा सकता है. इन कैप्चर वैरिएबल का इस्तेमाल करके, नोड की वैल्यू को सेव करें. इससे, बाद के नियमों के स्टेटमेंट में इनका इस्तेमाल किया जा सकेगा. इस तकनीक की मदद से, ज़्यादा जटिल Security Rules शर्तें लिखी जा सकती हैं. हम अगले विषय में इस बारे में ज़्यादा जानकारी देंगे.

{
  "rules": {
    "rooms": {
      // this rule applies to any child of /rooms/, the key for each room id
      // is stored inside $room_id variable for reference
      "$room_id": {
        "topic": {
          // the room's topic can be changed if the room id has "public" in it
          ".write": "$room_id.contains('public')"
        }
      }
    }
  }
}

डाइनैमिक $ वैरिएबल का इस्तेमाल, पाथ के कॉन्स्टेंट नामों के साथ भी किया जा सकता है. इस उदाहरण में, हम $other वैरिएबल का इस्तेमाल करके, .validate नियम का एलान कर रहे हैं. इससे यह पक्का होता है कि widget के पास title और color के अलावा कोई और चाइल्ड एलिमेंट नहीं है. अगर किसी डेटा को लिखने से अतिरिक्त चाइल्ड नोड बनते हैं, तो वह डेटा नहीं लिखा जाएगा.

{
  "rules": {
    "widget": {
      // a widget can have a title or color attribute
      "title": { ".validate": true },
      "color": { ".validate": true },

      // but no other child paths are allowed
      // in this case, $other means any key excluding "title" and "color"
      "$other": { ".validate": false }
    }
  }
}

रीड और राइट रूल कैस्केड

.read और .write नियम, ऊपर से नीचे की ओर काम करते हैं. इनमें कम गहराई वाले नियम, ज़्यादा गहराई वाले नियमों को बदल देते हैं. अगर कोई नियम किसी पाथ पर डेटा पढ़ने या उसमें बदलाव करने की अनुमति देता है, तो वह उस पाथ के सभी चाइल्ड नोड को भी ऐक्सेस करने की अनुमति देता है. इस स्ट्रक्चर को देखें:

{
  "rules": {
     "foo": {
        // allows read to /foo/*
        ".read": "data.child('baz').val() === true",
        "bar": {
          /* ignored, since read was allowed already */
          ".read": false
        }
     }
  }
}

इस सुरक्षा संरचना की मदद से, /bar/ को तब पढ़ा जा सकता है, जब /foo/ में true वैल्यू वाला चाइल्ड baz शामिल हो. /foo/bar/ में मौजूद ".read": false नियम का यहां कोई असर नहीं होता, क्योंकि चाइल्ड पाथ से ऐक्सेस वापस नहीं लिया जा सकता.

हालांकि, यह तुरंत समझ में नहीं आता, लेकिन यह नियमों की भाषा का एक अहम हिस्सा है. इसकी मदद से, कम से कम मेहनत में ऐक्सेस के लिए बहुत जटिल खास अधिकार लागू किए जा सकते हैं. इस गाइड में आगे, उपयोगकर्ता के हिसाब से सुरक्षा के बारे में जानकारी देते समय, इस बारे में बताया जाएगा.

ध्यान दें कि .validate नियम कैस्केड नहीं होते. डेटा सेव करने की अनुमति पाने के लिए, हैरारकी के सभी लेवल पर पुष्टि करने के सभी नियमों का पालन करना ज़रूरी है.

नियम, फ़िल्टर नहीं होते

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

{
  "rules": {
    "records": {
      "rec1": {
        ".read": true
      },
      "rec2": {
        ".read": false
      }
    }
  }
}

यह समझे बिना कि नियमों का आकलन अलग-अलग किया जाता है, ऐसा लग सकता है कि /records/ पाथ को फ़ेच करने पर rec1 दिखेगा, लेकिन rec2 नहीं. हालांकि, असल नतीजा एक गड़बड़ी है:

JavaScript
var db = firebase.database();
db.ref("records").once("value", function(snap) {
  // success method is not called
}, function(err) {
  // error callback triggered with PERMISSION_DENIED
});
Objective-C
ध्यान दें: Firebase का यह प्रॉडक्ट, ऐप्लिकेशन क्लिप टारगेट पर उपलब्ध नहीं है.
FIRDatabaseReference *ref = [[FIRDatabase database] reference];
[[_ref child:@"records"] observeSingleEventOfType:FIRDataEventTypeValue withBlock:^(FIRDataSnapshot *snapshot) {
  // success block is not called
} withCancelBlock:^(NSError * _Nonnull error) {
  // cancel block triggered with PERMISSION_DENIED
}];
Swift
ध्यान दें: Firebase का यह प्रॉडक्ट, ऐप्लिकेशन क्लिप टारगेट पर उपलब्ध नहीं है.
var ref = FIRDatabase.database().reference()
ref.child("records").observeSingleEventOfType(.Value, withBlock: { snapshot in
    // success block is not called
}, withCancelBlock: { error in
    // cancel block triggered with PERMISSION_DENIED
})
Java
FirebaseDatabase database = FirebaseDatabase.getInstance();
DatabaseReference ref = database.getReference("records");
ref.addListenerForSingleValueEvent(new ValueEventListener() {
  @Override
  public void onDataChange(DataSnapshot snapshot) {
    // success method is not called
  }

  @Override
  public void onCancelled(FirebaseError firebaseError) {
    // error callback triggered with PERMISSION_DENIED
  });
});
REST
curl https://docs-examples.firebaseio.com/rest/records/
# response returns a PERMISSION_DENIED error

/records/ पर डेटा को पढ़ने की कार्रवाई ऐटॉमिक है और डेटा को पढ़ने का ऐसा कोई नियम नहीं है जो /records/ के तहत मौजूद सभी डेटा का ऐक्सेस देता हो. इसलिए, इससे PERMISSION_DENIED गड़बड़ी होगी. अगर हम अपने Firebase कंसोल में, सुरक्षा सिम्युलेटर में इस नियम का आकलन करते हैं, तो हम देख सकते हैं कि डेटा पढ़ने की कार्रवाई को अस्वीकार कर दिया गया था. ऐसा इसलिए हुआ, क्योंकि डेटा पढ़ने के किसी भी नियम ने /records/ पाथ को ऐक्सेस करने की अनुमति नहीं दी थी. हालांकि, ध्यान दें कि rec1 के लिए नियम की जांच कभी नहीं की गई, क्योंकि यह उस पाथ में नहीं था जिसके लिए हमने अनुरोध किया था. rec1 को फ़ेच करने के लिए, हमें इसे सीधे ऐक्सेस करना होगा:

JavaScript
var db = firebase.database();
db.ref("records/rec1").once("value", function(snap) {
  // SUCCESS!
}, function(err) {
  // error callback is not called
});
Objective-C
ध्यान दें: Firebase का यह प्रॉडक्ट, ऐप्लिकेशन क्लिप टारगेट पर उपलब्ध नहीं है.
FIRDatabaseReference *ref = [[FIRDatabase database] reference];
[[ref child:@"records/rec1"] observeSingleEventOfType:FEventTypeValue withBlock:^(FIRDataSnapshot *snapshot) {
    // SUCCESS!
}];
Swift
ध्यान दें: Firebase का यह प्रॉडक्ट, ऐप्लिकेशन क्लिप टारगेट पर उपलब्ध नहीं है.
var ref = FIRDatabase.database().reference()
ref.child("records/rec1").observeSingleEventOfType(.Value, withBlock: { snapshot in
    // SUCCESS!
})
Java
FirebaseDatabase database = FirebaseDatabase.getInstance();
DatabaseReference ref = database.getReference("records/rec1");
ref.addListenerForSingleValueEvent(new ValueEventListener() {
  @Override
  public void onDataChange(DataSnapshot snapshot) {
    // SUCCESS!
  }

  @Override
  public void onCancelled(FirebaseError firebaseError) {
    // error callback is not called
  }
});
REST
curl https://docs-examples.firebaseio.com/rest/records/rec1
# SUCCESS!

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

किसी नोड पर एक से ज़्यादा नियम लागू हो सकते हैं. अगर एक से ज़्यादा नियम एक्सप्रेशन किसी नोड की पहचान करते हैं, तो ऐक्सेस करने के तरीके को अस्वीकार कर दिया जाता है. ऐसा तब होता है, जब इनमें से कोई भी शर्त false हो:

{
  "rules": {
    "messages": {
      // A rule expression that applies to all nodes in the 'messages' node
      "$message": {
        ".read": "true",
        ".write": "true"
      },
      // A second rule expression applying specifically to the 'message1` node
      "message1": {
        ".read": "false",
        ".write": "false"
      }
    }
  }
}

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

अगले चरण

Firebase रीयलटाइम डेटाबेस के सुरक्षा नियमों के बारे में ज़्यादा जानने के लिए, ये काम किए जा सकते हैं:

  • Security Rules भाषा के अगले मुख्य कॉन्सेप्ट, डाइनैमिक कंडीशन के बारे में जानें. इनकी मदद से, Security Rules उपयोगकर्ता की अनुमति की जांच कर सकता है, मौजूदा और आने वाले डेटा की तुलना कर सकता है, आने वाले डेटा की पुष्टि कर सकता है, क्लाइंट से आने वाली क्वेरी के स्ट्रक्चर की जांच कर सकता है, और बहुत कुछ कर सकता है.

  • सुरक्षा से जुड़े इस्तेमाल के सामान्य उदाहरण और Firebase के सुरक्षा नियमों की परिभाषाएं देखें जो उन्हें हल करती हैं.