Jak stworzyć bazę danych MongoDB: 6 kluczowych aspektów, które należy znać

W zależności od wymagań dotyczących oprogramowania możesz nadać priorytet elastyczności, skalowalności, wydajności lub szybkości. Dlatego programiści i firmy często są zdezorientowani przy wyborze bazy danych dla swoich potrzeb. Jeśli potrzebujesz bazy danych zapewniającej wysoką elastyczność i skalowalność oraz agregacji danych do analizy klientów, MongoDB może być dla Ciebie odpowiednim rozwiązaniem!
Dowiedz się więcej o strukturze bazy danych MongoDB oraz o tym, jak tworzyć, monitorować i zarządzać bazą danych z tego przydatnego przewodnika Kliknij, aby tweetować
W tym artykule omówimy strukturę bazy danych MongoDB oraz sposób tworzenia, monitorowania i zarządzania bazą danych! Zacznijmy.

Jaka jest struktura bazy danych MongoDB?

MongoDB to pozbawiona schematów baza danych NoSQL. Oznacza to, że nie określasz struktury tabel/baz danych, tak jak to robisz dla baz danych SQL.

Czy wiesz, że bazy danych NoSQL są w rzeczywistości szybsze niż relacyjne bazy danych? Wynika to z cech, takich jak potoki indeksowania, fragmentowania i agregacji. MongoDB jest również znany z szybkiego wykonywania zapytań. Dlatego jest preferowany przez firmy takie jak Google, Toyota i Forbes.

Poniżej omówimy kilka kluczowych cech MongoDB.

Dokumenty

MongoDB ma model danych dokumentu, który przechowuje dane jako dokumenty JSON. Dokumenty są w naturalny sposób mapowane na obiekty w kodzie aplikacji, co ułatwia programistom korzystanie z nich.

W tabeli relacyjnej bazy danych musisz dodać kolumnę, aby dodać nowe pole. Nie dotyczy to pól w dokumencie JSON. Pola w dokumencie JSON mogą się różnić w zależności od dokumentu, więc nie zostaną dodane do każdego rekordu w bazie danych.

Dokumenty mogą przechowywać struktury, takie jak tablice, które można zagnieżdżać w celu wyrażenia relacji hierarchicznych. Dodatkowo MongoDB konwertuje dokumenty do binarnego typu JSON (BSON). Zapewnia to szybszy dostęp i zwiększoną obsługę różnych typów danych, takich jak ciąg, liczba całkowita, liczba logiczna i wiele więcej!

Zestawy replik

Kiedy tworzysz nową bazę danych w MongoDB, system automatycznie tworzy co najmniej 2 dodatkowe kopie Twoich danych. Kopie te są znane jako „zestawy replik” i stale replikują dane między sobą, zapewniając lepszą dostępność danych. Zapewniają również ochronę przed przestojami podczas awarii systemu lub planowanej konserwacji.

Kolekcje

Kolekcja to grupa dokumentów powiązanych z jedną bazą danych. Są podobne do tabel w relacyjnych bazach danych.

Kolekcje są jednak znacznie bardziej elastyczne. Po pierwsze, nie polegają na schemacie. Po drugie, dokumenty nie muszą mieć tego samego typu danych!

Aby wyświetlić listę kolekcji należących do bazy danych, użyj polecenia listCollections .

Rurociągi agregacji

Możesz użyć tego frameworka do klubowania kilku operatorów i wyrażeń. Jest elastyczny, ponieważ pozwala przetwarzać, przekształcać i analizować dane dowolnej struktury.

Z tego powodu MongoDB umożliwia szybki przepływ danych i funkcje dla 150 operatorów i wyrażeń. Ma też kilka etapów, jak etap Unii, który elastycznie łączy wyniki z wielu kolekcji.

Indeksy

Możesz zindeksować dowolne pole w dokumencie MongoDB, aby zwiększyć jego wydajność i przyspieszyć działanie zapytań. Indeksowanie oszczędza czas dzięki skanowaniu indeksu w celu ograniczenia liczby kontrolowanych dokumentów. Czy nie jest to o wiele lepsze niż czytanie każdego dokumentu w kolekcji?

Możesz używać różnych strategii indeksowania, w tym indeksów złożonych na wielu polach. Załóżmy na przykład, że masz kilka dokumentów zawierających imię i nazwisko pracownika w oddzielnych polach. Jeśli chcesz, aby zwracane było imię i nazwisko, możesz utworzyć indeks zawierający zarówno „Nazwisko”, jak i „Imię”. Byłoby to znacznie lepsze niż posiadanie jednego indeksu „Nazwisko”, a drugiego „Imię”.

