Wie man die Leistung von MongoDB überwacht

Der Autor wählte den Open Internet/Free Speech Fund aus, um eine Spende im Rahmen des Write for DOnations-Programms zu erhalten.

Einführung

Die Überwachung ist ein wesentlicher Bestandteil der Datenbankverwaltung, da sie es Ihnen ermöglicht, die Leistung und den Gesundheitszustand Ihrer Datenbank zu verstehen. Durch die Überwachung der Leistung Ihrer Datenbank erhalten Sie ein besseres Verständnis für ihre aktuelle Kapazität, können beobachten, wie sich ihre Arbeitslast im Laufe der Zeit ändert, und vorausschauend planen, um die Datenbank zu skalieren, sobald sie ihre Grenzen erreicht. Sie kann auch dabei helfen, zugrunde liegende Hardwareprobleme oder abnormales Verhalten wie einen unerwarteten Anstieg der Datenbanknutzung zu bemerken. Schließlich kann die Überwachung dazu beitragen, Probleme mit Anwendungen zu diagnostizieren, die die Datenbank verwenden, wie Anfragen von Anwendungen, die Engpässe verursachen.

MongoDB wird mit einer Vielzahl von Tools und Dienstprogrammen geliefert, die Sie verwenden können, um die Leistung Ihrer Datenbank zu beobachten. In diesem Tutorial lernen Sie, wie Sie Datenbankmetriken auf Abruf mithilfe von integrierten Befehlen und Tools überwachen. Sie werden auch mit dem MongoDB-Datenbankprofil vertraut gemacht, das Ihnen dabei helfen kann, schlecht optimierte Abfragen zu erkennen.

Voraussetzungen

Um diesem Tutorial zu folgen, benötigen Sie:

• A server with a regular, non-root user with sudo privileges and a firewall configured with UFW. This tutorial was validated using a server running Ubuntu 20.04, and you can prepare your server by following this initial server setup tutorial for Ubuntu 20.04.
• MongoDB auf Ihrem Server installiert. Um dies einzurichten, folgen Sie unserem Tutorial zu So installieren Sie MongoDB unter Ubuntu 20.04.
• Ihre MongoDB-Instanz auf dem Server ist durch Aktivierung der Authentifizierung und Erstellung eines Administratorkontos gesichert. Um MongoDB auf diese Weise abzusichern, folgen Sie unserem Tutorial zu So sichern Sie MongoDB unter Ubuntu 20.04 ab.
• Vertrautheit mit der Abfrage von MongoDB-Sammlungen und Filtern von Ergebnissen. Um zu lernen, wie man MongoDB-Abfragen verwendet, folgen Sie unserem Leitfaden zu So erstellen Sie Abfragen in MongoDB.

Schritt 1 — Vorbereiten der Testdaten

Um zu erklären, wie Sie die Leistung von MongoDB überwachen können, zeigt dieser Schritt, wie Sie die MongoDB-Shell öffnen, um eine Verbindung zu Ihrer lokal installierten MongoDB-Instanz herzustellen und eine Beispielsammlung darin zu erstellen.

Um die Beispielsammlung zu erstellen, die in dieser Anleitung verwendet wird, verbinden Sie sich als Ihr Administrationsbenutzer zum MongoDB-Shell. Dieses Tutorial folgt den Konventionen des vorherigen MongoDB-Sicherheitstutorials und geht davon aus, dass der Name dieses Administrationsbenutzers AdminSammy ist und seine Authentifizierungsdatenbank admin ist. Stellen Sie sicher, dass Sie diese Details im folgenden Befehl ändern, um Ihre eigene Konfiguration widerzuspiegeln, falls sie sich unterscheidet:

mongo -u AdminSammy -p --authenticationDatabase admin

Geben Sie das während der Installation festgelegte Passwort ein, um Zugriff auf die Shell zu erhalten. Nach Bereitstellung des Passworts sehen Sie das > Promptzeichen.

use database_name

Das Überwachen der Datenbank ist bei kleinen Datensätzen nicht sehr praktisch oder nützlich, da das Datenbanksystem nur einige Datensätze für eine bestimmte Abfrage scannen muss. Um die Leistungsüberwachungsfunktionen von MongoDB zu veranschaulichen, benötigen Sie eine Datenbank mit ausreichend Daten, so dass MongoDB eine signifikante Zeit benötigt, um Abfragen auszuführen.

Zu diesem Zweck beziehen sich die Beispiele in diesem Leitfaden auf eine Beispielkollektion namens accounts, die eine große Anzahl von Dokumenten enthält. Jedes Dokument stellt ein individuelles Bankkonto mit einem zufällig generierten Kontostand dar. Jedes Dokument in der Sammlung wird eine Struktur wie diese haben:

{
    "number": "1000-987321",
    "currency": "USD",
    "balance": 431233431
}

