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

Migrer des données relationnelles SQL vers MongoDB n'est pas une simple copie de tables. La partie difficile consiste à décider quelles relations doivent devenir des documents embarqués, lesquelles doivent rester référencées, et comment votre application interrogera la nouvelle structure.

Les schémas relationnels sont souvent normalisés entre les tables. Le modèle de document de MongoDB fonctionne souvent mieux lorsque les données connexes lues ensemble sont stockées ensemble. Ce guide vous accompagne à travers la planification, la transformation, le chargement, la vérification et les modifications de l'application sans supposer que chaque table SQL doit devenir une collection MongoDB.

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 JOIN pour récupérer les données connexes. La normalisation est un principe clé.
• Modèle 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 de modélisation des données impacte directement 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 tirer parti de ses avantages. L'objectif est de modéliser vos données en fonction des modèles d'accès de l'application, et non d'une simple 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 le 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 entre les 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 :

• Embedding (Dénormalisation) : L'approche la plus courante. Intégrez des documents ou des tableaux de documents dans un document parent lorsque la relation est un-à-plusieurs ou lorsque les données sont fréquemment consulté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 order_items comme un tableau dans le document order.
• Referencing : Utilisez-le lorsque l'embedding conduirait à des documents excessivement volumineux, ou lorsque les données sont consultées indépendamment. Stockez l'_id d'un document connexe, similaire aux clés étrangères, et effectuez des jointures au niveau de l'application ou utilisez $lookup de MongoDB.
  • Exemple : Une collection users et une collection posts. Un post peut stocker le 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 post.

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 :

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

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

-- Table OrderItems
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 documents 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 :

  {
    "_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 }
        ]
      }
    ]
  }
  

• Option B : Collections séparées avec referencing, si les commandes sont nombreuses ou souvent interrogées indépendamment.

  Collection Customers :

  {
    "_id": ObjectId("..."),
    "customer_id": 1,
    "first_name": "John",
    "last_name": "Doe",
    "email": "[email protected]"
  }
  

  Collection Orders :

  {
    "_id": ObjectId("..."),
    "order_id": 101,
    "customer_id": 1,
    "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 sur 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 décomposer dans une collection séparée.

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 comme CSV ou JSON.

• Utilisation de 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 de 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 là que vous allez implémenter votre schéma conçu. Vous devrez écrire du code ou utiliser un outil pour :

• Regrouper les enregistrements connexes : Par exemple, rassembler 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).

Exemple avec Python :

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

import pandas as pd
import json
from bson import ObjectId

# Charger les données à partir des fichiers CSV (en supposant qu'ils sont dans le même répertoire)
customers_df = pd.read_csv('customers.csv')
orders_df = pd.read_csv('orders.csv')
order_items_df = pd.read_csv('order_items.csv')

# --- Logique de transformation des données ---

# Convertir les DataFrames en dictionnaires pour une manipulation plus facile
customers_list = customers_df.to_dict('records')
orders_list = orders_df.to_dict('records')
order_items_list = order_items_df.to_dict('records')

# Créer un mapping pour les commandes et les articles de commande pour une recherche rapide
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)

# --- Construction des documents MongoDB (Option A : Client avec commandes intégrées) ---
mongo_documents = []

for customer in customers_list:
    mongo_doc = {
        "_id": ObjectId(), # MongoDB génère _id automatiquement, mais vous pouvez mapper si nécessaire
        "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'], # Assurez-vous du format de date correct
                "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)

# Maintenant 'mongo_documents' est une liste de dictionnaires prête à être insérée dans MongoDB
# print(json.dumps(mongo_documents[0], indent=2, default=str)) # Imprimer le premier document en JSON

# Pour l'Option B (Collections séparées), vous créeriez des listes pour chaque 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]

# Sauvegarder en JSON pour l'import (optionnel)
# 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 SQL vers MongoDB.
• Plateformes de migration de bases de données : Certains outils ETL et CDC commerciaux peuvent synchroniser des sources relationnelles vers MongoDB. Vérifiez la prise en charge des connecteurs pour votre base de données SQL exacte et votre cible MongoDB avant de planifier autour d'un outil.

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 mongoimport : Si vous avez exporté vos données transformées dans un fichier JSON, vous pouvez utiliser mongoimport :

  # En supposant que vos données sont dans mongo_customer_data.json et que vous voulez les importer dans la collection 'customers'
  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 avec pymongo :

  from pymongo import MongoClient
  
  # En supposant que la liste 'mongo_documents' est définie à partir du script Python précédent
  client = MongoClient('mongodb://localhost:27017/')
  db = client['your_database_name']
  customers_collection = db['customers']
  
  # Insérer les documents transformés
  if mongo_documents:
      insert_result = customers_collection.insert_many(mongo_documents)
      print(f"{len(insert_result.inserted_ids)} documents insérés.")
  else:
      print("Aucun document à insérer.")
  
  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.

// Exemple : Compter les documents dans la collection 'customers'
use your_database_name;
print(db.customers.countDocuments());

// Exemple : Trouver un client spécifique et vérifier ses commandes intégrées
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 : Modifiez les chaînes de connexion et les bibliothèques.
• Réécrire les requêtes : Remplacez les requêtes SQL par le langage de requête MongoDB en utilisant l'API de votre pilote choisi.
• Ajuster la couche d'accès aux données : Modifiez votre ORM ou votre couche d'accès aux données pour travailler avec les documents MongoDB.
• Tirer parti des fonctionnalités de MongoDB : Adaptez votre application pour profiter de fonctionnalités telles que les schémas flexibles, le framework d'agrégation et les requêtes géospatiales si applicable.

Meilleures pratiques et conseils

• Commencez 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érez sur la conception du schéma : Votre schéma MongoDB initial n'est peut-être pas parfait. Soyez prêt à itérer et à l'affiner en fonction des tests de performance et des retours de l'application.
• Indexez judicieusement : Tout comme dans SQL, l'indexation est cruciale pour les performances dans MongoDB. Identifiez vos modèles de requêtes et créez des index appropriés.
• Surveillez les performances : Surveillez en continu votre déploiement MongoDB pour détecter les goulots d'étranglement de performance et optimisez les requêtes et le schéma si nécessaire.
• Envisagez une migration incrémentielle : Pour les grandes bases de données, envisagez une stratégie de migration incrémentielle où vous synchronisez les modifications de SQL vers MongoDB en quasi-temps réel avant d'effectuer un basculement final.

À retenir

La migration la plus sûre de SQL vers MongoDB commence par les modèles d'accès, pas par les noms de tables. Modélisez un flux de travail important, transformez une petite tranche de données, chargez-la dans MongoDB, vérifiez les comptages et les documents échantillons, puis mettez à jour le code de l'application autour de cette forme avant de passer à l'échelle de la migration.