Microservices Architecture

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

# order_service.py
from fastapi import FastAPI
from pydantic import BaseModel

app = FastAPI()

class Order(BaseModel):
    order_id: str
    user_id: str
    amount: float

@app.post("/orders")
def create_order(order: Order):
    # 주문 생성 로직
    return {"status": "created", "order": order}

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

# payment_service.py
import requests
from fastapi import FastAPI

app = FastAPI()

@app.post("/process-payment")
def process_payment(data: dict):
    # 결제 로직 수행
    # 실패 시 order 취소 이벤트 전송
    if data['amount'] > 1000:
        requests.post("http://order-service/cancel-order", json={"order_id": data["order_id"]})
        return {"status": "cancelled"}
    return {"status": "paid"}

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

// gateway.js (Express)
const express = require('express');
const request = require('request');
const app = express();

app.use('/gateway', (req, res) => {
  // 인증, 로깅, 속도 제한 …
  request(`http://order-service${req.originalUrl}`, { json: true }, (e, r, b) => {
    res.status(r.statusCode).send(b);
  });
});

app.listen(3000);

1
2
3
4
5
6
7

// bff-mobile.js
app.get('/mobile/orders', (req, res) => {
  // 모바일 요청에 특화된 간단한 데이터 반환
  request(`http://order-service/orders?user=${req.query.user}`, (e, r, b) => {
    res.send({ mobileOrders: b });
  });
});

1
2
3
4
5
6
7

# query_model.py (읽기 전용)
from elasticsearch import Elasticsearch
es = Elasticsearch()

def search_orders(user_id):
    resp = es.search(index="orders", query={"term": {"user_id": user_id}})
    return resp['hits']['hits']

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

# event_store.py
events = []

def append_event(event):
    events.append(event)

def get_current_state():
    state = {}
    for e in events:
        state[e['entity_id']] = e['data']
    return state

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

# deployment.yaml
apiVersion: apps/v1
kind: Deployment
metadata:
  name: order-service
spec:
  replicas: 3
  selector: { matchLabels: { app: order-service } }
  template:
    metadata: { labels: { app: order-service } }
    spec:
      containers:
      - name: order
        image: myregistry/order-service:latest
        ports: [{ containerPort: 80 }]

1
2
3
4
5
6

# canary-deployment.yaml
…
spec:
  replicas: 2 # Canary
  strategy:
    type: RollingUpdate

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

// featureToggle.js
const features = { newUI: false };

function getOrders(req, res) {
  if (features.newUI) {
    res.send(/* 새로운 UI 형태 */);
  } else {
    res.send(/* 기본 UI */);
  }
}

1
2
3
4
5
6

# saga_coordinator.py
steps = [
  ("order", "create"),
  ("payment", "charge"),
  ("inventory", "reserve")
]

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

# .github/workflows/deploy.yaml
on: push
jobs:
  build-and-deploy:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v2
      - name: Build
        run: docker build . -t myapp:latest
      - name: Deploy
        run: kubectl apply -f deployment.yaml

1
2
3
4
5

# producer.py
from kafka import KafkaProducer
producer = KafkaProducer(bootstrap_servers='localhost:9092')
producer.send('orders', b'{"order_id": "123"}')
producer.flush()

1
2
3
4

// using opossum package
const CircuitBreaker = require('opossum');
function callInventory() { /* 원격 호출 */ }
const cb = new CircuitBreaker(callInventory, { timeout: 3000, errorThresholdPercentage: 50 });

1
2
3
4
5
6
7

# tracing.py
from opentelemetry import trace
tracer = trace.get_tracer("order-service")

with tracer.start_as_current_span("create_order"):
    # 주문 처리 로직
    pass

1

[모놀리식] → [/orders 기능 신규 마이크로서비스로 교체] → 남은 기능 단계별 이전

  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
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286

// 사용자 서비스 (User Service) - Express.js 기반
const express = require('express');
const eureka = require('eureka-js-client').Eureka;
const winston = require('winston');
const circuit = require('opossum');