Możesz wykorzystać narzędzia, takie jak Performance Advisor, aby lepiej zrozumieć, które zapytanie może skorzystać z indeksów.

Fragmentacja

Sharding dystrybuuje pojedynczy zestaw danych w wielu bazach danych. Ten zestaw danych można następnie przechowywać na wielu komputerach, aby zwiększyć całkowitą pojemność pamięci systemu. Dzieje się tak, ponieważ dzieli większe zestawy danych na mniejsze porcje i przechowuje je w różnych węzłach danych.

MongoDB dzieli dane na poziomie kolekcji, dystrybuując dokumenty w kolekcji we fragmentach w klastrze. Zapewnia to skalowalność, umożliwiając architekturze obsługę największych aplikacji.

Jak utworzyć bazę danych MongoDB

Najpierw musisz zainstalować odpowiedni pakiet MongoDB odpowiedni dla Twojego systemu operacyjnego. Przejdź do strony „Pobierz serwer społeczności MongoDB”. Z dostępnych opcji wybierz najnowszą „wersję”, format „pakietu” jako plik zip i „platformę” jako system operacyjny i kliknij „Pobierz”, jak pokazano poniżej:

Proces jest dość prosty, więc MongoDB zostanie zainstalowany w swoim systemie w mgnieniu oka!

Po zakończeniu instalacji otwórz wiersz poleceń i wpisz mongod -version , aby to zweryfikować. Jeśli nie otrzymasz następujących danych wyjściowych, a zamiast tego zobaczysz ciąg błędów, może być konieczne ponowne zainstalowanie:

Korzystanie z powłoki MongoDB

Zanim zaczniemy, upewnij się, że:

• Twój klient ma usługę Transport Layer Security i znajduje się na Twojej liście dozwolonych adresów IP.
• Masz konto użytkownika i hasło w żądanym klastrze MongoDB.
• Zainstalowałeś MongoDB na swoim urządzeniu.

Krok 1: Uzyskaj dostęp do powłoki MongoDB

Aby uzyskać dostęp do powłoki MongoDB, wpisz następujące polecenie:

 net start MongoDB

Powinno to dać następujący wynik:

Poprzednie polecenie zainicjowało serwer MongoDB. Aby go uruchomić, musielibyśmy wpisać mongo w wierszu poleceń.

Tutaj, w powłoce MongoDB, możemy wykonywać polecenia tworzenia baz danych, wstawiać dane, edytować dane, wydawać polecenia administracyjne i usuwać dane.

Krok 2: Utwórz swoją bazę danych

W przeciwieństwie do SQL, MongoDB nie ma polecenia tworzenia bazy danych. Zamiast tego istnieje słowo kluczowe use , które przełącza do określonej bazy danych. Jeśli baza danych nie istnieje, utworzy nową bazę danych, w przeciwnym razie połączy się z istniejącą bazą danych.

Na przykład, aby zainicjować bazę danych o nazwie „firma”, wpisz:

 use Company

Możesz wpisać db , aby potwierdzić bazę danych, którą właśnie utworzyłeś w swoim systemie. Jeśli pojawi się nowa baza danych, którą utworzyłeś, to znaczy, że udało Ci się z nią połączyć.

Jeśli chcesz sprawdzić istniejące bazy danych, wpisz show dbs , a zwróci wszystkie bazy danych w twoim systemie:

Domyślnie instalacja MongoDB powoduje utworzenie bazy danych administratora, konfiguracji i lokalnych.

Czy zauważyłeś, że utworzona przez nas baza danych nie jest wyświetlana? Dzieje się tak, ponieważ nie zapisaliśmy jeszcze wartości w bazie danych! Będziemy omawiać wstawianie w sekcji zarządzania bazą danych.

Korzystanie z interfejsu użytkownika Atlasu

Możesz także rozpocząć korzystanie z usługi bazy danych MongoDB Atlas. Chociaż dostęp do niektórych funkcji Atlasu może być płatny, większość funkcji bazy danych jest dostępna w warstwie bezpłatnej. Funkcje warstwy bezpłatnej są więcej niż wystarczające do utworzenia bazy danych MongoDB.

Zanim zaczniemy, upewnij się, że:

1. Twój adres IP znajduje się na liście dozwolonych.
2. Masz konto użytkownika i hasło w klastrze MongoDB, którego chcesz użyć.

