DevOps Wissensdatenbank
DevOps Wissensdatenbank

Schritt-für-Schritt-Anleitung zur Migration relationaler SQL-Daten nach MongoDB

Erfahren Sie mit dieser umfassenden Schritt-für-Schritt-Anleitung, wie Sie Ihre relationalen SQL-Daten nach MongoDB migrieren können. Entdecken Sie Best Practices zur Transformation traditioneller Schemas in effiziente MongoDB-Dokumentstrukturen, einschließlich essenzieller Planung, Schemadesign-Strategien wie Embedding und Referenzierung, Datenextraktion, Transformationstechniken und das Laden in MongoDB. Dieses Tutorial bietet praktische Beispiele und umsetzbare Ratschläge für einen reibungslosen und erfolgreichen Übergang zu einer NoSQL-Datenbank.

36 Aufrufe

Schritt-für-Schritt-Anleitung zur Migration relationaler SQL-Daten zu MongoDB

Die Migration von einer relationalen Datenbank wie SQL zu einer NoSQL-Dokumentendatenbank wie MongoDB ist ein übliches, aber oft komplexes Unterfangen. Relationale Datenbanken zeichnen sich durch die Durchsetzung von Datenintegrität durch strukturierte Tabellen, Fremdschlüssel und ACID-Transaktionen aus. MongoDB hingegen bietet Flexibilität, Skalierbarkeit und Leistungsvorteile für bestimmte Workloads durch die Verwendung eines dokumentorientierten Datenmodells. Diese Anleitung bietet einen praktischen Schritt-für-Schritt-Ansatz zur Umwandlung traditioneller relationaler Schemata in effiziente MongoDB-Dokumentstrukturen, der wichtige Überlegungen zur Schemaentwicklung und Werkzeuge für einen reibungslosen Übergang abdeckt.

Das Verständnis der grundlegenden Unterschiede zwischen diesen Datenbankparadigmen ist entscheidend für eine erfolgreiche Migration. Relationale Schemata sind typischerweise normalisiert, wobei Daten zur Redundanzreduzierung in mehrere Tabellen aufgeteilt werden. Das Dokumentenmodell von MongoDB fördert jedoch die Denormalisierung, indem zusammengehörige Daten zur Verbesserung der Lesegeschwindigkeit und Vereinfachung der Anwendungslogik in einem einzigen Dokument eingebettet werden. Dieser Wandel erfordert sorgfältige Planung, um Dokumente zu entwerfen, die mit den Zugriffsmustern Ihrer Anwendung übereinstimmen.

Verstehen der Kernunterschiede: Relationale vs. Dokumentenmodelle

Bevor Sie sich mit dem Migrationsprozess befassen, ist es wichtig, die konzeptionellen Unterschiede zu verstehen:

  • Relationales Modell: Daten werden in Tabellen mit vordefinierten Schemata gespeichert. Beziehungen werden über Fremdschlüssel verwaltet, was JOIN-Operationen zur Abfrage verwandter Daten erfordert. Normalisierung ist ein Schlüsselprinzip.
  • Dokumentenmodell (MongoDB): Daten werden in flexiblen, JSON-ähnlichen Dokumenten gespeichert. Dokumente können unterschiedliche Strukturen aufweisen. Verwandte Daten können in einem einzigen Dokument eingebettet werden (Denormalisierung) oder über anwendungsseitige Joins oder die $lookup-Aggregationsstufe von MongoDB referenziert werden.

Dieser Unterschied im Datenmodell beeinflusst direkt, wie Sie Ihre MongoDB-Sammlungen und -Dokumente entwerfen.

Phase 1: Planung und Schemaentwicklung

Dies ist die kritischste Phase. Ein gut gestaltetes MongoDB-Schema ist der Schlüssel zur Nutzung seiner Vorteile. Ziel ist es, Ihre Daten basierend auf den Zugriffsmustern der Anwendung zu modellieren, nicht nur auf einer direkten Übersetzung Ihrer SQL-Tabellen.