Dieses Beispiel-Dokument enthält folgende Informationen:

• nummer: Dieses Feld stellt die Kontonummer für das jeweilige Konto dar. In dieser Sammlung wird jede Kontonummer einen Präfix von 1000- haben, gefolgt von einem inkrementellen numerischen Identifikator.
• währung: Dieses Feld gibt an, in welcher Währung der Kontostand jedes Kontos gespeichert ist. Der Wert währung jedes Kontos wird entweder USD oder EUR sein.
• saldo: Dies zeigt den Kontostand für jedes gegebene Bankkonto an. In dieser Beispieldatenbank wird das Feld saldo jedes Dokuments einen zufällig generierten Wert haben.

Statt manuell eine große Anzahl von Dokumenten einzufügen, können Sie den folgenden JavaScript-Code ausführen, um gleichzeitig eine Sammlung namens accounts zu erstellen und eine Million solcher Dokumente einzufügen:

for (let i = 1; i <= 1000000; ++i) {
    db.accounts.insertOne({
        "number": "1000-" + i,
        "currency": i > 500000 ? "USD" : "EUR",
        "balance": Math.random() * 100000
    })
}

Dieser Code führt eine Schleife aus, die eine Million Mal hintereinander ausgeführt wird. Jedes Mal, wenn die Schleife durchläuft, wird die Methode insertOne() auf der Kontensammlung ausgeführt, um ein neues Dokument einzufügen. Bei jeder Iteration wird der Methode ein Wert für das Feld number übergeben, der aus dem Präfix 1000- mit dem Wert besteht, der in der Variablen i für diese Iteration gehalten wird. Dies bedeutet, dass beim ersten Durchlauf dieser Schleife der Wert des Felds number auf 1000-1 gesetzt wird; beim letzten Durchlauf wird er auf 1000-1000000 gesetzt.

Die Währung wird immer als USD für Konten mit Nummern größer als 500.000 und als EUR für Konten mit Nummern kleiner als diese dargestellt. Das Feld Balance verwendet die Funktion Math.random(), um eine Zufallszahl zwischen 0 und 1 zu generieren, und multipliziert dann die Zufallszahl mit 100.000, um größere Werte bereitzustellen.

Die Ausgabe informiert Sie über den Erfolg und gibt die ObjectId des zuletzt eingefügten Dokuments zurück:

Output
{
        "acknowledged" : true,
        "insertedId" : ObjectId("61a38a4beedf737ac8e54e82")
}

Sie können überprüfen, ob die Dokumente ordnungsgemäß eingefügt wurden, indem Sie die Methode count() ohne Argumente ausführen, die die Anzahl der Dokumente in der Sammlung zurückgibt:

db.accounts.count()

Output
1000000

In diesem Schritt haben Sie erfolgreich die Liste der Beispiel-Dokumente erstellt, die als Testdaten in diesem Handbuch verwendet werden, um die von MongoDB bereitgestellten Tools zur Leistungsüberwachung zu erklären. Im nächsten Schritt erfahren Sie, wie Sie die grundlegenden Servernutzungsstatistiken überprüfen können.

Schritt 2 — Überprüfung der Servernutzungsstatistiken

MongoDB verfolgt automatisch eine Reihe nützlicher Leistungsstatistiken, und deren regelmäßige Überprüfung ist eine grundlegende Möglichkeit, Ihre Datenbank zu überwachen. Beachten Sie, dass diese Statistiken keinen Echtzeit-Einblick in das Geschehen Ihrer Datenbank bieten, aber sie können nützlich sein, um festzustellen, wie die Datenbank funktioniert und ob es möglicherweise bevorstehende Probleme gibt.

use admin

Output
switched to db admin

db.grantRolesToUser(
"AdminSammy",
[
"clusterMonitor",
{ role : "dbAdmin", db : "test" }
]
)

db.createUser(
{
user: "MonitorSammy",
pwd: passwordPrompt(),
roles: [ { role : "dbAdmin", db : "test" }, "clusterMonitor", "readWriteAnyDatabase" ]
}
)

use test

Output
switched to db test

Beginnen Sie damit, die allgemeinen Datenbankstatistiken zu überprüfen, indem Sie die stats()-Methode ausführen:

db.stats(1024*1024)

Das Argument dieser Methode (1024*1024) ist der Skalierungsfaktor und gibt MongoDB an, die Speicherinformationen in Megabyte zurückzugeben. Wenn Sie dies auslassen, werden die Werte alle in Bytes präsentiert.

Die Methode stats() gibt eine kurze, prägnante Ausgabe mit einigen wichtigen Statistiken zur aktuellen Datenbank zurück:

Output
{
        "db" : "test",
        "collections" : 3,
        "views" : 0,
        "objects" : 1000017,
        "avgObjSize" : 80.8896048767171,
        "dataSize" : 77.14365005493164,
        "storageSize" : 24.109375,
        "indexes" : 4,
        "indexSize" : 9.9765625,
        "totalSize" : 34.0859375,
        "scaleFactor" : 1048576,
        "fsUsedSize" : 4238.12109375,
        "fsTotalSize" : 24635.703125,
        "ok" : 1
}

Diese Ausgabe bietet einen Überblick über die Daten, die diese MongoDB-Instanz speichert. Die folgenden Schlüssel in dieser Ausgabe können besonders nützlich sein:

• Der Schlüssel objects zeigt die Gesamtzahl der Dokumente in der Datenbank an. Sie können dies verwenden, um die Größe der Datenbank und bei längerer Beobachtung ihr Wachstum einzuschätzen.
• avgObjectSize zeigt die durchschnittliche Größe dieser Dokumente an und gibt Aufschluss darüber, ob die Datenbank mit großen und komplexen Dokumenten oder kleinen arbeitet. Dieser Wert wird immer in Bytes angezeigt, unabhängig davon, ob Sie einen Skalierungsfaktor angeben.
• Die Schlüssel collections und indexes geben an, wie viele Sammlungen und Indizes derzeit in der Datenbank definiert sind.
• Der Schlüssel totalSize gibt an, wie viel Speicherplatz die Datenbank auf der Festplatte belegt.

Diese Informationen, die von der Methode stats() zurückgegeben werden, können Ihnen eine Vorstellung davon geben, wie viele Daten derzeit in Ihrer Datenbank gespeichert sind, bieten jedoch keine Einblicke in deren Leistung oder vorhandene Probleme. Dafür ist die weitaus ausführlichere Methode serverStatus() sehr praktisch:

db.serverStatus()

Die Ausgabe dieser Methode ist umfangreich und bietet viele Informationen zur Servernutzung:

Output
{
        "host" : "ubuntu-mongo-rs",
        "version" : "4.4.6",
        "process" : "mongod",
        "pid" : NumberLong(658997),
        "uptime" : 976,
        . . .
        "ok" : 1
}

Obwohl all diese Informationen potenziell nützlich sein könnten, konzentriert sich diese Anleitung insbesondere auf drei Abschnitte. Zuerst finden Sie den Abschnitt connections in dieser Ausgabe:

Output
        . . .
        "connections" : {
                "current" : 4,
                "available" : 51196,
                "totalCreated" : 4,
                "active" : 2,
                "exhaustIsMaster" : 1,
                "exhaustHello" : 0,
                "awaitingTopologyChanges" : 1
        },
        . . .

Jeder Datenbankserver kann nur eine begrenzte Anzahl von Verbindungen gleichzeitig unterstützen. Der current-Schlüssel zeigt die Anzahl der Clients, die derzeit mit der Datenbank verbunden sind, während available die Anzahl der verbleibenden ungenutzten Verbindungen angibt, die die Datenbank zur Verfügung hat. Der Wert totalCreated enthält die Anzahl der Verbindungen, die seit dem Start des Servers verwendet wurden.

Die meisten Anwendungen sind darauf ausgelegt, bestehende Verbindungen wiederzuverwenden und öffnen nicht oft mehrere Verbindungen. Ein hohe Anzahl von Verbindungen kann daher, wenn nicht vorausgesehen, ein alarmierendes Zeichen für eine Fehlkonfiguration darstellen, wie die Clients auf den Server zugreifen.

Wenn die hohe Anzahl von Verbindungen durch die Art der ausgeführten Arbeitslasten vorhersehbar ist, könnte erwogen werden, einem geschachtelten Cluster einen oder mehrere Shards hinzuzufügen, um den Datenverkehr auf mehrere MongoDB-Instanzen zu verteilen.

Als nächstes finden Sie den Abschnitt globalLock in der Ausgabe. Dieser Abschnitt bezieht sich auf globale Sperren auf dem gesamten Datenbankserver:

Output
        . . .
        "globalLock" : {
                "totalTime" : NumberLong(975312000),
                "currentQueue" : {
                        "total" : 0,
                        "readers" : 0,
                        "writers" : 0
                },
                "activeClients" : {
                        "total" : 0,
                        "readers" : 0,
                        "writers" : 0
                }
        },

MongoDB verwendet Sperren, um die Datenkonsistenz bei der Ausführung mehrerer Operationen sicherzustellen und sicherzustellen, dass keine zwei Abfragen gleichzeitig die gleichen Daten ändern. Auf stark genutzten Servern besteht die Möglichkeit, dass Sperren zu Engpässen führen, bei denen eine oder mehrere Abfragen auf das Freigeben der Sperren warten müssen, bevor sie ausgeführt werden können.