class UserService {
    constructor() {
        this.app = express();
        this.port = process.env.PORT || 3001;
        this.setupMiddleware();
        this.setupRoutes();
        this.setupServiceDiscovery();
        this.setupCircuitBreaker();
        this.setupLogging();
    }

    // 미들웨어 설정
    setupMiddleware() {
        this.app.use(express.json());
        this.app.use(express.urlencoded({ extended: true }));
        
        // CORS 설정
        this.app.use((req, res, next) => {
            res.header('Access-Control-Allow-Origin', '*');
            res.header('Access-Control-Allow-Headers', 'Content-Type, Authorization');
            res.header('Access-Control-Allow-Methods', 'GET, POST, PUT, DELETE');
            next();
        });
    }

    // 라우트 설정
    setupRoutes() {
        // 헬스 체크 엔드포인트
        this.app.get('/health', (req, res) => {
            res.status(200).json({
                service: 'user-service',
                status: 'healthy',
                timestamp: new Date().toISOString()
            });
        });

        // 사용자 생성
        this.app.post('/users', async (req, res) => {
            try {
                const { name, email, password } = req.body;
                
                // 입력 검증
                if (!name || !email || !password) {
                    return res.status(400).json({
                        error: 'Missing required fields'
                    });
                }

                const user = await this.createUser({ name, email, password });
                
                // 이벤트 발행 (다른 서비스에 알림)
                await this.publishEvent('user.created', {
                    userId: user.id,
                    email: user.email,
                    timestamp: new Date().toISOString()
                });

                res.status(201).json(user);
                this.logger.info(`User created: ${user.id}`);
            } catch (error) {
                this.logger.error('Error creating user:', error);
                res.status(500).json({ error: 'Internal server error' });
            }
        });

        // 사용자 조회
        this.app.get('/users/:id', async (req, res) => {
            try {
                const { id } = req.params;
                const user = await this.getUserById(id);
                
                if (!user) {
                    return res.status(404).json({ error: 'User not found' });
                }

                res.json(user);
            } catch (error) {
                this.logger.error('Error fetching user:', error);
                res.status(500).json({ error: 'Internal server error' });
            }
        });

        // 사용자 목록 조회
        this.app.get('/users', async (req, res) => {
            try {
                const { page = 1, limit = 10 } = req.query;
                const users = await this.getUsers(page, limit);
                res.json(users);
            } catch (error) {
                this.logger.error('Error fetching users:', error);
                res.status(500).json({ error: 'Internal server error' });
            }
        });

        // 다른 서비스 호출 예시 (주문 서비스)
        this.app.get('/users/:id/orders', async (req, res) => {
            try {
                const { id } = req.params;
                
                // 써킷 브레이커를 통한 외부 서비스 호출
                const orders = await this.orderServiceBreaker.fire(id);
                res.json(orders);
            } catch (error) {
                this.logger.error('Error fetching user orders:', error);
                // 써킷 브레이커가 열린 경우 기본값 반환
                res.json({ orders: [], message: 'Orders service unavailable' });
            }
        });
    }

    // 서비스 디스커버리 설정 (Eureka)
    setupServiceDiscovery() {
        this.eurekaClient = new eureka({
            instance: {
                app: 'user-service',
                hostName: 'localhost',
                ipAddr: '127.0.0.1',
                port: {
                    '$': this.port,
                    '@enabled': 'true'
                },
                vipAddress: 'user-service',
                dataCenterInfo: {
                    '@class': 'com.netflix.appinfo.InstanceInfo$DefaultDataCenterInfo',
                    name: 'MyOwn'
                }
            },
            eureka: {
                host: process.env.EUREKA_HOST || 'localhost',
                port: process.env.EUREKA_PORT || 8761,
                servicePath: '/eureka/apps/'
            }
        });
    }