1. Analysieren Sie die Zugriffsmuster Ihrer Anwendung

  • Identifizieren Sie Lese- vs. Schreiboperationen: Wie häufig werden Daten gelesen und wie werden sie typischerweise abgefragt? Welche Felder werden am häufigsten zusammen abgerufen?
  • Bestimmen Sie gängige Abfragepfade: Was sind die häufigsten SELECT-Anweisungen in Ihrer SQL-Anwendung? Welche Tabellen werden normalerweise verbunden?
  • Verstehen Sie Datenbeziehungen: Wie sind Entitäten miteinander verbunden? Handelt es sich um Eins-zu-Eins-, Eins-zu-Viele- oder Viele-zu-Viele-Beziehungen?

2. Wählen Sie Ihre Denormalisierungsstrategie

Die Stärke von MongoDB liegt in seiner Fähigkeit, zusammengehörige Daten einzubetten. Berücksichtigen Sie diese Strategien:

  • Einbetten (Denormalisierung): Der gängigste Ansatz. Betten Sie Dokumente oder Dokumenten-Arrays in ein übergeordnetes Dokument ein, wenn die Beziehung Eins-zu-Viele ist oder wenn Daten häufig zusammen abgerufen werden. Dies reduziert die Notwendigkeit von Joins.
    • Beispiel: Anstatt separater orders- und order_items-Tabellen können Sie order_items als Array innerhalb des order-Dokuments einbetten.
  • Referenzieren: Verwenden Sie dies, wenn das Einbetten zu übermäßig großen Dokumenten führen würde oder wenn Daten unabhängig abgerufen werden. Speichern Sie die _id eines verwandten Dokuments, ähnlich wie Fremdschlüssel, und führen Sie anwendungsseitige Joins durch oder verwenden Sie $lookup von MongoDB.
    • Beispiel: Eine users-Sammlung und eine posts-Sammlung. Ein Beitrag könnte die user_id seines Autors speichern. Sie können dann $lookup verwenden, um die Details des Autors beim Abrufen eines Beitrags abzurufen.

3. Entwerfen Sie Ihre MongoDB-Sammlungen und -Dokumente

Basierend auf Ihren Zugriffsmustern und Ihrer Denormalisierungsstrategie entwerfen Sie Ihre Sammlungen. Ein guter Ausgangspunkt ist die Abbildung von SQL-Tabellen auf MongoDB-Sammlungen. Entscheiden Sie dann, welche verwandten Daten eingebettet und welche referenziert werden sollen.

Beispiel für ein SQL-Schema:

-- Customers Table
CREATE TABLE Customers (
    CustomerID INT PRIMARY KEY,
    FirstName VARCHAR(50),
    LastName VARCHAR(50),
    Email VARCHAR(100)
);

-- Orders Table
CREATE TABLE Orders (
    OrderID INT PRIMARY KEY,
    CustomerID INT,
    OrderDate DATE,
    TotalAmount DECIMAL(10, 2),
    FOREIGN KEY (CustomerID) REFERENCES Customers(CustomerID)
);

-- OrderItems Table
CREATE TABLE OrderItems (
    OrderItemID INT PRIMARY KEY,
    OrderID INT,
    ProductID INT,
    Quantity INT,
    Price DECIMAL(10, 2),
    FOREIGN KEY (OrderID) REFERENCES Orders(OrderID)
);

