MongoDB ist eine Open-Source-NoSQL-Datenbank die für ihre Flexibilität und Skalierbarkeit bekannt ist. Im Gegensatz zu relationalen Datenbanken, die Daten in Tabellen speichern, verwendet MongoDB ein dokumentenorientiertes Datenmodell. Dieses Modell ermöglicht es komplexe Datenstrukturen in einem einzigen Dokument zu speichern. Diese Dokumente sind in einer dynamischen und teils schemalosen Struktur organisiert. Dies bietet die Möglichkeit Daten ohne vorherige Definition eines starren Schemas zu speichern und zu manipulieren.

Da MongoDB Open-Source ist, können Entwickler und Organisationen diese kostenlos herunterladen und auf ihrem eigenen Server installieren. Und genau darum geht es in diesem Beitrag

Zum Kapitel springen Voraussetzungen

MongoDB stellt spezifische Anforderungen an die Systemarchitektur und unterstützt keine 32-Bit-x86-Plattformen. Zudem ist die Verfügbarkeit von MongoDB auf 64-Bit ARM-Architekturen eingeschränkt. Das bedeutet, dass die Unterstützung und Leistung auf diesen Plattformen nicht vollumfänglich gewährleistet sein kann. Du musst daher sicherstellen, dass dein System mit diesen Voraussetzungen kompatibel ist um MongoDB installieren zu können.

Um die Architektur unter Linux herauszufinden reicht ein einfacher Befehl in der Kommandozeile:

dpkg --print-architecture

arm64

Die MongoDB 7.0 Community Edition unterstützt anhand der Voraussetzungen die folgenden 64-Bit Ubuntu LTS-Versionen:

22.04 LTS ("Jammy")
20.04 LTS ("Focal")

Um herauszufinden, welche Distribution auf deinem Server läuft, kannst du den folgenden Befehl ausführen:

cat /etc/lsb-release

DISTRIB_ID=Ubuntu
DISTRIB_RELEASE=22.04
DISTRIB_CODENAME=jammy
DISTRIB_DESCRIPTION="Ubuntu 22.04.4 LTS"

Mit den erhaltenen Informationen kann nun identifiziert werden, ob die Architektur für die Installation von MongoDB geeignet ist. Die Daten kannst du aus der folgenden Auflistung entnehmen:

Zum Kapitel springen x86_64

Zum Kapitel springen arm64

Die aktuelle Tabelle findest du hier.

Zum Kapitel springen Installation

Zum Kapitel springen Vorwort

Dieser Beitrag beschreibt die Installation von MongoDB auf einer arm64 Architektur unter Ubuntu 22.04 und basiert auf den Empfehlungen der offiziellen MongoDB-Dokumentation. Wenn du ein anderes Betriebssystem verwendest, ist es wichtig, dass du dich für die Installation an die entsprechende Anleitung in der Dokumentation deines Systems hältst. Im Abschnitt zur Konfiguration spielt das verwendete Betriebssystem für die Zwecke dieses Beitrags keine Rolle. Solltest du MongoDB also selbst anhand einer der verfügbaren Anleitungen installiert haben, kannst du direkt zum Kapitel MongoSH - Die Kommandozeile springen.

Zum Kapitel springen Pakete installieren

Die Pakete gnupg und curl installieren:

sudo apt-get install gnupg curl

Herunterladen des MongoDB Public Keys und Importieren sowie Konvertieren des Schlüssels

curl -fsSL https://www.mongodb.org/static/pgp/server-7.0.asc | \
   sudo gpg -o /usr/share/keyrings/mongodb-server-7.0.gpg \
   --dearmor

Ubuntu 22.04

echo "deb [ arch=amd64,arm64 signed-by=/usr/share/keyrings/mongodb-server-7.0.gpg ] https://repo.mongodb.org/apt/ubuntu jammy/mongodb-org/7.0 multiverse" | sudo tee /etc/apt/sources.list.d/mongodb-org-7.0.list

Ubuntu 20.04

echo "deb [ arch=amd64,arm64 signed-by=/usr/share/keyrings/mongodb-server-7.0.gpg ] https://repo.mongodb.org/apt/ubuntu focal/mongodb-org/7.0 multiverse" | sudo tee /etc/apt/sources.list.d/mongodb-org-7.0.list

Paketliste des Systems aktualisieren:

sudo apt-get update

MongoDB installieren:

sudo apt-get install -y mongodb-org

Zum Kapitel springen Version fixieren