Der Wert currentQueue.total zeigt die Anzahl der Abfragen an, die darauf warten, dass die Sperren freigegeben werden, damit sie ausgeführt werden können. Wenn dieser Wert hoch ist, bedeutet dies, dass die Leistung der Datenbank beeinträchtigt wird und Abfragen länger dauern, um abgeschlossen zu werden.

Dies kommt oft von vielen lang laufenden Abfragen, die die Sperren halten, und kann auf eine ineffektive Verwendung von Indizes oder schlecht entworfene Abfragen hinweisen, unter anderen Möglichkeiten.

Zuletzt finden Sie den Abschnitt opcounters:

Output
        "opcounters" : {
                "insert" : NumberLong(10000007),
                "query" : NumberLong(6),
                "update" : NumberLong(6),
                "delete" : NumberLong(0),
                "getmore" : NumberLong(0),
                "command" : NumberLong(1298)
        },

Dieser Abschnitt der Ausgabe von serverStatus() kann Ihnen eine Vorstellung davon vermitteln, ob der Datenbankserver hauptsächlich für Lese- oder Schreibvorgänge verwendet wird oder ob seine Verwendung gut ausbalanciert ist. In diesem Beispiel ist nach dem Einfügen der Testdokumente der Zähler für insert-Operationen viel höher als für query-Operationen. In einem realen Szenario wären diese Werte wahrscheinlich unterschiedlich.

Datenbanken mit vielen Schreibvorgängen können von horizontaler Skalierung durch Sharding profitieren. Ebenso werden leselastige MongoDB-Datenbanken normalerweise von Replikation profitieren.

Diese Statistiken können eine allgemeine Vorstellung davon geben, wie der Server verwendet wird und ob es Leistungsprobleme wie lange Sperrwarteschlangen gibt, wenn sie darauf zugreifen. Sie geben jedoch keine Echtzeitinformationen darüber, wie der Server verwendet wird. Dafür sind die Befehle mongostat und mongotop nützliche Tools.

Schritt 3 — Verwendung von mongostat und mongotop, um Echtzeit-Datenbankstatistiken zu erhalten

Während die Befehle, die verwendet werden, um auf die Serverstatistiken von MongoDB zuzugreifen, Einblicke liefern können, wie der Server rückblickend verwendet wurde, können sie keine Echtzeitinformationen darüber liefern, welche Sammlungen gerade am aktivsten genutzt werden oder welche Art von Abfragen gerade ausgeführt werden.

MongoDB stellt zwei nützliche Systemwerkzeuge für die Echtzeitüberwachung bereit, die die Datenbankaktivität analysieren und die von ihnen bereitgestellten Informationen kontinuierlich aktualisieren: mongostat und mongotop. mongostat bietet einen kurzen Überblick über den aktuellen Status der MongoDB-Instanz, während mongotop verfolgt, wie viel Zeit die Instanz mit Lese- und Schreibvorgängen verbringt. Beide dieser Werkzeuge werden von der Befehlszeile aus ausgeführt, anstatt von der MongoDB-Shell aus.

Um mongostat zu verwenden, behalten Sie Ihre aktuelle MongoDB-Shell-Verbindung bei und öffnen Sie ein weiteres Terminalfenster, um Ihre Server-Shell aufzurufen. In der zweiten Server-Shell führen Sie den Befehl mongostat aus:

mongostat -u AdminSammy --authenticationDatabase admin

Wie bereits erwähnt, erfordert mongostat erweiterte Berechtigungen. Wenn Sie die Authentifizierung in Ihrer MongoDB-Instanz aktiviert und einen Benutzer mit den entsprechenden Rollen eingerichtet haben, müssen Sie sich als dieser Benutzer authentifizieren, indem Sie ihren Benutzernamen und die Authentifizierungsdatenbank angeben (wie in diesem Beispiel gezeigt) und dann ihr Passwort eingeben, wenn Sie dazu aufgefordert werden.

In einer Standardkonfiguration druckt mongostat die Zähler der gerade ausgeführten Abfragen in Ein-Sekunden-Intervallen aus:

Output
insert query update delete getmore command dirty  used flushes vsize  res qrw arw net_in net_out conn                time
    *0    *0     *0     *0       0     1|0  0.0% 38.7%       0 1.54G 210M 0|0 1|0   223b   84.4k    7 Nov 28 15:40:40.621
    *0    *0     *0     *0       0     2|0  0.0% 38.7%       0 1.54G 210M 0|0 1|0   224b   84.8k    7 Nov 28 15:40:41.619
    *0    *0     *0     *0       0     1|0  0.0% 38.7%       0 1.54G 210M 0|0 1|0   223b   84.5k    7 Nov 28 15:40:42.621
    *0    *0     *0     *0       0     3|0  0.0% 38.7%       0 1.54G 210M 0|0 1|0   365b   85.0k    7 Nov 28 15:40:43.619

