Je nachdem, welche Anforderungen du an deine Software stellst, hast du vielleicht Flexibilität, Skalierbarkeit, Leistung oder Geschwindigkeit als Priorität. Daher sind Entwickler und Unternehmen oft verwirrt, wenn sie eine Datenbank für ihre Bedürfnisse auswählen. Wenn du eine Datenbank brauchst, die hohe Flexibilität und Skalierbarkeit bietet und Daten für Kundenanalysen zusammenfasst, ist MongoDB vielleicht die richtige Wahl für dich!
Erfahre mehr über die Struktur der MongoDB-Datenbank und wie du deine Datenbank erstellst, überwachst und verwaltest in diesem hilfreichen Leitfaden 🛠Klicken, um zu twittern
In diesem Artikel geht es um die Struktur der MongoDB-Datenbank und darum, wie du deine Datenbank erstellst, überwachst und verwaltest! Los geht’s.

Wie ist eine MongoDB-Datenbank strukturiert?

MongoDB ist eine schema-freie NoSQL-Datenbank. Das heißt, du gibst keine Struktur für die Tabellen/Datenbanken an, wie du es bei SQL-Datenbanken tust.

Wusstest du, dass NoSQL-Datenbanken sogar schneller sind als relationale Datenbanken? Das liegt an Merkmalen wie Indexierung, Sharding und Aggregationspipelines. MongoDB ist auch für seine schnelle Abfrageausführung bekannt. Aus diesem Grund wird sie von Unternehmen wie Google, Toyota und Forbes bevorzugt.

Im Folgenden gehen wir auf einige der wichtigsten Merkmale von MongoDB ein.

Dokumente

MongoDB hat ein Dokumentdatenmodell, das Daten als JSON-Dokumente speichert. Die Dokumente werden den Objekten im Anwendungscode zugeordnet, was die Verwendung für Entwickler einfacher macht.

In einer relationalen Datenbanktabelle musst du eine Spalte hinzufügen, um ein neues Feld hinzuzufügen. Das ist bei Feldern in einem JSON-Dokument nicht der Fall. Felder in einem JSON-Dokument können sich von Dokument zu Dokument unterscheiden und werden daher nicht zu jedem Datensatz in der Datenbank hinzugefügt.

Dokumente können Strukturen wie Arrays speichern, die verschachtelt werden können, um hierarchische Beziehungen auszudrücken. Außerdem konvertiert MongoDB Dokumente in einen binären JSON (BSON)-Typ. Dies ermöglicht einen schnelleren Zugriff und eine bessere Unterstützung für verschiedene Datentypen wie String, Integer, Boolesche Zahlen und vieles mehr!

Replikatsätze

Wenn du eine neue Datenbank in MongoDB erstellst, legt das System automatisch mindestens 2 weitere Kopien deiner Daten an. Diese Kopien werden als „Replikatsätze“ bezeichnet und replizieren kontinuierlich Daten zwischen ihnen, um eine bessere Verfügbarkeit deiner Daten zu gewährleisten. Außerdem bieten sie Schutz vor Ausfallzeiten bei einem Systemausfall oder einer geplanten Wartung.

Sammlungen

Eine Sammlung ist eine Gruppe von Dokumenten, die mit einer Datenbank verbunden sind. Sie sind vergleichbar mit Tabellen in relationalen Datenbanken.

Sammlungen sind jedoch viel flexibler. Zum einen sind sie nicht auf ein Schema angewiesen. Zweitens müssen die Dokumente nicht denselben Datentyp haben!

Um eine Liste der Sammlungen anzuzeigen, die zu einer Datenbank gehören, verwendest du den Befehl listCollections.

Aggregations-Pipelines

Du kannst dieses Framework nutzen, um verschiedene Operatoren und Ausdrücke zu verknüpfen. Es ist flexibel, weil es dir erlaubt, Daten beliebiger Struktur zu verarbeiten, umzuwandeln und zu analysieren.

Aus diesem Grund ermöglicht MongoDB schnelle Datenflüsse und Funktionen über 150 Operatoren und Ausdrücke. Außerdem verfügt es über mehrere Stufen, wie die Union-Stufe, die Ergebnisse aus mehreren Sammlungen flexibel zusammenführt.

Indizes

Du kannst jedes Feld in einem MongoDB-Dokument indizieren, um seine Effizienz zu erhöhen und die Abfragegeschwindigkeit zu verbessern. Die Indizierung spart Zeit, indem sie den Index durchsucht, um die geprüften Dokumente einzuschränken. Ist das nicht viel besser, als jedes Dokument in der Sammlung zu lesen?

Du kannst verschiedene Indizierungsstrategien verwenden, einschließlich zusammengesetzter Indizes für mehrere Felder. Angenommen, du hast mehrere Dokumente, die den Vor- und Nachnamen des Mitarbeiters in verschiedenen Feldern enthalten. Wenn du möchtest, dass der Vor- und Nachname zurückgegeben wird, kannst du einen Index erstellen, der sowohl „Nachname“ als auch „Vorname“ enthält. Das ist viel besser als ein Index für „Nachname“ und ein anderer für „Vorname“.

Du kannst Tools wie Performance Advisor nutzen, um herauszufinden, welche Abfrage von Indizes profitieren könnte.

Sharding

Beim Sharding wird ein einzelner Datensatz auf mehrere Datenbanken verteilt. Dieser Datensatz kann dann auf mehreren Rechnern gespeichert werden, um die gesamte Speicherkapazität eines Systems zu erhöhen. Der Grund dafür ist, dass größere Datensätze in kleinere Stücke aufgeteilt und in verschiedenen Datenknoten gespeichert werden.

MongoDB splittet Daten auf der Ebene der Sammlung und verteilt die Dokumente einer Sammlung auf die Shards in einem Cluster. Dies gewährleistet Skalierbarkeit, da die Architektur auch die größten Anwendungen bewältigen kann.

So erstellst du eine MongoDB-Datenbank

