Content Delivery Networks

  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
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342

"""
CDN (Content Delivery Network) 구현 예시
글로벌 전자상거래 플랫폼의 CDN 시뮬레이션
"""

import time
import random
import hashlib
from datetime import datetime, timedelta
from typing import Dict, List, Optional, Tuple
from dataclasses import dataclass
from enum import Enum
import json

class ContentType(Enum):
    """콘텐츠 타입 정의"""
    STATIC = "static"      # 정적 콘텐츠 (이미지, CSS, JS)
    DYNAMIC = "dynamic"    # 동적 콘텐츠 (API 응답)
    STREAMING = "streaming" # 스트리밍 콘텐츠

class CacheStatus(Enum):
    """캐시 상태"""
    HIT = "hit"           # 캐시 적중
    MISS = "miss"         # 캐시 미스
    STALE = "stale"       # 만료된 캐시

@dataclass
class GeographicLocation:
    """지리적 위치 정보"""
    region: str           # 지역 (asia, america, europe)
    country: str          # 국가
    city: str            # 도시
    latitude: float      # 위도
    longitude: float     # 경도

@dataclass
class Content:
    """콘텐츠 객체"""
    content_id: str                    # 콘텐츠 ID
    content_type: ContentType          # 콘텐츠 타입
    size: int                         # 크기 (bytes)
    data: bytes                       # 실제 데이터
    last_modified: datetime           # 마지막 수정 시간
    ttl: int                         # Time To Live (초)
    etag: str                        # ETag (버전 식별자)

class EdgeServer:
    """에지 서버 클래스"""
    
    def __init__(self, server_id: str, location: GeographicLocation, capacity: int):
        self.server_id = server_id
        self.location = location
        self.capacity = capacity            # 캐시 용량 (bytes)
        self.cache: Dict[str, Content] = {} # 캐시 저장소
        self.current_usage = 0              # 현재 사용량
        self.access_log: List[Dict] = []    # 접근 로그
        
    def calculate_distance(self, user_location: GeographicLocation) -> float:
        """사용자와 서버 간 거리 계산 (단순화된 유클리드 거리)"""
        lat_diff = self.location.latitude - user_location.latitude
        lon_diff = self.location.longitude - user_location.longitude
        return (lat_diff ** 2 + lon_diff ** 2) ** 0.5
    
    def get_content(self, content_id: str) -> Tuple[Optional[Content], CacheStatus]:
        """콘텐츠 조회"""
        current_time = datetime.now()
        
        # 캐시에 콘텐츠가 있는지 확인
        if content_id in self.cache:
            content = self.cache[content_id]
            
            # TTL 확인
            if current_time <= content.last_modified + timedelta(seconds=content.ttl):
                # 캐시 적중 로깅
                self._log_access(content_id, CacheStatus.HIT, content.size)
                return content, CacheStatus.HIT
            else:
                # 만료된 캐시
                self._evict_content(content_id)
                self._log_access(content_id, CacheStatus.STALE, 0)
                return None, CacheStatus.STALE
        
        # 캐시 미스
        self._log_access(content_id, CacheStatus.MISS, 0)
        return None, CacheStatus.MISS
    
    def store_content(self, content: Content) -> bool:
        """콘텐츠 캐싱"""
        # 용량 확인
        if self.current_usage + content.size > self.capacity:
            # LRU 기반 캐시 제거
            self._evict_lru_content(content.size)
        
        # 용량이 충분한지 재확인
        if self.current_usage + content.size <= self.capacity:
            self.cache[content.content_id] = content
            self.current_usage += content.size
            return True
        
        return False
    
    def _evict_content(self, content_id: str):
        """특정 콘텐츠 제거"""
        if content_id in self.cache:
            content = self.cache[content_id]
            self.current_usage -= content.size
            del self.cache[content_id]
    
    def _evict_lru_content(self, required_size: int):
        """LRU 기반 캐시 제거"""
        # 단순화: 가장 오래된 콘텐츠부터 제거
        sorted_content = sorted(
            self.cache.items(),
            key=lambda x: x[1].last_modified
        )
        
        freed_size = 0
        content_to_remove = []
        
        for content_id, content in sorted_content:
            content_to_remove.append(content_id)
            freed_size += content.size
            
            if freed_size >= required_size:
                break
        
        for content_id in content_to_remove:
            self._evict_content(content_id)
    
    def _log_access(self, content_id: str, status: CacheStatus, size: int):
        """접근 로그 기록"""
        log_entry = {
            'timestamp': datetime.now().isoformat(),
            'content_id': content_id,
            'status': status.value,
            'size': size,
            'server_id': self.server_id
        }
        self.access_log.append(log_entry)
    
    def get_cache_stats(self) -> Dict:
        """캐시 통계 반환"""
        total_requests = len(self.access_log)
        hits = sum(1 for log in self.access_log if log['status'] == CacheStatus.HIT.value)
        
        return {
            'server_id': self.server_id,
            'total_requests': total_requests,
            'cache_hits': hits,
            'hit_ratio': hits / total_requests if total_requests > 0 else 0,
            'cache_usage': self.current_usage,
            'cache_capacity': self.capacity,
            'cached_items': len(self.cache)
        }

