Event-driven APIs

 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

// 이벤트 기반 API의 기본 개념을 보여주는 예시 코드 (Node.js)
const EventEmitter = require('events');

// 이벤트 브로커 역할을 하는 이벤트 이미터 인스턴스 생성
const orderEventBroker = new EventEmitter();

// 이벤트 소비자(구독자) 설정 - 주문 생성 이벤트 리스너
orderEventBroker.on('orderCreated', (orderData) => {
  console.log('새 주문이 생성되었습니다:', orderData);
  // 주문 처리 로직
  processOrder(orderData);
});

// 이벤트 소비자(구독자) 설정 - 주문 취소 이벤트 리스너
orderEventBroker.on('orderCancelled', (orderId) => {
  console.log('주문이 취소되었습니다. 주문 ID:', orderId);
  // 주문 취소 처리 로직
  handleOrderCancellation(orderId);
});

// 이벤트 발행자 - 주문 생성 이벤트 발행
function createOrder(orderDetails) {
  // 주문 데이터 생성 및 저장
  const orderData = {
    id: generateOrderId(),
    items: orderDetails.items,
    customer: orderDetails.customer,
    timestamp: new Date(),
    status: 'created'
  };
  saveOrderToDatabase(orderData);
  
  // 이벤트 발행
  orderEventBroker.emit('orderCreated', orderData);
  
  return orderData.id;
}

// 이벤트 발행자 - 주문 취소 이벤트 발행
function cancelOrder(orderId) {
  // 주문 상태 업데이트
  updateOrderStatus(orderId, 'cancelled');
  
  // 이벤트 발행
  orderEventBroker.emit('orderCancelled', orderId);
}

// 보조 함수들
function processOrder(orderData) {
  // 주문 처리 로직
}

function handleOrderCancellation(orderId) {
  // 주문 취소 처리 로직
}

function generateOrderId() {
  // 주문 ID 생성 로직
  return 'ORD-' + Math.floor(Math.random() * 10000);
}

function saveOrderToDatabase(orderData) {
  // 데이터베이스 저장 로직
  console.log('주문이 데이터베이스에 저장되었습니다.');
}

