Next:
Impressum
MongoDB Grundlagen
1
Impressum
2
Einleitung: MongoDB für Praktiker
2.1
Aufbau und Struktur
2.1.1
Teil I: Grundlagen und Architektur
2.1.2
Teil II: Tooling und Shell
2.1.3
Teil III: CRUD-Operations
2.1.4
Teil IV: Aggregation
2.1.5
Teil V: Security
2.1.6
Teil VI: Performance und Indexierung
2.1.7
Teil VII: Backup und Recovery
2.1.8
Teil VIII: Maintenance und Operations
2.2
Didaktischer Ansatz
2.3
Zielgruppe
2.4
Verwendung des Handbuchs
2.5
Versionshinweise
2.6
Ergänzende Ressourcen
3
Einführung
3.1
Was ist MongoDB?
3.1.1
Dokumentenorientierte Speicherung
3.1.2
Skalierbarkeit als Grundprinzip
3.1.3
Flexibilität durch Schemafreiheit
3.1.4
Native Replikation für Hochverfügbarkeit
3.1.5
Sharding für massive Datenmengen
3.1.6
Intuitive Abfragesprache
3.2
MongoDB im Kontext moderner Datenbanken
4
NoSQL im Überblick
4.1
Definition
4.2
Haupttypen von NoSQL-Datenbanken
4.2.1
Dokumentenorientierte Datenbanken
4.2.2
Spaltenorientierte Datenbanken
4.2.3
Key-Value-Datenbanken
4.2.4
Graphdatenbanken
4.3
Vorteile von NoSQL-Datenbanken
4.4
Herausforderungen
5
Geschichte und Verbreitung
5.1
Ursprünge von NoSQL und MongoDB
5.2
Wichtige Meilensteine
5.3
Verbreitung
6
Begriffe und Wording
6.1
Datenorganisation: Von Datenbanken zu Dokumenten
6.2
Datenstruktur: BSON und Felder
6.3
Datenmanipulation: Queries, Projections und Indizes
6.4
Datenreplikation und Verteilung: Replica Sets und Sharding
6.5
Sicherheit und Verwaltung: Authentifizierung und Rollen
7
Deployment-Modelle
7.1
Single Node: Standalone-Deployment
7.2
Replica Set: Hochverfügbarkeit durch Replikation
7.3
Sharded Cluster: Horizontale Skalierung für massive Datenmengen
7.4
Cloud-Deployment: MongoDB Atlas und Self-Managed
7.5
Entscheidungskriterien: Das richtige Modell wählen
8
Datenmodell: Dokumente, Collections, Datenbanken
8.1
Dokumente: Die atomare Einheit
8.2
Collections: Logische Gruppierung
8.3
Datenbanken: Organisatorische Container
8.4
Datenmodellierung in der Praxis
9
Installation und Konfiguration
9.1
Voraussetzungen und Planung
9.2
Installation unter Linux
9.3
Installation unter Windows und macOS
9.4
Erster Start und Verifikation
9.5
Konfiguration: mongod.conf verstehen
9.6
Nach der Installation: Best Practices
10
Unterschiede zwischen Windows und Linux
10.1
Installation: Zwei Welten, zwei Ansätze
10.2
Dienstverwaltung: systemd versus Windows Services
10.3
Dateisysteme: Performance-Fundament
10.4
Pfade und Konfiguration: Konventionen und Konsistenz
10.5
Sicherheit und Berechtigungen
10.6
Performance-Charakteristiken in der Praxis
10.7
Tooling und Ökosystem
10.8
Wann welche Plattform?
11
Speicher-Engines in MongoDB
11.1
Die Evolution: Von MMAPv1 zu WiredTiger
11.2
WiredTiger: Die moderne Standard-Engine
11.3
In-Memory Storage Engine: Geschwindigkeit ohne Persistenz
11.4
Drittanbieter-Engines: Nischenexistenzen
11.5
Praktische Aspekte: Abfragen und Wechseln
11.6
Tuning für optimale Performance
12
Das richtige Dateisystem für MongoDB
12.1
Linux: XFS und ext4 als bewährte Standards
12.2
Windows: NTFS ohne Alternative
12.3
Spezial-Dateisysteme: ZFS und Btrfs
12.4
Konfiguration und Tuning: Mount-Optionen
12.5
Hardware-Überlegungen: SSDs vs. HDDs
12.6
Capacity Planning und Dateisystem-Größe
13
Neuerungen in MongoDB Version 5.0
13.1
Zeitreihen-Collections: Native Unterstützung für IoT und Monitoring
13.2
Live-Resizing von Sharded Clustern
13.3
Hidden Indexes: Risikofreies Performance-Testing
13.4
Serverless-Instanzen: Cloud-Native MongoDB
13.5
Aggregation- und Sharding-Optimierungen
13.6
Sicherheits- und Audit-Verbesserungen
13.7
MongoDB Compass: GUI-Verbesserungen
14
Neuerungen in MongoDB Version 6.0
14.1
Lücken füllen: $densify und $fill
14.2
Top-N und Bottom-N: Neue Ranking-Operatoren
14.3
Dokumenten-Literale und Array-Sortierung
14.4
Sharding-Insights: $shardedDataDistribution
14.5
Operative Verbesserungen: Change Streams und Cluster-Parameter
14.6
Sharding-Optimierung: Größere Chunks
14.7
Sicherheit: Verschlüsselte Audit-Logs
15
Neuerungen in MongoDB Version 7.0
15.1
Atlas Search Index Management: Shell-Integration
15.2
Query Execution Engine: Der Slot-Based Executor
15.3
Concurrent Transactions: Dynamische Skalierung
15.4
Compound Wildcard Indexes: Flexibilität trifft Effizienz
15.5
Large Change Stream Events: Fragmentierung
15.6
Queryable Encryption: General Availability
15.7
Statistische Operatoren: $median und $percentile
15.8
Sharding-Metriken und Debugging-Verbesserungen
16
Neuerungen in MongoDB Version 8.0
16.1
Performance-Revolution: Der kompilierte Executor schlägt zu
16.2
Queryable Encryption: Range Queries auf verschlüsselten Daten
16.3
Sharding-Revolution: Config Shards und 50x schnellere Datenverteilung
16.4
Query Settings: Persistente Query-Governance
16.5
Vector Search: Quantisierung für KI-Workloads
16.6
Zeitreihen-Optimierungen: Downsampling und Aggregationen
17
Hands On: Installation einer Single Instance von MongoDB
17.1
Systemvorbereitung: Updates und Dependencies
17.2
MongoDB-Repository einrichten: Aktuelle Versionen garantieren
17.3
Installation: MongoDB und Tools
17.4
Erster Start: MongoDB zum Leben erwecken
17.5
Verbindung testen: Die erste Interaktion
17.6
Konfiguration verstehen und anpassen
17.7
Mehrere Instanzen: Manuelles Starten für Experimente
17.8
Logs verstehen: Was MongoDB erzählt
17.9
Nächste Schritte: Von Standalone zu Replica Sets
18
Replica Set in MongoDB
18.1
Architektur eines Replica Sets: Primary, Secondaries und das Oplog
18.2
Elections: Automatisches Failover bei Ausfällen
18.3
Read Preferences: Lastverteilung und Konsistenz-Trade-offs
18.4
Hands-On: Ein lokales Replica Set aufsetzen
18.5
Failover testen: Den Primary simuliert töten
18.6
Write Concerns und Read Concerns: Konsistenz-Garantien
19
Konfiguration eines MongoDB Replica Sets
19.1
Das Konfigurationsdokument: Anatomie eines Replica Sets
19.2
Members: Knoten mit Rollen und Eigenschaften
19.3
Hidden Members und Delayed Secondaries
19.4
Tags und Tag Sets: Geo-Awareness und Workload-Isolation
19.5
Election Tuning: Timeouts und Prioritäten
19.6
Chaining: Replication-Topologien
19.7
Reconfiguration: Änderungen sicher durchführen
19.8
Arbiter: Stimmrecht ohne Daten
19.9
Monitoring und Troubleshooting
20
Infrastruktur eines MongoDB Replica Sets
20.1
Physische Topologie: Einzelstandort versus geografische Verteilung
20.2
Netzwerk-Architektur: Latenz, Bandbreite und Sicherheit
20.3
Hardware-Dimensionierung: CPU, RAM und Storage
20.4
Betriebssystem und Tuning
20.5
Sicherheit: Defense in Depth
20.6
Monitoring: Proaktive Überwachung statt reaktive Feuerlöschung
20.7
Backup-Strategie: Redundanz ist kein Backup
21
Hands On: Installation eines MongoDB Replica Sets
21.1
Vorbereitung: MongoDB auf allen Nodes installieren
21.2
Konfiguration: mongod.conf für Replica-Set-Betrieb
21.3
Netzwerk-Verifizierung: Können Nodes sich sehen?
21.4
Initialisierung: Das Replica Set zum Leben erwecken
21.5
Erste Operationen: Daten schreiben und replizieren sehen
21.6
Failover testen: Primary-Ausfall simulieren
21.7
Authentifizierung aktivieren: Sicherheit für das Set
21.8
Advanced Setup: Prioritäten und Tags setzen
21.9
Monitoring und Troubleshooting
22
Sharding in MongoDB
22.1
Wann Sharding nötig wird: Die Grenzen vertikaler Skalierung
22.2
Architektur eines Sharded Clusters: Router, Shards und Config Servers
22.3
Shard Keys: Die kritischste Architektur-Entscheidung
22.4
Hands-On: Lokales Sharded Cluster aufbauen
22.4.1
Schritt 1: Config Server Replica Set
22.4.2
Schritt 2: Shard Replica Sets
22.4.3
Schritt 3: mongos Router starten
22.4.4
Schritt 4: Shards zum Cluster hinzufügen
22.5
Daten sharden: Database und Collection aktivieren
22.6
Chunks und Balancing: Dynamische Daten-Umverteilung
22.7
Query-Routing: Targeted vs. Scatter-Gather
22.8
Resharding: Den Shard Key ändern
22.9
Skalierung über Grenzen hinaus: Sharded Cluster erweitern
23
Shard-Key-Auswahl: Theorie trifft Praxis
23.1
Szenario: E-Commerce Orders Collection
23.2
Option 1: OrderId als Shard Key
23.3
Option 2: CustomerId als Shard Key
23.4
Option 3: Compound Key – CustomerId + OrderDate
23.5
Hashed vs. Range Sharding: Der fundamentale Trade-off
23.6
Szenario 2: Inventory Collection mit geografischer Verteilung
23.7
Zonned Sharding: Geografische Daten-Platzierung
23.8
Anti-Patterns: Was man vermeiden sollte
23.9
Praktische Entscheidungs-Matrix
24
Vorteile und Herausforderungen der Datenverteilung
24.1
Die Vorteile: Warum Sharding sich lohnt
24.2
Die Herausforderungen: Was Sharding kostet
24.3
Trade-offs akzeptieren: Wann Sharding sich lohnt
25
Shutdown von MongoDB: Sauber beenden statt hart killen
25.1
Was beim Shutdown intern passiert
25.2
Die drei Methoden: Shell, systemd und Signale
25.2.1
Methode 1: Administrative Shutdown über die Shell
25.2.2
Methode 2: systemd Service Management
25.2.3
Methode 3: Manuelle Signale
25.3
Replica Set Shutdown: Reihenfolge ist wichtig
25.4
Sharded Cluster Shutdown: Die Reihenfolge zählt
25.5
Recovery nach Hard-Crash: Was MongoDB repariert
25.6
Best Practices: Shutdowns planen und automatisieren
26
JSON und BSON: Von menschenlesbar zu maschinenoptimiert
26.1
JSON: Die universelle Datensprache des Webs
26.2
BSON: Binär, schnell und typenreich
26.3
Performance-Charakteristiken: Warum BSON schneller ist
26.4
Entwickler-Erfahrung: Das Beste aus beiden Welten
26.5
Die 16-MB-Grenze: BSON’s fundamentales Limit
26.6
JSON und BSON in der Praxis: Wann was nutzen
27
Datentypen in MongoDB: Mehr als nur JSON
27.1
Die JSON-Basis-Typen: Vertraut aber limitiert
27.2
BSON’s Crown Jewel: ObjectId
27.3
Date: Zeit richtig speichern
27.4
Decimal128: Präzision für Finanzdaten
27.5
BinData: Binäre Effizienz
27.6
Spezialisierte Typen: Regex, MinKey, MaxKey
27.7
Type Coercion und Type Confusion: Häufige Fallstricke
28
Verwendung von JSON mit MongoDB: Die Developer Experience
28.1
Die mongosh-Shell: JSON als Interface
28.2
Create: Dokumente einfügen mit Nuancen
28.3
Read: Queries von simpel bis komplex
28.4
Update: Dokumente modifizieren mit Präzision
28.5
Delete: Dokumente entfernen mit Vorsicht
28.6
Aggregation Framework: Queries auf Steroiden
29
Arbeiten mit der MongoDB Shell: mongosh als mächtiges Werkzeug
29.1
Der Start: Verbindung und erste Schritte
29.2
Navigation und Exploration: Die Datenbank kennenlernen
29.3
Interaktives JavaScript: Mehr als nur Queries
29.4
Modern JavaScript: async/await und Promises
29.5
Autocomplete und Introspection: Die Shell kennt MongoDB
29.6
Der .editor: Multi-Line-Code komfortabel schreiben
29.7
Snippets: Wiederverwendbarer Code
29.8
Explain: Query-Performance verstehen
29.9
Administration und Maintenance: mongosh als Admin-Tool
29.10
Profiling und Monitoring: Slow Queries finden
29.11
Scripting und Automation: mongosh in CI/CD
29.12
Tips und Tricks für produktive Nutzung
30
mongosh vs. mongo: Evolution statt Revolution
30.1
Architektur: Von C++ zu Node.js
30.2
User Experience: Von rudimentär zu modern
30.3
JavaScript Capabilities: Von ES5 zu ES2020+
30.4
Async/Await: Der Game-Changer
30.5
Plugin-Architektur: Extensibility für die Community
30.6
Telemetrie: Transparency und Privacy
30.7
Kompatibilität und Migration: Der Übergang
30.8
Version-Support: Was läuft wo?
30.9
Performance: Ist mongosh langsamer?
30.10
Die Zukunft ist mongosh
31
Konfigurieren der MongoDB Shell: Von Default zu maßgeschneidert
31.1
Connection Strings: Die moderne Art der Verbindung
31.2
Authentifizierung: Credentials sicher handhaben
31.3
Authentication Mechanisms: Mehr als Username/Password
31.4
TLS/SSL: Verschlüsselte Verbindungen
31.5
.mongoshrc.js: Personalisierung und Helper-Functions
31.6
Advanced Configuration: Read Preferences und Write Concerns
31.7
Environment-Specific Config: Multiple Profiles managen
31.8
SSH Tunneling: Sicherer Zugriff auf Remote-Datenbanken
31.9
Performance Tuning: Batch Sizes und Timeouts
31.10
Troubleshooting: Verbindungsprobleme debuggen
32
Mongo Shell Scripting: Von Ad-hoc zu Automatisierung
32.1
Das erste Script: Von der Shell zur Datei
32.2
Script-Struktur: Von linear zu modular
32.3
Error Handling: Robust gegen Failures
32.4
Exit Codes: Success oder Failure signalisieren
32.5
Parameter übergeben: Scripts konfigurierbar machen
32.6
Load: Modulare Scripts mit Wiederverwendung
32.7
Iterationen und Bulk-Operations: Effizient über viele Dokumente
32.8
Transactions: Atomic Multi-Document-Operations
32.9
Logging und Debugging: Visibility in Scripts
32.10
Real-World Use-Case: Data Migration Script
32.11
Performance Considerations: Scripts optimieren
32.12
CI/CD Integration: Scripts in Pipelines
33
CRUD: Create – Die Kunst des Einfügens
33.1
insertOne: Der einfachste Fall
33.2
insertMany: Bulk-Inserts für Performance
33.3
Write Concerns: Durability vs. Performance
33.4
Schema Validation: Constraints beim Insert
33.5
Upserts: Insert oder Update, idempotent
33.6
Bulk Write API: Flexibles Batch-Processing
33.7
Embedded Documents und Arrays: Strukturierte Inserts
33.8
Best Practices für Inserts
34
CRUD: Read – Die Kunst des Abfragens
34.1
find(): Die fundamentale Query-Methode
34.2
Comparison Operators: Beyond Equality
34.3
Logical Operators: Komplexe Boolean-Logik
34.4
Array Queries: Suchen in Listen
34.5
Nested Document Queries: Dot Notation
34.6
Projection: Nur benötigte Felder fetchen
34.7
Sorting: Reihenfolge kontrollieren
34.8
Limiting und Skipping: Pagination implementieren
34.9
Cursor Methods: Flexibles Result-Processing
34.10
distinct(): Unique Values finden
34.11
findOne(): Ein Dokument genügt
34.12
Performance-Optimierung: Explain und Indexes
35
CRUD: Update – Präzise Modifikation statt Überschreibung
35.1
updateOne und updateMany: Scoping der Änderungen
35.2
$set und $unset: Felder setzen und entfernen
35.3
$inc und $mul: Numerische Operationen
35.4
Array-Operatoren: $push, $pull, $addToSet
35.5
Positional Operators: Updates auf spezifische Array-Elemente
35.6
replaceOne: Komplettes Dokument ersetzen
35.7
Upserts: Insert wenn nicht existiert, Update sonst
35.8
findOneAndUpdate: Atomic Read-Modify-Write
35.9
Concurrency und Atomicity: Updates in Multi-User-Systemen
35.10
Performance Considerations: Index-Nutzung bei Updates
35.11
Bulk-Updates: Effizient viele Dokumente updaten
36
CRUD: Delete – Permanenz und Vorsicht
36.1
deleteOne und deleteMany: Die primären Delete-APIs
36.2
Safety-Pattern: Dry-Run via countDocuments
36.3
Soft Deletes: Marking statt Removing
36.4
findOneAndDelete: Atomic Read-Delete
36.5
Bulk Deletes: Performance bei großen Mengen
36.6
drop() vs. deleteMany({}): Collection löschen
36.7
TTL Indexes: Automatische Deletes
36.8
Performance-Implikationen: Indexes und Deletes
36.9
Audit-Logging und Compliance
36.10
Backup-Strategien vor kritischen Deletes
36.11
Die Psychologie von Deletes: Cultural Practices
37
Aggregation Framework: MongoDB’s Analytics-Engine
37.1
Pipeline-Architektur: Stages als Transformations-Kette
37.2
$match: Filter für Pipeline-Eingang
37.3
$group: Aggregation und Statistiken
37.4
$project: Felder transformieren und reshapen
37.5
$sort und $limit: Ordering und Pagination
37.6
$unwind: Arrays zu einzelnen Dokumenten
37.7
$lookup: Joins zwischen Collections
37.8
Practical Examples: Real-World-Aggregations
37.9
Performance-Optimierung: Indexes und Stage-Ordering
37.10
Memory Limits und allowDiskUse
37.11
Aggregation in Sharded Clusters: Parallelisierung
38
Aggregation in der Praxis: Von simpel zu komplex
38.1
Basic Pattern: Filter, Sort, Limit
38.2
Grouping Pattern: Aggregierte Statistiken
38.3
Time-Series Pattern: Temporal Aggregation
38.4
Join Pattern: Enriching mit $lookup
38.5
Advanced Join: Pipeline $lookup mit Filtering
38.6
Conditional Logic: Business-Rules in Pipelines
38.7
Window Functions: Running Totals und Rankings
38.8
Output to Collection: Materialized Views
38.9
Real-World-Pattern: Customer-360-View
39
User Management: Security und Access Control
39.1
Authentication vs. Authorization: Die fundamentale Dichotomie
39.2
Der admin-User: Root-Access und Bootstrap
39.3
User-Creation: Die Anatomie eines Users
39.4
Built-in Roles: Die Standard-Permissions
39.5
Practical User-Scenarios: Wer braucht welche Rolle?
39.6
Custom Roles: Granulare Permissions
39.7
Password-Management: Security-Best-Practices
39.8
Authentication-Mechanisms: Beyond Passwords
39.9
User-Administration: CRUD-Operations
39.10
Security-Best-Practices: Production-Hardening
40
Keys in MongoDB: Identity, Performance und Distribution
40.1
_id: Der unverzichtbare Primary Key
40.2
Custom _id: Wenn ObjectId nicht passt
40.3
Indexes als Performance-Keys
40.4
Shard Keys: Distribution-Control in Clustern
40.5
Foreign Keys und Relationships: MongoDB’s Approach
40.6
Compound Keys für Multi-Field-Uniqueness
40.7
Key-Design-Patterns: Best Practices
41
Indexierung: Von Sekunden zu Millisekunden
41.1
Wie Indexes funktionieren: B-Tree-Grundlagen
41.2
Single-Field-Indexes: Die Basics
41.3
Compound-Indexes: Multi-Field-Queries
41.4
Covered Queries: Index-Only-Performance
41.5
Sparse und Partial Indexes: Selective Indexing
41.6
Text-Indexes: Full-Text-Search
41.7
Geospatial-Indexes: Location-Based-Queries
41.8
TTL-Indexes: Auto-Expire-Documents
41.9
Hashed-Indexes: Für Sharding
41.10
Explain: Index-Usage analysieren
41.11
Index-Selection: MongoDB’s Query-Planner
41.12
Index-Maintenance: Listing, Dropping, Rebuilding
41.13
Index-Build-Performance: Background vs. Foreground
41.14
Index-Limits und Best Practices
42
Index-Metriken: Datengetriebene Performance-Optimierung
42.1
explain(): Die Query-Mikroskop
42.2
$indexStats: Index-Usage-Tracking
42.3
Profiler: Slow-Query-Detection
42.4
serverStatus(): System-Wide-Metrics
42.5
stats(): Collection und Index-Size-Metrics
42.6
Practical Workflow: Systematic Index-Optimization
43
Monitoring-Integration: Von Logs zu Actionable Insights
43.1
MongoDB Atlas: Fully-Managed-Monitoring
43.2
Prometheus + Grafana: Infrastructure-Monitoring-Standard
43.3
ELK Stack: Log-Aggregation und Search
43.4
Custom-Monitoring: Lightweight-Solutions
43.5
Monitoring-Best-Practices: Was messen, was alerten
44
Query-Analyse: Von Symptomen zu Root-Causes
44.1
explain() Deep-Dive: Execution-Plan-Details verstehen
44.2
hint(): Index-Selection forcieren
44.3
Covering Indexes: Die schnellste Query ist keine Query
44.4
Aggregation-Pipeline-Analysis: Stage-by-Stage-Performance
44.5
benchRun(): Synthetic-Load-Testing
44.6
system.profile-Aggregations: Pattern-Analysis
44.7
Practical Workflow: Query-Optimization-Process
45
Backup und Restore: Die letzte Verteidigungslinie
45.1
Die Backup-Grundfrage: RTO und RPO
45.2
mongodump und mongorestore: Die Basics
45.3
Filesystem-Snapshots: Speed und Consistency
45.4
Replica-Set-Backups: Zero-Impact on Primary
45.5
Sharded-Cluster-Backups: Koordinierte Multi-Shard-Strategy
45.6
Oplog-Backups: Point-in-Time-Recovery
45.7
Backup-Testing: Der kritischste Schritt
45.8
Backup-Retention und Lifecycle
45.9
Backup-Encryption und Security
45.10
Disaster-Recovery-Planning: Das Playbook
46
Database-Maintenance: Fragmentierung und Reorganisation
46.1
Fragmentierung: Ursachen und Impact
46.2
compact: In-Place-Defragmentation
46.3
repairDatabase: Full-Database-Reorganization
46.4
Export-Reimport: The Nuclear Option
46.5
Index-Maintenance: Rebuild vs. Compact
46.6
Shard-Balancing: Cluster-Reorganization
46.7
Zone-Sharding: Geographic-Data-Organization
46.8
TTL-Indexes: Automated-Data-Expiration
46.9
Maintenance-Scheduling: Wann und Wie