Was ist MongoDB?

MongoDB ist eine dokumentenbasierte NoSQL-Datenbank, die JSON-ähnliche Datenstrukturen (BSON) verwendet. Sie wurde entwickelt, um eine hohe Flexibilität und Skalierbarkeit zu bieten, und ist besonders geeignet für Anwendungen mit dynamischen oder unstrukturierten Daten.

Vorteile von MongoDB

• Schemaflexibilität: Dokumente in einer Collection können unterschiedliche Felder und Strukturen aufweisen.
• Hohe Skalierbarkeit: Unterstützt horizontales Sharding zur Verteilung von Daten über mehrere Server.
• JSON-ähnliches Format: BSON erleichtert die Integration mit modernen Programmiersprachen.
• Eingebaute Replikation: Daten werden automatisch über Replikatsets gesichert.
• Leistungsfähige Abfragen: Unterstützung für Indexe, Aggregationen und komplexe Suchanfragen.
• Open Source: Große Community und kostenlose Nutzung (mit kostenpflichtigen Enterprise-Optionen).

Typische Einsatzgebiete

• Web- und Mobilanwendungen: Speicherung von Benutzerdaten, Sitzungsinformationen oder dynamischen Inhalten.
• IoT: Speicherung und Verarbeitung von Sensordaten.
• Content-Management-Systeme (CMS): Flexible Datenmodelle für Inhalte und Metadaten.
• Echtzeit-Analysen: Verarbeitung von Ereignisdaten für Dashboards oder Monitoring.
• Geodaten-Anwendungen: Speicherung und Abfragen von Standortdaten.

Mit MongoDB lassen sich schnell und effizient Anwendungen entwickeln, die mit dynamischen Datenstrukturen und wachsendem Datenvolumen umgehen können.

Installation von MongoDB mit Docker

Schritte zur Installation von MongoDB mit Docker

1. MongoDB-Image herunterladen:

   docker pull mongo:latest

   Dies lädt das neueste MongoDB-Docker-Image aus dem offiziellen Docker Hub.

2. MongoDB-Container starten:

   docker run -d \
    --name mongodb \
    -p 27017:27017 \
    -v mongodb_data:/data/db \
    mongo:latest

   • -d: Startet den Container im Hintergrund.
   • --name mongodb: Gibt dem Container den Namen mongodb.
   • -p 27017:27017: Bindet den MongoDB-Port (Standard: 27017) an den Host.
   • -v mongodb_data:/data/db: Erstellt ein Docker-Volume für die persistente Speicherung der Daten unter /data/db.

3. Überprüfung des Containers:

   docker ps

   Dies zeigt eine Liste der laufenden Container. Der mongodb-Container sollte in der Liste erscheinen.

4. Logs überprüfen (optional): Um sicherzustellen, dass der Container ordnungsgemäß läuft, kannst du die Logs abrufen:

   docker logs mongodb

5. Container stoppen und entfernen (bei Bedarf):

   • Stoppen:

     docker stop mongodb

   • Entfernen:

     docker rm mongodb

Hinweis

Die Konfiguration verwendet keine Authentifizierung. Für produktive Umgebungen sollte ein Benutzer mit Passwort eingerichtet werden, und der Zugriff auf die Datenbank sollte über eine Firewall geschützt sein.

Clients

1. MongoDB Compass

• Beschreibung: Das offizielle GUI-Tool von MongoDB.
• Vorteile:
  • Einfache Installation und Nutzung.
  • Intuitive Benutzeroberfläche für Abfragen und Datenvisualisierung.
  • Unterstützt erweiterte Funktionen wie Aggregations-Pipelines.
• Nachteile:
  • Kann ressourcenintensiv sein.
  • Nicht optimal für sehr große Datenmengen.
• Link: MongoDB Compass herunterladen

2. DBeaver (Community Edition)

• Beschreibung: Open-Source-Datenbank-Tool mit Unterstützung für viele Datenbanken.
• Vorteile:
  • Multi-Datenbank-Support in einer einzigen Anwendung.
  • Solide SQL-Editor-Funktionen.
• Nachteile:
  • Die Community Edition unterstützt MongoDB nicht direkt (Pro-Version erforderlich).
  • Keine native JSON-Visualisierung.