Aby utworzyć bazę danych MongoDB z AtlasUI, otwórz okno przeglądarki i zaloguj się na https://cloud.mongodb.com. Na stronie swojego klastra kliknij Przeglądaj kolekcje . Jeśli w klastrze nie ma żadnych baz danych, możesz utworzyć bazę danych, klikając przycisk Dodaj własne dane .

Monit poprosi o podanie bazy danych i nazwy kolekcji. Po ich nazwaniu kliknij Utwórz , i gotowe! Możesz teraz wprowadzać nowe dokumenty lub łączyć się z bazą danych za pomocą sterowników.

Zarządzanie bazą danych MongoDB

W tej sekcji omówimy kilka fajnych sposobów efektywnego zarządzania bazą danych MongoDB. Możesz to zrobić za pomocą kompasu MongoDB lub poprzez kolekcje.

Korzystanie z kolekcji

Podczas gdy relacyjne bazy danych posiadają dobrze zdefiniowane tabele z określonymi typami danych i kolumnami, NoSQL ma kolekcje zamiast tabel. Te kolekcje nie mają żadnej struktury, a dokumenty mogą się różnić — możesz mieć różne typy danych i pola bez konieczności dopasowywania formatu innego dokumentu w tej samej kolekcji.

Aby to zademonstrować, stwórzmy kolekcję o nazwie „Pracownik” i dodajmy do niej dokument:

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

Jeśli wstawienie się powiedzie, zwróci WriteResult({ "nInserted" : 1 }) :

Tutaj „db” odnosi się do aktualnie podłączonej bazy danych. „Pracownik” to nowo utworzony zbiór w bazie danych firmy.

Nie ustawiliśmy tutaj klucza podstawowego, ponieważ MongoDB automatycznie tworzy pole klucza podstawowego o nazwie „_id” i ustawia do niego wartość domyślną.

Uruchom poniższe polecenie, aby sprawdzić kolekcję w formacie JSON:

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

Wyjście:

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

Chociaż wartość „_id” jest przypisywana automatycznie, możesz zmienić wartość domyślnego klucza podstawowego. Tym razem wstawimy kolejny dokument do bazy danych „Pracownik”, z wartością „_id” jako „1”:

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

Po uruchomieniu polecenia db.Employee.find().forEach(printjson) otrzymujemy następujące dane wyjściowe:

W powyższym wyniku wartość „_id” dla „Ava” jest ustawiona na „1”, zamiast automatycznie przypisywać wartość.

Teraz, gdy pomyślnie dodaliśmy wartości do bazy danych, możemy sprawdzić, czy pojawia się ona pod istniejącymi bazami danych w naszym systemie za pomocą następującego polecenia:

 show dbs

I voila! Udało Ci się stworzyć bazę danych w swoim systemie!

Korzystanie z kompasu MongoDB

Chociaż możemy pracować z serwerami MongoDB z powłoki Mongo, czasami może to być nużące. Możesz tego doświadczyć w środowisku produkcyjnym.

Istnieje jednak narzędzie kompasu (odpowiednio nazwane Compass) stworzone przez MongoDB, które może to ułatwić. Ma lepszy graficzny interfejs użytkownika i dodatkowe funkcje, takie jak wizualizacja danych, profilowanie wydajności i dostęp CRUD (tworzenie, odczyt, aktualizacja, usuwanie) do danych, baz danych i kolekcji.

Możesz pobrać Compass IDE dla swojego systemu operacyjnego i zainstalować go za pomocą prostego procesu.

Następnie otwórz aplikację i utwórz połączenie z serwerem, wklejając parametry połączenia. Jeśli nie możesz go znaleźć, możesz kliknąć Wypełnij pola połączenia pojedynczo . Jeśli nie zmieniłeś numeru portu podczas instalacji MongoDB, po prostu kliknij przycisk połączenia i gotowe! W przeciwnym razie po prostu wprowadź ustawione wartości i kliknij Połącz .

Następnie podaj nazwę hosta, port i uwierzytelnianie w oknie Nowe połączenie.

W MongoDB Compass możesz utworzyć bazę danych i jednocześnie dodać jej pierwszą kolekcję. Oto jak to robisz:

1. Kliknij Utwórz bazę danych , aby otworzyć monit.
2. Wpisz nazwę bazy danych i jej pierwszą kolekcję.
3. Kliknij opcję Utwórz bazę danych .

Możesz wstawić więcej dokumentów do swojej bazy danych, klikając nazwę swojej bazy danych, a następnie klikając nazwę kolekcji, aby wyświetlić kartę Dokumenty . Następnie możesz kliknąć przycisk Dodaj dane , aby wstawić jeden lub więcej dokumentów do swojej kolekcji.

