ปรับใช้ชุดจำลองที่มีความพร้อมใช้งานสูงใน MongoDB 3.4 โดยใช้ Keyfile สำหรับการควบคุมการเข้าถึงบน Ubuntu 16.04

• เกี่ยวกับ Replica Set
• ข้อกำหนดเบื้องต้น
• ออกแบบชุดแบบจำลอง
• คำแนะนำในการปรับใช้
• ข้อสรุป

นับตั้งแต่ก่อตั้งขึ้นในปี 2552 MongoDB ได้เป็นผู้นำในอุตสาหกรรม NoSQL หนึ่งในแนวคิดหลักของ MongoDB คือ Replica Set ดังนั้นก่อนที่จะทำงานกับมันก่อนอื่นให้ทบทวนแนวคิด

เกี่ยวกับ Replica Set

รูปแบบการสื่อสารที่ง่ายที่สุดที่ใช้ในการจำลองฐานข้อมูลคือสถาปัตยกรรม Master-Slave เนื่องจากชื่อแนะนำโมเดลนี้มี 2 บทบาทซึ่งกระจายอยู่ในต้นแบบที่ไม่ซ้ำกันและทาสจำนวนมากบทบาทของต้นแบบคือการประมวลผลการดำเนินการอ่านและเขียนที่ดำเนินการโดยลูกค้าและทาสนั้นจะถือว่าเป็นแบบจำลองของต้นแบบ

ข้อได้เปรียบที่สำคัญที่สุดของรุ่นนี้คือประสิทธิภาพการทำงานของต้นแบบไม่ได้ลดลงจากการดำเนินการสำรองข้อมูลการดำเนินการสำรองข้อมูลจะดำเนินการในแบบอะซิงโครนัสและอาจกลายเป็นปัญหาร้ายแรงเมื่อโหนดหลักล้มเหลว โหนด Slave เป็นแบบอ่านอย่างเดียวและจะต้องเลื่อนไปที่โหนดหลักด้วยตนเองดังนั้นในเวลานี้มีความเป็นไปได้ที่จะสูญเสียข้อมูล

ตัวเลือกหนึ่งในการแก้ไขปัญหาความพร้อมใช้งานคือการมีต้นแบบมากกว่าหนึ่งในสถาปัตยกรรม แต่อาจนำไปสู่ปัญหาอื่นในความสอดคล้องของข้อมูลระหว่างอินสแตนซ์เหล่านั้นและความซับซ้อนที่เพิ่มขึ้นของการกำหนดค่า

บริบทที่ได้รับตอนนี้เราสามารถนำเสนอเทคโนโลยีชุดจำลองของ MongoDB Replica Set เป็นชื่อของสถาปัตยกรรม Master-Slave ที่มีการ failover อัตโนมัติดังนั้นในขณะที่primaryโหนดmaster (ซึ่งตอนนี้ชื่อ) ไม่สามารถทำงานได้อย่างถูกต้องelectionจะทริกเกอร์และโหนดหลักใหม่จะถูกเลือกจากทาสที่เหลืออยู่ ( เรียกว่าเป็นsecondaries)

โหนดหลัก

โหนดหลักเป็นโหนดเดียวที่ดำเนินการเขียนโดยการดำเนินการอ่านเริ่มต้นจะได้รับการจัดการโดยหลักเช่นกัน แต่พฤติกรรมนี้สามารถเปลี่ยนแปลงได้ในภายหลัง

การดำเนินการจะถูกบันทึกลงในoplog(บันทึกการทำงาน) จากนั้นโหนดรองจะอัพเดตเนื้อหาแบบอะซิงโครนัสตามเนื้อหาของoplog

หมายเหตุ: oplogเป็นคอลเลกชันที่มีฝาครอบซึ่งหมายความว่าคอลเลกชันมีขีด จำกัด โดยlocal.oplog.rsคุณสามารถตรวจสอบเนื้อหาของคอลเลกชันนี้ภายในเชลล์ mongo ในสมาชิกชุดใดก็ได้

โหนดรอง

นอกเหนือจากการเป็นผู้สำรองข้อมูลที่เหมาะสมแล้วโหนดรองยังมีบทบาทเหล่านี้:

