# values 파일 생성 (리소스 절약 설정)
cat > prometheus-values.yaml << 'EOF'
# Grafana 설정
grafana:
  service:
    type: NodePort              # 로컬 접근용 (프로덕션에서는 Ingress 사용)
  persistence:
    enabled: false              # 실습용 (프로덕션에서는 true)

# Prometheus 설정
prometheus:
  prometheusSpec:
    retention: 15d              # 메트릭 보존 기간
    storageSpec:
      volumeClaimTemplate:
        spec:
          resources:
            requests:
              storage: 10Gi
    # 모든 네임스페이스의 ServiceMonitor를 허용
    serviceMonitorSelectorNilUsesHelmValues: false
    podMonitorSelectorNilUsesHelmValues: false

# Alertmanager 설정
alertmanager:
  alertmanagerSpec:
    storage:
      volumeClaimTemplate:
        spec:
          resources:
            requests:
              storage: 2Gi
EOF

# 스택 설치
read -r -s GRAFANA_ADMIN_PASSWORD && echo
export GRAFANA_ADMIN_PASSWORD
helm install kube-prometheus-stack \
  prometheus-community/kube-prometheus-stack \
  --namespace monitoring \
  --create-namespace \
  -f prometheus-values.yaml \
  --set-string grafana.adminPassword="$GRAFANA_ADMIN_PASSWORD" \
  --wait \
  --timeout 10m

# 설치 확인
kubectl get pods -n monitoring
# NAME                                                     READY   STATUS
# alertmanager-kube-prometheus-stack-alertmanager-0        2/2     Running
# kube-prometheus-stack-grafana-7d9f6b8d4c-xk2p9          3/3     Running
# kube-prometheus-stack-kube-state-metrics-xxx             1/1     Running
# kube-prometheus-stack-operator-xxx                       1/1     Running
# prometheus-kube-prometheus-stack-prometheus-0            2/2     Running
# kube-prometheus-stack-prometheus-node-exporter-xxx       1/1     Running  (각 노드)

# NodePort로 접근 (minikube/kind)
kubectl get svc -n monitoring kube-prometheus-stack-grafana
# NAME                              TYPE       CLUSTER-IP    PORT(S)
# kube-prometheus-stack-grafana     NodePort   10.96.x.x     80:32xxx/TCP

# minikube의 경우
minikube service kube-prometheus-stack-grafana -n monitoring

# 또는 포트포워딩으로 접근
kubectl port-forward -n monitoring svc/kube-prometheus-stack-grafana 3000:80 &
# → http://localhost:3000 접속 (admin / 입력한 GRAFANA_ADMIN_PASSWORD)

Grafana 로그인 후 Dashboards → Browse:
  - Kubernetes / Cluster       — 클러스터 전체 리소스 사용률
  - Kubernetes / Nodes         — 노드별 CPU/Memory/Disk
  - Kubernetes / Workloads     — Deployment/DaemonSet 상태
  - Kubernetes / Pods          — 파드별 상세 메트릭
  - Kubernetes / Namespaces    — 네임스페이스별 리소스
  - Node Exporter / Full       — 노드 상세 시스템 메트릭

[Operator]  ServiceMonitor 생성  (selector: app=sample-app)
   │
   ① 서비스 디스커버리   (Operator가 SM→Service→Endpoints를 scrape 대상으로 변환)
   │    → 타깃 목록이 /service-discovery 에 등장 (파드 IP 자동 추적)
   │
   ② 주기적 Scrape       (scrape_interval마다 각 타깃의 GET /metrics 를 HTTP pull)
   │    → 성공 시 up{...}=1, /targets 에서 State=UP
   │
   ③ 라벨 부착 + TSDB 저장 (job·instance·pod 라벨을 붙여 시계열 샘플로 append)
   │
   ④ 룰 평가(PromQL)     (evaluation_interval마다 alerting rule 식을 계산)
   │    → 조건이 for 기간만큼 참이면 alert가 Pending→Firing
   │
   ⑤ Alertmanager 통지   (Firing 알림을 push → 그룹화·억제·음소거·라우팅)
   ▼
[결과]  Slack·PagerDuty 로 묶인 통지 1건

# sample-app.yaml — /metrics 엔드포인트가 있는 nginx
apiVersion: apps/v1
kind: Deployment
metadata:
  name: sample-app
  namespace: default
  labels:
    app: sample-app
spec:
  replicas: 2
  selector:
    matchLabels:
      app: sample-app
  template:
    metadata:
      labels:
        app: sample-app
        version: "1.0"
    spec:
      containers:
        - name: app
          image: quay.io/brancz/prometheus-example-app:v0.3.0
          ports:
            - name: http
              containerPort: 8080
          resources:
            requests:
              cpu: 50m
              memory: 32Mi
