Cara Membuat Basis Data MongoDB: 6 Aspek Penting yang Perlu Diketahui

Berdasarkan kebutuhan perangkat lunak Anda, Anda dapat memprioritaskan fleksibilitas, skalabilitas, kinerja, atau kecepatan. Oleh karena itu, pengembang dan bisnis sering bingung saat memilih database untuk kebutuhan mereka. Jika Anda membutuhkan database yang menyediakan fleksibilitas dan skalabilitas tinggi, dan agregasi data untuk analitik pelanggan, MongoDB mungkin cocok untuk Anda!
Pelajari lebih lanjut tentang struktur database MongoDB dan cara membuat, memantau, dan mengelola database Anda dalam panduan bermanfaat ini Klik untuk Tweet
Pada artikel ini, kita akan membahas struktur database MongoDB dan cara membuat, memantau, dan mengelola database Anda! Mari kita mulai.

Bagaimana Struktur Basis Data MongoDB?

MongoDB adalah database NoSQL tanpa skema. Ini berarti Anda tidak menentukan struktur untuk tabel/database seperti yang Anda lakukan untuk database SQL.

Tahukah Anda bahwa database NoSQL sebenarnya lebih cepat daripada database relasional? Ini karena karakteristik seperti pengindeksan, sharding, dan pipa agregasi. MongoDB juga dikenal dengan eksekusi kuerinya yang cepat. Inilah sebabnya mengapa lebih disukai oleh perusahaan seperti Google, Toyota, dan Forbes.

Di bawah ini, kita akan menjelajahi beberapa karakteristik utama MongoDB.

Dokumen

MongoDB memiliki model data dokumen yang menyimpan data sebagai dokumen JSON. Dokumen memetakan secara alami ke objek dalam kode aplikasi, membuatnya lebih mudah digunakan oleh pengembang.

Dalam tabel database relasional, Anda harus menambahkan kolom untuk menambahkan bidang baru. Itu tidak terjadi dengan bidang dalam dokumen JSON. Bidang dalam dokumen JSON dapat berbeda dari satu dokumen ke dokumen lainnya, sehingga tidak akan ditambahkan ke setiap catatan dalam database.

Dokumen dapat menyimpan struktur seperti array yang dapat disarangkan untuk mengekspresikan hubungan hierarkis. Selain itu, MongoDB mengonversi dokumen menjadi tipe biner JSON (BSON). Ini memastikan akses yang lebih cepat dan peningkatan dukungan untuk berbagai tipe data seperti string, integer, nomor boolean, dan banyak lagi!

Set Replika

Saat Anda membuat database baru di MongoDB, sistem secara otomatis membuat setidaknya 2 salinan data Anda lagi. Salinan ini dikenal sebagai "set replika", dan mereka terus-menerus mereplikasi data di antara mereka, memastikan ketersediaan data Anda yang lebih baik. Mereka juga menawarkan perlindungan terhadap waktu henti selama kegagalan sistem atau pemeliharaan terencana.

Koleksi

Koleksi adalah sekelompok dokumen yang terkait dengan satu database. Mereka mirip dengan tabel dalam database relasional.

Koleksi, bagaimanapun, jauh lebih fleksibel. Pertama, mereka tidak bergantung pada skema. Kedua, dokumen tidak harus memiliki tipe data yang sama!

Untuk melihat daftar koleksi milik database, gunakan perintah listCollections .

Pipa Agregasi

Anda dapat menggunakan kerangka kerja ini untuk menggabungkan beberapa operator dan ekspresi. Ini fleksibel karena memungkinkan Anda untuk memproses, mengubah, dan menganalisis data dari struktur apa pun.

Karena itu, MongoDB memungkinkan aliran data yang cepat dan fitur di 150 operator dan ekspresi. Ini juga memiliki beberapa tahap, seperti tahap Union, yang secara fleksibel menyatukan hasil dari beberapa koleksi.

Indeks

Anda dapat mengindeks bidang apa pun dalam dokumen MongoDB untuk meningkatkan efisiensinya dan meningkatkan kecepatan kueri. Pengindeksan menghemat waktu dengan memindai indeks untuk membatasi dokumen yang diperiksa. Bukankah ini jauh lebih baik daripada membaca setiap dokumen dalam koleksi?

Anda dapat menggunakan berbagai strategi pengindeksan, termasuk indeks gabungan di beberapa bidang. Misalnya, Anda memiliki beberapa dokumen yang berisi nama depan dan belakang karyawan di bidang terpisah. Jika Anda ingin nama depan dan belakang dikembalikan, Anda dapat membuat indeks yang menyertakan "Nama belakang" dan "Nama depan". Ini akan jauh lebih baik daripada memiliki satu indeks di "Nama belakang" dan satu lagi di "Nama depan".

Anda dapat memanfaatkan alat seperti Performance Advisor untuk lebih memahami kueri mana yang dapat memperoleh manfaat dari indeks.

Sharding

Sharding mendistribusikan satu set data di beberapa database. Dataset itu kemudian dapat disimpan di beberapa mesin untuk meningkatkan total kapasitas penyimpanan suatu sistem. Ini karena ia membagi kumpulan data yang lebih besar menjadi potongan yang lebih kecil dan menyimpannya di berbagai node data.

Data pecahan MongoDB di tingkat pengumpulan, mendistribusikan dokumen dalam koleksi di seluruh pecahan dalam sebuah cluster. Ini memastikan skalabilitas dengan memungkinkan arsitektur untuk menangani aplikasi terbesar.

Cara Membuat Basis Data MongoDB

Anda harus menginstal paket MongoDB yang sesuai untuk OS Anda terlebih dahulu. Buka halaman 'Unduh Server Komunitas MongoDB'. Dari opsi yang tersedia, pilih "versi" terbaru, format "paket" sebagai file zip, dan "platform" sebagai OS Anda dan klik "Unduh" seperti yang digambarkan di bawah ini:

Prosesnya cukup mudah, jadi Anda akan segera menginstal MongoDB di sistem Anda!

