AIOps 기반 이상 탐지 자동화: ML 알림과 Kubernetes 이벤트 상관 분석 가이드

import numpy as np
import pandas as pd
from sklearn.ensemble import IsolationForest
from prometheus_api_client import PrometheusConnect

# Prometheus에서 메트릭 수집
prom = PrometheusConnect(url="http://prometheus:9090", disable_ssl=True)

# 최근 24시간 CPU, 메모리, 네트워크 메트릭 수집
metrics = {}
for metric_name in ['node_cpu_seconds_total', 'node_memory_MemAvailable_bytes', 'node_network_receive_bytes_total']:
    result = prom.custom_query_range(
        query=f'rate({metric_name}[5m])',
        start_time=pd.Timestamp.now() - pd.Timedelta(hours=24),
        end_time=pd.Timestamp.now(),
        step='60s'
    )
    metrics[metric_name] = [float(v[1]) for v in result[0]['values']]

# 다차원 feature 행렬 구성
df = pd.DataFrame(metrics)
df = df.dropna()

# Isolation Forest 학습 및 예측
model = IsolationForest(
    n_estimators=200,         # 트리 개수 (기본 100, 정밀도 향상을 위해 200)
    contamination=0.01,       # 이상치 비율 예상 (1%)
    max_samples='auto',
    random_state=42
)
model.fit(df)

# 예측: -1이면 이상, 1이면 정상
predictions = model.predict(df)
anomaly_scores = model.decision_function(df)

# 이상 탐지 결과 출력
anomalies = df[predictions == -1]
print(f"총 {len(df)}개 샘플 중 {len(anomalies)}개 이상 탐지")
print(f"이상 점수 범위: {anomaly_scores.min():.4f} ~ {anomaly_scores.max():.4f}")

# 이상 탐지 결과를 Prometheus Pushgateway로 전송
from prometheus_client import CollectorRegistry, Gauge, push_to_gateway

registry = CollectorRegistry()
anomaly_gauge = Gauge('aiops_anomaly_score', 'Anomaly score from Isolation Forest',
                      ['metric_group'], registry=registry)
anomaly_gauge.labels(metric_group='node_resources').set(anomaly_scores[-1])
push_to_gateway('pushgateway:9091', job='aiops_anomaly_detection', registry=registry)

from prophet import Prophet
import pandas as pd
from prometheus_api_client import PrometheusConnect

# Prometheus에서 최근 14일 HTTP 요청 수 수집
prom = PrometheusConnect(url="http://prometheus:9090", disable_ssl=True)
result = prom.custom_query_range(
    query='sum(rate(http_requests_total[5m]))',
    start_time=pd.Timestamp.now() - pd.Timedelta(days=14),
    end_time=pd.Timestamp.now(),
    step='300s'
)

# Prophet 입력 형식으로 변환 (ds, y 컬럼 필수)
df = pd.DataFrame({
    'ds': [pd.Timestamp(v[0], unit='s') for v in result[0]['values']],
    'y': [float(v[1]) for v in result[0]['values']]
})

# Prophet 모델 학습
model = Prophet(
    changepoint_prior_scale=0.05,    # 트렌드 변화 민감도 (낮을수록 보수적)
    seasonality_prior_scale=10.0,    # 계절성 강도
    interval_width=0.99,             # 예측 구간 너비 (99% 신뢰 구간)
    daily_seasonality=True,
    weekly_seasonality=True,
)

# 한국 공휴일 추가 (트래픽 패턴 변화 반영)
model.add_country_holidays(country_name='KR')
model.fit(df)

# 동일 기간 예측 수행
forecast = model.predict(df)

# 이상 탐지: 실측값이 예측 구간(yhat_lower, yhat_upper)을 벗어나면 이상
df_merged = df.merge(forecast[['ds', 'yhat', 'yhat_lower', 'yhat_upper']], on='ds')
df_merged['is_anomaly'] = (
    (df_merged['y'] < df_merged['yhat_lower']) |
    (df_merged['y'] > df_merged['yhat_upper'])
)

anomalies = df_merged[df_merged['is_anomaly']]
print(f"Prophet 이상 탐지 결과: {len(anomalies)}건의 이상 감지")