Optionen für das MongoDB-Dokumentendesign:

  • **Option A: Kunde mit eingebetteten Bestellungen (wenn Kunden eine überschaubare Anzahl von Bestellungen haben und Bestellungen häufig zusammen mit dem Kunden angezeigt werden):
    json { "_id": ObjectId("..."), "customer_id": 1, "first_name": "John", "last_name": "Doe", "email": "[email protected]", "orders": [ { "order_id": 101, "order_date": ISODate("2023-10-26T00:00:00Z"), "total_amount": 50.00, "items": [ { "product_id": 1, "quantity": 2, "price": 25.00 }, { "product_id": 3, "quantity": 1, "price": 0.00 } // Beispiel für kostenlosen Artikel ] }, // ... weitere Bestellungen ] }
  • Option B: Separate Sammlungen mit Referenzierung (wenn Bestellungen zahlreich sind oder oft unabhängig abgefragt werden):
    Customers Collection:
    json { "_id": ObjectId("..."), "customer_id": 1, "first_name": "John", "last_name": "Doe", "email": "[email protected]" }
    Orders Collection:**
    json { "_id": ObjectId("..."), "order_id": 101, "customer_id": 1, // Referenz zur Customers-Sammlung "order_date": ISODate("2023-10-26T00:00:00Z"), "total_amount": 50.00, "items": [ { "product_id": 1, "quantity": 2, "price": 25.00 }, { "product_id": 3, "quantity": 1, "price": 0.00 } ] }

Überlegungen zur Dokumentgröße: MongoDB hat eine Beschränkung der Dokumentgröße (16 MB). Vermeiden Sie das Einbetten von übermäßig großen Arrays, die dieses Limit überschreiten könnten. Wenn ein Array unendlich wächst, sollten Sie es in eine separate Sammlung auslagern.

Phase 2: Datenextraktion und -transformation

Sobald Ihr Zielschema entworfen ist, müssen Sie Daten aus Ihrer SQL-Datenbank extrahieren und in das neue Dokumentenformat transformieren.

1. Daten aus SQL extrahieren

Verwenden Sie Standard-SQL-Abfragen, um die benötigten Daten auszuwählen. Sie können diese Daten in Formate wie CSV oder JSON exportieren.

  • Verwendung von SQL-Clients: Die meisten SQL-Datenbanktools (z. B. DBeaver, SQL Developer, pgAdmin) ermöglichen den Export von Abfrageergebnissen nach CSV oder JSON.
  • Skripting: Schreiben Sie Skripte (Python, Node.js usw.), um eine Verbindung zu Ihrer SQL-Datenbank herzustellen, Abfragen auszuführen und Daten abzurufen.

2. Daten transformieren

Hier implementieren Sie Ihr entworfenes Schema. Sie müssen Code schreiben oder ein Werkzeug verwenden, um:

  • Zusammengehörige Datensätze gruppieren: Sammeln Sie beispielsweise alle OrderItems, die zu einer bestimmten Order gehören.
  • Daten umstrukturieren: Konvertieren Sie relationale Zeilen in verschachtelte JSON-Dokumente.
  • Datentypen behandeln: Stellen Sie sicher, dass die Datentypen mit MongoDB kompatibel sind (z. B. Datumsangaben, Zahlen, Zeichenfolgen).

Beispiel mit Python:

Angenommen, Sie haben Customers, Orders und OrderItems in CSV-Dateien exportiert.

import pandas as pd
import json
from bson import ObjectId # Für MongoDB ObjectId, obwohl für die direkte Transformation nicht unbedingt erforderlich

# Daten aus CSV-Dateien laden (angenommen, sie befinden sich im selben Verzeichnis)
customers_df = pd.read_csv('customers.csv')
orders_df = pd.read_csv('orders.csv')
order_items_df = pd.read_csv('order_items.csv')

# --- Daten transformationslogik ---

# DataFrame zur einfacheren Bearbeitung in Wörterbücher konvertieren
customers_list = customers_df.to_dict('records')
orders_list = orders_df.to_dict('records')
order_items_list = order_items_df.to_dict('records')

# Eine Zuordnung für Bestellungen und Bestellpositionen für schnellen Abruf erstellen
orders_by_customer = {}
for order in orders_list:
    customer_id = order['CustomerID']
    if customer_id not in orders_by_customer:
        orders_by_customer[customer_id] = []
    orders_by_customer[customer_id].append(order)

order_items_by_order = {}
for item in order_items_list:
    order_id = item['OrderID']
    if order_id not in order_items_by_order:
        order_items_by_order[order_id] = []
    order_items_by_order[order_id].append(item)

# --- MongoDB-Dokumente erstellen (Option A: Kunde mit eingebetteten Bestellungen) ---
mongo_documents = []

for customer in customers_list:
    mongo_doc = {
        "_id": ObjectId(), # MongoDB generiert _id automatisch, aber Sie können es bei Bedarf zuordnen
        "customer_id": customer['CustomerID'],
        "first_name": customer['FirstName'],
        "last_name": customer['LastName'],
        "email": customer['Email'],
        "orders": []
    }

    customer_id = customer['CustomerID']
    if customer_id in orders_by_customer:
        for order in orders_by_customer[customer_id]:
            order_doc = {
                "order_id": order['OrderID'],
                "order_date": order['OrderDate'], # Sicherstellen, dass das Datumsformat korrekt ist
                "total_amount": order['TotalAmount'],
                "items": []
            }

            order_id = order['OrderID']
            if order_id in order_items_by_order:
                for item in order_items_by_order[order_id]:
                    order_doc['items'].append({
                        "product_id": item['ProductID'],
                        "quantity": item['Quantity'],
                        "price": item['Price']
                    })
            mongo_doc['orders'].append(order_doc)

    mongo_documents.append(mongo_doc)

# Jetzt ist 'mongo_documents' eine Liste von Wörterbüchern, die zur Einfügung in MongoDB bereit sind
# print(json.dumps(mongo_documents[0], indent=2, default=str)) # Erstes Dokument als JSON ausgeben

# Für Option B (Separate Sammlungen) würden Sie Listen für jede Sammlung erstellen:
# customers_mongo = [{'customer_id': c['CustomerID'], ...} for c in customers_list]
# orders_mongo = [{'order_id': o['OrderID'], 'customer_id': o['CustomerID'], ...} for o in orders_list]

# In JSON für den Import speichern (optional)
# with open('mongo_customer_data.json', 'w') as f:
#     json.dump(mongo_documents, f, indent=2, default=str)

3. Werkzeuge für die Transformation

  • Benutzerdefinierte Skripte: Python mit Pandas, Node.js mit Bibliotheken wie csv-parser und mysql/pg sind leistungsfähig für komplexe Transformationen.
  • ETL-Werkzeuge: Werkzeuge wie Apache NiFi, Talend oder AWS Glue können komplexe Datenpipelines orchestrieren, einschließlich der SQL-zu-MongoDB-Migration.
  • MongoDB Atlas Live Migration: Wenn Sie zu MongoDB Atlas migrieren, kann deren Live Migration Service Ihnen helfen, Daten aus verschiedenen Quellen, einschließlich SQL-Datenbanken, zu verschieben.

Phase 3: Datenladung in MongoDB

Sobald Ihre Daten transformiert sind, können Sie sie in Ihre MongoDB-Instanz laden.

1. Verbindung zu MongoDB herstellen

Verwenden Sie die MongoDB Shell (mongosh) oder einen MongoDB-Treiber (für Ihre Programmiersprache), um eine Verbindung zu Ihrer Datenbank herzustellen.

2. Transformierte Daten importieren

  • Verwendung von mongosh mit mongoimport: Wenn Sie Ihre transformierten Daten in eine JSON-Datei exportiert haben (wie im Python-Beispiel gezeigt), können Sie mongoimport verwenden:
    bash # Angenommen, Ihre Daten befinden sich in mongo_customer_data.json und Sie möchten sie in die 'customers'-Sammlung importieren mongoimport --db Ihr_datenbankname --collection customers --file mongo_customer_data.json --jsonArray

    • --jsonArray: Verwenden Sie dieses Flag, wenn Ihre JSON-Datei ein Array von Dokumenten enthält.

  • Verwendung von MongoDB-Treibern: Wenn Sie Ihre Datenstrukturen in Ihrer Programmiersprache generiert haben (wie die mongo_documents-Liste in Python), können Sie sie direkt einfügen:

    **Python-Beispiel (mit pymongo):
    ```python
    from pymongo import MongoClient

    Angenommen, die 'mongo_documents'-Liste wurde aus dem vorherigen Python-Skript definiert

    client = MongoClient('mongodb://localhost:27017/')
    db = client['Ihr_datenbankname']
    customers_collection = db['customers']

    Die transformierten Dokumente einfügen

    if mongo_documents:
    insert_result = customers_collection.insert_many(mongo_documents)
    print(f"{len(insert_result.inserted_ids)} Dokumente eingefügt.")
    else:
    print("Keine Dokumente zum Einfügen vorhanden.")

    client.close()
    ```

3. Datenintegrität überprüfen

Führen Sie nach dem Laden Abfragen in MongoDB aus, um zu überprüfen, ob die Daten korrekt importiert wurden und Ihren Erwartungen entsprechen.

// Beispiel: Dokumente in der 'customers'-Sammlung zählen
use Ihr_datenbankname;
print(db.customers.countDocuments());

// Beispiel: Einen bestimmten Kunden finden und seine eingebetteten Bestellungen überprüfen
db.customers.findOne({ "customer_id": 1 })

Phase 4: Anwendungsrefactoring

Dies ist wohl die zeitaufwändigste Phase. Ihr Anwendungs-Code muss aktualisiert werden, um mit MongoDB anstelle von SQL zu interagieren.

  • Datenbankverbindungen aktualisieren: Verbindungszeichenfolgen und Bibliotheken ändern.
  • Abfragen neu schreiben: SQL-Abfragen durch die MongoDB Query Language (MQL) über die API Ihres gewählten Treibers ersetzen.
  • Datenzugriffsschicht anpassen: Ändern Sie Ihr ORM oder Ihre Datenzugriffsschicht, damit sie mit MongoDB-Dokumenten funktioniert.
  • MongoDB-Funktionen nutzen: Passen Sie Ihre Anwendung an, um Funktionen wie flexible Schemata, das Aggregationsframework und, falls zutreffend, Geodatenabfragen zu nutzen.

Best Practices und Tipps

  • Klein anfangen: Migrieren Sie, wenn möglich, zuerst einen Teil Ihrer Daten oder eine weniger kritische Anwendung, um Erfahrungen zu sammeln.
  • Schemaentwicklung iterieren: Ihr anfängliches MongoDB-Schema ist möglicherweise nicht perfekt. Seien Sie bereit, es basierend auf Leistungstests und Anwendungsfeedback zu iterieren und zu verfeinern.
  • Indizes mit Bedacht wählen: Genau wie in SQL sind Indizes für die Leistung in MongoDB entscheidend. Identifizieren Sie Ihre Abfragemuster und erstellen Sie entsprechende Indizes.
  • Leistung überwachen: Überwachen Sie Ihre MongoDB-Bereitstellung kontinuierlich auf Leistungsengpässe und optimieren Sie Abfragen und Schemata nach Bedarf.
  • Inkrementelle Migration in Erwägung ziehen: Ziehen Sie für große Datenbanken eine inkrementelle Migrationsstrategie in Betracht, bei der Sie Änderungen von SQL nach MongoDB nahezu in Echtzeit synchronisieren, bevor Sie einen endgültigen Cutover durchführen.

Fazit

Die Migration von SQL zu MongoDB ist ein strategischer Schritt, der erhebliche Vorteile in Bezug auf Flexibilität und Skalierbarkeit bringen kann. Der Prozess erfordert sorgfältige Planung, durchdachte Schemaentwicklung, die sich auf die Zugriffsmuster der Anwendung konzentriert, und eine robuste Transformations- und Ladestrategie. Indem Sie diese Schritte und Best Practices befolgen, können Sie die Komplexität der Umwandlung Ihrer relationalen Daten in ein effizientes und leistungsstarkes MongoDB-Dokumentenmodell meistern und so den Weg für eine agilere und skalierbarere Anwendungsarchitektur ebnen.