Hub de Connaissances DevOps
Hub de Connaissances DevOps

Guide étape par étape pour migrer des données relationnelles SQL vers MongoDB

Apprenez à migrer vos données relationnelles SQL vers MongoDB grâce à ce guide complet étape par étape. Découvrez les meilleures pratiques pour transformer des schémas traditionnels en structures de documents MongoDB efficaces, y compris la planification essentielle, les stratégies de conception de schémas comme l'intégration (embedding) et la référence (referencing), l'extraction de données, les techniques de transformation et le chargement dans MongoDB. Ce tutoriel fournit des exemples pratiques et des conseils exploitables pour une transition fluide et réussie vers une base de données NoSQL.

34 vues

Guide pas-à-pas pour la migration de données relationnelles SQL vers MongoDB

La migration d'une base de données relationnelle comme SQL vers une base de données de documents NoSQL telle que MongoDB est une entreprise courante mais souvent complexe. Les bases de données relationnelles excellent à assurer l'intégrité des données grâce à des tables structurées, des clés étrangères et des transactions ACID. MongoDB, en revanche, offre flexibilité, évolutivité et avantages de performance pour certaines charges de travail en utilisant un modèle de données orienté document. Ce guide fournit une approche pratique et étape par étape pour transformer des schémas relationnels traditionnels en structures de documents MongoDB efficaces, couvrant les considérations essentielles de conception de schéma et les outils pour une transition en douceur.

Comprendre les différences fondamentales entre ces paradigmes de bases de données est crucial pour une migration réussie. Les schémas relationnels sont généralement normalisés, décomposant les données en plusieurs tables pour réduire la redondance. Le modèle de document de MongoDB, cependant, encourage la dénormalisation, intégrant les données connexes au sein d'un seul document pour améliorer les performances de lecture et simplifier la logique d'application. Ce changement nécessite une planification minutieuse pour concevoir des documents qui s'alignent sur les modèles d'accès de votre application.

Comprendre les différences fondamentales : Modèles relationnel vs. document

Avant de plonger dans le processus de migration, il est essentiel de saisir les différences conceptuelles :

  • Modèle relationnel : Les données sont stockées dans des tables avec des schémas prédéfinis. Les relations sont gérées via des clés étrangères, nécessitant des opérations de JOIN pour récupérer les données associées. La normalisation est un principe clé.
  • Modèle de document (MongoDB) : Les données sont stockées dans des documents flexibles, de type JSON. Les documents peuvent avoir des structures variables. Les données connexes peuvent être intégrées dans un seul document (dénormalisation) ou référencées à l'aide de jointures au niveau de l'application ou de l'étape d'agrégation $lookup de MongoDB.

Cette différence dans la modélisation des données a un impact direct sur la façon dont vous concevez vos collections et documents MongoDB.

Phase 1 : Planification et conception du schéma

C'est la phase la plus critique. Un schéma MongoDB bien conçu est essentiel pour exploiter ses avantages. L'objectif est de modéliser vos données en fonction des modèles d'accès de l'application, et non seulement d'une traduction directe de vos tables SQL.

1. Analyser les modèles d'accès de votre application

  • Identifier les opérations à forte lecture vs. à forte écriture : À quelle fréquence les données sont-elles lues et comment sont-elles généralement interrogées ? Quels champs sont les plus souvent récupérés ensemble ?
  • Déterminer les chemins de requête courants : Quelles sont les instructions SELECT les plus fréquentes dans votre application SQL ? Quelles tables sont généralement jointes ?
  • Comprendre les relations de données : Comment les entités sont-elles liées ? S'agit-il de relations un-à-un, un-à-plusieurs ou plusieurs-à-plusieurs ?

2. Choisir votre stratégie de dénormalisation

La puissance de MongoDB réside dans sa capacité à intégrer des données connexes. Considérez ces stratégies :

  • Intégration (Dénormalisation) : L'approche la plus courante. Intégrez des documents ou des tableaux de documents au sein d'un document parent lorsque la relation est un-à-plusieurs ou lorsque les données sont fréquemment accédées ensemble. Cela réduit le besoin de jointures.
    • Exemple : Au lieu d'avoir des tables orders et order_items séparées, vous pouvez intégrer les order_items comme un tableau dans le document order.
  • Référencement : À utiliser lorsque l'intégration entraînerait des documents excessivement volumineux, ou lorsque les données sont accédées indépendamment. Stockez l'_id d'un document lié, de manière similaire aux clés étrangères, et effectuez des jointures au niveau de l'application ou utilisez le $lookup de MongoDB.
    • Exemple : Une collection users et une collection posts. Un message pourrait stocker l'user_id de son auteur. Vous pouvez ensuite utiliser $lookup pour récupérer les détails de l'auteur lors de la récupération d'un message.

