메뉴
SLI 메트릭을 자동 수집하여 SLO 대비 추적하고, Error Budget 소진율에 따라 배포 게이트를 제어한다. 번다운 차트 생성, 예측 기반 SLO 위반 사전 경고, Error Budget 정책(freeze/slow-down/normal) 자동 적용을 수행하며 continuous-eval의 품질 게이트를 보완한다.
기본적으로 소스를 먼저 확인하는 Prompt가 선택됩니다. 직접 명령으로 전환하거나 로컬 사본을 다운로드할 수도 있습니다.
설치 여부를 결정하기 전에 SKILL.md와 SkillsMP에 표시된 보조 파일을 읽어 보세요.
Codex 또는 Claude로 설치 이 Prompt를 복사해 Codex, Claude 또는 다른 어시스턴트에 붙여 넣으면 Skill 페이지를 검토하고 설치를 진행할 수 있습니다.
직접 명령은 검토 Prompt를 거치지 않습니다. 실행하기 전에 소스를 확인하세요.
npx skills add https://github.com/aws-samples/sample-oh-my-aidlcops --skill slo-management명령은 한 줄로 유지됩니다. 복사하기 전에 가로로 스크롤해 전체 내용을 확인하세요.
로컬 사본을 원하시나요? SkillsMP에서 현재 제공할 수 있는 파일을 다운로드하세요.
CloudWatch 메트릭과 Prometheus 시계열 데이터에서 통계적 이상 징후를 자동 탐지하여 incident-response의 입력 소스로 제공한다. 베이스라인 학습(7일 이동 평균 + 3σ), 다변량 상관 분석, 계절성 보정을 수행하며 탐지된 anomaly를 severity 분류하여 알람을 생성한다.
알려진 장애 패턴에 대해 사전 정의된 Runbook 기반 자동 복구를 실행한다. RCA 결과 또는 incident-response의 가설을 입력으로 받아 매칭되는 remediation playbook을 선택하고, 복구 전/후 상태를 검증하며, 실패 시 에스컬레이션한다. SEV2/3만 자동 복구 대상이며 SEV1은 사람 전용이다.
Agent 또는 skill의 프로덕션 배포를 canary 1% → 10% → 50% → 100% 4단계로 자동 진행한다. 각 단계는 continuous-eval 통과와 SLO 준수를 gate로 하며 circuit breaker가 SLO 위반을 감지하면 즉시 이전 단계로 자동 롤백한다. 100% 승격은 사람 승인이 필수다.
SOC 직업 분류 기준
SKILL.md 표시 중
| name | slo-management |
| description | SLI 메트릭을 자동 수집하여 SLO 대비 추적하고, Error Budget 소진율에 따라 배포 게이트를 제어한다. 번다운 차트 생성, 예측 기반 SLO 위반 사전 경고, Error Budget 정책(freeze/slow-down/normal) 자동 적용을 수행하며 continuous-eval의 품질 게이트를 보완한다. |
| argument-hint | [service-name or slo-name] |
| user-invocable | true |
| model | claude-sonnet-4-6 |
| allowed-tools | Read,Grep,Bash,mcp__cloudwatch,mcp__prometheus |
| ontology | {"references":["Deployment","Budget","Incident"]} |
| loop-interface | {"accepts-from":["automated-remediation.remediation-event","predictive-scaling.scaling-event"],"emits-to":[],"emits-signals":["slo-management.breach"]} |
continuous-eval의 품질 게이트에 SLO 기반 판단 추가autopilot-deploy의 배포 게이트에 Error Budget 정책 적용사용 제외:
.omao/plans/slo/definitions/${service}.yaml.autopilot-deploy 상태 파일 접근 — Error Budget 기반 배포 제어.continuous-eval 연동 — 품질 SLI 데이터 공유.# .omao/plans/slo/definitions/rag-qa-agent.yaml
service: rag-qa-agent
owner: ml-platform-team
created: "2026-04-01T00:00:00Z"
slos:
- name: availability
description: "서비스 가용성 — 성공 응답 비율"
sli:
type: ratio
good_events: "agent_request_success_total"
total_events: "agent_request_total"
source: prometheus
query_good: 'sum(rate(agent_request_success_total{service="rag-qa-agent"}[5m]))'
query_total: 'sum(rate(agent_request_total{service="rag-qa-agent"}[5m]))'
target: 0.999 # 99.9%
window:
import json
import os
import yaml
from datetime import datetime, timedelta
from dataclasses import dataclass
@dataclass
class ErrorBudget:
slo_name: str
target: float
window_days: int
total_events: int
good_events: int
bad_events: int
allowed_bad_events: float
consumed_bad_events: int
remaining_budget: float # 남은 bad event 허용량
remaining_pct: float # 잔여 비율 (0~100)
burn_rate: float # 현재 소진 속도 (1.0 = 정상)
projected_exhaustion_days: float | None # 소진 예상 일수
def calculate_error_budget(slo_config: dict,
good_events: int,
total_events: int,
window_days: int) -> ErrorBudget:
"""Error Budget 잔량 계산.
Error Budget = (1 - SLO target) × total events
Remaining = Error Budget - actual bad events
"""
target = slo_config["target"]
bad_events = total_events - good_events
# 허용된 bad event 수
allowed_bad = (1 - target) * total_events
# 잔여 budget
remaining = max(0, allowed_bad - bad_events)
remaining_pct = (remaining / allowed_bad * 100) if allowed_bad > 0 else 100.0
# Burn rate: 현재 소진 속도 / 지속 가능 소진 속도
# 지속 가능 = allowed_bad / window_days (하루 평균 허용량)
# 롤링 윈도우이므로 경과 일수 = window_days (전체 윈도우 기간에 걸쳐 관측)
elapsed_days = window_days
sustainable_daily_burn = allowed_bad / window_days
actual_daily_burn = bad_events / elapsed_days if elapsed_days > 0 else 0
burn_rate = actual_daily_burn / sustainable_daily_burn if sustainable_daily_burn > 0 else 0
# 소진 예상 일수
if actual_daily_burn > 0 and remaining > 0:
projected_exhaustion = remaining / actual_daily_burn
else:
projected_exhaustion = None # 소진 안 됨 또는 이미 소진
return ErrorBudget(
slo_name=slo_config["name"],
target=target,
window_days=window_days,
total_events=total_events,
good_events=good_events,
bad_events=bad_events,
allowed_bad_events=allowed_bad,
consumed_bad_events=bad_events,
remaining_budget=remaining,
remaining_pct=remaining_pct,
burn_rate=burn_rate,
projected_exhaustion_days=projected_exhaustion,
)
각 SLO 정의에 따라 해당 메트릭을 조회합니다.
def collect_sli(slo_config: dict) -> tuple[int, int]:
"""SLI 데이터 수집. (good_events, total_events) 반환.
SLI 타입에 따라 수집 방식이 다름:
- ratio: good/total 이벤트 수 직접 조회
- threshold: 임계값 이하 이벤트 수 / 전체 이벤트 수
- gauge: 현재 값이 target 이상인 시간 비율
"""
sli = slo_config["sli"]
window_days = slo_config.get("window", "30d")
window_seconds = int(window_days.replace("d", "")) * 86400
if sli["type"] == "ratio":
# Prometheus range query
# good = mcp__prometheus__query(sli["query_good"])
# total = mcp__prometheus__query(sli["query_total"])
good = query_prometheus_scalar(sli["query_good"], window_seconds)
total = query_prometheus_scalar(sli["query_total"], window_seconds)
return int(good), int(total)
elif sli["type"] == "threshold":
good = query_prometheus_scalar(sli["query_good"], window_seconds)
total = query_prometheus_scalar(sli["query_total"], window_seconds)
return int(good), int(total)
elif sli["type"] == "gauge":
# Gauge: 시간 기반 — target 이상인 시간 비율 (query_good/query_total 사용)
good = query_prometheus_scalar(sli["query_good"], window_seconds)
total = query_prometheus_scalar(sli["query_total"], window_seconds)
return int(good), int(total)
return 0, 0
def query_prometheus_scalar(query: str, window_seconds: int) -> float:
"""Prometheus instant query 실행."""
# mcp__prometheus__query(query=f'sum(increase({query}[{window_seconds}s]))')
return 0.0 # placeholder
def query_prometheus_range(query: str, window_seconds: int, step: int) -> list[float]:
"""Prometheus range query 실행."""
# mcp__prometheus__query_range(query=query, start=..., end=..., step=step)
return [] # placeholder
def evaluate_budget_policy(service: str, budgets: list[ErrorBudget],
policy_config: list[dict]) -> dict:
"""Error Budget 잔량에 따라 정책 결정.
가장 낮은 remaining_pct를 기준으로 정책을 적용합니다.
(하나의 SLO라도 위험하면 전체 서비스에 제한 적용)
"""
# 가장 낮은 budget을 기준으로 정책 결정
min_budget = min(budgets, key=lambda b: b.remaining_pct)
remaining = min_budget.remaining_pct
# 정책 매칭 (min inclusive, max exclusive; 최상위 밴드만 max inclusive)
active_policy = None
for policy in sorted(policy_config, key=lambda p: p["remaining_pct_min"]):
pmin = policy["remaining_pct_min"]
pmax = policy["remaining_pct_max"]
if pmax == 100:
in_band = pmin <= remaining <= pmax
else:
in_band = pmin <= remaining < pmax
if in_band:
active_policy = policy
break
if not active_policy:
active_policy = {"mode": "normal", "deploy_allowed": True}
return {
"service": service,
"limiting_slo": min_budget.slo_name,
"remaining_pct": remaining,
"mode": active_policy["mode"],
"deploy_allowed": active_policy["deploy_allowed"],
"deploy_frequency": active_policy.get("deploy_frequency", "unlimited"),
"description": active_policy.get("description", ""),
}
Error Budget 잔량에 따라 autopilot-deploy에 배포 허용/차단 신호를 전달합니다.
def deploy_gate_decision(service: str) -> dict:
"""Error Budget 기반 배포 게이트 판정.
autopilot-deploy의 pre-flight gate에서 호출됩니다.
"""
# SLO 정의 로드
slo_file = f".omao/plans/slo/definitions/{service}.yaml"
with open(slo_file) as f:
slo_def = yaml.safe_load(f)
# 각 SLO별 budget 계산
budgets = []
for slo in slo_def["slos"]:
window_days = int(slo.get("window", "30d").replace("d", ""))
good, total = collect_sli(slo)
budget = calculate_error_budget(slo, good, total, window_days)
budgets.append(budget)
# 정책 평가
policy = evaluate_budget_policy(service, budgets, slo_def["error_budget_policy"])
# 게이트 결과 저장
gate_file = f".omao/state/slo/{service}/deploy-gate.json"
os.makedirs(os.path.dirname(gate_file), exist_ok=True)
with open(gate_file, "w") as f:
json.dump(policy, f, indent=2)
return policy
Error Budget 소진 속도를 기반으로 사전 경고를 발행합니다.
def check_burn_rate_alerts(service: str, budgets: list[ErrorBudget],
alert_config: list[dict]) -> list[dict]:
"""Burn rate 기반 알림 발행."""
alerts_fired = []
for budget in budgets:
for alert in alert_config:
if budget.remaining_pct <= alert["at_remaining_pct"]:
alert_event = {
"service": service,
"slo_name": budget.slo_name,
"remaining_pct": budget.remaining_pct,
"burn_rate": budget.burn_rate,
"projected_exhaustion_days": budget.projected_exhaustion_days,
"action": alert["action"],
"channel": alert["channel"],
"timestamp": datetime.utcnow().isoformat() + "Z",
}
alerts_fired.append(alert_event)
# 심각도에 따라 후속 조치
if alert["action"] == "freeze_and_escalate":
trigger_deploy_freeze(service, budget)
trigger_incident_response(service, budget, severity="SEV3")
return alerts_fired
def predict_budget_exhaustion(budget: ErrorBudget) -> dict:
"""Error Budget 소진 예측.
현재 burn rate가 유지될 경우 소진 시점을 예측합니다.
"""
if budget.burn_rate <= 1.0:
return {
"status": "sustainable",
"message": f"Current burn rate ({budget.burn_rate:.2f}x) is sustainable",
}
if budget.projected_exhaustion_days is not None:
if budget.projected_exhaustion_days < 3:
urgency = "critical"
elif budget.projected_exhaustion_days < 7:
urgency = "warning"
else:
urgency = "info"
return {
"status": "at_risk",
"urgency": urgency,
"projected_exhaustion_days": budget.projected_exhaustion_days,
"burn_rate": budget.burn_rate,
"message": f"Budget will exhaust in {budget.projected_exhaustion_days:.1f} days at current rate",
}
return {"status": "exhausted", "message": "Error budget already exhausted"}
def generate_slo_report(service: str, period: str = "weekly") -> str:
"""SLO 달성 현황 리포트 생성."""
slo_file = f".omao/plans/slo/definitions/{service}.yaml"
with open(slo_file) as f:
slo_def = yaml.safe_load(f)
budgets = []
for slo in slo_def["slos"]:
window_days = int(slo.get("window", "30d").replace("d", ""))
good, total = collect_sli(slo)
budget = calculate_error_budget(slo, good, total, window_days)
budgets.append(budget)
# 리포트 생성
now = datetime.utcnow().strftime("%Y-%m-%d")
report = f"""# SLO Report — {service} ({period}: {now})
## Summary
| SLO | Target | Actual | Status | Error Budget | Burn Rate |
|-----|--------|--------|--------|--------------|-----------|
"""
for budget in budgets:
actual = budget.good_events / budget.total_events if budget.total_events > 0 else 0
status = "✅" if budget.remaining_pct > 25 else ("⚠️" if budget.remaining_pct > 10 else "🔴")
report += f"| {budget.slo_name} | {budget.target:.1%} | {actual:.3%} | {status} | {budget.remaining_pct:.1f}% | {budget.burn_rate:.2f}x |\n"
# 정책 상태
policy = evaluate_budget_policy(service, budgets, slo_def["error_budget_policy"])
report += f"""
## Current Policy
- **Mode**: {policy['mode']}
- **Deploy Allowed**: {policy['deploy_allowed']}
- **Limiting SLO**: {policy['limiting_slo']}
- **Deploy Frequency**: {policy.get('deploy_frequency', 'unlimited')}
## Burn Rate Analysis
"""
for budget in budgets:
prediction = predict_budget_exhaustion(budget)
report += f"- **{budget.slo_name}**: burn rate {budget.burn_rate:.2f}x — {prediction['message']}\n"
report += f"""
## Recommendations
"""
for budget in budgets:
if budget.burn_rate > 2.0:
report += f"- 🔴 **{budget.slo_name}**: Burn rate critical. Investigate root cause immediately.\n"
elif budget.burn_rate > 1.5:
report += f"- ⚠️ **{budget.slo_name}**: Burn rate elevated. Consider reducing deploy frequency.\n"
elif budget.remaining_pct < 25:
report += f"- ⚠️ **{budget.slo_name}**: Budget low. Prioritize reliability work.\n"
# 리포트 저장
report_dir = f".omao/plans/slo/reports"
os.makedirs(report_dir, exist_ok=True)
report_file = f"{report_dir}/{service}-{period}-{now}.md"
with open(report_file, "w") as f:
f.write(report)
return report
.omao/plans/slo/definitions/${service}.yaml — SLO 정의.omao/plans/slo/reports/${service}-${period}-${date}.md — SLO 리포트.omao/plans/slo/overrides/${service}.yaml — Error Budget freeze override 사유 기록.omao/state/slo/${service}/current.json — 현재 SLI/Error Budget 상태.omao/state/slo/${service}/deploy-gate.json — 배포 게이트 판정 결과.omao/state/slo/${service}/history.jsonl — SLI 이력 (번다운 차트용).omao/state/slo/${service}/alerts.jsonl — 발행된 알림 이력Input: /slo-management rag-qa-agent
Output (normal):
[10:00:00Z] SLO evaluation for: rag-qa-agent
[10:00:01Z] Collecting SLIs (4 SLOs defined)...
[10:00:03Z] Results:
availability : 99.95% (target 99.9%) — Budget: 72.3% remaining
latency_p99 : 99.2% (target 99.0%) — Budget: 85.1% remaining
quality_faithfulness: 87.2% (target 85.0%) — Budget: 68.5% remaining
error_rate : 99.4% (target 99.0%) — Budget: 61.2% remaining
[10:00:03Z] Policy: NORMAL (min budget: 61.2% from error_rate)
[10:00:03Z] Deploy gate: ALLOWED (unlimited frequency)
[10:00:03Z] Burn rate: all SLOs sustainable (max 0.8x)
[10:00:03Z] State saved to .omao/state/slo/rag-qa-agent/current.json
Output (slow-down):
[10:00:00Z] SLO evaluation for: rag-qa-agent
[10:00:03Z] Results:
availability : 99.85% (target 99.9%) — Budget: 32.1% remaining ⚠️
latency_p99 : 98.5% (target 99.0%) — Budget: 28.4% remaining ⚠️
quality_faithfulness: 86.1% (target 85.0%) — Budget: 55.0% remaining
error_rate : 99.1% (target 99.0%) — Budget: 45.8% remaining
[10:00:03Z] Policy: SLOW-DOWN (min budget: 28.4% from latency_p99)
[10:00:03Z] Deploy gate: ALLOWED (max 1/day)
[10:00:03Z] Burn rate analysis:
latency_p99: 2.3x — Budget will exhaust in 4.2 days ⚠️
availability: 1.8x — Budget will exhaust in 6.1 days ⚠️
[10:00:04Z] Alert fired: notify_and_slow → slack + pagerduty
[10:00:04Z] Recommendation: Investigate latency regression. Consider rollback of recent deploy.
Output (freeze):
[10:00:00Z] SLO evaluation for: rag-qa-agent
[10:00:03Z] Results:
availability : 99.70% (target 99.9%) — Budget: 5.2% remaining 🔴
latency_p99 : 97.8% (target 99.0%) — Budget: 8.1% remaining 🔴
[10:00:03Z] Policy: FREEZE (min budget: 5.2% from availability)
[10:00:03Z] Deploy gate: BLOCKED (security-patch-only)
[10:00:03Z] Burn rate: availability 4.1x — Budget exhausts in 1.3 days
[10:00:04Z] Alert fired: freeze_and_escalate → pagerduty
[10:00:04Z] Action: Deploy freeze applied. incident-response SEV3 triggered.
[10:00:04Z] BLOCKING: OPERATIONS-07 — Error Budget freeze active.
Override: security patches only via .omao/plans/slo/overrides/${service}.yaml
Input: /slo-management rag-qa-agent --report weekly
Output:
[10:00:00Z] Generating weekly SLO report for: rag-qa-agent
[10:00:05Z] Report saved: .omao/plans/slo/reports/rag-qa-agent-weekly-2026-05-08.md
[10:00:05Z] Summary:
3/4 SLOs meeting target
1 SLO at risk (latency_p99: burn rate 2.3x)
Policy: SLOW-DOWN
| 연동 대상 | 방향 | 설명 |
|---|---|---|
continuous-eval | ← 입력 | 품질 SLI (faithfulness 등) 데이터 수신 |
autopilot-deploy | → 출력 | Error Budget 기반 배포 게이트 신호 전달 |
incident-response | ↔ 양방향 | SLO 위반 시 인시던트 생성 / 인시던트가 Error Budget 소진 |
cost-governance | ← 입력 | 비용 SLI 데이터 수신 (cost per request 등) |
anomaly-detection | ← 입력 | SLI 메트릭 이상 탐지 결과 수신 |
predictive-scaling | → 출력 | SLO 위반 위험 시 스케일업 트리거 |