डेटाबेस चुनने के बाद प्रमाणित करें

ऐसा लगता है कि आप यहां कुछ अवधारणाओं को याद कर रहे हैं, इसलिए मैं मूल रूप से "गाइड" के रूप में उत्तर दूंगा कि आपको इसके बजाय क्या करना चाहिए। तो "प्रमाणीकरण' वास्तव में ऐसा कुछ नहीं है जिसे आप "बाद" कनेक्शन के बाद करते हैं, बल्कि जब आप वास्तव में प्रमाणित करने का प्रयास करते हैं तो आपको "सही जगह पर देखना" चाहिए।

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

संशोधन चरण - सीधे दस्तावेज़ीकरण से

तो पहले एक स्थानीय कार्यशील निर्देशिका चुनना चाहेंगे और उसके नीचे डेटाबेस संग्रहण फ़ाइलों के लिए पथ बनाना चाहेंगे। *निक्स आधारित सिस्टम पर आप कुछ ऐसा कर सकते हैं:

mkdir -p scratch/data/db
cd scratch

फिर हम बिना किसी अन्य विकल्प के एक अलग MongoDB उदाहरण शुरू करना चाहते हैं। यह सुनिश्चित करना कि पोर्ट किसी अन्य चल रहे इंस्टेंस के साथ विरोध न करे:

mongod --port 37017 --dbpath data/db

एक नए टर्मिनल या कमांड लाइन विंडो में, फिर आप शेल से जुड़ सकते हैं:

mongo --port 37017

आप हमेशा कम से कम "खाते बनाने" के लिए प्रशासनिक विशेषाधिकारों के साथ कम से कम एक खाता चाहते हैं और समस्या आने पर उन्हें बदल दें, इसलिए एक बनाएं:

use admin
db.createUser(
  {
    user: "admin",
    pwd: "admin",
    roles: [{ role: "userAdminAnyDatabase", db: "admin" }]
  }
)

अब खोल से बाहर निकलें और मौजूदा mongod . को बंद करें इंस्टेंस दूसरे टर्मिनल या कमांड प्रॉम्प्ट में चल रहा है और फिर --auth . का उपयोग करके इसे फिर से शुरू करें :

mongod --auth --port 37017 --dbpath data/db

विशिष्ट उपयोगकर्ता - सुनिश्चित करें कि आप इनका पालन करते हैं

अब आप वास्तव में एक उपयोगकर्ता बनाना चाहते हैं जो "आपके एप्लिकेशन द्वारा उपयोग किया जाएगा"। इसलिए यह सुनिश्चित करने के लिए ये कदम महत्वपूर्ण हैं कि आप इसे सही तरीके से प्राप्त करें।

अपने "व्यवस्थापकीय उपयोगकर्ता" का उपयोग करके एक शेल में प्रवेश करें:

mongo -u admin -p admin --port 37017 --authenticationDatabase 'admin'

आप बारी-बारी से db.auth() कर सकते हैं विधि जैसा कि प्रश्न में दिखाया गया है, लेकिन जैसा कि नोट किया गया है जरूरी "admin" . पर अधिकृत हो नाम स्थान।

अगली चीज़ जो आप करना चाहते हैं वह है एक उपयोगकर्ता बनाना जिसके पास "mydb" . तक पहुंच हो readWrite . के साथ नाम स्थान के रूप में भूमिका। किक के लिए, हम इस उपयोगकर्ता को readAnyDatabase . भी देने जा रहे हैं उन्हें सभी डेटाबेस नामस्थानों को "सूचीबद्ध" करने की अनुमति देता है, यदि वास्तव में उनके साथ कुछ और करने में सक्षम नहीं है।

use admin
db.createUser(
  {
    "user": "myuser",
    "pwd": "password",
    "roles": [
      { "role": "readWrite", "db": "mydb" },
      "readAnyDatabase"
    ]
  }
)

केवल अतिरिक्त आउटपुट के लिए, आइए वर्तमान बनाए गए उपयोगकर्ताओं को देखें:

db.getUsers()
[
        {
                "_id" : "admin.admin",
                "user" : "admin",
                "db" : "admin",
                "roles" : [
                        {
                                "role" : "userAdminAnyDatabase",
                                "db" : "admin"
                        }
                ]
        },
        {
                "_id" : "admin.myuser",
                "user" : "myuser",
                "db" : "admin",
                "roles" : [
                        {
                                "role" : "readWrite",
                                "db" : "mydb"
                        },
                        {
                                "role" : "readAnyDatabase",
                                "db" : "admin"
                        }
                ]
        }
]