---
apiVersion: v1
kind: Service
metadata:
  name: sample-app
  namespace: default
  labels:
    app: sample-app              # ServiceMonitor가 이 레이블로 찾음
spec:
  selector:
    app: sample-app
  ports:
    - name: http                 # 포트 이름이 ServiceMonitor의 port와 일치해야 함
      port: 8080
      targetPort: 8080

# servicemonitor-sample.yaml
apiVersion: monitoring.coreos.com/v1
kind: ServiceMonitor
metadata:
  name: sample-app
  namespace: default
  labels:
    release: kube-prometheus-stack  # Prometheus가 이 레이블로 ServiceMonitor를 선택
spec:
  # scrape할 Service를 레이블로 선택
  selector:
    matchLabels:
      app: sample-app              # Service의 labels.app: sample-app

  # 여러 네임스페이스에 걸친 Service 선택 (기본: 동일 네임스페이스)
  namespaceSelector:
    matchNames:
      - default
      - production

  # scrape 엔드포인트 설정
  endpoints:
    - port: http                   # Service의 port 이름과 일치
      path: /metrics               # 메트릭 경로 (기본값)
      interval: 30s                # scrape 간격
      scrapeTimeout: 10s           # 타임아웃
      # TLS 설정 (HTTPS 엔드포인트의 경우)
      # tlsConfig:
      #   insecureSkipVerify: true

kubectl apply -f sample-app.yaml
kubectl apply -f servicemonitor-sample.yaml

# Prometheus UI에서 타겟 확인 (약 1분 후)
kubectl port-forward -n monitoring svc/prometheus-kube-prometheus-stack-prometheus 9090:9090 &
# → http://localhost:9090/targets 접속
# status=UP으로 표시되면 수집 중

# Service 없이 파드를 직접 scrape할 때 PodMonitor 사용
apiVersion: monitoring.coreos.com/v1
kind: PodMonitor
metadata:
  name: batch-jobs
  namespace: default
  labels:
    release: kube-prometheus-stack
spec:
  selector:
    matchLabels:
      app: batch-processor
  podMetricsEndpoints:
    - port: metrics                # 파드 containerPort 이름
      path: /metrics
      interval: 60s               # 배치 잡은 긴 간격

# ServiceMonitor: Service → Endpoints를 통해 파드 자동 추적
# PodMonitor:     Service 없이 파드를 직접 레이블로 선택

# --- Gauge (현재 상태값) ---
# 현재 메모리 사용률 (%)
100 - (node_memory_MemAvailable_bytes / node_memory_MemTotal_bytes * 100)

# 파드별 메모리 사용량 (MiB)
container_memory_working_set_bytes{container!=""} / 1024 / 1024

# --- Counter (단조 증가값) — rate()로 변화율 계산 ---
# 초당 HTTP 요청 수
rate(http_requests_total[5m])

# 초당 에러 요청 수 (5xx)
rate(http_requests_total{status=~"5.."}[5m])

# --- Histogram — 분위수 계산 ---
# HTTP 응답시간 P99 (99th percentile)
histogram_quantile(
  0.99,
  rate(http_request_duration_seconds_bucket[5m])
)

# HTTP 응답시간 P50, P95, P99 비교
histogram_quantile(0.50, rate(http_request_duration_seconds_bucket[5m]))
histogram_quantile(0.95, rate(http_request_duration_seconds_bucket[5m]))
histogram_quantile(0.99, rate(http_request_duration_seconds_bucket[5m]))

# 서비스별 초당 요청 수 합계
sum(rate(http_requests_total[5m])) by (service)
# 결과:
# {service="auth"}      → 45.2
# {service="payment"}   → 12.1
# {service="catalog"}   → 150.3

# 네임스페이스별 파드 수
count(kube_pod_info) by (namespace)

# 파드별 CPU 사용률 상위 5개
topk(5, rate(container_cpu_usage_seconds_total{container!=""}[5m]))

# 노드별 CPU 사용률 (전체 대비 %)
100 * (1 - avg by (instance) (
  rate(node_cpu_seconds_total{mode="idle"}[5m])
))

# Deployment 파드 가용률
kube_deployment_status_replicas_available / kube_deployment_spec_replicas

# 파드 재시작 횟수 증가율 (크래시 루프 감지)
rate(kube_pod_container_status_restarts_total[15m]) * 60

# OOMKilled 파드 감지
kube_pod_container_status_last_terminated_reason{reason="OOMKilled"}

# PersistentVolume 사용률
(
  kubelet_volume_stats_used_bytes /
  kubelet_volume_stats_capacity_bytes
) * 100

