Skip to content

MongoDB Spickzettel

NoSQL-Dokumentendatenbank für die Speicherung großer Datenmengen.

01

Erste Schritte

Mit MongoDB verbinden

mongosh ist die moderne MongoDB-Shell (sie ersetzt die alte mongo-Shell). Ein Connection-String folgt dem URI-Format mongodb://[user:pass@]host[:port]/[db][?options]. Die /admin-Datenbank ist die Standard-Auth-Datenbank. Du kannst dich direkt mit einer bestimmten Datenbank verbinden, indem du sie an den URI anhängst.

mongodb
# connect to a local server on default port
mongosh

# connect to a specific host and port
mongosh "mongodb://localhost:27017"

# connect with authentication
mongosh "mongodb://user:pass@localhost:27017/admin"

# connect to a specific database directly
mongosh "mongodb://localhost:27017/mydb"

# show connection info
db.getMongo().getDBNames()

Datenbank-Grundlagen

MongoDB legt Datenbanken und Collections lazy an — sie erscheinen erst nach dem Einfügen des ersten Dokuments. 'use mydb' wechselt den Kontext, erzeugt die Datenbank aber erst, wenn Daten geschrieben werden. show dbs listet leere Datenbanken nicht auf. dropDatabase löscht dauerhaft alle Collections samt Daten.

mongodb
# show all databases
show dbs

# switch to (or create) a database
use mydb

# show the current database
db

# create is implicit: inserting into a
# non-existent collection creates both the
# collection and the database

# drop the current database
db.dropDatabase()

Collections

Collections sind das Gegenstück zu SQL-Tabellen und halten Dokumente. Sie werden beim ersten Insert automatisch erzeugt, aber createCollection erlaubt Optionen wie capped (Collections fester Größe, die alte Dokumente überschreiben — nützlich für Logs). stats() zeigt Speichergröße, Dokumentanzahl und Index-Details.

mongodb
# list collections in current database
show collections
db.getCollectionNames()

# create a collection explicitly with options
db.createCollection("users", {
  capped: true,
  size: 5242880,
  max: 5000
})

# rename a collection
db.users.renameCollection("accounts")

# drop a collection
db.users.drop()

# get collection stats
db.users.stats()

BSON-Datentypen

BSON erweitert JSON um Typen, die für Anwendungen wichtig sind: ObjectId (12-Byte-eindeutige IDs), ISODate, NumberDecimal (exaktes Dezimal für Geld — vermeidet Float-Rundung), NumberLong (64-Bit-Ganzzahlen), BinData (binär) und mehr. NumberDecimal für Währung vermeidet klassische Fließkommafehler.

mongodb
# MongoDB stores BSON (binary JSON) with rich types
{
  _id: ObjectId("65a1b2c3d4e5f6a7b8c9d0e1"),
  name: "Alice",                       // String
  age: 30,                             // Int32
  score: NumberLong(9007199254740992), // Int64
  price: NumberDecimal("19.99"),       // Decimal128 (exact money)
  active: true,                        // Boolean
  birthday: ISODate("1995-08-15"),     // Date
  tags: ["red", "blue"],               // Array
  meta: { views: 100 },                // Embedded document
  data: BinData(0, "aGVsbG8="),        // Binary
  id: UUID("...")                      // UUID
}

Shell-Helfer & Help

mongosh unterstützt vollständiges JavaScript, daher kannst du Schleifen, Funktionen und Variablen in der Shell schreiben. .pretty() formatiert die Ausgabe lesbar (in mongosh Standard). load() führt eine .js-Datei im Shell-Kontext aus — praktisch für sich wiederholende Admin-Skripte. db.collection.help() listet alle verfügbaren Methoden.

mongodb
# get help on database methods
db.help()

# get help on collection methods
db.users.help()

# list common shell commands
help

# pretty-print query results
db.users.find().pretty()

# print JSON in a compact form
db.users.find().toArray()

# execute a JavaScript file
mongosh --file script.js
load("script.js")
02

CRUD-Operationen

Dokumente einfügen

MongoDB erzeugt automatisch ein _id (ObjectId), wenn du keines angibst. Das _id muss innerhalb einer Collection eindeutig sein — ein doppeltes _id erzeugt einen Schreibfehler. ordered:false lässt insertMany nach einem Fehler weitere Dokumente einfügen und verbessert den Durchsatz bei Bulk-Loads.

mongodb
# insert a single document
db.users.insertOne({
  name: "Alice",
  email: "[email protected]",
  age: 30
})

# insert multiple documents
db.users.insertMany([
  { name: "Bob", age: 25 },
  { name: "Carol", age: 28 }
])

# insert with a custom _id
db.users.insertOne({ _id: 1, name: "Dave" })

# ordered insert (stops on error) vs unordered
db.users.insertMany(docs, { ordered: false })

Dokumente finden / abfragen

find() gibt einen Cursor zurück (lazy ausgewertet); findOne() gibt ein einzelnes Dokument oder null zurück. Die Projektion steuert, welche Felder zurückkommen — Inklusion und Exklusion lassen sich nicht mischen (außer _id). 1 bedeutet einbeziehen, 0 ausschließen. countDocuments ist genau; das ältere count() ist für gefilterte Zählungen veraltet.

mongodb
# find all documents
db.users.find()

# find with a filter
db.users.find({ age: 30 })
db.users.find({ "address.city": "NYC" })

# find one matching document
db.users.findOne({ name: "Alice" })

# projection: include/exclude fields
db.users.find({}, { name: 1, age: 1, _id: 0 })
db.users.find({}, { email: 0 })

# count matching documents
db.users.countDocuments({ age: { $gte: 18 } })

Dokumente aktualisieren

updateOne/updateMany nutzen Update-Operatoren ($set, $inc usw.), um bestimmte Felder zu ändern. replaceOne ersetzt das ganze Dokument außer _id. upsert:true erzeugt ein neues Dokument, wenn kein Treffer existiert — nützlich für 'create or update'-Muster. Felder immer mit $set aktualisieren; ein nacktes Objekt ersetzt das Dokument (Legacy-Verhalten).

mongodb
# update one document
db.users.updateOne(
  { name: "Alice" },
  { $set: { age: 31, status: "active" } }
)

# update many documents
db.users.updateMany(
  { status: "pending" },
  { $set: { status: "active" } }
)

# replace an entire document (keeps _id)
db.users.replaceOne(
  { name: "Alice" },
  { name: "Alice", age: 32, city: "NYC" }
)

# upsert: insert if no match found
db.users.updateOne(
  { name: "Eve" },
  { $set: { age: 22 } },
  { upsert: true }
)

Update-Operatoren

Update-Operatoren ändern Felder atomar auf Dokumentebene. $inc ist nebenläufigkeitssicher (keine Read-Modify-Write-Race). $min/$max aktualisieren nur, wenn der neue Wert kleiner/größer ist. $currentDate ist praktisch für 'last modified'-Zeitstempel. Mehrere Operatoren lassen sich in einem Update kombinieren.

mongodb
# $set and $unset
db.users.updateOne({n:"A"}, { $set: {age:30}, $unset: {temp:""} })

# $inc increments a numeric field
db.users.updateOne({n:"A"}, { $inc: {views: 1} })
db.users.updateOne({n:"A"}, { $inc: {balance: -50} })

# $rename a field
db.users.updateOne({n:"A"}, { $rename: {n: "name"} })

# $min / $max keep the smaller/larger value
db.users.updateOne({n:"A"}, { $min: {lowScore: 80} })

# $mul multiply the field value
db.users.updateOne({n:"A"}, { $mul: {price: 1.1} })

# $currentDate sets to current date
db.users.updateOne({n:"A"}, { $currentDate: {updatedAt: true} })

Dokumente löschen

deleteOne entfernt den ersten Treffer; deleteMany entfernt alle Treffer. deleteMany({}) leert die Collection, behält aber die Indizes (schneller als drop+neu anlegen, wenn Indexdefinitionen erhalten bleiben sollen). findOneAndDelete gibt das gelöschte Dokument atomar zurück. Löschungen sind unwiderruflich — Filter immer sorgfältig prüfen.

mongodb
# delete one matching document
db.users.deleteOne({ name: "Alice" })

# delete all matching documents
db.users.deleteMany({ status: "inactive" })

# delete all documents in a collection
db.users.deleteMany({})

# findAndDelete: return the deleted document
db.users.findOneAndDelete({ name: "Bob" })

# remove is deprecated, prefer deleteOne/deleteMany
db.users.remove({ name: "Bob" }, { justOne: true })

Array-Update-Operatoren

$push hängt an (Duplikate erlaubt); $addToSet dedupliziert. $pull entfernt Elemente, die einer Bedingung entsprechen. Der Positionsoperator ($) verweist auf das erste vom Query getroffene Array-Element — essenziell, um bestimmte Array-Elemente ohne bekannten Index zu aktualisieren. $[] aktualisiert alle Array-Elemente.

mongodb
# $push append to an array
db.users.updateOne({n:"A"}, { $push: {tags: "new"} })

# $push with $each for multiple values
db.users.updateOne({n:"A"}, { $push: {tags: { $each: ["x","y"] } } })

# $addToSet adds only if not already present
db.users.updateOne({n:"A"}, { $addToSet: {tags: "x"} })

# $pull remove all matching array elements
db.users.updateOne({n:"A"}, { $pull: {tags: "x"} })

# $pop remove first (-1) or last (1) element
db.users.updateOne({n:"A"}, { $pop: {tags: 1} })

# update an array element by position
db.users.updateOne({}, { $set: {"tags.0": "first"} })
db.users.updateOne({"tags":"old"}, { $set: {"tags.$":"new"} })
03

Dokumente abfragen

Vergleichsoperatoren

Vergleichsoperatoren sind das Fundament der Abfragen. $in ist deutlich effizienter als mehrere $or-Bedingungen auf demselben Feld. Mehrere Operatoren lassen sich auf einem Feld kombinieren (z. B. $gte und $lte für einen Bereich). $exists:true findet Dokumente mit dem Feld, $exists:false solche ohne.

mongodb
# $eq equal (same as direct value)
db.products.find({ price: { $eq: 100 } })

# $ne not equal
db.products.find({ price: { $ne: 100 } })

# $gt, $gte, $lt, $lte
db.products.find({ price: { $gte: 50, $lte: 200 } })

# $in matches any value in an array
db.products.find({ category: { $in: ["books", "music"] } })

# $nin not in array
db.products.find({ category: { $nin: ["books"] } })

# $exists check field presence
db.products.find({ discount: { $exists: true } })

Logische Operatoren

Implizites AND (Komma im Filter) ist am häufigsten und effizientesten. Explizites $and nur verwenden, wenn du mehrere Bedingungen auf dasselbe Feld brauchst (implizites AND auf demselben Feld überschreibt frühere Bedingungen). $or nutzt separate Index-Scans und verschmilzt die Ergebnisse — die Felder in $or sollten für Performance indiziert sein.

mongodb
# $and (explicit, useful for same-field conditions)
db.users.find({ $and: [
  { age: { $gte: 18 } },
  { age: { $lte: 65 } }
]})

# $or matches if ANY condition is true
db.users.find({ $or: [
  { status: "active" },
  { vip: true }
]})

# $nor matches if NO condition is true
db.users.find({ $nor: [{ status: "active" }]})

# $not inverts a condition
db.users.find({ age: { $not: { $gt: 18 } } })

# implicit AND (comma-separated)
db.users.find({ age: { $gte: 18 }, status: "active" })

Element- & Auswertungsoperatoren

$type filtert nach BSON-Typ (nützlich bei Feldern mit gemischten Typen). $regex unterstützt Optionen wie 'i' (Groß-/Kleinschreibung ignorieren) — aber ein Regex ohne Präfix-Anker kann Indizes nicht effizient nutzen. $expr ermöglicht Vergleiche zwischen Dokumentfeldern, was normale Operatoren nicht können. $expr sparsam einsetzen, da es Indizes umgehen kann.

mongodb
# $type filter by BSON data type
db.users.find({ age: { $type: "int" } })
db.users.find({ age: { $type: ["int", "double"] } })

# $regex regular expression match
db.users.find({ name: { $regex: "^Al", $options: "i" } })

# $mod modulo operation
db.users.find({ age: { $mod: [2, 0] } })  # even ages

# $expr compare fields within a document
db.orders.find({ $expr: { $gt: ["$total", "$budget"] } })

# $jsonSchema validate against a schema
db.users.find({ $jsonSchema: {
  required: ["name", "email"]
}})

Array-Abfrageoperatoren

$all findet Arrays, die alle angegebenen Werte enthalten (reihenfolgeunabhängig). $elemMatch ist essenziell, wenn ein Array-Element mehrere Bedingungen gleichzeitig erfüllen muss (ein einfacher Query würde Elemente einzeln matchen). $size matcht nur exakte Längen — ein $size mit Bereich gibt es nicht; die Länge stattdessen vorab berechnen und als separates Feld speichern.

mongodb
# $all: array contains ALL specified values
db.posts.find({ tags: { $all: ["mongo", "db"] } })

