So installierst und verwendest du die NoSQL-Datenbank MongoDB auf Rocky Linux 9

MongoDB ist ein quelloffenes, plattformübergreifendes und verteiltes NoSQL (Non-SQL oder Non-Relational) Datenbanksystem. Anstatt Daten wie herkömmliche SQL-Datenbanken in Tabellen zu speichern, verwendet MongoDB flexible Dokumente, um verschiedene Datenformen zu speichern. MongoDB verwendet zum Speichern von Daten das BSON-Format, also das binäre JSON-Format.

MongoDB ist eine verteilte NoSQL-Datenbank mit eingebauter Hochverfügbarkeit, automatischer Ausfallsicherung und Datenredundanz, horizontaler Skalierung durch Sharding über verteilte Cluster hinweg und unterstützt den geografischen Einsatz in mehreren Regionen. MongoDB bietet außerdem eine Abfrage-API, die CRUD-Operationen (Lesen und Schreiben), eine Datenaggregations-Pipeline, eine Textsuche und Geodatenabfragen unterstützt.

Einige namhafte Unternehmen, die MongoDB nutzen, sind Forbes, Toyota, SEGA, EA, Vodafone, Verizon und viele mehr.

In diesem Lernprogramm installierst du die NoSQL-Datenbank MongoDB auf dem Server Rocky Linux 9. Außerdem lernst du, wie du ein Linux-System für den Einsatz von MongoDB Server optimierst. Am Ende dieses Tutoriums lernst du außerdem die grundlegenden Abfragen des MongoDB-Datenbank-Servers kennen.

Wenn du diese Anleitung abschließt, hast du MongoDB installiert und kennst die grundlegenden MongoDB-Operationen, wie z. B. die Verwaltung von Benutzern, das Erstellen von Datenbanken, das Einfügen und Abrufen von Daten aus MongoDB, das Aktualisieren von Daten in MongoDB und das Entfernen von Daten vom MongoDB-Server.

Voraussetzungen

Um dieses Lernprogramm zu absolvieren, musst du die folgenden Voraussetzungen erfüllen:

• Einen Rocky Linux 9 Server – In diesem Beispiel wird ein Rocky Linux mit dem Hostnamen„mongodb-rocky“ verwendet.
• Einen Nicht-Root-Benutzer mit sudo/root-Administrator-Rechten.

Wenn dein Rocky Linux bereit ist, kannst du beginnen.

Hinzufügen des MongoDB-Repositorys

MongoDB ist nur über das offizielle MongoDB-Repository verfügbar. Um es zu installieren, musst du das MongoDB-Repository zu deinem System hinzufügen. Zum Zeitpunkt der Erstellung dieser Anleitung ist die neueste Version von MongoDB v6.0, die du für den Rest dieser Anleitung verwenden wirst.

Im ersten Schritt fügst du das offizielle MongoDB-Repository zu deinem Rocky Linux-System hinzu.

Dazu erstellst du eine neue Repository-Datei„/etc/yum.repos.d/mongodb-org-6.0.repo“ mit dem unten stehenden nano-Editor-Befehl.

sudo nano /etc/yum.repos.d/mongodb-org-6.0.repo

Füge die folgenden Zeilen des MongoDB 6.0-Repositorys in die Datei ein.

[mongodb-org-6.0]
name=MongoDB Repository
baseurl=https://repo.mongodb.org/yum/redhat/$releasever/mongodb-org/6.0/x86_64/
gpgcheck=1
enabled=1
gpgkey=https://www.mongodb.org/static/pgp/server-6.0.asc

Speichere die Datei und beende den Editor, wenn du fertig bist.

Führe nun den unten stehenden dnf-Befehl aus, um die Liste der Repositories auf deinem Rocky Linux-System zu überprüfen.

sudo dnf repolist

Du wirst eine Ausgabe wie diese erhalten – Das MongoDB 6.0 Repository wurde dem Rocky Linux System hinzugefügt.

Nachdem das MongoDB-Repository zu deinem System hinzugefügt wurde, startest du als Nächstes die MongoDB-Installation.

Installation von MongoDB Server und Mongosh

In diesem Schritt installierst du den MongoDB Server auf dem Rocky Linux Server. Dann startest du den MongoDB-Dienst und aktivierst ihn, damit er beim Hochfahren automatisch ausgeführt wird.

