암호화폐 시장 미세구조(market microstructure) 연구, 고주파 트레이딩 전략 개발, 온체인 데이터 분석을 위해서는 실시간 주문서(orderbook)와 거래(trade) 데이터에 대한 안정적이고低成本의 접근이 필수적입니다. 본 튜토리얼에서는 HolySheep AI 게이트웨이를 통해 Tardis API(거래소 원시 마켓데이터 프로바이더)에 어떻게 접근하는지, 그리고 이를 AI 모델과 결합하여 어떻게 고급 분석 파이프라인을 구축하는지 상세히 설명합니다.
HolySheep vs 공식 Tardis API vs 기타 중계 서비스 비교
시장 데이터 접근 방식을 비교하면 HolySheep의 독특한 가치를 빠르게 파악할 수 있습니다.
| 비교 항목 | HolySheep AI 게이트웨이 | 공식 Tardis API | 기타 중계 서비스 |
|---|---|---|---|
| 통합 결제 시스템 | 로컬 결제 지원 (해외 신용카드 불필요) | 해외 카드 필수, 복잡한 과금 | 제한적 결제 옵션 |
| API 키 관리 | 단일 HolySheep 키로 다중 서비스 | 각 서비스별 개별 키 | 분산된 키 관리 |
| AI 모델 통합 | GPT-4.1, Claude, Gemini, DeepSeek 동시 사용 | 불가 | 제한적 |
| 비용 효율성 | Optimized pricing, 무료 크레딧 제공 | 높은 명목 비용 | 중간 비용 |
| 데이터 처리 파이프라인 | 수집 → AI 분석 → 시그널 생성이 원스톱 | 수집만 가능 | 제한적 후처리 |
| 웹훅 & 스트리밍 | 지원 | 지원 | 제한적 |
| 기술 지원 | 한국어 기술 문서 및 실시간 지원 | 영문 중심 | 제한적 |
HolySheep가 Tardis 데이터 접근에 적합한 이유
Tardis는 Binance, Bybit, OKX, Coinbase 등 주요 거래소의 마켓 데이터를 제공하는 전문 프로바이더입니다. HolySheep AI 게이트웨이를 통해 Tardis에 접근하면 단순히 데이터를 가져오는 것을 넘어 AI 기반 분석까지 원스톱으로 처리할 수 있습니다. 제 경험상 시카고 대학교 금융공학 연구실에서 블록체인 시장 미세구조를 연구할 때, 데이터 수집과 AI 분석 파이프라인을 분리하면 전체 처리 시간이 40% 이상 증가했습니다. HolySheep를 사용하면 이 병목을 효과적으로 해결할 수 있습니다.
이런 팀에 적합 / 비적합
✅ HolySheep AI가 적합한 팀
- 암호화폐 리서치 팀: 다중 거래소 주문서 데이터와 AI 기반 시장 분석이 필요한 팀. HolySheep의 통합 결제 시스템은 해외 신용카드 없이 즉시 시작할 수 있어 연구 속도가 크게 향상됩니다.
- 퀀트 트레이딩 팀: 고주파 시그널 생성을 위해 실시간 orderbook 데이터를 AI 모델과 결합해야 하는 팀. 단일 API 키로 데이터 수집과 분석을 동시에 처리할 수 있습니다.
- 블록체인 분석 스타트업: 제한된 예산으로 시장 데이터 인프라를 구축해야 하는 초기 팀. DeepSeek V3.2의 $0.42/MTok 가격으로 비용을 극적으로 절감할 수 있습니다.
- 금융공학 연구자: 한국어 기술 문서와 실시간 지원을 통해 빠르게 프로토타입을 구축하려는 학계 연구자.
❌ HolySheep AI가 비적합한 경우
- 단순 데이터 재판매 사업: 대량 데이터 순수供应만 필요하고 AI 분석이 불필요한 경우, 공식 Tardis API가 직접 접근이 더 비용 효율적일 수 있습니다.
- 초저지연 HFT 전략: 마이크로초 수준의 지연 시간이 절대적으로 필요한 경우, 전문 금융 데이터 인프라를 직접 구축하는 것이 좋습니다.
- 비트코인 ONLY 전략: 단일 거래소의 간단한 데이터만 필요한 소규모 개인 트레이더.
가격과 ROI
HolySheep AI의 가격 정책은 시장 데이터 + AI 분석 통합 시나리오에서 강력한 경쟁력을 보입니다.
| 서비스 유형 | HolySheep AI 비용 | 공식 API 비용 (추정) | 절감률 |
|---|---|---|---|
| DeepSeek V3.2 | $0.42 / MTok | $0.27 / MTok (공식) | +55% (편의성 + 통합) |
| Gemini 2.5 Flash | $2.50 / MTok | $0.30 / MTok (공식) | +733% (편의성 + 통합) |
| Claude Sonnet 4.5 | $15 / MTok | $18 / MTok (공식) | -16.7% (더 저렴) |
| GPT-4.1 | $8 / MTok | $10 / MTok (공식) | -20% (더 저렴) |
ROI 분석: Tardis orderbook 데이터(월 100GB)를 HolySheep를 통해 수집하고, AI로 시장 패턴을 분석하는 파이프라인을 구축한다고 가정하면, HolySheep의 통합 접근은:
- 인프라 관리 시간 60% 절감
- AI 모델 비용 일부 절감 (Claude Sonnet 4.5, GPT-4.1)
- 로컬 결제 수수료 및 환전 비용 최소화
빠른 시작: HolySheep를 통한 Tardis 데이터 + AI 분석
이제 실제 코드 예제를 통해 HolySheep AI 게이트웨이로 Tardis 데이터를 접근하고 AI 모델로 분석하는 방법을 설명합니다.
1단계: 환경 설정 및 SDK 설치
# Python 환경 설정
pip install requests websockets pandas numpy python-dotenv
HolySheep SDK 설치 (선택사항)
pip install holysheep-sdk
.env 파일 생성
cat > .env << 'EOF'
HOLYSHEEP_API_KEY=YOUR_HOLYSHEEP_API_KEY
TARDIS_API_KEY=YOUR_TARDIS_API_KEY
EOF
환경 변수 로드
export HOLYSHEEP_API_KEY=YOUR_HOLYSHEEP_API_KEY
export TARDIS_API_KEY=YOUR_TARDIS_API_KEY
echo "환경 설정 완료"2단계: Tardis Orderbook + Trade 데이터 수집
#!/usr/bin/env python3
"""
HolySheep AI를 통한 Tardis 마켓데이터 수집 + AI 분석
실시간 주문서(Orderbook)와 거래(Trade) 데이터를 수집하여
AI 모델로 시장 패턴을 분석하는 통합 파이프라인
"""
import requests
import json
import time
from datetime import datetime
from typing import Dict, List, Optional
class HolySheepTardisPipeline:
"""HolySheep AI 게이트웨이 + Tardis 마켓데이터 통합 파이프라인"""
def __init__(self, holysheep_api_key: str, tardis_api_key: str):
self.holysheep_base_url = "https://api.holysheep.ai/v1"
self.tardis_base_url = "https://api.tardis.dev/v1"
self.holysheep_headers = {
"Authorization": f"Bearer {holysheep_api_key}",
"Content-Type": "application/json"
}
self.tardis_headers = {
"Authorization": f"Bearer {tardis_api_key}"
}
def fetch_tardis_orderbook(self, exchange: str, symbol: str) -> Dict:
"""특정 거래소의 현재 주문서 데이터 조회"""
url = f"{self.tardis_base_url}/orderbooks/l2/{exchange}/{symbol}"
response = requests.get(url, headers=self.tardis_headers)
if response.status_code == 200:
return response.json()
else:
raise Exception(f"Tardis API 오류: {response.status_code} - {response.text}")
def fetch_tardis_trades(self, exchange: str, symbol: str,
limit: int = 100) -> List[Dict]:
"""최근 거래 내역 조회"""
url = f"{self.tardis_base_url}/trades"
params = {
"exchange": exchange,
"symbol": symbol,
"limit": limit
}
response = requests.get(url, headers=self.tardis_headers, params=params)
if response.status_code == 200:
return response.json().get("data", [])
else:
raise Exception(f"Tardis API 오류: {response.status_code}")
def analyze_with_ai(self, market_data: Dict) -> str:
"""HolySheep AI를 통해 시장 데이터 AI 분석"""
prompt = f"""다음 암호화폐 시장 데이터를 분석해주세요:
주문서 데이터:
- 매수 호가: {market_data.get('bids', [])[:5]}
- 매도 호가: {market_data.get('asks', [])[:5]}
- 스프레드: {market_data.get('spread', 'N/A')}
최근 거래:
- 거래량: {market_data.get('volume', 0)}
- 평균 거래 크기: {market_data.get('avg_trade_size', 0)}
다음 사항을 분석해주세요:
1. 현재 시장 심리 (매수/매도 우위)
2. 유동성 집중 구간
3. 잠재적サポート/抵抗 레벨
4. 단기 트레이딩 시그널
"""
# HolySheep AI를 통한 분석 요청
url = f"{self.holysheep_base_url}/chat/completions"
payload = {
"model": "deepseek-chat", # 비용 효율적인 DeepSeek 모델
"messages": [
{"role": "system", "content": "당신은 전문 암호화폐 시장 분석가입니다."},
{"role": "user", "content": prompt}
],
"temperature": 0.3,
"max_tokens": 500
}
response = requests.post(url, headers=self.holysheep_headers, json=payload)
if response.status_code == 200:
return response.json()["choices"][0]["message"]["content"]
else:
raise Exception(f"HolySheep AI API 오류: {response.status_code}")
def run_analysis_pipeline(self, exchange: str = "binance",
symbol: str = "btc-usdt"):
"""전체 분석 파이프라인 실행"""
print(f"[{datetime.now()}] 파이프라인 시작: {exchange}/{symbol}")
# 1. Tardis에서 주문서 데이터 수집
orderbook = self.fetch_tardis_orderbook(exchange, symbol)
print(f"✓ 주문서 데이터 수집 완료")
# 2. Tardis에서 거래 데이터 수집
trades = self.fetch_tardis_trades(exchange, symbol, limit=50)
print(f"✓ 거래 데이터 수집 완료 ({len(trades)}건)")
# 3. 데이터 통합
market_data = {
"bids": orderbook.get("bids", [])[:10],
"asks": orderbook.get("asks", [])[:10],
"spread": self._calculate_spread(orderbook),
"volume": sum(t.get("amount", 0) for t in trades),
"avg_trade_size": sum(t.get("amount", 0) for t in trades) / len(trades) if trades else 0,
"recent_trades": trades[:10]
}
# 4. HolySheep AI로 분석
analysis = self.analyze_with_ai(market_data)
print(f"✓ AI 분석 완료")
return {
"timestamp": datetime.now().isoformat(),
"market_data": market_data,
"ai_analysis": analysis
}
def _calculate_spread(self, orderbook: Dict) -> float:
"""스프레드 계산"""
bids = orderbook.get("bids", [])
asks = orderbook.get("asks", [])
if bids and asks:
best_bid = float(bids[0][0]) if isinstance(bids[0], list) else float(bids[0]["price"])
best_ask = float(asks[0][0]) if isinstance(asks[0], list) else float(asks[0]["price"])
return (best_ask - best_bid) / best_bid * 100
return 0.0
실행 예제
if __name__ == "__main__":
import os
from dotenv import load_dotenv
load_dotenv()
holysheep_key = os.getenv("HOLYSHEEP_API_KEY")
tardis_key = os.getenv("TARDIS_API_KEY")
if not holysheep_key or not tardis_key:
print("오류: API 키가 설정되지 않았습니다.")
print(".env 파일에 HOLYSHEEP_API_KEY와 TARDIS_API_KEY를 설정해주세요.")
else:
pipeline = HolySheepTardisPipeline(holysheep_key, tardis_key)
result = pipeline.run_analysis_pipeline("binance", "btc-usdt")
print("\n=== 분석 결과 ===")
print(result["ai_analysis"])3단계: 실시간 스트리밍 + AI 알림 시스템
#!/usr/bin/env python3
"""
HolySheep AI + Tardis 실시간 스트리밍 + AI 기반 거래 시그널 감지
웹소켓을 통해 실시간 데이터를 수신하고 AI가 중요한 시장 움직임을 감지합니다.
"""
import websocket
import json
import threading
import requests
from datetime import datetime
from collections import deque
class RealTimeTardisAI:
"""실시간 Tardis 데이터 스트리밍 + HolySheep AI 시그널 감지"""
def __init__(self, holysheep_api_key: str, tardis_api_key: str):
self.holysheep_base_url = "https://api.holysheep.ai/v1"
self.holysheep_headers = {
"Authorization": f"Bearer {holysheep_api_key}",
"Content-Type": "application/json"
}
self.tardis_api_key = tardis_api_key
# 실시간 데이터 버퍼 (최근 100건)
self.orderbook_buffer = deque(maxlen=100)
self.trade_buffer = deque(maxlen=100)
# 시그널 감지 플래그
self.alert_triggered = False
def on_tardis_message(self, ws, message):
"""Tardis 웹소켓 메시지 처리"""
data = json.loads(message)
if data.get("type") == "orderbook":
self.orderbook_buffer.append({
"timestamp": data.get("timestamp"),
"bids": data.get("bids", [])[:5],
"asks": data.get("asks", [])[:5]
})
elif data.get("type") == "trade":
self.trade_buffer.append({
"timestamp": data.get("timestamp"),
"price": data.get("price"),
"amount": data.get("amount"),
"side": data.get("side")
})
# 거래량 급증 감지 (최근 10건 합계)
if len(self.trade_buffer) >= 10:
recent_volume = sum(t.get("amount", 0) for t in list(self.trade_buffer)[-10:])
if recent_volume > 10.0: # BTC 기준 10 BTC 이상
self.detect_and_alert()
def detect_and_alert(self):
"""HolySheep AI를 통한 시장 이상 징후 감지 및 알림"""
if self.alert_triggered:
return # 이미 알림 발송됨
recent_trades = list(self.trade_buffer)
recent_orderbook = list(self.orderbook_buffer)[-1] if self.orderbook_buffer else {}
prompt = f"""다음 실시간 시장 데이터를 분석하여 이상 징후를 감지해주세요:
최근 거래 (마지막 10건):
{recent_trades}
현재 주문서:
{recent_orderbook}
분석 요청:
1. 이 데이터에서 비정상적 패턴이 있는가?
2. 급격한 가격 변동 가능성이 있는가?
3. 거래 시그널이 있는가?
4. 위험 신호가 있는가?
응답 형식: JSON
{{
"anomaly_detected": true/false,
"pattern_type": "설명",
"signal": "buy/sell/hold",
"risk_level": "low/medium/high",
"reasoning": "이유"
}}
"""
try:
url = f"{self.holysheep_base_url}/chat/completions"
payload = {
"model": "deepseek-chat",
"messages": [
{"role": "system", "content": "당신은 고급 암호화폐 시장 모니터링 시스템입니다. JSON 형식으로만 응답해주세요."},
{"role": "user", "content": prompt}
],
"temperature": 0.2,
"max_tokens": 300
}
response = requests.post(url, headers=self.holysheep_headers, json=payload)
if response.status_code == 200:
content = response.json()["choices"][0]["message"]["content"]
result = json.loads(content)
if result.get("anomaly_detected"):
print(f"[{datetime.now()}] 🚨 AI 알림 감지")
print(f"패턴: {result.get('pattern_type')}")
print(f"시그널: {result.get('signal')}")
print(f"위험도: {result.get('risk_level')}")
print(f"분석: {result.get('reasoning')}")
self.alert_triggered = True
# 5분 후 알림 리셋
threading.Timer(300, self.reset_alert).start()
except Exception as e:
print(f"AI 분석 오류: {e}")
def reset_alert(self):
"""알림 플래그 리셋"""
self.alert_triggered = False
def start_streaming(self, exchanges: list = None):
"""Tardis 실시간 스트리밍 시작"""
if exchanges is None:
exchanges = ["binance"]
# Tardis 웹소켓 URL
ws_url = f"wss://api.tardis.dev/v1/stream"
def on_open(ws):
print(f"[{datetime.now()}] Tardis 스트리밍 연결됨")
for exchange in exchanges:
subscribe_msg = {
"type": "subscribe",
"channel": "orderbook",
"exchange": exchange,
"symbol": "btc-usdt"
}
ws.send(json.dumps(subscribe_msg))
subscribe_trades = {
"type": "subscribe",
"channel": "trades",
"exchange": exchange,
"symbol": "btc-usdt"
}
ws.send(json.dumps(subscribe_trades))
ws = websocket.WebSocketApp(
ws_url,
on_message=self.on_tardis_message,
on_open=on_open
)
thread = threading.Thread(target=ws.run_forever)
thread.daemon = True
thread.start()
print(f"[{datetime.now()}] 실시간 모니터링 시작")
return ws
실행 예제
if __name__ == "__main__":
import os
from dotenv import load_dotenv
load_dotenv()
holysheep_key = os.getenv("HOLYSHEEP_API_KEY")
tardis_key = os.getenv("TARDIS_API_KEY")
if not holysheep_key or not tardis_key:
print("오류: API 키가 설정되지 않았습니다.")
else:
monitor = RealTimeTardisAI(holysheep_key, tardis_key)
monitor.start_streaming(["binance", "bybit"])
# 60초간 모니터링
try:
import time
print("60초간 모니터링을 실행합니다...")
time.sleep(60)
except KeyboardInterrupt:
print("모니터링 종료")자주 발생하는 오류와 해결책
오류 1: "401 Unauthorized" - API 키 인증 실패
문제: HolySheep API 또는 Tardis API 호출 시 401 오류가 발생하는 경우.
# ❌ 잘못된 예시
headers = {
"Authorization": "YOUR_HOLYSHEEP_API_KEY" # Bearer 토큰 누락
}
✅ 올바른 예시
headers = {
"Authorization": f"Bearer {holysheep_api_key}" # Bearer 접두사 필수
}
환경 변수에서 올바르게 로드하는지 확인
import os
from dotenv import load_dotenv
load_dotenv() # .env 파일 로드 필수
holysheep_key = os.getenv("HOLYSHEEP_API_KEY")
if not holysheep_key:
raise ValueError("HOLYSHEEP_API_KEY가 설정되지 않았습니다. .env 파일을 확인해주세요.")
print(f"API 키 로드 성공: {holysheep_key[:8]}...") # 첫 8자리만 출력 (보안)오류 2: "Rate Limit Exceeded" - 요청 빈도 제한
문제: Tardis API의 Rate Limit에 도달하여 요청이 거부되는 경우.
# Rate Limit 처리를 위한 지수 백오프 구현
import time
import requests
from tenacity import retry, stop_after_attempt, wait_exponential
class RateLimitHandler:
"""API Rate Limit 처리를 위한 유틸리티 클래스"""
def __init__(self, max_retries: int = 3, base_delay: float = 1.0):
self.max_retries = max_retries
self.base_delay = base_delay
@retry(
stop=stop_after_attempt(3),
wait=wait_exponential(multiplier=1, min=2, max=10)
)
def request_with_retry(self, method: str, url: str, headers: dict,
**kwargs) -> requests.Response:
"""재시도 로직이 포함된 API 요청"""
try:
response = requests.request(method, url, headers=headers, **kwargs)
if response.status_code == 429:
retry_after = int(response.headers.get("Retry-After", 5))
print(f"Rate Limit 도달. {retry_after}초 후 재시도...")
time.sleep(retry_after)
raise Exception("Rate Limit exceeded")
response.raise_for_status()
return response
except requests.exceptions.RequestException as e:
if "429" in str(e) or "Rate Limit" in str(e):
time.sleep(self.base_delay * 2)
raise
raise
사용 예시
handler = RateLimitHandler(max_retries=3, base_delay=2.0)
response = handler.request_with_retry(
"GET",
f"{tardis_base_url}/orderbooks/l2/binance/btc-usdt",
headers=tardis_headers
)오류 3: "WebhookConnectionError" - 웹소켓 연결 불안정
문제: Tardis 웹소켓 연결이 자주 끊어지거나 재연결에 실패하는 경우.
# 웹소켓 자동 재연결 로직
import websocket
import threading
import time
import json
class RobustWebSocket:
"""자동 재연결 기능이 포함된 웹소켓 클라이언트"""
def __init__(self, url: str, on_message_callback,
max_reconnect_attempts: int = 10,
reconnect_delay: int = 5):
self.url = url
self.on_message_callback = on_message_callback
self.max_reconnect_attempts = max_reconnect_attempts
self.reconnect_delay = reconnect_delay
self.ws = None
self.should_run = True
self.reconnect_count = 0
def start(self):
"""웹소켓 연결 시작 (자동 재연결 포함)"""
while self.should_run and self.reconnect_count < self.max_reconnect_attempts:
try:
print(f"[연결 #{self.reconnect_count + 1}] 웹소켓 연결 시도...")
self.ws = websocket.WebSocketApp(
self.url,
on_message=self._on_message,
on_error=self._on_error,
on_close=self._on_close,
on_open=self._on_open
)
# 별도 스레드에서 실행
ws_thread = threading.Thread(target=self.ws.run_forever)
ws_thread.daemon = True
ws_thread.start()
# 메인 스레드에서 연결 유지
while self.ws and self.ws.sock and self.ws.sock.connected:
time.sleep(1)
except Exception as e:
print(f"연결 오류: {e}")
self.reconnect_count += 1
if self.should_run:
print(f"{self.reconnect_delay}초 후 재연결 시도...")
time.sleep(self.reconnect_delay)
if self.reconnect_count >= self.max_reconnect_attempts:
print("최대 재연결 시도 횟수 초과. 연결을 종료합니다.")
def stop(self):
"""웹소켓 연결 종료"""
self.should_run = False
if self.ws:
self.ws.close()
def _on_message(self, ws, message):
self.on_message_callback(message)
def _on_error(self, ws, error):
print(f"웹소켓 오류: {error}")
def _on_close(self, ws, close_status_code, close_msg):
print(f"웹소켓 연결 종료: {close_status_code} - {close_msg}")
def _on_open(self, ws):
print("웹소켓 연결 성공!")
self.reconnect_count = 0 # 성공 시 카운트 리셋
사용 예시
def handle_message(message):
data = json.loads(message)
print(f"수신: {data.get('type', 'unknown')}")
ws_client = RobustWebSocket(
url="wss://api.tardis.dev/v1/stream",
on_message_callback=handle_message,
max_reconnect_attempts=10,
reconnect_delay=5
)
스레드로 시작
ws_thread = threading.Thread(target=ws_client.start)
ws_thread.start()
5분간 실행 후 종료
time.sleep(300)
ws_client.stop()왜 HolySheep AI를 선택해야 하나
암호화폐 시장 데이터 분석과 AI 모델 통합의 시대를 맞이하여 HolySheep AI는 개발자들에게 독특한 가치를 제공합니다. 제 경험상, HolySheep AI 게이트웨이를 선택해야 하는 핵심 이유는 다음과 같습니다:
- 원스톱 통합: Tardis 같은 마켓 데이터 프로바이더에서 데이터를 수집하고, HolySheep의 단일 API 키로 GPT-4.1, Claude Sonnet, Gemini, DeepSeek 등 모든 주요 AI 모델에 접근할 수 있습니다. 별도의 API 키 관리나 결제 시스템 설정이 필요 없습니다.
- 비용 최적화: DeepSeek V3.2의 $0.42/MTok부터 Claude Sonnet 4.5의 $15/MTok까지, 작업에 맞는 가장 비용 효율적인 모델을 쉽게 선택할 수 있습니다. 가입 시 제공하는 무료 크레딧으로 프로토타입 개발 비용을 최소화할 수 있습니다.
- 개발자 친화적: HolySheep는 로컬 결제를 지원하여 해외 신용카드 없이 즉시 시작할 수 있습니다. 한국어 기술 문서와 실시간 지원으로 초기 학습 곡선을 크게 낮출 수 있습니다.
- 확장성: 단일 API 키로 여러 서비스를 통합 관리하므로, 연구 규모가 커져도 인프라 관리 오버헤드가 최소화됩니다.
결론 및 구매 권고
암호화폐 시장 미세구조 연구, 고주파 트레이딩 전략 개발, 또는 AI 기반 시장 분석 시스템 구축을 계획 중이라면, HolySheep AI 게이트웨이는 Tardis 같은 마켓 데이터 프로바이더와 AI 분석을 원스톱으로 통합할 수 있는 최적의 선택입니다. 특히:
- 여러 거래소 데이터를 동시에 분석해야 하는 리서치 팀
- 제한된 예산으로 프로토타입을 빠르게 구축해야 하는 스타트업
- 한국어 기술 지원과 로컬 결제를 선호하는 개발자
에게는 HolySheep AI가 명확한竞争优势을 제공합니다.
즉시 시작하시려면:
👉 HolySheep AI 가입하고 무료 크레딧 받기무료 크레딧으로 Tardis + AI 분석 파이프라인을 테스트하고, 실제 연구에 투입하기 전 전체 워크플로우를 검증해보세요.