Wenn die Ausgabe von mongostat einen Wert von 0 für einen bestimmten Abfragetyp anzeigt, deutet dies darauf hin, dass die Datenbank keine Operationen dieses Typs ausführt. Diese Beispiel-Ausgabe zeigt 0 für jeden Abfragetyp an, was bedeutet, dass derzeit keine Abfragen aktiv ausgeführt werden.

Sie sollten immer noch Ihr erstes Terminalfenster geöffnet und mit Ihrer MongoDB-Shell verbunden haben. Fügen Sie einige weitere Testdokumente in die accounts-Sammlung ein und überprüfen Sie, ob mongostat die Aktivität bemerkt:

for (let i = 1; i <= 10000; ++i) {
    db.accounts.insertOne({
        "number": "2000-" + i,
        "currency": "USD",
        "balance": Math.random() * 100000
    })
}

Dies ist eine for-Schleife ähnlich der, die Sie im Schritt 1 ausgeführt haben. Diesmal fügt die Schleife jedoch nur 10000 Einträge ein. Die Kontonummern sind mit 2000 vorangestellt, und die Währung ist immer USD.

Während die neuen Dokumente eingefügt werden, überprüfen Sie die Ausgabe von mongostat:

Output
. . .
    *0    *0     *0     *0       0     1|0  0.0% 38.7%       0 1.54G 210M 0|0 1|0   112b   42.5k    4 Nov 28 15:50:33.294
    *0    *0     *0     *0       0     0|0  0.0% 38.7%       0 1.54G 210M 0|0 1|0   111b   42.2k    4 Nov 28 15:50:34.295
   755    *0     *0     *0       0     1|0  0.1% 38.8%       0 1.54G 210M 0|0 1|0   154k   79.4k    4 Nov 28 15:50:35.294
  2853    *0     *0     *0       0     0|0  0.4% 39.1%       0 1.54G 211M 0|0 1|0   585k    182k    4 Nov 28 15:50:36.295
  2791    *0     *0     *0       0     1|0  0.7% 39.4%       0 1.54G 212M 0|0 1|0   572k    179k    4 Nov 28 15:50:37.293
  2849    *0     *0     *0       0     0|0  1.0% 39.7%       0 1.54G 213M 0|0 1|0   584k    182k    4 Nov 28 15:50:38.296
   745    *0     *0     *0       0     2|0  1.1% 39.8%       0 1.54G 213M 0|0 1|0   153k   79.2k    4 Nov 28 15:50:39.294
    *0    *0     *0     *0       0     0|0  1.1% 39.8%       0 1.54G 213M 0|0 1|0   111b   42.2k    4 Nov 28 15:50:40.295
    *0    *0     *0     *0       0     2|0  1.1% 39.8%       0 1.54G 213M 0|0 1|0   167b   42.7k    4 Nov 28 15:50:41.293
. . .

Während die Abfrage läuft, beginnen die neuen Zeilen, die von mongostat zurückgegeben werden, Werte anzuzeigen, die nicht 0 sind. In der Spalte insert, die die Anzahl der Abfragen anzeigt, die neue Daten in die Datenbank einfügen, waren die Werte für mehrere Sekunden höher. Da mongostat Daten in Ein-Sekunden-Intervallen anzeigt, können Sie nicht nur den Anteil der Einfügungen im Vergleich zu anderen Arten von Datenbankoperationen finden, sondern auch wie schnell die Datenbank die neuen Daten einfügt. In diesem Beispiel erreichte der Server fast 3000 Einfügungen pro Sekunde.

Sie können mongostat verwenden, um die aktuelle Arbeitslast des Datenbankservers nach Abfragetypen zu überwachen. Das zweite Tool, das MongoDB mitliefert — mongotop — zeigt die Aktivität des Datenbankservers nach Sammlungen gruppiert an.

Stoppen Sie mongostat in Ihrem zweiten Terminalfenster, indem Sie CTRL + C drücken. Führen Sie dann mongotop in demselben Terminal aus. Wenn Sie die Authentifizierung aktiviert haben, müssen Sie sich als Benutzer mit entsprechenden Berechtigungen authentifizieren:

mongotop -u AdminSammy --authenticationDatabase admin

mongotop gibt eine Liste aller Sammlungen in der Datenbank aus, begleitet von der Zeit, die für Lese- und Schreibvorgänge sowie insgesamt im Zeitfenster benötigt wird. Ähnlich wie bei mongostat wird die Ausgabe alle Sekunde aktualisiert:

Output
2021-11-28T15:54:42.290+0000    connected to: mongodb://localhost/

                    ns    total    read    write    2021-11-28T15:54:43Z
    admin.system.roles      0ms     0ms      0ms
  admin.system.version      0ms     0ms      0ms