• Link: DBeaver herunterladen

3. MongoSH

 docker exec -it mongodb mongosh

MongoDB in der Cloud

kostenlose MongoDB im Atlas-Clusters

1. Registrierung bei MongoDB Atlas:

   • Besuche die MongoDB Atlas Website.
   • Erstelle ein kostenloses Konto oder melde dich mit deinem bestehenden Konto an.

2. Erstellen eines neuen Clusters:

   • Klicke auf "Create a Cluster".
   • Wähle die Option Shared Cluster (kostenlos) und klicke auf "Create".
   • Konfiguriere dein Cluster:
     • Cloud-Provider: AWS, Google Cloud oder Azure (Standard ist AWS).
     • Region: Wähle die nächstgelegene Region, um Latenzzeiten zu minimieren.
     • Cluster Name: Gib einen Namen für deinen Cluster ein oder verwende den Standardnamen.
   • Klicke auf "Create Cluster". Der Vorgang kann ein paar Minuten dauern.

3. Einrichten von Zugriff und Netzwerk:

   • Gehe nach der Cluster-Erstellung zu Network Access:
     • Klicke auf "Add IP Address".
     • Wähle "Allow Access from Anywhere" (für Testzwecke) oder gib eine spezifische IP-Adresse an.
   • Gehe zu Database Access:
     • Erstelle einen neuen Benutzer, indem du auf "Add New Database User" klickst.
     • Gib einen Benutzernamen und ein Passwort ein.
     • Setze die Rolle auf "Read and Write to Any Database" (für Testumgebungen).

4. Verbindung herstellen:

   • Gehe zu Connect im Cluster-Dashboard.
   • Wähle "Connect Your Application".
   • Kopiere die bereitgestellte Verbindung-URI, z. B.:

     mongodb+srv://<username>:<password>@<cluster-name>.mongodb.net/<database-name>?retryWrites=true&w=majority

   • Ersetze <username> und <password> mit den von dir erstellten Anmeldedaten.

5. Testen der Verbindung (Beispiel mit Python):

   • Installiere die offizielle Python-Bibliothek pymongo:

     pip install pymongo

   • Beispielcode:

     from pymongo import MongoClient
     
     # Verbindung zu Atlas-Cluster herstellen
     uri = "mongodb+srv://<username>:<password>@<cluster-name>.mongodb.net/?retryWrites=true&w=majority"
     client = MongoClient(uri)
     
     # Test der Verbindung
     try:
      print("MongoDB-Version:", client.server_info()["version"])
     except Exception as e:
      print("Verbindung fehlgeschlagen:", e)

6. Cluster-Verwaltung:

   • Über das Atlas-Dashboard kannst du:
     • Datenbanken erstellen und Collections verwalten.
     • Aggregationen und Abfragen durchführen.
     • Performance überwachen (beschränkt in der Free-Tier-Version).

Vorteile von Atlas-Free-Tier:

• Kostenlos: Bis zu 512 MB Speicherplatz.
• Hohe Verfügbarkeit: Automatische Replikation auf mehrere Nodes.
• Einfache Verwaltung: Intuitive Oberfläche zur Verwaltung von Clustern und Benutzern.
• Schnelle Skalierbarkeit: Möglichkeit, bei Bedarf auf kostenpflichtige Pläne zu upgraden.

Einschränkungen:

• Speicherplatz und Performance sind begrenzt.
• Eingeschränkte Konfigurationsmöglichkeiten (kein vollständiger Root-Zugriff).
• Free-Tier-Datenbanken können nach 30 Minuten Inaktivität schlafen gehen.

Lokale DB in die Cloud kopieren

1. Dump erstellen

   docker exec -it mongodb mongodump

2. Dump in die Cloud kopieren

   docker exec -it mongodb mongorestore --uri="mongodb+srv://<username>:<password>@<cluster>.mongodb.net/"

3. Index erstellen Mit Cloud DB verbinden:

   docker exec -it mongodb mongosh "mongodb+srv://<cluster>.mongodb.net/" --apiVersion 1 --username <username>

   Index erstellen:

   use <database>
   db.fullsite.createIndex(
   { cleaned_text: "text" },  // Das Feld, das durchsucht werden soll
   { default_language: "german" }  // Sprache für den Textindex
   );