    // 써킷 브레이커 설정
    setupCircuitBreaker() {
        const options = {
            timeout: 3000,        // 3초 타임아웃
            errorThresholdPercentage: 50, // 50% 실패율
            resetTimeout: 30000   // 30초 후 재시도
        };

        // 주문 서비스 호출을 위한 써킷 브레이커
        this.orderServiceBreaker = circuit(this.callOrderService.bind(this), options);
        
        // 써킷 브레이커 이벤트 핸들링
        this.orderServiceBreaker.on('open', () => {
            this.logger.warn('Circuit breaker opened for order service');
        });
        
        this.orderServiceBreaker.on('halfOpen', () => {
            this.logger.info('Circuit breaker half-open for order service');
        });
    }

    // 로깅 설정
    setupLogging() {
        this.logger = winston.createLogger({
            level: 'info',
            format: winston.format.combine(
                winston.format.timestamp(),
                winston.format.errors({ stack: true }),
                winston.format.json()
            ),
            transports: [
                new winston.transports.Console(),
                new winston.transports.File({ filename: 'user-service.log' })
            ]
        });
    }

    // 사용자 생성 (데이터베이스 로직)
    async createUser(userData) {
        // 실제 구현에서는 데이터베이스 연동
        const user = {
            id: Math.random().toString(36).substr(2, 9),
            name: userData.name,
            email: userData.email,
            createdAt: new Date().toISOString()
        };
        
        // 데이터베이스 저장 로직
        // await this.userRepository.save(user);
        
        return user;
    }

    // 사용자 조회
    async getUserById(id) {
        // 실제 구현에서는 데이터베이스 조회
        // return await this.userRepository.findById(id);
        return {
            id,
            name: 'John Doe',
            email: 'john@example.com',
            createdAt: '2023-01-01T00:00:00Z'
        };
    }

    // 사용자 목록 조회
    async getUsers(page, limit) {
        // 실제 구현에서는 페이징 처리
        // return await this.userRepository.findAll(page, limit);
        return {
            users: [
                { id: '1', name: 'John Doe', email: 'john@example.com' },
                { id: '2', name: 'Jane Smith', email: 'jane@example.com' }
            ],
            total: 2,
            page: parseInt(page),
            limit: parseInt(limit)
        };
    }

    // 외부 서비스 호출 (주문 서비스)
    async callOrderService(userId) {
        const fetch = require('node-fetch');
        
        // 서비스 디스커버리를 통해 주문 서비스 URL 획득
        const orderServiceUrl = await this.getServiceUrl('order-service');
        
        const response = await fetch(`${orderServiceUrl}/orders/user/${userId}`);
        
        if (!response.ok) {
            throw new Error(`Order service error: ${response.status}`);
        }
        
        return await response.json();
    }

    // 서비스 URL 획득 (서비스 디스커버리)
    async getServiceUrl(serviceName) {
        // 실제 구현에서는 Eureka 클라이언트 사용
        const services = {
            'order-service': 'http://localhost:3002',
            'payment-service': 'http://localhost:3003'
        };
        
        return services[serviceName] || 'http://localhost:3000';
    }

    // 이벤트 발행 (메시지 큐를 통한 비동기 통신)
    async publishEvent(eventType, data) {
        // 실제 구현에서는 RabbitMQ, Apache Kafka 등 사용
        this.logger.info(`Publishing event: ${eventType}`, data);
        
        // 예시: 메시지 큐에 이벤트 발행
        // await this.messageQueue.publish(eventType, data);
    }

    // 서비스 시작
    start() {
        this.app.listen(this.port, () => {
            this.logger.info(`User service running on port ${this.port}`);
            
            // 서비스 디스커버리에 등록
            this.eurekaClient.start((error) => {
                if (error) {
                    this.logger.error('Error starting Eureka client:', error);
                } else {
                    this.logger.info('User service registered with Eureka');
                }
            });
        });

        // graceful shutdown 처리
        process.on('SIGTERM', () => {
            this.logger.info('Received SIGTERM, shutting down gracefully');
            this.eurekaClient.stop();
            process.exit(0);
        });
    }
}

// 서비스 인스턴스 생성 및 시작
const userService = new UserService();
userService.start();

module.exports = UserService;

 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