Setelah Anda selesai menginstal, buka command prompt Anda dan ketik mongod -version untuk memverifikasinya. Jika Anda tidak mendapatkan output berikut dan malah melihat serangkaian kesalahan, Anda mungkin harus menginstal ulang:

Menggunakan MongoDB Shell

Sebelum kita mulai, pastikan bahwa:

• Klien Anda memiliki Keamanan Lapisan Transportasi dan ada dalam daftar IP yang diizinkan.
• Anda memiliki akun pengguna dan kata sandi pada cluster MongoDB yang diinginkan.
• Anda telah menginstal MongoDB di perangkat Anda.

Langkah 1: Akses MongoDB Shell

Untuk mendapatkan akses ke shell MongoDB, ketik perintah berikut:

 net start MongoDB

Ini harus memberikan output berikut:

Perintah sebelumnya menginisialisasi server MongoDB. Untuk menjalankannya, kita harus mengetikkan mongo di command prompt.

Di sini, di shell MongoDB, kita dapat menjalankan perintah untuk membuat database, memasukkan data, mengedit data, mengeluarkan perintah administratif, dan menghapus data.

Langkah 2: Buat Basis Data Anda

Tidak seperti SQL, MongoDB tidak memiliki perintah pembuatan database. Sebagai gantinya, ada kata kunci yang disebut use yang beralih ke database tertentu. Jika database tidak ada, itu akan membuat database baru, jika tidak, itu akan menautkan ke database yang ada.

Misalnya, untuk memulai database yang disebut "perusahaan", ketik:

 use Company

Anda dapat mengetikkan db untuk mengonfirmasi database yang baru saja Anda buat di sistem Anda. Jika database baru yang Anda buat muncul, Anda telah berhasil menyambungkannya.

Jika Anda ingin memeriksa database yang ada, ketik show dbs dan itu akan mengembalikan semua database di sistem Anda:

Secara default, menginstal MongoDB membuat admin, konfigurasi, dan database lokal.

Apakah Anda memperhatikan bahwa database yang kami buat tidak ditampilkan? Ini karena kita belum menyimpan nilai ke dalam database! Kami akan membahas penyisipan di bawah bagian manajemen basis data.

Menggunakan Atlas UI

Anda juga dapat memulai dengan layanan database MongoDB, Atlas. Meskipun Anda mungkin perlu membayar untuk mengakses beberapa fitur Atlas, sebagian besar fungsionalitas basis data tersedia dengan tingkat gratis. Fitur tier gratis lebih dari cukup untuk membuat database MongoDB.

Sebelum kita mulai, pastikan bahwa:

1. IP Anda ada di daftar yang diizinkan.
2. Anda memiliki akun pengguna dan kata sandi di cluster MongoDB yang ingin Anda gunakan.

Untuk membuat Database MongoDB dengan AtlasUI, buka jendela browser dan masuk ke https://cloud.mongodb.com. Dari laman klaster Anda, klik Jelajahi Koleksi . Jika tidak ada database di cluster, Anda dapat membuat database Anda dengan mengklik tombol Add My Own Data .

Prompt akan meminta Anda untuk memberikan database dan nama koleksi. Setelah Anda menamainya, klik Buat , dan selesai! Anda sekarang dapat memasukkan dokumen baru atau terhubung ke database menggunakan driver.

Mengelola Basis Data MongoDB Anda

Di bagian ini, kita akan membahas beberapa cara bagus untuk mengelola database MongoDB Anda secara efektif. Anda dapat melakukan ini dengan menggunakan Kompas MongoDB atau melalui koleksi.

Menggunakan Koleksi

Sementara database relasional memiliki tabel yang terdefinisi dengan baik dengan tipe data dan kolom tertentu, NoSQL memiliki koleksi, bukan tabel. Koleksi ini tidak memiliki struktur apa pun, dan dokumen dapat bervariasi — Anda dapat memiliki tipe dan bidang data yang berbeda tanpa harus mencocokkan format dokumen lain dalam koleksi yang sama.

Untuk mendemonstrasikan, mari buat koleksi yang disebut "Karyawan" dan tambahkan dokumen ke dalamnya:

 db.Employee.insert( { "Employeename" : "Chris", "EmployeeDepartment" : "Sales" } )

Jika penyisipan berhasil, ia akan mengembalikan WriteResult({ "nInserted" : 1 }) :

Di sini, "db" mengacu pada database yang saat ini terhubung. "Karyawan" adalah koleksi yang baru dibuat di database perusahaan.

Kami belum menetapkan kunci utama di sini karena MongoDB secara otomatis membuat bidang kunci utama yang disebut "_id" dan menetapkan nilai default untuk itu.

Jalankan perintah di bawah ini untuk memeriksa koleksi dalam format JSON:

 db.Employee.find().forEach(printjson)

Keluaran:

 { "_id" : ObjectId("63151427a4dd187757d135b8"), "Employeename" : "Chris", "EmployeeDepartment" : "Sales" }

Sementara nilai “_id” ditetapkan secara otomatis, Anda dapat mengubah nilai kunci utama default. Kali ini, kita akan memasukkan dokumen lain ke dalam database “Employee”, dengan nilai “_id” sebagai “1”:

 db.Employee.insert( { "_id" : 1, "EmployeeName" : "Ava", "EmployeeDepartment" : "Public Relations" } )

Saat menjalankan perintah db.Employee.find().forEach(printjson) kita mendapatkan output berikut:

Pada output di atas, nilai "_id" untuk "Ava" diatur ke "1" alih-alih diberi nilai secara otomatis.

Sekarang kita telah berhasil menambahkan nilai ke dalam database, kita dapat memeriksa apakah itu muncul di bawah database yang ada di sistem kita menggunakan perintah berikut:

 show dbs

Dan voila! Anda telah berhasil membuat database di sistem Anda!

Menggunakan Kompas MongoDB

Meskipun kita dapat bekerja dengan server MongoDB dari shell Mongo, terkadang hal itu membosankan. Anda mungkin mengalami ini di lingkungan produksi.

