Cum să creezi o bază de date MongoDB: 6 aspecte critice de știut

Pe baza cerințelor dvs. pentru software-ul dvs., puteți acorda prioritate flexibilității, scalabilității, performanței sau vitezei. Prin urmare, dezvoltatorii și companiile sunt adesea confuze atunci când aleg o bază de date pentru nevoile lor. Dacă aveți nevoie de o bază de date care să ofere flexibilitate și scalabilitate ridicate și agregare de date pentru analiza clienților, MongoDB poate fi potrivit pentru dvs.!
Aflați mai multe despre structura bazei de date MongoDB și despre cum să vă creați, să monitorizați și să vă gestionați baza de date în acest ghid util Faceți clic pentru a Tweet
În acest articol, vom discuta despre structura bazei de date MongoDB și despre cum să creați, să monitorizați și să vă gestionați baza de date! Să începem.

Cum este structurată o bază de date MongoDB?

MongoDB este o bază de date NoSQL fără schemă. Aceasta înseamnă că nu specificați o structură pentru tabele/bazele de date așa cum o faceți pentru bazele de date SQL.

Știați că bazele de date NoSQL sunt de fapt mai rapide decât bazele de date relaționale? Acest lucru se datorează unor caracteristici precum indexarea, fragmentarea și conductele de agregare. MongoDB este, de asemenea, cunoscut pentru execuția sa rapidă a interogărilor. Acesta este motivul pentru care este preferat de companii precum Google, Toyota și Forbes.

Mai jos, vom explora câteva caracteristici cheie ale MongoDB.

Documente

MongoDB are un model de date de document care stochează datele ca documente JSON. Documentele se mapează în mod natural la obiectele din codul aplicației, făcându-l mai simplu de utilizat pentru dezvoltatori.

Într-un tabel de bază de date relațională, trebuie să adăugați o coloană pentru a adăuga un câmp nou. Nu este cazul câmpurilor dintr-un document JSON. Câmpurile dintr-un document JSON pot diferi de la document la document, așa că nu vor fi adăugate la fiecare înregistrare din baza de date.

Documentele pot stoca structuri precum matrice care pot fi imbricate pentru a exprima relații ierarhice. În plus, MongoDB convertește documentele într-un tip binar JSON (BSON). Acest lucru asigură acces mai rapid și suport sporit pentru diferite tipuri de date, cum ar fi șir, întreg, număr boolean și multe altele!

Seturi de replici

Când creați o nouă bază de date în MongoDB, sistemul creează automat cel puțin încă 2 copii ale datelor dvs. Aceste copii sunt cunoscute sub denumirea de „seturi de replici” și reproduc continuu datele între ele, asigurând o disponibilitate îmbunătățită a datelor dvs. Ele oferă, de asemenea, protecție împotriva perioadelor de nefuncționare în timpul unei defecțiuni a sistemului sau întreținere planificată.

Colecții

O colecție este un grup de documente asociat cu o bază de date. Sunt similare cu tabelele din bazele de date relaționale.

Colecțiile, însă, sunt mult mai flexibile. În primul rând, ei nu se bazează pe o schemă. În al doilea rând, documentele nu trebuie să fie de același tip de date!

Pentru a vizualiza o listă a colecțiilor care aparțin unei baze de date, utilizați comanda listCollections .

Conducte de agregare

Puteți folosi acest cadru pentru a cluba mai mulți operatori și expresii. Este flexibil, deoarece vă permite să procesați, să transformați și să analizați datele oricărei structuri.

Din acest motiv, MongoDB permite fluxuri rapide de date și caracteristici peste 150 de operatori și expresii. Are, de asemenea, mai multe etape, cum ar fi etapa Unirii, care reunește în mod flexibil rezultatele din mai multe colecții.

Indici

Puteți indexa orice câmp dintr-un document MongoDB pentru a crește eficiența acestuia și a îmbunătăți viteza de interogare. Indexarea economisește timp prin scanarea indexului pentru a limita documentele inspectate. Nu este asta mult mai bine decât să citești fiecare document din colecție?