Zuerst musst du das richtige MongoDB-Paket für dein Betriebssystem installieren. Gehe auf die Seite „MongoDB Community Server herunterladen“. Wähle aus den verfügbaren Optionen die neueste „Version“, das „Paket“-Format als Zip-Datei und als „Plattform“ dein Betriebssystem aus und klicke auf „Herunterladen“, wie unten abgebildet:

Dieses Bild zeigt die verfügbaren Optionen - Version, Plattform und Paket - beim Herunterladen von MongoDB Community Server.
MongoDB Community Server Download-Prozess. (Bildquelle: MongoDB Community Server)

Der Prozess ist ziemlich einfach, sodass du MongoDB im Handumdrehen in deinem System installiert hast!

Wenn du die Installation abgeschlossen hast, öffne die Eingabeaufforderung und gib mongod -version ein, um sie zu überprüfen. Wenn du nicht die folgende Ausgabe erhältst, sondern stattdessen eine Reihe von Fehlern, musst du die Installation möglicherweise erneut durchführen:

Dies ist ein Codeschnipsel, um die MongoDB-Version nach der Installation zu überprüfen.
Überprüfen der MongoDB-Version. (Bildquelle: configserverfirewall)

MongoDB-Shell verwenden

Bevor wir loslegen, stelle sicher, dass:

  • Dein Client verfügt über Transport Layer Security und befindet sich auf deiner IP-Zulassungsliste.
  • Du hast ein Benutzerkonto und ein Passwort für den gewünschten MongoDB-Cluster.
  • Du hast MongoDB auf deinem Gerät installiert.

Schritt 1: Zugriff auf die MongoDB-Shell

Um auf die MongoDB-Shell zuzugreifen, gibst du den folgenden Befehl ein:

net start MongoDB

Dies sollte die folgende Ausgabe ergeben:

Hier ein Codeausschnitt zur Initialisierung des MongoDB-Servers
MongoDB Server Initialisierung. (Bildquelle: c-sharpcorner)

Der vorherige Befehl hat den MongoDB-Server initialisiert. Um ihn auszuführen, müssen wir in der Eingabeaufforderung mongo eingeben.

Dies ist ein Codeschnipsel, um den MongoDB-Server zu starten.
Laufender MongoDB-Server. (Bildquelle: bmc)

Hier in der MongoDB-Shell können wir Befehle ausführen, um Datenbanken zu erstellen, Daten einzufügen, Daten zu bearbeiten, administrative Befehle zu erteilen und Daten zu löschen.

Schritt 2: Erstelle deine Datenbank

Im Gegensatz zu SQL gibt es bei MongoDB keinen Befehl zum Anlegen einer Datenbank. Stattdessen gibt es ein Schlüsselwort namens use, das zu einer bestimmten Datenbank wechselt. Wenn die Datenbank nicht existiert, wird eine neue Datenbank erstellt, andernfalls wird eine Verknüpfung mit der bestehenden Datenbank hergestellt.

Um zum Beispiel eine Datenbank namens „Firma“ zu erstellen, gibst du ein:

use Company
Dies ist ein Codeschnipsel zum Erstellen einer Datenbank in MongoDB.
Datenbank in MongoDB erstellen.

Du kannst db eingeben, um die Datenbank, die du gerade erstellt hast, in deinem System zu bestätigen. Wenn die neu erstellte Datenbank angezeigt wird, hast du dich erfolgreich mit ihr verbunden.

Wenn du die vorhandenen Datenbanken überprüfen willst, gib show dbs ein. Dann werden alle Datenbanken in deinem System angezeigt:

Dies ist ein Codeschnipsel, um die vorhandenen Datenbanken im System anzuzeigen.
Anzeigen von Datenbanken in MongoDB.

Standardmäßig werden bei der Installation von MongoDB die Datenbanken admin, config und local angelegt.

Hast du bemerkt, dass die Datenbank, die wir erstellt haben, nicht angezeigt wird? Das liegt daran, dass wir noch keine Werte in der Datenbank gespeichert haben! Wir werden das Einfügen im Abschnitt über die Datenbankverwaltung besprechen.

Atlas UI verwenden

Du kannst auch mit dem MongoDB-Datenbankdienst Atlas beginnen. Auch wenn du für einige Funktionen von Atlas bezahlen musst, sind die meisten Datenbankfunktionen mit der kostenlosen Version verfügbar. Die Funktionen der kostenlosen Version sind mehr als genug, um eine MongoDB-Datenbank zu erstellen.

Bevor wir loslegen, solltest du sicherstellen, dass:

  1. Deine IP steht auf der Zulassen-Liste.
  2. Du hast ein Benutzerkonto und ein Passwort für den MongoDB-Cluster, den du verwenden möchtest.

Um eine MongoDB-Datenbank mit AtlasUI zu erstellen, öffne ein Browserfenster und melde dich bei https://cloud.mongodb.com an. Klicke auf der Seite deines Clusters auf Sammlungen durchsuchen. Wenn keine Datenbanken im Cluster vorhanden sind, kannst du deine Datenbank erstellen, indem du auf die Schaltfläche Eigene Daten hinzufügen klickst.

Du wirst aufgefordert, eine Datenbank und einen Sammlungsnamen anzugeben. Wenn du sie benannt hast, klicke auf Erstellen und du bist fertig! Jetzt kannst du neue Dokumente eingeben oder dich über Treiber mit der Datenbank verbinden.

Verwalten deiner MongoDB-Datenbank

In diesem Abschnitt stellen wir dir einige Möglichkeiten vor, wie du deine MongoDB-Datenbank effektiv verwalten kannst. Das kannst du entweder mit dem MongoDB-Kompass oder mit Collections machen.

Sammlungen verwenden

Während relationale Datenbanken über klar definierte Tabellen mit bestimmten Datentypen und Spalten verfügen, gibt es bei NoSQL keine Tabellen, sondern Sammlungen. Diese Sammlungen haben keine Struktur, und die Dokumente können variieren – du kannst verschiedene Datentypen und Felder haben, ohne dass das Format eines anderen Dokuments in derselben Sammlung übereinstimmen muss.

Zur Veranschaulichung erstellen wir eine Sammlung namens „Employee“ und fügen ihr ein Dokument hinzu:

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

