Data Mesh Architecture

Data Mesh Architecture

Data Mesh Architecture 는 데이터 플랫폼의 중앙 집중적 한계를 극복하기 위해 등장한 분산형 데이터 관리 아키텍처다. 각 도메인 (업무 영역) 이 데이터의 소유권과 책임을 갖고, 데이터 제품 (Data Product) 으로서 데이터를 제공한다. 데이터 거버넌스, 품질, 보안을 자동화된 플랫폼 기능으로 지원하며, 확장성과 민첩성, 조직 내 데이터 활용도를 극대화한다. 대규모 엔터프라이즈 데이터 환경에서 점점 더 중요한 역할을 하고 있다.

배경

Data Mesh 아키텍처가 등장한 배경은 전통적인 중앙집중형 데이터 아키텍처의 한계에서 비롯된다:

전통적 아키텍처의 문제점:

1. 데이터 팀 병목현상: 모든 데이터 요청이 중앙 데이터팀을 거쳐야 하는 구조
2. 도메인 지식 부족: 중앙 데이터팀이 각 도메인의 비즈니스 맥락을 완전히 이해하기 어려움
3. 확장성 제약: 조직 성장과 함께 중앙집중형 구조의 한계 노출
4. 민첩성 저하: 데이터 기반 의사결정의 속도 저하

디지털 전환의 요구사항:

• 실시간 데이터 처리 필요성 증가
• AI/ML 워크로드를 위한 대용량 데이터 접근성
• 비즈니스 도메인별 특화된 데이터 요구사항

목적 및 필요성

주요 목적:

1. 데이터 민주화: 모든 도메인이 필요한 데이터에 자유롭게 접근
2. 확장성 확보: 조직 성장에 따른 데이터 아키텍처의 선형적 확장
3. 혁신 가속화: 도메인별 데이터 실험과 혁신 촉진
4. 운영 효율성: 중앙집중형 병목현상 제거

비즈니스 필요성:

• 시장 대응력 향상: 빠른 데이터 기반 의사결정
• 고객 경험 개선: 실시간 개인화 서비스 제공
• 비용 최적화: 중복 인프라 제거 및 효율적 자원 활용

핵심 개념

Data Mesh Architecture 는 데이터 소유권과 책임을 중앙 데이터팀이 아닌 각 도메인 팀에 분산시켜, 도메인별로 데이터 제품을 생산·관리·공유하는 분산 데이터 관리 아키텍처이다.

기본 개념

1. 도메인 중심 데이터 소유권 (Domain-Oriented Data Ownership)
   각 비즈니스 도메인이 해당 도메인과 관련된 데이터의 수집, 변환, 제공에 대한 완전한 책임을 갖는 개념이다. 이는 Conway’s Law 와 Eric Evans 의 Domain-Driven Design (DDD) 원칙을 데이터 영역에 적용한 것이다.

2. 데이터 제품화 (Data as a Product)
   데이터를 단순한 부산물이 아닌 독립적인 제품으로 취급하여, 명확한 고객 (다른 도메인) 을 위한 품질, 유용성, 접근성을 보장하는 철학이다.

3. 셀프서비스 데이터 인프라 (Self-serve Data Infrastructure as a Platform)
   도메인팀이 자율적으로 데이터 제품을 구축, 배포, 운영할 수 있도록 지원하는 플랫폼 기반 인프라를 의미한다.

4. 연합 거버넌스 (Federated Computational Governance)
   중앙집중적 통제가 아닌 표준화와 상호운용성을 통한 분산된 거버넌스 모델이다.

실무 구현을 위한 연관성

• 마이크로서비스 아키텍처와의 연관성: 서비스 경계와 데이터 경계의 일치
• DevOps 문화와의 연관성: 도메인팀의 자율성과 책임감 강화
• API 설계와의 연관성: 데이터 제품의 인터페이스 표준화
• 클라우드 네이티브와의 연관성: 확장 가능한 인프라 플랫폼 활용