Führe den folgenden dnf-Befehl aus, um die MongoDB-Pakete zu installieren. Das Paket„mongodb-org“ ist das Hauptpaket des MongoDB-Servers und das Paket„mongodb-mongosh“ ist die neue Version des MongoDB-Clients, eine Alternative zum Client„mongo„.

sudo dnf install mongodb-org mongodb-mongosh

Wenn du dazu aufgefordert wirst, gib y ein, um zu bestätigen, und drücke ENTER, um fortzufahren.

Außerdem wirst du aufgefordert, den GPG-Schlüssel von MongoDB zu akzeptieren. Gib y ein und drücke ENTER, um zu bestätigen.

Nach der Installation des MongoDB-Servers führst du den folgenden systemctl-Befehl aus, um den MongoDB-Dienst zu starten und zu überprüfen, ob der Dienst läuft.

sudo systemctl start mongod
sudo systemctl status mongod

Du solltest eine Ausgabe wie im folgenden Screenshot erhalten – Der MongoDB-Dienst läuft und ist aktiviert. Der MongoDB-Dienst wird beim Hochfahren automatisch ausgeführt.

Jetzt, wo der MongoDB-Server läuft, wirst du im nächsten Schritt dein Rocky-Linux-System für den MongoDB-Einsatz einrichten und optimieren.

System einrichten

In diesem Schritt richtest du deinen Rocky Linux-Server ein und optimierst ihn für den MongoDB-Einsatz. Dazu gehören die Deaktivierung von Transparent Huge Pages (THP), die Erhöhung des ulimit und die Erhöhung des maximalen virtuellen Speichers über die Datei sysctl.conf.

Du kannst verschiedene Methoden verwenden, um Transparent Huge Pages (THP) zu deaktivieren. In dieser Anleitung wirst du THP dauerhaft über den systemd-Dienst deaktivieren.

Erstelle eine neue systemd-Dienstdatei „/etc/systemd/system/disable-thp.service“ mit dem unten stehenden nano-Editor-Befehl.

sudo nano /etc/systemd/system/disable-thp.service
Füge die folgenden Zeilen in die Datei ein.

[Unit]
Description=Disable Transparent Huge Pages (THP)
[Service]
Type=simple
ExecStart=/bin/sh -c "echo 'never' > /sys/kernel/mm/transparent_hugepage/enabled && echo 'never' > /sys/kernel/mm/transparent_hugepage/defrag"

[Install]
WantedBy=multi-user.target

Speichere die Datei und beende den Editor.

Als Nächstes führst du den systemctl-Befehl aus, um den systemd-Manager neu zu laden und eine neue Dienstdatei anzuwenden.

sudo systemctl daemon-reload

Starte und aktiviere anschließend den systemd-Dienst„disable-thp“ mit dem unten stehenden systemctl-Befehl.

sudo systemctl enable disable-thp
sudo systemctl start disable-thp

Wenn der Dienst„disable-thp“ aktiviert ist, werden die Transparent Huge Pages (THP) bei jedem Systemstart automatisch deaktiviert.

Als Nächstes erhöhst du das ulimit auf deinem System für den MongoDB-Einsatz. Das Standard-Ulimit für ein allgemeines Linux-System ist„1024„, und MongoDB benötigt mindestens„64000„.

Um das Ulimit zu ändern, erstelle eine neue Konfigurationsdatei „/etc/security/limits.d/mongodb.conf“ mit dem unten stehenden nano-Editor-Befehl.

sudo nano /etc/security/limits.d/mongodb.conf

Füge die folgenden Zeilen in die Datei ein. Mit diesen Zeilen richtest du Ulimit für den Benutzer„mongod“ ein, den Standardbenutzer, der den MongoDB-Server betreibt.

mongod soft nproc 64000
mongod hard nproc 64000
mongod soft nofile 64000
mongod hard nofile 64000

Speichere die Datei und beende den Editor, wenn du fertig bist.

Nachdem du ulimit konfiguriert hast, kannst du den maximalen virtuellen Speicher deines MongoDB-Servers über die Datei „/etc/sysctl.conf“ erhöhen.

Öffne die Konfigurationsdatei„/etc/sysctl.conf“ mit dem unten stehenden Editor-Befehl nano.

sudo nano /etc/sysctl.conf