# user_service.py - 사용자 서비스
from flask import Flask, request, jsonify
from flask_sqlalchemy import SQLAlchemy
import jwt
import datetime
import logging

app = Flask(__name__)
app.config['SQLALCHEMY_DATABASE_URI'] = 'postgresql://user:pass@localhost/userdb'
app.config['SECRET_KEY'] = 'your-secret-key'
db = SQLAlchemy(app)

class User(db.Model):
    """사용자 정보를 저장하는 모델"""
    id = db.Column(db.Integer, primary_key=True)
    username = db.Column(db.String(80), unique=True, nullable=False)
    email = db.Column(db.String(120), unique=True, nullable=False)
    subscription_tier = db.Column(db.String(20), default='basic')
    created_at = db.Column(db.DateTime, default=datetime.datetime.utcnow)

class UserService:
    """사용자 관리를 위한 비즈니스 로직"""
    
    def authenticate_user(self, username, password):
        """사용자 인증 처리"""
        user = User.query.filter_by(username=username).first()
        if user and self._verify_password(password, user.password_hash):
            # JWT 토큰 생성
            token = jwt.encode({
                'user_id': user.id,
                'exp': datetime.datetime.utcnow() + datetime.timedelta(hours=24)
            }, app.config['SECRET_KEY'])
            return {'token': token, 'user_id': user.id}
        return None
    
    def get_user_profile(self, user_id):
        """사용자 프로필 조회"""
        user = User.query.get(user_id)
        if user:
            return {
                'id': user.id,
                'username': user.username,
                'email': user.email,
                'subscription_tier': user.subscription_tier
            }
        return None
    
    def _verify_password(self, password, password_hash):
        """패스워드 검증 (실제로는 bcrypt 등 사용)"""
        # 실제 구현에서는 보안 해시 함수 사용
        return True

user_service = UserService()

@app.route('/auth', methods=['POST'])
def authenticate():
    """사용자 인증 엔드포인트"""
    data = request.get_json()
    result = user_service.authenticate_user(data['username'], data['password'])
    if result:
        return jsonify(result), 200
    return jsonify({'error': 'Invalid credentials'}), 401

@app.route('/users/<int:user_id>', methods=['GET'])
def get_profile(user_id):
    """사용자 프로필 조회 엔드포인트"""
    profile = user_service.get_user_profile(user_id)
    if profile:
        return jsonify(profile), 200
    return jsonify({'error': 'User not found'}), 404

if __name__ == '__main__':
    # 개발 환경에서만 debug=True 사용
    app.run(debug=True, port=5001)

  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

# recommendation_service.py - 추천 서비스
from flask import Flask, request, jsonify
import requests
import redis
import json
import logging
from datetime import datetime, timedelta

app = Flask(__name__)
redis_client = redis.Redis(host='localhost', port=6379, db=0)