Puteți utiliza diverse strategii de indexare, inclusiv indecși compuși pe mai multe câmpuri. De exemplu, să presupunem că aveți mai multe documente care conțin numele și prenumele angajatului în câmpuri separate. Dacă doriți ca numele și prenumele să fie returnate, puteți crea un index care să includă atât „Numele” cât și „Prenumele”. Acest lucru ar fi mult mai bine decât să ai un index pe „Nume” și altul pe „Prenumele”.

Puteți utiliza instrumente precum Performance Advisor pentru a înțelege în continuare ce interogare ar putea beneficia de pe urma indicilor.

Sharding

Sharding distribuie un singur set de date în mai multe baze de date. Acest set de date poate fi apoi stocat pe mai multe mașini pentru a crește capacitatea totală de stocare a unui sistem. Acest lucru se datorează faptului că împarte seturi de date mai mari în bucăți mai mici și le stochează în diferite noduri de date.

MongoDB fragmentează datele la nivel de colecție, distribuind documentele dintr-o colecție peste fragmentele dintr-un cluster. Acest lucru asigură scalabilitate, permițând arhitecturii să gestioneze cele mai mari aplicații.

Cum se creează o bază de date MongoDB

Mai întâi va trebui să instalați pachetul MongoDB potrivit pentru sistemul de operare. Accesați pagina „Descărcați serverul comunitar MongoDB”. Din opțiunile disponibile, selectați cea mai recentă „versiune”, formatul „pachet” ca fișier zip și „platformă” ca sistem de operare și faceți clic pe „Descărcați”, așa cum este prezentat mai jos:

Procesul este destul de simplu, așa că veți avea MongoDB instalat în sistemul dvs. în cel mai scurt timp!

După ce ați terminat instalarea, deschideți promptul de comandă și tastați mongod -version pentru ao verifica. Dacă nu obțineți următoarea ieșire și vedeți în schimb un șir de erori, poate fi necesar să-l reinstalați:

Folosind MongoDB Shell

Înainte de a începe, asigurați-vă că:

• Clientul dvs. are Transport Layer Security și se află pe lista dvs. de IP permise.
• Aveți un cont de utilizator și o parolă pentru clusterul MongoDB dorit.
• Ați instalat MongoDB pe dispozitivul dvs.

Pasul 1: Accesați Shell MongoDB

Pentru a obține acces la shell-ul MongoDB, tastați următoarea comandă:

 net start MongoDB

Aceasta ar trebui să dea următoarea ieșire:

Comanda anterioară a inițializat serverul MongoDB. Pentru a-l rula, ar trebui să introducem mongo în promptul de comandă.

Aici, în shell-ul MongoDB, putem executa comenzi pentru a crea baze de date, a insera date, a edita date, a emite comenzi administrative și a șterge date.

Pasul 2: Creați-vă baza de date

Spre deosebire de SQL, MongoDB nu are o comandă de creare a bazei de date. În schimb, există un cuvânt cheie numit use care comută la o bază de date specificată. Dacă baza de date nu există, va crea o nouă bază de date, altfel se va conecta la baza de date existentă.

De exemplu, pentru a iniția o bază de date numită „companie”, tastați:

 use Company

Puteți introduce db pentru a confirma baza de date pe care tocmai ați creat-o în sistemul dvs. Dacă apare noua bază de date pe care ați creat-o, v-ați conectat cu succes la ea.

Dacă doriți să verificați bazele de date existente, tastați show dbs și va returna toate bazele de date din sistemul dvs.:

În mod implicit, instalarea MongoDB creează bazele de date de administrare, de configurare și locale.

Ați observat că baza de date creată de noi nu este afișată? Acest lucru se datorează faptului că nu am salvat încă valori în baza de date! Vom discuta despre inserare în secțiunea de gestionare a bazei de date.

Folosind interfața de utilizare Atlas

De asemenea, puteți începe cu serviciul de baze de date MongoDB, Atlas. Deși poate fi necesar să plătiți pentru a accesa unele funcții ale Atlas, majoritatea funcționalităților bazei de date sunt disponibile cu nivelul gratuit. Caracteristicile nivelului gratuit sunt mai mult decât suficiente pentru a crea o bază de date MongoDB.

Înainte de a începe, asigurați-vă că:

1. IP-ul dvs. este pe lista permisă.
2. Aveți un cont de utilizator și o parolă pentru clusterul MongoDB pe care doriți să îl utilizați.