Füge die folgenden Zeilen in die Datei ein.

fs.file-max = 2097152
vm.max_map_count = 262144
vm.swappiness = 1

Speichere die Datei und beende den Editor.

Führe abschließend den unten stehenden Befehl aus, um dein Rocky-Linux-System neu zu starten und die Systemänderungen zu übernehmen, die du vorgenommen hast.

sudo reboot

Damit sollte dein MongoDB-Server jetzt mit deaktiviertem THP, ulimit‚64000‚ für MongoDB-Benutzer und dem maximalen virtuellen Speicher‚262144‚ laufen. Im nächsten Schritt richtest du den MongoDB-Admin-Benutzer ein und lernst dann die Grundlagen des MongoDB-Betriebs kennen.

Admin für MongoDB einrichten

Jetzt hast du MongoDB auf dem optimierten Rocky Linux Server laufen. In diesem Schritt sicherst du deinen MongoDB-Einsatz, indem du einen neuen Admin-Benutzer anlegst und die Authentifizierung und Autorisierung auf dem MongoDB-Server aktivierst.

Melde dich zunächst mit dem unten stehenden Befehl„mongosh“ am MongoDB-Server an.

mongosh

Führe nun die folgende Abfrage aus, um die MongoDB-Überwachung zu deaktivieren, die bei der Standard-MongoDB-Installation aktiviert ist.

db.disableFreeMonitoring()

Wechsle dann mit der unten stehenden Abfrage zur Standarddatenbank„admin„.

use admin

Erstelle nun einen neuen MongoDB-Admin-Benutzer mit der folgenden MongoDB-Abfrage. Achte darauf, dass du den Benutzernamen in der Abfrage änderst.

In diesem Beispiel wird ein neuer Admin-Benutzer„myAliceAdmin“ erstellt. Mit der Abfrage„passwordPrompt()“ legst du das Passwort per Eingabeaufforderung fest, anstatt den Klartext in der Abfrage zu verwenden.

db.createUser(
  {
    user: "myAliceAdmin",
    pwd: passwordPrompt(),
    roles: [
      { role: "userAdminAnyDatabase", db: "admin" },
      { role: "readWriteAnyDatabase", db: "admin" }
    ]
  }
)

Wenn der neue Benutzer erstellt ist, erhältst du eine Ausgabe wie „{ ok: 1 }‚.

Drücke nun Strg+d oder gib„quit“ ein, um die MongoDB-Shell zu verlassen.

Als Nächstes öffnest du die MongoDB-Konfigurationsdatei„/etc/mongod.conf“ mit dem unten stehenden Befehl nano editor.

sudo nano /etc/mongod.conf

Entferne den Kommentar zum Parameter„security“ und füge die Zeile„authorization: enabled“ hinzu, um die MongoDB-Authentifizierung und -Autorisierung zu aktivieren.

security:
    authorization: enabled

Speichere die Datei und beende den Editor, wenn du fertig bist.

Führe abschließend den folgenden systemctl-Befehl aus, um den MongoDB-Dienst neu zu starten und die Änderungen zu übernehmen.

sudo systemctl restart mongod

Jetzt ist der MongoDB-Admin-Benutzer erstellt und die Autorisierung und Authentifizierung auf dem MongoDB-Server aktiviert. Als Nächstes überprüfst du die Benutzerauthentifizierung mit zwei verschiedenen Methoden.

Melde dich mit dem unten stehenden Befehl„mongosh“ in der MongoDB-Shell an.

mongosh

Nach dem Einloggen führst du die folgende Abfrage aus, um dich als MongoDB-Admin„myAliceAdmin“ zu authentifizieren. Wenn du zur Eingabe des Passworts aufgefordert wirst, gibst du dein MongoDB-Admin-Passwort ein.

use admin
db.auth("myAliceAdmin", passwordPrompt())

Wenn die Authentifizierung erfolgreich ist, solltest du eine Ausgabe wie„{ ok: 1 }‚.

Eine andere Methode, um dich bei der MongoDB-Shell anzumelden und dich zu authentifizieren, ist der unten stehende Befehl mongosh. Gib dein Passwort ein, wenn du dazu aufgefordert wirst.

Mit diesem Befehl stellst du eine Verbindung zum MongoDB-Server her, der auf Port 27017 läuft, und authentifizierst dich bei der Datenbank„admin“ mit dem Benutzernamen„myAliceAdmin„.