Namun, ada alat kompas (tepatnya bernama Kompas) yang dibuat oleh MongoDB yang dapat membuatnya lebih mudah. Ini memiliki GUI yang lebih baik dan fungsionalitas tambahan seperti visualisasi data, profil kinerja, dan akses CRUD (membuat, membaca, memperbarui, menghapus) ke data, database, dan koleksi.

Anda dapat mengunduh Compass IDE untuk OS Anda dan menginstalnya dengan proses yang mudah.

Selanjutnya, buka aplikasi dan buat koneksi dengan server dengan menempelkan string koneksi. Jika Anda tidak dapat menemukannya, Anda dapat mengklik Isi kolom koneksi satu per satu . Jika Anda tidak mengubah nomor port saat menginstal MongoDB, cukup klik tombol sambungkan, dan Anda masuk! Jika tidak, cukup masukkan nilai yang Anda tetapkan dan klik Hubungkan .

Selanjutnya, berikan Hostname, Port, dan Authentication di jendela New Connection.

Di MongoDB Compass, Anda dapat membuat database dan menambahkan koleksi pertamanya secara bersamaan. Inilah cara Anda melakukannya:

1. Klik Buat Database untuk membuka prompt.
2. Masukkan nama database dan koleksi pertamanya.
3. Klik Buat Basis Data .

Anda dapat memasukkan lebih banyak dokumen ke dalam database Anda dengan mengklik nama database Anda, dan kemudian mengklik nama koleksi untuk melihat tab Dokumen . Anda kemudian dapat mengklik tombol Tambah Data untuk menyisipkan satu atau beberapa dokumen ke dalam koleksi Anda.

Saat menambahkan dokumen Anda, Anda dapat memasukkannya satu per satu atau sebagai beberapa dokumen dalam sebuah larik. Jika Anda menambahkan beberapa dokumen, pastikan dokumen yang dipisahkan koma ini diapit dalam tanda kurung siku. Sebagai contoh:

 { _id: 1, item: { name: "apple", code: "123" }, qty: 15, tags: [ "A", "B", "C" ] }, { _id: 2, item: { name: "banana", code: "123" }, qty: 20, tags: [ "B" ] }, { _id: 3, item: { name: "spinach", code: "456" }, qty: 25, tags: [ "A", "B" ] }, { _id: 4, item: { name: "lentils", code: "456" }, qty: 30, tags: [ "B", "A" ] }, { _id: 5, item: { name: "pears", code: "000" }, qty: 20, tags: [ [ "A", "B" ], "C" ] }, { _id: 6, item: { name: "strawberry", code: "123" }, tags: [ "B" ] }

Terakhir, klik Sisipkan untuk menambahkan dokumen ke koleksi Anda. Ini akan menjadi seperti apa isi dokumen:

 { "StudentID" : 1 "StudentName" : "JohnDoe" }

Di sini, nama bidangnya adalah "StudentID" dan "StudentName". Nilai bidang masing-masing adalah "1" dan "JohnDoe".

Perintah yang Berguna

Anda dapat mengelola koleksi ini melalui manajemen peran dan perintah manajemen pengguna.

Perintah Manajemen Pengguna

Perintah manajemen pengguna MongoDB berisi perintah yang berhubungan dengan pengguna. Kami dapat membuat, memperbarui, dan menghapus pengguna menggunakan perintah ini.

dropPengguna

Perintah ini menghapus satu pengguna dari database yang ditentukan. Di bawah ini adalah sintaksnya:

 db.dropUser(username, writeConcern)

Di sini, username adalah bidang wajib yang berisi dokumen dengan otentikasi dan informasi akses tentang pengguna. writeConcern bidang opsional berisi tingkat perhatian penulisan untuk operasi pembuatan. Tingkat kekhawatiran penulisan dapat ditentukan oleh bidang opsional writeConcern .

Sebelum menjatuhkan pengguna yang memiliki peran userAdminAnyDatabase , pastikan bahwa setidaknya ada satu pengguna lain dengan hak istimewa administrasi pengguna.

Dalam contoh ini, kami akan menjatuhkan pengguna "user26" di database pengujian:

 use test db.dropUser("user26", {w: "majority", wtimeout: 4000})

Keluaran:

 > db.dropUser("user26", {w: "majority", wtimeout: 4000}); true

buat pengguna

Perintah ini membuat pengguna baru untuk database yang ditentukan sebagai berikut:

 db.createUser(user, writeConcern)

Di sini, user adalah bidang wajib yang berisi dokumen dengan otentikasi dan informasi akses tentang pengguna yang akan dibuat. writeConcern bidang opsional berisi tingkat perhatian penulisan untuk operasi pembuatan. Tingkat kekhawatiran penulisan dapat ditentukan oleh bidang opsional, writeConcern .

createUser akan mengembalikan kesalahan pengguna duplikat jika pengguna sudah ada di database.

Anda dapat membuat pengguna baru di database pengujian sebagai berikut:

 use test db.createUser( { user: "user26", pwd: "myuser123", roles: [ "readWrite" ] } );

Outputnya adalah sebagai berikut:

 Successfully added user: { "user" : "user26", "roles" : [ "readWrite", "dbAdmin" ] }

hibahPeranKepadaPengguna

Anda dapat memanfaatkan perintah ini untuk memberikan peran tambahan kepada pengguna. Untuk menggunakannya, Anda perlu mengingat sintaks berikut:

 db.runCommand( { grantRolesToUser: "<user>", roles: [ <roles> ], writeConcern: { <write concern> }, comment: <any> } )

Anda dapat menentukan peran yang ditentukan pengguna dan bawaan dalam peran yang disebutkan di atas. Jika Anda ingin menentukan peran yang ada di database yang sama di mana grantRolesToUser berjalan, Anda bisa menentukan peran dengan dokumen, seperti yang disebutkan di bawah ini:

 { role: "<role>", db: "<database>" }

Atau, Anda cukup menentukan peran dengan nama peran. Contohnya:

 "readWrite"