• สามารถยอมรับการดำเนินการอ่านได้ถ้าจำเป็น
• สามารถทริกเกอร์การเลือกตั้งหากโหนดหลักล้มเหลว
• สามารถลงคะแนนในการเลือกตั้ง
• สามารถกลายเป็นตัวหลักตัวใหม่ได้ถ้าต้องการ

ด้วยคุณสมบัติเหล่านี้เราสามารถมีโหนดรองประเภทต่าง ๆ ได้:

• ลำดับความสำคัญ 0 : โหนดเหล่านี้ไม่สามารถเป็นprimaryและไม่สามารถเริ่มการเลือกตั้งได้ แต่พวกเขายังสามารถลงคะแนนในการเลือกตั้งมีแบบจำลองที่สมบูรณ์และสามารถยอมรับการอ่าน สิ่งเหล่านี้มีประโยชน์ในการปรับใช้ศูนย์ข้อมูลหลายแห่ง
• ซ่อน : Priority 0สมาชิกเหล่านี้แต่ยิ่งไปกว่านั้นพวกเขาไม่สามารถดำเนินการอ่าน พวกเขาอาจลงคะแนนหากจำเป็น งานที่ต้องการสำหรับสมาชิกเหล่านี้คือการรายงานและการสำรองข้อมูล
• ล่าช้า : โหนดเหล่านี้รับผิดชอบ "ข้อมูลประวัติ" โดยล่าช้าในบางเวลา สมาชิกที่ล่าช้าจะต้องเป็นpriority 0โหนดและขอแนะนำให้พวกเขาเป็นhiddenสมาชิกด้วย

ข้อกำหนดเบื้องต้น

• ความพร้อมในการรันอย่างน้อย 3 อินสแตนซ์ของ Ubuntu 16.04 x64 ด้วยขนาดเซิร์ฟเวอร์เดียวกัน

ออกแบบชุดแบบจำลอง

ก่อนที่จะปรับใช้โครงสร้างพื้นฐานเป็นสิ่งสำคัญในการออกแบบและมีจุดที่ต้องพิจารณาในการออกแบบนี้

การเลือกจำนวนสมาชิก

โปรดทราบว่าจำนวนองค์ประกอบขั้นต่ำในการสร้างชุดแบบจำลองคือ 3 คุณสามารถผสมโหนดทั้งสามประเภทเข้าด้วยกันอย่างน้อยหนึ่งโหนดหลักและโหนดรองหนึ่งโหนด

ในคู่มือนี้เรากำลังปรับใช้ 3 สมาชิกหนึ่งในสองหลักและสองมาตรฐาน

หมายเหตุ: ขอแนะนำให้มีสมาชิกที่ลงคะแนนสูงสุด 7 คนโดยมีการรวมกันของอนุญาโตตุลาการและสมาชิกรอง

เลือกชื่อ

ชื่อนี้มีไว้สำหรับอ้างอิง แต่คุณใช้ในการกำหนดค่าของชุด โปรดจำไว้ว่าคุณสามารถมีชุดจำลองมากกว่าหนึ่งชุดในสภาพแวดล้อมการผลิตของคุณดังนั้นอย่าละเลยชื่อชุด

บทช่วยสอนนี้สนับสนุนให้ผู้ใช้เลือกชื่อของชุด

การกระจายตัวของสมาชิกในศูนย์ข้อมูลต่าง ๆ

บทแนะนำนี้แนะนำให้ปรับใช้ในศูนย์ข้อมูลเดียวกันเพื่อให้คุณสามารถหลีกเลี่ยงปัญหาการสื่อสาร

หมายเหตุ: ในกรณีของการปรับใช้ในศูนย์ข้อมูลที่แตกต่างกันขอแนะนำให้ห่อหุ้มโหนดของคุณด้วย VPN

คำแนะนำในการปรับใช้

ขั้นตอนที่ 1: ปรับใช้โหนดขั้นต่ำสำหรับโครงสร้างพื้นฐานของคุณ

เปิดตัว 3 โหนดของ Ubuntu 16.04 x64; ในภูมิภาคเดียวกันจากพอร์ทัลลูกค้าของคุณถ้าเป็นไปได้ อย่าลืมให้ชื่อพวกเขาตามประเภทของโครงการคุณจะจัดการกับและให้แน่ใจว่าจะมีเหมือนกันขนาดเซิร์ฟเวอร์ในต่อมน้ำทั้งหมดเหล่านี้