mongosh --port 27017 --authenticationDatabase \
    "admin" -u "myAliceAdmin" -p

Wenn die Authentifizierung erfolgreich war, solltest du in der MongoDB-Shell angemeldet sein.

Dein MongoDB-Server ist jetzt mit einer Benutzer- und Passwortauthentifizierung gesichert. Außerdem hast du einen Administrator-Benutzer für MongoDB erstellt. Als Nächstes erfährst du, wie du einen neuen MongoDB-Benutzer anlegst, den du für deine Anwendungen verwenden kannst.

Benutzer und Datenbank in MongoDB anlegen

In diesem Schritt erstellst du einen neuen MongoDB-Benutzer, den du für deine Anwendungen verwenden kannst. Außerdem überprüfst du die Liste der Benutzer auf dem MongoDB-Server und meldest dich dann mit deinem neuen MongoDB-Benutzer in der MongoDB-Shell an.

Bevor du beginnst, stelle sicher, dass du dich in der MongoDB-Shell angemeldet hast. Dann führst du den folgenden Befehl aus, um zur neuen Datenbank „testdb“ zu wechseln und einen neuen MongoDB-Benutzer anzulegen.

In diesem Beispiel erstellst du einen neuen MongoDB-Benutzer„myTestUser“ mit der Rolle„readWrite“ für die Datenbank„testdb“ und der Rolle„read„-only für die Datenbank„reporting„.

use tesdb
db.createUser(
  {
    user: "myTestUser",
    pwd:  passwordPrompt(),   // or cleartext password
    roles: [ { role: "readWrite", db: "testdb" },
             { role: "read", db: "reporting" } ]
  }
)

Wenn du dazu aufgefordert wirst, gibst du das neue Passwort für den neuen Benutzer „myTestUser“ ein. Du solltest dann die Ausgabe„{ ok: 1 }„, was bedeutet, dass der neue Benutzer„myTestUser“ erstellt ist.

Als Nächstes wechselst du zur Datenbank „admin“ und führst die folgende Abfrage aus, um die Liste der Benutzer auf deinem MongoDB-Server zu überprüfen.

use admin
db.system.users.find()

Du wirst eine ähnliche Ausgabe sehen wie diese – Der neue Benutzer„myTestUser“ wurde mit der Rolle„readWrite“ für die Datenbank„testdb“ und der Rolle„read“ für die Datenbank reporting erstellt.

Drücke jetzt Strg+d, um die MongoDB-Shell zu verlassen.

Um sicherzustellen, dass der MongoDB-Benutzer„myTestUser“ erstellt wird, meldest du dich jetzt über„myTestUser“ bei der MongoDB an.

Führe den folgenden Befehl aus, um dich mit dem Benutzer„myTestUser“ bei der MongoDB anzumelden. Wenn du zur Eingabe deines Passworts aufgefordert wirst, gibst du dein Passwort ein.

mongosh --port 27017 -u "myTestUser" \
    --authenticationDatabase "testdb" -p

Nachdem du dich eingeloggt hast, führe die folgende MongoDB-Abfrage aus, um deine aktuelle Verbindung zu überprüfen.

db.runCommand({connectionStatus : 1})

Du erhältst eine Ausgabe ähnlich wie in diesem Screenshot – Du hast dich nun mit dem Benutzer„myTestUser“ mit dem MongoDB-Server verbunden und authentifiziert.

Nachdem du einen neuen MongoDB-Benutzer erstellt hast, lernst du nun, wie du Daten in MongoDB einfügen und abfragen kannst.

Einfügen und Abfragen von Daten in MongoDB

Nachdem du einen neuen MongoDB-Benutzer angelegt hast, erfährst du nun, wie du die Datenbank erstellst, Daten einfügst und Daten aus MongoDB abrufst. Du lernst, wie du mit den Abfragen„insertOne“ und„insertMany“ Daten zu MongoDB hinzufügst und Abfrageoperatoren wie„$in“ und„$gte“ mit der Abfrage„find“ verwendest, um Daten aus MongoDB abzurufen.

Vergewissere dich zunächst, dass du dich mit deinem neuen Benutzer, in diesem Beispiel„myTestUser„, beim MongoDB-Server angemeldet hast. Wechsle dann mit der unten stehenden„use„-Abfrage zur Datenbank„testdb„.

