DevOps 지식 허브
DevOps 지식 허브

MongoDB로 SQL 관계형 데이터를 마이그레이션하는 단계별 가이드

포괄적인 단계별 가이드를 통해 SQL 관계형 데이터를 MongoDB로 마이그레이션하는 방법을 알아보세요. 기존 스키마를 효율적인 MongoDB 문서 구조로 변환하는 모범 사례를 살펴보고, 여기에는 필수 계획, 임베딩 및 참조와 같은 스키마 설계 전략, 데이터 추출, 변환 기술 및 MongoDB로의 로딩이 포함됩니다. 이 튜토리얼은 NoSQL 데이터베이스로의 원활하고 성공적인 전환을 위한 실질적인 예제와 실행 가능한 조언을 제공합니다.

37 조회수

SQL 관계형 데이터를 MongoDB로 마이그레이션하는 단계별 가이드

SQL과 같은 관계형 데이터베이스에서 MongoDB와 같은 NoSQL 문서 데이터베이스로 마이그레이션하는 것은 일반적이지만 종종 복잡한 작업입니다. 관계형 데이터베이스는 구조화된 테이블, 외래 키 및 ACID 트랜잭션을 통해 데이터 무결성을 적용하는 데 탁월합니다. 반면 MongoDB는 문서 지향 데이터 모델을 사용하여 특정 워크로드에 대한 유연성, 확장성 및 성능 이점을 제공합니다. 이 가이드는 필수적인 스키마 디자인 고려 사항과 원활한 전환을 위한 도구를 다루면서 기존 관계형 스키마를 효율적인 MongoDB 문서 구조로 변환하는 실용적인 단계별 접근 방식을 제공합니다.

이러한 데이터베이스 패러다임 간의 근본적인 차이점을 이해하는 것은 성공적인 마이그레이션을 위해 매우 중요합니다. 관계형 스키마는 일반적으로 정규화되어 중복을 줄이기 위해 데이터를 여러 테이블로 나눕니다. 그러나 MongoDB의 문서 모델은 읽기 성능을 향상하고 애플리케이션 로직을 단순화하기 위해 관련 데이터를 단일 문서 내에 포함하는 비정규화를 장려합니다. 이러한 변화에는 애플리케이션의 액세스 패턴에 맞는 문서를 설계하기 위한 신중한 계획이 필요합니다.

핵심 차이점 이해하기: 관계형 모델 대 문서 모델

마이그레이션 프로세스에 뛰어들기 전에 개념적 차이점을 파악하는 것이 필수적입니다.

  • 관계형 모델: 데이터는 미리 정의된 스키마가 있는 테이블에 저장됩니다. 관계는 외래 키를 통해 관리되며, 관련 데이터를 검색하려면 JOIN 작업이 필요합니다. 정규화는 핵심 원칙입니다.
  • 문서 모델 (MongoDB): 데이터는 유연한 JSON과 유사한 문서에 저장됩니다. 문서는 다양한 구조를 가질 수 있습니다. 관련 데이터는 단일 문서 내에 포함되거나(비정규화) 애플리케이션 수준 조인 또는 MongoDB의 $lookup 집계 단계를 사용하여 참조될 수 있습니다.

이 데이터 모델링의 차이는 MongoDB 컬렉션과 문서를 설계하는 방식에 직접적인 영향을 미칩니다.

1단계: 계획 및 스키마 디자인

이것이 가장 중요한 단계입니다. 잘 설계된 MongoDB 스키마는 MongoDB의 이점을 활용하는 열쇠입니다. 목표는 SQL 테이블을 직접 변환하는 것뿐만 아니라 애플리케이션 액세스 패턴을 기반으로 데이터를 모델링하는 것입니다.