3. Concevoir vos collections et documents MongoDB

En fonction de vos modèles d'accès et de votre stratégie de dénormalisation, concevez vos collections. Un bon point de départ est de mapper les tables SQL aux collections MongoDB. Ensuite, décidez quelles données connexes doivent être intégrées et lesquelles doivent être référencées.

Exemple de schéma SQL :

-- 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)
);

Options de conception de document MongoDB :

  • Option A : Client avec commandes intégrées (si les clients ont un nombre gérable de commandes et que les commandes sont fréquemment consultées avec le client) :
    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 } // Example of free item ] }, // ... more orders ] }
  • Option B : Collections séparées avec référencement (si les commandes sont nombreuses ou souvent interrogées indépendamment) :
    Collection Clients :
    json { "_id": ObjectId("..."), "customer_id": 1, "first_name": "John", "last_name": "Doe", "email": "[email protected]" }
    Collection Commandes :
    json { "_id": ObjectId("..."), "order_id": 101, "customer_id": 1, // Reference to Customers collection "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 } ] }

Considérations relatives à la taille des documents : MongoDB a une limite de taille de document (16 Mo). Évitez d'intégrer des tableaux excessivement volumineux qui pourraient dépasser cette limite. Si un tableau croît indéfiniment, envisagez de le séparer dans une collection distincte.

Phase 2 : Extraction et transformation des données

Une fois votre schéma cible conçu, vous devez extraire les données de votre base de données SQL et les transformer dans le nouveau format de document.

1. Extraire les données de SQL

Utilisez des requêtes SQL standard pour sélectionner les données dont vous avez besoin. Vous pouvez exporter ces données dans des formats tels que CSV ou JSON.

  • Utilisation des clients SQL : La plupart des outils de base de données SQL (par exemple, DBeaver, SQL Developer, pgAdmin) vous permettent d'exporter les résultats des requêtes vers CSV ou JSON.
  • Scripting : Écrivez des scripts (Python, Node.js, etc.) pour vous connecter à votre base de données SQL, exécuter des requêtes et récupérer des données.

2. Transformer les données

C'est ici que vous implémenterez votre schéma conçu. Vous devrez écrire du code ou utiliser un outil pour :

  • Regrouper les enregistrements associés : Par exemple, regroupez tous les OrderItems appartenant à une Order spécifique.
  • Restructurer les données : Convertir les lignes relationnelles en documents JSON imbriqués.
  • Gérer les types de données : Assurez-vous que les types de données sont compatibles avec MongoDB (par exemple, dates, nombres, chaînes de caractères).

Exemple utilisant Python :

Supposons que vous ayez exporté Customers, Orders et OrderItems vers des fichiers CSV.

import pandas as pd
import json
from bson import ObjectId # For MongoDB ObjectId, though not strictly needed for direct transformation

# Load data from CSV files (assuming they are in the same directory)
customers_df = pd.read_csv('customers.csv')
orders_df = pd.read_csv('orders.csv')
order_items_df = pd.read_csv('order_items.csv')

# --- Data Transformation Logic ---

# Convert DataFrame to dictionaries for easier manipulation
customers_list = customers_df.to_dict('records')
orders_list = orders_df.to_dict('records')
order_items_list = order_items_df.to_dict('records')

# Create a mapping for orders and order_items for quick lookup
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)

# --- Building MongoDB Documents (Option A: Customer with Embedded Orders) ---
mongo_documents = []