# 노드별 할당 가능 CPU 대비 요청 비율
sum(kube_pod_container_resource_requests{resource="cpu"}) by (node) /
sum(kube_node_status_allocatable{resource="cpu"}) by (node) * 100

1. Grafana → Explore (나침반 아이콘) → Prometheus 데이터 소스 선택
2. 쿼리 입력 후 Run Query
3. 시각화: Graph, Stat, Table, Heatmap 등 선택
4. Dashboard에 패널 추가: "Add to Dashboard" 버튼

# prometheus-rules.yaml
apiVersion: monitoring.coreos.com/v1
kind: PrometheusRule
metadata:
  name: app-alerts
  namespace: default
  labels:
    release: kube-prometheus-stack  # Prometheus가 선택하는 레이블
spec:
  groups:
    - name: availability            # 알림 그룹 이름
      interval: 30s                 # 평가 간격
      rules:
        # 파드 크래시 루프 감지
        - alert: PodCrashLooping
          expr: |
            rate(kube_pod_container_status_restarts_total[15m]) * 60 > 0
          for: 5m                   # 5분간 지속될 때만 발화
          labels:
            severity: critical
            team: platform
          annotations:
            summary: "파드 {{ $labels.pod }}가 크래시 루프 중"
            description: |
              네임스페이스 {{ $labels.namespace }}의 파드
              {{ $labels.pod }} (컨테이너: {{ $labels.container }})가
              지난 15분간 {{ printf "%.1f" $value }}회/분 재시작되고 있습니다.

        # 고에러율 감지
        - alert: HighErrorRate
          expr: |
            sum(rate(http_requests_total{status=~"5.."}[5m])) by (service)
            /
            sum(rate(http_requests_total[5m])) by (service)
            > 0.05
          for: 2m
          labels:
            severity: warning
            team: backend
          annotations:
            summary: "{{ $labels.service }} 에러율 {{ printf \"%.1f\" $value | humanizePercentage }}"
            description: "서비스 {{ $labels.service }}의 5xx 에러율이 5%를 초과했습니다."

        # 높은 응답시간 감지
        - alert: HighResponseTime
          expr: |
            histogram_quantile(
              0.99,
              rate(http_request_duration_seconds_bucket[5m])
            ) > 1.0
          for: 5m
          labels:
            severity: warning
          annotations:
            summary: "{{ $labels.service }} P99 응답시간 1초 초과"
            description: "{{ $labels.service }}의 P99 응답시간이 {{ printf \"%.2f\" $value }}초입니다."

    - name: resources
      rules:
        # 노드 메모리 고갈 임박
        - alert: NodeMemoryPressure
          expr: |
            100 - (
              node_memory_MemAvailable_bytes /
              node_memory_MemTotal_bytes * 100
            ) > 85
          for: 10m
          labels:
            severity: warning
          annotations:
            summary: "노드 {{ $labels.instance }} 메모리 부족"
            description: "메모리 사용률 {{ printf \"%.1f\" $value }}%"

        # PV 용량 임박
        - alert: PersistentVolumeAlmostFull
          expr: |
            (
              kubelet_volume_stats_used_bytes /
              kubelet_volume_stats_capacity_bytes
            ) * 100 > 80
          for: 15m
          labels:
            severity: warning
          annotations:
            summary: "PV {{ $labels.persistentvolumeclaim }} 용량 {{ printf \"%.1f\" $value }}% 사용"

# alertmanager-config.yaml (Helm values에 포함하거나 Secret으로 배포)
alertmanager:
  config:
    global:
      resolve_timeout: 5m
      slack_api_url: "https://hooks.slack.com/services/xxx/yyy/zzz"

    route:
      group_by: ["alertname", "namespace"]
      group_wait: 30s       # 그룹 내 첫 알림 대기 (더 쌓이길 기다림)
      group_interval: 5m    # 같은 그룹 알림 간격
      repeat_interval: 12h  # 해결 안 됐을 때 반복 간격
      receiver: "slack-general"

      routes:
        - match:
            severity: critical
          receiver: "pagerduty-oncall"

        - match:
            team: backend
          receiver: "slack-backend"

    receivers:
      - name: "slack-general"
        slack_configs:
          - channel: "#alerts"
            title: "{{ .GroupLabels.alertname }}"
            text: "{{ range .Alerts }}{{ .Annotations.description }}{{ end }}"

      - name: "slack-backend"
        slack_configs:
          - channel: "#backend-alerts"
            send_resolved: true

      - name: "pagerduty-oncall"
        pagerduty_configs:
          - routing_key: "YOUR_INTEGRATION_KEY"
            severity: "{{ .CommonLabels.severity }}"

kubectl apply -f prometheus-rules.yaml

# 알림 규칙이 Prometheus에 반영됐는지 확인
# http://localhost:9090/rules → "app-alerts" 그룹 확인