Podczas dodawania dokumentów możesz wprowadzać je pojedynczo lub jako wiele dokumentów w tablicy. Jeśli dodajesz wiele dokumentów, upewnij się, że te dokumenty oddzielone przecinkami są ujęte w nawiasy kwadratowe. Na przykład:

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

Na koniec kliknij Wstaw , aby dodać dokumenty do swojej kolekcji. Tak wyglądałaby treść dokumentu:

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

Tutaj nazwy pól to „StudentID” i „StudentName”. Wartości pól to odpowiednio „1” i „JohnDoe”.

Przydatne polecenia

Tymi kolekcjami można zarządzać za pomocą poleceń zarządzania rolami i zarządzania użytkownikami.

Polecenia zarządzania użytkownikami

Polecenia zarządzania użytkownikami MongoDB zawierają polecenia dotyczące użytkownika. Za pomocą tych poleceń możemy tworzyć, aktualizować i usuwać użytkowników.

dropUser

Ta komenda usuwa pojedynczego użytkownika z określonej bazy danych. Poniżej znajduje się składnia:

 db.dropUser(username, writeConcern)

Tutaj username jest wymaganym polem, które zawiera dokument z informacjami uwierzytelniającymi i dostępowymi o użytkowniku. Opcjonalne pole writeConcern zawiera poziom zainteresowania zapisem dla operacji tworzenia. Poziom zainteresowania zapisem można określić za pomocą opcjonalnego pola writeConcern .

Przed usunięciem użytkownika, który ma rolę userAdminAnyDatabase , upewnij się, że istnieje co najmniej jeden inny użytkownik z uprawnieniami administrowania użytkownikami.

W tym przykładzie usuniemy użytkownika „user26” w testowej bazie danych:

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

Wyjście:

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

Stwórz użytkownika

To polecenie tworzy nowego użytkownika dla określonej bazy danych w następujący sposób:

 db.createUser(user, writeConcern)

Tutaj user jest wymaganym polem, które zawiera dokument z informacjami uwierzytelniającymi i dostępowymi o użytkowniku do utworzenia. Opcjonalne pole writeConcern zawiera poziom zainteresowania zapisem dla operacji tworzenia. Poziom zainteresowania zapisem można określić za pomocą opcjonalnego pola writeConcern .

createUser zwróci błąd zduplikowanego użytkownika, jeśli użytkownik już istnieje w bazie danych.

Możesz utworzyć nowego użytkownika w testowej bazie danych w następujący sposób:

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

Dane wyjściowe są następujące:

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

grantRolesToUser

Możesz wykorzystać to polecenie, aby przypisać użytkownikowi dodatkowe role. Aby z niego skorzystać, musisz pamiętać o następującej składni:

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

W rolach wymienionych powyżej można określić role zdefiniowane przez użytkownika i wbudowane. Jeśli chcesz określić rolę, która istnieje w tej samej bazie danych, w której działa grantRolesToUser , możesz określić rolę w dokumencie, jak wspomniano poniżej:

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

Możesz też po prostu określić rolę za pomocą nazwy roli. Na przykład:

 "readWrite"

Jeśli chcesz określić rolę, która jest obecna w innej bazie danych, musisz określić rolę w innym dokumencie.

Aby nadać rolę w bazie danych, potrzebujesz akcji grantRole w określonej bazie danych.

Oto przykład, który da ci jasny obraz. Weźmy na przykład użytkownika productUser00 w bazie produktów z następującymi rolami:

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

Operacja grantRolesToUser zapewnia „productUser00” rolę readWrite w bazie danych giełdowych oraz rolę read w bazie danych produktów:

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

Użytkownik productUser00 w bazie produktów ma teraz następujące role:

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

informacje o użytkownikach

Możesz użyć komendy usersInfo , aby zwrócić informacje o jednym lub kilku użytkownikach. Oto składnia:

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

Jeśli chodzi o dostęp, użytkownicy zawsze mogą przeglądać własne informacje. Aby przeglądać informacje innego użytkownika, użytkownik uruchamiający komendę musi mieć uprawnienia obejmujące akcję viewUser w bazie danych innego użytkownika.

Po uruchomieniu komendy userInfo możesz uzyskać następujące informacje w zależności od określonych opcji:

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

