MongoDB Community setup guide — server configuration and security

MongoDB
Ubuntu
Database
Security
Next.js

MongoDB 8.0 Einrichtungsanleitung

Eine umfassende Anleitung zur Installation, Konfiguration und Absicherung von MongoDB 8.0 auf Ubuntu 24.04 – mit Authentifizierung, Netzwerkbindung, TLS/SSL, automatisierten Backups und Next.js-Integration.

15. März 20253 Min. Lesen

Diese Anleitung führt durch die Installation von MongoDB 8.0 auf Ubuntu 24.04.2, die Absicherung mit Authentifizierung und TLS/SSL, die Einrichtung automatisierter Backups und die Anbindung an eine Next.js-Anwendung.

Installation

1. MongoDB-GPG-Schlüssel importieren

Den Signaturschlüssel zur Prüfung der Paketintegrität importieren:

sudo apt-get install gnupg curl
curl -fsSL https://pgp.mongodb.com/server-8.0.asc | \
   sudo gpg -o /usr/share/keyrings/mongodb-server-8.0.gpg \
   --dearmor

2. MongoDB-Repository hinzufügen

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

3. MongoDB installieren

Paketdatenbank aktualisieren und installieren:

sudo apt-get update
sudo apt-get install -y mongodb-org

Dabei werden der MongoDB-Server, mongosh und die Standardwerkzeuge installiert.

4. Dienst starten und aktivieren

sudo systemctl start mongod
sudo systemctl enable mongod

Prüfen, ob der Dienst läuft:

sudo systemctl status mongod

Die Ausgabe sollte den Status active (running) anzeigen.

5. Standardkonfiguration überprüfen

Die MongoDB-Konfiguration befindet sich unter /etc/mongod.conf:

sudo nano /etc/mongod.conf

Wichtige Standardwerte:

# Netzwerkeinstellungen
net:
  port: 27017         # Standardport
  bindIp: 127.0.0.1  # Erlaubt standardmäßig nur lokale Verbindungen

# Speicher
storage:
  dbPath: /var/lib/mongodb

# Prozessverwaltung
processManagement:
  timeZoneInfo: /usr/share/zoneinfo

Nach jeder Konfigurationsänderung MongoDB neu starten:

sudo systemctl restart mongod

Sicherheit

1. Admin-Benutzer anlegen

MongoDB-Shell öffnen:

mongosh

Einen Root-Admin-Benutzer anlegen:

use admin
db.createUser(
  {
    user: "adminUser",
    pwd: "secure_password_here",
    roles: [ { role: "userAdminAnyDatabase", db: "admin" }, "readWriteAnyDatabase" ]
  }
)
exit

2. Authentifizierung aktivieren

/etc/mongod.conf bearbeiten und den Security-Abschnitt hinzufügen:

security:
  authorization: enabled

MongoDB neu starten:

sudo systemctl restart mongod

3. Netzwerkbindung konfigurieren

Standardmäßig lauscht MongoDB nur auf localhost. Wenn sich deine Anwendung auf demselben Server befindet, kann diese Einstellung beibehalten werden. Um Verbindungen von bestimmten Remote-Hosts zuzulassen:

net:
  port: 27017
  bindIp: 127.0.0.1              # Nur localhost (Standard)
  # bindIp: 127.0.0.1,192.168.1.100  # Bestimmte IP erlauben
  # bindIp: 0.0.0.0              # Alle IPs erlauben (nicht empfohlen)

Sicherheitshinweis: Remote-Verbindungen müssen immer mit Firewall-Regeln, TLS/SSL und starker Authentifizierung kombiniert werden.

4. TLS/SSL einrichten

Selbstsigniertes Zertifikat generieren (nur für Tests; in der Produktion CA-signierte Zertifikate verwenden):

# Verzeichnis für Zertifikate anlegen
sudo mkdir -p /etc/ssl/mongodb
cd /etc/ssl/mongodb

# Selbstsigniertes Zertifikat generieren
sudo openssl req -newkey rsa:4096 -x509 -sha256 -days 365 -nodes \
  -out mongodb-cert.pem \
  -keyout mongodb-key.pem

# Geeignete Berechtigungen setzen
sudo chmod 600 mongodb-key.pem mongodb-cert.pem
sudo chown mongodb:mongodb mongodb-key.pem mongodb-cert.pem

/etc/mongod.conf aktualisieren, um SSL zu erzwingen:

net:
  port: 27017
  bindIp: 127.0.0.1
  ssl:
    mode: requireSSL
    PEMKeyFile: /etc/ssl/mongodb/mongodb-cert.pem
    PEMKeyPassword: "dein_passwort_falls_vorhanden"

5. Automatisierte Backups einrichten

Backup-Verzeichnis und Skript anlegen:

sudo mkdir -p /var/backups/mongodb
sudo nano /usr/local/bin/mongodb-backup.sh

Inhalt des Backup-Skripts:

#!/bin/bash
BACKUP_DIR="/var/backups/mongodb/$(date +%Y-%m-%d_%H-%M-%S)"
LOG_FILE="/var/log/mongodb/backup_$(date +%Y-%m-%d).log"

mkdir -p $BACKUP_DIR