use testdb

Jetzt wird deine MongoDB-Shell zu„testdb>“.

Als Nächstes führst du die unten stehende Abfrage aus, um eine neue Sammlung zu erstellen und neue Daten in diese einzufügen. In diesem Beispiel erstellst du eine neue Sammlung„movies“ und fügst neue Daten mit der Abfrage„insertOne“ ein, mit der du nur eine einzige Datei in eine Sammlung einfügen kannst.

db.movies.insertOne(
  {
    title: "The Hobbit",
    genres: [ "Adventure", "Fantasy" ],
    runtime: 172,
    rated: "R",
    year: 2012,
    directors: [ "Peter Jackson" ],
    cast: [ "Martin Freeman", "Ian McKellen", "Richard Armitage" ],
    type: "movie"
  }
)

Du erhältst nun eine Ausgabe wie„acknowledged: ok„, was bedeutet, dass die neuen Daten hinzugefügt wurden und die neue Sammlung erstellt wurde.

Führe nun die folgende Abfrage aus, um die Liste der Sammlungen in der Datenbank„testdb“ zu überprüfen und die verfügbaren Daten in der „testdb“ anzuzeigen.

Die Abfrage „show collection“ zeigt dir die Liste der Sammlungen/Tabellen in der aktuellen Datenbank, und die Abfrage„find“ zeigt die verfügbaren Daten in deiner Datenbank. Mit der Abfrage„find“ kannst du auch bestimmte Felder filtern.

show collections
db.movies.find( {} )

Du solltest eine Ausgabe wie diese erhalten – Die Sammlung„movies“ ist in der Datenbank„testdb“ verfügbar. Außerdem siehst du die neuen Daten, die du hinzugefügt hast, nämlich

Als Nächstes kannst du mit der Abfrage„insertMany“ auch mehrere Daten auf einmal hinzufügen. Führe die folgende Abfrage aus, um zwei Daten über die Abfrage„insertMany“ in die Sammlung„movies“ einzufügen.

db.movies.insertMany([
   {
      title: "The Lord of the Rings",
      genres: [ "Action", "Adventure", "Drama" ],
      runtime: 240,
      rated: "PG-13",
      year: 2001,
      directors: [ "Peter Jackson" ],
      cast: [ "Elijah Wood", "Ian McKellen", "Orlando Bloom" ],
      type: "movie"
    },
    {
      title: "Harry Potter",
      genres: [ "Adventure", "Family", "Fantasy" ],
      runtime: 140,
      rated: "R",
      year: 2007,
      directors: [ "David Yates" ],
      cast: [ "Daniel Radcliffe", "Emma Watson", "Rupert Grint" ],
      type: "movie"
    }
])

Ausgabe:

Führe nun die folgende„find„-Abfrage aus, um deine Daten abzurufen. Damit erhältst du die Daten mit dem Filter„directors: „Peter Jackson“‚.

db.movies.find( { directors: "Peter Jackson" })

Du erhältst eine Ausgabe wie diese – Alle Filme mit„directors:„Peter Jackson“ werden auf deinem Terminal angezeigt.

Als Nächstes kannst du in derSuchabfrage mit Hilfe von Abfrageoperatoren auch Bedingungen angeben.

Führe die folgende Abfrage aus, um alle Daten abzurufen, bei denen das„Genre„„Action“ und/oder„Familie“ ist. Der Operator „$in“ kann verwendet werden, um Daten abzurufen, die mit einem der in einem Array angegebenen Werte übereinstimmen.

db.movies.find( { genres: { $in: [ "Action", "Family" ] } } )

Du solltest jetzt eine Ausgabe wie diese erhalten:

Ein weiterer Abfrageoperator, den du ausprobieren kannst, ist„$gte„, mit dem du Daten abrufen kannst, die größer oder gleich einem bestimmten Wert sind.

Führe zunächst die folgende Abfrage aus, um neue Daten in die Sammlung„Filme“ einzufügen.

db.movies.insertOne(
  {
    title: "Transformers",
    genres: [ "Adventure", "Action", "Sci-Fi" ],
    runtime: 150,
    rated: "PG-13",
    year: 2007,
    directors: [ "Michael Bay" ],
    cast: [ "Shia LaBeouf", "Megan Fox", "Josh Duhamel" ],
    type: "movie"
  }
)