หลังจากที่คุณปรับใช้ 3 โหนดของคุณคุณจะต้องแน่ใจว่าทุกโหนดสามารถพูดคุยกับส่วนที่เหลือ คุณจำเป็นต้อง ssh เป็นสองโหนดและเข้าถึงคนอื่น ๆ ping -c 4 EXAMPLE_IPใช้ เปลี่ยนEXAMPLE_IPเป็น IP จริงของโหนดของคุณ

ที่นี่คุณสามารถดูตัวอย่างของการสื่อสารที่ประสบความสำเร็จระหว่างสองโหนด

root@foo_node:~# ping -c 4 EXAMPLE_IP
PING EXAMPLE_IP (EXAMPLE_IP) 56(84) bytes of data.
64 bytes from EXAMPLE_IP: icmp_seq=1 ttl=59 time=0.594 ms
64 bytes from EXAMPLE_IP: icmp_seq=2 ttl=59 time=0.640 ms
64 bytes from EXAMPLE_IP: icmp_seq=3 ttl=59 time=0.477 ms
64 bytes from EXAMPLE_IP: icmp_seq=4 ttl=59 time=0.551 ms

--- EXAMPLE_IP ping statistics ---
4 packets transmitted, 4 received, 0% packet loss, time 3021ms
rtt min/avg/max/mdev = 0.477/0.565/0.640/0.064 ms

ขั้นตอนที่ 2: ติดตั้ง MongoDB ในแต่ละโหนดของโครงสร้างพื้นฐานของคุณ

โดยทั่วไปคุณสามารถใช้แพ็คเกจ MongoDB ของ Ubuntu ได้ แต่จะดีกว่าถ้าใช้ repo ชุมชนอย่างเป็นทางการเพราะมันทันสมัยอยู่เสมอ repo นี้มีแพ็คเกจเหล่านี้:

• mongodb-org , แพ็กเกจกลุ่มที่ห่อหุ้มสี่คอมโพเนนต์
• mongodb-org-serverสิ่งนี้มีmongoddaemon (กระบวนการหลักที่จัดการการร้องขอข้อมูล)
• mongodb-org-mongosสิ่งนี้มีmongosdaemon (เซอร์วิสการเราต์สำหรับการปรับใช้ที่แบ่งใช้)
• mongodb-org-shellนี่คือmongo shellอินเตอร์เฟส JavaScript
• mongodb-org-tools เครื่องมือบางอย่างสำหรับกิจกรรมการบริหาร

ดำเนินการติดตั้งแพ็คเกจ

อิมพอร์ตพับลิกคีย์ไปยังระบบการจัดการแพ็กเกจ

sudo apt-key adv --keyserver hkp://keyserver.ubuntu.com:80 --recv 0C49F3730359A14518585931BC711F9BA15703C6

สร้างไฟล์รายการสำหรับ MongoDB '/etc/apt/sources.list.d/mongodb-org-3.4.list'

echo "deb [ arch=amd64,arm64 ] http://repo.mongodb.org/apt/ubuntu xenial/mongodb-org/3.4 multiverse" | sudo tee /etc/apt/sources.list.d/mongodb-org-3.4.list

อัพเดตฐานข้อมูลแพ็กเกจ

sudo apt-get update

ติดตั้ง MongoDB metapackage

sudo apt-get install -y mongodb-org

เริ่มบริการ MongoDB

sudo service mongod start

ตอนนี้คุณสามารถเปิดmongo shellในเซสชั่นทุบตีใด ๆ ในการทำเช่นนี้คุณต้องใช้mongoคำสั่ง คุณจะได้รับการต้อนรับจากบางสิ่งที่คล้ายกับสิ่งนี้

MongoDB shell version v3.4.7
connecting to: mongodb://127.0.0.1:27017
MongoDB server version: 3.4.7
Welcome to the MongoDB shell.
For interactive help, type "help".
For more comprehensive documentation, see http://docs.mongodb.org/
Questions? Try the support group
http://groups.google.com/group/mongodb-user
Server has startup warnings:
*Some extra logs are cut by the way*
>

อย่าลืมปิดบริการด้วยsudo service mongod stopเพราะในภายหลังเราจะเริ่มต้นmongodอีกครั้งด้วยพารามิเตอร์บางอย่าง ทำซ้ำกระบวนการนี้ในทั้ง 3 โหนดของชุด