1. 애플리케이션 액세스 패턴 분석

  • 읽기 집약적 대 쓰기 집약적 작업 식별: 데이터가 얼마나 자주 읽히며, 일반적으로 어떻게 쿼리됩니까? 어떤 필드가 가장 자주 함께 검색됩니까?
  • 일반적인 쿼리 경로 결정: SQL 애플리케이션에서 가장 빈번한 SELECT 문은 무엇입니까? 일반적으로 어떤 테이블이 조인됩니까?
  • 데이터 관계 이해: 엔터티는 어떻게 관련되어 있습니까? 일대일, 일대다 또는 다대다 관계입니까?

2. 비정규화 전략 선택

MongoDB의 강력함은 관련 데이터를 포함할 수 있는 능력에 있습니다. 다음 전략을 고려하십시오.

  • 포함 (비정규화): 가장 일반적인 접근 방식입니다. 관계가 일대다이거나 데이터가 자주 함께 액세스되는 경우 문서 또는 문서 배열을 부모 문서 내에 포함합니다. 이는 조인의 필요성을 줄여줍니다.
    • 예시: 별도의 orders와 order_items 테이블을 갖는 대신, order 문서 내에 order_items를 배열로 포함할 수 있습니다.
  • 참조: 포함할 경우 문서가 너무 커지거나 데이터가 독립적으로 액세스될 때 사용합니다. 외래 키와 유사하게 관련 문서의 _id를 저장하고 애플리케이션 수준 조인을 수행하거나 MongoDB의 $lookup을 사용합니다.
    • 예시: users 컬렉션과 posts 컬렉션. 게시물은 작성자의 user_id를 저장할 수 있습니다. 그런 다음 게시물을 가져올 때 $lookup을 사용하여 작성자 세부 정보를 검색할 수 있습니다.

3. MongoDB 컬렉션 및 문서 설계

액세스 패턴 및 비정규화 전략을 기반으로 컬렉션을 설계합니다. 시작점으로 SQL 테이블을 MongoDB 컬렉션에 매핑하는 것이 좋습니다. 그런 다음 어떤 관련 데이터를 포함할지, 어떤 데이터를 참조할지 결정합니다.

SQL 스키마 예시:

-- 고객 테이블
CREATE TABLE Customers (
    CustomerID INT PRIMARY KEY,
    FirstName VARCHAR(50),
    LastName VARCHAR(50),
    Email VARCHAR(100)
);

-- 주문 테이블
CREATE TABLE Orders (
    OrderID INT PRIMARY KEY,
    CustomerID INT,
    OrderDate DATE,
    TotalAmount DECIMAL(10, 2),
    FOREIGN KEY (CustomerID) REFERENCES Customers(CustomerID)
);

-- 주문 항목 테이블
CREATE TABLE OrderItems (
    OrderItemID INT PRIMARY KEY,
    OrderID INT,
    ProductID INT,
    Quantity INT,
    Price DECIMAL(10, 2),
    FOREIGN KEY (OrderID) REFERENCES Orders(OrderID)
);

MongoDB 문서 설계 옵션:

  • **옵션 A: 포함된 주문이 있는 고객 (고객 주문 수가 관리 가능하고 주문이 고객과 함께 자주 조회되는 경우):
    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 } // 무료 항목 예시 ] }, // ... 주문 더 보기 ] }
  • 옵션 B: 참조를 사용한 별도 컬렉션 (주문이 많거나 자주 독립적으로 쿼리되는 경우):
    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, // Customers 컬렉션에 대한 참조 "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 } ] }

문서 크기 고려 사항: MongoDB에는 문서 크기 제한(16MB)이 있습니다. 이 한도를 초과할 수 있는 지나치게 큰 배열 포함을 피하십시오. 배열이 무한정 커지면 별도의 컬렉션으로 분리하는 것을 고려하십시오.

2단계: 데이터 추출 및 변환

대상 스키마가 설계되면 SQL 데이터베이스에서 데이터를 추출하여 새 문서 형식으로 변환해야 합니다.

1. SQL에서 데이터 추출