Teraz, gdy masz już ogólne pojęcie o tym, co możesz osiągnąć za pomocą polecenia usersInfo , oczywiste następne pytanie, które może się pojawić, brzmi: jakie polecenia przydadzą się do przyjrzenia się określonym użytkownikom i wielu użytkownikom?

Oto dwa przydatne przykłady ilustrujące to samo:
Aby sprawdzić określone uprawnienia i informacje dla określonych użytkowników, ale nie poświadczenia użytkownika „Anthony” zdefiniowanego w bazie danych „biuro”, wykonaj następujące polecenie:

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

Jeśli chcesz spojrzeć na użytkownika w bieżącej bazie danych, możesz wymienić go tylko po imieniu. Na przykład, jeśli jesteś w domowej bazie danych, a użytkownik o nazwie „Timothy” istnieje w domowej bazie danych, możesz uruchomić następujące polecenie:

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

Następnie możesz użyć tablicy, jeśli chcesz przeglądać informacje dla różnych użytkowników. Możesz uwzględnić opcjonalne pola showCredentials i showPrivileges lub możesz je pominąć. Tak wyglądałoby polecenie:

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

cofnijRoleOdUżytkownika

Możesz użyć komendy revokeRolesFromUser , aby usunąć jedną lub więcej ról z użytkownika w bazie danych, w której te role są obecne. Komenda revokeRolesFromUser ma następującą składnię:

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

W powyższej składni możesz określić role zdefiniowane przez użytkownika i wbudowane w polu roles . Podobnie jak w przypadku polecenia grantRolesToUser , możesz określić rolę, którą chcesz odwołać w dokumencie lub użyć jej nazwy.

Aby pomyślnie wykonać komendę revokeRolesFromUser , musisz mieć akcję revokeRole na określonej bazie danych.

Oto przykład, jak doprowadzić punkt do domu. Jednostka productUser00 w bazie produktów miała następujące role:

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

Poniższa komenda revokeRolesFromUser usunie dwie role użytkownika: rolę „odczyt” z products oraz rolę assetsWriter z bazy danych „assets”:

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

Użytkownik „productUser00” w bazie danych produktów ma teraz tylko jedną rolę:

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

Polecenia zarządzania rolami

Role zapewniają użytkownikom dostęp do zasobów. Kilka wbudowanych ról może być używanych przez administratorów do kontrolowania dostępu do systemu MongoDB. Jeśli role nie obejmują żądanych uprawnień, możesz nawet przejść dalej, aby utworzyć nowe role w określonej bazie danych.

dropRole

Za pomocą polecenia dropRole możesz usunąć rolę zdefiniowaną przez użytkownika z bazy danych, w której uruchamiasz polecenie. Aby wykonać to polecenie, użyj następującej składni:

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

Aby pomyślnie wykonać, musisz mieć akcję dropRole w określonej bazie danych. Następujące operacje usunęłyby rolę writeTags z bazy danych „products”:

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

utwórz rolę

Możesz użyć polecenia createRole , aby utworzyć rolę i określić jej uprawnienia. Rola zostanie zastosowana do bazy danych, na której zdecydujesz się uruchomić polecenie. Komenda createRole zwróci błąd zduplikowanej roli, jeśli rola już istnieje w bazie danych.

Aby wykonać to polecenie, postępuj zgodnie z podaną składnią:

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

Uprawnienia roli będą miały zastosowanie do bazy danych, w której została utworzona rola. Rola może dziedziczyć uprawnienia z innych ról w swojej bazie danych. Na przykład rola nadana w bazie danych „admin” może obejmować uprawnienia dotyczące klastra lub wszystkich baz danych. Może również dziedziczyć uprawnienia z ról obecnych w innych bazach danych.

Aby utworzyć rolę w bazie danych, musisz mieć dwie rzeczy:

1. Akcja grantRole w tej bazie danych, aby wspomnieć o uprawnieniach dla nowej roli, a także o rolach, z których mają być dziedziczone.
2. Akcja createRole na tym zasobie bazy danych.

Następujące polecenie createRole utworzy rolę clusterAdmin w bazie danych użytkowników:

 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

Za pomocą komendy grantRolesToRole można przydzielić role do roli zdefiniowanej przez użytkownika. Komenda grantRolesToRole wpłynie na role w bazie danych, w której komenda jest wykonywana.

To polecenie grantRolesToRole ma następującą składnię:

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

Uprawnienia dostępu są podobne do polecenia grantRolesToUser — do poprawnego wykonania polecenia potrzebna jest akcja grantRole na bazie danych.