Führe nun die folgende Abfrage aus, um Daten mit dem Abfrageoperator„$gte“ abzurufen. Dies wird alle Filme mit demGenre„Action“ abrufen, die nach oder gleich 2001 veröffentlicht wurden.

db.movies.find( { genres: "Action", "year": { $gte: 2001 } } )

Du erhältst eine ähnliche Ausgabe wie diese – in diesem Beispiel erhältst du zwei Filme mit dem Genre„Action„, die nach oder gleich 2001 veröffentlicht wurden, nämlich„Der Herr der Ringe“ und„Transformers„.

Damit hast du nun gelernt, wie du Daten in MongoDB einfügst und abrufst. Du hast die grundlegende Abfrage „insertOne“ zum Hinzufügen einzelner Daten und die Abfrage „insertMany“ zum gleichzeitigen Hinzufügen mehrerer Daten gelernt.

Außerdem hast du die grundlegende Verwendung der Abfrage „find“ zum Abrufen von Daten aus MongoDB gelernt. Außerdem hast du gelernt, wie du die Operator-Abfragen„$in“ und„$gte“ in MongoDB verwendest.

Im nächsten Schritt erfährst du, wie du Daten in MongoDB-Sammlungen aktualisieren kannst.

Daten in MongoDB aktualisieren

In diesem Schritt lernst du, wie du Daten in MongoDB aktualisieren kannst, indem du zwei Abfragen verwendest: „updateOne“, um ein Feld im Dokument zu aktualisieren, und „replaceOne“, um die zuerst gefundenen Daten durch neue Daten zu ersetzen.

Um Daten in MongoDB zu aktualisieren, kannst du mehrere Methoden und Abfragen verwenden. In diesem Beispiel lernst du, wie du die Abfragen„updateOne“ und„replaceOne“ verwendest. Mit der Abfrage„updateOne“ kannst du ein einzelnes Feld im Dokument aktualisieren, während„replaceOne“ das gesamte Dokument ersetzt.

Führe die folgende Abfrage aus, um Daten mit der Abfrage„updateOne“ zu aktualisieren. In diesem Beispiel aktualisierst du das Feld „rated:„PG-13„“ auf „rated:„R„“ für den Film„Transformers„.

db.movies.updateOne( { title: "Transformers" },
{
  $set: {
    rated: "R"
  }
})

Du solltest eine Ausgabe wie„matchedCount: 1“ und„modifiedCount: 1‚.

Überprüfe nun die neuen Daten mit der folgenden Abfrage. Du solltest sehen, dass die Daten für den Film„Transformers“ aktualisiert wurden.

db.movies.find( { title: "Transformers" })

Als Nächstes führst du die folgende„replaceOne„-Abfrage aus, um die ersten übereinstimmenden Daten im Filter zu ersetzen und das gesamte Dokument durch die neuen Daten zu ersetzen. In diesem Beispiel ersetzt du das gesamte Dokument zum Film„Transformers“ durch die neuen Daten.

db.movies.replaceOne(
  { title: "Transformers" },
  {
    title: "Transformers: Dark of the Moon",
    genres: [ "Adventure", "Action", "Sci-Fi" ],
    runtime: 160,
    rated: "PG-13",
    year: 2011,
    directors: [ "Michael Bay" ],
    cast: [ "Shia LaBeouf", "Rosie Huntington-Whiteley", "Tyrese Gibson" ],
    type: "movie"
  }
)

Du solltest jetzt eine Ausgabe wie diese erhalten.

Führe nun die folgende Abfrage aus, um die neu aktualisierten Daten in deiner MongoDB zu überprüfen.

db.movies.find( { title: "Transformers" })
db.movies.find( { title: "Transformers: Dark of the Moon" })

Du solltest eine ähnliche Ausgabe erhalten wie diese – Der Film „Transformers“ wurde entfernt/durch den neuen Film„Transformers: Dark of the Moon‚ ersetzt.

Daten in MongoDB löschen

In diesem Schritt lernst du, wie du Daten in einem MongoDB-Dokument löschen kannst. Anschließend erfährst du, wie du die Datenbank und den Benutzer in MongoDB löschen kannst.

Führe den folgenden Befehl aus, um Daten aus der MongoDB-Sammlung zu löschen. In diesem Beispiel löschst du das gesamte Dokument„Transformers: Dark of the Moon“ über die Abfrage„deleteMany„.