주요 기능 및 역할

• 도메인별 데이터 제품 개발·운영
• 데이터 거버넌스 자동화 및 표준화
• 데이터 품질, 보안, 접근 권한 관리

특징

• 도메인 중심 데이터 소유권 및 책임
• 데이터 제품 (Product) 단위의 관리
• 자율적 데이터 플랫폼 제공

주요 원리

Data Mesh 는 네 가지 핵심 원리를 중심으로 설계된다. 이는 모든 구성요소와 프로세스의 기반이며, 시스템이 분산성과 자율성을 유지하면서도 신뢰성과 일관성을 확보할 수 있게 한다.

각 도메인에서 데이터 제품을 생산·관리하며, 자율적 데이터 플랫폼을 통해 공유 및 소비한다. 거버넌스는 플랫폼을 통해 자동화·표준화된다.

graph TB
    subgraph "Data Mesh Core Principles"
        A[Domain-Oriented<br/>Decentralized Data Ownership]
        B[Data as a Product]
        C[Self-serve Data<br/>Infrastructure Platform]
        D[Federated Computational<br/>Governance]
    end
    
    subgraph "Domain A"
        A1[Domain Team A]
        A2[Data Product A]
        A3[Local Infrastructure]
    end
    
    subgraph "Domain B"
        B1[Domain Team B]
        B2[Data Product B]
        B3[Local Infrastructure]
    end
    
    subgraph "Shared Infrastructure"
        SI[Self-serve Platform]
        SG[Global Governance]
        SC[Common Standards]
    end
    
    A --> A1
    B --> A2
    C --> SI
    D --> SG
    
    A1 --> A2
    B1 --> B2
    A2 <--> B2
    A3 --> SI
    B3 --> SI
    SC --> A2
    SC --> B2

작동 원리 및 방식

sequenceDiagram
    participant DomainTeam as Domain Team
    participant Platform as Self-Serve Platform
    participant Governance as Governance Engine
    participant Catalog as Metadata Catalog
    participant Consumer as Data Consumer

    DomainTeam->>Platform: 데이터 파이프라인 구성 (ETL, 모델링)
    DomainTeam->>Governance: 정책 확인 및 자동 적용 (ex. 스키마 검증)
    DomainTeam->>Catalog: 메타데이터 등록 (스키마, SLA 등)
    Consumer->>Catalog: 데이터 제품 검색 및 문서 확인
    Consumer->>DomainTeam: 데이터 요청 / API 호출
    Platform-->>DomainTeam: 파이프라인 실행 지원 및 모니터링
    Governance-->>Platform: 정책 배포 및 규칙 모니터링

1. 도메인 팀이 자사 서비스에 맞는 Data Product를 설계한다.
2. Data Product는 메타데이터와 함께 Data Catalog에 등록된다.
3. Self-Serve Platform을 활용해 ETL/ELT, 보안, 모니터링, 배포를 처리한다.
4. 중앙 Governance는 정책을 코드 기반으로 배포하고 위반 여부를 모니터링한다.
5. 데이터 소비자는 API 또는 Query Interface를 통해 제품을 검색, 평가, 요청하여 사용한다.

구조 및 아키텍처

Data Mesh 아키텍처는 3 가지 주요 플레인 (Plane) 으로 구성된다:

graph TB
    subgraph "Data Mesh Experience Plane"
        DC[Data Catalog]
        DD[Data Discovery]
        AC[Access Control]
        DQ[Data Quality]
    end
    
    subgraph "Domain A"
        DA_T[Domain Team A]
        DA_P[Data Product A]
        DA_API[Data API A]
    end
    
    subgraph "Domain B"
        DB_T[Domain Team B]
        DB_P[Data Product B]
        DB_API[Data API B]
    end
    
    subgraph "Data Product Developer Plane"
        DP[Data Pipeline Tools]
        VCS[Version Control]
        TEST[Testing Framework]
        CICD[CI/CD Pipeline]
    end
    
    subgraph "Data Infrastructure Plane"
        COMPUTE[Compute Engines]
        STORAGE[Storage Systems]
        STREAM[Streaming Platform]
        CONTAINER[Container Platform]
    end
    
    subgraph "Federated Governance"
        POLICIES[Global Policies]
        STANDARDS[Data Standards]
        SECURITY[Security Policies]
    end
    
    DA_T --> DA_P
    DB_T --> DB_P
    DA_P --> DA_API
    DB_P --> DB_API
    
    DA_P --> DP
    DB_P --> DP
    DP --> COMPUTE
    DP --> STORAGE
    DP --> STREAM
    
    DA_API --> DC
    DB_API --> DC
    DC --> DD
    DD --> AC
    
    POLICIES --> DA_P
    POLICIES --> DB_P
    STANDARDS --> DA_API
    STANDARDS --> DB_API
    
    DA_API <--> DB_API

구성 요소

Data Infrastructure Plane

도메인에 독립적인 공통 인프라로서 모든 데이터 처리의 기반을 구성함

🔍 핵심 기여: 고가용성, 대규모 분산 처리, 실시간/비동기 시스템을 위한 기초 체계 제공

Data Product Developer Plane

데이터 제품의 생성부터 배포까지 개발 주기를 전담하고 자동화함

🔍 핵심 기여: 데이터 제품 개발의 일관성, 자동화, 품질 확보. 도메인 팀의 자율성과 독립성 강화

Data Mesh Experience Plane

데이터 소비자의 경험 최적화를 통해 신뢰할 수 있는 접근성과 거버넌스를 제공함

🔍 핵심 기여: 소비자의 신뢰·발견·이해·접근성 중심으로 데이터 접근 비용을 최소화하고 거버넌스와 품질 관리까지 자동화

구현 기법

Data Mesh 는 단일한 기술이 아닌, 설계 철학과 운영 모델의 결합이다. 따라서 다양한 기술 스택과 방법론이 함께 쓰이며, 핵심 구성요소별로 구현 기법을 나눠 설명합니다.

장점

단점과 문제점 그리고 해결방안

단점

문제점

도전 과제

기술적 도전 과제

조직적 도전 과제

운영 및 거버넌스 도전 과제

분류 기준에 따른 종류 및 유형

Data Mesh 자체는 아키텍처 스타일이기 때문에 분류는 보통 도입 형태, 기술 구성, 조직 방식 등에 따라 나뉜다.

유형

기술 구성

조직 구조/운영 전략

거버넌스 방식

데이터 제품 유형

Data Mesh vs. Data Lakehouse

상세 비교

실무 사용 예시

활용 사례

사례 1: Netflix 의 Data Mesh 구현

Netflix 는 Data Mesh 아키텍처를 도입하여 콘텐츠 추천과 플랫폼 운영을 혁신했다.

시스템 구성:

graph TB
    subgraph "Netflix Data Mesh Architecture"
        subgraph "Content Domain"
            CD[Content Team]
            CM[Content Metadata]
            CR[Content Recommendations]
        end
        
        subgraph "User Domain"
            UD[User Team]
            UP[User Profiles]
            UB[User Behavior]
        end
        
        subgraph "Platform Domain"
            PD[Platform Team]
            PM[Platform Metrics]
            PP[Platform Performance]
        end
        
        subgraph "Shared Infrastructure"
            K[Apache Kafka]
            I[Apache Iceberg]
            S[Spark/Flink]
            MW[Microservices]
        end
        
        subgraph "Self-serve Platform"
            DP[Data Pipeline Tools]
            DC[Data Catalog]
            MF[ML Feature Store]
        end
    end
    
    CD --> CM
    CD --> CR
    UD --> UP
    UD --> UB
    PD --> PM
    PD --> PP
    
    CM --> K
    UP --> K
    PM --> K
    
    K --> I
    K --> S
    
    CR --> MF
    UB --> MF
    PP --> MF
    
    DP --> S
    DC --> I