ขั้นตอนที่ 3: กำหนดค่า accessfile key

การใช้ keyfile บังคับสองแนวคิดในการดูแลชุดแบบจำลอง Internal Authenticationคนแรกคือ โดยเริ่มต้นที่คุณสามารถเริ่มต้นmongo shellเซสชั่นโดยไม่ต้องใช้ผู้ใช้และการประชุมครั้งนี้จะมีการควบคุมเต็มรูปแบบของฐานข้อมูล แต่เมื่อคุณใช้ keyfile สำหรับการตรวจสอบของคุณเซสชั่นถึงรัฐที่เรียกว่าmongo shell localhost exceptionสถานะนี้ให้คุณสร้างผู้ใช้ผู้ดูแลระบบและชุดแบบจำลองเท่านั้น แนวคิดที่สองคือRole-Based Access Controlหรือในคำอื่น ๆ การอนุญาต สิ่งนี้ถูกบังคับใช้เพื่อควบคุมระดับการดูแลระบบให้กับชุดเรพลิกา

สร้าง keyfile ของคุณ

keyfile เป็นรหัสผ่านที่ใช้ในชุดรหัสผ่านนี้จะต้องเหมือนกันในสมาชิกทุกคนในชุด เพื่อเพิ่มความปลอดภัยเป็นสิ่งสำคัญที่จะต้องใช้กุญแจสุ่มกับเครื่องมือที่คุณเลือก

เนื้อหาจะต้องมีความยาวระหว่าง 6 ถึง 1064 ตัวอักษร นอกจากนี้คุณต้องตั้งค่าการread onlyอนุญาตสำหรับ keyfile

chmod 400 PATH_OF_YOUR_KEYFILE

วาง keyfile ในสมาชิกแต่ละชุด

ตอนนี้คัดลอกไฟล์คีย์ของคุณไปยังสมาชิกทุกคนในชุดโปรดใช้โฟลเดอร์ที่สอดคล้องกันสำหรับการอ้างอิงในอนาคตและอย่าเก็บไว้ในสื่อที่ถอดออกได้

ใช้โฟลเดอร์สำหรับไฟล์ที่mongodสามารถเข้าถึงได้

บังคับใช้ keyfile ในชุด Replica

ในขั้นตอนนี้เราจำเป็นต้องเริ่มต้นในสมาชิกชุดทุกmongod daemon การเริ่มต้นmongodกระบวนการมีสองวิธี: การใช้ไฟล์ปรับแต่งหรือใช้บรรทัดคำสั่ง ทั้งสองวิธีค่อนข้างง่าย แต่เพื่อความเรียบง่ายบทช่วยสอนนี้ใช้เวอร์ชันบรรทัดคำสั่ง

การกำหนดค่าบรรทัดคำสั่ง

ใช้ชื่อที่คุณเลือกไว้ก่อนหน้านี้ในคำสั่งนี้

mongod --keyFile PATH_OF_YOUR_KEYFILE --replSet "YOUR_SET_NAME"

โดยค่าเริ่มต้นmongodจะไม่ทำงานเป็น daemon คุณจะต้องใช้--forkพารามิเตอร์หรือใช้upstartเพื่อรันเป็น daemon อย่างสมบูรณ์ ในบทช่วยสอนนี้เราไม่สนับสนุนให้เรียกใช้mongodเป็น daemon เพื่อให้คุณสามารถดูบันทึกในเทอร์มินัลของคุณโดยตรง

หมายเหตุ: พิมพ์ชื่อของชุดแบบจำลองอย่างระมัดระวังเพราะเมื่อสร้างแล้วคุณจะไม่สามารถเปลี่ยนได้

ขั้นตอนที่ 4: เชื่อมต่อกับอินเตอร์เฟส localhost จากหนึ่งในสมาชิกชุด

หมายเหตุ: หากคุณเรียกใช้mongodเป็นกระบวนการที่ไม่ใช่ daemon คุณจะต้องเปิดการเชื่อมต่อ ssh อื่นเพื่อทำงานต่อไป

คุณต้องใช้คำสั่งเพื่อเปิดmongo mongo shellสามารถทำได้ในสมาชิกชุดใดก็ได้