db.movies.deleteMany( { title: "Transformers: Dark of the Moon" } )
db.movies.find( { title: "Transformers: Dark of the Moon" })

Du solltest eine Ausgabe wie„deletedCount“ erhalten:1‚.

Als Nächstes führst du den folgenden Befehl aus, um ein einzelnes Dokument mit der Abfrage„deleteOne“ zu löschen. Damit werden die ersten übereinstimmenden Daten innerhalb des Filters gelöscht.

In diesem Beispiel löschst du das erste Dokument, das mit„Besetzung“ übereinstimmt:„Ian McKellen“ übereinstimmt.

db.movies.deleteOne( { cast: "Ian McKellen" } )
db.movies.find( { cast: "Ian McKellen" })

Nachfolgend siehst du die Ausgabe vor und nach dem Löschen der Daten.

Vor dem Löschen – Du solltest zwei Filme mit der„Besetzung:„Ian McKellen„‚.

Nachdem das Dokument entfernt wurde, solltest du nur noch einen Film mit der„Besetzung“ sehen: „Ian McKellen„‚ sehen.

Als Nächstes erfährst du, wie du Benutzer und Datenbanken in MongoDB löschen kannst. Um einen Benutzer in MongoDB zu löschen, musst du die Rolle „root“ für deinen MongoDB-Admin-Benutzer haben.

Führe den folgenden Befehl aus, um dich als MongoDB-Admin-Benutzer„myAliceAdmin“ zu authentifizieren und gib dein Passwort ein.

use admin
db.auth("myAliceAdmin", passwordPrompt())

Nachdem du dich als MongoDB-Admin authentifiziert hast, führe die folgende Abfrage aus, um dem Admin-Benutzer die Rolle„root“ zu geben.

db.grantRolesToUser("myAliceAdmin", ["root"]);

Wechsle nun zur„testdb“ und lösche die Benutzer in der Datenbank„testdb“ mit der unten stehenden Abfrage. Dadurch wird der Benutzer„myTestUser“ aus der MongoDB gelöscht.

use testdb
db.runCommand( { dropAllUsersFromDatabase: 1 } )

Du solltest eine Ausgabe erhalten wie‚{ n:1, ok: 1 }‚.

Als Nächstes führst du die folgende Abfrage aus, um die Datenbank„testdb“ zu löschen/entfernen.

db.dropDatabase()

Du solltest die folgende Ausgabe erhalten: „{ ok: 1, gelöscht: ‚testdb‘ }‚.

Jetzt, wo die„testdb“ und die Benutzer in der Datenbank entfernt sind.

Führe die folgende Abfrage aus, um zur Datenbank„admin“ zu wechseln und die Liste der Datenbanken auf deinem MongoDB-Server zu überprüfen. Du solltest sehen, dass die Datenbank„testdb“ entfernt wurde.

use admin
show dbs

Zuletzt führst du die folgende Abfrage aus, um die Benutzer auf MongoDB anzuzeigen und aufzulisten.

db.system.users.find()

Du solltest eine Ausgabe wie diese erhalten – Die Verwendung„myTestUser“ wurde vom MongoDB-Server entfernt/gelöscht.

Fazit

In dieser Anleitung hast du die neueste Version von MongoDB Server (Community Edition) auf einem Rocky Linux 9 Server installiert. Du hast außerdem gelernt, wie du die Authentifizierung und Autorisierung auf dem MongoDB-Server aktivierst und wie du den Linux-Server für den MongoDB-Einsatz optimierst.

Außerdem hast du die grundlegende Verwendung des Mongosh-Befehls für die Verbindung und Verwaltung des MongoDB-Servers gelernt. Außerdem hast du die grundlegenden MongoDB-Abfragen zum Anlegen von Benutzern, Erstellen von Datenbanken, Einfügen und Abrufen von Daten, Aktualisieren von Daten und Löschen/Entfernen von Daten vom MongoDB-Server gelernt.

Mehr über MongoDB-Abfragen erfährst du in der MongoDB-Dokumentation. Wenn du MongoDB in einer großen Umgebung einsetzen möchtest, kannst du außerdem Sharding aktivieren, um eine horizontale Skalierung des MongoDB-Clusters zu ermöglichen.