Pentru a crea o bază de date MongoDB cu AtlasUI, deschideți o fereastră de browser și conectați-vă la https://cloud.mongodb.com. Din pagina cluster, faceți clic pe Răsfoiți colecții . Dacă nu există baze de date în cluster, vă puteți crea baza de date făcând clic pe butonul Adăugați propriile date .

Solicitarea vă va cere să furnizați o bază de date și un nume de colecție. După ce le-ați numit, faceți clic pe Creare și ați terminat! Acum puteți introduce documente noi sau vă puteți conecta la baza de date folosind drivere.

Gestionarea bazei de date MongoDB

În această secțiune, vom trece peste câteva moduri ingenioase de a vă gestiona în mod eficient baza de date MongoDB. Puteți face acest lucru fie folosind busola MongoDB, fie prin colecții.

Utilizarea colecțiilor

În timp ce bazele de date relaționale posedă tabele bine definite cu tipuri și coloane de date specificate, NoSQL are colecții în loc de tabele. Aceste colecții nu au nicio structură, iar documentele pot varia - puteți avea diferite tipuri de date și câmpuri fără a fi necesar să se potrivească cu formatul altui document din aceeași colecție.

Pentru a demonstra, să creăm o colecție numită „Angajat” și să adăugăm un document la ea:

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

Dacă inserarea are succes, va returna WriteResult({ "nInserted" : 1 }) :

Aici, „db” se referă la baza de date conectată în prezent. „Angajat” este colecția nou creată în baza de date a companiei.

Nu am setat o cheie primară aici, deoarece MongoDB creează automat un câmp de cheie primară numit „_id” și îi setează o valoare implicită.

Rulați comanda de mai jos pentru a verifica colecția în format JSON:

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

Ieșire:

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

În timp ce valoarea „_id” este atribuită automat, puteți modifica valoarea cheii primare implicite. De data aceasta, vom introduce un alt document în baza de date „Angajat”, cu valoarea „_id” ca „1”:

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

La rularea comenzii db.Employee.find().forEach(printjson) obținem următoarea ieșire:

În rezultatul de mai sus, valoarea „_id” pentru „Ava” este setată la „1” în loc să i se atribuie o valoare automat.

Acum că am adăugat cu succes valori în baza de date, putem verifica dacă apare în bazele de date existente în sistemul nostru utilizând următoarea comandă:

 show dbs

Și voila! Ați creat cu succes o bază de date în sistemul dvs.!

Folosind busola MongoDB

Deși putem lucra cu serverele MongoDB din shell-ul Mongo, uneori poate fi plictisitor. Este posibil să experimentați acest lucru într-un mediu de producție.

Cu toate acestea, există un instrument de busolă (numit în mod corespunzător Compass) creat de MongoDB care poate face acest lucru mai ușor. Are o interfață grafică mai bună și funcționalități adăugate precum vizualizarea datelor, profilarea performanței și accesul CRUD (creare, citire, actualizare, ștergere) la date, baze de date și colecții.

Puteți descărca IDE-ul Compass pentru sistemul de operare și îl puteți instala cu procesul său simplu.

Apoi, deschideți aplicația și creați o conexiune cu serverul prin lipirea șirului de conexiune. Dacă nu îl găsiți, puteți da clic pe Completați câmpurile de conexiune individual . Dacă nu ați schimbat numărul portului în timpul instalării MongoDB, faceți clic pe butonul de conectare și sunteți în joc! În caz contrar, trebuie doar să introduceți valorile pe care le-ați setat și să faceți clic pe Conectare .

Apoi, furnizați numele de gazdă, portul și autentificarea în fereastra Conexiune nouă.

În MongoDB Compass, puteți crea o bază de date și puteți adăuga prima sa colecție simultan. Iată cum o faci:

1. Faceți clic pe Creare bază de date pentru a deschide solicitarea.
2. Introduceți numele bazei de date și prima ei colecție.
3. Faceți clic pe Creare bază de date .

Puteți introduce mai multe documente în baza de date făcând clic pe numele bazei de date, apoi făcând clic pe numele colecției pentru a vedea fila Documente . Puteți apoi să faceți clic pe butonul Adăugați date pentru a insera unul sau mai multe documente în colecția dvs.