# $elemMatch: at least one element matches all conditions
db.students.find({ scores: { $elemMatch: {
  subject: "math", score: { $gte: 90 }
}}})

# $size: array of exact length
db.users.find({ tags: { $size: 3 } })

# match if array contains the value
db.posts.find({ tags: "mongo" })

# match a specific array index
db.users.find({ "scores.0": 95 })  # first score is 95

Cursor-Methoden & Sortierung

skip+limit implementiert Paginierung, aber skip wird bei großen Offsets langsam (er scannt alle übersprungenen Dokumente). Für tiefe Paginierung Keyset-Paginierung nutzen: mit Filter auf dem Sortierfeld größer als der zuletzt gesehene Wert abfragen. sort() kann einen Index nutzen, um In-Memory-Sortierung zu vermeiden — Sortierfelder großer Collections immer indizieren.

mongodb
# limit and skip (pagination)
db.users.find().limit(10)
db.users.find().skip(20).limit(10)  # page 3

# sort: 1 ascending, -1 descending
db.users.find().sort({ age: 1, name: -1 })

# count results
db.users.find({active:true}).count()

# iterate the cursor in the shell
db.users.find().forEach(doc => print(doc.name))

# get a specific field's distinct values
db.users.distinct("city")
04

Indexierung

Indizes erzeugen

Indizes beschleunigen Abfragen dramatisch, verlangsamen aber Schreibvorgänge und belegen Speicherplatz. Single-Field-Indizes unterstützen Abfragen auf diesem Feld in beiden Sortierrichtungen. Compound-Indizes folgen der ESR-Regel (Equality, Sort, Range) für optimale Reihenfolge. TTL-Indizes löschen Dokumente automatisch nach einer Dauer — ideal für Sessions und Logs.

mongodb
# create a single-field index
db.users.createIndex({ email: 1 })          # ascending
db.users.createIndex({ age: -1 })            # descending

# create a unique index
db.users.createIndex({ email: 1 }, { unique: true })

# create a compound index
db.users.createIndex({ lastName: 1, firstName: 1 })

# create a text index
db.posts.createIndex({ title: "text", body: "text" })

# create a TTL (time-to-live) index
db.sessions.createIndex({ createdAt: 1 },
  { expireAfterSeconds: 3600 })

# name an index explicitly
db.users.createIndex({ email: 1 }, { name: "email_idx" })

Indizes ansehen & verwalten

getIndexes listet alle Indizes mit ihren Schlüsseln und Optionen auf. hideIndex/unhideIndex lässt die Auswirkung eines Entfernens testen, ohne den Index wirklich zu löschen — der Query-Planer ignoriert versteckte Indizes. Bleibt die Performance gleich, ist Löschen sicher. Vor und nach Indexänderungen immer explain() ausführen.

mongodb
# list all indexes on a collection
db.users.getIndexes()

# total index size in bytes
db.users.totalIndexSize()

# drop an index by name
db.users.dropIndex("email_1")

# drop all indexes except _id
db.users.dropIndexes()

# hide an index (test impact before dropping)
db.users.hideIndex("email_1")
db.users.unhideIndex("email_1")

# check if queries use indexes
db.users.find({email:"[email protected]"}).explain("executionStats")

Spezielle Indextypen

2dsphere-Indizes treiben Geo-Abfragen ($near, $geoWithin). Hashed-Indizes unterstützen hash-basiertes Sharding für gleichmäßige Datenverteilung. Wildcard-Indizes ($**) decken unvorhersehbare/variable Feldnamen in Dokumenten ab — nützlich für polymorphe Daten. Partial-Indizes indexieren nur passende Dokumente und sparen Platz, wenn du nur eine Teilmenge abfragst.

mongodb
# geospatial 2dsphere index (GeoJSON points)
db.places.createIndex({ location: "2dsphere" })
db.places.find({
  location: { $near: {
    $geometry: { type: "Point", coordinates: [-73.99, 40.73] },
    $maxDistance: 1000
  }}
})

# hashed index (for sharding)
db.users.createIndex({ user_id: "hashed" })

# wildcard index (index arbitrary field names)
db.products.createIndex({ "$**": 1 })

# partial index (only matching documents)
db.users.createIndex({ email: 1 },
  { partialFilterExpression: { active: true } })

Explain & Query-Pläne

explain() ist das wichtigste Performance-Werkzeug. COLLSCAN (Collection-Scan) heißt, kein Index wurde genutzt — ein Warnsignal für große Collections. IXSCAN heißt, ein Index wurde benutzt. totalDocsExamined >> nReturned deutet auf einen schlechten Index hin (viele Dokumente geprüft, wenige geliefert). hint() erzwingt einen bestimmten Index, um die Wahl des Planers zu testen.

mongodb
# explain a query (basic)
db.users.find({age:30}).explain()

# explain with execution stats (timing)
db.users.find({age:30}).explain("executionStats")

# key fields in the output:
#   winningPlan.stage    -> COLLSCAN (bad) or IXSCAN (good)
#   totalDocsExamined    -> should be close to nReturned
#   executionTimeMillis  -> query duration
#   indexUsed            -> which index was chosen

# force a specific index (testing)
db.users.find({age:30}).hint("age_1")
db.users.find({age:30}).hint({age:1})

Indexierungs-Best-Practices

Die ESR-Regel (Equality, Sort, Range) ist das wichtigste Designprinzip für Compound-Indizes: Gleichheitsgefilterte Felder zuerst, dann Sortierfelder, dann Bereichsfelder. Eine Covered Query (alle Felder im Index) holt das Dokument nie — die schnellstmögliche Abfrage. Unbenutzte Indizes vermeiden; jeder fügt Schreib-Overhead hinzu.

mongodb
# ESR rule: Equality, Sort, Range for compound indexes
# equality fields first, then sort, then range
db.orders.createIndex({
  status: 1,        # Equality  (filter)
  date: 1,          # Sort      (order)
  amount: 1         # Range     (comparison)
})

# avoid over-indexing: each index slows writes
db.orders.getIndexes().length

# covered query: index satisfies query without fetching doc
db.users.createIndex({ name: 1, email: 1 })
db.users.find({ name: "A" }, { _id: 0, name: 1, email: 1 })

# background index build (deprecated in 4.2+, builds don't block)
db.users.createIndex({ name: 1 })  # non-blocking by default
05

Aggregation Framework

Aggregations-Pipeline-Grundlagen

Die Aggregations-Pipeline verarbeitet Dokumente nacheinander durch Stufen. $match früh in der Pipeline verkleinert die Arbeitsmenge (und kann Indizes nutzen). $group entspricht SQL GROUP BY. $count ist eine Abkürzung für $group + $project. Die Reihenfolge zählt: erst filtern, dann gruppieren, dann sortieren, dann limitieren.

mongodb
# a pipeline is an array of stages
db.orders.aggregate([
  { $match: { status: "shipped" } },
  { $group: { _id: "$customerId", total: { $sum: "$amount" } } },
  { $sort: { total: -1 } },
  { $limit: 10 }
])

# each stage transforms documents and passes them
# to the next stage

# count documents
db.orders.aggregate([
  { $match: { status: "shipped" } },
  { $count: "shippedCount" }
])

$match, $project & $limit

$match immer so früh wie möglich platzieren — es verkleinert die Dokumente für alle Folge-Stufen und kann Indizes nutzen. $project formt Dokumente um und berechnet neue Felder mit Ausdrücken. Umbenennen oder Berechnen von Feldern in $project ist vor $group üblich. $unset ist die Kurzform zum Ausschließen von Feldern.

mongodb
# $match filters documents (like find)
{ $match: { status: "active", age: { $gte: 18 } } }

# $project reshapes documents (1 include, 0 exclude)
{ $project: { name: 1, _id: 0, "address.city": 1 } }

# $project with computed fields
{ $project: {
  fullName: { $concat: ["$first", " ", "$last"] },
  ageNextYear: { $add: ["$age", 1] }
}}

# $limit and $skip
{ $limit: 10 }
{ $skip: 20 }

# $unset removes fields (inverse of $project)
{ $unset: "tempField" }

$group & Accumulators

$group ist die zentrale Aggregationsstufe. _id legt den Gruppierungsschlüssel fest (null für die Aggregation aller Dokumente). $push baut ein Array von Werten pro Gruppe; $addToSet dedupliziert. $first/$last beziehen sich auf die Dokumentreihenfolge in der Gruppe — bei relevanter Ordnung $sort vor $group. Das Speicherlimit liegt bei 100 MB pro Stufe (allowDiskUse für große Datensätze).

mongodb
# $group: group by a field and aggregate
{ $group: {
  _id: "$category",
  count: { $sum: 1 },
  totalRevenue: { $sum: "$amount" },
  avgPrice: { $avg: "$price" },
  minPrice: { $min: "$price" },
  maxPrice: { $max: "$price" },
  products: { $push: "$name" },     # array of values
  firstOrder: { $first: "$date" },
  lastOrder: { $last: "$date" }
}}

# group by multiple fields
{ $group: { _id: { category: "$cat", status: "$status" } } }

# group ALL documents together (_id: null)
{ $group: { _id: null, total: { $sum: "$amount" } } }

$lookup (Joins)

$lookup führt einen Left-Outer-Join aus — wie SQL LEFT JOIN. Die verbundenen Daten landen in einem Array-Feld, benannt durch 'as'. Die Pipeline-Form erlaubt Filtern und Transformieren der verbundenen Dokumente. $unwind zerlegt Array-Felder (ein Ausgabedokument pro Array-Element) — oft nach $lookup, um Ergebnisse zu glätten. Joins sind in MongoDB weniger effizient als eingebettete Daten.

mongodb
# $lookup: join another collection (left outer join)
{ $lookup: {
  from: "orders",
  localField: "_id",
  foreignField: "customerId",
  as: "orders"
}}

# with pipeline (filtered/transformed join)
{ $lookup: {
  from: "orders",
  let: { custId: "$_id" },
  pipeline: [
    { $match: { $expr: { $eq: ["$customerId", "$$custId"] } } },
    { $project: { amount: 1, _id: 0 } }
  ],
  as: "recentOrders"
}}

# $unwind: flatten an array field into multiple docs
{ $unwind: "$orders" }

$unwind, $sort & $facet

$facet führt mehrere Sub-Pipelines auf derselben Eingabe aus — perfekt für Dashboards, die mehrere Aggregationen (Top N, Zählungen, Aufschlüsselungen) in einer Abfrage brauchen. $bucket kategorisiert Werte automatisch in Bereiche. $unwind mit preserveNullAndEmptyArrays behält Dokumente mit leerem oder fehlendem Array — verhindert Datenverlust in Pipelines.

mongodb
# $unwind with preserveNullAndEmptyArrays
{ $unwind: {
  path: "$tags",
  preserveNullAndEmptyArrays: true
}}

# $sort within pipeline
{ $sort: { total: -1 } }

# $facet: run multiple pipelines in parallel
{ $facet: {
  "topCustomers": [{ $sort: {total:-1} }, { $limit: 5 }],
  "byCategory":   [{ $group: { _id: "$cat" } }],
  "totalCount":   [{ $count: "n" }]
}}

# $bucket: group into ranges automatically
{ $bucket: {
  groupBy: "$price",
  boundaries: [0, 50, 100, 500],
  default: "other",
  output: { count: { $sum: 1 } }
}}
07

Transaktionen

ACID-Transaktionen

Mehrdokument-Transaktionen bieten ACID-Garantien über Collections hinweg (erfordert ein Replica-Set oder Sharded Cluster). Die Session an jede Operation in der Transaktion übergeben. commitTransaction macht Änderungen dauerhaft und sichtbar; abortTransaction rollt alles zurück. Transaktionen kurz halten — sie halten Locks und können die Performance beeinträchtigen.

mongodb
# multi-document transaction (replica set required)
const session = db.getMongo().startSession()
session.startTransaction()

try {
  db.accounts.updateOne(
    { name: "Alice" }, { $inc: { balance: -100 } }, { session }
  )
  db.accounts.updateOne(
    { name: "Bob" }, { $inc: { balance: 100 } }, { session }
  )
  session.commitTransaction()
} catch (e) {
  session.abortTransaction()
  print("Transaction aborted: " + e)
} finally {
  session.endSession()
}

Transaktions-Read/Write-Concern

Der Read Concern steuert, wie 'frisch' und konsistent Lesevorgänge sind. 'snapshot' liefert eine transaktionskonsistente Sicht über Shards hinweg — ideal fürs Reporting. Der Write Concern steuert Dauerhaftigkeit: w:majority stellt sicher, dass Daten repliziert sind, bevor bestätigt wird (übersteht einen Primary-Failover); j:true wartet auf den Journal-Flush. Höhere Concerns sind sicherer, aber langsamer.

mongodb
# set transaction-level read/write concern
session.startTransaction({
  readConcern: { level: "snapshot" },
  writeConcern: { w: "majority", j: true, wtimeout: 5000 }
})

# read concern levels:
#   "local"      - sees latest local data (default)
#   "majority"   - committed, replicated to majority
#   "snapshot"   - consistent snapshot across shards