config.system.sessions      0ms     0ms      0ms
   config.transactions      0ms     0ms      0ms
  local.system.replset      0ms     0ms      0ms
         test.accounts      0ms     0ms      0ms

. . .

Versuchen Sie, einige weitere Dokumente in die Datenbank einzufügen, um zu sehen, ob die Aktivität in mongotop registriert wird. Führen Sie in der MongoDB-Shell die folgende for-Schleife aus. Beobachten Sie anschließend das Terminalfenster mit mongotop im Hintergrund:

for (let i = 1; i <= 10000; ++i) {
    db.accounts.insertOne({
        "number": "3000-" + i,
        "currency": "USD",
        "balance": Math.random() * 100000
    })
}

Diesmal wird die Aktivität in den mongotop-Statistiken sichtbar sein.

Output
. . .
                    ns    total    read    write    2021-11-28T15:57:27Z
         test.accounts    127ms     0ms    127ms
  admin.$cmd.aggregate      0ms     0ms      0ms
    admin.system.roles      0ms     0ms      0ms
  admin.system.version      0ms     0ms      0ms
config.system.sessions      0ms     0ms      0ms
   config.transactions      0ms     0ms      0ms
  local.system.replset      0ms     0ms      0ms

                    ns    total    read    write    2021-11-28T15:57:28Z
         test.accounts    130ms     0ms    130ms
  admin.$cmd.aggregate      0ms     0ms      0ms
    admin.system.roles      0ms     0ms      0ms
  admin.system.version      0ms     0ms      0ms
config.system.sessions      0ms     0ms      0ms
   config.transactions      0ms     0ms      0ms
  local.system.replset      0ms     0ms      0ms
. . .

Hier zeigt mongotop, dass alle Datenbankaktivitäten in der accounts-Sammlung in der Datenbank test stattgefunden haben und dass alle Operationen im Zeitfenster Schreiboperationen waren. All dies sollte mit der for-Schleifenoperation übereinstimmen, die Sie ausgeführt haben.

Wie bei mongostat können Sie mongotop stoppen, indem Sie CTRL + C drücken.

Bei Beobachtung während Spitzenlasten können Sie mongotop verwenden, um zu überwachen, wie sich die Datenbankaktivität auf verschiedene Sammlungen verteilt, um Ihr Schema besser zu verstehen und sich auf das Skalieren vorzubereiten. Es bietet auch Einblick, ob die Nutzung einer Sammlung eher lese- oder schreibintensiv ist.

Schritt 4 — Verwenden des Database Profilers von MongoDB zur Identifizierung langsamer Abfragen

Datenbankleistungsengpässe können aus vielen Quellen stammen. Obwohl das Skalieren der Datenbank (entweder horizontal oder vertikal) oft die Lösung für Leistungsengpässe ist, kann die Ursache nicht tatsächlich die Grenzen der Datenbank sein, sondern Probleme mit dem Schema oder dem Abfragendesign.

Wenn Abfragen zu lange dauern, kann die Ursache eine ineffektive Verwendung von Indizes oder Fehler in der Abfrage selbst sein. Lang laufende Abfragen bleiben während der Anwendungsentwicklung oft unbemerkt, normalerweise, weil die Testdatensätze zu klein sind oder die Bedingungen sich von denen in der Produktion unterscheiden.

Sie könnten den Verursacher potenziell finden, indem Sie Testabfragen manuell ausführen und überprüfen, welche unterperformen, obwohl dies sehr mühsam wäre. Glücklicherweise kann das Datenbankprofiler-Tool von MongoDB dies automatisch tun.

Der Datenbankprofiler von MongoDB kann Abfragen und Statistiken zu deren Ausführung protokollieren, wenn sie bestimmte Bedingungen erfüllen. Die wichtigste dieser Bedingungen ist die Ausführungszeit der Abfrage: Wenn eine Abfrage länger als eine festgelegte Zeit dauert, um ausgeführt zu werden, markiert der Profiler diese Abfrage automatisch als problematisch. Mit dem Profiler können Sie identifizieren, welche Abfragen schlecht funktionieren, und sich dann darauf konzentrieren, diese bestimmten Probleme zu beheben.

Bevor Sie den Profiler verwenden, führen Sie die folgende Abfrage aus. Diese Abfrage wird einen der von Ihnen eingefügten Konten abrufen, obwohl es nicht so einfach ist, wie es auf den ersten Blick erscheinen mag:

db.accounts.find({"number": "1000-20"})

Der Befehl wird das genaue Konto abrufen, das Sie angefordert haben:

Output
{ "_id" : ObjectId("61a38fd5eedf737ac8e54e96"), "number" : "1000-20", "currency" : "EUR", "balance" : 24101.14770458518 }