W poniższym przykładzie możesz użyć polecenia grantRolesToUser , aby zaktualizować rolę productsReader w bazie danych „products”, aby dziedziczyła uprawnienia roli productsWriter :

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

cofnij przywileje z roli

Za pomocą revokePrivilegesFromRole można usunąć określone uprawnienia ze zdefiniowanej przez użytkownika roli w bazie danych, w której wykonywane jest polecenie. Do prawidłowego wykonania należy pamiętać o następującej składni:

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

Aby odwołać uprawnienie, wzorzec „dokument zasobów” musi być zgodny z polem „zasób” tego uprawnienia. Pole „działania” może być dokładnym dopasowaniem lub podzbiorem.

Rozważmy na przykład rolę manageRole w bazie danych produktów z następującymi uprawnieniami, które określają bazę danych „menedżerów” jako zasób:

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

Nie można odwołać akcji „wstaw” lub „usuń” z tylko jednej kolekcji w bazie danych menedżerów. Następujące operacje nie powodują zmiany roli:

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

Aby odwołać akcje „wstaw” i/lub „usuń” z roli manageRole , musisz dokładnie dopasować dokument zasobu. Na przykład następująca operacja odwołuje tylko akcję „usuń” z istniejącego uprawnienia:

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

Następująca operacja usunie wiele uprawnień z roli „executive” w bazie danych menedżerów:

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

roleInformacje

Komenda rolesInfo zwróci informacje o uprawnieniach i dziedziczeniu dla określonych ról, w tym zarówno ról wbudowanych, jak i zdefiniowanych przez użytkownika. Możesz również użyć polecenia rolesInfo , aby pobrać wszystkie role objęte zakresem bazy danych.

Aby wykonać prawidłowe wykonanie, postępuj zgodnie z następującą składnią:

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

Aby zwrócić informacje o roli z bieżącej bazy danych, możesz określić jej nazwę w następujący sposób:

 { rolesInfo: "<rolename>" }

Aby zwrócić informacje o roli z innej bazy danych, możesz wspomnieć o roli w dokumencie, który wspomina o roli i bazie danych:

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

Na przykład poniższe polecenie zwraca informacje o dziedziczeniu ról dla osoby wykonawczej roli zdefiniowanej w bazie danych menedżerów:

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

Kolejna komenda zwróci informacje o dziedziczeniu roli: accountManager w bazie danych, na której komenda jest wykonywana:

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

Następujące polecenie zwróci zarówno uprawnienia, jak i dziedziczenie ról dla roli „executive” zdefiniowanej w bazie danych menedżerów:

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

Aby wymienić wiele ról, możesz użyć tablicy. Możesz również wymienić każdą rolę w tablicy jako ciąg znaków lub dokument.

Ciągu znaków należy używać tylko wtedy, gdy rola istnieje w bazie danych, na której wykonywane jest polecenie:

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

Na przykład następujące polecenie zwróci informacje o trzech rolach w trzech różnych bazach danych:

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

Zarówno uprawnienia, jak i dziedziczenie ról można uzyskać w następujący sposób:

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

Osadzanie dokumentów MongoDB dla lepszej wydajności

Bazy danych dokumentów, takie jak MongoDB, pozwalają zdefiniować schemat zgodnie z własnymi potrzebami. Aby stworzyć optymalne schematy w MongoDB, możesz zagnieździć dokumenty. Dlatego zamiast dopasowywać swoją aplikację do modelu danych, możesz zbudować model danych, który pasuje do Twojego przypadku użycia.

Osadzone dokumenty umożliwiają przechowywanie powiązanych danych, do których masz wspólny dostęp. Podczas projektowania schematów dla MongoDB zalecane jest domyślne osadzenie dokumentów. Używaj sprzężeń i odwołań po stronie bazy danych lub aplikacji tylko wtedy, gdy jest to warte zachodu.

Upewnij się, że obciążenie może pobierać dokument tak często, jak jest to wymagane. Jednocześnie dokument powinien również zawierać wszystkie potrzebne mu dane. Ma to kluczowe znaczenie dla wyjątkowej wydajności aplikacji.

Poniżej znajdziesz kilka różnych wzorów do osadzania dokumentów:

Wzorzec dokumentu osadzonego

Możesz użyć tego do osadzania nawet skomplikowanych podstruktur w dokumentach, z którymi są używane. Osadzanie połączonych danych w jednym dokumencie może zmniejszyć liczbę operacji odczytu potrzebnych do uzyskania danych. Ogólnie rzecz biorąc, należy uporządkować schemat tak, aby aplikacja otrzymywała wszystkie wymagane informacje w jednej operacji odczytu. Dlatego należy pamiętać, że to , co jest używane razem, powinno być przechowywane razem .