echo "Backup gestartet um $(date)" >> $LOG_FILE

mongodump --port 27017 \
  --authenticationDatabase "admin" \
  --username "adminUser" \
  --password "secure_password_here" \
  --out $BACKUP_DIR \
  --gzip

echo "Backup abgeschlossen um $(date)" >> $LOG_FILE

# Backups älter als 14 Tage entfernen
find /var/backups/mongodb -type d -mtime +14 -exec rm -rf {} \; 2>/dev/null || true

Skript ausführbar machen und per Cron planen:

sudo chmod +x /usr/local/bin/mongodb-backup.sh

# Crontab bearbeiten – täglich um 2 Uhr ausführen
sudo crontab -e
# Hinzufügen: 0 2 * * * /usr/local/bin/mongodb-backup.sh

Aus einem Backup wiederherstellen:

# Verfügbare Backups auflisten
ls -la /var/backups/mongodb/

# Aus einem bestimmten Backup wiederherstellen
mongorestore --port 27017 \
  --authenticationDatabase "admin" \
  --username "adminUser" \
  --password "secure_password_here" \
  --gzip \
  /var/backups/mongodb/2025-03-25_02-00-00/

Sicherheitsbest Practices

Starke, einzigartige Passwörter für alle MongoDB-Benutzer verwenden.
Prinzip der minimalen Rechtevergabe beachten – Benutzer nur die tatsächlich benötigten Berechtigungen gewähren.
MongoDB regelmäßig aktualisieren, um Sicherheits-Patches einzuspielen.
IP-Whitelisting implementieren, um den Zugriff auf vertrauenswürdige Quellen zu beschränken.
TLS/SSL für alle Verbindungen in Produktionsumgebungen verwenden.
Regelmäßig die Wiederherstellung aus Backups testen, nicht nur die Erstellung.
Logs auf verdächtige Aktivitäten überwachen und automatische Benachrichtigungen einrichten.

MongoDB mit Next.js integrieren

Verbindungs-Utility

Ein Verbindungs-Singleton in lib/mongodb.ts anlegen, um nicht bei jeder Anfrage eine neue Verbindung zu öffnen:

// lib/mongodb.ts
import { MongoClient } from 'mongodb'

if (!process.env.MONGODB_URI) {
  throw new Error('Please add your MongoDB URI to .env.local')
}

const uri = process.env.MONGODB_URI
const options = {}

let client: MongoClient
let clientPromise: Promise<MongoClient>

if (process.env.NODE_ENV === 'development') {
  // In der Entwicklung die Verbindung über HMR-Neuladen hinweg erhalten
  const globalWithMongo = global as typeof globalThis & {
    _mongoClientPromise?: Promise<MongoClient>
  }
  if (!globalWithMongo._mongoClientPromise) {
    client = new MongoClient(uri, options)
    globalWithMongo._mongoClientPromise = client.connect()
  }
  clientPromise = globalWithMongo._mongoClientPromise
} else {
  client = new MongoClient(uri, options)
  clientPromise = client.connect()
}

export default clientPromise

Umgebungsvariablen

Den Connection-String in .env.local eintragen:

MONGODB_URI=mongodb://adminUser:secure_password@127.0.0.1:27017/mydb?authSource=admin

Verbindung in API-Routen verwenden

// app/api/users/route.ts
import { NextResponse } from 'next/server'
import clientPromise from '@/lib/mongodb'

export async function GET() {
  try {
    const client = await clientPromise
    const db = client.db("mydb")

    const users = await db.collection("users").find({}).limit(10).toArray()

    return NextResponse.json({ users })
  } catch (e) {
    console.error(e)
    return NextResponse.json({ error: 'Failed to fetch users' }, { status: 500 })
  }
}

Häufig gestellte Fragen

Können MongoDB und Next.js auf demselben Server laufen?

Ja, für kleine bis mittlere Anwendungen ist das in Ordnung. Bei größeren Lasten empfiehlt sich eine Trennung – dedizierte Datenbankserver bieten bessere Skalierbarkeit, unabhängige Ressourcenzuweisung und klarere Sicherheitsgrenzen.

Wie überwache ich die MongoDB-Performance?

Verwende die eingebauten Werkzeuge (db.stats(), db.serverStatus()), oder Drittlösungen wie Prometheus mit dem MongoDB-Exporter, MongoDB Atlas-Monitoring oder kommerzielle Tools wie Datadog.

Sollte ich MongoDB Atlas statt Self-Hosting verwenden?

Atlas bietet automatische Backups, Skalierung und verwaltete Sicherheitsupdates – auf Kosten von weniger Kontrolle und laufenden Abogebühren. Self-Hosting gibt dir volle Kontrolle, erfordert aber mehr operativen Aufwand. Für die meisten Produktionsanwendungen ist Atlas die pragmatische Wahl, es sei denn, Kosten oder Datenschutzanforderungen sprechen für Self-Hosting.

Wie sichere und stelle ich meine Datenbank wieder her?

Verwende mongodump für Backups und mongorestore für die Wiederherstellung, wie im Backup-Abschnitt beschrieben. Stelle immer sicher, dass der Wiederherstellungsprozess funktioniert, bevor du ihn tatsächlich benötigst.