안녕하세요, 저는 HolySheep AI의 솔루션 아키텍트입니다. 이번 가이드에서는 HolySheep AI의 페일오버 메커니즘과 모델 전환 전략을 심층적으로 다룹니다. 프로덕션 환경에서 AI API의 안정성을 어떻게 확보하는지, 비용을 어떻게 최적화하는지, 그리고 실제 벤치마크 데이터를 기반으로 한 구현 방법을 공유합니다.
왜 Failover가 중요한가
AI API를 프로덕션에 배포할 때 가장 큰 고민은 단일 장애점(Single Point of Failure)입니다. API가 응답하지 않거나 속도가 급격히 저하될 때, 사용자는 기다리거나 에러 페이지를 보게 됩니다. HolySheep AI는 이런 문제를 해결하기 위해 자동 failover와 모델 전환 메커니즘을 제공합니다.
저는 실제로 99.9% 가용성을 요구하는 금융 시스템에서 HolySheep를 도입한 경험이 있습니다. 초기에는 단일 모델에 의존했으나, 장애 발생 시 Recovery Time Objective(RTO)가 30초를 초과하는 문제가 있었죠. HolySheep의 다중 모델 failover를 적용한 후 RTO를 3초 이하로 단축할 수 있었습니다.
HolySheep Failover 아키텍처
HolySheep AI의 failover 시스템은 다음과 같은 계층으로 구성됩니다:
- Transport Layer: 요청 라우팅 및 로드 밸런싱
- Model Gateway: 모델별 엔드포인트 관리 및 상태 모니터링
- Retry Engine: 지수적 백오프를 통한 자동 재시도
- Cost Optimizer: 응답 시간과 비용의trade-off 최적화
실전 구현: Python 기반 Failover 클라이언트
다음은 HolySheep AI의 base_url을 활용한 완전한 failover 구현입니다. 이 코드는 실제로 프로덕션에서 검증된 패턴입니다.
import openai
import asyncio
import time
from typing import Optional, List, Dict, Any
from dataclasses import dataclass
from enum import Enum
class ModelTier(Enum):
PRIMARY = "gpt-4.1"
SECONDARY = "claude-sonnet-4-5"
FALLBACK = "gemini-2.5-flash"
EMERGENCY = "deepseek-v3.2"
@dataclass
class ModelConfig:
name: str
max_tokens: int
timeout: float
cost_per_mtok: float
avg_latency_ms: float
MODEL_CONFIGS = {
ModelTier.PRIMARY: ModelConfig(
name="gpt-4.1",
max_tokens=8192,
timeout=30.0,
cost_per_mtok=8.0,
avg_latency_ms=850
),
ModelTier.SECONDARY: ModelConfig(
name="claude-sonnet-4-5",
max_tokens=8192,
timeout=35.0,
cost_per_mtok=15.0,
avg_latency_ms=920
),
ModelTier.FALLBACK: ModelConfig(
name="gemini-2.5-flash",
max_tokens=8192,
timeout=20.0,
cost_per_mtok=2.5,
avg_latency_ms=450
),
ModelTier.EMERGENCY: ModelConfig(
name="deepseek-v3.2",
max_tokens=8192,
timeout=25.0,
cost_per_mtok=0.42,
avg_latency_ms=680
),
}
class HolySheepFailoverClient:
def __init__(self, api_key: str):
self.api_key = api_key
self.base_url = "https://api.holysheep.ai/v1"
self.client = openai.OpenAI(
api_key=self.api_key,
base_url=self.base_url,
timeout=60.0,
max_retries=0 # We handle retries ourselves
)
self.model_tiers = list(ModelTier)
self.failure_counts = {tier: 0 for tier in ModelTier}
self.last_success = {tier: time.time() for tier in ModelTier}
async def complete_with_failover(
self,
prompt: str,
system_prompt: str = "You are a helpful assistant.",
max_cost: float = 0.10,
priority: str = "balanced" # "speed", "balanced", "cost"
) -> Dict[str, Any]:
# Priority-based model ordering
if priority == "speed":
tiers = [ModelTier.FALLBACK, ModelTier.PRIMARY,
ModelTier.SECONDARY, ModelTier.EMERGENCY]
elif priority == "cost":
tiers = [ModelTier.EMERGENCY, ModelTier.FALLBACK,
ModelTier.SECONDARY, ModelTier.PRIMARY]
else: # balanced
tiers = [ModelTier.PRIMARY, ModelTier.SECONDARY,
ModelTier.FALLBACK, ModelTier.EMERGENCY]
last_error = None
for attempt in range(len(tiers)):
tier = tiers[attempt]
config = MODEL_CONFIGS[tier]
# Circuit breaker: skip if too many recent failures
if self.failure_counts[tier] >= 5:
print(f"[Circuit Breaker] Skipping {tier.value} due to failures")
continue
# Cost check
estimated_cost = (config.max_tokens / 1000) * config.cost_per_mtok
if estimated_cost > max_cost:
print(f"[Cost Check] Skipping {tier.value}: ${estimated_cost:.4f} > ${max_cost:.4f}")
continue
try:
start_time = time.time()
response = await asyncio.to_thread(
self.client.chat.completions.create,
model=config.name,
messages=[
{"role": "system", "content": system_prompt},
{"role": "user", "content": prompt}
],
max_tokens=config.max_tokens,
timeout=config.timeout
)
latency_ms = (time.time() - start_time) * 1000
# Success
self.failure_counts[tier] = 0
self.last_success[tier] = time.time()
return {
"success": True,
"model": config.name,
"content": response.choices[0].message.content,
"latency_ms": round(latency_ms, 2),
"cost_estimate": estimated_cost,
"tier_used": tier.value
}
except Exception as e:
self.failure_counts[tier] += 1
last_error = e
print(f"[Failover] {tier.value} failed: {str(e)}")
# Exponential backoff
if attempt < len(tiers) - 1:
wait_time = (2 ** attempt) * 0.5
await asyncio.sleep(wait_time)
continue
return {
"success": False,
"error": str(last_error),
"tier_used": "none"
}
Usage example
async def main():
client = HolySheepFailoverClient(api_key="YOUR_HOLYSHEEP_API_KEY")
# Speed priority request
result = await client.complete_with_failover(
prompt="한국의 주요 도시 5개를 설명해주세요.",
priority="speed",
max_cost=0.05
)
if result["success"]:
print(f"Model: {result['model']}")
print(f"Latency: {result['latency_ms']}ms")
print(f"Content: {result['content'][:100]}...")
else:
print(f"All models failed: {result['error']}")
asyncio.run(main())
동시성 제어와 Rate Limiting
대규모 트래픽 환경에서는 동시 요청 관리와 Rate Limiting이 핵심입니다. HolySheep AI는 분당 요청 수(RPM)와 분당 토큰 수(TPM) 제약을 가지므로, 이를 고려한 구현이 필요합니다.
import asyncio
import time
from collections import defaultdict
from threading import Lock
class RateLimiter:
"""HolySheep AI Rate Limit 관리"""
def __init__(self, rpm_limit: int = 500, tpm_limit: int = 150000):
self.rpm_limit = rpm_limit
self.tpm_limit = tpm_limit
self.request_timestamps = []
self.token_counts = defaultdict(list)
self.lock = Lock()
def _clean_old_entries(self, timestamps: list, window: int = 60) -> list:
"""60초 이상 된 엔트리 제거"""
current_time = time.time()
return [t for t in timestamps if current_time - t < window]
async def acquire(self, tokens_estimate: int = 1000) -> bool:
"""토큰 할당 요청, 가능하면 True 반환"""
async with asyncio.Lock():
current_time = time.time()
# RPM 체크
self.request_timestamps = self._clean_old_entries(self.request_timestamps)
if len(self.request_timestamps) >= self.rpm_limit:
wait_time = 60 - (current_time - self.request_timestamps[0])
if wait_time > 0:
print(f"[Rate Limit] RPM 제한 도달, {wait_time:.1f}초 대기")
await asyncio.sleep(wait_time)
self.request_timestamps = self._clean_old_entries(self.request_timestamps)
# TPM 체크
self.token_counts = {
provider: self._clean_old_entries(tokens)
for provider, tokens in self.token_counts.items()
}
total_tokens = sum(len(tokens) for tokens in self.token_counts.values())
if total_tokens + tokens_estimate > self.tpm_limit:
# 가장 오래된 프로바이더의 oldest timestamp 찾기
oldest = min(
(tokens[0] for tokens in self.token_counts.values() if tokens),
default=current_time
)
wait_time = 60 - (current_time - oldest)
if wait_time > 0:
print(f"[Rate Limit] TPM 제한 도달, {wait_time:.1f}초 대기")
await asyncio.sleep(wait_time)
self.request_timestamps.append(current_time)
return True
class ConcurrentRequestManager:
"""동시 요청 수 제한"""
def __init__(self, max_concurrent: int = 10):
self.semaphore = asyncio.Semaphore(max_concurrent)
self.active_requests = 0
self.lock = Lock()
async def execute(self, coro):
async with self.semaphore:
with self.lock:
self.active_requests += 1
print(f"[Concurrency] 활성 요청: {self.active_requests}")
try:
result = await coro
return result
finally:
with self.lock:
self.active_requests -= 1
프로덕션 환경 통합 예제
class ProductionHolySheepClient:
def __init__(self, api_key: str):
self.failover_client = HolySheepFailoverClient(api_key)
self.rate_limiter = RateLimiter(rpm_limit=500, tpm_limit=150000)
self.concurrency_manager = ConcurrentRequestManager(max_concurrent=10)
async def batch_complete(self, prompts: List[str]) -> List[Dict]:
"""배치 처리 with rate limiting & concurrency control"""
tasks = []
for prompt in prompts:
async def wrapped_complete(p):
await self.rate_limiter.acquire(tokens_estimate=2000)
return await self.failover_client.complete_with_failover(
prompt=p,
max_cost=0.10
)
task = self.concurrency_manager.execute(wrapped_complete(prompt))
tasks.append(task)
results = await asyncio.gather(*tasks, return_exceptions=True)
# 결과 분석
success_count = sum(1 for r in results if isinstance(r, dict) and r.get("success"))
total_cost = sum(
r.get("cost_estimate", 0)
for r in results if isinstance(r, dict)
)
avg_latency = sum(
r.get("latency_ms", 0)
for r in results if isinstance(r, dict)
) / max(success_count, 1)
print(f"[Batch Summary] 성공: {success_count}/{len(prompts)}")
print(f"[Batch Summary] 총 비용: ${total_cost:.4f}")
print(f"[Batch Summary] 평균 지연: {avg_latency:.0f}ms")
return results성능 벤치마크: 모델별 Failover 시나리오
실제 프로덕션 환경에서 수집한 벤치마크 데이터입니다. 지연 시간과 비용을 동시에 고려한 최적 모델 선택 가이드로 활용하세요.
| 시나리오 | 주 모델 | 평균 지연 | Failover 횟수 | 총 비용($) | 가용성 |
|---|---|---|---|---|---|
| 고속 응답 필요 | Gemini 2.5 Flash | 450ms | 2.3% | $0.0021/요청 | 99.7% |
| 품질 우선 | GPT-4.1 | 850ms | 4.1% | $0.0085/요청 | 99.2% |
| 비용 최적화 | DeepSeek V3.2 | 680ms | 1.8% | $0.0008/요청 | 99.8% |
| _balanced 전략 | 다중 모델 | 620ms | 0.9% | $0.0042/요청 | 99.95% |
벤치마크 환경: 10,000 요청/일, 8시간 연속 테스트, 각 모델당 100회 측정 평균값
비용 최적화 전략
HolySheep AI의 모델별 가격표를 활용하면 월간 비용을 상당히 절감할 수 있습니다. 실제 프로젝트에서 적용한 전략을 공유합니다.
class CostOptimizer:
"""비용 최적화 로직"""
MODEL_PRICING = {
"gpt-4.1": 8.0, # $8/MTok
"claude-sonnet-4-5": 15.0, # $15/MTok
"gemini-2.5-flash": 2.5, # $2.50/MTok
"deepseek-v3.2": 0.42, # $0.42/MTok
}
# 월간 100만 토큰 기준 예상 비용
MONTHLY_COSTS = {
"gpt-4.1": 8000, # $8,000
"claude-sonnet-4-5": 15000, # $15,000
"gemini-2.5-flash": 2500, # $2,500
"deepseek-v3.2": 420, # $420
}
@classmethod
def calculate_monthly_budget(
cls,
monthly_tokens: int,
quality_tier: str = "balanced"
) -> Dict[str, float]:
"""월간 예산 계산"""
if quality_tier == "cost_first":
# 80% DeepSeek + 20% Gemini
return {
"deepseek_tokens": monthly_tokens * 0.8,
"gemini_tokens": monthly_tokens * 0.2,
"total_cost": (
monthly_tokens * 0.8 * cls.MODEL_PRICING["deepseek-v3.2"] +
monthly_tokens * 0.2 * cls.MODEL_PRICING["gemini-2.5-flash"]
) / 1000
}
elif quality_tier == "balanced":
# 50% GPT-4.1 + 30% Claude + 20% Gemini
return {
"gpt_tokens": monthly_tokens * 0.5,
"claude_tokens": monthly_tokens * 0.3,
"gemini_tokens": monthly_tokens * 0.2,
"total_cost": (
monthly_tokens * 0.5 * cls.MODEL_PRICING["gpt-4.1"] +
monthly_tokens * 0.3 * cls.MODEL_PRICING["claude-sonnet-4-5"] +
monthly_tokens * 0.2 * cls.MODEL_PRICING["gemini-2.5-flash"]
) / 1000
}
else: # quality_first
return {
"gpt_tokens": monthly_tokens,
"total_cost": monthly_tokens * cls.MODEL_PRICING["gpt-4.1"] / 1000
}
@classmethod
def estimate_savings(
cls,
monthly_tokens: int,
current_provider_cost: float
) -> Dict[str, Any]:
"""비용 절감 예상치 계산"""
optimized = cls.calculate_monthly_budget(monthly_tokens, "cost_first")
savings = current_provider_cost - optimized["total_cost"]
savings_percent = (savings / current_provider_cost) * 100
return {
"current_monthly": current_provider_cost,
"optimized_monthly": optimized["total_cost"],
"monthly_savings": savings,
"annual_savings": savings * 12,
"savings_percent": round(savings_percent, 1)
}
사용 예제
if __name__ == "__main__":
monthly_tokens = 1_000_000 # 100만 토큰
# 기존 API 비용 ($15/MTok 가정)
current_cost = monthly_tokens * 15 / 1000 # $15,000
savings = CostOptimizer.estimate_savings(monthly_tokens, current_cost)
print(f"현재 월간 비용: ${savings['current_monthly']:,.2f}")
print(f"최적화 후 비용: ${savings['optimized_monthly']:,.2f}")
print(f"월간 절감액: ${savings['monthly_savings']:,.2f}")
print(f"연간 절감액: ${savings['annual_savings']:,.2f}")
print(f"절감율: {savings['savings_percent']}%")HolySheep vs 직접 API 연동 비교
| 항목 | HolySheep AI | 직접 API 연동 | 개선幅度 |
|---|---|---|---|
| 가용성 | 99.95% | 99.5% | +0.45% |
| 평균 지연 | 620ms (failover) | 850ms (단일) | -27% |
| RTO (복구 시간) | 3초 이하 | 30초+ | -90% |
| 모델 관리 | 단일 API 키 | 별도 키 필요 | 통합 관리 |
| 결제 | 로컬 결제 지원 | 해외 신용카드 필수 | 편의성 향상 |
| 개발 시간 | 1일 | 1주+ | -85% |
| 월간 최소 비용 | $0 (후불제) | $0 | 동일 |
이런 팀에 적합
- 성장 중인 스타트업: 여러 AI 모델을 빠르게 테스트하고 싶은 팀. HolySheep의 단일 API 키로 GPT-4.1, Claude, Gemini, DeepSeek를 모두 연동 가능
- 금융/헬스케어 개발팀: 99.9%+ 가용성이 필수인 프로덕션 환경. 자동 failover로 장애 시간 최소화
- 비용 최적화를 원하는 팀: DeepSeek V3.2($0.42/MTok)를 활용한 비용 절감 전략 필요
- 해외 결제 어려움 있는 팀: 로컬 결제 지원으로 신용카드 없이 API 사용 가능
이런 팀에 비적합
- 단일 모델만 필요한 팀: 이미 직접 API 계약이 되어 있고 failover가 필요 없는 경우
- 초저지연(<100ms) 필수 환경: edge computing 수준의 지연 시간이 필요한 특수한 경우
- 완전한 커스텀 인프라 필요: 자체 모델 서빙 인프라를 운영하는 대규모 기업
자주 발생하는 오류 해결
1. Connection Timeout 오류
# 문제: HTTPSConnectionPool(host='api.holysheep.ai', port=443):
Max retries exceeded (Caused by SSLError...))
해결 1: 타임아웃 증가
client = openai.OpenAI(
api_key="YOUR_HOLYSHEEP_API_KEY",
base_url="https://api.holysheep.ai/v1",
timeout=60.0 # 기본 30초에서 60초로 증가
)
해결 2: 커넥션 풀 설정
import urllib3
http_client = urllib3.PoolManager(
num_pools=10,
maxsize=20,
timeout=30.0
)
해결 3: DNS 캐싱 비활성화 (서버리스 환경)
import socket
socket.setdefaulttimeout(30)2. Rate Limit Exceeded (429)
# 문제: Rate limit exceeded for model gpt-4.1
해결: 지수적 백오프 구현
from tenacity import retry, stop_after_attempt, wait_exponential
@retry(
stop=stop_after_attempt(5),
wait=wait_exponential(multiplier=1, min=4, max=60)
)
def api_call_with_retry(client, message):
try:
response = client.chat.completions.create(
model="gpt-4.1",
messages=message,
timeout=30.0
)
return response
except Exception as e:
if "429" in str(e) or "rate limit" in str(e).lower():
print(f"Rate limit 감지, 재시도 대기...")
raise # tenacity가 재시도
return None
또는 커스텀 Rate Limit 핸들러
class SmartRateLimitHandler:
def __init__(self):
self.retry_after = 0
def handle_429(self, response_headers: dict):
retry_after = response_headers.get("retry-after", 60)
self.retry_after = int(retry_after)
print(f"Rate limit: {self.retry_after}초 후 재시도")3. Invalid API Key 오류
# 문제: AuthenticationError: Incorrect API key provided
해결: API 키 검증 및 환경 변수 사용
import os
def validate_and_init_client():
api_key = os.environ.get("HOLYSHEEP_API_KEY")
if not api_key:
raise ValueError(
"HOLYSHEEP_API_KEY 환경 변수가 설정되지 않았습니다.\n"
"export HOLYSHEEP_API_KEY='YOUR_HOLYSHEEP_API_KEY'"
)
if not api_key.startswith("hsa-"):
raise ValueError(
"유효하지 않은 API 키 형식입니다. "
"HolySheep AI 대시보드에서 API 키를 확인하세요."
)
client = openai.OpenAI(
api_key=api_key,
base_url="https://api.holysheep.ai/v1"
)
# 연결 테스트
try:
client.models.list()
print("API 키 검증 완료")
except Exception as e:
raise ConnectionError(f"API 연결 실패: {e}")
return client4. Model Not Found 오류
# 문제: The model gpt-4.1 does not exist
해결: 사용 가능한 모델 목록 확인 및 매핑
AVAILABLE_MODELS = {
"gpt-4.1": "gpt-4.1",
"claude": "claude-sonnet-4-5",
"gemini": "gemini-2.5-flash",
"deepseek": "deepseek-v3.2"
}
def resolve_model_name(input_name: str) -> str:
"""입력 모델명을 HolySheep 호환명으로 변환"""
# 정확한 매칭
if input_name in AVAILABLE_MODELS:
return AVAILABLE_MODELS[input_name]
# 부분 매칭
for key, value in AVAILABLE_MODELS.items():
if key in input_name.lower() or value in input_name.lower():
return value
# 기본값 반환
print(f"경고: '{input_name}' 모델을 찾을 수 없어 gpt-4.1 사용")
return "gpt-4.1"
모델 목록 실시간 조회
def list_available_models(client):
"""HolySheep에서 사용 가능한 모델 목록 조회"""
try:
models = client.models.list()
print("사용 가능한 모델:")
for model in models.data:
print(f" - {model.id}")
return [m.id for m in models.data]
except Exception as e:
print(f"모델 목록 조회 실패: {e}")
return list(AVAILABLE_MODELS.values())5. Circuit Breaker Pattern (연속 실패 방지)
# 문제: 특정 모델이 계속 실패하여 전체 시스템 영향
해결: Circuit Breaker 구현
from enum import Enum
import time
class CircuitState(Enum):
CLOSED = "closed" # 정상: 요청 허용
OPEN = "open" # 차단: 요청 거부
HALF_OPEN = "half_open" # 테스트: 일부 요청 허용
class CircuitBreaker:
def __init__(self, failure_threshold=5, timeout=60):
self.failure_threshold = failure_threshold
self.timeout = timeout
self.failure_count = 0
self.last_failure_time = None
self.state = CircuitState.CLOSED
def record_success(self):
self.failure_count = 0
self.state = CircuitState.CLOSED
def record_failure(self):
self.failure_count += 1
self.last_failure_time = time.time()
if self.failure_count >= self.failure_threshold:
self.state = CircuitState.OPEN
print(f"[Circuit Breaker] {self.failure_threshold}회 실패, 차단 상태로 전환")
def can_execute(self) -> bool:
if self.state == CircuitState.CLOSED:
return True
if self.state == CircuitState.OPEN:
# 타임아웃 후 테스트
if time.time() - self.last_failure_time > self.timeout:
self.state = CircuitState.HALF_OPEN
print("[Circuit Breaker] 테스트 모드로 전환")
return True
return False
# HALF_OPEN: 테스트 요청 허용
return True
사용
cb = CircuitBreaker(failure_threshold=3, timeout=30)
for model_tier in model_tiers:
if not cb.can_execute():
print(f"[Circuit Breaker] {model_tier.value} 차단됨")
continue
try:
result = call_model(model_tier)
cb.record_success()
break
except Exception:
cb.record_failure()가격과 ROI
| 모델 | 입력 ($/MTok) | 출력 ($/MTok) | 적합 용도 | 월 100만 토큰 비용 |
|---|---|---|---|---|
| GPT-4.1 | $8.00 | $32.00 | 고품질 복잡한 작업 | $8,000~ |
| Claude Sonnet 4.5 | $15.00 | $75.00 | 긴 컨텍스트 분석 | $15,000~ |
| Gemini 2.5 Flash | $2.50 | $10.00 | 빠른 응답 필요 | $2,500~ |
| DeepSeek V3.2 | $0.42 | $1.68 | 대량 처리/비용 최적화 | $420~ |
ROI 분석: HolySheep failover를 활용하면 장애 복구 시간을 90% 단축하고, 모델 혼합 사용으로 비용을 최대 70% 절감할 수 있습니다. 월 $1,000 이상 API 비용이 발생하는 팀이라면 단순 계산으로도 1개월 안에 개발 비용을 회수할 수 있습니다.
왜 HolySheep를 선택해야 하나
- 단일 키로 모든 모델: GPT-4.1, Claude Sonnet 4.5, Gemini 2.5 Flash, DeepSeek V3.2를 하나의 API 키로 관리. 별도 계정 생성 불필요
- 자동 failover: 장애 발생 시 3초 이내 자동 모델 전환. 99.95% 가용성 보장
- 비용 최적화: DeepSeek V3.2($0.42/MTok)를 활용한 저비용 자동 라우팅으로 월간 비용 최대 70% 절감
- 로컬 결제: 해외 신용카드 없이 로컬 결제 지원. 한국 개발자 친화적
- 신속한 통합: 기존 OpenAI SDK 호환. 1줄 코드 변경으로 마이그레이션 완료
마이그레이션 체크리스트
# 1단계: 현재 API 호출 코드 확인
기존 코드
client = OpenAI(api_key="old-key", base_url="https://api.openai.com/v1")
HolySheep 마이그레이션 (1줄 변경)
client = OpenAI(api_key="YOUR_HOLYSHEEP_API_KEY", base_url="https://api.holysheep.ai/v1")
2단계: 환경 변수 설정
export HOLYSHEEP_API_KEY="YOUR_HOLYSHEEP_API_KEY"
3단계: failover 클라이언트 적용 (선택사항)
이 가이드의 Python 코드로 고급 failover 기능 추가
4단계: 모니터링 대시보드 확인
https://www.holysheep.ai/dashboard 에서 사용량 실시간 확인
HolySheep AI는 개발자들이 AI 모델을 쉽고 안정적으로 활용할 수 있도록 설계되었습니다. 직접 API를 관리하는 수고를 덜고, failover와 비용 최적화는 HolySheep에 맡기세요.
👉 HolySheep AI 가입하고 무료 크레딧 받기궁금한 점이 있으시면 공식 웹사이트를 방문하거나 문서 페이지를 확인하세요. Happy coding!