# 이상 발생 시 상세 정보 출력
for _, row in anomalies.iterrows():
    deviation = abs(row['y'] - row['yhat']) / row['yhat'] * 100
    direction = "급증" if row['y'] > row['yhat_upper'] else "급감"
    print(f"  [{row['ds']}] 트래픽 {direction}: "
          f"실측={row['y']:.1f}, 예측={row['yhat']:.1f}, "
          f"편차={deviation:.1f}%")

# prometheus-rules.yaml
# 전통적 임계값 알림과 ML 이상 탐지 알림을 동시 운용
groups:
  - name: traditional_threshold_alerts
    rules:
      # Level 1: 고정 임계값 알림 (즉각 대응 필요)
      - alert: HighCPUUsageCritical
        expr: |
          100 - (avg by(instance) (rate(node_cpu_seconds_total{mode="idle"}[5m])) * 100) > 95
        for: 5m
        labels:
          severity: critical
          alert_type: threshold
        annotations:
          summary: 'CPU 사용률 95% 초과 ({{ $labels.instance }})'
          description: '{{ $labels.instance }}의 CPU 사용률이 {{ $value | printf "%.1f" }}%입니다.'

      # Level 1: 메모리 임계값 알림
      - alert: HighMemoryUsageCritical
        expr: |
          (1 - node_memory_MemAvailable_bytes / node_memory_MemTotal_bytes) * 100 > 90
        for: 10m
        labels:
          severity: critical
          alert_type: threshold
        annotations:
          summary: '메모리 사용률 90% 초과 ({{ $labels.instance }})'

  - name: aiops_ml_anomaly_alerts
    rules:
      # Level 2: ML 기반 이상 탐지 알림 (Pushgateway에서 수집)
      - alert: MLAnomalyDetected
        expr: |
          aiops_anomaly_score < -0.5
        for: 3m
        labels:
          severity: warning
          alert_type: ml_anomaly
        annotations:
          summary: 'ML 이상 탐지: {{ $labels.metric_group }}에서 비정상 패턴 감지'
          description: |
            Isolation Forest 이상 점수: {{ $value | printf "%.4f" }}
            점수가 -0.5 미만이면 통계적으로 유의미한 이상입니다.
            대시보드: http://grafana:3000/d/aiops-anomaly

      # Level 2: Prophet 기반 트래픽 이상 탐지
      - alert: TrafficAnomalyDetected
        expr: |
          aiops_prophet_anomaly_flag == 1
        for: 5m
        labels:
          severity: warning
          alert_type: prophet_anomaly
        annotations:
          summary: 'Prophet 예측 벗어남: 트래픽 이상 패턴 감지'
          description: |
            실측값이 99% 예측 구간을 벗어났습니다.
            편차: {{ $labels.deviation_pct }}%

#!/bin/bash
# k8s-event-correlation.sh
# Kubernetes 이벤트 상관 분석 스크립트
# 사용법: ./k8s-event-correlation.sh [namespace] [minutes]

NAMESPACE=${1:-"default"}
MINUTES=${2:-30}
SINCE=$(date -u -d "${MINUTES} minutes ago" +"%Y-%m-%dT%H:%M:%SZ" 2>/dev/null || \
        date -u -v-${MINUTES}M +"%Y-%m-%dT%H:%M:%SZ")

echo "========================================"
echo " K8s 이벤트 상관 분석 보고서"
echo " 네임스페이스: ${NAMESPACE}"
echo " 분석 범위: 최근 ${MINUTES}분"
echo " 시작 시각: ${SINCE}"
echo "========================================"

# 1단계: Warning 이벤트 수집 및 빈도 분석
echo ""
echo "[1/4] Warning 이벤트 빈도 분석"
echo "----------------------------------------"
kubectl get events -n "${NAMESPACE}" \
  --field-selector type=Warning \
  --sort-by='.lastTimestamp' \
  -o custom-columns='TIME:.lastTimestamp,TYPE:.type,REASON:.reason,OBJECT:.involvedObject.name,MESSAGE:.message' \
  | tail -50

# 2단계: OOMKilled Pod 탐지
echo ""
echo "[2/4] OOMKilled Pod 탐지"
echo "----------------------------------------"
kubectl get pods -n "${NAMESPACE}" -o json | \
  jq -r '.items[] |
    select(.status.containerStatuses[]?.lastState.terminated.reason == "OOMKilled") |
    "\(.metadata.name) | 재시작: \(.status.containerStatuses[0].restartCount) | 마지막 OOM: \(.status.containerStatuses[0].lastState.terminated.finishedAt)"'