Workflow:

1. 데이터 수집: 각 도메인이 자체 데이터를 실시간 수집
2. 데이터 제품화: 도메인별 특화된 데이터 제품 생성
3. 크로스 도메인 분석: 추천 알고리즘을 위한 다중 도메인 데이터 활용
4. 실시간 서비스: 개인화된 콘텐츠 추천 제공

Data Mesh 역할:

• 콘텐츠 도메인: 메타데이터 관리 및 콘텐츠 분석
• 사용자 도메인: 시청 패턴 분석 및 프로파일링
• 플랫폼 도메인: 성능 모니터링 및 최적화

사례 2: 글로벌 이커머스 기업의 Data Mesh 도입 사례

시스템 구성:

• 도메인별 (상품, 주문, 고객 등) 데이터팀 → 데이터 제품 (API, 데이터셋) → 자율적 데이터 플랫폼 (저장, 처리, 배포) → 데이터 카탈로그 및 거버넌스

Workflow:

1. 각 도메인팀이 자체적으로 데이터 제품 설계·운영
2. 자율적 데이터 플랫폼에서 데이터 저장, 처리, 배포 자동화
3. 데이터 카탈로그를 통해 조직 내 다른 팀이 데이터 탐색·소비
4. 연합형 거버넌스로 품질, 보안, 규제 준수 자동화

Data Mesh Architecture 의 역할:
도메인별 데이터 소유권 강화, 데이터 제품화, 운영 자동화, 데이터 활용 극대화

Data Mesh Architecture 유무에 따른 차이:

• 도입 전:
  중앙 데이터팀 병목, 데이터 활용 속도 저하, 품질/보안 문제
• 도입 후:
  도메인별 신속한 데이터 제품 개발, 데이터 품질·보안·규제 준수 강화, 데이터 소비·공유 활성화

사례 3: 전자상거래 주문 분석

데이터 메쉬를 도입하여 주문 도메인이 독립적으로 주문 데이터를 처리하고, 분석팀과 공유하는 구조를 구현.

구성 및 역할:

• 도메인 A 팀: 주문 로그 ETL → dbt 모델링 → Data Product A
• Self-Serve 플랫폼: Airflow, Terraform, dbt, DataHub, OPA 기반
• Governance 팀: 데이터 계약 검증, SLA 설정, 보안 정책 관리
• 분석팀: Catalog 에서 Data Product 검색, SQL API 사용

시스템 구성:

flowchart LR
  subgraph OrderDomain
    LogDB[(Orders DB)]
    ETL[Airflow]
    dbtModel[dbt Models]
    ProdA[(Data Product A)]
  end

  subgraph Platform
    Terraform
    DataHub
    OPA
    Catalog[(Metadata Catalog)]
  end

  subgraph Analyst
    Consumer[분석팀 Consumer]
  end

  LogDB --> ETL --> dbtModel --> ProdA
  ProdA --> Catalog
  ETL -.-> OPA
  Terraform --> Platform
  Consumer --> Catalog --> ProdA

구현 예시

Python

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228

