EAI(Enterprise Application Integration) 완전 가이드: 기업 시스템 통합의 모든 것

EAI (통합 전략)
├── SOA (아키텍처 스타일)
│   └── Microservices (SOA 발전형)
├── API Management (API 관리 계층)
├── Message Broker (비동기 통합)
└── iPaaS (클라우드 통합 플랫폼)

시스템 A ←→ 시스템 B
시스템 A ←→ 시스템 C
시스템 B ←→ 시스템 C
시스템 A ←→ 시스템 D
시스템 B ←→ 시스템 D
시스템 C ←→ 시스템 D

         시스템 A
            |
시스템 D ── HUB ── 시스템 B
            |
         시스템 C

시스템 A ── 어댑터 ──┐
                     │
시스템 B ── 어댑터 ──┼── ESB (분산 메시지 버스) ──┼── 어댑터 ── 시스템 E
                     │                           │
시스템 C ── 어댑터 ──┘                           └── 어댑터 ── 시스템 F

[모바일/웹/파트너]
       │
  Experience API (채널별 맞춤)
       │
   Process API (비즈니스 로직 조합)
       │
   System API (백엔드 시스템 추상화)
       │
[SAP / Salesforce / DB / 레거시]

[클라이언트]
    │
API Gateway (동기 요청)
    │                    Event Mesh (비동기 이벤트)
    ├── REST API ───────── Kafka / EventBridge
    └── GraphQL             │
                     ┌──────┼──────┐
                  서비스A  서비스B  서비스C

// Apache Camel - 메시지 채널 정의
from("jms:queue:orders")       // 입력 채널
    .to("jms:queue:validated"); // 출력 채널

// Apache Camel - Content-Based Router
from("jms:queue:orders")
    .choice()
        .when(xpath("/order/country = 'KR'"))
            .to("jms:queue:orders-kr")
        .when(xpath("/order/country = 'US'"))
            .to("jms:queue:orders-us")
        .when(xpath("/order/country = 'JP'"))
            .to("jms:queue:orders-jp")
        .otherwise()
            .to("jms:queue:orders-other")
    .end();

// Apache Camel - Message Filter
from("jms:queue:orders")
    .filter(xpath("/order/amount > 100000"))
    .to("jms:queue:high-value-orders");

// Apache Camel - XML에서 JSON으로 변환
from("jms:queue:orders-xml")
    .unmarshal().jacksonXml(Order.class)
    .marshal().json(JsonLibrary.Jackson)
    .to("jms:queue:orders-json");

// Apache Camel - Splitter
from("jms:queue:batch-orders")
    .split(xpath("/orders/order"))
    .to("jms:queue:single-order");

// Apache Camel - Aggregator
from("jms:queue:single-order-result")
    .aggregate(header("batchId"), new OrderAggregationStrategy())
    .completionSize(10)
    .completionTimeout(5000)
    .to("jms:queue:batch-result");

// Apache Camel - Dead Letter Channel
errorHandler(deadLetterChannel("jms:queue:dead-letters")
    .maximumRedeliveries(3)
    .redeliveryDelay(1000)
    .retryAttemptedLogLevel(LoggingLevel.WARN));

from("jms:queue:orders")
    .process(exchange -> {
        // 처리 로직 - 실패 시 자동으로 DLC로 이동
        Order order = exchange.getIn().getBody(Order.class);
        orderService.process(order);
    })
    .to("jms:queue:processed-orders");

// Apache Camel - Idempotent Consumer (메모리 기반)
from("jms:queue:orders")
    .idempotentConsumer(
        header("orderId"),
        MemoryIdempotentRepository.memoryIdempotentRepository(200)
    )
    .to("jms:queue:unique-orders");

// Redis 기반 멱등성 (프로덕션 추천)
from("jms:queue:orders")
    .idempotentConsumer(
        header("orderId"),
        new RedisIdempotentRepository(redisTemplate, "processed-orders")
    )
    .to("jms:queue:unique-orders");

// Apache Camel - Wire Tap
from("jms:queue:orders")
    .wireTap("jms:queue:order-audit")    // 감사용 복제
    .to("jms:queue:order-processing");   // 원래 흐름 계속

CDM 없이 (N:N 매핑):
SAP (IDOC) ←→ Salesforce (SOQL)
SAP (IDOC) ←→ WMS (CSV)
Salesforce (SOQL) ←→ WMS (CSV)
= 3개 매핑 (3시스템 기준)

CDM 적용 (N:1 매핑):
SAP (IDOC) → CDM (JSON) → Salesforce
WMS (CSV) → CDM (JSON) → Salesforce
SAP (IDOC) → CDM (JSON) → WMS
= 각 시스템에서 CDM으로 1개 매핑만 구현

{
  "canonicalOrder": {
    "orderId": "ORD-2026-001",
    "orderDate": "2026-03-23T10:30:00Z",
    "customer": {
      "customerId": "CUST-001",
      "name": "김영주",
      "email": "yj@example.com"
    },
    "items": [
      {
        "productId": "PROD-100",
        "productName": "노트북",
        "quantity": 2,
        "unitPrice": 1500000,
        "currency": "KRW"
      }
    ],
    "totalAmount": 3000000,
    "status": "CREATED"
  }
}

