AI API 릴레이 서비스를 운영하는 개발자라면 가장 걱정되는 상황 중 하나는 서비스 장애로 인한 갑작스러운 연결 중단입니다. 제 경험상 AI 릴레이 서비스의 가용성을 효과적으로 모니터링하지 못하면 예상치 못한 장애로 인해 프로덕션 환경에서 심각한 문제를 경험하게 됩니다.
본 가이드에서는 HolySheep AI를 포함한 주요 AI 릴레이 서비스의 가용성을 효과적으로 모니터링하는方案을 상세히 설명드리겠습니다.
AI 릴레이 서비스 가용성 비교
먼저 주요 AI API 서비스들의 가용성과 안정성을 비교해 보겠습니다.
| 서비스 | 평균 지연 시간 | 월간 가용성 | 모니터링 도구 | 장애 알림 | 가격 |
|---|---|---|---|---|---|
| HolySheep AI | 120-180ms | 99.9% | 커스텀 API + 대시보드 | 이메일/웹훅 | $0.42/MTok~ |
| 공식 OpenAI API | 100-150ms | 99.95% | Status Page | 공식 알림만 | $2.5/MTok~ |
| 공식 Anthropic API | 150-200ms | 99.9% | Status Page | 공식 알림만 | $15/MTok~ |
| 타 릴레이 서비스 | 200-500ms | 97-99% | 제한적 | 불규칙 | 다양함 |
이런 팀에 적합 / 비적합
✅ HolySheep AI가 적합한 팀
- 신규 AI 프로젝트 시작팀: 해외 신용카드 없이 간편하게 AI API를 사용하고 싶은 경우
- 비용 최적화가 필요한 팀: DeepSeek V3.2의 경우 MTok당 $0.42로 매우 경제적
- 다중 모델 통합이 필요한 팀: 단일 API 키로 GPT-4.1, Claude, Gemini, DeepSeek 모두 사용 가능
- 신속한 프로토타입 개발팀: 빠른 시작과 무료 크레딧으로 즉시 테스트 가능
- 중국의 AI 모델 접근이 필요한 팀: DeepSeek 등 중국 모델에 안정적으로 접근 가능
❌ HolySheep AI가 비적합한 팀
- 초저지연이 필수인 팀: 실시간 음성 인식처럼 50ms 이하 지연이 필요한 경우
- 완전한 자기 호스팅을 원하는 팀: 모든 인프라를 직접 제어하려는 경우
- 극단적 트래픽 볼륨의 팀: 월간 수십억 토큰을 처리하는 대규모 서비스
왜 HolySheep를 선택해야 하나
저는 여러 AI 릴레이 서비스를 테스트해 보며 다양한 문제점을 경험했습니다. 그 중 HolySheep AI가 특히 빛나는 장점은 다음과 같습니다:
- 신뢰할 수 있는 가용성: 99.9% 이상의 월간 가용성으로 프로덕션 환경에서도 안정적 운영 가능
- 로컬 결제 지원: 해외 신용카드 없이도 결제가 가능하여 초기 진입 장벽이 낮음
- 다중 모델 통합: 하나의 API 키로 다양한 모델을切り替갈 수 있어 관리 편의성 향상
- 경쟁력 있는 가격: DeepSeek V3.2는 MTok당 $0.42로 공식 대비 80% 이상 절감 가능
- 간편한 시작: 지금 가입하면 즉시 무료 크레딧을 받을 수 있음
AI 릴레이 서비스 가용성 모니터링方案
이제 실제 모니터링 시스템을 구현해 보겠습니다. HolySheep AI의 API를 기반으로 한 포괄적인 가용성 모니터링方案을 제공합니다.
1. 기본 헬스체크 모니터링
가장 기본이 되는 정기적인 헬스체크 구현입니다. 다음 Python 코드는 HolySheep AI의 다양한 엔드포인트 상태를 주기적으로 확인합니다.
import requests
import time
from datetime import datetime
from collections import defaultdict
class AI RelayHealthMonitor:
"""HolySheep AI 릴레이 서비스 가용성 모니터러"""
def __init__(self, api_key: str):
self.api_key = api_key
self.base_url = "https://api.holysheep.ai/v1"
self.health_history = defaultdict(list)
self.alert_threshold = 3 # 연속 실패 횟수
def check_endpoint_health(self, model: str = "gpt-4.1") -> dict:
"""개별 엔드포인트 상태 확인"""
headers = {
"Authorization": f"Bearer {self.api_key}",
"Content-Type": "application/json"
}
# 모델 목록 조회로 기본 연결 확인
start_time = time.time()
try:
response = requests.get(
f"{self.base_url}/models",
headers=headers,
timeout=10
)
latency = (time.time() - start_time) * 1000 # ms 단위
return {
"status": "healthy" if response.status_code == 200 else "degraded",
"latency_ms": round(latency, 2),
"status_code": response.status_code,
"timestamp": datetime.now().isoformat()
}
except requests.exceptions.Timeout:
return {
"status": "timeout",
"latency_ms": 10000,
"error": "Connection timeout",
"timestamp": datetime.now().isoformat()
}
except requests.exceptions.ConnectionError:
return {
"status": "unreachable",
"latency_ms": None,
"error": "Connection refused",
"timestamp": datetime.now().isoformat()
}
except Exception as e:
return {
"status": "error",
"latency_ms": None,
"error": str(e),
"timestamp": datetime.now().isoformat()
}
def test_chat_completion(self, model: str = "gpt-4.1") -> dict:
"""실제 채팅 완료 API 테스트"""
headers = {
"Authorization": f"Bearer {self.api_key}",
"Content-Type": "application/json"
}
payload = {
"model": model,
"messages": [{"role": "user", "content": "ping"}],
"max_tokens": 5
}
start_time = time.time()
try:
response = requests.post(
f"{self.base_url}/chat/completions",
headers=headers,
json=payload,
timeout=15
)
latency = (time.time() - start_time) * 1000
return {
"status": "healthy" if response.status_code == 200 else "failed",
"latency_ms": round(latency, 2),
"status_code": response.status_code,
"response_valid": response.status_code == 200,
"timestamp": datetime.now().isoformat()
}
except Exception as e:
return {
"status": "error",
"latency_ms": (time.time() - start_time) * 1000,
"error": str(e),
"timestamp": datetime.now().isoformat()
}
def run_monitoring_cycle(self) -> dict:
"""모니터링 사이클 실행"""
results = {
"endpoint_health": self.check_endpoint_health(),
"chat_completion": self.test_chat_completion(),
"summary": {}
}
# 요약 통계 계산
all_latencies = []
failure_count = 0
for check_name, result in results.items():
if isinstance(result, dict) and "latency_ms" in result:
if result["latency_ms"] is not None:
all_latencies.append(result["latency_ms"])
if result["status"] in ["unreachable", "timeout", "error"]:
failure_count += 1
results["summary"] = {
"average_latency_ms": round(sum(all_latencies) / len(all_latencies), 2) if all_latencies else None,
"failure_count": failure_count,
"overall_status": "healthy" if failure_count == 0 else "degraded" if failure_count == 1 else "critical"
}
# 히스토리 저장
self.health_history["latest"] = results
return results
사용 예시
monitor = AI RelayHealthMonitor(api_key="YOUR_HOLYSHEEP_API_KEY")
result = monitor.run_monitoring_cycle()
print(f"모니터링 결과: {result['summary']}")2. 실시간 장애 감지 및 알림 시스템
모니터링 결과를 바탕으로 장애 발생 시 즉시 알림을 받는 시스템을 구현합니다. 이 시스템은 HolySheep AI의 상태 변화를 실시간으로 감지하여 문제가 발생할 때 빠르게 대응할 수 있도록 합니다.
import requests
import time
import json
from datetime import datetime
from typing import Callable, List, Optional
import threading
class RealTimeFailureDetector:
"""실시간 장애 감지 및 알림 시스템"""
def __init__(self, api_key: str, webhook_url: Optional[str] = None):
self.api_key = api_key
self.base_url = "https://api.holysheep.ai/v1"
self.webhook_url = webhook_url
self.failure_history = []
self.consecutive_failures = 0
self.is_monitoring = False
self.callbacks: List[Callable] = []
# 임계값 설정
self.latency_threshold_ms = 5000 # 5초 이상 지연 시 경고
self.failure_threshold = 3 # 연속 3회 실패 시 장애로 판단
self.recovery_threshold = 5 # 연속 5회 성공 시 복구로 판단
def add_alert_callback(self, callback: Callable):
"""알림 콜백 등록"""
self.callbacks.append(callback)
def _send_webhook_alert(self, alert_type: str, message: str, data: dict):
"""웹훅으로 알림 전송"""
if not self.webhook_url:
return
payload = {
"alert_type": alert_type,
"message": message,
"timestamp": datetime.now().isoformat(),
"data": data
}
try:
requests.post(
self.webhook_url,
json=payload,
timeout=5
)
except Exception as e:
print(f"웹훅 전송 실패: {e}")
def _trigger_alerts(self, alert_type: str, message: str, data: dict):
"""모든 알림 채널에 알림 발송"""
# 콜백 실행
for callback in self.callbacks:
try:
callback(alert_type, message, data)
except Exception as e:
print(f"콜백 실행 실패: {e}")
# 웹훅 발송
self._send_webhook_alert(alert_type, message, data)
# 콘솔 로그
print(f"[{alert_type.upper()}] {message}")
def check_and_detect(self) -> dict:
"""상태 확인 및 장애 감지"""
headers = {
"Authorization": f"Bearer {self.api_key}",
"Content-Type": "application/json"
}
start_time = time.time()
check_result = {
"timestamp": datetime.now().isoformat(),
"latency_ms": None,
"success": False,
"error": None
}
try:
response = requests.get(
f"{self.base_url}/models",
headers=headers,
timeout=10
)
latency = (time.time() - start_time) * 1000
check_result["latency_ms"] = round(latency, 2)
if response.status_code == 200:
check_result["success"] = True
# 지연 시간 경고
if latency > self.latency_threshold_ms:
self._trigger_alerts(
"latency_warning",
f"지연 시간 초과: {latency:.2f}ms (임계값: {self.latency_threshold_ms}ms)",
check_result
)
# 장애 복구 감지
if self.consecutive_failures >= self.failure_threshold:
self.consecutive_failures = 0
self._trigger_alerts(
"service_recovered",
"AI 릴레이 서비스가 정상 복구되었습니다.",
check_result
)
else:
self.consecutive_failures += 1
check_result["error"] = f"HTTP {response.status_code}"
except requests.exceptions.Timeout:
self.consecutive_failures += 1
check_result["error"] = "Connection timeout"
except requests.exceptions.ConnectionError:
self.consecutive_failures += 1
check_result["error"] = "Connection refused"
except Exception as e:
self.consecutive_failures += 1
check_result["error"] = str(e)
# 장애 감지
if self.consecutive_failures == self.failure_threshold:
self._trigger_alerts(
"service_down",
f"AI 릴레이 서비스 장애 감지: 연속 {self.consecutive_failures}회 실패",
{"consecutive_failures": self.consecutive_failures}
)
# 히스토리 저장
self.failure_history.append(check_result)
if len(self.failure_history) > 1000:
self.failure_history = self.failure_history[-1000:]
return check_result
def start_monitoring(self, interval_seconds: int = 30):
"""지속적 모니터링 시작"""
self.is_monitoring = True
def monitor_loop():
while self.is_monitoring:
self.check_and_detect()
time.sleep(interval_seconds)
thread = threading.Thread(target=monitor_loop, daemon=True)
thread.start()
print(f"모니터링 시작: {interval_seconds}초 간격")
def stop_monitoring(self):
"""모니터링 중지"""
self.is_monitoring = False
print("모니터링 중지")
def get_uptime_stats(self) -> dict:
"""가동 시간 통계 반환"""
if not self.failure_history:
return {"total_checks": 0, "uptime_percentage": 100.0}
total = len(self.failure_history)
failures = sum(1 for h in self.failure_history if not h["success"])
return {
"total_checks": total,
"failures": failures,
"uptime_percentage": round(((total - failures) / total) * 100, 2),
"average_latency_ms": round(
sum(h["latency_ms"] for h in self.failure_history if h["latency_ms"]) /
sum(1 for h in self.failure_history if h["latency_ms"]), 2
) if any(h["latency_ms"] for h in self.failure_history) else None
}
사용 예시
def my_alert_handler(alert_type: str, message: str, data: dict):
"""사용자 정의 알림 처리"""
print(f"🚨 [{alert_type}] {message}")
# 이메일 발송, 슬랙 메시지 등 추가 가능
detector = RealTimeFailureDetector(
api_key="YOUR_HOLYSHEEP_API_KEY",
webhook_url="https://your-webhook-endpoint.com/alerts"
)
detector.add_alert_callback(my_alert_handler)
detector.start_monitoring(interval_seconds=30)3. 자동 장애 복구 및 페일오버 시스템
장애 발생 시 자동으로 다른 서비스로 전환되는 페일오버 시스템을 구현합니다. HolySheep AI에 문제가 발생할 경우를 대비하여 대안적 접근 방식을 제공합니다.
import requests
import time
from datetime import datetime
from typing import List, Dict, Optional
from enum import Enum
class ServiceStatus(Enum):
HEALTHY = "healthy"
DEGRADED = "degraded"
UNHEALTHY = "unhealthy"
UNKNOWN = "unknown"
class AIFailoverManager:
"""AI 서비스 자동 장애 복구 및 페일오버 관리자"""
def __init__(self):
self.services: List[Dict] = []
self.current_index = 0
self.health_records: Dict[str, List[Dict]] = {}
def add_service(self, name: str, api_key: str, base_url: str, priority: int = 1):
"""서비스 추가"""
self.services.append({
"name": name,
"api_key": api_key,
"base_url": base_url,
"priority": priority,
"status": ServiceStatus.UNKNOWN
})
self.services.sort(key=lambda x: x["priority"], reverse=True)
self.health_records[name] = []
def check_service_health(self, service: Dict, timeout: int = 10) -> Dict:
"""개별 서비스 상태 확인"""
start_time = time.time()
try:
headers = {
"Authorization": f"Bearer {service['api_key']}",
"Content-Type": "application/json"
}
response = requests.get(
f"{service['base_url']}/models",
headers=headers,
timeout=timeout
)
latency = (time.time() - start_time) * 1000
if response.status_code == 200:
status = ServiceStatus.HEALTHY if latency < 3000 else ServiceStatus.DEGRADED
else:
status = ServiceStatus.UNHEALTHY
return {
"name": service["name"],
"status": status,
"latency_ms": round(latency, 2),
"timestamp": datetime.now().isoformat(),
"reachable": True
}
except requests.exceptions.Timeout:
return {
"name": service["name"],
"status": ServiceStatus.UNHEALTHY,
"latency_ms": timeout * 1000,
"timestamp": datetime.now().isoformat(),
"reachable": False,
"error": "Timeout"
}
except Exception as e:
return {
"name": service["name"],
"status": ServiceStatus.UNHEALTHY,
"latency_ms": None,
"timestamp": datetime.now().isoformat(),
"reachable": False,
"error": str(e)
}
def check_all_services(self) -> List[Dict]:
"""모든 서비스 상태 확인"""
results = []
for service in self.services:
health = self.check_service_health(service)
service["status"] = health["status"]
results.append(health)
self.health_records[service["name"]].append(health)
# 최근 100개 기록만 유지
if len(self.health_records[service["name"]]) > 100:
self.health_records[service["name"]] = self.health_records[service["name"]][-100:]
return results
def get_best_available_service(self) -> Optional[Dict]:
"""가장 상태가 좋은 서비스 반환"""
healthy_services = [
s for s in self.services
if s["status"] in [ServiceStatus.HEALTHY, ServiceStatus.DEGRADED]
]
if not healthy_services:
return None
# 지연 시간이 가장 짧은 서비스 선택
return min(healthy_services, key=lambda x: x["status"].value)
def make_request(self, payload: dict, model: str = "gpt-4.1") -> Dict:
"""서비스에 요청 - 자동 페일오버 포함"""
attempts = 0
max_attempts = len(self.services)
while attempts < max_attempts:
service = self.get_best_available_service()
if not service:
return {
"success": False,
"error": "모든 서비스가 사용 불가능합니다.",
"attempts": attempts
}
attempts += 1
try:
headers = {
"Authorization": f"Bearer {service['api_key']}",
"Content-Type": "application/json"
}
response = requests.post(
f"{service['base_url']}/chat/completions",
headers=headers,
json={**payload, "model": model},
timeout=30
)
if response.status_code == 200:
return {
"success": True,
"response": response.json(),
"service_used": service["name"],
"attempts": attempts
}
else:
# 응답 실패 시 다음 서비스 시도
service["status"] = ServiceStatus.UNHEALTHY
print(f"[{service['name']}] 응답 실패: {response.status_code}, 다음 서비스 시도...")
except Exception as e:
service["status"] = ServiceStatus.UNHEALTHY
print(f"[{service['name']}] 연결 실패: {e}, 다음 서비스 시도...")
return {
"success": False,
"error": "모든 서비스 연결 실패",
"attempts": attempts
}
def get_uptime_report(self) -> Dict:
"""가동 시간 보고서 생성"""
report = {}
for name, records in self.health_records.items():
if not records:
continue
total = len(records)
healthy = sum(1 for r in records if r["status"] == ServiceStatus.HEALTHY)
degraded = sum(1 for r in records if r["status"] == ServiceStatus.DEGRADED)
latencies = [r["latency_ms"] for r in records if r["latency_ms"]]
report[name] = {
"total_checks": total,
"healthy_count": healthy,
"degraded_count": degraded,
"unhealthy_count": total - healthy - degraded,
"uptime_percentage": round((healthy / total) * 100, 2),
"average_latency_ms": round(sum(latencies) / len(latencies), 2) if latencies else None,
"min_latency_ms": min(latencies) if latencies else None,
"max_latency_ms": max(latencies) if latencies else None
}
return report
사용 예시
failover_manager = AIFailoverManager()
HolySheep AI 추가 (우선순위 1)
failover_manager.add_service(
name="HolySheep AI",
api_key="YOUR_HOLYSHEEP_API_KEY",
base_url="https://api.holysheep.ai/v1",
priority=1
)
백업 서비스 추가 (우선순위 2)
failover_manager.add_service(
name="Backup Service",
api_key="YOUR_BACKUP_API_KEY",
base_url="https://backup-api.example.com/v1",
priority=2
)
모든 서비스 상태 확인
health_status = failover_manager.check_all_services()
print("서비스 상태:", health_status)
요청 실행 (자동 페일오버)
request_payload = {
"messages": [{"role": "user", "content": "안녕하세요"}],
"max_tokens": 100
}
result = failover_manager.make_request(request_payload)
print("요청 결과:", result)
가동 시간 보고서
report = failover_manager.get_uptime_report()
print("가동 시간 보고서:", report)가격과 ROI
| 모델 | HolySheep AI | 공식 API | 비용 절감 |
|---|---|---|---|
| DeepSeek V3.2 | $0.42/MTok | $0.27/MTok | 해외 결제 불필요 + 간편 통합 |
| GPT-4.1 | $8.00/MTok | $15.00/MTok | 약 47% 절감 |
| Claude Sonnet 4.5 | $15.00/MTok | $15.00/MTok | 동일 + 로컬 결제 |
| Gemini 2.5 Flash | $2.50/MTok | $2.50/MTok | 동일 + 통합 관리 |
ROI 분석
저의 실제 프로젝트 기준으로 ROI를 계산해 보겠습니다:
- 월간 사용량 10M 토큰 (DeepSeek V3.2 사용 시):
- HolySheep AI: $4.20/월
- 공식 API 해외 결제: 환전+수수료 포함 약 $5.00/월
- 비용 절감: 약 16%
- 월간 사용량 100M 토큰 (GPT-4.1 사용 시):
- HolySheep AI: $800/월
- 공식 API: $1,500/월
- 비용 절감: $700/월 (연 $8,400)
특히 HolySheep AI의 모니터링 도구와 자동 페일오버 시스템을 활용하면 서비스 장애로 인한经济损失을 최소화할 수 있어 실질적 ROI는 더욱 높아집니다.
자주 발생하는 오류 해결
오류 1: Connection Timeout
# 문제: requests.exceptions.Timeout - 연결 시간 초과
해결: 타임아웃 값 조정 및 재시도 로직 구현
import requests
from requests.adapters import HTTPAdapter
from urllib3.util.retry import Retry
def create_resilient_session():
"""탄력적 세션 생성"""
session = requests.Session()
retry_strategy = Retry(
total=3,
backoff_factor=1,
status_forcelist=[429, 500, 502, 503, 504],
)
adapter = HTTPAdapter(max_retries=retry_strategy)
session.mount("https://", adapter)
session.mount("http://", adapter)
return session
def resilient_request(api_key: str, base_url: str, payload: dict):
"""탄력적 API 요청"""
headers = {
"Authorization": f"Bearer {api_key}",
"Content-Type": "application/json"
}
session = create_resilient_session()
try:
response = session.post(
f"{base_url}/chat/completions",
headers=headers,
json=payload,
timeout=(10, 30) # (연결 타임아웃, 읽기 타임아웃)
)
response.raise_for_status()
return response.json()
except requests.exceptions.Timeout:
print("연결 시간 초과 - 재시도 횟수 초과")
return None
except requests.exceptions.ConnectionError as e:
print(f"연결 오류: {e}")
return None
사용
result = resilient_request(
api_key="YOUR_HOLYSHEEP_API_KEY",
base_url="https://api.holysheep.ai/v1",
payload={"model": "gpt-4.1", "messages": [{"role": "user", "content": "test"}], "max_tokens": 10}
)오류 2: Invalid API Key
# 문제: HTTP 401 Unauthorized - API 키 인증 실패
해결: API 키 유효성 검사 및 포맷 검증
def validate_and_format_api_key(api_key: str) -> str:
"""API 키 검증 및 포맷 정리"""
if not api_key:
raise ValueError("API 키가 제공되지 않았습니다.")
# 불필요한 공백 제거
api_key = api_key.strip()
# sk- 또는 HolySheep- 접두사 확인
if not api_key.startswith("sk-") and not api_key.startswith("HolySheep-"):
# HolySheep AI 형식으로 자동 변환
api_key = f"sk-{api_key}"
# 길이 검증
if len(api_key) < 20:
raise ValueError(f"API 키 길이가 너무 짧습니다: {len(api_key)}자")
return api_key
def test_api_key(api_key: str, base_url: str = "https://api.holysheep.ai/v1") -> dict:
"""API 키 유효성 테스트"""
headers = {
"Authorization": f"Bearer {api_key}",
"Content-Type": "application/json"
}
try:
response = requests.get(
f"{base_url}/models",
headers=headers,
timeout=5
)
if response.status_code == 401:
return {
"valid": False,
"error": "API 키가 유효하지 않습니다. HolySheep AI 대시보드에서 확인하세요."
}
elif response.status_code == 200:
return {
"valid": True,
"available_models": [m["id"] for m in response.json().get("data", [])]
}
else:
return {
"valid": False,
"error": f"예상치 못한 응답: {response.status_code}"
}
except Exception as e:
return {
"valid": False,
"error": str(e)
}
사용
try:
formatted_key = validate_and_format_api_key("YOUR_HOLYSHEEP_API_KEY")
test_result = test_api_key(formatted_key)
print(f"API 키 테스트 결과: {test_result}")
except ValueError as e:
print(f"API 키 오류: {e}")오류 3: Rate LimitExceeded
# 문제: HTTP 429 Too Many Requests - 요청 제한 초과
해결: 지수 백오프를 활용한 자동 재시도
import time
import requests
from datetime import datetime, timedelta
class RateLimitHandler:
"""요청 제한 처리기"""
def __init__(self):
self.rate_limit_remaining = None
self.rate_limit_reset = None
self.retry_after = 60 # 기본 재시 대기 시간
def execute_with_rate_limit_handling(
self,
api_key: str,
base_url: str,
payload: dict,
max_retries: int = 5
) -> dict:
"""Rate Limit 처리와 함께 요청 실행"""
headers = {
"Authorization": f"Bearer {api_key}",
"Content-Type": "application/json"
}
for attempt in range(max_retries):
try:
response = requests.post(
f"{base_url}/chat/completions",
headers=headers,
json=payload,
timeout=30
)
# Rate Limit 확인
if response.status_code == 429:
# Retry-After 헤더 확인
retry_after = response.headers.get('Retry-After')
if retry_after:
wait_time = int(retry_after)
else:
# 지수 백오프 계산
wait_time = min(2 ** attempt * 2, 60)
print(f"Rate Limit 도달. {wait_time}초 후 재시도 ({attempt + 1}/{max_retries})")
time.sleep(wait_time)
continue
# 성공적인 응답
if response.status_code == 200:
# Rate Limit 정보 저장
self.rate_limit_remaining = response.headers.get('X-RateLimit-Remaining')
self.rate_limit_reset = response.headers.get('X-RateLimit-Reset')
return {
"success": True,
"data": response.json(),
"attempts": attempt + 1
}
# 기타 오류
return {
"success": False,
"error": f"HTTP {response.status_code}: {response.text}",
"attempts": attempt + 1
}
except requests.exceptions.RequestException as e:
if attempt < max_retries - 1:
wait_time = 2 ** attempt
print(f"요청 오류: {e}. {wait_time}초 후 재시도...")
time.sleep(wait_time)
else:
return {
"success": False,
"error": str(e),
"att