Sie haben möglicherweise bemerkt, dass die Abfrage nicht sofort ausgeführt wurde und MongoDB einen Moment oder zwei gebraucht hat, um das Konto zu finden. In einer realen Anwendung könnten es viele Arten von Abfragen geben, die schlecht funktionieren, und Sie könnten ihre Unterperformance in der Praxis nicht bemerken.

Sie können MongoDB konfigurieren, um Ihnen dabei zu helfen, festzustellen, welche Abfragen länger als erwartet dauern. Um dies zu tun, aktivieren Sie zunächst den Profiler, indem Sie den folgenden Befehl ausführen:

db.setProfilingLevel(1, { slowms: 100 })

Die Methode setProfilingLevel() nimmt zwei Argumente entgegen. Erstens ist dies das Profiling-Level, das entweder 0, 1 oder 2 sein kann:

• 0 deaktiviert den Profiler
• 1 aktiviert den Profiler nur für langsame Abfragen, die die Bedingung erfüllen
• 2 aktiviert den Profiler für alle Abfragen

In diesem Beispiel wird der Profiler Abfragen analysieren, die länger als 100 Millisekunden dauern, wie durch das zweite Argument definiert, { slowms: 100 }.

Diese Methode wird eine Erfolgsmeldung zurückgeben:

Output
{ "was" : 0, "slowms" : 100, "sampleRate" : 1, "ok" : 1 }

Ab sofort wird das Datenbank-Profiling aktiviert sein und MongoDB wird aktiv jede von Ihnen ausgeführte Abfrage überwachen, um solche zu finden, die mehr als 100 Millisekunden zum Abschluss benötigen.

Probieren Sie dies aus, indem Sie einige verschiedene Abfragen ausführen. Zuerst verwenden Sie den count-Befehl, um die Anzahl der Dokumente in der accounts-Kollektion zu finden:

db.accounts.count()

Dieser Befehl wird schnell die Anzahl der Dokumente in der Kollektion zurückgeben:

Output
1020000

Dann versuchen Sie, die ersten drei Bankkonten in der Sammlung zu suchen:

db.accounts.find().limit(3)

Auch hier wird die Datenbank die Ergebnisse schnell zurückgeben:

Output
{ "_id" : ObjectId("61ef40640f2ba52efc56ee17"), "number" : "1000-1", "currency" : "EUR", "balance" : 25393.132960293842 }
{ "_id" : ObjectId("61ef40640f2ba52efc56ee18"), "number" : "1000-2", "currency" : "EUR", "balance" : 63629.42056192393 }
{ "_id" : ObjectId("61ef40640f2ba52efc56ee19"), "number" : "1000-3", "currency" : "EUR", "balance" : 75602.12331602155 }

Zuletzt führen Sie die Suchabfrage für das bestimmte Bankkonto erneut aus:

db.accounts.find({"number": "1000-20"})

Diese Abfrage wird das Ergebnis zurückgeben, aber wie zuvor wird es einen Moment länger dauern als die vorherigen Operationen:

Output
{ "_id" : ObjectId("61a38fd5eedf737ac8e54e96"), "number" : "1000-20", "currency" : "EUR", "balance" : 24101.14770458518 }

Der Profiler gibt keine eigene Ausgabe aus, obwohl die Abfrage sichtbar langsamer war. Stattdessen werden die Details zu langsamen Operationen in einer speziellen Sammlung innerhalb der Datenbank namens system.profile erfasst. Diese Sammlung ist eine begrenzte Sammlung, die niemals 1 MB überschreitet. Das bedeutet, dass sie immer eine Liste nur der neuesten langsamen Abfragen enthält.

Um Informationen zu Abfragen abzurufen, die vom Profiler identifiziert wurden, müssen Sie die Sammlung system.profile auf eine Weise abfragen, wie dies geschieht:

db.system.profile.find().sort({ "ts" : -1 }).pretty()

Diese Abfrage verwendet die Methode find(), wie üblich. Sie enthält auch eine sort-Klausel, die { "ts" : -1 } als Argument enthält. Dies sortiert das Ergebnis mit den neuesten Abfragen zuerst. Schließlich wird die Methode pretty() am Ende die Ausgabe in einem übersichtlicheren Format anzeigen.

Jede langsame Abfrage wird als reguläres Dokument dargestellt, und system.profile ist wie jede reguläre Sammlung. Das bedeutet, dass Sie die Ergebnisse filtern, sortieren und sogar in Aggregationspipelines verwenden können, um die Liste der vom Profiler identifizierten Abfragen weiter einzuschränken oder zu analysieren.

Beachten Sie, dass das Ergebnis nur aus einem einzelnen Dokument besteht. Die beiden anderen Abfragen wurden schnell genug ausgeführt, um den Profiler nicht auszulösen:

