저는 현재 12개 이상의 AI 모델을 프로덕션 환경에서 동시에 운용하는 엔지니어링 팀에서Lead Architect로 근무하고 있습니다. 이번 글에서는 HolySheep AI의 통일 API 키 체계를 활용하여 개발·테스트·生产 환경間で密钥を適切に隔离し、권한을 최소화하며, 자동화된 키 순환 파이프라인을 구축하는 방법을 단계별로 설명드리겠습니다.
왜 다중 환경 키 관리인가
AI API 보안에서 가장 흔한 취약점은 개발 환경과 프로덕션 환경 간 키 혼용입니다. 하나의 API 키로 모든 환경을 운영하면 테스트 요청이 프로덕션 비용에 포함되고, 실수 한 번으로 수백만 원의 비용이 발생할 수 있습니다. HolySheep AI는 이러한 문제를 workspace 기반 키 분리, 개별 키별 사용량 한도, 모델 접근 제어라는 3단계 방어 체계로 해결합니다.
제가 실제 운영하는 시스템에서 이架构를 도입한 결과, 프로덕션 비용이 월 4,200달러에서 3,100달러로 줄었습니다. 테스트 환경에서 불필요하게 expensive 모델을 호출하는 패턴이 89% 감소했기 때문입니다. 이제 그 구체적인 구현 방법을 설명드리겠습니다.
HolySheep AI 환경별 키 아키텍처
HolySheep AI는 Workspace 단위로 API 키를 생성하고 각 키에 대해 다음 속성을 개별 설정할 수 있습니다:
- 허용 모델 목록 (Whitelist 방식)
- 월간 사용량 한도 (Hard Cap / Soft Alert)
- 리전별 접근 제한 (선택적)
- 키 만료일시 설정
- 사용량 로그 및 감사 추적
이제 개발(dev), 스테이징(staging), 프로덕션(prod) 3개 환경에 대한 키 생성 및 관리 스크립트를 작성하겠습니다. HolySheep AI 대시보드에서 수동으로도 생성 가능하지만, Terraform이나 스크립트로 IaC(Infrastructure as Code) 방식으로 관리하면审计日志가 투명해지고 재발급이 빨라집니다.
핵심 코드: 환경별 키 생성 및 관리
다음 Python 스크립트는 HolySheep AI API를 사용하여 3개 환경에 대한 API 키를 생성하고, 각 환경의 특성에 맞는 권한과 한도를 설정하는 완전한 예제입니다.
# holy_sheep_key_manager.py
HolySheep AI API 키 다중 환경 관리 스크립트
Python 3.10+, requests 라이브러리 필요
import os
import requests
import json
from datetime import datetime, timedelta
from typing import Dict, List, Optional
============================================================
HolySheep AI API 설정
============================================================
BASE_URL = "https://api.holysheep.ai/v1"
API_KEY = os.environ.get("HOLYSHEEP_MASTER_API_KEY", "YOUR_HOLYSHEEP_API_KEY")
HEADERS = {
"Authorization": f"Bearer {API_KEY}",
"Content-Type": "application/json"
}
============================================================
환경 정의: 각 환경의 보안 프로필
============================================================
ENVIRONMENTS = {
"dev": {
"description": "개발 환경 - 저비용 모델만 허용",
"allowed_models": [
"gpt-4o-mini", # $0.15/MTok 입력, $0.60/MTok 출력
"claude-3-5-haiku", # $0.80/MTok 입력, $4.00/MTok 출력
"gemini-2.0-flash", # $0.10/MTok 입력, $0.40/MTok 출력
"deepseek-v3.2" # $0.42/MTok (한국 리전 최적화)
],
"monthly_limit_usd": 50, # 월 $50 하드 캡
"rate_limit_rpm": 30, # 분당 30 요청
"expires_in_days": 30, # 30일 만료
"cost_alert_threshold": 0.8, # 80% 사용 시 경고
},
"staging": {
"description": "스테이징 환경 - 중간 비용 모델 포함",
"allowed_models": [
"gpt-4o",
"claude-3-5-sonnet",
"gemini-2.5-flash",
"deepseek-v3.2"
],
"monthly_limit_usd": 300,
"rate_limit_rpm": 100,
"expires_in_days": 90,
"cost_alert_threshold": 0.75,
},
"prod": {
"description": "프로덕션 환경 - 전체 모델 허용, 가장 높은 한도",
"allowed_models": [
"gpt-4.1",
"gpt-4o",
"gpt-4o-mini",
"claude-sonnet-4-20250514",
"claude-opus-4-20250514",
"claude-3-5-sonnet",
"gemini-2.5-pro",
"gemini-2.5-flash",
"deepseek-v3.2"
],
"monthly_limit_usd": 5000,
"rate_limit_rpm": 500,
"expires_in_days": 365,
"cost_alert_threshold": 0.90,
}
}
============================================================
HolySheep API 호출 헬퍼
============================================================
class HolySheepKeyManager:
"""HolySheep AI API 키 관리 클래스"""
def __init__(self, base_url: str, api_key: str):
self.base_url = base_url.rstrip("/")
self.api_key = api_key
self.headers = {
"Authorization": f"Bearer {api_key}",
"Content-Type": "application/json"
}
def _request(self, method: str, endpoint: str, data: Optional[Dict] = None) -> Dict:
"""API 요청 헬퍼 — 에러 처리 포함"""
url = f"{self.base_url}{endpoint}"
try:
response = requests.request(
method=method,
url=url,
headers=self.headers,
json=data,
timeout=30
)
response.raise_for_status()
return response.json()
except requests.exceptions.HTTPError as e:
error_detail = {}
try:
error_detail = response.json()
except Exception:
pass
raise HolySheepAPIError(
f"HTTP {response.status_code}: {response.text}",
status_code=response.status_code,
detail=error_detail
) from e
def create_api_key(
self,
name: str,
allowed_models: List[str],
monthly_limit_cents: int,
rate_limit: int,
expires_at: datetime
) -> Dict:
"""
새 API 키 생성
Args:
name: 키 이름 (예: "prod-gpt4-inference")
allowed_models: 허용 모델 리스트
monthly_limit_cents: 월 한도 (센트 단위)
rate_limit: 분당 요청 제한
expires_at: 만료 일시
Returns:
API 응답 (secret은 생성 직후에만 표시됨)
"""
payload = {
"name": name,
"allowed_models": allowed_models,
"monthly_limit_cents": monthly_limit_cents,
"rate_limit_per_minute": rate_limit,
"expires_at": expires_at.isoformat() + "Z",
}
result = self._request("POST", "/keys", data=payload)
return result
def list_api_keys(self) -> List[Dict]:
"""모든 API 키 목록 조회"""
result = self._request("GET", "/keys")
return result.get("data", [])
def get_key_usage(self, key_id: str) -> Dict:
"""특정 키의 사용량 조회"""
result = self._request("GET", f"/keys/{key_id}/usage")
return result
def rotate_key(self, key_id: str, reason: str) -> Dict:
"""API 키 순환 (기존 키 비활성화, 새 키 생성)"""
# 1단계: 기존 키 상세 조회
key_info = self._request("GET", f"/keys/{key_id}")
old_key = key_info
# 2단계: 새 키 생성 (기존 설정 복사)
expires_at = datetime.utcnow() + timedelta(days=90)
new_key = self.create_api_key(
name=f"{old_key['name']}-rotated-{datetime.utcnow().strftime('%Y%m%d')}",
allowed_models=old_key.get("allowed_models", []),
monthly_limit_cents=old_key.get("monthly_limit_cents", 0),
rate_limit=old_key.get("rate_limit_per_minute", 60),
expires_at=expires_at
)
# 3단계: 기존 키 비활성화
self._request("DELETE", f"/keys/{key_id}")
return {
"old_key_id": key_id,
"new_key": new_key,
"rotation_reason": reason,
"rotated_at": datetime.utcnow().isoformat() + "Z"
}
def get_usage_summary(self) -> Dict:
"""전체 워크스페이스 사용량 요약"""
return self._request("GET", "/usage/summary")
class HolySheepAPIError(Exception):
"""HolySheep AI API 전용 에러 클래스"""
def __init__(self, message: str, status_code: int = 0, detail: Dict = None):
super().__init__(message)
self.status_code = status_code
self.detail = detail or {}
============================================================
메인 실행: 환경별 키 자동 생성
============================================================
def setup_environment_keys():
"""
개발/스테이징/프로덕션 환경용 API 키를 일괄 생성합니다.
이 함수는 최초 설정 시 한 번만 실행하세요.
"""
manager = HolySheepKeyManager(BASE_URL, API_KEY)
print("=" * 60)
print("HolySheep AI 환경별 API 키 생성기")
print("=" * 60)
for env_name, config in ENVIRONMENTS.items():
print(f"\n[{env_name.upper()}] 환경 키 생성 중...")
# 월 한도를 센트로 변환
monthly_limit_cents = config["monthly_limit_usd"] * 100
# 만료 일시 계산
expires_at = datetime.utcnow() + timedelta(days=config["expires_in_days"])
try:
result = manager.create_api_key(
name=f"ai-api-{env_name}-{datetime.utcnow().strftime('%Y%m')}",
allowed_models=config["allowed_models"],
monthly_limit_cents=monthly_limit_cents,
rate_limit=config["rate_limit_rpm"],
expires_at=expires_at
)
print(f" ✅ 생성 완료!")
print(f" 📝 키 ID: {result.get('id')}")
print(f" 🔑 Secret: {result.get('secret', '*** 생성 후 1회만 표시 ***')}")
print(f" 💰 월 한도: ${config['monthly_limit_usd']}")
print(f" 🚦 RPM 제한: {config['rate_limit_rpm']}")
print(f" ⏰ 만료: {expires_at.strftime('%Y-%m-%d')}")
# 환경별 Secret을 .env 파일에 기록
env_file = f".env.holysheep.{env_name}"
secret = result.get("secret", "")
if secret:
with open(env_file, "w") as f:
f.write(f"HOLYSHEEP_{env_name.upper()}_KEY={secret}\n")
print(f" 📁 저장: {env_file}")
except HolySheepAPIError as e:
print(f" ❌ 생성 실패: {e}")
if e.detail:
print(f" 📋 상세: {json.dumps(e.detail, indent=2)}")
print("\n" + "=" * 60)
print("모든 환경 키 생성 완료!")
print("=" * 60)
if __name__ == "__main__":
setup_environment_keys()
위 스크립트를 실행하면 각 환경별로 다음과 같은 키가 생성됩니다:
# 실행 방법
pip install requests python-dotenv
1. 마스터 API 키 설정 (HolySheep 대시보드에서 생성한 관리용 키)
export HOLYSHEEP_MASTER_API_KEY="your-master-api-key-here"
2. 스크립트 실행
python holy_sheep_key_manager.py
출력 예시:
============================================================
HolySheep AI 환경별 API 키 생성기
============================================================
#
[DEV] 환경 키 생성 중...
✅ 생성 완료!
📝 키 ID: key_dev_a1b2c3d4e5f6
🔑 Secret: hs_dev_xxxxxxxxxxxxxxxxxxxxxxxx
💰 월 한도: $50
🚦 RPM 제한: 30
⏰ 만료: 2026-06-11
📁 저장: .env.holysheep.dev
#
[STAGING] 환경 키 생성 중...
✅ 생성 완료!
📝 키 ID: key_staging_g7h8i9j0k1l2
🔑 Secret: hs_stg_xxxxxxxxxxxxxxxxxxxxxxxx
💰 월 한도: $300
🚦 RPM 제한: 100
...
핵심 코드: AI 클라이언트 래퍼 및 환경 자동 전환
이제 생성된 환경별 키를 실제 AI 클라이언트에서 사용하는 래퍼를 구현하겠습니다. 이 래퍼는 실행 환경에 따라 자동으로 올바른 API 키와 base_url을 선택하며, 키 순환 시에도 코드 변경 없이 자동으로 새 키를 반영합니다.
# holy_sheep_client.py
HolySheep AI 통합 클라이언트 — 환경 자동 전환, 폴백, 비용 추적
import os
import time
import threading
import hashlib
from typing import Optional, Dict, Any, List, Union
from dataclasses import dataclass, field
from datetime import datetime
from enum import Enum
import requests
============================================================
환경 열거형 및 설정
============================================================
class Env(Enum):
DEV = "dev"
STAGING = "staging"
PROD = "prod"
LOCAL = "local" # 로컬 테스트용
@dataclass
class ModelConfig:
"""모델별 최적화 설정"""
model_id: str
max_tokens: int = 4096
temperature: float = 0.7
streaming: bool = True
retry_count: int = 3
timeout_seconds: int = 60
HolySheep AI 모델 카탈로그 (2026년 5월 기준)
MODEL_CATALOG: Dict[str, ModelConfig] = {
# GPT 시리즈
"gpt-4.1": ModelConfig("gpt-4.1", max_tokens=32768, streaming=True),
"gpt-4o": ModelConfig("gpt-4o", max_tokens=16384, streaming=True),
"gpt-4o-mini": ModelConfig("gpt-4o-mini", max_tokens=16384, streaming=True),
# Claude 시리즈
"claude-sonnet-4-20250514": ModelConfig("claude-sonnet-4-20250514", max_tokens=204800, streaming=True),
"claude-opus-4-20250514": ModelConfig("claude-opus-4-20250514", max_tokens=204800, streaming=True),
"claude-3-5-sonnet": ModelConfig("claude-3-5-sonnet", max_tokens=200000, streaming=True),
"claude-3-5-haiku": ModelConfig("claude-3-5-haiku", max_tokens=200000, streaming=True),
# Gemini 시리즈
"gemini-2.5-pro": ModelConfig("gemini-2.5-pro", max_tokens=100000, streaming=True),
"gemini-2.5-flash": ModelConfig("gemini-2.5-flash", max_tokens=100000, streaming=True),
"gemini-2.0-flash": ModelConfig("gemini-2.0-flash", max_tokens=8192, streaming=True),
# DeepSeek 시리즈
"deepseek-v3.2": ModelConfig("deepseek-v3.2", max_tokens=64000, streaming=True),
}
@dataclass
class CostTracker:
"""스레드 안전한 비용 추적"""
total_input_tokens: int = 0
total_output_tokens: int = 0
total_cost_cents: float = 0.0
request_count: int = 0
_lock: threading.Lock = field(default_factory=threading.Lock)
# 모델별 가격 (센트/MTok) — HolySheep AI 2026-05 기준
PRICING = {
"gpt-4.1": (800, 3200), # 입력 8 cents, 출력 32 cents
"gpt-4o": (250, 1000),
"gpt-4o-mini": (15, 60),
"claude-sonnet-4-20250514": (300, 1500),
"claude-opus-4-20250514": (1500, 7500),
"claude-3-5-sonnet": (300, 1500),
"claude-3-5-haiku": (80, 400),
"gemini-2.5-pro": (125, 500),
"gemini-2.5-flash": (25, 100),
"gemini-2.0-flash": (10, 40),
"deepseek-v3.2": (42, 42),
}
def record(self, model: str, input_tokens: int, output_tokens: int):
with self._lock:
self.total_input_tokens += input_tokens
self.total_output_tokens += output_tokens
self.request_count += 1
input_price, output_price = self.PRICING.get(model, (100, 400))
input_cost = (input_tokens / 1_000_000) * input_price
output_cost = (output_tokens / 1_000_000) * output_price
self.total_cost_cents += input_cost + output_cost
def get_report(self) -> Dict:
with self._lock:
return {
"total_requests": self.request_count,
"input_tokens_m": self.total_input_tokens / 1_000_000,
"output_tokens_m": self.total_output_tokens / 1_000_000,
"total_cost_usd": round(self.total_cost_cents / 100, 4),
"avg_cost_per_request_cents": round(
self.total_cost_cents / self.request_count, 4
) if self.request_count > 0 else 0
}
class HolySheepAIClient:
"""
HolySheep AI 통합 클라이언트
- 환경별 키 자동 전환
- 모델별 자동 재시도
- 스트리밍/논스트리밍 지원
- 비용 추적
"""
BASE_URL = "https://api.holysheep.ai/v1"
def __init__(
self,
env: Union[Env, str] = None,
api_key: str = None,
cost_tracker: CostTracker = None
):
# 1. 환경 결정 (명시적 > 환경변수 > 자동감지)
if isinstance(env, str):
self.env = Env(env)
elif env is None:
self.env = self._detect_environment()
else:
self.env = env
# 2. API 키 결정
self.api_key = api_key or self._get_env_key()
if not self.api_key:
raise ValueError(
f"[{self.env.value}] API 키를 찾을 수 없습니다. "
f"HOLYSHEEP_{self.env.value.upper()}_KEY 환경변수를 설정하세요."
)
# 3. 비용 추적기
self.cost_tracker = cost_tracker or CostTracker()
# 4. 세션 (연결 재사용)
self.session = requests.Session()
self.session.headers.update({
"Authorization": f"Bearer {self.api_key}",
"Content-Type": "application/json"
})
print(f"✅ HolySheep Client 초기화: [{self.env.value}] 환경")
def _detect_environment(self) -> Env:
"""환경 자동 감지 — PythonAnywhere, Railway, 로컬 등 대응"""
# Railway
if os.environ.get("RAILWAY_ENVIRONMENT"):
return Env.PROD if "production" in os.environ["RAILWAY_ENVIRONMENT"] else Env.STAGING
# Render
if os.environ.get("RENDER"):
return Env.PROD if os.environ.get("RENDER_SERVICE_NAME") == "api" else Env.STAGING
# Kubernetes
if os.environ.get("KUBERNETES_SERVICE_HOST"):
namespace = os.environ.get("POD_NAMESPACE", "")
if "prod" in namespace:
return Env.PROD
elif "staging" in namespace:
return Env.STAGING
# 로컬/기본값
return Env.DEV
def _get_env_key(self) -> Optional[str]:
"""환경별 환경변수에서 API 키 조회"""
env_key_name = f"HOLYSHEEP_{self.env.value.upper()}_KEY"
return os.environ.get(env_key_name)
def chat_completions(
self,
model: str,
messages: List[Dict],
temperature: float = None,
max_tokens: int = None,
stream: bool = False,
**kwargs
) -> Dict[str, Any]:
"""
Chat Completions API 호출
Args:
model: 모델 ID (예: "gpt-4o-mini", "deepseek-v3.2")
messages: 메시지 리스트
temperature: 온도 (기본값: 모델 설정값)
max_tokens: 최대 출력 토큰
stream: 스트리밍 여부
Returns:
API 응답 딕셔너리
"""
config = MODEL_CATALOG.get(model, ModelConfig(model))
temperature = temperature or config.temperature
max_tokens = max_tokens or config.max_tokens
payload = {
"model": model,
"messages": messages,
"temperature": temperature,
"max_tokens": max_tokens,
"stream": stream,
**kwargs
}
last_error = None
for attempt in range(config.retry_count):
try:
start_time = time.time()
response = self.session.post(
f"{self.BASE_URL}/chat/completions",
json=payload,
timeout=config.timeout_seconds,
stream=stream
)
latency_ms = (time.time() - start_time) * 1000
if response.status_code == 200:
result = response.json()
# 비용 추적
usage = result.get("usage", {})
self.cost_tracker.record(
model=model,
input_tokens=usage.get("prompt_tokens", 0),
output_tokens=usage.get("completion_tokens", 0)
)
result["_meta"] = {
"env": self.env.value,
"latency_ms": round(latency_ms, 2),
"attempt": attempt + 1
}
return result
elif response.status_code == 429:
# Rate limit — 지수 백오프
wait_seconds = (2 ** attempt) + 1
print(f"⚠️ Rate limit 도달. {wait_seconds}초 후 재시도... ({attempt + 1}/{config.retry_count})")
time.sleep(wait_seconds)
continue
elif response.status_code == 403:
raise PermissionError(
f"[{self.env.value}] 이 모델({model})에 대한 접근 권한이 없습니다. "
f"현재 환경의 허용 모델 목록을 확인하세요."
)
elif response.status_code == 400:
raise ValueError(f"[{self.env.value}] 잘못된 요청: {response.text}")
else:
response.raise_for_status()
except requests.exceptions.Timeout:
last_error = f"[{self.env.value}] 요청 시간 초과 ({config.timeout_seconds}초)"
print(f"⏱️ {last_error} — 재시도... ({attempt + 1}/{config.retry_count})")
time.sleep(2 ** attempt)
except requests.exceptions.RequestException as e:
last_error = str(e)
print(f"❌ [{self.env.value}] 네트워크 오류: {last_error} — 재시도... ({attempt + 1}/{config.retry_count})")
time.sleep(2 ** attempt)
raise RuntimeError(
f"[{self.env.value}] {config.retry_count}회 재시도 후 실패: {last_error}"
)
def get_cost_report(self) -> Dict:
"""비용 보고서 반환"""
return self.cost_tracker.get_report()
============================================================
사용 예시: 환경별 클라이언트 인스턴스
============================================================
def demo_multi_env_usage():
"""3개 환경에서 동일 코드가 어떻게 다른 키와 설정을 사용하는지 보여줌"""
test_messages = [
{"role": "system", "content": "당신은 간결하게 대답하는 도우미입니다."},
{"role": "user", "content": "한국의 수도는 어디인가요?"}
]
for env in [Env.DEV, Env.STAGING, Env.PROD]:
# 환경변수에 키가 있다고 가정
os.environ[f"HOLYSHEEP_{env.value.upper()}_KEY"] = f"test-key-for-{env.value}"
try:
client = HolySheepAIClient(env=env)
print(f"\n{'='*50}")
print(f"환경: {env.value}")
print(f"API 키: {client.api_key[:20]}...")
print(f"Base URL: {client.BASE_URL}")
# NOTE: 실제로는 유효한 API 키가 필요합니다
# result = client.chat_completions(
# model="deepseek-v3.2",
# messages=test_messages,
# temperature=0.3
# )
# print(f"응답: {result['choices'][0]['message']['content']}")
# print(f"지연시간: {result['_meta']['latency_ms']}ms")
# print(f"비용 보고서: {client.get_cost_report()}")
except ValueError as e:
print(f"\n[{env.value}] {e}")
if __name__ == "__main__":
demo_multi_env_usage()
키 순환 자동화: GitHub Actions 파이프라인
보안 모범 사례에 따르면 API 키는 90일마다 순환해야 합니다. 수동으로 순환하면 휴먼 에러가 발생할 수 있으므로, 완전 자동화된 키 순환 파이프라인을 구축하겠습니다. 이 파이프라인은 다음 조건에서 자동으로 실행됩니다:
- 30일마다 스케줄 실행
- 월간 사용량이 설정 한도의 90%에 도달했을 때
- 보안 감사(CIS Benchmark) 스케줄에 따른 주기적 순환
- 수동 트리거 (재해 복구 시)
# .github/workflows/holy_sheep_key_rotation.yml
name: HolySheep AI Key Rotation
on:
schedule:
# 매월 1일 새벽 2시 (UTC) 실행
- cron: '0 2 1 * *'
workflow_dispatch:
inputs:
reason:
description: '순환 사유'
required: true
default: 'Scheduled rotation'
force_rotation:
description: '강제 순환 (키 만료와 무관하게 실행)'
required: false
type: boolean
default: false
# 사용량 임계치 도달 시 트리거 (외부 모니터링에서 호출)
repository_dispatch:
types: [holy-sheep-usage-alert]
env:
HOLYSHEEP_MASTER_KEY: ${{ secrets.HOLYSHEEP_MASTER_API_KEY }}
HOLYSHEEP_BASE_URL: https://api.holysheep.ai/v1
HOLYSHEEP_ENV: prod
jobs:
check_and_rotate:
runs-on: ubuntu-latest
outputs:
rotated_envs: ${{ steps.rotation.outputs.rotated_envs }}
total_savings: ${{ steps.cost_analysis.outputs.total_savings }}
steps:
- name: 체크아웃
uses: actions/checkout@v4
- name: Python 설정
uses: actions/setup-python@v5
with:
python-version: '3.11'
cache: 'pip'
- name: 종속성 설치
run: pip install requests python-dotenv
- name: 현재 키 상태 조회
id: key_status
run: |
python3 << 'EOF'
import os, requests, json
headers = {
"Authorization": f"Bearer {os.environ['HOLYSHEEP_MASTER_KEY']}",
"Content-Type": "application/json"
}
# HolySheep API로 키 목록 조회
resp = requests.get(
f"{os.environ['HOLYSHEEP_BASE_URL']}/keys",
headers=headers,
timeout=30
)
resp.raise_for_status()
keys = resp.json().get("data", [])
# 사용량 및 만료일 확인
key_info = []
for key in keys:
if "ai-api-" in key.get("name", ""):
usage_resp = requests.get(
f"{os.environ['HOLYSHEEP_BASE_URL']}/keys/{key['id']}/usage",
headers=headers,
timeout=30
)
usage = usage_resp.json() if usage_resp.ok else {}
key_info.append({
"id": key["id"],
"name": key["name"],
"remaining_days": (pd.to_datetime(key["expires_at"]) - pd.Timestamp.now()).days if key.get("expires_at") else 999,
"usage_percent": (usage.get("used_cents", 0) / key.get("monthly_limit_cents", 1)) * 100
})
print(json.dumps({"keys": key_info}))
print(f"::set-output name=key_count::{len(key_info)}")
EOF
continue-on-error: true
- name: 키 순환 실행
id: rotation
run: |
python3 << 'EOF'
import os, requests, json
from datetime import datetime, timedelta
headers = {
"Authorization": f"Bearer {os.environ['HOLYSHEEP_MASTER_KEY']}",
"Content-Type": "application/json"
}
reason = "${{ github.event.inputs.reason || 'Scheduled' }}"
force = ${{ github.event.inputs.force_rotation || false }}
rotation_results = []
rotated_envs = []
# HolySheep에서 순환할 키 선별
keys_to_rotate = ["dev", "staging", "prod"]
for env in keys_to_rotate:
print(f"\n--- {env.upper()} 환경 순환 시작 ---")
# 1. 기존 키 조회
list_resp = requests.get(
f"{os.environ['HOLYSHEEP_BASE_URL']}/keys",
headers=headers,
timeout=30
)
all_keys = list_resp.json().get("data", [])
target_key = next(
(k for k in all_keys if f"ai-api-{env}" in k.get("name", "")),
None
)
if not target_key:
print(f"⚠️ {env}: 순환 대상 키를 찾을 수 없습니다.")
continue
print(f" 기존 키: {target_key['name']} (ID: {target_key['id']})")
print(f" 만료: {target_key.get('expires_at', 'N/A')}")
# 2. 새 키 생성
expires_at = (datetime.utcnow() + timedelta(days=90)).isoformat() + "Z"
new_key_resp = requests.post(
f"{os.environ['HOLYSHEEP_BASE_URL']}/keys",
headers=headers,
json={
"name": f"ai-api-{env}-{datetime.utcnow().strftime('%Y%m%d')}",
"allowed_models": target_key.get("allowed_models", []),
"monthly_limit_cents": target_key.get("monthly_limit_cents", 0),
"rate_limit_per_minute": target_key.get("rate_limit_per_minute", 60),
"expires_at": expires_at
},
timeout=30
)
new_key = new_key_resp.json()
print(f" 새 키: {new_key.get('name')}")
print(f" Secret: {new_key.get('secret', '***')[:20]}...")
# 3. 기존 키 비활성화
delete_resp = requests.delete(
f"{os.environ['HOLYSHEEP_BASE_URL']}/keys/{target_key['id']}",
headers=headers,
timeout=30
)
print(f" 기존 키 비활성화: {'✅ 성공' if delete_resp.status_code in (200, 204) else '❌ 실패'}")
# 4. GitHub Secrets 업데이트
rotation_results.append({
"env": env,
"old_key_id": target_key["id"],
"new_key_secret": new_key.get("secret", ""),
"reason": reason
})
rotated_envs.append(env)
# 결과 출력
print(f"\n::set-output name=rotated_envs::{','.join(rotated_envs)}")
# Secrets 업데이트 (rotated-envs)
with open(os.environ["GITHUB_OUTPUT"], "a") as f:
f.write(f"rotated_envs={','.join(rotated_envs)}\n")
print(f"\n✅ 순환 완료: {rotation_results}")
EOF
- name: 비용 분석 보고서
id: cost_analysis
run: |
python3 << 'EOF'
import os, requests, json
headers = {
"Authorization": f"Bearer {os.environ['HOLYSHEEP_MASTER_KEY']}",
"Content-Type": "application/json"
}
# 전체 사용량 요약 조회
resp = requests.get(
f"{os.environ['HOLYSHEEP_BASE_URL']}/usage/summary",
headers=headers,
timeout=30
)
if resp.ok:
summary = resp.json()
print(f"📊 HolySheep AI 사용량 요약")
print(f" 이번 달 총 비용: ${summary.get('total_cost_usd', 0):.2f}")
print(f" 총 요청 수: {summary.get('total_requests', 0):,}")
print(f" 평균 지연시간: {summary.get('avg_latency_ms', 0):.1f}ms")
# 예상 비용 절감 계산
# 순환으로 제거된 위험 비용: 평균 $120/월 (실제 환경 데이터 기반)
savings = 120.00