În timp ce adăugați documentele, le puteți introduce pe rând sau ca mai multe documente într-o matrice. Dacă adăugați mai multe documente, asigurați-vă că aceste documente separate prin virgulă sunt incluse între paranteze drepte. De exemplu:

 { _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" ] }

În cele din urmă, faceți clic pe Inserare pentru a adăuga documentele la colecția dvs. Iată cum ar arăta corpul unui document:

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

Aici, numele câmpurilor sunt „StudentID” și „StudentName”. Valorile câmpului sunt „1” și, respectiv, „JohnDoe”.

Comenzi utile

Puteți gestiona aceste colecții prin comenzile de gestionare a rolurilor și de gestionare a utilizatorilor.

Comenzi de gestionare a utilizatorilor

Comenzile de gestionare a utilizatorilor MongoDB conțin comenzi care aparțin utilizatorului. Putem crea, actualiza și șterge utilizatorii folosind aceste comenzi.

dropUser

Această comandă elimină un singur utilizator din baza de date specificată. Mai jos este sintaxa:

 db.dropUser(username, writeConcern)

Aici, numele de username este un câmp obligatoriu care conține documentul cu informații de autentificare și acces despre utilizator. Câmpul opțional writeConcern conține nivelul de preocupare de scriere pentru operația de creare. Nivelul de preocupare privind scrierea poate fi determinat de câmpul opțional writeConcern .

Înainte de a elimina un utilizator care are rolul userAdminAnyDatabase , asigurați-vă că există cel puțin un alt utilizator cu privilegii de administrare a utilizatorilor.

În acest exemplu, vom arunca utilizatorul „user26” în baza de date de testare:

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

Ieșire:

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

creaza utilizator

Această comandă creează un utilizator nou pentru baza de date specificată, după cum urmează:

 db.createUser(user, writeConcern)

Aici, user este un câmp obligatoriu care conține documentul cu informații de autentificare și acces despre utilizator de creat. Câmpul opțional writeConcern conține nivelul de preocupare de scriere pentru operația de creare. Nivelul de preocupare privind scrierea poate fi determinat de câmpul opțional, writeConcern .

createUser va returna o eroare de utilizator duplicat dacă utilizatorul există deja în baza de date.

Puteți crea un utilizator nou în baza de date de testare după cum urmează:

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

Ieșirea este după cum urmează:

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

grantRolesToUser

Puteți folosi această comandă pentru a acorda roluri suplimentare unui utilizator. Pentru a-l folosi, trebuie să țineți cont de următoarea sintaxă:

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

Puteți specifica atât roluri definite de utilizator, cât și roluri încorporate în rolurile menționate mai sus. Dacă doriți să specificați un rol care există în aceeași bază de date în care rulează grantRolesToUser , puteți fie să specificați rolul cu un document, așa cum este menționat mai jos:

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

Sau puteți specifica pur și simplu rolul cu numele rolului. De exemplu:

 "readWrite"

Dacă doriți să specificați rolul care este prezent într-o altă bază de date, va trebui să specificați rolul cu un alt document.

Pentru a acorda un rol într-o bază de date, aveți nevoie de acțiunea grantRole în baza de date specificată.

Iată un exemplu pentru a vă oferi o imagine clară. Luați, de exemplu, un utilizator productUser00 din baza de date de produse cu următoarele roluri:

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

Operația grantRolesToUser oferă „productUser00” rolul readWrite în baza de date stoc și rolul citire în baza de date de produse:

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

Utilizatorul productUser00 din baza de date de produse are acum următoarele roluri:

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

Informații utilizatori

Puteți utiliza comanda usersInfo pentru a returna informații despre unul sau mai mulți utilizatori. Iată sintaxa:

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

În ceea ce privește accesul, utilizatorii pot întotdeauna să se uite la propriile informații. Pentru a vedea informațiile altui utilizator, utilizatorul care execută comanda trebuie să aibă privilegii care includ acțiunea viewUser în baza de date a celuilalt utilizator.

La rularea comenzii userInfo , puteți obține următoarele informații în funcție de opțiunile specificate:

 { "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 }

Acum că aveți o idee generală despre ceea ce puteți realiza cu comanda usersInfo , următoarea întrebare evidentă care ar putea apărea este, ce comenzi ar fi utile pentru a analiza anumiți utilizatori și mai mulți utilizatori?

Iată două exemple utile pentru a ilustra același lucru:
Pentru a analiza privilegiile și informațiile specifice pentru anumiți utilizatori, dar nu și acreditările, pentru un utilizator „Anthony” definit în baza de date „oficiu”, executați următoarea comandă:

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

Dacă doriți să vă uitați la un utilizator în baza de date curentă, îl puteți menționa numai după nume. De exemplu, dacă vă aflați în baza de date de acasă și un utilizator numit „Timothy” există în baza de date de acasă, puteți rula următoarea comandă:

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

Apoi, puteți utiliza o matrice dacă doriți să vă uitați la informațiile pentru diverși utilizatori. Puteți include fie câmpurile opționale showCredentials și showPrivileges , fie puteți alege să le excludeți. Iată cum ar arăta comanda:

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

revokeRolesFromUser

Puteți folosi comanda revokeRolesFromUser pentru a elimina unul sau mai multe roluri de la un utilizator din baza de date în care sunt prezente rolurile. Comanda revokeRolesFromUser are următoarea sintaxă:

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

În sintaxa menționată mai sus, puteți specifica atât roluri definite de utilizator, cât și roluri încorporate în câmpul de roles . Similar cu comanda grantRolesToUser , puteți specifica rolul pe care doriți să îl revocați într-un document sau puteți utiliza numele acestuia.

Pentru a executa cu succes comanda revokeRolesFromUser , trebuie să aveți acțiunea revokeRole în baza de date specificată.

Iată un exemplu pentru a conduce punctul acasă. Entitatea productUser00 din baza de date de produse a avut următoarele roluri:

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

Următoarea comandă revokeRolesFromUser va elimina două dintre rolurile utilizatorului: rolul „citește” din products și rolul assetsWriter din baza de date „assets”:

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

Utilizatorul „productUser00” din baza de date de produse are acum un singur rol rămas:

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

Comenzi de management al rolurilor

Rolurile oferă utilizatorilor acces la resurse. Mai multe roluri încorporate pot fi utilizate de administratori pentru a controla accesul la un sistem MongoDB. Dacă rolurile nu acoperă privilegiile dorite, puteți chiar să mergeți mai departe pentru a crea roluri noi într-o anumită bază de date.

dropRole

Cu comanda dropRole , puteți șterge un rol definit de utilizator din baza de date pe care rulați comanda. Pentru a executa această comandă, utilizați următoarea sintaxă:

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

Pentru o execuție cu succes, trebuie să aveți acțiunea dropRole în baza de date specificată. Următoarele operațiuni ar elimina rolul writeTags din baza de date „produse”:

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

createRole

Puteți utiliza comanda createRole pentru a crea un rol și pentru a specifica privilegiile acestuia. Rolul se va aplica bazei de date pe care alegeți să rulați comanda. Comanda createRole va returna o eroare de rol duplicat dacă rolul există deja în baza de date.

Pentru a executa această comandă, urmați sintaxa dată:

 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> } )