필요한 데이터를 선택하기 위해 표준 SQL 쿼리를 사용합니다. 이 데이터를 CSV 또는 JSON과 같은 형식으로 내보낼 수 있습니다.

  • SQL 클라이언트 사용: 대부분의 SQL 데이터베이스 도구(예: DBeaver, SQL Developer, pgAdmin)는 쿼리 결과를 CSV 또는 JSON으로 내보낼 수 있도록 지원합니다.
  • 스크립팅: Python, Node.js 등과 같은 스크립트를 작성하여 SQL 데이터베이스에 연결하고, 쿼리를 실행하고, 데이터를 가져옵니다.

2. 데이터 변환

여기서 설계된 스키마를 구현하게 됩니다. 다음 작업을 수행하기 위해 코드나 도구를 작성해야 합니다.

  • 관련 레코드 그룹화: 예를 들어 특정 Order에 속하는 모든 OrderItems를 수집합니다.
  • 데이터 구조 재구성: 관계형 행을 중첩된 JSON 문서로 변환합니다.
  • 데이터 형식 처리: 데이터 형식이 MongoDB와 호환되는지 확인합니다(예: 날짜, 숫자, 문자열).

Python 예시:

Customers, Orders, OrderItems를 CSV 파일로 내보냈다고 가정해 보겠습니다.

import pandas as pd
import json
from bson import ObjectId # 직접 변환에는 엄격하게 필요하지 않지만 MongoDB ObjectId용

# CSV 파일에서 데이터 로드 (같은 디렉토리에 있다고 가정)
customers_df = pd.read_csv('customers.csv')
orders_df = pd.read_csv('orders.csv')
order_items_df = pd.read_csv('order_items.csv')

# --- 데이터 변환 로직 ---

# 쉬운 조작을 위해 DataFrame을 딕셔너리로 변환
customers_list = customers_df.to_dict('records')
orders_list = orders_df.to_dict('records')
order_items_list = order_items_df.to_dict('records')

# 빠른 조회를 위해 주문 및 주문 항목 매핑 생성
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 문서 구축 (옵션 A: 포함된 주문이 있는 고객) ---
mongo_documents = []