class RecommendationService:
    """개인화된 콘텐츠 추천을 위한 서비스"""
    
    def __init__(self):
        # 외부 서비스 URL 설정
        self.user_service_url = 'http://localhost:5001'
        self.video_service_url = 'http://localhost:5003'
    
    def get_recommendations(self, user_id):
        """사용자 맞춤 추천 콘텐츠 생성"""
        # 캐시에서 추천 결과 확인
        cache_key = f"recommendations:{user_id}"
        cached_recommendations = redis_client.get(cache_key)
        
        if cached_recommendations:
            logging.info(f"Cache hit for user {user_id}")
            return json.loads(cached_recommendations)
        
        # 사용자 프로필 조회 (User Service 호출)
        user_profile = self._get_user_profile(user_id)
        if not user_profile:
            return {'error': 'User not found'}
        
        # 시청 히스토리 분석
        viewing_history = self._get_viewing_history(user_id)
        
        # 추천 알고리즘 실행
        recommendations = self._generate_recommendations(user_profile, viewing_history)
        
        # 캐시에 결과 저장 (1시간 TTL)
        redis_client.setex(
            cache_key, 
            timedelta(hours=1), 
            json.dumps(recommendations)
        )
        
        return recommendations
    
    def _get_user_profile(self, user_id):
        """User Service에서 사용자 프로필 조회"""
        try:
            response = requests.get(f"{self.user_service_url}/users/{user_id}")
            if response.status_code == 200:
                return response.json()
            return None
        except requests.RequestException as e:
            logging.error(f"Failed to get user profile: {e}")
            return None
    
    def _get_viewing_history(self, user_id):
        """사용자 시청 기록 조회 (실제로는 별도 서비스)"""
        # 실제 구현에서는 별도의 Analytics Service 호출
        return [
            {'video_id': 1, 'genre': 'action', 'rating': 4.5},
            {'video_id': 2, 'genre': 'comedy', 'rating': 3.8}
        ]
    
    def _generate_recommendations(self, user_profile, viewing_history):
        """추천 알고리즘 실행"""
        # 간단한 추천 로직 (실제로는 ML 모델 사용)
        recommendations = []
        
        # 구독 등급에 따른 추천
        if user_profile['subscription_tier'] == 'premium':
            recommendations.extend(self._get_premium_content())
        
        # 시청 기록 기반 추천
        preferred_genres = self._extract_preferred_genres(viewing_history)
        genre_based_recommendations = self._get_content_by_genres(preferred_genres)
        recommendations.extend(genre_based_recommendations)
        
        return {
            'user_id': user_profile['id'],
            'recommendations': recommendations[:10],  # 상위 10개
            'generated_at': datetime.utcnow().isoformat()
        }
    
    def _get_premium_content(self):
        """프리미엄 콘텐츠 조회"""
        return [
            {'video_id': 101, 'title': 'Premium Movie 1', 'genre': 'drama'},
            {'video_id': 102, 'title': 'Premium Series 1', 'genre': 'thriller'}
        ]
    
    def _extract_preferred_genres(self, viewing_history):
        """시청 기록에서 선호 장르 추출"""
        genre_scores = {}
        for item in viewing_history:
            genre = item['genre']
            rating = item['rating']
            genre_scores[genre] = genre_scores.get(genre, 0) + rating
        
        # 평점이 높은 장르 순으로 정렬
        return sorted(genre_scores.keys(), key=lambda x: genre_scores[x], reverse=True)
    
    def _get_content_by_genres(self, genres):
        """장르별 콘텐츠 조회"""
        content = []
        for genre in genres[:3]:  # 상위 3개 장르
            # 실제로는 Video Service API 호출
            content.extend([
                {'video_id': f"{genre}_1", 'title': f"Top {genre} Movie", 'genre': genre},
                {'video_id': f"{genre}_2", 'title': f"Popular {genre} Series", 'genre': genre}
            ])
        return content

recommendation_service = RecommendationService()

@app.route('/recommendations/<int:user_id>', methods=['GET'])
def get_recommendations(user_id):
    """사용자 맞춤 추천 엔드포인트"""
    try:
        recommendations = recommendation_service.get_recommendations(user_id)
        return jsonify(recommendations), 200
    except Exception as e:
        logging.error(f"Error generating recommendations: {e}")
        return jsonify({'error': 'Internal server error'}), 500

@app.route('/health', methods=['GET'])
def health_check():
    """서비스 헬스 체크 엔드포인트"""
    return jsonify({'status': 'healthy', 'service': 'recommendation'}), 200

if __name__ == '__main__':
    app.run(debug=True, port=5002)

  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

# api_gateway.py - API 게이트웨이
from flask import Flask, request, jsonify, redirect
import requests
import jwt
import logging
from functools import wraps

app = Flask(__name__)
app.config['SECRET_KEY'] = 'your-secret-key'

# 서비스 레지스트리 (실제로는 Consul, Eureka 등 사용)
SERVICE_REGISTRY = {
    'user-service': 'http://localhost:5001',
    'recommendation-service': 'http://localhost:5002',
    'video-service': 'http://localhost:5003'
}