<!-- SAP IDOC를 CDM으로 변환하는 XSLT -->
<xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform">
  <xsl:template match="/ORDERS05">
    <canonicalOrder>
      <orderId><xsl:value-of select="IDOC/E1EDK01/BELNR"/></orderId>
      <orderDate><xsl:value-of select="IDOC/E1EDK01/DATUM"/></orderDate>
      <customer>
        <customerId><xsl:value-of select="IDOC/E1EDKA1/PARVW"/></customerId>
        <name><xsl:value-of select="IDOC/E1EDKA1/NAME1"/></name>
      </customer>
    </canonicalOrder>
  </xsl:template>
</xsl:stylesheet>

%dw 2.0
output application/json
---
{
  canonicalOrder: {
    orderId: payload.ORDERS05.IDOC.E1EDK01.BELNR,
    orderDate: payload.ORDERS05.IDOC.E1EDK01.DATUM as Date,
    customer: {
      customerId: payload.ORDERS05.IDOC.E1EDKA1.PARVW,
      name: payload.ORDERS05.IDOC.E1EDKA1.NAME1
    },
    items: payload.ORDERS05.IDOC.E1EDP01 map ((item) -> {
      productId: item.MATNR,
      quantity: item.MENGE as Number,
      unitPrice: item.NETPR as Number
    })
  }
}

{
  "canonicalOrder": {
    "orderId": sapOrder.BELNR,
    "orderDate": sapOrder.DATUM,
    "customer": {
      "customerId": sapOrder.PARVW,
      "name": sapOrder.NAME1
    },
    "totalAmount": $sum(sapOrder.items.(MENGE * NETPR))
  }
}

# Debezium 커넥터 설정 (MySQL)
name: mysql-connector
config:
  connector.class: io.debezium.connector.mysql.MySqlConnector
  database.hostname: mysql-server
  database.port: 3306
  database.user: debezium
  database.password: secret
  database.server.id: 1
  topic.prefix: myapp
  database.include.list: ecommerce
  table.include.list: ecommerce.orders,ecommerce.customers
  schema.history.internal.kafka.bootstrap.servers: kafka:9092
  schema.history.internal.kafka.topic: schema-changes

[MySQL DB] → [Debezium Connector] → [Kafka Topic] → [Consumer App]
                                                    → [Elasticsearch]
                                                    → [Data Warehouse]

// Spring Boot + Apache Camel 예시
@Component
public class OrderIntegrationRoute extends RouteBuilder {

    @Override
    public void configure() throws Exception {
        // 에러 핸들링
        errorHandler(deadLetterChannel("kafka:dead-letters")
            .maximumRedeliveries(3)
            .redeliveryDelay(2000));

        // SAP에서 주문 수신 -> 변환 -> CRM으로 전송
        from("sap-idoc:ORDERS05")
            .routeId("sap-to-crm-orders")
            .log("SAP 주문 수신: orderId=${header.orderId}")
            .unmarshal().jacksonXml(SapOrder.class)
            .bean(OrderTransformer.class, "toCanonical")
            .marshal().json(JsonLibrary.Jackson)
            .choice()
                .when(simple("${body[totalAmount]} > 10000000"))
                    .to("kafka:high-value-orders")
                .otherwise()
                    .to("kafka:standard-orders")
            .end()
            .to("salesforce:upsert:Order__c?sObjectIdName=SAP_Order_Id__c");
    }
}

[웹사이트] → REST API → [API Gateway]
                            │
                     [Apache Camel Hub]
                     ┌──────┼──────────┐
                     │      │          │
                  [Kafka]  [Kafka]   [Kafka]
                  orders   inventory  shipping
                     │      │          │
                [SAP ERP] [WMS]  [Salesforce CRM]
                     │      │          │
                     └──────┼──────────┘
                            │
                     [Monitoring]
                  Prometheus + Grafana

@Component
public class EcommerceIntegrationRoutes extends RouteBuilder {