Dieser Schritt ist optional:

Obwohl man jede verfügbare und beliebige Version von MongoDB angeben kann würde apt-get die MongoDB Pakete aktualisieren sobald eine neuere Version verfügbar ist. Um unbeabsichtigte Upgrades zu verhindern, kann man das Paket auf der jetzt installierten Version festlegen und fixieren:

echo "mongodb-org hold" | sudo dpkg --set-selections
echo "mongodb-org-database hold" | sudo dpkg --set-selections
echo "mongodb-org-server hold" | sudo dpkg --set-selections
echo "mongodb-mongosh hold" | sudo dpkg --set-selections
echo "mongodb-org-mongos hold" | sudo dpkg --set-selections
echo "mongodb-org-tools hold" | sudo dpkg --set-selections

Zum Kapitel springen MongoDB Service

Je nach verwendetem System wird ein anderer Dienst für das Starten und Stoppen eines Services verwendet. Welchen Dienst dein System verwendet kannst mit einem Befehl herausfinden:

ps --no-headers -o comm 1

systemd

oder

init 

Je nach Dienst reicht dann der angepasste Befehle um den MongoDB Service zu starten:

sudo systemctl start mongod

sudo systemctl stop mongod

sudo systemctl restart mongod

sudo systemctl status  mongod

● mongod.service - MongoDB Database Server
     Loaded: loaded (/lib/systemd/system/mongod.service; disabled; vendor preset: enabled)
     Active: active (running) since Thu 2024-03-14 08:23:17 CET; 21s ago
       Docs: https://docs.mongodb.org/manual
   Main PID: 4247 (mongod)
     Memory: 71.8M
        CPU: 1.023s
     CGroup: /system.slice/mongod.service
             └─4247 /usr/bin/mongod --config /etc/mongod.conf

sudo systemctl enable mongod

sudo service mongod start

sudo service mongod stop

sudo service mongod restart

sudo service mongod status

● mongod.service - MongoDB Database Server
     Loaded: loaded (/lib/systemd/system/mongod.service; disabled; vendor preset: enabled)
     Active: active (running) since Thu 2024-03-14 08:23:17 CET; 21s ago
       Docs: https://docs.mongodb.org/manual
   Main PID: 4247 (mongod)
     Memory: 71.8M
        CPU: 1.023s
     CGroup: /system.slice/mongod.service
             └─4247 /usr/bin/mongod --config /etc/mongod.conf

Zum Kapitel springen MongoSH - Die Kommandozeile

Die Kommandozeile kann mit dem Befehl mongosh aufgerufen werden:

mongosh

Current Mongosh Log ID: 65f2a68bbfe5e801f60b2217
Connecting to:          mongodb://127.0.0.1:27017/?directConnection=true&serverSelectionTimeoutMS=2000&appName=mongosh+2.1.5
Using MongoDB:          7.0.6
Using Mongosh:          2.1.5

For mongosh info see: https://docs.mongodb.com/mongodb-shell/