# Data Product 클래스 - 데이터를 제품으로 취급하는 핵심 개념
class DataProduct:
    """
    Data Mesh의 핵심 구성요소인 Data Product를 구현
    각 도메인이 소유하고 관리하는 데이터 자산을 나타냄
    """
    def __init__(self, domain, name, version, owner):
        self.domain = domain              # 도메인 식별자
        self.name = name                  # 데이터 제품명
        self.version = version            # 버전 관리
        self.owner = owner                # 데이터 소유자 (도메인 팀)
        self.schema = None                # 데이터 스키마
        self.sla = {}                     # Service Level Agreement
        self.metadata = {}                # 메타데이터
        self.consumers = []               # 데이터 소비자 목록
        
    def register_schema(self, schema):
        """데이터 스키마 등록 - 데이터 계약 정의"""
        self.schema = schema
        print(f"Schema registered for {self.domain}.{self.name}")
        
    def set_sla(self, availability, latency, quality_threshold):
        """SLA 설정 - 데이터 제품의 품질 보장"""
        self.sla = {
            'availability': availability,    # 가용성 (예: 99.9%)
            'latency': latency,             # 지연시간 (예: <100ms)
            'quality': quality_threshold     # 품질 임계값 (예: >95%)
        }
        print(f"SLA set for {self.name}: {self.sla}")
        
    def add_consumer(self, consumer_domain):
        """데이터 소비자 등록 - 의존성 관리"""
        if consumer_domain not in self.consumers:
            self.consumers.append(consumer_domain)
            print(f"Consumer {consumer_domain} added to {self.name}")

# Domain 클래스 - 도메인 중심 데이터 소유권 구현
class DataDomain:
    """
    비즈니스 도메인을 나타내는 클래스
    해당 도메인의 모든 데이터 자산과 책임을 관리
    """
    def __init__(self, name, team_lead):
        self.name = name                  # 도메인명
        self.team_lead = team_lead        # 팀 리더
        self.data_products = []           # 도메인이 소유한 데이터 제품들
        self.governance_policies = []      # 적용되는 거버넌스 정책
        
    def create_data_product(self, product_name, version="1.0"):
        """새로운 데이터 제품 생성"""
        product = DataProduct(
            domain=self.name,
            name=product_name,
            version=version,
            owner=self.team_lead
        )
        self.data_products.append(product)
        print(f"Data product '{product_name}' created in domain '{self.name}'")
        return product
        
    def apply_governance_policy(self, policy):
        """연합 거버넌스 정책 적용"""
        self.governance_policies.append(policy)
        print(f"Policy '{policy}' applied to domain '{self.name}'")

# Self-serve Platform 클래스 - 셀프서비스 인프라 구현
class SelfServeDataPlatform:
    """
    도메인팀이 자율적으로 활용할 수 있는 데이터 플랫폼
    인프라, 도구, 서비스를 제공
    """
    def __init__(self):
        self.domains = {}                 # 등록된 도메인들
        self.data_catalog = {}            # 데이터 카탈로그
        self.governance_engine = GovernanceEngine()  # 거버넌스 엔진
        
    def register_domain(self, domain):
        """도메인 등록"""
        self.domains[domain.name] = domain
        print(f"Domain '{domain.name}' registered to platform")
        
    def publish_data_product(self, domain_name, product_name):
        """데이터 제품을 플랫폼에 게시하여 다른 도메인이 발견할 수 있도록 함"""
        domain = self.domains.get(domain_name)
        if domain:
            product = next((p for p in domain.data_products if p.name == product_name), None)
            if product:
                self.data_catalog[f"{domain_name}.{product_name}"] = product
                print(f"Data product '{product_name}' published to catalog")
                return True
        return False
        
    def discover_data_products(self, search_term):
        """데이터 제품 검색 - 데이터 디스커버리 기능"""
        results = []
        for key, product in self.data_catalog.items():
            if search_term.lower() in key.lower() or search_term.lower() in str(product.metadata).lower():
                results.append(product)
        print(f"Found {len(results)} data products for '{search_term}'")
        return results