Beispiel

Ich möchte die Datenbank aus dem letzten Artikel Webseitendaten Assistent KI in die Cloud bringen. Die Datenmenge ist allerdings zu groß, so dass ich zuerste die Rohdaten löschen muss. Anschließend kann ich den Dump erstellen, in die Cloud hoch laden und abschließend den Index erstellen.

Datenmenge verkleinern

docker exec -it CompanyDataAI-mongo mongosh

use firmendaten

show dbs
db.stats()

db.fullsite.updateMany(
  {},
  { $unset: { fieldName: "raw_html" } }
)

show dbs
db.stats()

Dump erstellen

docker exec -it CompanyDataAI-mongo mongodump --db firmendaten

Datenbank importieren

docker exec -it CompanyDataAI-mongo mongorestore --db firmendaten --uri="mongodb+srv://<username>:<password>@<cluster>.mongodb.net/"

Problem

Laut show dbs ist die Datenbank 335 MB groß, der Dump ist allerdings 1,3 GB groß. Die Erklärung ist vermutlich, dass die Daten in der Datenbank komprimiert sind, im Dump hingegen nicht. Die freie Cloud Datenbank hat aber nur einen Speicher von 512 MB. Als Lösungsansatz versuchen wir einen komprimierten Dump (190 MB):

docker exec -it CompanyDataAI-mongo mongodump --db firmendaten --gzip

docker exec -it CompanyDataAI-mongo mongorestore --gzip --db firmendaten --uri="mongodb+srv://<username>:<password>@<cluster>.mongodb.net/" /dump/firmendaten

Leider wird auch dadurch das Problem nicht gelöst:

Failed: firmendaten.fullsite: error restoring from /dump/firmendaten/fullsite.bson.gz: (AtlasError) you are over your space quota, using 526 MB of 512 MB

Daher habe ich den nicht komplett importierten Dump gelöscht und dann das Scraping-Tool mit der Cloud-DB verbunden und neu durchlaufen lassen. Das hat dann auch funktioniert, allerdings war das setzen des Index dann zu groß. Vielleicht hätte der Dump/Restore funktioniert, wenn ich vorher den Index in der lokalen DB gelöscht hätte?

Index setzen

docker exec -it mongodb mongosh "mongodb+srv://<cluster>.mongodb.net/" --apiVersion 1 --username <username>

Index erstellen:

use firmendaten
db.fullsite.createIndex(
  { cleaned_text: "text" },  // Das Feld, das durchsucht werden soll
  { default_language: "german" }  // Sprache für den Textindex
);

Leider bricht der Vorgang ab: you are over your space quota.

Fazit

Die Datenbankgröße von 512MB im Free Tier ist nicht ausreichend. Denn leider ist damit nicht der Speicher auf dem Filesystem gemeint (storageSize), den man mit show dbs sehen kann, sondern die Größe der Daten (dataSize) die man mit db.stats() sehen kann. Damit ist die Datenbank leider nicht für mein Projekt zu gebrauchen.

Workaround

Um mit meinem PoC weiter zu kommen, lösche ich irgendwelche Daten und überlege mir später eine andere Lösung:

docker exec -it mongodb mongosh "mongodb+srv://<cluster>.mongodb.net/" --apiVersion 1 --username <username>

use firmendaten;

# Index löschen
db.fullsite.dropIndexes();

# Dokumente ohne Inhalt löschen
db.fullsite.deleteMany({
    $or: [
        { cleaned_text: { $exists: false } }, // Optional
        { cleaned_text: "" },
        { cleaned_text: null }
    ]
});

# Die letzten 50 Dokument löschen
db.fullsite.find()
    .sort({ _id: -1 })
    .limit(50)
    .forEach(doc => db.fullsite.deleteOne({ _id: doc._id }));

# Rohdaten löschen
db.fullsite.updateMany({}, { $unset: { fieldName: "raw_html" } });

# Index setzen
db.fullsite.createIndex(
  { cleaned_text: "text" },  // Das Feld, das durchsucht werden soll
  { default_language: "german" }  // Sprache für den Textindex
);