To help improve our products, anonymous usage data is collected and sent to MongoDB periodically (https://www.mongodb.com/legal/privacy-policy).
You can opt-out by running the disableTelemetry() command.

------
   The server generated these startup warnings when booting
   2024-03-14T08:24:32.856+01:00: Using the XFS filesystem is strongly recommended with the WiredTiger storage engine. See http://dochub.mongodb.org/core/prodnotes-filesystem
   2024-03-14T08:24:33.813+01:00: Access control is not enabled for the database. Read and write access to data and configuration is unrestricted
   2024-03-14T08:24:33.813+01:00: vm.max_map_count is too low
------

Die anonymen Berichte können mit dem folgendem Befehl deaktiviert werden:

disableTelemetry()

Telemetry is now disabled.

Zum Kapitel springen Verbindung testen

Um die Verbindung zu testen habe ich hier zwei Code-Snippets vorbereitet. Einmal für Javascript unter Node.JS und einmal für Python. Solltest du eine andere Programmiersprache mit deiner MongoDB verwenden musst du ein anderes Code-Snippet verwenden.
Ich für meinen Teil nutze Javascript unter Node.JS, weswegen sich meine Meldungen darauf beziehen.

const mongoose                  = require('mongoose');
const connectionURI            = 'mongodb://192.168.0.187:27017/testdatabase';

const sampleSchema           = new mongoose.Schema({ name: { type: String } });

const sampleModel             = mongoose.model('example', sampleSchema);

async function main () {

  try{
    await mongoose.connect(connectionURI);
  }catch ( error ){
    console.error(`Bei der Verbindung mit der Datenbank ist ein Fehler aufgetreten: ${error}`);
    return;
  }
  
  const sampleDocument    = new sampleModel({ name: 'BeispielName' });

  try {
    const savedDocument   = await sampleDocument.save()
    console.log('Dokument wurde gespeichert:', savedDocument)
  } catch ( error ){
    console.error(`Fehler beim Speichern des Dokuments: ${error}`)
  }
}

main();

from pymongo import MongoClient


connection_uri  = 'mongodb://192.168.0.187:27017/'

database_name   = 'testdatabase'
sample_schema   = { 'name': str }


def main():

  try:

    client  = MongoClient(connection_uri)
    db      = client[database_name]
    print( "Erfolgreich zur MongoDB verbunden" )

  except Exception as err:

    print( f"Fehler bei der Verbindung mit der MongoDB: {err}" )
    exit( 1 )

  sample_collection   = db['example']
  sample_document     = { 'name': 'BeispielName' }

  try:

    result = sample_collection.insert_one(sample_document)
    print( 'Dokument wurde gespeichert:', result )
    exit( 0 )

  except Exception as err:
    print( f"Fehler beim Speichern des Dokuments: {err}" )
    exit( 1 )


main()

Egal ob Javascript oder Python - in beiden Fällen wird beim Verbinden mit der Datenbank ein Fehler auftreten.

Bei der Verbindung mit der Datenbank ist ein Fehler aufgetreten:
MongooseServerSelectionError: connect ECONNREFUSED 192.168.0.187:27017

Grund für den aufgeführten Fehler ist die aktuelle Konfiguration. Diese lässt im Standard nämlich nur Verbindungen von localhost also 127.0.0.1 zu. Ein guter Grund, die Konfiguration anzupassen.

Zum Kapitel springen Konfiguration

Beim Einsatz von MongoDB sollten einige wichtige Aspekte berücksichtigt werden. So ermöglicht die Standardkonfiguration beispielsweise uneingeschränkten Zugriff auf die Datenbank ohne die Notwendigkeit einen Benutzernamen oder ein Passwort einzugeben. Dies stellt ein erhebliches Sicherheitsrisiko dar. Daher ist es ein entscheidender und erster Schritt, die Konfiguration anzupassen.

Die Konfiguration findet man unter:

nano  /etc/mongod.conf

# mongod.conf

# for documentation of all options, see:
#   http://docs.mongodb.org/manual/reference/configuration-options/

# Where and how to store data.
storage:
  dbPath: /var/lib/mongodb
#  engine:
#  wiredTiger:

# where to write logging data.
systemLog:
  destination: file
  logAppend: true
  path: /var/log/mongodb/mongod.log

# network interfaces
net:
  port: 27017
  bindIp: 127.0.0.1

# how the process runs
processManagement:
  timeZoneInfo: /usr/share/zoneinfo

#security:

#operationProfiling:

#replication:

#sharding:

## Enterprise-Only Options:

#auditLog:

Zum Kapitel springen Zulässige IP-Adressen

Wie bereits erwähnt lässt MongoDB nach der Standardinstallation nur eine Verbindung vom Localhost zu. Dies ist im Bereich der network interfaces festgelegt.

# network interfaces
net:
  port: 27017
  bindIp: 127.0.0.1

Der Parameter bindIp legt fest, von welchen IP-Adressen man auf die Datenbank zugreifen kann. Setzt man diesen auf 0.0.0.0 kann grundsätzlich jede IP-Adresse auf den Server zugreifen.
Je nach Einsatzzweck der Datenbank bietet es sich hier an, eine feste IP-Adresse zu vergeben. Sollten Dienste auf dem Server selbst laufen, so kann der Zugriff von localhost bestehen bleiben. Zum Testen und validieren kann man hier erstmal ruhig den Zugriff von allen IP-Adressen erlauben:

# network interfaces
net:
  port: 27017
  bindIp: 0.0.0.0

Nach jeder Änderung an der Konfiguration muss MongoDB neugestartet werden:

service mongod restart

Führt man nun nochmal den Verbindungstest durch, sollte die Verbindung erfolgreich sein:

Dokument wurde gespeichert: {
  name: 'BeispielName',
  _id: new ObjectId('65f2b555cf96851874f3c93c'),
  __v: 0
}

Zum Kapitel springen Root-Benutzer anlegen

Anhand des Verbindungstest wird klar: Wo ist die Authentifizierung? Wie in der Einleitung des Kapitels Konfiguration bereits erwähnt, gibt es in der Standardkonfiguration keine Authentifizierung. Jeder der die IP-Adresse oder die Domain der Datenbank besitzt hat vollen Zugriff darauf. Wir sollten im nächsten Schritt also die Authentifizierung unbedingt aktivieren!

Wenn wir die Authentifizierung aktivieren, würden wir uns selbst unmittelbar von der Datenbank ausschließen. Solange wir Zugang zum Server und somit dem Befehl mongosh haben, lässt sich dies zwar einfach beheben, dennoch sollte der erste Schritt sein, einen Root-Benutzer für MongoDB zu erstellen.

Dieser Root-Benutzer hat volle Rechte für die MongoDB Instanz. Darunter fallen unter anderem die Verwaltung von Nutzern, Datenbanken und Tabellen.

Um einen neuen Root-Benutzer anzulegen öffnen wir die MongoDB Shell mit dem Befehl:

mongosh

Mit dem Befehl show dbs können wir uns alle vorhandenen Datenbank anzeigen lassen:

admin          40.00 KiB
config        108.00 KiB
local          72.00 KiB
testdatabase  112.00 KiB

Bei admin, config und local handelt es sich im Default-Datenbanken. Diese sind essenziell für den Betrieb und sollten nicht gelöscht werden. Die Datenbank testdatabase kommt vom vorhin durchgeführten Verbindungstest. Der Root-Benutzer muss in der admin Datenbank angelegt werden. Dazu wechseln wir zunächst in die Datenbank:

use admin

In dieser Datenbank werden wir nun den Root-Nutzer anlegen. Ändert dazu den Key user in einen Nutzernamen den euer Root-Benutzer haben soll und kopiert den Befehl in das mongosh Terminal:

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

Nach der Aufforderung zum Eingeben des Passwortes wird der Benutzer erstellt:

admin> db.createUser({
...     user: "admin",
...     pwd: passwordPrompt(),
...     roles: [ { role: "root", db: "admin" } ]
... })
Enter password
$sV]uyDD(6NU#b92+gi}&8cIT+
****************************************
{ ok: 1 }
admin>

Der Root-Benutzer wurde erfolgreich erstellt. Nun kann die allgemeine Authentifizierung der MongoDB aktiviert werden.

Zum Kapitel springen Authentifizierung aktivieren

MongoDB Konfiguration mit dem Editor Nano öffnen:

nano  /etc/mongod.conf

Sucht den Abschnitt der Sicherheitseinstellungen und aktiviert darin die Authentifizierung:

#security:
security:
  authorization: enabled

Speichert die Änderungen mit Strg+O, schließt den Editor mit Strg+X und startet die MongoDB anschließend neu.

Zum Kapitel springen Authentifizierung testen

Um die Authentifizierug zu testen kann wieder der Verbindungstest ausgeführt werden.
Wir erhalten ohne Änderungen des Test-Snippets die folgende Fehlermeldung:

Fehler beim Speichern des Dokuments:
MongoServerError: Command insert requires authentication

Auch bei dem Versuch über MongoSH die Datenbanken aufzulisten, erhalten wir einen Fehler:

mongosh

show dbs

Current Mongosh Log ID: 65f2be12139da04f26873c32
Connecting to:          mongodb://127.0.0.1:27017/?directConnection=true&serverSelectionTimeoutMS=2000&appName=mongosh+2.1.5
Using MongoDB:          7.0.6
Using Mongosh:          2.1.5

For mongosh info see: https://docs.mongodb.com/mongodb-shell/

test> show dbs
MongoServerError[Unauthorized]: Command listDatabases requires authentication

Grund dafür die ist aktivierte Authentifizierung. Ab sofort müssen wir uns sowohl bei MongoSH als auch bei unseren Anwendungen mit Zugangsdaten authentifieren:

Nutzt dazu die vergebenen Zugangsdaten aus Root-Benutzer anlegen.

mongosh -u admin -p --authenticationDatabase admin

Enter password: *********

Für den Verbindungstest müssen die Zugangsdaten dann mit angegeben werden:

// vorher
const connectionURI             = 'mongodb://192.168.0.187:27017/testdatabase';
// absofort
const connectionURI             = 'mongodb://admin:SuperSecretPassword!@192.168.0.187:27017/testdatabase?authSource=admin';

# vorher
connection_uri  = 'mongodb://192.168.0.187:27017/'
# absofort
connection_uri  = 'mongodb://admin:SuperSecretPassword!@192.168.0.187:27017'

Mit diesem Connection-String baut man eine Verbindung als Root-Benutzer auf. Die Authentifizierungs-Quelle ist die Datenbank admin. Man hat somit wieder vollen Zugriff auf die MongoDB-Instanz.

Zum Kapitel springen Standardport überschreiben

Der Standardport für MongoDB ist 27017. Dies bietet potenziellen Angreifern schon mal einen Anhaltspunkt. Aus diesem Grund ist es zu empfehlen, diesen zu ändern. Man findet den Port unter den Net-Optionen, genau wie die bindIP.

Zum Kapitel springen TLS einrichten

Solltest du deine Datenbank in einer Produktivumgebung verwenden oder von externen Systemen auf deine MongoDB zugreifen, solltest du deine MongoDB unbedingt mit TLS absichern. Dazu habe ich ein Tutorial verfasst:
TLS-Sicherheit für MongoDB: Umfassende Anleitung zur Verschlüsselung.

Entdecke noch andere spannende Tutorials zur MongoDB auf makesmart.

Zum Kapitel springen Benutzer verwalten

Wie im Kapitel Authentifizierung testen vermerkt, ist es nicht ratsam, den Root-Benutzer auch nur im Ansatz für ein Projekt zu verwenden. Dieser sollte wirklich nur zu Verwendung kommen, wenn man in der Datenbank direkt arbeitet - wenn überhaupt. Beispielsweise über MongoSH.

Besser ist es, weitere Benutzer anzulegen. Diese Nutzer haben dann nur fein abgestimmte Berechtigung auf eine bestimmte Datenbank. Als Beispiel verwenden wir folgende Daten:

Benutzername: myTester
Passwort: hallohallo123
Datenbank: testdatabase

Zuerst wechseln wir in die Datenbank testdatabase und legen anschließend den Nutzer an. Der Nutzer bekommt die Rechte des dbOwner. Das heißt er kann auf dieser Datenbank alle Operationen ausführen: Schreiben, lesen, leeren und Datenbank löschen. Nur auf die Datenbank testdatabase nicht auf die MongoDB-Instanz.

use testdatabase

db.createUser(
  {
    user: "myTester",
    pwd: passwordPrompt(),
    roles: [ 
      { role: "dbOwner", 	db: "testdatabase" }
    ]
  }
)

Eine Verbindung kann dann wie folgt hergestellt werden:

mongosh -u myTester -p --authenticationDatabase testdatabase

mongodb://myTester:${PASSWORD}@192.168.0.187:27017/testdatabase?authSource=testdatabase

Zum Kapitel springen Cheatsheet

Diese Befehle können über den Befehl mongosh ausgeführt werden:

Zum Kapitel springen Nutzer erstellen

// Nutzer erstellen
db.createUser(
  {
    user: "myTester",
    pwd: passwordPrompt(),
    roles: [ 
      { role: "readWrite", 	db: "testdatabase" }
    ]
  }
)

Zum Kapitel springen Nutzerrechte zuweisen

// Nutzerrechte zuweisen

// Typische User-Berechtigungen
// Datenbank-Lesen / -Schreiben
db.grantRolesToUser( "myTester", [ { role: "readWrite", 	db: "testdatabase" } ] )
// Datenbank-Benutzer Admin
db.grantRolesToUser( "myTester", [ { role: "userAdmin", 	db: "testdatabase" } ] )
// Datenbank Besitzer; schließt obige Rechte mit ein + leeren und löschen der Datenbank
db.grantRolesToUser( "myTester", [ { role: "dbOwner", 		db: "testdatabase" } ] )

Zum Kapitel springen Nutzerrechte entziehen

// Nutzerrechte entziehen
db.revokeRolesFromUser( "myTester", [
  { role: "readWrite", 	db: "testdatabase" }
])

Zum Kapitel springen Nutzerinformationen erhalten

// Nutzerinformationen erhalten
db.getUser("myTester")

Zum Kapitel springen Nutzer löschen

// Nutzer löschen
db.dropUser("myTester")

Zum Kapitel springen Verbindung mit einem Nutzer aufbauen

mongosh -u ${USERNAME} -p --authenticationDatabase {DATABASE_NAME}

mongodb://${USERNAME}:${PASSWORD}@192.168.0.187:27017/{DATABASE_NAME}?authSource={DATABASE_NAME}