# write concern levels:
#   { w: 1 }             - ack from primary (default)
#   { w: "majority" }    - ack from majority of members
#   { j: true }          - wait for journal write

Retry-Logik & Fehler

MongoDB markiert wiederholbare Fehler mit errorLabels: TransientTransactionError (ganze Transaktion wiederholen) und UnknownCommitResult (nur Commit wiederholen). Produktions-Treiber bieten eingebautes Retry. Transaktionen nach Möglichkeit idempotent gestalten. Langlebige Transaktionen vermeiden, die Locks halten und andere Operationen blockieren.

mongodb
# transactions can fail with TransientTransactionError
# retry the whole transaction on these errors

function runTransaction(txnFunc) {
  while (true) {
    const session = db.getMongo().startSession()
    try {
      session.startTransaction()
      txnFunc(session)
      session.commitTransaction()
      return
    } catch (e) {
      session.abortTransaction()
      if (e.errorLabels &&
          e.errorLabels.includes("TransientTransactionError")) {
        continue  // retry
      }
      throw e   // non-retryable error
    } finally {
      session.endSession()
    }
  }
}

Atomare Einzeldokument-Operationen

Einzeldokument-Operationen sind standardmäßig atomar — keine Transaktion nötig. findOneAndUpdate/findOneAndReplace/findOneAndDelete geben das Dokument atomar zurück (ideal für fortlaufende IDs). Bei vielen Workloads vermeidet das Einbetten verwandter Daten in ein Dokument plus atomare Operatoren ($inc, $push) Mehrdokument-Transaktionen ganz.

mongodb
# single-document operations are ALWAYS atomic
db.counters.updateOne(
  { _id: "pageViews" },
  { $inc: { count: 1 } }
)

# findAndModify: atomically find & update, return the doc
db.sequences.findOneAndUpdate(
  { _id: "orderId" },
  { $inc: { seq: 1 } },
  { returnNewDocument: true }
)

# atomic upsert (create-or-increment)
db.counters.updateOne(
  { _id: "visits", date: "2025-01-01" },
  { $inc: { count: 1 } },
  { upsert: true }
)

# use $expr for conditional atomic updates
db.products.updateMany(
  { $expr: { $lt: ["$stock", "$reorderLevel"] } },
  { $set: { needsRestock: true } }
)

Two-Phase-Commit (Muster)

Das Two-Phase-Commit-Muster simuliert verteilte Transaktionen ohne native Mehrdokument-Transaktionen. Es trackt einen 'pending'-Zustand, damit ein Wiederherstellungsprozess bei einem Absturz mitten im Transfer fortsetzen oder zurückrollen kann. Wenn verfügbar native Transaktionen verwenden — dieses Muster ist komplex und fehleranfällig und dient v. a. Lehr- und Legacy-Zwecken.

mongodb
# pattern for atomic transfers without transactions
# (pre-4.0 compatibility, or cross-system transfers)

# 1. create a pending transaction document
db.transactions.insertOne({
  _id: "t1", from: "Alice", to: "Bob", amount: 100, state: "pending"
})

# 2. debit source
db.accounts.updateOne(
  { name: "Alice", pendingTransactions: { $ne: "t1" } },
  { $inc: { balance: -100 }, $push: { pendingTransactions: "t1" } }
)

# 3. credit destination
db.accounts.updateOne(
  { name: "Bob", pendingTransactions: { $ne: "t1" } },
  { $inc: { balance: 100 }, $push: { pendingTransactions: "t1" } }
)

# 4. mark transaction done
db.transactions.updateOne({ _id: "t1" }, { $set: { state: "done" } })

# 5. clean up pending references
db.accounts.updateMany({},
  { $pull: { pendingTransactions: "t1" } })
08

Datenmodellierung

Einbetten vs. Referenzieren

Die zentrale Entscheidung beim MongoDB-Modellieren: Einbetten für Daten, die gemeinsam gelesen und selten geändert werden; Referenzieren für große, geteilte oder unabhängig aktualisierte Daten. Einbetten, wenn die 'hat-ein'-Beziehung exklusiv ist (die Adressen eines Nutzers). Referenzieren, wenn Daten wiederverwendet werden (ein Produkt in vielen Bestellungen) oder unbegrenzt wachsen (Millionen Logeinträge eines Nutzers).

mongodb
# EMBED: store related data in one document
db.users.insertOne({
  name: "Alice",
  addresses: [
    { city: "NYC", zip: "10001" },
    { city: "LA", zip: "90001" }
  ]
})
# Pros: single read, atomic update
# Cons: document size limit (16MB), data duplication

# REFERENCE: store IDs, join with $lookup
db.users.insertOne({ name: "Alice" })
db.orders.insertOne({
  customerId: ObjectId("..."),
  amount: 100
})
# Pros: no duplication, independent updates
# Cons: needs joins, more queries

Eins-zu-viele-Beziehungen

Bei 'wenigen' Beziehungen einbetten. Bei 'vielen' vom Kind aus referenzieren (Parent-ID an jedem Kind). Bei 'sehr vielen' (Millionen) das Bucket-Pattern nutzen: Kinddokumente in vom Parent verwalteten Buckets gruppieren (z. B. nach Monat), um Dokumentgröße und Abfragetempo auszubalancieren. Das vermeidet sowohl unbegrenzte Arrays als auch übermäßige Kinddokumente.

mongodb
# FEW: embed (e.g., a few addresses per user)
db.users.insertOne({
  name: "Alice",
  addresses: [{ city: "NYC" }, { city: "LA" }]
})

# MANY: reference with parent pointer
db.posts.insertOne({ title: "Hello", authorId: ObjectId("...") })

# VERY MANY: reference from parent (bucket pattern)
db.users.updateOne(
  { _id: userId },
  { $push: { postIds: postId } }   # beware 16MB limit
)

# BUCKET pattern for time series (thousands of items)
db.buckets.insertOne({
  ownerId: userId,
  date: "2025-01",
  measurements: [ {t: 1, v: 30}, {t: 2, v: 31} ]
})

Viele-zu-viele-Beziehungen

Bei Many-to-Many den Ansatz nach Abfragemustern und Datenmenge wählen. Beidseitige Arrays sind schnell, erfordern aber doppelte Pflege. Eine Junction-Collection (Mapping-Tabelle) ist am flexibelsten und skaliert am besten — sie kann Beziehungsmetadaten (Einschreibedatum, Note) speichern und hält die Parent-Dokumente schlank.

mongodb
# option 1: arrays of ObjectIds on both sides
db.students.insertOne({ name: "Alice", courseIds: [c1, c2] })
db.courses.insertOne({ name: "Math", studentIds: [s1, s2] })

# option 2: one side references (smaller side)
db.students.insertOne({ name: "Alice", courseIds: [c1, c2] })

# option 3: mapping/junction collection
db.enrollments.insertOne({
  studentId: s1,
  courseId: c1,
  enrolledAt: ISODate(),
  grade: "A"
})

# query: find a student's courses
db.enrollments.find({ studentId: s1 })

Schema-Design-Muster

Das Attribute-Pattern behandelt Entitäten mit wechselnden Attributen (Produkte mit unterschiedlichen Spezifikationen) — vermeidet spärliche Felder und ermöglicht dynamische Attribute. Das Polymorphic-Pattern speichert ähnliche, aber verschiedene Formen in einer Collection mit Typdiskriminator. Das Outlier-Pattern behandelt Ausnahmen (eine Berühmtheit mit Millionen Followern) durch Referenzieren statt Einbetten.

mongodb
# ATTRIBUTE PATTERN: flexible attributes (e.g., products)
db.products.insertOne({
  name: "Laptop",
  attributes: [
    { k: "cpu", v: "i7" },
    { k: "ram", v: 16 }
  ]
})
# query: db.products.find({ "attributes.k": "cpu", "attributes.v": "i7" })

# POLYMORPHIC PATTERN: one collection, type discriminator
db.events.insertMany([
  { type: "click", url: "/home", userId: 1 },
  { type: "purchase", orderId: 99, total: 50 }
])

# OUTLIER PATTERN: cap large lists
db.users.updateOne({n:"A"}, { $set: { reviews: "see reviews collection" } })

Schema-Validierung

Schema-Validierung erzwingt die Dokumentstruktur beim Schreiben — MongoDBs Antwort auf feste Schemata. validationLevel 'strict' validiert alle Schreibvorgänge; 'moderate' nur Inserts und vollständige Updates. validationAction 'error' verwirft ungültige Dokumente; 'warn' protokolliert sie nur. Validierung ergänzt (nicht ersetzt) die Validierung auf Anwendungsebene.

mongodb
# add a JSON schema validator to a collection
db.createCollection("users", {
  validator: {
    $jsonSchema: {
      bsonType: "object",
      required: ["name", "email"],
      properties: {
        name: { bsonType: "string", maxLength: 100 },
        email: { bsonType: "string", pattern: "^\S+@\S+$" },
        age: { bsonType: "int", minimum: 0, maximum: 150 },
        role: { enum: ["admin", "user", "guest"] }
      }
    }
  },
  validationLevel: "strict",
  validationAction: "error"
})

# add validation to an existing collection
db.runCommand({ collMod: "users", validator: { ... } })

# check existing validation rules
db.getCollectionInfos({ name: "users" })
09

Replica-Sets

Replica-Set-Grundlagen

Ein Replica-Set bietet Hochverfügbarkeit und Leseskalierung. Nur ein Member ist Primary (nimmt Schreibvorgänge an); die anderen replizieren asynchron. Fällt der Primary aus, kürt eine Wahl automatisch ein Secondary. Eine ungerade Zahl stimmberechtigter Member (mindestens 3) vermeidet Stimmengleichheit bei Wahlen. rs.status() zeigt Gesundheit, Zustand und Replikationsverzögerung jedes Members.

mongodb
# a replica set = 1 primary + N secondaries
# all writes go to the primary; secondaries replicate

# initiate a replica set
rs.initiate({
  _id: "rs0",
  members: [
    { _id: 0, host: "host1:27017" },
    { _id: 1, host: "host2:27017" },
    { _id: 2, host: "host3:27017" }
  ]
})

# check replica set status
rs.status()
rs.conf()

# step down the primary (force an election)
rs.stepDown(60)

# add a new member
rs.add("host4:27017")
rs.remove("host4:27017")

Read Preference

Die Read Preference balanciert Konsistenz gegen Last. primary garantiert, dass du immer die neuesten Schreibvorgänge liest. secondary/secondaryPreferred entlasten den Primary, Daten können aber veraltet sein (Replikationsverzug, meist Millisekunden). nearest minimiert Latenz — ideal für geografisch verteilte Apps. Analytische/Reporting-Workloads sollten Secondary-Lesevorgänge nutzen.

mongodb
# control where reads are routed
# primary (default) - always read from primary (strongest consistency)
db.users.find().readPref("primary")

# primaryPreferred - primary if available, else secondary
db.users.find().readPref("primaryPreferred")

# secondary - only secondaries (may be stale)
db.users.find().readPref("secondary")

# secondaryPreferred - prefer secondaries to offload primary
db.users.find().readPref("secondaryPreferred")

# nearest - lowest latency member
db.users.find().readPref("nearest")

# set in connection string
mongodb://host1:27017/mydb?replicaSet=rs0&readPreference=secondary

Write Concern

Der Write Concern tauscht Tempo gegen Sicherheit. w:1 bestätigt, sobald der Primary schreibt (schnell, riskiert aber Datenverlust, wenn der Primary vor der Replikation abstürzt). w:majority stellt sicher, dass der Schreibvorgang repliziert ist — übersteht einen einzelnen Knotenausfall (empfohlen für wichtige Daten). j:true wartet auf den Journal-Flush auf der Platte. Einen sinnvollen Standard auf Clusterebene setzen.

mongodb
# control how durable a write must be before ack
# w: 1 - primary acks (default, fastest, least safe)
db.users.insertOne(doc, { writeConcern: { w: 1 } })

# w: "majority" - majority of members confirmed
db.users.insertOne(doc, { writeConcern: { w: "majority" } })

# j: true - wait for journal flush (survives crash)
db.users.insertOne(doc, { writeConcern: { w: 1, j: true } })

# wtimeout - max wait time in ms
db.users.insertOne(doc, {
  writeConcern: { w: "majority", wtimeout: 5000 }
})

# set default write concern for the cluster
db.adminCommand({
  setDefaultRWConcern: { defaultWriteConcern: { w: "majority" } }
})

Arbiters & Wahlen

Arbiters liefern eine Stimme für die Mehrheit, ohne Daten zu speichern — nützlich bei Zwei-Knoten-Deployments, aber ein dritter Datenknoten ist besser. Priority-0-Member werden nie Primary (gut für dedizierte Analyse- oder DR-Knoten). Hidden-Member sind von der Read Preference 'nearest' ausgeschlossen und ideal für Backups. Delayed-Member hinken hinterher und ermöglichen die Wiederherstellung versehentlicher Löschungen.

mongodb
# an arbiter votes in elections but holds no data
rs.addArb("host5:27017")

# useful to break ties in even-member sets (e.g., 2 data + 1 arbiter)
# but prefer 3 data members for durability