Jika Anda ingin menentukan peran yang ada di database yang berbeda, Anda harus menentukan peran dengan dokumen yang berbeda.

Untuk memberikan peran pada database, Anda memerlukan tindakan grantRole pada database yang ditentukan.

Berikut adalah contoh untuk memberi Anda gambaran yang jelas. Ambil, misalnya, pengguna productUser00 dalam database produk dengan peran berikut:

 "roles" : [ { "role" : "assetsWriter", "db" : "assets" } ]

Operasi grantRolesToUser menyediakan "productUser00" peran readWrite pada database stok dan peran baca pada database produk:

 use products db.runCommand({ grantRolesToUser: "productUser00", roles: [ { role: "readWrite", db: "stock"}, "read" ], writeConcern: { w: "majority" , wtimeout: 2000 } })

Pengguna productUser00 dalam database produk sekarang memiliki peran berikut:

 "roles" : [ { "role" : "assetsWriter", "db" : "assets" }, { "role" : "readWrite", "db" : "stock" }, { "role" : "read", "db" : "products" } ]

info pengguna

Anda dapat menggunakan perintah usersInfo untuk mengembalikan informasi tentang satu atau lebih pengguna. Berikut sintaksnya:

 db.runCommand( { usersInfo: <various>, showCredentials: <Boolean>, showCustomData: <Boolean>, showPrivileges: <Boolean>, showAuthenticationRestrictions: <Boolean>, filter: <document>, comment: <any> } ) { usersInfo: <various> }

Dalam hal akses, pengguna selalu dapat melihat informasi mereka sendiri. Untuk melihat informasi pengguna lain, pengguna yang menjalankan perintah harus memiliki hak istimewa yang menyertakan tindakan viewUser di database pengguna lain.