localhost exceptionในขณะนี้เราอยู่ในสถานะที่เรียกว่า เมื่อคีย์ไฟล์ถูกใช้เพื่อตั้งค่าmongodกระบวนการคุณจำเป็นต้องสร้างผู้ดูแลระบบฐานข้อมูลก่อนที่คุณจะสามารถใช้การดำเนินการอ่าน - เขียนได้ แต่เราจะดำเนินการในภายหลัง

ขั้นตอนที่ 5: การเริ่มต้นชุดแบบจำลอง

นี่คือส่วนที่ละเอียดอ่อนเรากำลังใช้คำสั่งrs.initiate()ภายในmongo shellจากขั้นตอนที่ 4 ก่อนที่จะใช้คำสั่งนี้ให้ตรวจสอบมัน

rs.initiate(
  {
    _id : <replicaSetName>,
    members: [
      { _id : 0, host : "example1.net:27017" },
      { _id : 1, host : "example2.net:27017" },
      { _id : 2, host : "example3.net:27017" }
    ]
  }
)

ครั้งแรกที่_idสนามเป็นสตริงและต้องตรงกับที่ผ่านมาก่อนที่จะ--replSet mongodนอกจากนี้ค่าแต่ละค่าhostจะต้องเป็น ip หรือชื่อโดเมนของสมาชิกแต่ละคนของชุดแบบจำลอง อย่าลืมผนวกพอร์ตที่อินสแตนซ์ Mongo ใช้ในสมาชิกแต่ละคน

ตอนนี้ถึงเวลาที่จะดำเนินการคำสั่งด้วยข้อมูลของคุณมันจะทริกเกอร์electionแล้วหลักจะได้รับการเลือกตั้งโดยอัตโนมัติ

ที่นี่คุณควรทราบว่าเคอร์เซอร์เปลือกของคุณมีการเปลี่ยนแปลงไปหรือYOUR_SET_NAME:PRIMARY> YOUR_SET_NAME:SECONDARYซึ่งหมายความว่าการสร้างชุดนั้นประสบความสำเร็จ

หากต้องการทำงานต่อไปคุณจะต้องค้นหาสิ่งต่อไปprimaryนี้หากไม่ได้อยู่ในหลักสูตร ใช้คำสั่งเพื่อแสดงข้อมูลของชุดแบบจำลองและค้นหาrs.status() คุณกำลังมองหาสถานที่ให้บริการprimary"stateStr" : "PRIMARY"

ขั้นตอนที่ 6: การสร้างผู้ดูแลระบบ

หลังจากที่คุณพบprimaryแล้วให้ป้อนmongo shellและเรียกใช้คำสั่งถัดไปโดยใช้ข้อมูลของคุณ

admin = db.getSiblingDB("admin")
admin.createUser(
  {
    user: "YOUR_USER",
    pwd: "YOU_PASSWORD",
    roles: [ { role: "userAdminAnyDatabase", db: "admin" } ]
  }
)

admin = db.getSiblingDB("admin")ส่วนช่วยให้เราเขียนลงในadminจากฐานข้อมูลที่แตกต่างกัน สิ่งนี้จะสร้างนามแฝงที่เรียกว่าadminเพื่อให้เราสามารถรันคำสั่งโดยใช้แทน

หากการดำเนินการสำเร็จคุณจะได้รับการแจ้งเตือนว่ามีการเพิ่มผู้ใช้

Successfully added user: {
    "user" : "YOUR_USER",
    "roles" : [
        {
            "role" : "userAdminAnyDatabase",
            "db" : "admin"
        }
    ]
}

ณ จุดนี้เรามีผู้ดูแลระบบสำหรับเซิร์ฟเวอร์ทั้งหมดเท่านั้น แต่การมีชุดจำลองทำให้เราต้องมีผู้ใช้ที่มีclusterAdminบทบาท เราจะสร้างผู้ใช้รายอื่นโดยมีเพียงบทบาทนั้นเพื่อแยกข้อกังวลออก

ขั้นตอนที่ 7: รับรองความถูกต้องเป็นผู้ดูแล

เราถึงขีด จำกัดlocalhost exceptionซึ่งเป็นสาเหตุที่เราต้องเปลี่ยนการรับรองความถูกต้องให้กับผู้ใช้ที่สร้างขึ้นหนึ่งขั้นตอนก่อนหน้านี้

คุณสามารถเปลี่ยนผู้ใช้ภายในmongo shellด้วยต่อไปนี้