देखें कि नामकरण में इनका विस्तार कैसे हुआ है, और विशेष रूप से विभिन्न "db" . को असाइन किए गए मान प्रत्येक उपयोगकर्ता पर कुंजी। इससे आपको थोड़ी अधिक जानकारी मिलनी चाहिए कि MongoDB इसे कैसे देखता है और क्यों।

पायथन कनेक्शन

अंत में हम सिर्फ अजगर से जुड़ना चाहते हैं। तो मान लें कि आपके पास पहले से ही अजगर और पाइमोंगो स्थापित है, तो यह सत्यापित करने के लिए एक साधारण सूची है:

import pymongo
from pymongo import MongoClient
client = MongoClient('mongodb://myuser:[email protected]:37017');

db = client['mydb']
col = db.test

col.remove()

col.insert_one({ "a": 1 })

for doc in col.find():
  print(doc)

जो बिना किसी समस्या के बनाए और सूचीबद्ध दस्तावेज़ को दिखाता है:

{u'a': 1, u'_id': ObjectId('5a08e5e0760108251722a737')}

ध्यान दें कि हमें वास्तव में "admin" . का कोई उल्लेख करने की आवश्यकता नहीं है यहां, क्योंकि यह डिफ़ॉल्ट है जहां ड्राइवर "खातों की अपेक्षा करता है" और जहां आपको वास्तव में "चाहिए" ऐसा करना चाहिए।

लेकिन मैंने इसे गलत तरीके से किया

तो मान लीजिए कि आप मूल रूप से भ्रमित हो गए और उपयोगकर्ता को "mydb" . के तहत बनाया इसके बजाय:

use mydb
db.createUser({ "user": "bert", "pwd": "password", "roles": ["readWrite"] })

यदि आप "admin" . में देखें वह उपयोगकर्ता वहां नहीं है। लेकिन अगर आप "mydb" . पर देखें तो :

use mydb
db.getUsers()
[
        {
                "_id" : "mydb.bert",
                "user" : "bert",
                "db" : "mydb",
                "roles" : [
                        {
                                "role" : "readWrite",
                                "db" : "mydb"
                        }
                ]
        }
]

तो आप देख सकते हैं कि वास्तविक उपयोगकर्ता डेटा अब कहाँ रखा गया है और इसे कैसे रिकॉर्ड किया गया है।

यहाँ साधारण मामला यह है कि आपको MongoDB को यह बताना चाहिए कि इस उपयोगकर्ता के लिए प्रमाणीकरण कहाँ से प्राप्त करना है:

client = MongoClient('mongodb://bert:[email protected]:37017/mydb');

देखें कि हम कैसे जोड़ते हैं "mydb" कनेक्शन स्ट्रिंग पर। यह इस तरह से किया जाता है।

यह वास्तव में "प्रगति पर" है जिसे सभी ड्राइवरों के अनुरूप बनाया जाना है कि कनेक्शन कैसे बनाए जाते हैं और प्रमाणीकरण कहां होता है और साथ ही जहां आप डेटाबेस का चयन करते हैं। लेकिन बुनियादी नियम हैं:

1. यदि प्रमाणीकरण क्रेडेंशियल के लिए कनेक्शन विवरण के साथ कोई अन्य डेटाबेस नेमस्पेस प्रदान नहीं किया गया है, तो "admin" को डिफ़ॉल्ट . माना जाता है ।

2. जहां कनेक्शन स्ट्रिंग पर एक डेटाबेस नेमस्पेस प्रदान किया गया है, इसका उपयोग प्रमाणीकरण के लिए किया जाएगा और यह कनेक्शन स्ट्रिंग पर डेटाबेस नेमस्पेस का वास्तविक उद्देश्य है।

3. हालांकि अन्य ड्राइवर "वर्तमान में" कनेक्शन स्ट्रिंग पर डेटाबेस नेमस्पेस की भूमिका में भिन्न हैं, उपयोग को सभी ड्राइवरों के अनुरूप होने के लिए बदला जा रहा है कि डेटाबेस नेमस्पेस का "उपयोग" वास्तव में एक एपीआई कॉल है, बजाय असाइन किए जाने के कनेक्शन स्ट्रिंग।

तो जहां आपको प्रमाणित करने की आवश्यकता है "आपने उपयोगकर्ता को कहां बनाया" पर निर्भर करता है। लेकिन आपको वास्तव में यह ध्यान रखना चाहिए कि "admin" यह वह जगह है जहां आपको इसे कहीं और करने के बजाय "करना चाहिए"।