for customer in customers_list:
    mongo_doc = {
        "_id": ObjectId(), # MongoDB는 _id를 자동으로 생성하지만 필요한 경우 매핑할 수 있음
        "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'], # 올바른 날짜 형식 확인
                "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)

# 이제 'mongo_documents'는 MongoDB에 삽입할 준비가 된 딕셔너리 목록입니다
# print(json.dumps(mongo_documents[0], indent=2, default=str)) # 첫 번째 문서를 JSON으로 출력

# 옵션 B(별도 컬렉션)의 경우, 각 컬렉션에 대한 목록을 생성합니다:
# 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]

# 가져오기를 위해 JSON으로 저장 (선택 사항)
# with open('mongo_customer_data.json', 'w') as f:
#     json.dump(mongo_documents, f, indent=2, default=str)

3. 변환 도구

  • 사용자 지정 스크립트: Pandas를 사용하는 Python, CSV 파서 및 mysql/pg와 같은 라이브러리를 사용하는 Node.js는 복잡한 변환에 강력합니다.
  • ETL 도구: Apache NiFi, Talend 또는 AWS Glue와 같은 도구는 SQL에서 MongoDB로의 마이그레이션을 포함한 복잡한 데이터 파이프라인을 오케스트레이션할 수 있습니다.
  • MongoDB Atlas 라이브 마이그레이션: MongoDB Atlas로 마이그레이션하는 경우, 라이브 마이그레이션 서비스는 SQL 데이터베이스를 포함한 다양한 소스에서 데이터를 이동하는 데 도움을 줄 수 있습니다.

3단계: MongoDB로 데이터 로드

데이터가 변환되면 MongoDB 인스턴스로 로드할 수 있습니다.

1. MongoDB에 연결

MongoDB 셸(mongosh) 또는 MongoDB 드라이버(사용하는 프로그래밍 언어용)를 사용하여 데이터베이스에 연결합니다.

2. 변환된 데이터 가져오기

  • mongoimport와 mongosh 사용: 변환된 데이터를 JSON 파일(Python 예시에서와 같이)로 내보낸 경우 mongoimport를 사용할 수 있습니다.
    bash # 데이터가 mongo_customer_data.json에 있고 'customers' 컬렉션으로 가져오려는 경우 mongoimport --db your_database_name --collection customers --file mongo_customer_data.json --jsonArray

    • --jsonArray: JSON 파일에 문서 배열이 포함된 경우 이 플래그를 사용합니다.

  • MongoDB 드라이버 사용: 프로그래밍 언어에서 데이터 구조를 생성한 경우(Python 스크립트의 mongo_documents 목록과 같이) 직접 삽입할 수 있습니다.

    **Python 예시 (pymongo 사용):
    ```python
    from pymongo import MongoClient

    'mongo_documents' 목록은 이전 Python 스크립트에서 정의되었다고 가정

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

    변환된 문서 삽입

    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. 데이터 무결성 확인

로드 후 MongoDB에서 쿼리를 실행하여 데이터가 올바르게 가져와졌는지 예상과 일치하는지 확인합니다.

// 예시: 'customers' 컬렉션의 문서 개수 계산
use your_database_name;
print(db.customers.countDocuments());

// 예시: 특정 고객을 찾고 포함된 주문 확인
db.customers.findOne({ "customer_id": 1 })

4단계: 애플리케이션 리팩토링

아마도 가장 시간이 많이 걸리는 단계일 것입니다. 애플리케이션 코드를 SQL 대신 MongoDB와 상호 작용하도록 업데이트해야 합니다.

  • 데이터베이스 연결 업데이트: 연결 문자열 및 라이브러리를 변경합니다.
  • 쿼리 다시 작성: 선택한 드라이버의 API를 사용하여 SQL 쿼리를 MongoDB 쿼리 언어로 대체합니다.
  • 데이터 액세스 계층 조정: ORM 또는 데이터 액세스 계층을 수정하여 MongoDB 문서와 함께 작동하도록 합니다.
  • MongoDB 기능 활용: 유연한 스키마, 집계 프레임워크 및 지리 공간적 쿼리와 같은 기능을 활용하도록 애플리케이션을 조정합니다(해당하는 경우).

모범 사례 및 팁

  • 작게 시작: 가능하다면 먼저 데이터의 일부 또는 덜 중요한 애플리케이션을 마이그레이션하여 경험을 쌓으십시오.
  • 스키마 디자인 반복: 초기 MongoDB 스키마가 완벽하지 않을 수 있습니다. 성능 테스트 및 애플리케이션 피드백을 기반으로 반복하고 개선할 준비를 하십시오.
  • 현명하게 인덱싱: SQL과 마찬가지로 인덱싱은 MongoDB 성능에 중요합니다. 쿼리 패턴을 식별하고 적절한 인덱스를 생성하십시오.
  • 성능 모니터링: 성능 병목 현상을 확인하기 위해 MongoDB 배포을 지속적으로 모니터링하고 필요에 따라 쿼리 및 스키마를 최적화하십시오.
  • 점진적 마이그레이션 고려: 대규모 데이터베이스의 경우 최종 전환을 수행하기 전에 SQL에서 MongoDB로 변경 사항을 거의 실시간으로 동기화하는 점진적 마이그레이션 전략을 고려하십시오.

결론

SQL에서 MongoDB로의 마이그레이션은 유연성과 확장성 측면에서 상당한 이점을 얻을 수 있는 전략적 조치입니다. 이 프로세스에는 신중한 계획, 애플리케이션 액세스 패턴에 중점을 둔 사려 깊은 스키마 설계, 강력한 변환 및 로드 전략이 필요합니다. 이러한 단계와 모범 사례를 따르면 관계형 데이터를 효율적이고 강력한 MongoDB 문서 모델로 변환하는 복잡성을 탐색하여 보다 민첩하고 확장 가능한 애플리케이션 아키텍처를 위한 길을 열 수 있습니다.