# force a member to never become primary (priority 0)
rs.conf().members[1].priority = 0
rs.reconfig(rs.conf())

# hidden member: not visible to clients, used for analytics/backup
rs.conf().members[2].hidden = true
rs.conf().members[2].priority = 0
rs.reconfig(rs.conf())

# delayed member: lags behind (insurance against human errors)
rs.conf().members[3].secondaryDelaySecs = 3600
rs.conf().members[3].priority = 0

Oplog & Replikations-Interna

Das Oplog (operation log) ist eine capped Collection, die jeden Schreibvorgang aufzeichnet — Secondaries wenden diese Einträge in Reihenfolge an, um zu replizieren. Hinkt ein Secondary über das Oplog-Fenster hinaus, braucht er eine vollständige Resynchronisation. printReplicationInfo zeigt die Zeitspanne des Oplogs; printSecondaryReplicationInfo den Verzug jedes Secondary. Größere Oplogs verkraften längere Ausfallzeiten.

mongodb
# the oplog is a capped collection of all writes
use local
db.oplog.rs.stats()
db.oplog.rs.find().sort({ $natural: -1 }).limit(5)

# each oplog entry is an idempotent operation
# { ts: ..., op: "i", ns: "mydb.users", o: { ... } }

# check replication lag
rs.printReplicationInfo()   # primary's oplog window
rs.printSecondaryReplicationInfo()  # each secondary's lag

# resync a stale secondary (full re-sync)
rs.syncFrom("host2:27017")

# change the oplog size (MongoDB 4.4+)
db.adminCommand({ replSetResizeOplog: 1, size: 16384 })  # MB
10

Sharding

Sharding-Grundlagen

Sharding skaliert eine Collection horizontal über mehrere Shards. Der Shard Key bestimmt die Datenverteilung und ist nach dem Sharding unveränderlich. Hashed Sharding verteilt gleichmäßig (gut für monoton wachsende Schlüssel wie ObjectId); Ranged Sharding ermöglicht gezielte Abfragen, kann aber Hotspots erzeugen. Den Shard Key sorgfältig wählen — er lässt sich später nicht leicht ändern.

mongodb
# sharding distributes data across multiple machines
# requires: config servers + shard replica sets + mongos router

# enable sharding on a database
sh.enableSharding("mydb")

# shard a collection (index on shard key required first)
sh.shardCollection("mydb.users", { userId: 1 })

# hash-based sharding (even distribution)
db.users.createIndex({ userId: "hashed" })
sh.shardCollection("mydb.users", { userId: "hashed" })

# view shard status
sh.status()
sh.addShard("rs1/host1:27017,host2:27017")

# balancer moves chunks between shards automatically
sh.startBalancer()
sh.stopBalancer()

Shard-Key-Wahl

Der Shard Key ist die kritischste Sharding-Entscheidung. Er muss deine häufigen Abfragen unterstützen (Abfragen ohne Shard Key treffen alle Shards — Scatter-Gather). Hohe Kardinalität verhindert unbewegliche Jumbo-Chunks. Monotone Schlüssel (Zeitstempel, ObjectIds) lenken alle Inserts auf einen Shard — dafür hashed Sharding verwenden. Compound-Keys sollten mit dem selektivsten Feld beginnen.

mongodb
# GOOD shard key properties:
# - high cardinality (many distinct values)
# - low frequency (no single value dominates)
# - non-monotonic (avoids hot shards) OR use hashed

# hashed shard key (even distribution)
sh.shardCollection("mydb.logs", { _id: "hashed" })

# ranged shard key (enables targeted queries)
sh.shardCollection("mydb.events", { region: 1, date: 1 })

# compound shard key
sh.shardCollection("mydb.orders", { customerId: 1, orderId: 1 })

# check chunk distribution
db.getSiblingDB("config").chunks.find({ ns: "mydb.users" })

# see data distribution per shard
db.users.getShardDistribution()

Zonen & Tag-Aware Sharding

Zonen (tag-aware sharding) routen bestimmte Datenbereiche zu bestimmten Shards — das ermöglicht Data-Residency-Compliance (GDPR verlangt EU-Daten in der EU), Geo-Lokalität (schnelle regionale Lesevorgänge) oder Hardware-Stufen (heiße Daten auf SSDs, kalte auf HDDs). Der Balancer respektiert Zonenbereiche beim Chunk-Migration. Erst Shard-Tags definieren, dann Bereiche taggen.

mongodb
# tag shards by region (data locality / compliance)
sh.addShardTag("shard-us-east", "US")
sh.addShardTag("shard-eu", "EU")

# associate a key range with a tag
sh.addTagRange(
  "mydb.users",
  { region: "US", _id: MinKey },
  { region: "US", _id: MaxKey },
  "US"
)
sh.addTagRange(
  "mydb.users",
  { region: "EU", _id: MinKey },
  { region: "EU", _id: MaxKey },
  "EU"
)

# the balancer migrates tagged data to tagged shards
# useful for data residency (GDPR) and geo-locality

Chunk-Verwaltung

Chunks sind die Einheit der Datenbewegung zwischen Shards. Der Balancer teilt und migriert Chunks automatisch, um Shards auszugleichen. Jumbo-Chunks überschreiten das Größenlimit und können nicht migrieren — mit guter Shard-Key-Kardinalität vermeiden. Die Standard-Chunk-Größe von 128 MB balanciert Migrationsgeschwindigkeit und Overhead. Manuelle Chunk-Operationen sind für die Fehleranalyse, nicht für den Routinebetrieb.

mongodb
# chunks are ranges of shard key values
# default chunk size: 128MB (configurable)

# view chunks for a collection
db.getSiblingDB("config").chunks.find({ ns: "mydb.users" })

# manually move a chunk (testing)
sh.moveChunk("mydb.users", { userId: 100 }, "shard2")

# split a chunk at a specific value
sh.splitAt("mydb.users", { userId: 1000 })

# merge contiguous chunks
sh.mergeChunks("mydb.users",
  { userId: MinKey },
  { userId: 1000 }
)

# find chunks too large to migrate (jumbo chunks)
sh.status(true)   # verbose

Komponenten eines Sharded Clusters

Ein Sharded Cluster hat drei Komponenten: Config-Server (Metadaten, als Replica-Set deployt), mongos-Router (zustandslose Query-Router, mit denen sich Clients verbinden) und Shards (jeweils ein Replica-Set mit einer Datenteilmenge). Clients verbinden sich nie direkt mit Shards. Das Entfernen eines Shards löst eine Migration der Daten auf die restlichen Shards aus — ein langsamer Prozess, der beobachtet werden sollte.

mongodb
# config servers store metadata and routing info
# (deploy as a 3-member replica set)
# config server connection string:
# mongodb://cfg1:27019,cfg2:27019,cfg3:27019/config?replicaSet=cfgRS

# mongos is the query router (stateless, scale horizontally)
# clients connect to mongos, not shards directly
mongos --configdb cfgRS/cfg1:27019,cfg2:27019,cfg3:27019

# each shard is a replica set
sh.addShard("shardRS1/s1a:27017,s1b:27017,s1c:27017")
sh.addShard("shardRS2/s2a:27017,s2b:27017,s2c:27017")

# check cluster status
sh.status()

# remove a shard (migrates its data first)
db.adminCommand({ removeShard: "shardRS2" })
11

Sicherheit & Authentifizierung

Authentifizierung & Nutzer

Authentifizierung prüft die Identität. Den Admin-Nutzer anlegen, bevor auth aktiviert wird, sonst sperrst du dich aus. Eingebaute Rollen reichen von read-only bis vollem Admin. In der Shell passwordPrompt() verwenden, um Klartextpasswörter in der History zu vermeiden. Jeder Nutzer ist an eine Datenbank gebunden, kann aber Rollen auf anderen Datenbanken haben. In Produktion TLS aktivieren (net.tls.mode).

mongodb
# enable auth: start mongod with --auth
# or set security.authorization: "enabled" in config

# create the first admin user (before enabling auth)
use admin
db.createUser({
  user: "admin",
  pwd: passwordPrompt(),   // prompts securely
  roles: [ { role: "userAdminAnyDatabase", db: "admin" },
           { role: "readWriteAnyDatabase", db: "admin" } ]
})

# create a user for a specific database
use mydb
db.createUser({
  user: "appUser",
  pwd: passwordPrompt(),
  roles: [ { role: "readWrite", db: "mydb" } ]
})

# authenticate as a user
db.auth("appUser", "password")

Eingebaute & eigene Rollen

Eingebaute Rollen decken typische Fälle ab; eigene Rollen ermöglichen least-privilege. Privilegien paaren eine Ressource (Datenbank/Collection) mit erlaubten Aktionen (find, insert, update usw.). Nur das Nötigste gewähren — ein Reporting-Nutzer braucht nur 'find' auf bestimmten Collections. Eigene Rollen werden in der admin-Datenbank gespeichert und lassen sich über Nutzer hinweg wiederverwenden.

mongodb
# built-in roles:
#   read, readWrite, dbAdmin, dbOwner, userAdmin  (per database)
#   readAnyDatabase, readWriteAnyDatabase,         (all databases)
#   userAdminAnyDatabase, dbAdminAnyDatabase
#   root (superuser), clusterAdmin, backup, restore

# create a custom role with fine-grained privileges
db.createRole({
  role: "analyst",
  privileges: [
    { resource: { db: "mydb", collection: "reports" },
      actions: ["find"] },
    { resource: { db: "mydb", collection: "" },
      actions: ["listCollections"] }
  ],
  roles: []
})

# grant a role to a user
db.grantRolesToUser("appUser", [{ role: "analyst", db: "mydb" }])
db.revokeRolesFromUser("appUser", [{ role: "analyst", db: "mydb" }])

TLS/SSL-Verschlüsselung

TLS verschlüsselt Daten bei der Übertragung — in Produktion Pflicht. requireTLS weist Nicht-TLS-Verbindungen ab. Für interne PKI die x.509-Zertifikatsauthentifizierung verwenden (keine Passwörter — das Zertifikat IST die Anmeldeinformation). Die $external-Datenbank speichert x.509-Nutzer. In Produktion immer eine echte CA (oder interne CA) nutzen; selbstsignierte Zertifikate sind nur für Tests.

mongodb
# enable TLS in mongod.conf
net:
  tls:
    mode: requireTLS
    certificateKeyFile: /etc/mongodb/server.pem
    CAFile: /etc/mongodb/ca.pem

# connect with TLS and verify the server cert
mongosh "mongodb://host:27017/mydb" \
  --tls --tlsCAFile /etc/mongodb/ca.pem

# connect with a client certificate (x.509 auth)
mongosh "mongodb://host:27017/mydb" \
  --tls --tlsCertificateKeyFile client.pem \
  --tlsCAFile ca.pem \
  --authenticationMechanism MONGODB-X509 \
  --authenticationDatabase '$external'

# generate a self-signed cert for testing
openssl req -x509 -newkey rsa:4096 -nodes \
  -keyout server.key -out server.crt -days 365

Netzwerk & Auditing

bindIp begrenzt, welche Netzwerkinterfaces MongoDB abhört — MongoDB niemals direkt ins Internet stellen (bindIp: 0.0.0.0 + keine Auth hat unzählige Sicherheitsvorfälle verursacht). Auditing (nur Enterprise) protokolliert sicherheitsrelevante Operationen für Compliance. Die Community-Edition kann OS-Werkzeuge (auditd) oder App-Level-Logging als Ersatz nutzen.

mongodb
# restrict network interface in mongod.conf
net:
  bindIp: 127.0.0.1,10.0.0.5    # never 0.0.0.0 in production
  port: 27017

# enable auditing (enterprise feature)
auditLog:
  destination: file
  format: JSON
  path: /var/log/mongodb/audit.log
  filter: '{ atype: { $in: ["authenticate","createCollection","dropDatabase"] } }'

# view current authentication mechanisms
db.runCommand({ getCmdLineOpts: 1 })

# enable FIPS mode (government compliance)
setParameter:
  fipsMode: true

Feldbasierte Verschlüsselung (CSFLE)

CSFLE verschlüsselt sensible Felder auf dem Client, sodass Server, Backups und Logs nie Klartext enthalten — der stärkste Datenschutz. Deterministische Verschlüsselung unterstützt Gleichheitsabfragen; zufällige ist sicherer, aber nicht abfragbar. Auto-Verschlüsselung (über ein Treiber-Schema) ist für App-Code transparent. Die Verschlüsselungsschlüssel liegen in einem KMS (AWS KMS, lokaler Schlüssel usw.).

mongodb
# Client-Side Field Level Encryption encrypts fields
# before sending to the server — server never sees plaintext

# define a data key in the key vault
const clientEncryption = db.getMongo().getClientEncryption()
const keyId = clientEncryption.createDataKey(
  "local", { keyAltNames: ["mainKey"] }
)

# encrypt a field explicitly
const ssn = clientEncryption.encrypt(
  keyId, "123-45-6789", "deterministic"
)