Privilegiile unui rol s-ar aplica bazei de date în care a fost creat rolul. Rolul poate moșteni privilegii de la alte roluri din baza sa de date. De exemplu, un rol realizat în baza de date „admin” poate include privilegii care se aplică fie unui cluster, fie tuturor bazelor de date. De asemenea, poate moșteni privilegii de la roluri prezente în alte baze de date.

Pentru a crea un rol într-o bază de date, trebuie să aveți două lucruri:

1. Acțiunea grantRole din acea bază de date pentru a menționa privilegiile pentru noul rol, precum și pentru a menționa rolurile de care să moștenească.
2. Acțiunea createRole pe acea resursă a bazei de date.

Următoarea comandă createRole va crea un rol clusterAdmin în baza de date a utilizatorilor:

 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 } })

grantRolesToRole

Cu comanda grantRolesToRole , puteți acorda roluri unui rol definit de utilizator. Comanda grantRolesToRole ar afecta rolurile din baza de date în care este executată comanda.

Această comandă grantRolesToRole are următoarea sintaxă:

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

Privilegiile de acces sunt similare cu comanda grantRolesToUser — aveți nevoie de o acțiune grantRole pe o bază de date pentru executarea corectă a comenzii.

În exemplul următor, puteți utiliza comanda grantRolesToUser pentru a actualiza rolul productsReader din baza de date „produse” pentru a moșteni privilegiile rolului productsWriter :

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