class OriginServer:
    """원본 서버 클래스"""
    
    def __init__(self):
        self.content_storage: Dict[str, Content] = {}
        self.request_count = 0
        
    def add_content(self, content_id: str, content_type: ContentType, 
                   data: bytes, ttl: int = 3600):
        """콘텐츠 추가"""
        content = Content(
            content_id=content_id,
            content_type=content_type,
            size=len(data),
            data=data,
            last_modified=datetime.now(),
            ttl=ttl,
            etag=hashlib.md5(data).hexdigest()
        )
        self.content_storage[content_id] = content
    
    def get_content(self, content_id: str) -> Optional[Content]:
        """콘텐츠 조회"""
        self.request_count += 1
        return self.content_storage.get(content_id)
    
    def get_stats(self) -> Dict:
        """원본 서버 통계"""
        return {
            'total_requests': self.request_count,
            'stored_content': len(self.content_storage)
        }

class CDNOrchestrator:
    """CDN 오케스트레이터 - 전체 CDN 네트워크 관리"""
    
    def __init__(self, origin_server: OriginServer):
        self.origin_server = origin_server
        self.edge_servers: List[EdgeServer] = []
        self.dns_routing_table: Dict[str, str] = {}  # region -> server_id
        
    def register_edge_server(self, edge_server: EdgeServer):
        """에지 서버 등록"""
        self.edge_servers.append(edge_server)
        self.dns_routing_table[edge_server.location.region] = edge_server.server_id
        
    def find_nearest_server(self, user_location: GeographicLocation) -> EdgeServer:
        """사용자에게 가장 가까운 에지 서버 찾기"""
        if not self.edge_servers:
            raise Exception("No edge servers available")
        
        # 거리 기반 최적 서버 선택
        best_server = min(
            self.edge_servers,
            key=lambda server: server.calculate_distance(user_location)
        )
        
        return best_server
    
    def request_content(self, content_id: str, user_location: GeographicLocation) -> Tuple[Optional[Content], float, CacheStatus]:
        """콘텐츠 요청 처리"""
        start_time = time.time()
        
        # 1. 가장 가까운 에지 서버 찾기
        edge_server = self.find_nearest_server(user_location)
        
        # 2. 에지 서버에서 콘텐츠 조회
        content, cache_status = edge_server.get_content(content_id)
        
        if content:
            # 캐시 적중 - 즉시 반환
            response_time = time.time() - start_time
            return content, response_time, cache_status
        
        # 3. 캐시 미스 - 원본 서버에서 조회
        origin_content = self.origin_server.get_content(content_id)
        
        if origin_content:
            # 4. 에지 서버에 캐싱
            edge_server.store_content(origin_content)
            
            # 5. 사용자에게 반환
            response_time = time.time() - start_time + 0.1  # 원본 서버 지연 시뮬레이션
            return origin_content, response_time, CacheStatus.MISS
        
        # 콘텐츠를 찾을 수 없음
        response_time = time.time() - start_time
        return None, response_time, CacheStatus.MISS
    
    def get_global_stats(self) -> Dict:
        """전체 CDN 통계"""
        total_requests = sum(len(server.access_log) for server in self.edge_servers)
        total_hits = sum(
            len([log for log in server.access_log if log['status'] == CacheStatus.HIT.value])
            for server in self.edge_servers
        )
        
        server_stats = [server.get_cache_stats() for server in self.edge_servers]
        origin_stats = self.origin_server.get_stats()
        
        return {
            'global_hit_ratio': total_hits / total_requests if total_requests > 0 else 0,
            'total_requests': total_requests,
            'origin_requests': origin_stats['total_requests'],
            'bandwidth_saved': (total_requests - origin_stats['total_requests']) / total_requests if total_requests > 0 else 0,
            'edge_servers': server_stats
        }