# Federated Governance Engine 클래스 - 연합 거버넌스 구현
class GovernanceEngine:
    """
    연합 거버넌스를 구현하는 엔진
    전사적 정책과 표준을 관리하면서 도메인 자율성 보장
    """
    def __init__(self):
        self.global_policies = []         # 전사 정책
        self.standards = {}               # 표준 정의
        self.compliance_checks = []       # 컴플라이언스 체크 규칙
        
    def add_global_policy(self, policy_name, policy_rules):
        """전사 정책 추가"""
        policy = {
            'name': policy_name,
            'rules': policy_rules,
            'created_at': '2025-01-01'
        }
        self.global_policies.append(policy)
        print(f"Global policy '{policy_name}' added")
        
    def validate_data_product(self, data_product):
        """데이터 제품의 정책 준수 여부 검증"""
        violations = []
        
        # 스키마 검증
        if not data_product.schema:
            violations.append("Schema not defined")
            
        # SLA 검증
        if not data_product.sla:
            violations.append("SLA not defined")
            
        # 메타데이터 검증
        required_metadata = ['description', 'data_classification', 'update_frequency']
        for field in required_metadata:
            if field not in data_product.metadata:
                violations.append(f"Missing metadata: {field}")
                
        if violations:
            print(f"Compliance violations found: {violations}")
            return False
        else:
            print(f"Data product '{data_product.name}' is compliant")
            return True

# 실제 사용 시나리오 예시
def data_mesh_implementation_example():
    """
    Data Mesh 구현 시나리오
    전자상거래 회사의 고객, 주문, 상품 도메인을 예시로 구현
    """
    print("=== Data Mesh Implementation Example ===\n")
    
    # 1. 셀프서비스 플랫폼 초기화
    platform = SelfServeDataPlatform()
    
    # 2. 도메인 생성 및 등록
    customer_domain = DataDomain("customer", "Alice Johnson")
    order_domain = DataDomain("order", "Bob Smith")
    product_domain = DataDomain("product", "Carol Williams")
    
    platform.register_domain(customer_domain)
    platform.register_domain(order_domain)
    platform.register_domain(product_domain)
    
    # 3. 데이터 제품 생성
    customer_profile = customer_domain.create_data_product("customer_360_view")
    order_analytics = order_domain.create_data_product("order_analytics")
    product_catalog = product_domain.create_data_product("product_catalog")
    
    # 4. 데이터 제품 메타데이터 및 SLA 설정
    customer_profile.metadata = {
        'description': 'Comprehensive customer profile with demographics and behavior',
        'data_classification': 'PII',
        'update_frequency': 'real-time'
    }
    customer_profile.set_sla(availability=99.9, latency=100, quality_threshold=95)
    
    order_analytics.metadata = {
        'description': 'Order patterns and analytics for business intelligence',
        'data_classification': 'internal',
        'update_frequency': 'hourly'
    }
    order_analytics.set_sla(availability=99.5, latency=500, quality_threshold=90)
    
    # 5. 스키마 등록 (데이터 계약)
    customer_schema = {
        'customer_id': 'string',
        'demographics': 'object',
        'behavior_scores': 'object',
        'last_updated': 'timestamp'
    }
    customer_profile.register_schema(customer_schema)
    
    # 6. 거버넌스 정책 적용
    platform.governance_engine.add_global_policy(
        "Data Privacy", 
        ["PII data must be encrypted", "Data access must be logged"]
    )
    
    customer_domain.apply_governance_policy("Data Privacy")
    order_domain.apply_governance_policy("Data Privacy")
    
    # 7. 데이터 제품 퍼블리싱
    platform.publish_data_product("customer", "customer_360_view")
    platform.publish_data_product("order", "order_analytics")
    platform.publish_data_product("product", "product_catalog")
    
    # 8. 컴플라이언스 검증
    platform.governance_engine.validate_data_product(customer_profile)
    platform.governance_engine.validate_data_product(order_analytics)
    
    # 9. 크로스 도메인 데이터 소비
    customer_profile.add_consumer("order")  # 주문 도메인이 고객 데이터 사용
    order_analytics.add_consumer("product")  # 상품 도메인이 주문 분석 데이터 사용
    
    # 10. 데이터 디스커버리
    search_results = platform.discover_data_products("customer")
    for result in search_results:
        print(f"Found: {result.domain}.{result.name}")
    
    print("\n=== Data Mesh implementation completed successfully ===")