db.getSiblingDB("admin").auth("YOUR_ADMIN", "YOUR_PASSWORD" )

หากคุณยังไม่ได้เชื่อมต่อกับmongo shellคำสั่งนี้ให้ใช้แทน

mongo -u "YOUR_ADMIN" -p "YOUR_PASSWORD" --authenticationDatabase "admin"

คุณจะได้รับแจ้งการเปลี่ยนแปลงของผู้ใช้และคุณสามารถไปยังขั้นตอนต่อไป

ขั้นตอนที่ 8: การสร้างมาสเตอร์คลัสเตอร์

clusterAdminบทบาทช่วยให้ผู้ใช้ควบคุมเต็มรูปแบบของชุดแบบจำลอง การสร้างมันง่ายเหมือนการสร้างผู้ใช้งาน admin

db.getSiblingDB("admin").createUser(
  {
    "user" : "YOUR_USER",
    "pwd" : "YOUR_PASSWORD",
    roles: [ { "role" : "clusterAdmin", "db" : "admin" } ]
  }
)

clusterAdminหมายเหตุว่าเวลานี้บทบาทที่มีการเปลี่ยนแปลงไป

ขั้นตอนที่ 9: การแทรกข้อมูลลงในชุดแบบจำลอง

ในขณะนี้เรามีผู้ใช้ 2 คน: ผู้ใช้ที่มีการควบคุมเซิร์ฟเวอร์และอีกคนที่สามารถเข้าถึงงานการดูแลระบบในระดับชุดแบบจำลอง อย่างไรก็ตามเราไม่มีผู้ใช้ที่สามารถเข้าถึง "ใช้" ฐานข้อมูลดังนั้นเราจะสร้างผู้ใช้นั้นในตอนนี้

admin = db.getSiblingDB("admin")
admin.createUser(
  {
    user: "YOUR_USER",
    pwd: "YOUR_PASSWORD",
    roles: [ { role: "userAdminAnyDatabase", db: "cars" } ]
  }
)

ขอให้สังเกตเวลานี้เรามีการเปลี่ยนแปลงบางส่วนมีเราจะวางฐานข้อมูลสามารถเข้าถึงได้ให้กับผู้ใช้ในกรณีนี้เราจะใช้ฐานข้อมูลชื่อdbcars

ฐานข้อมูลยังไม่ถูกสร้างขึ้น ในการทำเช่นนั้นคุณจะต้องพิมพ์คำสั่งบางอย่างเพื่อสร้างมันขึ้นมาโดยปริยาย สลับไปยังcarsฐานข้อมูล

use cars

คุณจะได้รับการแจ้งเตือน: switched to db cars.

ฐานข้อมูลยังไม่ถูกสร้างขึ้นคุณจำเป็นต้องเขียนบางสิ่งลงไป เรากำลังใช้ตัวอย่างต่อไปนี้

db.models.insert({ make: "Dodge", model: "Viper", year: 2010 })

WriteResult({ "nInserted" : 1 })เวลานี้คุณจะได้รับการแจ้งเตือนด้วย

หากคุณต้องการคุณสามารถดึงข้อมูลวัตถุทั้งหมดในฐานข้อมูลด้วยfind()วิธีการ:

db.models.find()
{ "_id" : ObjectId("59acd8b55334882863541ff4"), "make" : "Dodge", "model" : "Viper", "year" : 2010 }

โปรดทราบว่า_idจะแตกต่างกันในผลลัพธ์ของคุณ แต่ข้อมูลอื่นควรเหมือนกัน ให้เวลาเพียงพอข้อมูลนี้จะถูกคัดลอกไปยังสมาชิกคนอื่น ๆ

ข้อสรุป

การสร้างชุดจำลองอาจเป็นเรื่องที่ท้าทายในตอนแรกเนื่องจากมีข้อมูลจำนวนมากที่จะเข้าใจ แต่เมื่อคุณได้รับแนวคิดเบื้องหลังคุณสามารถนำไปใช้งานได้อย่างรวดเร็วดังนั้นอย่ายอมแพ้ถ้าคุณไม่เข้าใจในครั้งแรก โปรดจำไว้ว่าชุดแบบจำลองมีความสำคัญในการดูแล MongoDB เพราะจะเปิดโอกาสให้เพิ่มคุณสมบัติขั้นสูงเช่น Load Balancing