# 사용 예시 및 시뮬레이션
def simulate_ecommerce_cdn():
    """전자상거래 CDN 시뮬레이션"""
    print("=== CDN 시뮬레이션 시작 ===\n")
    
    # 1. 원본 서버 설정
    origin_server = OriginServer()
    
    # 2. 샘플 콘텐츠 추가
    origin_server.add_content("product_image_001.jpg", ContentType.STATIC, b"fake_image_data" * 1000, ttl=86400)
    origin_server.add_content("product_list.json", ContentType.DYNAMIC, b'{"products": […]}' * 100, ttl=300)
    origin_server.add_content("user_recommendations.json", ContentType.DYNAMIC, b'{"recommendations": […]}' * 50, ttl=600)
    
    # 3. CDN 오케스트레이터 생성
    cdn = CDNOrchestrator(origin_server)
    
    # 4. 에지 서버 등록
    edge_servers = [
        EdgeServer("edge_asia", GeographicLocation("asia", "South Korea", "Seoul", 37.5665, 126.9780), 10_000_000),
        EdgeServer("edge_america", GeographicLocation("america", "USA", "New York", 40.7128, -74.0060), 10_000_000),
        EdgeServer("edge_europe", GeographicLocation("europe", "Germany", "Frankfurt", 50.1109, 8.6821), 10_000_000)
    ]
    
    for server in edge_servers:
        cdn.register_edge_server(server)
    
    # 5. 다양한 지역의 사용자 시뮬레이션
    user_locations = [
        GeographicLocation("asia", "South Korea", "Seoul", 37.5665, 126.9780),
        GeographicLocation("america", "USA", "Los Angeles", 34.0522, -118.2437),
        GeographicLocation("europe", "France", "Paris", 48.8566, 2.3522),
        GeographicLocation("asia", "Japan", "Tokyo", 35.6762, 139.6503)
    ]
    
    content_requests = [
        "product_image_001.jpg",
        "product_list.json", 
        "user_recommendations.json"
    ]
    
    print("6. 트래픽 시뮬레이션 실행")
    print("-" * 50)
    
    # 100개의 랜덤 요청 시뮬레이션
    for i in range(100):
        user_location = random.choice(user_locations)
        content_id = random.choice(content_requests)
        
        content, response_time, cache_status = cdn.request_content(content_id, user_location)
        
        if i < 10:  # 처음 10개 요청만 상세 출력
            print(f"요청 {i+1}: {user_location.city} -> {content_id}")
            print(f"  응답시간: {response_time:f}초, 캐시상태: {cache_status.value}")
            print(f"  콘텐츠 크기: {content.size if content else 0} bytes\n")
    
    # 7. 최종 통계 출력
    print("7. CDN 성능 통계")
    print("=" * 50)
    
    global_stats = cdn.get_global_stats()
    
    print(f"전체 요청 수: {global_stats['total_requests']}")
    print(f"원본 서버 요청 수: {global_stats['origin_requests']}")
    print(f"글로벌 캐시 적중률: {global_stats['global_hit_ratio']:%}")
    print(f"대역폭 절약률: {global_stats['bandwidth_saved']:%}")
    
    print("\n8. 에지 서버별 통계")
    print("-" * 50)
    
    for server_stat in global_stats['edge_servers']:
        print(f"서버 ID: {server_stat['server_id']}")
        print(f"  요청 수: {server_stat['total_requests']}")
        print(f"  캐시 적중률: {server_stat['hit_ratio']:%}")
        print(f"  캐시 사용률: {server_stat['cache_usage']:,} / {server_stat['cache_capacity']:,} bytes")
        print(f"  캐시된 항목 수: {server_stat['cached_items']}")
        print()

if __name__ == "__main__":
    simulate_ecommerce_cdn()