function updateOrderStatus(orderId, status) {
  // 주문 상태 업데이트 로직
  console.log(`주문 ${orderId}의 상태가 '${status}'로 업데이트되었습니다.`);
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19

// 이벤트 객체의 예시
{
  "eventType": "orderShipped",
  "eventId": "evt-123456",
  "timestamp": "2023-03-15T14:30:45Z",
  "source": "order-service",
  "data": {
    "orderId": "ORD-9876",
    "customer": {
      "id": "CUST-5678",
      "email": "customer@example.com"
    },
    "shippingInfo": {
      "carrier": "FedEx",
      "trackingNumber": "FX123456789",
      "estimatedDelivery": "2023-03-18"
    }
  }
}

  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

// IoT 디바이스에서 MQTT를 사용한 이벤트 기반 통신 예시 (Node.js)
const mqtt = require('mqtt');
const client = mqtt.connect('mqtt://broker.example.com');

// 온도 센서 이벤트 생산자
class TemperatureSensor {
  constructor(sensorId, location) {
    this.sensorId = sensorId;
    this.location = location;
    this.connected = false;
    this.interval = null;
  }

  connect() {
    client.on('connect', () => {
      console.log(`센서 ${this.sensorId} 연결됨`);
      this.connected = true;
      this.startReporting();
    });

    client.on('error', (error) => {
      console.error(`센서 ${this.sensorId} 연결 오류:`, error);
      this.connected = false;
    });
  }

  startReporting() {
    this.interval = setInterval(() => {
      if (this.connected) {
        const temperature = this.readTemperature();
        const humidity = this.readHumidity();
        
        const event = {
          sensorId: this.sensorId,
          location: this.location,
          timestamp: new Date().toISOString(),
          readings: {
            temperature,
            humidity
          }
        };
        
        // 온도 이벤트 발행
        client.publish(
          `sensors/temperature/${this.sensorId}`,
          JSON.stringify(event),
          { qos: 1 }
        );
        
        console.log(`온도 이벤트 발행: ${temperature}°C, ${humidity}%`);
        
        // 임계값 초과 시 알림 이벤트 발행
        if (temperature > 30) {
          const alertEvent = {
            sensorId: this.sensorId,
            location: this.location,
            timestamp: new Date().toISOString(),
            alertType: 'high-temperature',
            value: temperature,
            threshold: 30
          };
          
          client.publish(
            'alerts/temperature',
            JSON.stringify(alertEvent),
            { qos: 2 } // 중요 알림은 더 높은 QoS로 전송
          );
          
          console.log(`온도 경고 발행: ${temperature}°C > 30°C`);
        }
      }
    }, 60000); // 1분마다 보고
  }

  stopReporting() {
    if (this.interval) {
      clearInterval(this.interval);
      this.interval = null;
    }
  }

  readTemperature() {
    // 실제로는 센서 하드웨어에서 읽어오지만, 여기서는 시뮬레이션
    return 20 + Math.random() * 15;
  }

  readHumidity() {
    // 습도 센서 시뮬레이션
    return 40 + Math.random() * 30;
  }
}

// 온도 알림 이벤트 소비자
class TemperatureAlertHandler {
  constructor() {
    this.initialize();
  }

  initialize() {
    client.on('connect', () => {
      console.log('알림 핸들러 연결됨');
      
      // 온도 알림 주제 구독
      client.subscribe('alerts/temperature', { qos: 2 }, (err) => {
        if (!err) {
          console.log('온도 알림 주제 구독 성공');
        }
      });
    });

    client.on('message', (topic, message) => {
      if (topic === 'alerts/temperature') {
        try {
          const alertEvent = JSON.parse(message.toString());
          this.handleTemperatureAlert(alertEvent);
        } catch (error) {
          console.error('알림 처리 오류:', error);
        }
      }
    });
  }

  handleTemperatureAlert(alertEvent) {
    console.log('온도 알림 수신:', alertEvent);
    
    // 실제로는 알림 발송, 대시보드 업데이트, 자동화된 조치 등을 수행
    console.log(`[긴급] ${alertEvent.location}의 온도가 ${alertEvent.value}°C로 임계값 ${alertEvent.threshold}°C를 초과했습니다.`);
    
    // 알림 이벤트 기록
    this.logAlert(alertEvent);
    
    // 냉각 시스템 작동 명령 이벤트 발행
    this.triggerCoolingSystem(alertEvent.location);
  }

  logAlert(alertEvent) {
    // 알림 로깅 로직
    console.log(`알림 기록: ${JSON.stringify(alertEvent)}`);
  }

  triggerCoolingSystem(location) {
    const command = {
      timestamp: new Date().toISOString(),
      location: location,
      action: 'activate-cooling'
    };
    
    // 냉각 시스템 명령 발행
    client.publish(
      `commands/cooling/${location}`,
      JSON.stringify(command),
      { qos: 2 }
    );
    
    console.log(`${location}의 냉각 시스템 작동 명령 발행`);
  }
}

// 사용 예시
const sensor1 = new TemperatureSensor('temp-001', '서버실-A');
const alertHandler = new TemperatureAlertHandler();

sensor1.connect();

 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

// AWS Lambda와 EventBridge를 사용한 서버리스 이벤트 처리 예시
// Lambda 함수 (index.js)
exports.handler = async (event) => {
  console.log('이벤트 수신:', JSON.stringify(event, null, 2));
  
  // 이벤트 유형에 따른 처리
  if (event.source === 'order-service' && event.detail-type === 'OrderPlaced') {
    // 주문 처리 로직
    await processOrder(event.detail);
    
    // 후속 이벤트 발행
    await publishEvent({
      source: 'order-processor',
      detailType: 'OrderProcessed',
      detail: {
        orderId: event.detail.orderId,
        status: 'processed',
        processingTime: new Date().toISOString()
      }
    });
    
    return {
      statusCode: 200,
      body: JSON.stringify({ message: '주문 처리 완료', orderId: event.detail.orderId })
    };
  }
  
  return {
    statusCode: 400,
    body: JSON.stringify({ message: '지원되지 않는 이벤트 유형' })
  };
};

// 주문 처리 함수
async function processOrder(orderDetails) {
  console.log(`주문 ${orderDetails.orderId} 처리 중...`);
  // 실제 처리 로직 구현
}

// 이벤트 발행 함수
async function publishEvent(eventData) {
  const AWS = require('aws-sdk');
  const eventBridge = new AWS.EventBridge();
  
  const params = {
    Entries: [
      {
        Source: eventData.source,
        DetailType: eventData.detailType,
        Detail: JSON.stringify(eventData.detail),
        EventBusName: 'default'
      }
    ]
  };
  
  try {
    const result = await eventBridge.putEvents(params).promise();
    console.log('이벤트 발행 성공:', result);
    return result;
  } catch (error) {
    console.error('이벤트 발행 오류:', error);
    throw error;
  }
}