# 예시 실행
if __name__ == "__main__":
    data_mesh_implementation_example()

이 구현 예시는 Data Mesh 의 핵심 개념들을 실제 코드로 구현하여 다음을 보여준다:

1. 도메인 중심 데이터 소유권: 각 도메인이 자체 데이터 제품을 소유하고 관리
2. 데이터 제품화: 명확한 SLA, 스키마, 메타데이터를 가진 데이터 자산
3. 셀프서비스 인프라: 도메인팀이 자율적으로 활용할 수 있는 플랫폼
4. 연합 거버넌스: 전사 정책과 도메인 자율성의 균형

Python + Dbt + OPA

아래 코드는 주문 데이터 제품 생성 시나리오.

• dbt 로 스키마 작성
• Airflow DAG 내에 dbt 실행
• OPA 정책 검사
• catalog_api.py 로 MetadataHub 에 등록

1. Dbt 모델 (models/orders_product.sql)

   1 2 3 4 5 6 7 8 9 10 11 12 13 14

   -- 주문 데이터를 분석용으로 가공 with raw_orders as ( select * from {{ source('orders_db','orders') }} ), enriched as ( select order_id, user_id, total_amount, order_date, case when total_amount > 1000 then 'high' else 'normal' end as order_value_segment from raw_orders ) select * from enriched;

2. Airflow DAG (dags/orders_product.py)

   1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25

   from airflow import DAG from airflow.operators.bash import BashOperator from airflow.operators.python import PythonOperator from datetime import datetime def publish_metadata(): from catalog_api import register_data_product register_data_product( name="orders_product", schema="enriched schema...", sla_hours=24 ) with DAG("orders_data_product", start_date=datetime(2025,7,1), schedule_interval='@daily') as dag: run_dbt = BashOperator( task_id='run_dbt', bash_command='cd /opt/dbt && dbt run --models orders_product' ) check_opa = BashOperator( task_id='check_opa', bash_command='opa eval --data policies/ --input prod_manifest.json "data.contracts.allow"' ) publish = PythonOperator(task_id='publish_metadata', python_callable=publish_metadata) run_dbt >> check_opa >> publish

3. Metadata 등록 (catalog_api.py)

   1 2 3 4 5 6 7 8 9 10 11 12

   import requests def register_data_product(name, schema, sla_hours): api_url = "https://datahub.internal/api/register" payload = { "name": name, "schema": schema, "sla": sla_hours, "owner": "order-domain-team" } resp = requests.post(api_url, json=payload) resp.raise_for_status()

역할 및 기능 주석

• dbt 모델: 스키마와 파이프라인 정의, 테스트 지원
• Airflow DAG: 파이프라인 흐름, 정책 검사, 메타데이터 등록 포함
• OPA 검사: 정책 위반 여부 자동 탐지
• MetadataHub 등록: 소비자 조회 및 거버넌스 감시 대상 등록

실무에서 효과적으로 적용하기 위한 고려사항 및 주의할 점

최적화하기 위한 고려사항 및 주의할 점

주제와 관련하여 주목할 내용

반드시 학습해야할 내용

용어 정리

참고 및 출처

• Data Mesh Principles and Logical Architecture - Martin Fowler
• What is Data Mesh Architecture? Principles & Components - Atlan
• Data Mesh Architecture from an Engineering Perspective - INNOQ
• Mastering Data Mesh Architecture: Key Implementation Components - Acceldata
• What Is A Data Mesh — And How Not To Mesh It Up - Monte Carlo
• What is a Data Mesh? - AWS
• The Heart of the Data Mesh Beats Real-Time with Apache Kafka - Kai Waehner
• Apache Iceberg 공식 문서
• Netflix Data Mesh Case Study - Nash Tech
• Data Mesh Overview: Architecture & Case Studies for 2025 - Atlan