# store encrypted, query with encrypted value
db.patients.insertOne({ name: "Alice", ssn: ssn })
db.patients.find({
  ssn: clientEncryption.encrypt(keyId, "123-45-6789", "deterministic")
})

# automatic CSFLE uses a schema to encrypt per a JSON schema
# { encryptMetadata: { keyId: [keyId], algorithm: "AEAD_AES_256_CBC..." } }
12

Backup & Wiederherstellung

mongodump & mongorestore

mongodump erzeugt ein logisches Backup (BSON-Dateien) — portabel, aber langsam für große Datensätze und ohne --oplog nicht zeitsynchron über Collections hinweg. --drop löscht bestehende Collections vor der Wiederherstellung. --archive + --gzip ergeben eine einzige komprimierte Datei. Für große Produktions-Backups lieber Dateisystem-Snapshots oder Percona Backup statt mongodump.

mongodb
# dump an entire database
mongodump --db=mydb --out=/backup/$(date +%F)

# dump a single collection
mongodump --db=mydb --collection=users --out=/backup

# dump with a query filter
mongodump --db=mydb --collection=logs \
  --query='{"date":{"$gte":{"$date":"2025-01-01T00:00:00Z"}}}'

# compress the output archive
mongodump --archive=/backup/full.gz --gzip

# restore from a dump
mongorestore --db=mydb --drop /backup/2025-01-01/mydb
mongorestore --archive=/backup/full.gz --gzip

mongoexport & mongoimport

mongoexport/mongoimport arbeiten mit JSON/CSV — für Datenaustausch mit anderen Systemen, nicht für Backups (sie verlieren BSON-Typen wie ObjectId und Date-Präzision). Für Backups mongodump verwenden. CSV-Exporte sind ideal für Tabellenkalkulationen und BI-Tools. Immer --fields angeben für vorhersagbare CSV-Spaltenreihenfolge. JSON-Exporte sind standardmäßig auf ein Dokument pro Zeile begrenzt (--jsonArray für ein einzelnes Array).

mongodb
# export to JSON (human-readable)
mongoexport --db=mydb --collection=users \
  --out=users.json

# export to CSV
mongoexport --db=mydb --collection=users \
  --type=csv --fields=name,email,age --out=users.csv

# export with a query filter
mongoexport --db=mydb --collection=users \
  --query='{"status":"active"}' --out=active.json

# import from JSON
mongoimport --db=mydb --collection=users --file=users.json

# import from CSV with header row
mongoimport --db=mydb --collection=users \
  --type=csv --headerline --file=users.csv

Dateisystem-Snapshots

Dateisystem-Snapshots sind die schnellste Backup-Methode für große Datensätze — sie erfassen das gesamte Datenverzeichnis konsistent. fsyncLock blockiert Schreibvorgänge kurz und spült auf die Platte, sodass der Snapshot konsistent ist. Snapshots sind nahezu sofort, unabhängig von der Datenmenge. Wiederherstellen ist so einfach wie Zurückkopieren — viel schneller als mongorestore. Am besten auf LVM, ZFS oder Cloud-Block-Storage (EBS-Snapshots).

mongodb
# snapshot the dbPath volume for a consistent backup
# 1. flush writes to disk and lock (brief)
db.fsyncLock()

# 2. take a filesystem snapshot (LVM, ZFS, EBS, etc.)
lvcreate --snapshot --size 1G --name mongosnap /dev/vg/data

# 3. unlock the database
db.fsyncUnlock()

# 4. mount the snapshot and copy or back it up
mount /dev/vg/mongosnap /mnt/snap
rsync -a /mnt/snap/ /backup/

# restore: stop mongod, replace dbPath, start mongod
# (fastest restore method for large datasets)

Point-in-Time-Recovery (oplog)

Point-in-time recovery (PITR) rekonstruiert den Datenbankzustand zu einem bestimmten Zeitpunkt — essenziell nach versehentlichen Löschungen oder fehlerhaften Migrationen. Regelmäßige Basis-Backups mit --oplog anlegen, dann das Oplog bis zum gewünschten Zeitpunkt wiedergeben (--oplogLimit stoppt genau vor einer fehlerhaften Operation). PITR erfordert ein Replica-Set (das Oplog existiert nur auf Replica-Set-Membern).

mongodb
# 1. take a base backup (snapshot or mongodump --oplog)
mongodump --archive=/backup/base.gz --oplog --gzip

# 2. note the time of the accident
# 3. replay the oplog up to just before the error

# dump the oplog from a secondary
mongodump --db=local --collection=oplog.rs \
  --query='{"ts":{"$gt":{"$timestamp":{"t":1700000000,"i":1}}}}' \
  --out=/oplog_dump

# restore the base backup, then replay oplog
mongorestore --archive=/backup/base.gz --oplogReplay \
  --oplogLimit=1700000123:1   # stop before this timestamp

# for a running replica set, use mongorestore --oplogReplay
# with a BSON oplog file

Atlas-Backup & Cloud-Optionen

MongoDB Atlas bietet verwaltete kontinuierliche Backups mit Point-in-Time-Recovery — am einfachsten für Cloud-Deployments. Percona Backup for MongoDB (PBM) ist das führende Open-Source-Backup-Werkzeug für selbst gehostete Cluster, mit physischen Backups und PITR über Replica-Sets und Sharded Cluster hinweg. Wiederherstellungsverfahren immer testen — ein Backup, das du nicht wiederherstellen kannst, ist kein Backup.

mongodb
# MongoDB Atlas: continuous backups with PITR
# configured via UI or Atlas CLI:
atlas backups policies create [clusterId] ...

# on-demand snapshot
atlas backups snapshots create [clusterId] \
  --description "pre-migration" \
  --retentionDays 7

# restore an Atlas snapshot
atlas backups restores start [clusterId] \
  --snapshotId [snapId] \
  --deliveryType automated \
  --targetClusterName [target]

# Percona Backup for MongoDB (PBM) — open source
pbm backup --type=physical
pbm restore [snapshotName]
pbm pitr restore --time "2025-01-15T14:30:00"
13

Performance & Optimierung

Langsame Abfragen profilen

Der Database-Profiler protokolliert Operationen, die langsamer als slowms sind (Standard 100 ms), in system.profile (eine capped Collection). Stufe 2 protokolliert alles — nützlich zum Debuggen, beeinträchtigt aber die Performance. Auf millis (Dauer), nreturned (gelieferte Dokumente) und docsExamined achten, um ineffiziente Abfragen zu finden. Profiling danach deaktivieren.

mongodb
# enable the database profiler
# levels: 0=off, 1=slow ops only, 2=all ops
db.setProfilingLevel(1, { slowms: 100 })

# view profiled operations
db.system.profile.find().sort({ ts: -1 }).limit(5)

# find the slowest operations
db.system.profile.find({ millis: { $gt: 1000 } })
  .sort({ millis: -1 })

# profile a specific collection
db.system.profile.find({ ns: "mydb.users" })

# get current profiling level
db.getProfilingStatus()

# clear the profile collection
db.system.profile.drop()

explain() im Detail

explain() ist dein wichtigstes Tuning-Werkzeug. COLLSCAN heißt vollständiger Collection-Scan — Index ergänzen. Das Verhältnis von docsExamined zu nReturned ist die entscheidende Effizienzmetrik: 10000 geprüfte Dokumente für 10 Ergebnisse heißen schlechter Index. allPlansExecution zeigt, warum der Planer seinen Plan wählte. Gleichheits-, Sortier- und Bereichsfelder deiner Abfrage indexieren (ESR-Regel).

mongodb
# three verbosity modes
db.users.find({age:30}).explain("queryPlanner")     # plan only
db.users.find({age:30}).explain("executionStats")    # + timing
db.users.find({age:30}).explain("allPlansExecution") # + rejected plans

# key metrics to check:
#   winningPlan.stage: COLLSCAN (bad) vs IXSCAN (good)
#   totalKeysExamined: index entries scanned
#   totalDocsExamined: documents fetched
#   nReturned: documents returned
#   executionTimeMillis: total time
#   works: number of work units

# ideal ratio: docsExamined ≈ nReturned
# if docsExamined >> nReturned -> missing or bad index

Working Set & Speicher

Die Performance hängt davon ab, dass das Working Set (häufig gelesene Daten) in den RAM passt. Ist wiredTiger.cache 'pages read into cache' hoch, gehst du auf die Platte — RAM ergänzen oder Indizes ergänzen, um Scans zu reduzieren. mongotop zeigt, welche Collections I/O-heiß sind; mongostat zeigt Abfrage-/Insert-/Update-Raten und Faults. compact holt verschwendeten Plattenplatz gelöschter/geänderter Dokumente zurück.

mongodb
# check the working set size
db.serverStatus().wiredTiger.cache
# look at: "maximum bytes configured", "current bytes"
#          "pages requested from disk" vs "pages read into cache"

# check storage stats
db.stats()
db.users.stats()
db.users.totalSize()   # data + index size in bytes

# mongotop: time spent reading/writing per collection
mongotop 30   # every 30 seconds

# mongostat: live server stats
mongostat --rowcount 10  # 10 iterations

# compact a collection (reclaims disk, blocks writes pre-4.4)
db.runCommand({ compact: "users" })

Connection Pooling

Jede MongoDB-Verbindung verbraucht Server-Speicher — Tausende Verbindungen verschlechtern die Performance. Connection Pooling nutzen (Treiber pflegen einen wiederverwendbaren Pool) mit maxPoolSize passend zur Last (50-100 üblich). Einen einzigen MongoClient über die App teilen — niemals pro Request einen anlegen. maxIdleTimeMS setzen, um veraltete Verbindungen hinter Load Balancern zu recyceln.

mongodb
# each connection consumes memory (~1MB) on the server
# limit connections in the driver's connection string
mongodb://host:27017/mydb?maxPoolSize=50

# Node.js driver example
const { MongoClient } = require("mongodb")
const client = new MongoClient(uri, {
  maxPoolSize: 50,        // max connections
  minPoolSize: 5,         // keep-alive connections
  maxIdleTimeMS: 30000,   // close idle conns after 30s
  serverSelectionTimeoutMS: 5000
})

# view current connections on the server
db.serverStatus().connections
# { current: 120, available: 880, totalCreated: 200 }

Bulk-Writes & Batch-Größen

Bulk-Writes gruppieren Operationen in einen einzigen Round-Trip — deutlich schneller als Einzeloperationen. unordered:true maximiert den Durchsatz (setzt nach Fehlern fort, parallelisiert auf Sharded Clusters). Bei großen Imports in Schüben von 1000-5000 Dokumenten arbeiten, um Speicher und Round-Trips auszubalancieren. insertMany mit ordered:false ist der schnellste Weg, Daten zu laden.

mongodb
# ordered bulk write (stops on first error)
db.users.bulkWrite([
  { insertOne: { document: { name: "A" } } },
  { updateOne: { filter: {n:"B"}, update: {$set:{age:1}} } },
  { deleteOne: { filter: { n: "C" } } }
], { ordered: true })

# unordered bulk write (continues on errors, faster)
db.users.bulkWrite(ops, { ordered: false })

# insertMany is a bulk insert — batch large loads
const docs = Array.from({length: 100000}, (_,i) => ({ i }))
const batch = 1000
for (let i = 0; i < docs.length; i += batch) {
  db.big.insertMany(docs.slice(i, i + batch), { ordered: false })
}
14

Change Streams

Änderungen beobachten

Change Streams lassen Anwendungen in Echtzeit auf Datenänderungen reagieren, indem sie das Oplog nachziehen. Jedes Event enthält den Operationstyp, das vollständige Dokument (bei Inserts/Updates mit der Option fullDocument) und ein Resume-Token. Das Resume-Token speichern, um nach einem Neustart fortzusetzen, ohne Events zu verpassen oder zu duplizieren. Erfordert ein Replica-Set oder Sharded Cluster.

mongodb
# open a change stream on a collection
const stream = db.users.watch()

# process change events (Node.js driver)
stream.on("change", (event) => {
  console.log(event.operationType)  // insert|update|delete|replace
  console.log(event.fullDocument)   // the new document
  console.log(event.documentKey)    // the _id
  console.log(event.updateDescription)  // updated fields
})

# resume token enables restart from last position
const token = stream.resumeToken
// store token, then resume later:
const stream2 = db.users.watch([], { resumeAfter: token })

# close the stream
stream.close()

Change-Events filtern

Change Streams mit einer Aggregations-Pipeline filtern — nur passende Events erreichen deine App, weniger Rauschen. Standardmäßig enthalten Updates nur die geänderten Felder, nicht das ganze Dokument; fullDocument:'updateLookup' holt das aktuelle Dokument (Extra-Abfrage pro Event). fullDocumentBeforeChange (6.0+) schließt das Dokument vor der Änderung ein — nützlich für Audit-Logs.

mongodb
# filter with an aggregation pipeline
const stream = db.users.watch([
  { $match: { operationType: "update" } },
  { $match: { "updateDescription.updatedFields.status": "active" } },
  { $project: { fullDocument: 1, documentKey: 1 } }
])

# watch specific operations
{ $match: { operationType: { $in: ["insert", "update"] } } }