Osadzony wzór podzbioru

Wbudowany wzorzec podzbioru jest przypadkiem hybrydowym. Użyłbyś go do oddzielnej kolekcji długiej listy powiązanych elementów, gdzie możesz trzymać niektóre z tych elementów pod ręką do wyświetlenia.

Oto przykład z listą recenzji filmów:

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

Teraz wyobraź sobie tysiąc podobnych recenzji, ale podczas wyświetlania filmu planujesz wyświetlić tylko dwie najnowsze. W tym scenariuszu sensowne jest przechowywanie tego podzbioru jako listy w dokumencie filmu:

 > 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

Mówiąc najprościej, jeśli rutynowo uzyskujesz dostęp do podzbioru powiązanych elementów, upewnij się, że go osadziłeś.

Niezależny dostęp

Możesz chcieć przechowywać dokumenty podrzędne w swojej kolekcji, aby oddzielić je od kolekcji nadrzędnej.

Weźmy na przykład linię produktów firmy. Jeśli firma sprzedaje niewielki zestaw produktów, warto przechowywać je w dokumencie firmy. Ale jeśli chcesz ponownie wykorzystać je w różnych firmach lub uzyskać do nich bezpośredni dostęp przez ich jednostkę magazynową (SKU), warto również przechowywać je w ich kolekcji.

Jeśli manipulujesz lub uzyskujesz dostęp do encji niezależnie, utwórz kolekcję, aby przechowywać ją oddzielnie, aby uzyskać najlepsze praktyki.

Listy nieograniczone

Przechowywanie krótkich list powiązanych informacji w ich dokumencie ma wadę. Jeśli Twoja lista nadal rośnie bez kontroli, nie powinieneś umieszczać jej w jednym dokumencie. Dzieje się tak, ponieważ nie byłbyś w stanie długo go wspierać.

Są ku temu dwa powody. Po pierwsze, MongoDB ma limit rozmiaru pojedynczego dokumentu. Po drugie, jeśli uzyskasz dostęp do dokumentu zbyt często, zobaczysz negatywne wyniki niekontrolowanego użycia pamięci.

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.

Znajomości

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.

Wysoki stosunek liczby wskazuje na nieoptymalne operacje. Operacje te skanują wiele dokumentów, aby zwrócić mniejszą część.

Skanuj i zamawiaj

Opisuje średnią szybkość na sekundę w wybranym okresie próbnym zapytań. Zwraca posortowane wyniki, które nie mogą wykonać operacji sortowania przy użyciu indeksu.

Kolejki

Kolejki mogą opisywać liczbę operacji oczekujących na blokadę, zapisu lub odczytu. Wysokie kolejki mogą wskazywać na istnienie mniej niż optymalnego projektu schematu. Może również wskazywać na sprzeczne ścieżki pisania, popychając wysoką konkurencję o zasoby bazy danych.

Metryki replikacji MongoDB

Oto podstawowe metryki monitorowania replikacji:

Okno replikacji Oplog

Ta metryka zawiera przybliżoną liczbę godzin dostępnych w oplogu replikacji podstawowej. Jeśli dodatkowe opóźnienie przekracza tę wartość, nie może nadążyć i będzie wymagać pełnej ponownej synchronizacji.

Opóźnienie replikacji

Opóźnienie replikacji jest definiowane jako przybliżona liczba sekund, w których węzeł pomocniczy znajduje się za węzłem podstawowym w operacjach zapisu. Duże opóźnienie replikacji wskazywałoby na drugorzędne, które napotykają trudności w replikacji. Może to wpłynąć na opóźnienie operacji, biorąc pod uwagę obawy dotyczące odczytu/zapisu połączeń.

Zapas replikacji

Ta metryka odnosi się do różnicy między oknem oplog replikacji podstawowej a opóźnieniem replikacji pomocniczej. Jeśli ta wartość spadnie do zera, może to spowodować przejście urządzenia wtórnego w tryb ODZYSKIWANIA.

Przeciwnicy -repl

Opcounters -repl jest definiowana jako średnia częstotliwość operacji replikacji wykonywanych na sekundę dla wybranego okresu próbkowania. Dzięki opcounters -graph/metric można przyjrzeć się szybkości operacji i podziałowi typów operacji dla określonej instancji.

Oplog GB/godzinę