revokePrivilegesFromRole

Puteți utiliza revokePrivilegesFromRole pentru a elimina privilegiile specificate din rolul definit de utilizator din baza de date în care este executată comanda. Pentru o execuție corectă, trebuie să aveți în vedere următoarea sintaxă:

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

Pentru a revoca un privilegiu, modelul „document de resurse” trebuie să se potrivească cu câmpul „resurse” al privilegiului respectiv. Câmpul „acțiuni” poate fi fie o potrivire exactă, fie un subset.

De exemplu, luați în considerare rolul manageRole din baza de date de produse cu următoarele privilegii care specifică baza de date „manageri” ca resursă:

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

Nu puteți revoca acțiunile de „inserare” sau „eliminare” dintr-o singură colecție din baza de date a managerilor. Următoarele operațiuni nu provoacă nicio modificare a rolului:

 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" ] } ] } )

Pentru a revoca acțiunile „inserare” și/sau „eliminare” din rolul manageRole , trebuie să potriviți exact documentul resursă. De exemplu, următoarea operație revocă doar acțiunea „eliminare” din privilegiul existent:

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

Următoarea operațiune va elimina mai multe privilegii din rolul „executiv” din baza de date a managerilor:

 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" } } )

Informații despre roluri

Comanda rolesInfo va returna informații despre privilegii și moștenire pentru roluri specificate, inclusiv atât rolurile încorporate, cât și cele definite de utilizator. De asemenea, puteți utiliza comanda rolesInfo pentru a prelua toate rolurile incluse într-o bază de date.

Pentru o execuție corectă, urmați această sintaxă:

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

Pentru a returna informații pentru un rol din baza de date curentă, puteți specifica numele acestuia după cum urmează:

 { rolesInfo: "<rolename>" }

Pentru a returna informații pentru un rol dintr-o altă bază de date, puteți menționa rolul cu un document care menționează rolul și baza de date:

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

De exemplu, următoarea comandă returnează informațiile despre moștenirea rolului pentru directorul de rol definit în baza de date a managerilor:

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

Această următoare comandă va returna informațiile despre moștenirea rolului: accountManager în baza de date pe care este executată comanda:

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

Următoarea comandă va returna atât privilegiile, cât și moștenirea rolului pentru rolul „executiv”, așa cum este definit în baza de date a managerilor:

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

Pentru a menționa mai multe roluri, puteți utiliza o matrice. De asemenea, puteți menționa fiecare rol din matrice ca șir sau document.

Ar trebui să utilizați un șir numai dacă rolul există în baza de date pe care este executată comanda:

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

De exemplu, următoarea comandă va returna informații pentru trei roluri din trei baze de date diferite:

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

Puteți obține atât privilegiile, cât și moștenirea rolului, după cum urmează:

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

Încorporarea documentelor MongoDB pentru o performanță mai bună

Bazele de date de documente precum MongoDB vă permit să vă definiți schema în funcție de nevoile dvs. Pentru a crea scheme optime în MongoDB, puteți imbrica documentele. Deci, în loc să potriviți aplicația dvs. cu un model de date, puteți construi un model de date care să se potrivească cu cazul dvs. de utilizare.

Documentele încorporate vă permit să stocați datele conexe pe care le accesați împreună. În timp ce proiectați scheme pentru MongoDB, este recomandat să încorporați documente în mod implicit. Folosiți conexiunile și referințele de la baza de date sau de la aplicație numai atunci când merită.

Asigurați-vă că volumul de lucru poate prelua un document ori de câte ori este necesar. În același timp, documentul ar trebui să aibă și toate datele de care are nevoie. Acest lucru este esențial pentru performanța excepțională a aplicației dvs.

Mai jos, veți găsi câteva modele diferite pentru a încorpora documente:

Model de document încorporat

