Prometheus·Alertmanager 알림 파이프라인 구축: 규칙 작성부터 PagerDuty·Slack 라우팅까지

groups:
  - name: infrastructure-alerts
    interval: 30s
    rules:
      # CPU 사용률이 5분간 80% 이상 지속
      - alert: HighCpuUsage
        expr: |
          100 - (avg by (instance) (rate(node_cpu_seconds_total{mode="idle"}[5m])) * 100) > 80
        for: 5m
        labels:
          severity: warning
          team: infra
        annotations:
          summary: 'CPU 사용률 높음'
          description: '인스턴스 {{ $labels.instance }}의 CPU 사용률이 {{ $value | printf "%.1f" }}%입니다.'
          runbook_url: 'https://wiki.internal/runbook/high-cpu'

      # 메모리 사용률 90% 초과
      - alert: HighMemoryUsage
        expr: |
          (1 - node_memory_MemAvailable_bytes / node_memory_MemTotal_bytes) * 100 > 90
        for: 5m
        labels:
          severity: warning
          team: infra
        annotations:
          summary: '메모리 사용률 높음'
          description: '인스턴스 {{ $labels.instance }}의 메모리 사용률이 {{ $value | printf "%.1f" }}%입니다.'

      # 디스크 24시간 내 고갈 예측
      - alert: DiskWillFillIn24Hours
        expr: |
          predict_linear(node_filesystem_avail_bytes{fstype!~"tmpfs|overlay"}[6h], 24*3600) < 0
        for: 10m
        labels:
          severity: critical
          team: infra
        annotations:
          summary: '디스크 24시간 내 고갈 예측'
          description: '인스턴스 {{ $labels.instance }}의 마운트포인트 {{ $labels.mountpoint }}가 24시간 내 고갈될 것으로 예측됩니다.'
          runbook_url: 'https://wiki.internal/runbook/disk-full'

groups:
  - name: slo-burn-rate-alerts
    rules:
      # 에러율 Recording Rule (사전 계산)
      - record: slo:http_error_rate:ratio_rate5m
        expr: |
          sum(rate(http_requests_total{status=~"5.."}[5m])) by (service)
          /
          sum(rate(http_requests_total[5m])) by (service)

      - record: slo:http_error_rate:ratio_rate30m
        expr: |
          sum(rate(http_requests_total{status=~"5.."}[30m])) by (service)
          /
          sum(rate(http_requests_total[30m])) by (service)

      - record: slo:http_error_rate:ratio_rate1h
        expr: |
          sum(rate(http_requests_total{status=~"5.."}[1h])) by (service)
          /
          sum(rate(http_requests_total[1h])) by (service)

      - record: slo:http_error_rate:ratio_rate6h
        expr: |
          sum(rate(http_requests_total{status=~"5.."}[6h])) by (service)
          /
          sum(rate(http_requests_total[6h])) by (service)

      # SLO 99.9% (에러 버짓 0.1%)
      # 빠른 소진: 5m/30m 윈도우, burn rate 14.4x → 1시간 내 버짓 소진 속도
      - alert: SloHighBurnRate
        expr: |
          slo:http_error_rate:ratio_rate5m{service="api-gateway"} > (14.4 * 0.001)
          and
          slo:http_error_rate:ratio_rate30m{service="api-gateway"} > (14.4 * 0.001)
        for: 2m
        labels:
          severity: critical
          slo: 'availability'
          window: 'fast'
        annotations:
          summary: 'SLO 빠른 소진 감지 - 즉시 대응 필요'
          description: 'api-gateway의 에러 버짓이 1시간 내 소진될 속도로 감소 중입니다.'

      # 느린 소진: 1h/6h 윈도우, burn rate 6x → 4시간 내 버짓 소진 속도
      - alert: SloMediumBurnRate
        expr: |
          slo:http_error_rate:ratio_rate1h{service="api-gateway"} > (6 * 0.001)
          and
          slo:http_error_rate:ratio_rate6h{service="api-gateway"} > (6 * 0.001)
        for: 5m
        labels:
          severity: warning
          slo: 'availability'
          window: 'slow'
        annotations:
          summary: 'SLO 느린 소진 감지 - 조사 필요'
          description: 'api-gateway의 에러 버짓이 4시간 내 소진될 속도로 감소 중입니다.'