Saat menjalankan perintah userInfo , Anda dapat memperoleh informasi berikut tergantung pada opsi yang ditentukan:

 { "users" : [ { "_id" : "<db>.<username>", "userId" : <UUID>, // Starting in MongoDB 4.0.9 "user" : "<username>", "db" : "<db>", "mechanisms" : [ ... ], // Starting in MongoDB 4.0 "customData" : <document>, "roles" : [ ... ], "credentials": { ... }, // only if showCredentials: true "inheritedRoles" : [ ... ], // only if showPrivileges: true or showAuthenticationRestrictions: true "inheritedPrivileges" : [ ... ], // only if showPrivileges: true or showAuthenticationRestrictions: true "inheritedAuthenticationRestrictions" : [ ] // only if showPrivileges: true or showAuthenticationRestrictions: true "authenticationRestrictions" : [ ... ] // only if showAuthenticationRestrictions: true }, ], "ok" : 1 }

Sekarang setelah Anda memiliki gagasan umum tentang apa yang dapat Anda capai dengan perintah usersInfo , pertanyaan berikutnya yang mungkin muncul adalah, perintah apa yang berguna untuk melihat pengguna tertentu dan banyak pengguna?

Berikut adalah dua contoh praktis untuk menggambarkan hal yang sama:
Untuk melihat hak istimewa dan informasi khusus untuk pengguna tertentu, tetapi bukan kredensial, untuk pengguna "Anthony" yang ditentukan dalam database "kantor", jalankan perintah berikut:

 db.runCommand( { usersInfo: { user: "Anthony", db: "office" }, showPrivileges: true } )

Jika Anda ingin melihat pengguna di database saat ini, Anda hanya dapat menyebutkan nama pengguna. Misalnya, jika Anda berada di database rumah dan pengguna bernama "Timothy" ada di database rumah, Anda dapat menjalankan perintah berikut:

 db.getSiblingDB("home").runCommand( { usersInfo: "Timothy", showPrivileges: true } )

Selanjutnya, Anda dapat menggunakan array jika Anda ingin melihat informasi untuk berbagai pengguna. Anda dapat menyertakan bidang opsional showCredentials dan showPrivileges , atau Anda dapat memilih untuk tidak memasukkannya. Ini adalah apa yang akan terlihat seperti perintah:

 db.runCommand({ usersInfo: [ { user: "Anthony", db: "office" }, { user: "Timothy", db: "home" } ], showPrivileges: true })

mencabutPeranDariPengguna

Anda dapat memanfaatkan perintah revokeRolesFromUser untuk menghapus satu atau beberapa peran dari pengguna di database tempat peran tersebut ada. Perintah revokeRolesFromUser memiliki sintaks berikut:

 db.runCommand( { revokeRolesFromUser: "<user>", roles: [ { role: "<role>", db: "<database>" } | "<role>", ], writeConcern: { <write concern> }, comment: <any> } )

Dalam sintaks yang disebutkan di atas, Anda dapat menentukan peran yang ditentukan pengguna dan bawaan di bidang roles . Mirip dengan perintah grantRolesToUser , Anda dapat menentukan peran yang ingin Anda cabut dalam dokumen atau menggunakan namanya.

Agar berhasil menjalankan perintah revokeRolesFromUser , Anda harus memiliki tindakan revokeRole pada database yang ditentukan.

Berikut adalah contoh untuk mengarahkan poin ke rumah. Entitas productUser00 dalam database produk memiliki peran berikut:

 "roles" : [ { "role" : "assetsWriter", "db" : "assets" }, { "role" : "readWrite", "db" : "stock" }, { "role" : "read", "db" : "products" } ]

Perintah revokeRolesFromUser berikut akan menghapus dua peran pengguna: peran "baca" dari products dan peran assetsWriter dari database "aset":

 use products db.runCommand( { revokeRolesFromUser: "productUser00", roles: [ { role: "AssetsWriter", db: "assets" }, "read" ], writeConcern: { w: "majority" } } )

Pengguna "productUser00" di database produk sekarang hanya memiliki satu peran yang tersisa:

 "roles" : [ { "role" : "readWrite", "db" : "stock" } ]

Perintah Manajemen Peran

Peran memberi pengguna akses ke sumber daya. Beberapa peran bawaan dapat digunakan oleh administrator untuk mengontrol akses ke sistem MongoDB. Jika peran tidak mencakup hak istimewa yang diinginkan, Anda bahkan dapat melangkah lebih jauh untuk membuat peran baru dalam database tertentu.

dropPeran

Dengan perintah dropRole , Anda dapat menghapus peran yang ditentukan pengguna dari database tempat Anda menjalankan perintah. Untuk menjalankan perintah ini, gunakan sintaks berikut:

 db.runCommand( { dropRole: "<role>", writeConcern: { <write concern> }, comment: <any> } )

Untuk eksekusi yang berhasil, Anda harus memiliki tindakan dropRole pada database yang ditentukan. Operasi berikut akan menghapus peran writeTags dari database "produk":

 use products db.runCommand( { dropRole: "writeTags", writeConcern: { w: "majority" } } )

buatPeran

Anda dapat memanfaatkan perintah createRole untuk membuat peran dan menentukan hak istimewanya. Peran akan diterapkan ke database tempat Anda memilih untuk menjalankan perintah. Perintah createRole akan mengembalikan kesalahan peran duplikat jika peran sudah ada di database.

Untuk menjalankan perintah ini, ikuti sintaks yang diberikan:

 db.adminCommand( { createRole: "<new role>", privileges: [ { resource: { <resource> }, actions: [ "<action>", ... ] }, ], roles: [ { role: "<role>", db: "<database>" } | "<role>", ], authenticationRestrictions: [ { clientSource: ["<IP>" | "<CIDR range>", ...], serverAddress: ["<IP>" | "<CIDR range>", ...] }, ], writeConcern: <write concern document>, comment: <any> } )

Hak istimewa peran akan diterapkan ke database tempat peran dibuat. Peran tersebut dapat mewarisi hak istimewa dari peran lain dalam databasenya. Misalnya, peran yang dibuat pada database "admin" dapat mencakup hak istimewa yang berlaku untuk cluster atau semua database. Itu juga dapat mewarisi hak istimewa dari peran yang ada di database lain.

Untuk membuat peran dalam database, Anda harus memiliki dua hal:

1. Tindakan grantRole pada database itu untuk menyebutkan hak istimewa untuk peran baru serta menyebutkan peran yang akan diwarisi.
2. Tindakan createRole pada sumber daya database tersebut.

Perintah createRole berikut akan membuat peran clusterAdmin di database pengguna:

 db.adminCommand({ createRole: "clusterAdmin", privileges: [ { resource: { cluster: true }, actions: [ "addShard" ] }, { resource: { db: "config", collection: "" }, actions: [ "find", "remove" ] }, { resource: { db: "users", collection: "usersCollection" }, actions: [ "update", "insert" ] }, { resource: { db: "", collection: "" }, actions: [ "find" ] } ], roles: [ { role: "read", db: "user" } ], writeConcern: { w: "majority" , wtimeout: 5000 } })

hibahPeranUntukPeran

Dengan perintah grantRolesToRole , Anda dapat memberikan peran ke peran yang ditentukan pengguna. Perintah grantRolesToRole akan mempengaruhi peran pada database tempat perintah dijalankan.

Perintah grantRolesToRole ini memiliki sintaks berikut:

 db.runCommand( { grantRolesToRole: "<role>", roles: [ { role: "<role>", db: "<database>" }, ], writeConcern: { <write concern> }, comment: <any> } )

Hak akses mirip dengan perintah grantRolesToUser — Anda memerlukan tindakan grantRole pada database untuk eksekusi perintah yang tepat.

Dalam contoh berikut, Anda dapat menggunakan perintah grantRolesToUser untuk memperbarui peran productsReader dalam database "produk" untuk mewarisi hak istimewa peran productsWriter :

 use products db.runCommand( { grantRolesToRole: "productsReader", roles: [ "productsWriter" ], writeConcern: { w: "majority" , wtimeout: 5000 } } )

mencabutHak IstimewaDariPeran

Anda dapat menggunakan revokePrivilegesFromRole untuk menghapus hak istimewa yang ditentukan dari peran yang ditentukan pengguna di database tempat perintah dijalankan. Untuk eksekusi yang tepat, Anda perlu mengingat sintaks berikut:

 db.runCommand( { revokePrivilegesFromRole: "<role>", privileges: [ { resource: { <resource> }, actions: [ "<action>", ... ] }, ], writeConcern: <write concern document>, comment: <any> } )

Untuk mencabut hak istimewa, pola "dokumen sumber daya" harus cocok dengan bidang "sumber daya" hak istimewa itu. Bidang "tindakan" dapat berupa pencocokan tepat atau subkumpulan.

Misalnya, pertimbangkan peran manageRole dalam database produk dengan hak istimewa berikut yang menentukan database "manajer" sebagai sumber daya:

 { "resource" : { "db" : "managers", "collection" : "" }, "actions" : [ "insert", "remove" ] }

Anda tidak dapat mencabut tindakan "masukkan" atau "hapus" hanya dari satu koleksi di database manajer. Operasi berikut tidak menyebabkan perubahan peran:

 use managers db.runCommand( { revokePrivilegesFromRole: "manageRole", privileges: [ { resource : { db : "managers", collection : "kiosks" }, actions : [ "insert", "remove" ] } ] } )

 db.runCommand( { revokePrivilegesFromRole: "manageRole", privileges: [ { resource : { db : "managers", collection : "kiosks" }, actions : [ "insert" ] } ] } )

Untuk mencabut tindakan "masukkan" dan/atau "hapus" dari peran manageRole , Anda harus mencocokkan dokumen sumber daya dengan tepat. Misalnya, operasi berikut hanya mencabut tindakan "hapus" dari hak istimewa yang ada:

 use managers db.runCommand( { revokePrivilegesFromRole: "manageRole", privileges: [ { resource : { db : "managers", collection : "" }, actions : [ "remove" ] } ] } )

Operasi berikut akan menghapus beberapa hak istimewa dari peran "eksekutif" di database manajer:

 use managers db.runCommand( { revokePrivilegesFromRole: "executive", privileges: [ { resource: { db: "managers", collection: "" }, actions: [ "insert", "remove", "find" ] }, { resource: { db: "managers", collection: "partners" }, actions: [ "update" ] } ], writeConcern: { w: "majority" } } )

informasi peran

Perintah rolesInfo akan mengembalikan hak istimewa dan informasi warisan untuk peran tertentu, termasuk peran bawaan dan yang ditentukan pengguna. Anda juga dapat memanfaatkan perintah rolesInfo untuk mengambil semua peran yang dicakup ke database.

Untuk eksekusi yang tepat, ikuti sintaks ini:

 db.runCommand( { rolesInfo: { role: <name>, db: <db> }, showPrivileges: <Boolean>, showBuiltinRoles: <Boolean>, comment: <any> } )

Untuk mengembalikan informasi peran dari database saat ini, Anda dapat menentukan namanya sebagai berikut:

 { rolesInfo: "<rolename>" }

Untuk mengembalikan informasi peran dari database lain, Anda bisa menyebutkan peran dengan dokumen yang menyebutkan peran dan database:

 { rolesInfo: { role: "<rolename>", db: "<database>" } }

Misalnya, perintah berikut mengembalikan informasi pewarisan peran untuk eksekutif peran yang ditentukan dalam database manajer:

 db.runCommand( { rolesInfo: { role: "executive", db: "managers" } } )

Perintah berikutnya ini akan mengembalikan informasi pewarisan peran: accountManager pada database tempat perintah dijalankan:

 db.runCommand( { rolesInfo: "accountManager" } )

Perintah berikut akan mengembalikan hak istimewa dan pewarisan peran untuk peran "eksekutif" seperti yang didefinisikan pada database manajer:

 db.runCommand( { rolesInfo: { role: "executive", db: "managers" }, showPrivileges: true } )

Untuk menyebutkan beberapa peran, Anda dapat menggunakan array. Anda juga dapat menyebutkan setiap peran dalam array sebagai string atau dokumen.

Anda harus menggunakan string hanya jika peran ada di database tempat perintah dijalankan:

 { rolesInfo: [ "<rolename>", { role: "<rolename>", db: "<database>" }, ] }

Misalnya, perintah berikut akan mengembalikan informasi untuk tiga peran pada tiga database yang berbeda:

 db.runCommand( { rolesInfo: [ { role: "executive", db: "managers" }, { role: "accounts", db: "departments" }, { role: "administrator", db: "products" } ] } )

Anda bisa mendapatkan hak istimewa dan pewarisan peran sebagai berikut:

 db.runCommand( { rolesInfo: [ { role: "executive", db: "managers" }, { role: "accounts", db: "departments" }, { role: "administrator", db: "products" } ], showPrivileges: true } )

Menyematkan Dokumen MongoDB untuk Performa Lebih Baik

Database dokumen seperti MongoDB memungkinkan Anda menentukan skema sesuai dengan kebutuhan Anda. Untuk membuat skema yang optimal di MongoDB, Anda dapat membuat sarang dokumen. Jadi, alih-alih mencocokkan aplikasi Anda dengan model data, Anda bisa membangun model data yang cocok dengan kasus penggunaan Anda.

Dokumen yang disematkan memungkinkan Anda menyimpan data terkait yang Anda akses bersama. Saat merancang skema untuk MongoDB, sebaiknya Anda menyematkan dokumen secara default. Gunakan gabungan dan referensi sisi database atau sisi aplikasi hanya jika bermanfaat.

Pastikan bahwa beban kerja dapat mengambil dokumen sesering yang diperlukan. Pada saat yang sama, dokumen juga harus memiliki semua data yang dibutuhkan. Ini sangat penting untuk kinerja luar biasa aplikasi Anda.

Di bawah ini, Anda akan menemukan beberapa pola berbeda untuk menyematkan dokumen:

Pola Dokumen Tertanam

Anda dapat menggunakan ini untuk menyematkan bahkan sub-struktur yang rumit dalam dokumen yang mereka gunakan. Menyematkan data yang terhubung dalam satu dokumen dapat mengurangi jumlah operasi baca yang diperlukan untuk mendapatkan data. Umumnya, Anda harus menyusun skema sehingga aplikasi Anda menerima semua informasi yang diperlukan dalam satu operasi baca. Oleh karena itu, aturan yang perlu diingat di sini adalah apa yang digunakan bersama harus disimpan bersama .

Pola Subset Tertanam

Pola subset tertanam adalah kasus hibrida. Anda akan menggunakannya untuk koleksi terpisah dari daftar panjang item terkait, di mana Anda dapat menyimpan beberapa item tersebut untuk ditampilkan.

Berikut adalah contoh yang mencantumkan ulasan film:

 > db.movie.findOne() { _id: 321475, title: "The Dark Knight" } > db.review.find({movie_id: 321475}) { _id: 264579, movie_id: 321475, stars: 4 text: "Amazing" } { _id: 375684, movie_id: 321475, stars:5, text: "Mindblowing" }

Sekarang, bayangkan seribu ulasan serupa, tetapi Anda hanya berencana untuk menampilkan dua yang terbaru saat Anda menayangkan film. Dalam skenario ini, masuk akal untuk menyimpan subset itu sebagai daftar di dalam dokumen film:

 > db.movie.findOne({_id: 321475}) { _id: 321475, title: "The Dark Knight", recent_reviews: [ {_id: 264579, stars: 4, text: "Amazing"}, {_id: 375684, stars: 5, text: "Mindblowing"} ] }</code

Sederhananya, jika Anda secara rutin mengakses subset item terkait, pastikan Anda menyematkannya.

Akses Independen

Anda mungkin ingin menyimpan sub-dokumen dalam koleksinya untuk memisahkannya dari koleksi induknya.

Misalnya, ambil lini produk perusahaan. Jika perusahaan menjual sejumlah kecil produk, Anda mungkin ingin menyimpannya di dalam dokumen perusahaan. Tetapi jika Anda ingin menggunakannya kembali di seluruh perusahaan atau mengaksesnya secara langsung oleh unit penyimpanan stok (SKU), Anda juga ingin menyimpannya di koleksi mereka.

Jika Anda memanipulasi atau mengakses entitas secara independen, buat koleksi untuk menyimpannya secara terpisah untuk praktik terbaik.

Daftar Tanpa Batas

Menyimpan daftar pendek informasi terkait dalam dokumen mereka memiliki kelemahan. Jika daftar Anda terus bertambah tanpa dicentang, Anda tidak boleh memasukkannya ke dalam satu dokumen. Ini karena Anda tidak akan dapat mendukungnya untuk waktu yang lama.

Ada dua alasan untuk ini. Pertama, MongoDB memiliki batasan ukuran satu dokumen. Kedua, jika Anda mengakses dokumen terlalu banyak frekuensi, Anda akan melihat hasil negatif dari penggunaan memori yang tidak terkontrol.

Sederhananya, jika daftar mulai tumbuh tanpa batas, buat koleksi untuk menyimpannya secara terpisah.

Extended Reference Pattern

The extended reference pattern is like the subset pattern. It also optimizes information that you regularly access to store on the document.

Here, instead of a list, it's leveraged when a document refers to another that is present in the same collection. At the same time, it also stores some fields from that other document for ready access.

Contohnya:

 > db.movie.findOne({_id: 245434}) { _id: 245434, title: "Mission Impossible 4 - Ghost Protocol", studio_id: 924935, studio_name: "Paramount Pictures" }

As you can see, “the studio_id” is stored so that you can look up more information on the studio that created the film. But the studio's name is also copied to this document for simplicity.

To embed information from modified documents regularly, remember to update documents where you've copied that information when it is modified. In other words, if you routinely access some fields from a referenced document, embed them.

How To Monitor MongoDB

You can use monitoring tools like Kinsta APM to debug long API calls, slow database queries, long external URL requests, to name a few. You can even leverage commands to improve database performance. You can also use them to inspect the ase/” data-mce-href=”https://kinsta.com/knowledgebase/wordpress-repair-database/”>health of your database instances.

Why Should You Monitor MongoDB Databases?

A key aspect of database administration planning is monitoring your cluster's performance and health. MongoDB Atlas handles the majority of administration efforts through its fault-tolerance/scaling abilities.

Despite that, users need to know how to track clusters. They should also know how to scale or tweak whatever they need before hitting a crisis.

By monitoring MongoDB databases, you can:

• Observe the utilization of resources.
• Understand the current capacity of your database.
• React and detect real-time issues to enhance your application stack.
• Observe the presence of performance issues and abnormal behavior.
• Align with your governance/data protection and service-level agreement (SLA) requirements.

Key Metrics To Monitor

While monitoring MongoDB, there are four key aspects you need to keep in mind:

1. MongoDB Hardware Metrics

Here are the primary metrics for monitoring hardware:

Normalized Process CPU

It's defined as the percentage of time spent by the CPU on application software maintaining the MongoDB process.

You can scale this to a range of 0-100% by dividing it by the number of CPU cores. It includes CPU leveraged by modules such as kernel and user.

High kernel CPU might show exhaustion of CPU via the operating system operations. But the user linked with MongoDB operations might be the root cause of CPU exhaustion.

Normalized System CPU

It's the percentage of time the CPU spent on system calls servicing this MongoDB process. You can scale it to a range of 0-100% by dividing it by the number of CPU cores. It also covers the CPU used by modules such as iowait, user, kernel, steal, etc.

User CPU or high kernel might show CPU exhaustion through MongoDB operations (software). High iowait might be linked to storage exhaustion causing CPU exhaustion.

Disk IOPS

Disk IOPS is the average consumed IO operations per second on MongoDB's disk partition.

Disk Latency

This is the disk partition's read and write disk latency in milliseconds in MongoDB. High values (>500ms) show that the storage layer might affect MongoDB's performance.

System Memory

Use the system memory to describe physical memory bytes used versus available free space.

The available metric approximates the number of bytes of system memory available. You can use this to execute new applications, without swapping.

Disk Space Free

This is defined as the total bytes of free disk space on MongoDB's disk partition. MongoDB Atlas provides auto-scaling capabilities based on this metric.

Swap Usage

You can leverage a swap usage graph to describe how much memory is being placed on the swap device. A high used metric in this graph shows that swap is being utilized. This shows that the memory is under-provisioned for the current workload.

MongoDB Cluster's Connection and Operation Metrics

Here are the main metrics for Operation and Connection Metrics:

Operation Execution Times

The average operation time (write and read operations) performed over the selected sample period.

Opcounters

It is the average rate of operations executed per second over the selected sample period. Opcounters graph/metric shows the operations breakdown of operation types and velocity for the instance.

Koneksi

This metric refers to the number of open connections to the instance. High spikes or numbers might point to a suboptimal connection strategy either from the unresponsive server or the client side.

Query Targeting and Query Executors

This is the average rate per second over the selected sample period of scanned documents. For query executors, this is during query-plan evaluation and queries. Query targeting shows the ratio between the number of documents scanned and the number of documents returned.

Rasio angka yang tinggi menunjukkan operasi suboptimal. Operasi ini memindai banyak dokumen untuk mengembalikan bagian yang lebih kecil.

Pindai dan Pesan

Ini menjelaskan tingkat rata-rata per detik selama periode sampel kueri yang dipilih. Ini mengembalikan hasil yang diurutkan yang tidak dapat menjalankan operasi pengurutan menggunakan indeks.

Antrian

Antrian dapat menggambarkan jumlah operasi menunggu kunci, baik menulis atau membaca. Antrian yang tinggi dapat menggambarkan adanya desain skema yang kurang optimal. Ini juga bisa menunjukkan jalur penulisan yang saling bertentangan, mendorong persaingan tinggi atas sumber daya basis data.

Metrik Replikasi MongoDB

Berikut adalah metrik utama untuk pemantauan replikasi:

Jendela Oplog Replikasi

Metrik ini mencantumkan perkiraan jumlah jam yang tersedia di oplog replikasi utama. Jika sekunder tertinggal lebih dari jumlah ini, tidak dapat mengikuti dan akan membutuhkan sinkronisasi ulang penuh.

Keterlambatan Replikasi

Replikasi lag didefinisikan sebagai perkiraan jumlah detik node sekunder berada di belakang primer dalam operasi tulis. Jeda replikasi yang tinggi akan menunjukkan sekunder yang menghadapi kesulitan dalam mereplikasi. Ini mungkin memengaruhi latensi operasi Anda, mengingat masalah baca/tulis koneksi.

Ruang Kepala Replikasi

Metrik ini mengacu pada perbedaan antara jendela oplog replikasi primer dan jeda replikasi sekunder. Jika nilai ini menjadi nol, dapat menyebabkan sekunder masuk ke mode PEMULIHAN.

Opcounters -repl

Opcounters -repl didefinisikan sebagai tingkat rata-rata operasi replikasi yang dijalankan per detik untuk periode sampel yang dipilih. Dengan opcounters -graph/metric, Anda dapat melihat kecepatan operasi dan perincian jenis operasi untuk instance yang ditentukan.

Oplog GB/Jam

Ini didefinisikan sebagai tingkat rata-rata gigabyte oplog yang dihasilkan utama per jam. Volume oplog yang tinggi dan tidak terduga mungkin menunjukkan beban kerja tulis yang sangat tidak mencukupi atau masalah desain skema.

Alat Pemantauan Kinerja MongoDB

MongoDB memiliki alat antarmuka pengguna bawaan di Cloud Manager, Atlas, dan Ops Manager untuk pelacakan kinerja. Ini juga menyediakan beberapa perintah dan alat independen untuk melihat lebih banyak data berbasis mentah. Kami akan berbicara tentang beberapa alat yang dapat Anda jalankan dari host yang memiliki akses dan peran yang sesuai untuk memeriksa lingkungan Anda:

mongotop

Anda dapat memanfaatkan perintah ini untuk melacak jumlah waktu yang dihabiskan instans MongoDB untuk menulis dan membaca data per koleksi. Gunakan sintaks berikut:

 mongotop <options> <connection-string> <polling-interval in seconds>

rs.status()

Perintah ini mengembalikan status set replika. Itu dieksekusi dari sudut pandang anggota tempat metode dieksekusi.

mongostat

Anda dapat menggunakan perintah mongostat untuk mendapatkan gambaran umum singkat tentang status instans server MongoDB Anda. Untuk hasil yang optimal, Anda dapat menggunakannya untuk menonton satu kejadian untuk peristiwa tertentu karena menawarkan tampilan waktu nyata.

Manfaatkan perintah ini untuk memantau statistik server dasar seperti antrian kunci, kerusakan operasi, statistik memori MongoDB, dan koneksi/jaringan:

 mongostat <options> <connection-string> <polling interval in seconds>

dbStats

Perintah ini mengembalikan statistik penyimpanan untuk database tertentu, seperti jumlah indeks dan ukurannya, total koleksi data versus ukuran penyimpanan, dan statistik terkait koleksi (jumlah koleksi dan dokumen).

db.serverStatus()

Anda dapat memanfaatkan perintah db.serverStatus() untuk mendapatkan gambaran umum tentang status database. Ini memberi Anda dokumen yang mewakili penghitung metrik instans saat ini. Jalankan perintah ini secara berkala untuk menyusun statistik tentang instance.

colStats

Perintah collStats mengumpulkan statistik yang serupa dengan yang ditawarkan oleh dbStats di tingkat pengumpulan. Outputnya terdiri dari jumlah objek dalam koleksi, jumlah ruang disk yang dikonsumsi oleh koleksi, ukuran koleksi, dan informasi mengenai indeksnya untuk koleksi tertentu.

Anda dapat menggunakan semua perintah ini untuk menawarkan pelaporan dan pemantauan real-time dari server database yang memungkinkan Anda memantau kinerja dan kesalahan database dan membantu dalam pengambilan keputusan yang tepat untuk memperbaiki database.

Cara Menghapus Basis Data MongoDB

Untuk menjatuhkan database yang Anda buat di MongoDB, Anda harus menghubungkannya melalui kata kunci use.

Katakanlah Anda membuat database bernama "Insinyur". Untuk terhubung ke database, Anda akan menggunakan perintah berikut:

 use Engineers

Selanjutnya, ketik db.dropDatabase() untuk menyingkirkan database ini. Setelah eksekusi, inilah hasil yang dapat Anda harapkan:

 { "dropped" : "Engineers", "ok" : 1 }

Anda dapat menjalankan perintah showdbs untuk memverifikasi apakah database masih ada.

Ringkasan

Untuk memeras setiap tetes nilai terakhir dari MongoDB, Anda harus memiliki pemahaman yang kuat tentang dasar-dasarnya. Oleh karena itu, sangat penting untuk mengetahui database MongoDB seperti punggung tangan Anda. Ini membutuhkan membiasakan diri Anda dengan metode untuk membuat database terlebih dahulu.
Mencari database yang memberikan fleksibilitas dan skalabilitas tinggi? MongoDB bisa menjadi jawabannya... Klik untuk Tweet
Dalam artikel ini, kami menjelaskan berbagai metode yang dapat Anda gunakan untuk membuat database di MongoDB, diikuti dengan penjelasan rinci tentang beberapa perintah MongoDB yang bagus untuk membuat Anda tetap berada di atas database Anda. Terakhir, kami mengakhiri diskusi dengan membahas bagaimana Anda dapat memanfaatkan dokumen yang disematkan dan alat pemantauan kinerja di MongoDB untuk memastikan alur kerja Anda berfungsi pada efisiensi puncak.

Apa pendapat Anda tentang perintah MongoDB ini? Apakah kami melewatkan aspek atau metode yang ingin Anda lihat di sini? Beri tahu kami di komentar!