# 3단계: 노드 상태 분석 (메모리/디스크 압박)
echo ""
echo "[3/4] 노드 Condition 분석"
echo "----------------------------------------"
kubectl get nodes -o json | \
  jq -r '.items[] |
    .metadata.name as $node |
    .status.conditions[] |
    select(.type != "Ready" and .status == "True") |
    "\($node) | \(.type): \(.message)"'

# 4단계: 최근 디플로이먼트 변경 이력
echo ""
echo "[4/4] 최근 디플로이먼트 롤아웃 이력"
echo "----------------------------------------"
for deploy in $(kubectl get deployments -n "${NAMESPACE}" -o name); do
  echo "--- ${deploy} ---"
  kubectl rollout history "${deploy}" -n "${NAMESPACE}" | tail -5
done

# 상관 분석 요약
echo ""
echo "========================================"
echo " 상관 분석 요약"
echo "========================================"
echo ""

# OOMKill과 노드 메모리 압박의 상관관계 체크
OOM_COUNT=$(kubectl get pods -n "${NAMESPACE}" -o json | \
  jq '[.items[] | select(.status.containerStatuses[]?.lastState.terminated.reason == "OOMKilled")] | length')
NODE_PRESSURE=$(kubectl get nodes -o json | \
  jq '[.items[] | .status.conditions[] | select(.type == "MemoryPressure" and .status == "True")] | length')

if [ "$OOM_COUNT" -gt 0 ] && [ "$NODE_PRESSURE" -gt 0 ]; then
  echo "[높은 상관] OOMKill(${OOM_COUNT}건)과 노드 메모리 압박(${NODE_PRESSURE}건) 동시 발생"
  echo "  -> 근본 원인 후보: 노드 메모리 부족 또는 리소스 limits 과다 설정"
elif [ "$OOM_COUNT" -gt 0 ]; then
  echo "[중간 상관] OOMKill(${OOM_COUNT}건) 발생, 노드 압박 없음"
  echo "  -> 근본 원인 후보: 컨테이너 메모리 limits 부족 또는 메모리 릭"
fi

echo ""
echo "분석 완료. 상세 조사가 필요하면 Grafana 대시보드를 확인하세요."

# robusta-playbook.yaml
# Robusta Playbook: Kubernetes 이벤트 자동 상관 분석
customPlaybooks:
  # OOMKill 발생 시 자동 분석
  - triggers:
      - on_pod_oom_killed:
          namespace_prefix: 'production'
    actions:
      # 1. OOMKilled Pod의 메모리 사용 그래프 수집
      - resource_babysitter:
          fields_to_monitor: ['status.containerStatuses']
      # 2. Prometheus에서 관련 메트릭 수집
      - prometheus_enricher:
          prometheus_url: 'http://prometheus:9090'
          query: |
            container_memory_working_set_bytes{
              pod="{{ $pod_name }}",
              namespace="{{ $namespace }}"
            }
          duration_minutes: 60
      # 3. 동일 노드의 다른 Pod 상태 확인
      - node_running_pods_enricher: {}
      # 4. Slack으로 분석 결과 전송
      - slack_sender:
          slack_channel: '#k8s-alerts'
          message: |
            :rotating_light: OOMKill 상관 분석 보고서
            Pod: {{ $pod_name }}
            네임스페이스: {{ $namespace }}
            노드: {{ $node }}
            메모리 사용 추이 및 동일 노드 Pod 상태가 첨부됩니다.

  # CPU Throttling 발생 시 자동 분석
  - triggers:
      - on_prometheus_alert:
          alert_name: CPUThrottlingHigh
          status: 'firing'
    actions:
      - cpu_throttling_analysis: {}
      - prometheus_enricher:
          prometheus_url: 'http://prometheus:9090'
          query: |
            rate(container_cpu_cfs_throttled_periods_total{
              pod="{{ $pod_name }}"
            }[5m])
          duration_minutes: 30
      - slack_sender:
          slack_channel: '#k8s-alerts'

  # 디플로이먼트 변경 후 에러율 증가 시 자동 상관 분석
  - triggers:
      - on_deployment_update:
          namespace_prefix: 'production'
    actions:
      - deployment_status_enricher: {}
      - prometheus_enricher:
          prometheus_url: 'http://prometheus:9090'
          query: |
            sum(rate(http_requests_total{status=~"5.."}[5m])) /
            sum(rate(http_requests_total[5m])) * 100
          duration_minutes: 15