# full document lookup on update (fetches current doc)
db.users.watch([], {
  fullDocument: "updateLookup"   // include latest doc on updates
})

# fullDocumentBeforeChange (MongoDB 6.0+)
db.users.watch([], {
  fullDocumentBeforeChange: "whenAvailable"
})

Change Stream auf Datenbank/Cluster

Change Streams können eine einzelne Collection, eine ganze Datenbank oder den gesamten Cluster beobachten. Datenbank- und Cluster-Streams enthalten den Namensraum (ns) in jedem Event, sodass du weißt, wo die Änderung geschah. Mit startAtOperationTime Änderungen ab einem bestimmten Oplog-Punkt wiedergeben — nützlich zum Nachfüllen oder Wiederherstellen verpasster Events nach einer Ausfallzeit.

mongodb
# watch all collections in a database
const stream = db.watch()

# watch all databases in a cluster
const stream = client.watch()

# events include the ns (namespace) field
stream.on("change", (e) => {
  console.log(e.ns.db + "." + e.ns.coll)
  console.log(e.operationType)
})

# useful for audit logging, cache invalidation,
# cross-system sync, and real-time analytics

# start at a specific timestamp
db.users.watch([], {
  startAtOperationTime: Timestamp(1700000000, 1)
})

Resume-Tokens & Verlässlichkeit

Resume-Token garantieren at-least-once-Zustellung — nach dem Verarbeiten jedes Events speichern, damit ein Neustart exakt dort weitermacht, wo du aufgehört hast. resumeAfter und startAfter sind ähnlich; startAfter funktioniert sogar nach Collection-Invalidierungs-Events (wie einem drop). Fehler immer behandeln und mit dem letzten Token neu verbinden. Das Token ist opak — als Black Box behandeln.

mongodb
# each event has a resume token (_id)
stream.on("change", (e) => {
  saveToStore(e._id)        // persist the token
  processEvent(e)
})

# after a restart, resume from the last token
const lastToken = loadFromStore()
const stream = db.users.watch([], {
  resumeAfter: lastToken     // resume after this event
})

# alternative: start after a cluster time
db.users.watch([], { startAfter: lastToken })

# handle errors and reconnect
stream.on("error", (err) => {
  console.error("stream error", err)
  // reconnect with the last saved token
})

# the token is opaque — store it, don't parse it

Change-Stream-Anwendungsfälle

Change Streams treiben Echtzeit-Architekturen: Cache-Invalidierung (veraltete Cache-Einträge löschen), Live-Benachrichtigungen (WebSocket-Pushes), Audit-Logging (jede Änderung für Compliance aufzeichnen) und ETL/Sync (zu Elasticsearch, ein Data Warehouse oder ein anderes System replizieren). Sie ersetzen manuelles Polling und Trigger durch ein sauberes, reaktives ereignisgetriebenes Modell.

mongodb
# 1. Cache invalidation: clear cache when data changes
stream.on("change", (e) => {
  redis.del("user:" + e.documentKey._id)
})

# 2. Real-time notifications: push to WebSocket clients
stream.on("change", (e) => {
  io.emit("user-updated", e.fullDocument)
})

# 3. Audit log: record all changes to a separate store
stream.on("change", (e) => {
  auditLog.insertOne({
    op: e.operationType,
    doc: e.fullDocument,
    at: new Date()
  })
})

# 4. ETL: sync to a search index or warehouse
stream.on("change", async (e) => {
  await elasticsearch.index(e.fullDocument)
})
15

Administration & Tools

Serverstatus & Monitoring

serverStatus() ist die Hauptquelle fürs Monitoring — Verbindungen, Opcounters, Cache-Hit-Ratio und Replikationsverzug tracken. currentOp zeigt laufende Operationen; killOp beendet eine langlebige Abfrage anhand ihrer opid. Einen Monitoring-Agenten (Prometheus, Datadog, Atlas) einrichten, um diese Metriken kontinuierlich zu sammeln. Wichtige Alarme: Verbindungsanzahl nahe am Limit, sinkende Cache-Hit-Ratio, aufflackernde Replikationsverzögerung.

mongodb
# overall server status
db.serverStatus()

# key metrics to monitor:
db.serverStatus().connections       # active/idle connections
db.serverStatus().opcounters         # queries/inserts/updates/sec
db.serverStatus().wiredTiger.cache   # cache hit ratio (aim >95%)
db.serverStatus().metrics.document   # docs inserted/returned/deleted
db.serverStatus().repl               # replication state

# current operations (find long-running ops)
db.currentOp({ secs_running: { $gte: 5 } })

# kill a long-running operation
db.killOp(opid)

# host info (CPU, OS, memory)
db.hostInfo()

Datenbank- & Collection-Stats

stats() zeigt Speicherdetails: dataSize (logisch), storageSize (physisch, nach WiredTiger-Kompression — oft 50-80 % kleiner) und indexSize. estimatedDocumentCount ist sofort (aus Collection-Metadaten), aber ungefähr; countDocuments({}) ist genau, aber scannt. Geschätzte Zählungen für Dashboards, exakte fürs Billing. Speicherwachstumstrends beobachten, um Kapazität zu planen.

mongodb
# database-level stats
db.stats()
db.stats(1024*1024)   # in MB

# collection-level stats
db.users.stats()
db.users.dataSize()       # uncompressed data size
db.users.storageSize()    # on-disk size (with compression)
db.users.totalIndexSize() # total index size
db.users.totalSize()      # data + indexes

# count documents (accurate, may be slow)
db.users.countDocuments({})

# estimated count (fast, from metadata)
db.users.estimatedDocumentCount()

# list collections with sizes
db.runCommand({ listCollections: 1 })

Compact & Repair

WiredTiger nutzt freigegebenen Plattenplatz wieder, daher ist compact selten nötig — nur nach dem Löschen eines großen Anteils einer Collection. compact blockiert Operationen auf der Collection (vor 4.4) oder läuft online (4.4+). repairDatabase ist eine destruktive letzte Rettung, die alle Daten neu schreibt — vorher immer Backup. Für Platzrückgewinnung auf einem Replica-Set einen Secondary resynchronisieren (Daten löschen und neu replizieren lassen).

mongodb
# compact: reclaim disk space from deleted/updated docs
# (WiredTiger reuses freed space, so rarely needed)
db.runCommand({ compact: "users" })

# fullDatabase compact (compact every collection)
db.getCollectionNames().forEach(c => {
  db.runCommand({ compact: c })
})

# repairDatabase (legacy, rewrites all data — last resort)
# Stops the server! Back up first.
mongod --repair --dbpath /data/db

# check data integrity (validates BSON)
db.users.validate({ full: true })

# reclaim space by re-syncing a secondary instead
# (safer than repair on a running primary)

mongotop & mongostat

mongostat gibt einen Echtzeitüberblick über die Serverlast (Inserts, Queries, Cache-Nutzung, Verbindungen) — wie top/vmstat für MongoDB. mongotop zeigt, welche Collections die meiste I/O-Zeit fressen — unbezahlbar, um heiße Collections zu finden. Beide sind in MongoDB enthalten. Für Produktions-Monitoring das mongod-Log und serverStatus-Metriken an ein Monitoring-System liefern, für historische Analyse.

mongodb
# mongostat: live server stats (like vmstat for MongoDB)
mongostat
mongostat --host=host:27017 --rowcount 10
# columns: insert/query/update/delete/getmore/command
#          dirty (cache %), used (cache %), conn, time

# mongotop: time spent per collection (read/write)
mongotop
mongotop 30          # every 30 seconds
mongotop --host=host:27017

# columns: ns (namespace), total/read/write time (ms)
# helps identify which collections are I/O hot

# log slow queries in the mongod log
# set in mongod.conf:
# operationProfiling:
#   mode: slowOp
#   slowOpThresholdMs: 100

Konfiguration & Start

Produktions-MongoDB läuft über eine Config-Datei (mongod.conf in YAML). Wichtige Einstellungen: cacheSizeGB begrenzt WiredTigers RAM (Standard nutzt 50 % des RAM — auf geteilten Servern explizit setzen), bindIp schränkt Netzwerkzugriff ein, authorization aktiviert Auth, und replSetName/clusterRole aktivieren Replikation/Sharding. mongod.conf immer prüfen und versionieren. serverCmdLineOpts zeigt die aktive Konfiguration.

mongodb
# start mongod with a config file
mongod --config /etc/mongod.conf

# typical mongod.conf (YAML)
storage:
  dbPath: /var/lib/mongodb
  wiredTiger:
    engineConfig:
      cacheSizeGB: 4        # limit RAM usage
  journal:
    enabled: true
net:
  port: 27017
  bindIp: 127.0.0.1
security:
  authorization: enabled
replication:
  replSetName: rs0
sharding:
  clusterRole: shardsvr

# view current configuration
db.serverCmdLineOpts()
db.runCommand({ getCmdLineOpts: 1 })
16

Treiber & Integration

Node.js-Treiber

Der Node.js-Treiber ist async/await-basiert mit voller ES6+-Unterstützung. Immer Connection Pooling nutzen (ein MongoClient pro App, wiederverwendet). Cursors sind async iterables. Mit for-await-of iterieren, ohne alle Dokumente in den Speicher zu laden. Den Client beim Herunterfahren schließen. Der Treiber unterstützt Transaktionen, Change Streams und alle Aggregations-Features.

mongodb
const { MongoClient } = require("mongodb")

const client = new MongoClient(
  "mongodb://localhost:27017",
  { maxPoolSize: 50 }
)

async function main() {
  await client.connect()
  const db = client.db("mydb")
  const users = db.collection("users")

  // insert
  await users.insertOne({ name: "Alice", age: 30 })

  // find with a cursor
  const cursor = users.find({ age: { $gte: 18 } })
  for await (const doc of cursor) {
    console.log(doc.name)
  }

  // update
  await users.updateOne(
    { name: "Alice" },
    { $inc: { age: 1 } }
  )
}

main().finally(() => client.close())

Python-Treiber (PyMongo)

PyMongo ist der offizielle Python-Treiber. Er ist synchron; für async Motor (asyncio) oder Beanie (ODM) verwenden. PyMongo-Dictionarys sind einfache Python-Dicts — keine Spezialobjekte nötig. Aggregations-Pipelines sind Listen von Dicts. Das Context-Manager-Transaktionsmuster sorgt für automatisches Commit/Abort. Immer Connection Pooling nutzen (der Standard-MongoClient poolt Verbindungen).

mongodb
from pymongo import MongoClient

client = MongoClient("mongodb://localhost:27017")
db = client["mydb"]
users = db["users"]

# insert
users.insert_one({"name": "Alice", "age": 30})

# find
for doc in users.find({"age": {"$gte": 18}}).sort("age", -1):
    print(doc["name"])

# update
users.update_one(
    {"name": "Alice"},
    {"$inc": {"age": 1}}
)

# aggregation
pipeline = [
    {"$group": {"_id": "$city", "count": {"$sum": 1}}},
    {"$sort": {"count": -1}}
]
for doc in users.aggregate(pipeline):
    print(doc)

# use a context manager for transactions
with client.start_session() as session:
    with session.start_transaction():
        users.update_one({"n":"A"}, {"$inc":{"bal":-100}}, session=session)
        users.update_one({"n":"B"}, {"$inc":{"bal":100}}, session=session)

Indizes aus Treibern

Indizes aus den Setup-/Migrationsskripten der Anwendung erzeugen, nicht bei jedem Request. createIndexes (Plural) erzeugt mehrere Indizes in einem Aufruf. In Produktion können Index-Builds auf großen Collections langsam sein — MongoDB 4.2+ baut Indizes standardmäßig nicht-blockierend. Index-Erzeugungsskripte zusammen mit Schema-Migrationen versionieren.

mongodb
// Node.js: create indexes
await db.collection("users").createIndex({ email: 1 }, { unique: true })
await db.collection("users").createIndex({ name: "text" })

// Python
users.create_index([("email", 1)], unique=True)
users.create_index([("name", "text")])

// list indexes
const indexes = await db.collection("users").indexes()

// drop an index
await db.collection("users").dropIndex("email_1")

// create indexes in bulk
await db.collection("orders").createIndexes([
  { key: { customerId: 1 } },
  { key: { status: 1, date: -1 }, name: "status_date" }
])

Connection-String-Optionen

Der Connection-String trägt die gesamte Client-Konfiguration als Query-Parameter. mongodb+srv nutzt DNS-SRV-Records, um Hosts zu finden — Atlas nutzt dieses Format; es vereinfacht Connection-Strings und aktualisiert sich automatisch, wenn Knoten wechseln. retryWrites=true (Standard in modernen Treibern) wiederholt idempotente Schreibvorgänge nach Netzwerkschwankungen automatisch. Sinnvolle Timeouts setzen, um hängende Verbindungen zu vermeiden.

mongodb
# standard connection string
mongodb://user:pass@host1:27017,host2:27017/mydb?replicaSet=rs0