# alert_test.yaml
rule_files:
  - infrastructure_alerts.yaml

evaluation_interval: 1m

tests:
  # 테스트 1: CPU 80% 이상 5분 지속 시 firing
  - interval: 1m
    input_series:
      - series: 'node_cpu_seconds_total{mode="idle",instance="node1:9100",cpu="0"}'
        values: '0+0.15x20' # 매분 0.15초 idle = 85% 사용률
      - series: 'node_cpu_seconds_total{mode="idle",instance="node1:9100",cpu="1"}'
        values: '0+0.15x20'
    alert_rule_test:
      # 4분 시점: pending 상태여야 함 (for: 5m 미충족)
      - eval_time: 4m
        alertname: HighCpuUsage
        exp_alerts: []
      # 6분 시점: firing 상태여야 함
      - eval_time: 6m
        alertname: HighCpuUsage
        exp_alerts:
          - exp_labels:
              severity: warning
              team: infra
              instance: 'node1:9100'
            exp_annotations:
              summary: 'CPU 사용률 높음'

  # 테스트 2: 메모리 90% 미만이면 알림 없음
  - interval: 1m
    input_series:
      - series: 'node_memory_MemAvailable_bytes{instance="node1:9100"}'
        values: '2147483648x10' # 2GB available
      - series: 'node_memory_MemTotal_bytes{instance="node1:9100"}'
        values: '8589934592x10' # 8GB total = 75% 사용
    alert_rule_test:
      - eval_time: 10m
        alertname: HighMemoryUsage
        exp_alerts: []

# 문법 검증
promtool check rules infrastructure_alerts.yaml
promtool check rules slo_alerts.yaml

# 단위 테스트 실행
promtool test rules alert_test.yaml

# Alertmanager 설정 검증
amtool check-config alertmanager.yaml

# CI 파이프라인 예시 (GitHub Actions)
# jobs:
#   validate-alerts:
#     steps:
#       - name: Check alert rules syntax
#         run: promtool check rules rules/*.yaml
#       - name: Run alert rule tests
#         run: promtool test rules tests/*.yaml
#       - name: Check Alertmanager config
#         run: amtool check-config alertmanager.yaml

# alertmanager.yaml
global:
  resolve_timeout: 5m
  smtp_smarthost: 'smtp.internal:587'
  smtp_from: 'alertmanager@company.com'

route:
  receiver: default-slack
  group_by: [alertname, cluster, namespace]
  group_wait: 30s # 첫 알림 수신 후 그룹핑을 위해 대기
  group_interval: 5m # 기존 그룹에 새 알림 추가 시 재전송 간격
  repeat_interval: 4h # 동일 알림 반복 전송 간격

  routes:
    # Critical 알림 → PagerDuty (즉시 페이징)
    - match:
        severity: critical
      receiver: pagerduty-critical
      group_wait: 10s
      repeat_interval: 1h
      continue: true # Slack에도 동시 전송

    # Critical 알림 → Slack critical 채널 (동시 전송)
    - match:
        severity: critical
      receiver: slack-critical

    # SLO 관련 알림 → SRE 팀 전용 채널
    - match_re:
        alertname: '^Slo.*'
      receiver: slack-sre-slo
      group_by: [alertname, service]

    # 인프라 팀 알림
    - match:
        team: infra
      receiver: slack-infra
      group_by: [alertname, instance]

    # 백엔드 팀 알림
    - match:
        team: backend
      receiver: slack-backend
      group_by: [alertname, service, namespace]

    # Watchdog 알림 (Alertmanager 정상 동작 확인용)
    - match:
        alertname: Watchdog
      receiver: 'null'
      repeat_interval: 24h

# alertmanager.yaml (inhibition section)
inhibit_rules:
  # 노드 다운 시 해당 노드의 모든 하위 알림 억제
  - source_matchers:
      - alertname = NodeDown
    target_matchers:
      - severity =~ "warning|info"
    equal: [instance]

  # 클러스터 레벨 장애 시 개별 서비스 알림 억제
  - source_matchers:
      - alertname = ClusterUnreachable
    target_matchers:
      - severity =~ "warning|critical"
    equal: [cluster]

  # Critical이 firing 중이면 동일 알림의 Warning 억제
  - source_matchers:
      - severity = critical
    target_matchers:
      - severity = warning
    equal: [alertname, cluster, namespace]

  # 대규모 장애 시 SLO 알림 억제 (인프라 레벨 문제이므로)
  - source_matchers:
      - alertname =~ "NodeDown|ClusterUnreachable"
    target_matchers:
      - alertname =~ "^Slo.*"
    equal: [cluster]