Wenn das Einfügen erfolgreich ist, wird WriteResult({ "nInserted" : 1 }) zurückgegeben:

Dieser Codeschnipsel liefert WriteResult({
Erfolgreiche Einfügung in MongoDB.

Hier bezieht sich „db“ auf die aktuell verbundene Datenbank. „Mitarbeiter“ ist die neu erstellte Sammlung in der Unternehmensdatenbank.

Wir haben hier keinen Primärschlüssel festgelegt, weil MongoDB automatisch ein Primärschlüsselfeld namens „_id“ erstellt und ihm einen Standardwert zuweist.

Führe den folgenden Befehl aus, um die Sammlung im JSON-Format auszuchecken:

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

Ausgabe:

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

Obwohl der Wert „_id“ automatisch zugewiesen wird, kannst du den Wert des Standard-Primärschlüssels ändern. Diesmal fügen wir ein weiteres Dokument in die Datenbank „Employee“ ein, wobei wir den Wert „_id“ auf „1“ setzen:

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

Wenn wir den Befehl db.Employee.find().forEach(printjson) ausführen, erhalten wir die folgende Ausgabe:

Die Ausgabe zeigt die Dokumente in der Sammlung Employee zusammen mit ihrem Primärschlüssel
Dokumente in der Sammlung mit ihrem Primärschlüssel.

In der obigen Ausgabe ist der „_id“-Wert für „Ava“ auf „1“ gesetzt, anstatt automatisch einen Wert zu erhalten.

Nachdem wir nun erfolgreich Werte in die Datenbank eingefügt haben, können wir mit dem folgenden Befehl überprüfen, ob sie unter den bestehenden Datenbanken in unserem System auftaucht:

show dbs
Die Ausgabe zeigt die Sammlung der Mitarbeiter in den bestehenden Datenbanken in unserem System.
Anzeige der Liste der Datenbanken.

Und voila! Du hast erfolgreich eine Datenbank in deinem System erstellt!

Den MongoDB-Kompass verwenden

Obwohl wir mit MongoDB-Servern von der Mongo-Shell aus arbeiten können, kann das manchmal mühsam sein. Das wirst du vielleicht in einer Produktionsumgebung erleben.

Es gibt jedoch ein von MongoDB entwickeltes Kompass-Tool (passenderweise Compass genannt), das die Arbeit erleichtern kann. Es verfügt über eine bessere Benutzeroberfläche und zusätzliche Funktionen wie Datenvisualisierung, Leistungsprofilerstellung und CRUD-Zugriff (Erstellen, Lesen, Aktualisieren, Löschen) auf Daten, Datenbanken und Sammlungen.

Du kannst die Compass IDE für dein Betriebssystem herunterladen und sie ganz einfach installieren.

Als Nächstes öffnest du die Anwendung und stellst eine Verbindung mit dem Server her, indem du den Verbindungsstring einfügst. Wenn du ihn nicht finden kannst, kannst du auf Verbindungsfelder einzeln ausfüllen klicken. Wenn du die Portnummer bei der Installation von MongoDB nicht geändert hast, klickst du einfach auf die Schaltfläche Verbinden und schon bist du dabei! Andernfalls gibst du einfach die von dir festgelegten Werte ein und klickst auf Verbinden.

Dieses Bild zeigt das Fenster Neue Verbindung, in dem du die Verbindungsurl einfügen kannst.
Fenster Neue Verbindung in MongoDB (Bildquelle: mongodb)

Als Nächstes gibst du im Fenster „Neue Verbindung“ den Hostnamen, den Port und die Authentifizierung an.

In MongoDB Compass kannst du eine Datenbank erstellen und gleichzeitig ihre erste Sammlung hinzufügen. So machst du es:

  1. Klicke auf Datenbank erstellen, um die Eingabeaufforderung zu öffnen.
  2. Gib den Namen der Datenbank und ihre erste Sammlung ein.
  3. Klicke auf Datenbank erstellen.

Du kannst weitere Dokumente in deine Datenbank einfügen, indem du auf den Namen deiner Datenbank und dann auf den Namen der Sammlung klickst, um die Registerkarte Dokumente anzuzeigen. Du kannst dann auf die Schaltfläche Daten hinzufügen klicken, um ein oder mehrere Dokumente in deine Sammlung einzufügen.

Wenn du Dokumente hinzufügst, kannst du sie einzeln oder als mehrere Dokumente in einer Reihe eingeben. Wenn du mehrere Dokumente hinzufügst, musst du darauf achten, dass die Dokumente durch Kommata getrennt in eckige Klammern gesetzt werden. Zum Beispiel:

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

Klicke abschließend auf Einfügen, um die Dokumente zu deiner Sammlung hinzuzufügen. So würde der Textkörper eines Dokuments aussehen:

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

Hier lauten die Feldnamen „SchülerID“ und „Schülername“. Die Feldwerte sind „1“ bzw. „JohnDoe“.

Nützliche Befehle

Du kannst diese Sammlungen mit den Befehlen für die Rollen- und Benutzerverwaltung verwalten.

Befehle zur Benutzerverwaltung

Die MongoDB-Befehle zur Benutzerverwaltung enthalten Befehle, die sich auf den Benutzer beziehen. Mit diesen Befehlen können wir die Benutzer erstellen, aktualisieren und löschen.

dropUser

Dieser Befehl löscht einen einzelnen Benutzer aus der angegebenen Datenbank. Im Folgenden findest du die Syntax:

db.dropUser(username, writeConcern)

username ist ein Pflichtfeld, das das Dokument mit den Authentifizierungs- und Zugriffsinformationen über den Benutzer enthält. Das optionale Feld writeConcern enthält den Grad des Schreibschutzes für den Erstellungsvorgang. Der Grad der Schreibberechtigung kann durch das optionale Feld writeConcern bestimmt werden.

Bevor du einen Benutzer mit der Rolle userAdminAnyDatabase ablegst, musst du sicherstellen, dass es mindestens einen anderen Benutzer mit Benutzerverwaltungsrechten gibt.

In diesem Beispiel löschen wir den Benutzer „user26“ in der Testdatenbank:

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

Ausgabe:

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

Dieser Befehl erstellt einen neuen Benutzer für die angegebene Datenbank wie folgt:

db.createUser(user, writeConcern)

Hier ist user ein Pflichtfeld, das das Dokument mit den Authentifizierungs- und Zugangsinformationen über den anzulegenden Benutzer enthält. Das optionale Feld writeConcern enthält den Grad der Schreibberechtigung für den Erstellungsvorgang. Der Grad der Schreibberechtigung kann durch das optionale Feld writeConcern bestimmt werden.

createUser gibt einen Fehler zurück, wenn der Benutzer bereits in der Datenbank existiert.

Du kannst einen neuen Benutzer in der Testdatenbank wie folgt anlegen:

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

Die Ausgabe sieht wie folgt aus:

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

Du kannst diesen Befehl nutzen, um einem Benutzer zusätzliche Rollen zu gewähren. Um ihn zu verwenden, musst du die folgende Syntax beachten:

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

Du kannst sowohl benutzerdefinierte als auch eingebaute Rollen in den oben genannten Rollen angeben. Wenn du eine Rolle angeben möchtest, die in derselben Datenbank existiert, in der auch grantRolesToUser läuft, kannst du die Rolle entweder mit einem Dokument angeben, wie unten beschrieben:

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

Oder du kannst die Rolle einfach mit dem Namen der Rolle angeben. Zum Beispiel:

"readWrite"

Wenn du eine Rolle angeben willst, die in einer anderen Datenbank vorhanden ist, musst du die Rolle mit einem anderen Dokument angeben.

Um eine Rolle in einer Datenbank zu gewähren, brauchst du die Aktion grantRole in der angegebenen Datenbank.

Hier ist ein Beispiel, um dir ein klares Bild zu geben. Nimm zum Beispiel einen Benutzer productUser00 in der Produktdatenbank mit den folgenden Rollen:

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

Durch die Operation grantRolesToUser erhält „productUser00“ die Rolle readWrite in der Bestandsdatenbank und die Leserolle in der Produktdatenbank:

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

Der Benutzer productUser00 in der Produktdatenbank besitzt nun die folgenden Rollen:

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

Du kannst den Befehl usersInfo verwenden, um Informationen über einen oder mehrere Benutzer zu erhalten. Hier ist die Syntax:

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

Was den Zugriff angeht, so können Benutzer immer ihre eigenen Informationen einsehen. Um die Daten eines anderen Benutzers einzusehen, muss der Benutzer, der den Befehl ausführt, über die Aktion viewUser in der Datenbank des anderen Benutzers verfügen.

Wenn du den Befehl userInfo ausführst, kannst du je nach den angegebenen Optionen die folgenden Informationen erhalten:

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

Nachdem du nun eine allgemeine Vorstellung davon hast, was du mit dem Befehl usersInfo erreichen kannst, stellt sich natürlich die Frage, welche Befehle nützlich sind, um bestimmte Benutzer oder mehrere Benutzer zu überprüfen

Hier sind zwei praktische Beispiele, um das zu veranschaulichen:
Um die spezifischen Berechtigungen und Informationen für bestimmte Benutzer, aber nicht die Anmeldedaten, für den Benutzer „Anthony“ in der Datenbank „office“ einzusehen, führe den folgenden Befehl aus:

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

Wenn du dir einen Benutzer in der aktuellen Datenbank ansehen willst, kannst du ihn nur namentlich erwähnen. Wenn du dich zum Beispiel in der Datenbank „home“ befindest und ein Benutzer namens „Timothy“ in der Datenbank „home“ existiert, kannst du den folgenden Befehl ausführen:

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

Als Nächstes kannst du ein Array verwenden, wenn du dir die Informationen für verschiedene Benutzer ansehen möchtest. Du kannst entweder die optionalen Felder showCredentials und showPrivileges hinzufügen oder sie weglassen. So würde der Befehl aussehen:

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

Mit dem Befehl revokeRolesFromUser kannst du eine oder mehrere Rollen von einem Benutzer in der Datenbank entfernen, in der die Rollen vorhanden sind. Der Befehl revokeRolesFromUser hat die folgende Syntax:

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

In der oben genannten Syntax kannst du im Feld roles sowohl benutzerdefinierte als auch eingebaute Rollen angeben. Ähnlich wie beim Befehl grantRolesToUser kannst du die Rolle, die du widerrufen willst, in einem Dokument angeben oder ihren Namen verwenden.

Um den Befehl revokeRolesFromUser erfolgreich ausführen zu können, musst du die Aktion revokeRole auf der angegebenen Datenbank haben.

Hier ist ein Beispiel, um die Sache zu verdeutlichen. Die Entität productUser00 in der Produktdatenbank hatte die folgenden Rollen:

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

Mit dem folgenden Befehl revokeRolesFromUser werden zwei Rollen des Benutzers entfernt: die Rolle „Lesen“ aus products und die Rolle assetsWriter aus der Datenbank „Assets“:

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

Der Benutzer „productUser00“ in der Produktdatenbank hat jetzt nur noch eine Rolle:

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

Rollenmanagement-Befehle

Rollen gewähren Benutzern Zugriff auf Ressourcen. Mehrere integrierte Rollen können von Administratoren verwendet werden, um den Zugriff auf ein MongoDB-System zu steuern. Wenn die Rollen die gewünschten Berechtigungen nicht abdecken, kannst du sogar noch weiter gehen und neue Rollen für eine bestimmte Datenbank erstellen.

dropRole

Mit dem Befehl dropRole kannst du eine benutzerdefinierte Rolle aus der Datenbank löschen, auf der du den Befehl ausführst. Um diesen Befehl auszuführen, verwendest du die folgende Syntax:

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

Für eine erfolgreiche Ausführung musst du die Aktion dropRole auf der angegebenen Datenbank haben. Die folgenden Operationen würden die Rolle writeTags aus der Datenbank „Produkte“ entfernen:

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

Mit dem Befehl createRole kannst du eine Rolle erstellen und ihre Berechtigungen festlegen. Die Rolle gilt für die Datenbank, für die du den Befehl ausführst. Der Befehl createRole würde einen Fehler bezüglich einer doppelten Rolle zurückgeben, wenn die Rolle bereits in der Datenbank existiert.

Um diesen Befehl auszuführen, befolge die angegebene Syntax:

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

Die Berechtigungen einer Rolle gelten für die Datenbank, in der die Rolle erstellt wurde. Die Rolle kann Berechtigungen von anderen Rollen in ihrer Datenbank erben. Eine Rolle, die in der Datenbank „admin“ erstellt wurde, kann z. B. Berechtigungen enthalten, die entweder für einen Cluster oder für alle Datenbanken gelten. Sie kann auch Berechtigungen von Rollen in anderen Datenbanken erben.

Um eine Rolle in einer Datenbank zu erstellen, musst du zwei Dinge haben:

  1. Die Aktion grantRole auf dieser Datenbank, um die Berechtigungen für die neue Rolle und die Rollen, von denen sie erben soll, anzugeben.
  2. Die Aktion createRole für diese Datenbankressource.

Mit dem folgenden createRole Befehl wird eine clusterAdmin Rolle in der Benutzerdatenbank erstellt:

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

Mit dem Befehl grantRolesToRole kannst du einer benutzerdefinierten Rolle Rollen gewähren. Der Befehl grantRolesToRole würde sich auf die Rollen in der Datenbank auswirken, in der der Befehl ausgeführt wird.

Dieser grantRolesToRole Befehl hat die folgende Syntax:

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

Die Zugriffsrechte sind ähnlich wie beim Befehl grantRolesToUser – für die ordnungsgemäße Ausführung des Befehls benötigst du eine grantRole Aktion auf einer Datenbank.

Im folgenden Beispiel kannst du den Befehl grantRolesToUser verwenden, um die Rolle productsReader in der Datenbank „Produkte“ zu aktualisieren, damit sie die Rechte der Rolle productsWriter erbt:

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

Mit revokePrivilegesFromRole kannst du der benutzerdefinierten Rolle in der Datenbank, in der der Befehl ausgeführt wird, die angegebenen Berechtigungen entziehen. Damit der Befehl korrekt ausgeführt wird, musst du die folgende Syntax beachten:

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

Um ein Privileg zu entziehen, muss das Muster „Ressourcendokument“ mit dem Feld „Ressource“ des betreffenden Privilegs übereinstimmen. Das Feld „Aktionen“ kann entweder eine genaue Übereinstimmung oder eine Teilmenge sein.

Nehmen wir zum Beispiel die Rolle manageRole in der Produktdatenbank mit den folgenden Berechtigungen, die die Datenbank „Manager“ als Ressource angeben:

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

Du kannst die Aktionen „Einfügen“ oder „Entfernen“ nicht nur für eine Sammlung in der Managerdatenbank widerrufen. Die folgenden Operationen führen zu keiner Änderung in der Rolle:

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

Um die Aktionen „Einfügen“ und/oder „Entfernen“ aus der Rolle manageRole zu widerrufen, musst du das Ressourcendokument genau abgleichen. Der folgende Vorgang widerruft zum Beispiel nur die Aktion „Entfernen“ des bestehenden Privilegs:

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

Der folgende Vorgang entfernt mehrere Berechtigungen aus der Rolle „Führungskraft“ in der Managerdatenbank:

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

Der Befehl rolesInfo liefert Informationen zu den Berechtigungen und der Vererbung der angegebenen Rollen, einschließlich der eingebauten und benutzerdefinierten Rollen. Du kannst auch den Befehl rolesInfo verwenden, um alle Rollen abzurufen, die für eine Datenbank gelten.

Für eine korrekte Ausführung musst du die folgende Syntax beachten:

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

Um Informationen zu einer Rolle aus der aktuellen Datenbank zu erhalten, kannst du ihren Namen wie folgt angeben:

{ rolesInfo: "<rolename>" }

Um Informationen für eine Rolle aus einer anderen Datenbank zu erhalten, kannst du die Rolle in einem Dokument erwähnen, in dem die Rolle und die Datenbank erwähnt werden:

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

Der folgende Befehl gibt zum Beispiel die Informationen zur Rollenvererbung für die Rolle Executive in der Managerdatenbank zurück:

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

Der nächste Befehl gibt die Informationen zur Rollenvererbung zurück: accountManager in der Datenbank, in der der Befehl ausgeführt wird:

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

Der folgende Befehl gibt sowohl die Berechtigungen als auch die Rollenvererbung für die Rolle „Führungskraft“ zurück, wie sie in der Managerdatenbank definiert ist:

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

Um mehrere Rollen anzugeben, kannst du ein Array verwenden. Du kannst auch jede Rolle in dem Array als String oder Dokument angeben.

Du solltest eine Zeichenkette nur dann verwenden, wenn die Rolle in der Datenbank existiert, in der der Befehl ausgeführt wird:

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

Der folgende Befehl gibt zum Beispiel Informationen für drei Rollen in drei verschiedenen Datenbanken zurück:

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

Du kannst sowohl die Berechtigungen als auch die Rollenvererbung wie folgt abrufen:

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

MongoDB-Dokumente für bessere Leistung einbetten

Mit Dokumentendatenbanken wie MongoDB kannst du dein Schema nach deinen Bedürfnissen definieren. Um optimale Schemas in MongoDB zu erstellen, kannst du die Dokumente verschachteln. Anstatt deine Anwendung an ein Datenmodell anzupassen, kannst du also ein Datenmodell erstellen, das zu deinem Anwendungsfall passt.

Haben Sie mit Ausfallzeiten und WordPress-Problemen zu kämpfen? Kinsta ist die Hosting-Lösung, die Ihnen Zeit spart! Sieh dir unsere Features an

Mit eingebetteten Dokumenten kannst du zusammengehörige Daten speichern, auf die du gemeinsam zugreifst. Wenn du Schemas für MongoDB entwirfst, empfiehlt es sich, Dokumente standardmäßig einzubetten. Verwende datenbank- oder anwendungsseitige Joins und Referenzen nur dann, wenn sie sinnvoll sind.

Sorge dafür, dass die Arbeitslast ein Dokument so oft wie nötig abrufen kann. Gleichzeitig sollte das Dokument auch alle Daten enthalten, die es braucht. Dies ist entscheidend für die außergewöhnliche Leistung deiner Anwendung.

Im Folgenden findest du ein paar verschiedene Muster für die Einbettung von Dokumenten:

Muster für eingebettete Dokumente

Mit diesem Muster kannst du selbst komplizierte Unterstrukturen in die Dokumente einbetten, mit denen sie verwendet werden. Wenn du zusammenhängende Daten in ein einziges Dokument einbettest, kannst du die Anzahl der Lesevorgänge verringern, die nötig sind, um Daten zu erhalten. Generell solltest du dein Schema so strukturieren, dass deine Anwendung alle benötigten Informationen in einem einzigen Lesevorgang erhält. Daher gilt hier die Regel: Was zusammen verwendet wird, sollte auch zusammen gespeichert werden.

Eingebettetes Subset-Muster

Das eingebettete Teilmengenmuster ist ein Mischfall. Du verwendest es für eine separate Sammlung einer langen Liste zusammengehöriger Elemente, von denen du einige zur Anzeige bereithalten kannst.

Hier ist ein Beispiel mit einer Liste von Filmkritiken:

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

Stell dir vor, es gibt tausend ähnliche Kritiken, aber du willst nur die letzten beiden anzeigen, wenn du einen Film zeigst. In diesem Fall ist es sinnvoll, diese Teilmenge als Liste im Filmdokument zu speichern:

> 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

Einfach ausgedrückt: Wenn du routinemäßig auf eine Teilmenge verwandter Artikel zugreifst, solltest du sie einbetten.

Unabhängiger Zugriff

Vielleicht möchtest du Unterdokumente in ihrer eigenen Sammlung speichern, um sie von ihrer übergeordneten Sammlung zu trennen.

Nehmen wir zum Beispiel die Produktlinie eines Unternehmens. Wenn das Unternehmen nur eine kleine Anzahl von Produkten verkauft, möchtest du sie vielleicht im Unternehmensdokument speichern. Wenn du sie aber unternehmensübergreifend wiederverwenden oder direkt auf sie zugreifen möchtest, solltest du sie ebenfalls in ihrer Sammlung speichern.

Wenn du eine Entität eigenständig bearbeitest oder auf sie zugreifst, solltest du sie in einer Sammlung separat speichern, um eine optimale Vorgehensweise zu gewährleisten.

Unbegrenzte Listen

Kurze Listen mit zusammengehörigen Informationen in ihrem Dokument zu speichern, hat einen Nachteil. Wenn deine Liste unkontrolliert weiter wächst, solltest du sie nicht in einem einzigen Dokument speichern. Das liegt daran, dass du sie nicht sehr lange unterstützen kannst.

Hierfür gibt es zwei Gründe. Erstens gibt es bei MongoDB eine Größenbeschränkung für ein einzelnes Dokument. Zweitens: Wenn du zu häufig auf das Dokument zugreifst, führt das zu einer unkontrollierten Speichernutzung.

Einfach ausgedrückt: Wenn eine Liste anfängt, unbegrenzt zu wachsen, solltest du eine Sammlung anlegen, um sie separat zu speichern.

Erweitertes Referenzmuster

Das erweiterte Referenzmuster ähnelt dem Teilmengenmuster. Es optimiert ebenfalls Informationen, auf die du regelmäßig zugreifst, um sie im Dokument zu speichern.

Hier wird statt einer Liste ein Verweis auf ein anderes Dokument verwendet, das sich in derselben Sammlung befindet. Gleichzeitig werden auch einige Felder des anderen Dokuments gespeichert, damit du jederzeit darauf zugreifen kannst.

Zum Beispiel:

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

Wie du sehen kannst, wird die „studio_id“ gespeichert, damit du weitere Informationen über das Studio, das den Film produziert hat, nachschlagen kannst. Aber auch der Name des Studios wird der Einfachheit halber in dieses Dokument kopiert.

Um Informationen aus geänderten Dokumenten regelmäßig einzubinden, solltest du die Dokumente, in die du die Informationen kopiert hast, immer aktualisieren, wenn sie geändert werden. Mit anderen Worten: Wenn du regelmäßig auf einige Felder eines referenzierten Dokuments zugreifst, bette sie ein.

Wie man MongoDB überwacht

Mit Monitoring-Tools wie Kinsta APM kannst du lange API-Aufrufe, langsame Datenbankabfragen und lange externe URL-Anfragen debuggen, um nur einige Beispiele zu nennen. Du kannst sogar Befehle einsetzen, um die Datenbankleistung zu verbessern. Außerdem kannst du mit ihnen den Gesundheitszustand deiner Datenbankinstanzen überprüfen.

Warum solltest du MongoDB-Datenbanken überwachen?

Ein wichtiger Aspekt bei der Planung der Datenbankverwaltung ist die Überwachung der Leistung und des Zustands deines Clusters. MongoDB Atlas übernimmt den Großteil des Verwaltungsaufwands durch seine Fehlertoleranz- und Skalierungsfähigkeiten.

Trotzdem müssen die Nutzer wissen, wie man Cluster überwacht. Sie sollten auch wissen, wie sie skalieren oder Anpassungen vornehmen können, bevor es zu einer Krise kommt.

Mit der Überwachung von MongoDB-Datenbanken kannst du:

  • Beobachte die Auslastung der Ressourcen.
  • Verstehe die aktuelle Kapazität deiner Datenbank.
  • Reagiere und erkenne Probleme in Echtzeit, um deinen Application Stack zu verbessern.
  • Beobachte das Vorhandensein von Leistungsproblemen und abnormalem Verhalten.
  • Richte dich nach deinen Governance-/Datenschutz- und Service Level Agreement (SLA)-Anforderungen.

Wichtige Metriken zur Überwachung

Bei der Überwachung von MongoDB gibt es vier wichtige Aspekte, die du im Auge behalten musst:

1. MongoDB Hardware-Metriken

Hier sind die wichtigsten Metriken zur Überwachung der Hardware:

Normalisierte Prozess-CPU

Sie ist definiert als der prozentuale Anteil der Zeit, den die CPU für die Anwendungssoftware zur Aufrechterhaltung des MongoDB-Prozesses aufwendet.

Du kannst diesen Wert in einem Bereich von 0-100% skalieren, indem du ihn durch die Anzahl der CPU-Kerne teilst. Dazu gehört auch die CPU, die von Modulen wie dem Kernel und dem Benutzer genutzt wird.

Eine hohe Kernel-CPU zeigt an, dass die CPU durch die Operationen des Betriebssystems ausgelastet ist. Der Benutzer, der mit MongoDB-Operationen verbunden ist, könnte jedoch die Hauptursache für die CPU-Erschöpfung sein.

Normalisierte System-CPU

Dies ist der prozentuale Anteil der Zeit, den die CPU für Systemaufrufe zur Bedienung dieses MongoDB-Prozesses verwendet. Du kannst den Wert in einem Bereich von 0-100% einstellen, indem du ihn durch die Anzahl der CPU-Kerne teilst. Er umfasst auch die CPU, die von Modulen wie iowait, user, kernel, steal usw. verwendet wird.

Eine hohe User-CPU oder eine hohe Kernel-CPU kann eine Erschöpfung der CPU durch MongoDB-Operationen (Software) anzeigen. Ein hoher Iowait-Wert kann mit der Erschöpfung des Speichers zusammenhängen, die zu einer Erschöpfung der CPU führt.

Festplatten-IOPS

Festplatten-IOPS sind die durchschnittlich verbrauchten IO-Operationen pro Sekunde auf der Festplattenpartition von MongoDB.

Festplatten-Latenz

Dies ist die Lese- und Schreiblatenz der Festplattenpartition in Millisekunden in MongoDB. Hohe Werte (>500 ms) zeigen, dass die Speicherschicht die Leistung von MongoDB beeinträchtigen kann.

Systemspeicher

Der Systemspeicher gibt an, wie viele Bytes des physischen Speichers genutzt werden und wie viel freier Speicherplatz verfügbar ist.

Die verfügbare Metrik gibt die Anzahl der Bytes des verfügbaren Systemspeichers an. Du kannst dies nutzen, um neue Anwendungen ohne Swapping auszuführen.

Freier Speicherplatz

Dies ist die Summe der freien Bytes auf der Festplattenpartition von MongoDB. MongoDB Atlas bietet automatische Skalierungsfunktionen, die auf dieser Metrik basieren.

Swap-Nutzung

Du kannst ein Swap-Nutzungsdiagramm verwenden, um zu beschreiben, wie viel Speicher auf dem Swap-Gerät platziert wird. Eine stark genutzte Metrik in diesem Diagramm zeigt, dass der Swap-Speicher ausgelastet ist. Dies zeigt, dass der Speicher für die aktuelle Arbeitslast nicht ausreichend bereitgestellt wird.

Metriken für Verbindung und Betrieb des MongoDB-Clusters

Hier sind die wichtigsten Metriken für Operation und Connection Metrics:

Ausführungszeiten der Operationen

Die durchschnittliche Ausführungszeit von Operationen (Schreib- und Lesevorgänge), die über den ausgewählten Zeitraum durchgeführt wurden.

Operationszähler

Dies ist die durchschnittliche Anzahl der ausgeführten Operationen pro Sekunde im ausgewählten Stichprobenzeitraum. Das Diagramm/die Metrik Opcounters zeigt die Aufschlüsselung der Operationstypen und der Geschwindigkeit für die Instanz.

Verbindungen

Diese Metrik bezieht sich auf die Anzahl der offenen Verbindungen zur Instanz. Hohe Spitzen oder Zahlen können auf eine suboptimale Verbindungsstrategie hindeuten, entweder von einem nicht reagierenden Server oder von der Client-Seite.

Query Targeting und Query Executors

Dies ist die durchschnittliche Rate pro Sekunde über den ausgewählten Stichprobenzeitraum der gescannten Dokumente. Bei Query Executors ist dies die Rate während der Bewertung des Abfrageplans und der Abfragen. Query Targeting zeigt das Verhältnis zwischen der Anzahl der gescannten Dokumente und der Anzahl der zurückgegebenen Dokumente.

Ein hohes Zahlenverhältnis deutet auf suboptimale Vorgänge hin. Bei diesen Vorgängen werden viele Dokumente gescannt, um einen kleineren Teil zurückzugeben.

Scannen und Reihenfolge

Sie beschreibt die durchschnittliche Rate pro Sekunde über die gewählte Stichprobenzeit der Abfragen. Sie gibt sortierte Ergebnisse zurück, die die Sortieroperation nicht über einen Index ausführen können.

Warteschlangen

Warteschlangen können die Anzahl der Operationen beschreiben, die auf eine Sperre warten, entweder zum Schreiben oder zum Lesen. Hohe Warteschlangen können ein Hinweis auf ein nicht optimales Schema-Design sein. Sie können auch auf konkurrierende Schreibpfade hinweisen, die zu einem starken Wettbewerb um die Datenbankressourcen führen.

Metriken für die MongoDB-Replikation

Hier sind die wichtigsten Metriken zur Überwachung der Replikation:

Replikations-Oplog-Fenster

Diese Metrik gibt die ungefähre Anzahl der Stunden an, die im Replikations-Oplog der Primärdatenbank verfügbar sind. Wenn die sekundäre Replikation mehr als diesen Wert unterschreitet, kann sie nicht mithalten und muss vollständig neu synchronisiert werden.

Replikationsverzögerung

Der Replikationsrückstand ist definiert als die ungefähre Anzahl von Sekunden, die ein sekundärer Knoten bei Schreibvorgängen hinter dem primären zurückliegt. Ein hoher Replikationsrückstand deutet darauf hin, dass der sekundäre Knoten Schwierigkeiten mit der Replikation hat. Das kann sich auf die Latenzzeit deines Vorgangs auswirken, da es sich um Lese-/Schreibvorgänge handelt.

Replikationsspielraum

Diese Kennzahl bezieht sich auf die Differenz zwischen dem Oplog-Fenster der primären Replikation und der Replikationsverzögerung der sekundären. Wenn dieser Wert auf Null sinkt, kann dies dazu führen, dass die Sekundärreplikation in den RECOVERING-Modus geht.

Opcounters -repl

Opcounters -repl ist definiert als die durchschnittliche Rate der Replikationsvorgänge, die pro Sekunde für den gewählten Stichprobenzeitraum ausgeführt werden. Mit opcounters -graph/metric kannst du dir die Geschwindigkeit der Operationen und die Aufschlüsselung der Operationstypen für die angegebene Instanz ansehen.

Oplog GB/Stunde

Dies ist die durchschnittliche Anzahl der Gigabytes an Oplog, die die Primärinstanz pro Stunde erzeugt. Unerwartet hohe Oplog-Mengen können auf eine unzureichende Schreiblast oder ein Problem beim Schema-Design hinweisen.

MongoDB Tools zur Leistungsüberwachung

MongoDB verfügt über integrierte Benutzeroberflächen-Tools im Cloud Manager, Atlas und Ops Manager zur Leistungsüberwachung. Darüber hinaus gibt es einige unabhängige Befehle und Tools, mit denen du dir die Rohdaten ansehen kannst. Wir stellen dir einige Tools vor, die du von einem Host aus ausführen kannst, der Zugriff und die entsprechenden Rollen hat, um deine Umgebung zu überprüfen:

mongotop

Mit diesem Befehl kannst du verfolgen, wie viel Zeit eine MongoDB-Instanz mit dem Schreiben und Lesen von Daten pro Collection verbringt. Verwende die folgende Syntax:

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

rs.status()

Dieser Befehl gibt den Status des Replikatsets zurück. Er wird aus der Sicht des Mitglieds ausgeführt, in dem die Methode ausgeführt wird.

mongostat

Mit dem Befehl mongostat kannst du dir einen schnellen Überblick über den Status deiner MongoDB-Serverinstanz verschaffen. Für eine optimale Ausgabe kannst du damit eine einzelne Instanz auf ein bestimmtes Ereignis hin überwachen, da es eine Echtzeitansicht bietet.

Mit diesem Befehl kannst du grundlegende Serverstatistiken wie Warteschlangen für Sperren, Aufschlüsselung von Operationen, MongoDB-Speicherstatistiken und Verbindungen/Netzwerke überwachen:

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

dbStats

Dieser Befehl liefert Speicherstatistiken für eine bestimmte Datenbank, z. B. die Anzahl der Indizes und ihre Größe, die Gesamtdaten der Sammlung im Vergleich zur Speichergröße und sammlungsbezogene Statistiken (Anzahl der Sammlungen und Dokumente).

db.serverStatus()

Mit dem Befehl db.serverStatus() kannst du dir einen Überblick über den Zustand der Datenbank verschaffen. Du erhältst ein Dokument mit den aktuellen Zählern der Instanzmetrik. Führe diesen Befehl in regelmäßigen Abständen aus, um Statistiken über die Instanz zusammenzustellen.

collStats

Der Befehl collStats sammelt Statistiken, die denen von dbStats auf der Ebene der Sammlung ähneln. Die Ausgabe besteht aus der Anzahl der Objekte in der Sammlung, dem von der Sammlung belegten Speicherplatz, der Größe der Sammlung und Informationen zu den Indizes für eine bestimmte Sammlung.

Mit all diesen Befehlen kannst du Echtzeitberichte und -überwachungen des Datenbankservers erstellen, mit denen du die Leistung und Fehler der Datenbank überwachen und fundierte Entscheidungen zur Verbesserung der Datenbank treffen kannst.

So löschst du eine MongoDB-Datenbank

Um eine in MongoDB erstellte Datenbank zu löschen, musst du dich über das Schlüsselwort use mit ihr verbinden.

Angenommen, du hast eine Datenbank mit dem Namen „Engineers“ erstellt. Um dich mit der Datenbank zu verbinden, verwendest du den folgenden Befehl:

use Engineers

Als Nächstes gibst du db.dropDatabase() ein, um diese Datenbank zu löschen. Nach der Ausführung kannst du das folgende Ergebnis erwarten:

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

Du kannst den Befehl showdbs ausführen, um zu überprüfen, ob die Datenbank noch existiert.

Zusammenfassung

Um das Beste aus MongoDB herauszuholen, musst du die Grundlagen gut verstehen. Deshalb ist es wichtig, dass du MongoDB-Datenbanken wie deine Westentasche kennst. Dazu musst du dich zunächst mit den Methoden zur Erstellung einer Datenbank vertraut machen.
Du suchst eine Datenbank, die hohe Flexibilität und Skalierbarkeit bietet? 🛠 MongoDB könnte die Antwort sein... 👀Klicken, um zu twittern
In diesem Artikel beleuchten wir die verschiedenen Methoden, mit denen du eine Datenbank in MongoDB erstellen kannst, und beschreiben anschließend einige raffinierte MongoDB-Befehle, mit denen du den Überblick über deine Datenbanken behältst. Abschließend gehen wir darauf ein, wie du eingebettete Dokumente und Tools zur Leistungsüberwachung in MongoDB nutzen kannst, um sicherzustellen, dass deine Arbeitsabläufe mit höchster Effizienz funktionieren.

Was hältst du von diesen MongoDB-Befehlen? Haben wir einen Aspekt oder eine Methode ausgelassen, die du hier gerne gesehen hättest? Lass es uns in den Kommentaren wissen!


Spare Zeit, Kosten und maximiere die Leistung deiner Seite mit:

  • Schnelle Hilfe von WordPress Hosting Experten, 24/7.
  • Cloudflare Enterprise Integration.
  • Globale Reichweite mit 35 Rechenzentren weltweit.
  • Optimierung mit unserem integrierten Application Performance Monitoring.

All das und noch viel mehr, in einem Plan ohne langfristige Verträge, betreute Migrationen und eine 30-Tage-Geld-zurück-Garantie. Schau Dir hier unsere Pakete an oder sprich mit dem Vertrieb, um den richtigen Tarif für dich zu finden.