# common options (as query params):
#   replicaSet=rs0            - replica set name
#   readPreference=secondary  - route reads to secondaries
#   readConcernLevel=majority - read committed data
#   w=majority                - write concern
#   journal=true              - wait for journal flush
#   maxPoolSize=50            - max connections
#   connectTimeoutMS=5000     - connection timeout
#   socketTimeoutMS=30000     - socket timeout
#   authSource=admin          - db for credentials
#   tls=true                  - enable TLS
#   retryWrites=true          - retry on network errors

# SRV connection string (Atlas, uses DNS)
mongodb+srv://user:[email protected]/mydb

ODMs & höherstufige Bibliotheken

ODMs (Object Document Mappers) ergänzen Schemata, Validierung und eine höherstufige API. Mongoose (Node.js) ist am beliebtesten — es erzwingt Struktur, die MongoDB nativ fehlt. Beanie ist die führende async Python-ODM. ODMs sind großartig für schnelle Entwicklung und Teamkonsistenz, aber sie haben Overhead und können MongoDBs Macht verstecken. Für performance-kritische Apps den rohen Treiber verwenden.

mongodb
// Mongoose (Node.js ODM with schemas)
const mongoose = require("mongoose")
const userSchema = new mongoose.Schema({
  name: { type: String, required: true },
  age: { type: Number, min: 0 }
})
const User = mongoose.model("User", userSchema)
await User.create({ name: "Alice", age: 30 })
await User.find({ age: { $gte: 18 } })

# Beanie (Python async ODM)
from beanie import Document
class User(Document):
    name: str
    age: int
await User(name="Alice", age=30).insert()
await User.find(User.age >= 18).to_list()

# Mongose vs raw driver:
# ODMs add schemas, validation, and middleware
# but add overhead and a learning curve
# use the raw driver for max performance/control
17

GridFS & große Dateien

GridFS-Grundlagen

GridFS speichert Dateien größer als das 16-MB-BSON-Dokumentlimit, indem es sie in Chunks (Standard 255 KB) in fs.chunks zerlegt, Metadaten in fs.files liegen. Es ist faktisch ein Dateisystem auf MongoDB. Für Dateien über 16 MB, die noch von MongoDBs Replikation und Sharding profitieren sollen. Für wirklich große Medien lieber S3 oder ein CDN erwägen.

mongodb
# GridFS stores files larger than 16MB (the BSON doc limit)
# by splitting them into chunks

# store a file via mongofiles (CLI)
mongofiles --db=mydb put large_video.mp4
mongofiles --db=mydb list
mongofiles --db=myfs get large_video.mp4

# two collections are used:
#   fs.files  - file metadata (one doc per file)
#   fs.chunks - file data in 255KB chunks

# query file metadata
db.fs.files.find().pretty()
db.fs.files.findOne({ filename: "large_video.mp4" })

# query chunks for a file
db.fs.chunks.find({ files_id: fileId }).sort({ n: 1 })

GridFS aus Treibern

Treiber exponieren GridFS als Streaming-API (GridFSBucket) — ideal für große Dateien, da sie nie vollständig in den Speicher laden. Upload/Download sind Streams, die du an Dateien oder HTTP-Antworten pipen kannst. Metadaten beim Upload sind abfragbar wie jedes Dokumentfeld. GridFS-Chunks werden beim Download automatisch zusammengesetzt. Der Bucket-Name ('fs' standardmäßig) ist konfigurierbar.

mongodb
// Node.js: upload and download with streams
const { MongoClient, GridFSBucket } = require("mongodb")
const fs = require("fs")

const bucket = new GridFSBucket(db)

// upload a file
fs.createReadStream("video.mp4")
  .pipe(bucket.openUploadStream("video.mp4", {
    metadata: { uploadedBy: "alice" }
  }))

// download a file
bucket.openDownloadStreamByName("video.mp4")
  .pipe(fs.createWriteStream("downloaded.mp4"))

// delete a file
await bucket.delete(fileId)

// find files
const files = await bucket.find({}).toArray()

Time-Series-Collections

Time-Series-Collections (5.0+) sind optimiert für sequenzielle, zeitgeordnete Daten (IoT-Sensoren, Metriken, Logs). Sie speichern Daten intern spaltenorientiert und erreichen 30-50 % Kompression sowie schnellere Bereichsabfragen als normale Collections. granularity sollte dem Datenintervall entsprechen. TTL (expireAfterSeconds) räumt alte Daten automatisch ab. $dateTrunc für Zeit-Bucket-Aggregation nutzen.

mongodb
# create a time series collection (MongoDB 5.0+)
db.createCollection("temperatures", {
  timeseries: {
    timeField: "timestamp",
    metaField: "sensorId",
    granularity: "seconds"   // seconds|minutes|hours
  },
  expireAfterSeconds: 2592000   // auto-delete after 30 days
})

# insert measurements
db.temperatures.insertMany([
  { timestamp: ISODate(), sensorId: "s1", value: 22.5 },
  { timestamp: ISODate(), sensorId: "s1", value: 22.7 }
])

# query by time range
db.temperatures.find({
  sensorId: "s1",
  timestamp: { $gte: ISODate("2025-01-01") }
})

# aggregate averages per hour
db.temperatures.aggregate([
  { $group: {
    _id: { $dateTrunc: { date: "$timestamp", unit: "hour" } },
    avg: { $avg: "$value" }
  }}
])

Capped Collections

Capped Collections erhalten die Einfügereihenfolge und überschreiben die ältesten Dokumente, wenn sie voll sind — perfekt für Logs, Recent-Activity-Feeds und Ringpuffer. Sie unterstützen Hochdurchsatz-Inserts und tailable Cursors (wie tail -f). Grenzen: Einzeldokumente lassen sich nicht löschen, und Dokumente können nicht über ihre ursprüngliche Größe hinaus wachsen. Change Streams sind die moderne Alternative für Echtzeit-Tailing.

mongodb
# capped collections have a fixed size and overwrite old docs
db.createCollection("logs", {
  capped: true,
  size: 5242880,    # 5MB max
  max: 10000        # optional: max document count
})

# inserts only (no arbitrary deletes/updates)
db.logs.insertOne({ msg: "started", t: new Date() })

# high-throughput tail with a tailable cursor
const cursor = db.logs.find().addOption(2)  // tailable
while (true) {
  if (cursor.hasNext()) printjson(cursor.next())
}

# convert a regular collection to capped
db.runCommand({
  convertToCapped: "events",
  size: 1000000
})

BSON-Größe & Dokumentgrenzen

Das 16-MB-BSON-Dokumentlimit ist eine harte Obergrenze — mit Object.bsonsize() Dokumentgrößen prüfen. Große Arrays (Tausende Elemente) blähen Dokumente auf und verlangsamen Updates (MongoDB schreibt beim Update das ganze Dokument neu). Für unbegrenzte Daten (Rezensionen, Kommentare, Logeinträge) eine separate Collection mit Referenz nutzen. Für Binärblobs über 16 MB GridFS oder externen Speicher mit URL-Referenz.

mongodb
# maximum BSON document size: 16MB
# check a document's size (in bytes)
Object.bsonsize(db.users.findOne())

# large arrays/fields should be referenced, not embedded
# a product with 10000 reviews -> use a separate collection

# check if a document is too large
const doc = { /* ... huge doc ... */ }
const size = Object.bsonsize(doc)
if (size > 16 * 1024 * 1024) {
  throw new Error("Document exceeds 16MB BSON limit")
}

# GridFS bypasses the limit by chunking
# alternatively, store large blobs externally (S3)
# and keep only a URL reference in the document
18

SQL-Vergleich & Migration

SQL-zu-MongoDB-Zuordnung

Diese Zuordnung ist der schnellste Weg für SQL-Entwickler, MongoDB zu lernen. Der Kernunterschied: MongoDB hat kein festes Schema (Dokumente in einer Collection dürfen abweichen), und 'Joins' werden ersetzt durch Einbetten verwandter Daten oder $lookup (langsamer als SQL-Joins — das Schema so entwerfen, dass sie minimiert werden). SQL GROUP BY entspricht der $group-Aggregationsstufe.

mongodb
# SQL -> MongoDB terminology
# database          -> database
# table             -> collection
# row               -> document
# column            -> field
# index             -> index
# join              -> $lookup (or embed)
# primary key       -> _id (ObjectId by default)
# foreign key       -> reference (ObjectId field)
# group by          -> $group
# select            -> find / $project
# where             -> $match

# SQL query -> MongoDB query
# SELECT * FROM users WHERE age >= 18
db.users.find({ age: { $gte: 18 } })

# SELECT name, age FROM users
db.users.find({}, { name: 1, age: 1, _id: 0 })

# SELECT * FROM users ORDER BY age DESC LIMIT 10
db.users.find().sort({ age: -1 }).limit(10)

# SELECT city, COUNT(*) FROM users GROUP BY city
db.users.aggregate([
  { $group: { _id: "$city", count: { $sum: 1 } } }
])

Migration von SQL

Migration ist keine 1:1-Tabelle-zu-Collection-Zuordnung — das Schema sollte für MongoDBs Dokumentenmodell neu entworfen werden. Kleine, exklusive, gemeinsam gelesene Daten einbetten (Profil + Adressen eines Nutzers). Referenzen behalten für große, geteilte oder unbegrenzte Daten (Bestellungen eines Kunden). MongoDBs Relational Migrator automatisiert viel dieser Analyse. Das Schema planen, nicht einfach übertragen.

mongodb
# step 1: export SQL data to JSON/CSV
# (mysqldump, pg_dump, or a script)

# step 2: transform relational data to documents
# SQL:
#   users(id, name, dept_id)
#   departments(id, name)
# MongoDB (embed small, related data):
db.users.insertOne({
  _id: 1,
  name: "Alice",
  department: { id: 10, name: "Engineering" }  # embedded
})

# step 3: for large related data, keep references
db.orders.insertOne({
  _id: 101,
  customerId: 1,    # reference, not embedded
  items: [...]      # embed order items (bounded)
})

# tools: MongoDB Relational Migrator (GUI), mongoimport
# https://www.mongodb.com/.../relational-migrator

Transaktionen vs. SQL-ACID

MongoDB bietet ACID: Einzeldokument-Operationen sind immer atomar (keine Transaktion nötig), und Mehrdokument-Transaktionen (4.0+) liefern vollständiges ACID über Collections. Der Kernunterschied: SQL setzt ACID bei jeder Anweisung voraus, während MongoDB zu einem Schemadesign ermutigt, das verwandte Daten in einem Dokument hält (standardmäßig atomar) und Transaktionen nur bei echtem Bedarf einsetzt. Einbetten bevorzugen, um Transaktions-Overhead zu vermeiden.

mongodb
# SQL: ACID by default on every statement
BEGIN TRANSACTION;
UPDATE accounts SET balance = balance - 100 WHERE name = 'Alice';
UPDATE accounts SET balance = balance + 100 WHERE name = 'Bob';
COMMIT;

# MongoDB: single-document ops are atomic (ACID)
db.accounts.updateOne({name:"Alice"}, {$inc:{balance:-100}})
# (one document = one atomic operation)

# MongoDB: multi-document ACID (transactions, replica set)
const s = db.getMongo().startSession()
s.startTransaction()
db.accounts.updateOne({name:"Alice"},{$inc:{balance:-100}},{session:s})
db.accounts.updateOne({name:"Bob"},{$inc:{balance:100}},{session:s})
s.commitTransaction()

# prefer embedding to avoid transactions entirely
# (embedded data updates atomically in one document)

Normalisierung vs. Denormalisierung

SQL normalisiert, um Redundanz zu vermeiden; MongoDB denormalisiert für Lesegeschwindigkeit. Der Trade-off: Denormalisierte Daten sind schneller zu lesen, aber schwerer zu aktualisieren (mehrere Dokumente). Daten denormalisieren, die sich selten ändern (Ländernamen, Produktkataloge), und Daten referenzieren, die sich häufig ändern (Preise, Bestand). Die richtige Balance hängt von deinem Lese-/Schreibverhältnis ab — beobachten und anpassen.

mongodb
# SQL: normalize to avoid duplication (3NF)
#   users(id, name, city_id)
#   cities(id, name, country_id)
#   countries(id, name)
# -> 4 joins to get a user's country

# MongoDB: denormalize for read performance
db.users.insertOne({
  name: "Alice",
  city: "NYC",
  country: "USA"        # denormalized — duplicate but fast reads
})

# trade-off: updates must touch multiple documents
# when a city's name changes:
db.users.updateMany(
  { "city": "New York" },
  { $set: { "city": "NYC" } }
)

# rule: duplicate data that changes rarely,
# reference data that changes often

Wann MongoDB vs. SQL

Es gibt keine universell 'beste' Datenbank. MongoDB glänzt bei flexiblen Schemata, hierarchischen Daten und horizontaler Skalierung. SQL glänzt bei relationaler Integrität, komplexen Joins und schweren transaktionalen Workloads. Viele moderne Apps sind polyglott — MongoDB für Kataloge/Inhalte/nutzergenerierte Daten, PostgreSQL für Finanztransaktionen. Die Datenbank an den Workload anpassen, nicht am Hype.