# amtool로 Silence 생성 (2시간 동안 특정 클러스터 알림 중지)
amtool silence add \
  --alertmanager.url=http://alertmanager:9093 \
  --author="sre-team" \
  --comment="Planned maintenance: k8s cluster upgrade" \
  --duration=2h \
  cluster="production-us-east-1"

# 활성 Silence 목록 확인
amtool silence query --alertmanager.url=http://alertmanager:9093

# Silence 해제
amtool silence expire --alertmanager.url=http://alertmanager:9093 <silence-id>

# alertmanager.yaml (receivers section)
receivers:
  # 기본 수신자: Slack general 채널
  - name: default-slack
    slack_configs:
      - api_url: 'https://hooks.slack.com/services/T00/B00/XXXXX'
        channel: '#alerts-general'
        send_resolved: true
        title: '{{ if eq .Status "firing" }}FIRING{{ else }}RESOLVED{{ end }} - {{ .CommonLabels.alertname }}'
        text: >-
          *Severity:* {{ .CommonLabels.severity | toUpper }}
          *Cluster:* {{ .CommonLabels.cluster }}
          *Namespace:* {{ .CommonLabels.namespace }}
          {{ range .Alerts }}
          - *{{ .Labels.instance }}*: {{ .Annotations.description }}
          {{ end }}

  # PagerDuty Critical 수신자
  - name: pagerduty-critical
    pagerduty_configs:
      - service_key_file: '/etc/alertmanager/secrets/pagerduty-service-key'
        severity: '{{ .CommonLabels.severity }}'
        description: '{{ .CommonAnnotations.summary }}'
        details:
          firing: '{{ .Alerts.Firing | len }}'
          resolved: '{{ .Alerts.Resolved | len }}'
          cluster: '{{ .CommonLabels.cluster }}'
          namespace: '{{ .CommonLabels.namespace }}'
          runbook_url: '{{ .CommonAnnotations.runbook_url }}'

  # Slack Critical 채널 (PagerDuty와 동시 전송)
  - name: slack-critical
    slack_configs:
      - api_url: 'https://hooks.slack.com/services/T00/B00/YYYYY'
        channel: '#alerts-critical'
        send_resolved: true
        color: '{{ if eq .Status "firing" }}danger{{ else }}good{{ end }}'
        title: 'CRITICAL: {{ .CommonLabels.alertname }}'
        text: >-
          *Status:* {{ .Status | toUpper }}
          {{ range .Alerts }}
          - {{ .Annotations.description }}
            Runbook: {{ .Annotations.runbook_url }}
          {{ end }}

  # SRE SLO 전용 채널
  - name: slack-sre-slo
    slack_configs:
      - api_url: 'https://hooks.slack.com/services/T00/B00/ZZZZZ'
        channel: '#sre-slo-alerts'
        send_resolved: true
        title: 'SLO Alert: {{ .CommonLabels.alertname }}'
        text: >-
          *Service:* {{ .CommonLabels.service }}
          *Window:* {{ .CommonLabels.window }}
          {{ range .Alerts }}
          - {{ .Annotations.description }}
          {{ end }}

  # 인프라 팀 채널
  - name: slack-infra
    slack_configs:
      - api_url: 'https://hooks.slack.com/services/T00/B00/INFRA'
        channel: '#team-infra-alerts'
        send_resolved: true

  # 백엔드 팀 채널
  - name: slack-backend
    slack_configs:
      - api_url: 'https://hooks.slack.com/services/T00/B00/BACKEND'
        channel: '#team-backend-alerts'
        send_resolved: true

  # Null 수신자 (Watchdog 등 불필요한 알림 흡수)
  - name: 'null'

# amtool로 라우팅 경로 시뮬레이션
amtool config routes test \
  --config.file=alertmanager.yaml \
  --tree \
  severity=critical team=payments alertname=HighErrorRate

# 예상 출력: pagerduty-critical → slack-critical
# team=payments 라벨이 없는 경우: default-slack (경고 발생)