Output
{
        "op" : "query",
        "ns" : "test.accounts",
        "command" : {
                "find" : "accounts",
                "filter" : {
                        "number" : "1000-20"
                },
                . . .
        },
        "nreturned" : 1,
        "keysExamined" : 0,
        "docsExamined" : 1030000,
        . . .
        "millis" : 434,
        "planSummary" : "COLLSCAN",
        . . .
}

Diese Ausgabe liefert eine Reihe von Details zur Ausführung der langsamen Abfrage:

• Der Schlüssel op zeigt an, welche Art von Operation diese Informationen darstellen. Hier handelt es sich um eine Abfrage, da sie eine Operation darstellt, bei der Sie die find()-Methode verwendet haben, um Daten aus der Datenbank abzurufen.
• Der Schlüssel ns gibt an, welche Datenbank und Sammlung an der Operation beteiligt waren. Wie aus der Ausgabe hervorgeht, hat diese Operation die Sammlung accounts in der Datenbank test abgefragt.
• Der Schlüssel command liefert weitere Informationen über die Abfrage selbst. In diesem Fall enthält der Unterbefehl filter das gesamte Filterdokument. Mit den Informationen aus den Feldern op und command können Sie die betreffende Abfrage rekonstruieren.
• Im Feld millis finden Sie die genaue Zeit, die benötigt wurde, um die Abfrage abzuschließen. In diesem Beispiel fast eine halbe Sekunde.
• Das Feld docsExamined gibt die Anzahl der gescannten Dokumente zur Rückgabe des Ergebnissatzes an.
• nreturned repräsentiert die Anzahl der Dokumente, die die Abfrage zurückgegeben hat. In diesem Beispiel wurde nur ein einziges Dokument von über einer Million gescannten zurückgegeben.
• Die planSummary zeigt die Methode an, die MongoDB zur Ausführung der Abfrage verwendet hat. COLLSCAN entspricht einem vollständigen Sammlungs-Scan, was bedeutet, dass jedes Dokument in der Sammlung einzeln durchsucht wurde, um das übereinstimmende Bankkonto zu finden.

Alles in allem unterstreicht diese Information die Notwendigkeit eines Index, der MongoDB helfen könnte, diese Abfrage schneller auszuführen. Die Datenbank musste die gesamte Sammlung durchsuchen, um ein einziges Dokument zu finden, wie durch den großen Unterschied zwischen der Anzahl der überprüften und zurückgegebenen Dokumente sowie der Ausführungsstrategie angezeigt.

In diesem speziellen Beispiel würde die Erstellung eines Index zur Unterstützung von Abfragen, die Daten basierend auf dem Feld number filtern, eine sofortige Verbesserung der Leistung dieser Art von Abfragen bieten. In realen Szenarien können die Lösungen für langsame Abfragen unterschiedlich sein und vom genauen Abfrage abhängen, die Probleme verursacht.

Um die Profilierungssitzung abzuschließen, können Sie den Profiler deaktivieren, indem Sie den Profilierungsgrad auf Null setzen:

db.setProfilingLevel(0)

Die Operation wird mit einer Bestätigungsnachricht erfolgreich sein:

Output
{ "was" : 1, "slowms" : 100, "sampleRate" : 1, "ok" : 1 }

Jetzt kehrt die Datenbank zum normalen Betrieb zurück, ohne dass im Hintergrund eine Profilierung stattfindet.

Immer wenn Sie vermuten, dass langsame Abfragen sich negativ auf die Leistung Ihrer Datenbank auswirken könnten, können Sie den Datenbankprofiler verwenden, um sie zu finden und ihre Struktur und Ausführung besser zu verstehen. Mit diesen Informationen sind Sie besser gerüstet, um sie anzupassen und ihre Leistung zu verbessern.

Schlussfolgerung

Indem Sie diesem Leitfaden folgen, haben Sie gelernt, wie Sie die Serverstatistiken von MongoDB finden und diagnostische Tools wie mongotop, mongostat sowie den Profilermechanismus der MongoDB-Datenbank verwenden können. Sie können diese verwenden, um ein besseres Verständnis für die Arbeitslast Ihrer Datenbank zu erhalten, festzustellen, welche Sammlungen am aktivsten sind, und ob der Server hauptsächlich Schreib- oder Lesevorgänge durchführt. Sie können auch langsame Abfragen identifizieren, die die Leistung von MongoDB beeinträchtigen, um sie durch effizientere zu ersetzen.

Dies sind nur eine Auswahl von Tools und Techniken, die Sie verwenden können, um die Gesundheit und Leistung Ihrer MongoDB-Installation zu überwachen und entsprechend zu handeln. Jedes dieser Tools kann weiter konfiguriert und angepasst werden, um Ihnen gezieltere Einblicke in die Serverleistung zu bieten. Wir ermutigen Sie, die offizielle MongoDB-Dokumentation zu studieren, um mehr über Techniken zu erfahren, mit denen Sie die Serverleistung überwachen und entsprechend handeln können.