Puteți folosi acest lucru pentru a încorpora chiar și substructuri complicate în documentele cu care sunt folosite. Încorporarea datelor conectate într-un singur document poate reduce numărul de operațiuni de citire necesare pentru a obține date. În general, ar trebui să vă structurați schema astfel încât aplicația dvs. să primească toate informațiile necesare într-o singură operație de citire. Prin urmare, regula de reținut aici este că ceea ce este folosit împreună ar trebui stocat împreună .

Model de subset încorporat

Modelul subsetului încorporat este un caz hibrid. L-ați folosi pentru o colecție separată de o listă lungă de articole conexe, unde puteți păstra unele dintre aceste articole la îndemână pentru afișare.

Iată un exemplu care listează recenzii de filme:

 > 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" }

Acum, imaginează-ți o mie de recenzii similare, dar plănuiești să le afișezi doar pe cele mai recente două atunci când arăți un film. În acest scenariu, este logic să stocați acel subset ca o listă în documentul filmului:

 > 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

Mai simplu spus, dacă accesați în mod obișnuit un subset de articole conexe, asigurați-vă că îl încorporați.

Acces independent

Poate doriți să stocați subdocumente în colecția lor pentru a le separa de colecția părinte.

De exemplu, luați linia de produse a unei companii. Dacă compania vinde un set mic de produse, poate doriți să le stocați în documentul companiei. Dar dacă doriți să le reutilizați între companii sau să le accesați direct prin unitatea lor de stocare (SKU), ați dori, de asemenea, să le stocați în colecția lor.

Dacă manipulați sau accesați o entitate independent, creați o colecție pentru a o stoca separat pentru cele mai bune practici.

Liste nelimitate

Stocarea listelor scurte de informații conexe în documentul lor are un dezavantaj. Dacă lista dvs. continuă să crească nebifată, nu ar trebui să o puneți într-un singur document. Acest lucru se datorează faptului că nu ați putea să-l susțineți pentru foarte mult timp.

Există două motive pentru aceasta. În primul rând, MongoDB are o limită pentru dimensiunea unui singur document. În al doilea rând, dacă accesați documentul la prea multe frecvențe, veți vedea rezultate negative de la utilizarea necontrolată a memoriei.

To put it simply, if a list starts growing unboundedly, make a collection to store it separately.

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.

For instance:

 > 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.

Connections

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.

Un raport de număr mare indică operațiuni suboptime. Aceste operațiuni scanează o mulțime de documente pentru a returna o parte mai mică.

Scanează și comandă

Acesta descrie rata medie pe secundă în perioada de eșantion aleasă de interogări. Returnează rezultate sortate care nu pot executa operația de sortare folosind un index.

Cozile

Cozile pot descrie numărul de operațiuni care așteaptă o blocare, fie de scriere, fie de citit. Cozile mari ar putea descrie existența unui design mai puțin decât optim al schemei. De asemenea, ar putea indica căi de scriere conflictuale, împingând o concurență ridicată asupra resurselor bazei de date.

Metrici de replicare MongoDB

Iată valorile principale pentru monitorizarea replicării:

Fereastra Oplog de replicare

Această valoare listează numărul aproximativ de ore disponibile în oplogul de replicare al principalului. Dacă un secundar este mai întârziat decât această sumă, nu poate ține pasul și va avea nevoie de o resincronizare completă.

Întârziere de replicare

Decalajul de replicare este definit ca numărul aproximativ de secunde în care un nod secundar se află în spatele operațiunilor de scriere primar. Decalajul mare de replicare ar indica un secundar care se confruntă cu dificultăți în replicare. Ar putea afecta latența operațiunii dvs., având în vedere preocuparea de citire/scriere a conexiunilor.

Spațiu pentru replicare

Această valoare se referă la diferența dintre fereastra oplog a replicării primare și decalajul de replicare a secundarului. Dacă această valoare ajunge la zero, ar putea duce un secundar să intre în modul RECOVERING.

Opcounters -repl

Opcounters -repl este definită ca rata medie a operațiunilor de replicare executate pe secundă pentru perioada de eșantion aleasă. Cu opcounters -graph/metric, puteți arunca o privire asupra vitezei operațiilor și a defalcării tipurilor de operații pentru instanța specificată.

Oplog GB/oră

Aceasta este definită ca rata medie de gigaocteți de oplog pe care primarul o generează pe oră. Volumele mari neașteptate de oplog ar putea indica o sarcină de lucru de scriere extrem de insuficientă sau o problemă de proiectare a schemei.