class APIGateway:
    """API Gateway의 핵심 기능 구현"""
    
    def __init__(self):
        self.request_count = 0
        self.rate_limits = {}  # 사용자별 요청 제한
    
    def authenticate_request(self, token):
        """JWT 토큰 검증"""
        try:
            payload = jwt.decode(token, app.config['SECRET_KEY'], algorithms=['HS256'])
            return payload['user_id']
        except jwt.ExpiredSignatureError:
            return None
        except jwt.InvalidTokenError:
            return None
    
    def check_rate_limit(self, user_id, limit=100):
        """사용자별 API 요청 제한 확인"""
        current_requests = self.rate_limits.get(user_id, 0)
        if current_requests >= limit:
            return False
        self.rate_limits[user_id] = current_requests + 1
        return True
    
    def route_request(self, service_name, path, method='GET', data=None):
        """요청을 적절한 마이크로서비스로 라우팅"""
        service_url = SERVICE_REGISTRY.get(service_name)
        if not service_url:
            return {'error': 'Service not found'}, 404
        
        try:
            url = f"{service_url}{path}"
            
            if method == 'GET':
                response = requests.get(url)
            elif method == 'POST':
                response = requests.post(url, json=data)
            elif method == 'PUT':
                response = requests.put(url, json=data)
            elif method == 'DELETE':
                response = requests.delete(url)
            else:
                return {'error': 'Method not allowed'}, 405
            
            return response.json(), response.status_code
            
        except requests.RequestException as e:
            logging.error(f"Service call failed: {e}")
            return {'error': 'Service unavailable'}, 503

gateway = APIGateway()

def require_auth(f):
    """인증이 필요한 엔드포인트를 위한 데코레이터"""
    @wraps(f)
    def decorated(*args, **kwargs):
        token = request.headers.get('Authorization')
        if not token:
            return jsonify({'error': 'Token missing'}), 401
        
        # Bearer 토큰 형식 확인
        if token.startswith('Bearer '):
            token = token[7:]
        
        user_id = gateway.authenticate_request(token)
        if not user_id:
            return jsonify({'error': 'Invalid token'}), 401
        
        # 요청 제한 확인
        if not gateway.check_rate_limit(user_id):
            return jsonify({'error': 'Rate limit exceeded'}), 429
        
        # 인증된 사용자 ID를 함수에 전달
        return f(user_id, *args, **kwargs)
    
    return decorated

# API Gateway 라우팅 규칙
@app.route('/api/auth', methods=['POST'])
def auth():
    """인증 요청을 User Service로 전달"""
    data = request.get_json()
    result, status = gateway.route_request('user-service', '/auth', 'POST', data)
    return jsonify(result), status

@app.route('/api/users/<int:user_id>', methods=['GET'])
@require_auth
def get_user(authenticated_user_id, user_id):
    """사용자 프로필 조회 (인증 필요)"""
    # 본인 정보만 조회 가능하도록 권한 확인
    if authenticated_user_id != user_id:
        return jsonify({'error': 'Access denied'}), 403
    
    result, status = gateway.route_request('user-service', f'/users/{user_id}')
    return jsonify(result), status

@app.route('/api/recommendations/<int:user_id>', methods=['GET'])
@require_auth
def get_recommendations(authenticated_user_id, user_id):
    """추천 서비스 호출 (인증 필요)"""
    if authenticated_user_id != user_id:
        return jsonify({'error': 'Access denied'}), 403
    
    result, status = gateway.route_request('recommendation-service', f'/recommendations/{user_id}')
    return jsonify(result), status

@app.route('/health', methods=['GET'])
def health():
    """API Gateway 헬스 체크"""
    return jsonify({
        'status': 'healthy',
        'service': 'api-gateway',
        'request_count': gateway.request_count
    }), 200

@app.errorhandler(404)
def not_found(error):
    """404 에러 핸들러"""
    return jsonify({'error': 'Endpoint not found'}), 404

@app.errorhandler(500)
def internal_error(error):
    """500 에러 핸들러"""
    return jsonify({'error': 'Internal server error'}), 500

if __name__ == '__main__':
    app.run(debug=True, port=8080)