Jest to określane jako średnia szybkość gigabajtów oplogów generowanych przez serwer podstawowy na godzinę. Duże nieoczekiwane woluminy oplog mogą wskazywać na wysoce niewystarczające obciążenie związane z zapisem lub problem z projektem schematu.

Narzędzia do monitorowania wydajności MongoDB

MongoDB ma wbudowane narzędzia interfejsu użytkownika w Cloud Manager, Atlas i Ops Manager do śledzenia wydajności. Zapewnia również kilka niezależnych poleceń i narzędzi do przeglądania bardziej surowych danych. Porozmawiamy o niektórych narzędziach, które możesz uruchomić z hosta, który ma dostęp i odpowiednie role do sprawdzania środowiska:

mongotop

Możesz wykorzystać to polecenie do śledzenia czasu, jaki instancja MongoDB spędza na zapisie i odczytaniu danych na kolekcję. Użyj następującej składni:

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

rs.status()

To polecenie zwraca stan zestawu replik. Jest wykonywany z punktu widzenia członka, na którym wykonywana jest metoda.

mongostat

Możesz użyć polecenia mongostat , aby uzyskać szybki przegląd stanu instancji serwera MongoDB. Aby uzyskać optymalne wyniki, możesz go użyć do obejrzenia pojedynczej instancji określonego wydarzenia, ponieważ oferuje widok w czasie rzeczywistym.

Użyj tego polecenia do monitorowania podstawowych statystyk serwera, takich jak kolejki blokad, podział operacji, statystyki pamięci MongoDB i połączenia/sieć:

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

dbStats

To polecenie zwraca statystyki pamięci dla określonej bazy danych, takie jak liczba indeksów i ich rozmiar, łączne dane kolekcji w porównaniu z rozmiarem pamięci oraz statystyki związane z kolekcją (liczba kolekcji i dokumentów).

stan_bazy_serwera()

Możesz użyć komendy db.serverStatus() , aby uzyskać przegląd stanu bazy danych. Daje ci dokument reprezentujący bieżące liczniki metryk instancji. Wykonuj to polecenie w regularnych odstępach czasu, aby zestawiać statystyki dotyczące instancji.

collStats

Komenda collStats zbiera statystyki podobne do tych, które oferuje dbStats na poziomie kolekcji. Jego dane wyjściowe składają się z liczby obiektów w kolekcji, ilości miejsca na dysku zajmowanego przez kolekcję, rozmiaru kolekcji oraz informacji dotyczących jej indeksów dla danej kolekcji.

Wszystkich tych poleceń można używać, aby oferować raportowanie i monitorowanie serwera bazy danych w czasie rzeczywistym, co pozwala monitorować wydajność i błędy bazy danych oraz pomagać w podejmowaniu świadomych decyzji w celu udoskonalenia bazy danych.

Jak usunąć bazę danych MongoDB

Aby usunąć bazę danych utworzoną w MongoDB, musisz połączyć się z nią za pomocą słowa kluczowego use.

Załóżmy, że utworzyłeś bazę danych o nazwie „Inżynierowie”. Aby połączyć się z bazą danych, użyjesz następującego polecenia:

 use Engineers

Następnie wpisz db.dropDatabase() , aby pozbyć się tej bazy danych. Po wykonaniu takiego wyniku możesz się spodziewać:

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

Możesz uruchomić komendę showdbs , aby sprawdzić, czy baza danych nadal istnieje.

Streszczenie

Aby wycisnąć każdą kroplę wartości z MongoDB, musisz dobrze rozumieć podstawy. Dlatego kluczowe znaczenie ma znajomość baz danych MongoDB jak własną kieszeń. Wymaga to wcześniejszego zapoznania się z metodami tworzenia bazy danych.
Szukasz bazy danych, która zapewnia dużą elastyczność i skalowalność? MongoDB może być odpowiedzią... Kliknij, aby Tweet
W tym artykule rzucimy światło na różne metody, których możesz użyć do utworzenia bazy danych w MongoDB, a następnie przedstawimy szczegółowy opis kilku fajnych poleceń MongoDB, które pozwolą Ci być na bieżąco z bazami danych. Na koniec omówiliśmy dyskusję, omawiając, w jaki sposób można wykorzystać osadzone dokumenty i narzędzia do monitorowania wydajności w MongoDB, aby zapewnić najwyższą wydajność funkcji przepływu pracy.

Jak oceniasz te polecenia MongoDB? Czy przegapiliśmy aspekt lub metodę, którą chciałbyś tutaj zobaczyć? Daj nam znać w komentarzach!