Instrumente de monitorizare a performanței MongoDB

MongoDB are instrumente de interfață cu utilizatorul încorporate în Cloud Manager, Atlas și Ops Manager pentru urmărirea performanței. De asemenea, oferă câteva comenzi și instrumente independente pentru a analiza mai multe date brute. Vom vorbi despre câteva instrumente pe care le puteți rula de la o gazdă care are acces și roluri adecvate pentru a vă verifica mediul:

mongotop

Puteți utiliza această comandă pentru a urmări timpul petrecut de o instanță MongoDB scriind și citind date per colecție. Utilizați următoarea sintaxă:

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

rs.status()

Această comandă returnează starea setului de replici. Se execută din punctul de vedere al membrului în care este executată metoda.

mongostat

Puteți folosi comanda mongostat pentru a obține o imagine de ansamblu rapidă a stării instanței dvs. de server MongoDB. Pentru rezultate optime, îl puteți folosi pentru a urmări o singură instanță pentru un anumit eveniment, deoarece oferă o vizualizare în timp real.

Utilizați această comandă pentru a monitoriza statisticile de bază ale serverului, cum ar fi cozile de blocare, defalcarea operațiunilor, statisticile de memorie MongoDB și conexiunile/rețea:

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

dbStats

Această comandă returnează statistici de stocare pentru o anumită bază de date, cum ar fi numărul de indici și dimensiunea acestora, datele totale de colectare față de dimensiunea stocării și statistici legate de colecții (numărul de colecții și documente).

db.serverStatus()

Puteți folosi comanda db.serverStatus() pentru a avea o privire de ansamblu asupra stării bazei de date. Vă oferă un document reprezentând contoarele de valori ale instanțelor curente. Executați această comandă la intervale regulate pentru a aduna statistici despre instanță.

collStats

Comanda collStats colectează statistici similare cu cele oferite de dbStats la nivel de colecție. Ieșirea sa constă dintr-un număr de obiecte din colecție, cantitatea de spațiu pe disc consumată de colecție, dimensiunea colecției și informații referitoare la indecșii acesteia pentru o anumită colecție.

Puteți utiliza toate aceste comenzi pentru a oferi raportare și monitorizare în timp real a serverului de baze de date, ceea ce vă permite să monitorizați performanța și erorile bazei de date și să asiste la luarea deciziilor în cunoștință de cauză pentru a perfecționa o bază de date.

Cum să ștergeți o bază de date MongoDB

Pentru a elimina o bază de date creată în MongoDB, trebuie să vă conectați la ea prin cuvântul cheie use.

Să presupunem că ați creat o bază de date numită „Ingineri”. Pentru a vă conecta la baza de date, veți folosi următoarea comandă:

 use Engineers

Apoi, tastați db.dropDatabase() pentru a scăpa de această bază de date. După execuție, acesta este rezultatul la care vă puteți aștepta:

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

Puteți rula comanda showdbs pentru a verifica dacă baza de date mai există.

rezumat

Pentru a stoarce până la ultima picătură de valoare din MongoDB, trebuie să aveți o înțelegere puternică a elementelor fundamentale. Prin urmare, este esențial să cunoașteți bazele de date MongoDB ca pe dosul mâinii. Acest lucru necesită familiarizarea mai întâi cu metodele de creare a unei baze de date.
Căutați o bază de date care să ofere flexibilitate și scalabilitate ridicate? MongoDB ar putea fi răspunsul... Faceți clic pentru a Tweet
În acest articol, aruncăm lumină asupra diferitelor metode pe care le puteți utiliza pentru a crea o bază de date în MongoDB, urmată de o descriere detaliată a unor comenzi MongoDB interesante pentru a vă menține în fruntea bazelor de date. În cele din urmă, am încheiat discuția discutând despre cum puteți utiliza documentele încorporate și instrumentele de monitorizare a performanței în MongoDB pentru a vă asigura că fluxul de lucru funcționează la eficiență maximă.

Ce părere aveți despre aceste comenzi MongoDB? Am ratat un aspect sau o metodă pe care ți-ar fi plăcut să vezi aici? Spune-ne în comentarii!