    @Override
    public void configure() throws Exception {

        // ===== 글로벌 에러 핸들링 =====
        errorHandler(deadLetterChannel("kafka:dead-letter-queue")
            .maximumRedeliveries(3)
            .redeliveryDelay(2000)
            .backOffMultiplier(2)
            .useExponentialBackOff()
            .retryAttemptedLogLevel(LoggingLevel.WARN)
            .logRetryStackTrace(true));

        // ===== 1단계: 주문 수신 → SAP ERP 등록 =====
        from("rest:post:/api/orders")
            .routeId("order-intake")
            .log("신규 주문 수신: ${body}")
            .unmarshal().json(JsonLibrary.Jackson, OrderRequest.class)
            .bean(OrderValidator.class, "validate")
            .bean(OrderTransformer.class, "toCanonical")
            .marshal().json(JsonLibrary.Jackson)
            .to("kafka:orders?brokers=localhost:9092")
            .setBody(simple("주문이 접수되었습니다. 주문번호: ${header.orderId}"));

        // SAP ERP 주문 등록
        from("kafka:orders?brokers=localhost:9092&groupId=sap-consumer")
            .routeId("sap-order-registration")
            .idempotentConsumer(
                header("orderId"),
                new RedisIdempotentRepository(redisTemplate, "sap-orders")
            )
            .unmarshal().json(JsonLibrary.Jackson, CanonicalOrder.class)
            .bean(SapOrderTransformer.class, "toSapIdoc")
            .to("sap-idoc:ORDERS05")
            .log("SAP 주문 등록 완료: ${header.orderId}")
            .to("kafka:inventory-check?brokers=localhost:9092");

        // ===== 2단계: 재고 확인 → WMS 출고 지시 =====
        from("kafka:inventory-check?brokers=localhost:9092&groupId=wms-consumer")
            .routeId("inventory-check-and-ship")
            .unmarshal().json(JsonLibrary.Jackson, CanonicalOrder.class)
            .bean(InventoryService.class, "checkAvailability")
            .choice()
                .when(simple("${header.inventoryAvailable} == true"))
                    .log("재고 확보: ${header.orderId}")
                    .bean(WmsTransformer.class, "toShipmentRequest")
                    .to("http://wms-api.internal:8080/api/shipments")
                    .to("kafka:shipping-started?brokers=localhost:9092")
                .otherwise()
                    .log("재고 부족: ${header.orderId}")
                    .to("kafka:backorder-queue?brokers=localhost:9092")
            .end();

        // ===== 3단계: 배송 시작 → Salesforce 상태 업데이트 =====
        from("kafka:shipping-started?brokers=localhost:9092&groupId=crm-consumer")
            .routeId("crm-status-update")
            .unmarshal().json(JsonLibrary.Jackson, ShipmentEvent.class)
            .bean(SalesforceTransformer.class, "toOpportunityUpdate")
            .to("salesforce:upsert:Opportunity?sObjectIdName=Order_Id__c")
            .log("Salesforce 상태 업데이트 완료: ${header.orderId}");

        // ===== Circuit Breaker (서킷 브레이커) =====
        from("kafka:critical-orders?brokers=localhost:9092")
            .routeId("circuit-breaker-route")
            .circuitBreaker()
                .resilience4jConfiguration()
                    .failureRateThreshold(50)
                    .waitDurationInOpenState(30000)
                    .slidingWindowSize(10)
                .end()
                .to("http://payment-service:8080/api/process")
            .onFallback()
                .log("결제 서비스 장애 - 폴백 처리")
                .to("kafka:payment-retry-queue?brokers=localhost:9092")
            .end();
    }
}

# docker-compose-monitoring.yml
version: '3.8'
services:
  prometheus:
    image: prom/prometheus:latest
    ports:
      - '9090:9090'
    volumes:
      - ./prometheus.yml:/etc/prometheus/prometheus.yml

  grafana:
    image: grafana/grafana:latest
    ports:
      - '3000:3000'
    environment:
      - GF_SECURITY_ADMIN_PASSWORD=admin

  # Camel 메트릭 노출
  camel-app:
    build: .
    ports:
      - '8080:8080'
      - '8081:8081' # Actuator/Prometheus 메트릭
    environment:
      - MANAGEMENT_ENDPOINTS_WEB_EXPOSURE_INCLUDE=health,prometheus
      - MANAGEMENT_METRICS_EXPORT_PROMETHEUS_ENABLED=true

[마이크로서비스 A] ──── API Gateway (동기) ──── [마이크로서비스 B]
        │                                              │
        └──── Event Mesh (Kafka/EventBridge) ──────────┘
                          │
                   [레거시 ERP]  ← Apache Camel 어댑터

[외부 시스템] → API Gateway → Lambda (변환) → EventBridge → Step Functions
                                                              │
                                                    ┌─────────┼─────────┐
                                                 Lambda A   Lambda B   Lambda C
                                                 (SAP)     (SF)      (WMS)
                                                    │         │         │
                                                    └─────────┼─────────┘
                                                              │
                                                        DynamoDB (상태)
                                                              │
                                                    CloudWatch (모니터링)

[AI 에이전트 (Claude, GPT)]
        │
    MCP Protocol
        │
[MCP 서버: EAI 오케스트레이터]
    ├── Tool: createIntegrationFlow
    ├── Tool: monitorPipeline
    ├── Tool: triggerDataSync
    └── Tool: debugFailedMessages
        │
[Apache Camel / MuleSoft / AWS Step Functions]

[인터넷뱅킹] ─┐
[모바일뱅킹] ──┤── MCI ── EAI ── 코어뱅킹
[ATM]        ──┤                   │
[텔러시스템] ──┘              ├── CRM
                              ├── 리스크
                              └── FEP → 금융결제원/카드사/보험사