mongodb
# CHOOSE MongoDB when:
# - schema is flexible or evolving rapidly
# - data is naturally hierarchical (embed)
# - you need horizontal scaling (sharding)
# - reads >> writes and you can denormalize
# - document-oriented domain (CMS, product catalogs, IoT)

# CHOOSE SQL (PostgreSQL/MySQL) when:
# - schema is fixed and relational (banking, ERP)
# - you need complex multi-table joins frequently
# - transactions span many tables constantly
# - strong consistency is non-negotiable
# - your team knows SQL well

# HYBRID: use both — MongoDB for product catalog/comments,
# SQL for orders/payments. Many large apps are polyglot.

# AVOID MongoDB for:
# - heavy multi-entity transactional workloads
# - apps requiring complex cross-table joins as core feature
19

Fortgeschrittene Aggregation

$merge & $out (Materialized Views)

$out ersetzt eine Ziel-Collection durch die Pipeline-Ausgabe (destruktiv). $merge ist flexibler — es kann einfügen, ersetzen oder mit bestehenden Dokumenten kombinieren und ermöglicht inkrementelle Materialized Views. $merge ist für geplante Aktualisierungen bevorzugt: Nur neue/geänderte Daten werden aktualisiert. Materialized Views berechnen teure Aggregationen vorab für schnelle Dashboard-Abfragen.

mongodb
# $out: write aggregation results to a NEW collection
db.orders.aggregate([
  { $group: { _id: "$customerId", total: { $sum: "$amount" } } },
  { $out: "customer_totals" }
])

# $merge: merge results into an EXISTING collection (flexible)
db.orders.aggregate([
  { $group: { _id: "$customerId", total: { $sum: "$amount" } } },
  { $merge: {
    into: "customer_totals",
    on: "_id",
    whenMatched: "replace",    // replace|keepExisting|merge|fail
    whenNotMatched: "insert"   // insert|discard|fail
  }}
])

# build a materialized view refreshed on a schedule
# (cron job or change-stream triggered)
db.daily_stats.aggregate([
  { $match: { date: today } },
  { $group: { _id: "$category", count: { $sum: 1 } } },
  { $merge: { into: "daily_stats", whenMatched: "replace" } }
])

Window-Funktionen ($setWindowFields)

$setWindowFields (5.0+) bringt SQL-Window-Funktionen nach MongoDB: laufende Summen, Ranglisten, gleitende Durchschnitte und lag/lead. partitionBy entspricht PARTITION BY, sortBy entspricht ORDER BY, und window definiert den Rahmen. Range-Fenster nutzen Werte (z. B. letzte 7 Tage), Document-Fenster nutzen Zeilenzahlen. Essenziell für Zeitreihenanalyse und Reporting.

mongodb
# $setWindowFields: window functions (MongoDB 5.0+)
# like SQL OVER() — compute values across a window of docs
db.sales.aggregate([{
  $setWindowFields: {
    partitionBy: "$region",       # like PARTITION BY
    sortBy: { date: 1 },          # like ORDER BY
    output: {
      runningTotal: { $sum: "$amount", window: { documents: ["unbounded", "current"] } },
      rank: { $rank: {} },
      denseRank: { $denseRank: {} },
      movingAvg: { $avg: "$amount", window: { range: [-7, "current"], unit: "day" } },
      lagValue: { $shift: { by: -1, output: "$amount" } }
    }
  }
}])

# window: documents (count-based) or range (value-based)
# ["unbounded", "current"] = from start to current row
# [-3, "current"] = last 3 docs including current

$map, $filter & $reduce

$map, $filter und $reduce sind funktionale Array-Operatoren für Transformationen im Dokument. $map wandelt jedes Element um, $filter behält passende Elemente, und $reduce verdichtet ein Array zu einem Wert. Die 'as'-Variable (Standard $$this) benennt das aktuelle Element. Diese vermeiden $unwind bei vielen Array-Operationen — schneller und sauberer.

mongodb
# $map: transform each array element
{ $project: {
  squares: { $map: {
    input: "$nums",
    as: "n",
    in: { $multiply: ["$$n", "$$n"] }
  }}
}}

# $filter: keep elements matching a condition
{ $project: {
  adults: { $filter: {
    input: "$users",
    as: "u",
    cond: { $gte: ["$$u.age", 18] }
  }}
}}

# $reduce: fold an array into a single value
{ $project: {
  total: { $reduce: {
    input: "$items",
    initialValue: 0,
    in: { $add: ["$$value", "$$this.price"] }
  }}
}}

# variables: $$value (accumulator), $$this (current element), $$n (named)

$facet & Multi-Pipeline

$facet führt mehrere Sub-Pipelines auf derselben Eingabe in einer einzigen Abfrage aus — perfekt für Dashboards, die mehrere Sichtweisen auf die Daten brauchen (Aufschlüsselungen, Stats, Top N). Jede Sub-Pipeline ist unabhängig. Das Ergebnis ist ein Dokument mit einem Feld pro Sub-Pipeline. Das ersetzt mehrere Round-Trips und garantiert einen konsistenten Snapshot.

mongodb
# run several aggregations on the same data in one pass
db.products.aggregate([{
  $facet: {
    "byCategory": [
      { $group: { _id: "$category", count: { $sum: 1 } } },
      { $sort: { count: -1 } }
    ],
    "priceStats": [
      { $group: { _id: null, avg: { $avg: "$price" }, max: { $max: "$price" } } }
    ],
    "topRated": [
      { $sort: { rating: -1 } },
      { $limit: 5 },
      { $project: { name: 1, rating: 1, _id: 0 } }
    ],
    "totalCount": [{ $count: "n" }]
  }
}])
# result: a single doc with all four arrays/objects

$bucket & $bucketAuto

$bucket kategorisiert Dokumente in explizite Wertbereiche (wie SQL CASE WHEN) — ideal für Preisklassen, Altersgruppen und Histogramme. $bucketAuto lässt MongoDB die Grenzen berechnen, um eine Zielanzahl von Buckets zu erzeugen (gut für Datenexploration ohne bekannte Verteilung). Grenzen sind links-inklusive, rechts-exklusiv.

mongodb
# $bucket: group documents into explicit ranges
db.products.aggregate([{
  $bucket: {
    groupBy: "$price",
    boundaries: [0, 50, 100, 500, 1000],
    default: "other",
    output: {
      count: { $sum: 1 },
      names: { $push: "$name" },
      avgPrice: { $avg: "$price" }
    }
  }
}])
# buckets: [0,50), [50,100), [100,500), [500,1000), other

# $bucketAuto: let MongoDB choose the boundaries
db.products.aggregate([{
  $bucketAuto: {
    groupBy: "$price",
    buckets: 5,           # target 5 buckets
    output: { count: { $sum: 1 }, avg: { $avg: "$price" } }
  }
}])
# good for histograms and data exploration
20

Monitoring & Fehlerbehebung

Wichtige Monitoring-Metriken

Die vier goldenen Signale für MongoDB: Verbindungen (Annäherung ans Limit deutet auf Lecks oder fehlendes Pooling), Cache-Hit-Ratio (von der Platte gelesene Seiten zeigen RAM-Druck), Replikationsverzug (ein hinkender Secondary riskiert Datenverlust beim Failover) und Queue-Tiefe (Lock-Contention). Alarme auf alle vier setzen. Eine sinkende Cache-Hit-Ratio ist Warnsignal Nr. 1 für Performance.

mongodb
# connections (watch for connection leaks)
db.serverStatus().connections
# { current, available, totalCreated }

# operation rates (queries/inserts/updates/deletes per sec)
db.serverStatus().opcounters

# WiredTiger cache (disk reads = cache misses)
db.serverStatus().wiredTiger.cache
# "bytes currently in the cache" vs "maximum bytes configured"
# "pages read into cache" should be low (cache hits)

# replication lag (critical for HA)
rs.printSecondaryReplicationInfo()

# queue depth (operations waiting for locks)
db.serverStatus().globalLock.currentQueue

# open cursors (watch for leaks)
db.serverStatus().metrics.cursor

Lock-Contention auflösen

MongoDB nutzt Locking auf Dokumentebene (WiredTiger), also ist Contention selten — aber nicht-indizierte Abfragen, riesige Sortierungen und lange Transaktionen blockieren trotzdem. currentOp findet den Übeltäter; killOp stoppt ihn. Die Ursache ist meist ein fehlender Index (explain ausführen). Schema-Migrationen auf großen Collections können lange sperren — in kleinen Schüben oder bei niedrigem Traffic durchführen.

mongodb
# check current queue (operations waiting)
db.serverStatus().globalLock.currentQueue
# { readers, writers, total }

# find long-running operations
db.currentOp({
  secs_running: { $gte: 5 },
  op: { $ne: "none" }
})

# kill a long-running op blocking others
db.killOp(opid)

# common causes of lock contention:
# - unindexed queries (COLLSCAN holds locks)
# - large in-memory sorts
# - long transactions
# - schema migrations on large collections

# check for slow ops in the log
db.adminCommand({ getLog: "global" }).log
  .filter(l => l.includes(" Slow query"))

Speicher- & Plattenanalyse

WiredTigers Cache ist die Speichergrenze — voller Dirty-Pages verlangsamt Schreibvorgänge (Flushing auf die Platte). Ist 'pages read into cache' hoch, RAM ergänzen oder Indizes, um Scans zu reduzieren. Unbenutzte Indizes löschen — sie kosten Platz UND Speicher UND verlangsamen Schreibvorgänge. Speicherwachstum beobachten, um Kapazitätsbedarf vorherzusagen. Bei Sharded Clustern deuten Jumbo-Chunks (zu groß zum Migrieren) auf einen schlechten Shard Key.

mongodb
# check storage engine memory usage
db.serverStatus().wiredTiger.cache
# "maximum bytes configured" = cache limit (default 50% RAM)
# "tracked dirty bytes" = dirty pages awaiting flush
# target: dirty < 20%, cache usage < 95%

# disk space per collection
db.users.stats().storageSize
db.users.totalIndexSize()

# find the largest collections
db.getCollectionNames().map(c => ({
  name: c, size: db.getCollection(c).storageSize()
})).sort((a,b) => b.size - a.size).slice(0, 5)

# check for jumbo chunks (sharded clusters)
sh.status(true)

# review index sizes (drop unused indexes)
db.users.getIndexes().map(i => ({
  name: i.name, size: db.users.stats().indexSizes[i.name]
}))

Log-Analyse

Das mongod-Log zeichnet langsame Operationen, Wahlen, Fehler und mehr auf. slowOpThresholdMs setzen, um Abfragen oberhalb deines SLO zu erfassen. getLog holt den In-Memory-Ringpuffer; das Log auf der Platte übersteht Neustarts. logRotate archiviert das aktuelle Log (mit logrotate für tägliche Rotation). Die Component-Verbosity temporär erhöhen für tiefes Debuggen (z. B. replication: 2 bei Wahl-Problemen), dann zurücksetzen.

mongodb
# view recent log entries
db.adminCommand({ getLog: "global" })

# log slow queries (set threshold)
db.adminCommand({
  setParameter: 1,
  logComponentVerbosity: { query: { verbosity: 1 } }
})

# mongod.conf: log slow operations
# operationProfiling:
#   mode: slowOp
#   slowOpThresholdMs: 100
#   slowOpSampleRate: 1.0

# grep the mongod log for slow queries
grep "Slow query" /var/log/mongodb/mongod.log
grep "COMMAND" /var/log/mongodb/mongod.log | tail -50

# rotate logs
db.adminCommand({ logRotate: 1 })

# set log verbosity for a component
db.adminCommand({
  setParameter: 1,
  logComponentVerbosity: { replication: 2 }
})

Häufige Fehler & Lösungen

Dies sind die häufigsten MongoDB-Fehler. Duplicate-Key-Fehler kommen von _id- oder Unique-Index-Verletzungen — im App-Code behandeln. Aggregations-Speicherlimits werden mit allowDiskUse behoben (langsamer, funktioniert aber). WriteConflict in Transaktionen ist bei Contention normal — wiederholen. Cursor-Timeouts heißen, dass deine Batch-Verarbeitung zu langsam ist — kleinere Batches oder noCursorTimeout nutzen (aber Cursor immer schließen).

mongodb
# ERROR: "E11000 duplicate key"
# cause: _id or unique index conflict
# fix: check the duplicate value, use upsert, or catch the error

# ERROR: "QueryExceededMemoryLimitNoDiskUseAllowed"
# cause: aggregation stage exceeded 100MB RAM
# fix: add { allowDiskUse: true } or add $match early
db.big.aggregate([...], { allowDiskUse: true })

# ERROR: "BSONObjTooLarge"
# cause: document > 16MB
# fix: use GridFS or split the document

# ERROR: "WriteConflict" (transaction)
# cause: two transactions modified the same doc
# fix: retry the transaction (TransientTransactionError)

# ERROR: "ReplicaSetNoPrimary"
# cause: no primary (election in progress)
# fix: wait for election; check rs.status()

# ERROR: "cursor not found"
# cause: cursor timed out (10 min default)
# fix: use noCursorTimeout or process faster

Was this helpful?