for customer in customers_list:
    mongo_doc = {
        "_id": ObjectId(), # MongoDB generates _id automatically, but you can map if needed
        "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'], # Ensure correct date format
                "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)

# Now 'mongo_documents' is a list of dictionaries ready to be inserted into MongoDB
# print(json.dumps(mongo_documents[0], indent=2, default=str)) # Print first document as JSON

# For Option B (Separate Collections), you would create lists for each collection:
# 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]

# Save to JSON for import (optional)
# with open('mongo_customer_data.json', 'w') as f:
#     json.dump(mongo_documents, f, indent=2, default=str)

3. Outils de transformation

  • Scripts personnalisés : Python avec Pandas, Node.js avec des bibliothèques comme csv-parser et mysql/pg sont puissants pour les transformations complexes.
  • Outils ETL : Des outils comme Apache NiFi, Talend ou AWS Glue peuvent orchestrer des pipelines de données complexes, y compris la migration de SQL vers MongoDB.
  • Migration en direct MongoDB Atlas : Si vous migrez vers MongoDB Atlas, leur service de migration en direct peut vous aider à déplacer des données depuis diverses sources, y compris les bases de données SQL.

Phase 3 : Chargement des données dans MongoDB

Une fois vos données transformées, vous pouvez les charger dans votre instance MongoDB.

1. Se connecter à MongoDB

Utilisez le shell MongoDB (mongosh) ou un pilote MongoDB (pour votre langage de programmation) pour vous connecter à votre base de données.

2. Importer les données transformées

  • Utilisation de mongosh avec mongoimport : Si vous avez exporté vos données transformées dans un fichier JSON (comme montré dans l'exemple Python), vous pouvez utiliser mongoimport :
    bash # Assuming your data is in mongo_customer_data.json and you want to import into 'customers' collection mongoimport --db your_database_name --collection customers --file mongo_customer_data.json --jsonArray

    • --jsonArray : Utilisez cet indicateur si votre fichier JSON contient un tableau de documents.

  • Utilisation des pilotes MongoDB : Si vous avez généré vos structures de données dans votre langage de programmation (comme la liste mongo_documents en Python), vous pouvez les insérer directement :

    Exemple Python (utilisant pymongo) :
    ```python
    from pymongo import MongoClient

    Assuming 'mongo_documents' list is defined from previous Python script

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

    Insert the transformed documents

    if mongo_documents:
    insert_result = customers_collection.insert_many(mongo_documents)
    print(f"Inserted {len(insert_result.inserted_ids)} documents.")
    else:
    print("No documents to insert.")

    client.close()
    ```

3. Vérifier l'intégrité des données

Après le chargement, exécutez des requêtes dans MongoDB pour vérifier que les données ont été importées correctement et correspondent à vos attentes.

// Example: Count documents in the 'customers' collection
use your_database_name;
print(db.customers.countDocuments());

// Example: Find a specific customer and check their embedded orders
db.customers.findOne({ "customer_id": 1 })

Phase 4 : Refactorisation de l'application

C'est sans doute la phase la plus longue. Le code de votre application doit être mis à jour pour interagir avec MongoDB au lieu de SQL.

  • Mettre à jour les connexions à la base de données : Modifier les chaînes de connexion et les bibliothèques.
  • Réécrire les requêtes : Remplacer les requêtes SQL par le langage de requête MongoDB en utilisant l'API du pilote choisi.
  • Ajuster la couche d'accès aux données : Modifier votre ORM ou votre couche d'accès aux données pour travailler avec des documents MongoDB.
  • Exploiter les fonctionnalités de MongoDB : Adapter votre application pour tirer parti de fonctionnalités telles que les schémas flexibles, le framework d'agrégation et les requêtes géospatiales, le cas échéant.

Bonnes pratiques et conseils

  • Commencer petit : Si possible, migrez d'abord un sous-ensemble de vos données ou une application moins critique pour acquérir de l'expérience.
  • Itérer sur la conception du schéma : Votre schéma MongoDB initial pourrait ne pas être parfait. Soyez prêt à itérer et à l'affiner en fonction des tests de performance et des retours de l'application.
  • Indexer judicieusement : Tout comme dans SQL, l'indexation est cruciale pour la performance dans MongoDB. Identifiez vos modèles de requête et créez des index appropriés.
  • Surveiller les performances : Surveillez en permanence votre déploiement MongoDB pour détecter les goulots d'étranglement de performance et optimisez les requêtes et le schéma au besoin.
  • Envisager une migration incrémentale : Pour les grandes bases de données, envisagez une stratégie de migration incrémentale où vous synchronisez les changements de SQL vers MongoDB en quasi temps réel avant d'effectuer une bascule finale.

Conclusion

La migration de SQL vers MongoDB est une étape stratégique qui peut débloquer des avantages significatifs en termes de flexibilité et d'évolutivité. Le processus nécessite une planification minutieuse, une conception de schéma réfléchie axée sur les modèles d'accès des applications, et une stratégie robuste de transformation et de chargement. En suivant ces étapes et bonnes pratiques, vous pouvez naviguer dans les complexités de la transformation de vos données relationnelles en un modèle de document MongoDB efficace et puissant, ouvrant la voie à une architecture d'application plus agile et évolutive.