13년차의 서버실

서버, 인프라, 홈랩 기술 블로그

[태그:] Grafana

  • [k8s] Loki로 Kubernetes 로그 중앙화: 효율적인 모니터링 구축 가이드

    [k8s] Loki로 Kubernetes 로그 중앙화: 효율적인 모니터링 구축 가이드

    [k8s] Loki로 Kubernetes 로그 중앙화: 효율적인 모니터링 구축 가이드

    Kubernetes 환경을 운영하다 보면 결국 로그 때문에 한 번은 크게 삽질하게 됩니다. Pod(파드)가 재시작되면 이전 로그가 날아가고, 노드가 여러 대로 늘어나면 어디서 무슨 에러가 터졌는지 찾는 데 시간이 꽤 걸리거든요. 저도 홈랩과 실무 환경에서 비슷한 문제를 겪으면서 Loki Kubernetes 로그 구성을 진지하게 붙잡게 됐습니다. 처음엔 “그냥 kubectl logs로 보면 되지 않나?” 싶었는데, 운영 규모가 조금만 커져도 그 방식은 금방 한계가 오더라고요.

    그래서 이번 글에서는 Grafana Loki를 기준으로 Kubernetes 로그 수집과 중앙 집중형 로깅 구성을 어떻게 가져가면 좋은지, 제가 직접 해보면서 정리한 흐름으로 풀어보겠습니다. 너무 이론만 길게 가지 않고, 바로 써먹을 수 있는 형태로 설명드릴게요.

    Loki, Promtail, Grafana, Kubernetes 노드와 애플리케이션 로그 흐름을 한눈에 보여주는 전체 구성도입니다.

    Loki로 Kubernetes 로그를 모아야 하는 이유

    쉽게 말해 Loki는 로그를 저장하고 검색하기 위한 시스템입니다. 로그 전체를 무겁게 색인(indexing)하는 방식보다는, 메타데이터(label) 중심으로 다루는 접근이 특징이죠. 이게 왜 좋냐면, 운영 입장에서 필요한 로그를 비교적 효율적으로 모으고 찾는 데 유리하거든요.

    제가 처음 Loki를 붙여봤을 때 좋았던 점은 딱 세 가지였습니다.

    • Grafana(그라파나)와 궁합이 좋습니다. 로그 조회 화면이 익숙해서 진입 장벽이 낮더라고요.
    • Kubernetes 로그 수집 흐름을 만들기 편합니다. 특히 DaemonSet(데몬셋) 기반 수집기가 노드별 로그를 긁어오는 구조가 이해하기 쉬웠습니다.
    • 메트릭(metrics), 로그(logs), 추적(traces) 관측 체계를 한 방향으로 정리하기 좋습니다.

    물론 무조건 Loki만 정답은 아닙니다. Elasticsearch(엘라스틱서치) 계열이 더 맞는 조직도 있습니다. 다만 “복잡도를 조금 낮추면서 Kubernetes 로그를 중앙에서 보고 싶다”는 목적이라면 Loki는 꽤 현실적인 선택지에요.

    Grafana Loki 핵심 개념부터 먼저 잡아보겠습니다

    Loki, Promtail, Grafana 역할 구분

    구성요소 역할 운영 포인트
    Loki 로그 저장 및 조회 API 제공 라벨 설계가 중요합니다
    Promtail 노드의 로그 파일 수집 후 Loki로 전송 DaemonSet으로 배포하는 경우가 많습니다
    Grafana 로그 검색, 필터링, 시각화 처리 대시보드와 Explore 기능이 편합니다

    여기서 중요한 포인트! Promtail(프롬테일)이 하는 역할은 로그를 읽어 Loki로 보내는 수집기 일이죠. Kubernetes에서는 보통 컨테이너 로그가 노드 파일 시스템에 쌓이기 때문에, 노드마다 하나씩 떠 있는 DaemonSet이 그 로그를 읽는 구조를 많이 씁니다.

    라벨(Label)이 왜 중요할까요?

    Loki는 라벨 기반으로 로그를 찾습니다. 예를 들면 namespace, pod, container, app 같은 값들이죠. 실제로 써보니까 라벨을 너무 많이 붙이면 관리가 복잡해지고, 반대로 너무 적으면 검색이 답답하더라고요. 저도 처음엔 이것저것 다 넣었다가 쿼리가 지저분해져서 다시 정리했었습니다 ㅎㅎ

    • 자주 검색하는 기준만 라벨로 둡니다
    • 변동성이 큰 값은 라벨 남발을 피합니다
    • 운영팀이 실제로 찾는 축을 먼저 정합니다

    Kubernetes 로그 중앙화 구성 흐름

    전체 흐름은 생각보다 단순합니다.

    1. 애플리케이션 컨테이너가 표준 출력(stdout/stderr)으로 로그를 남깁니다.
    2. Kubernetes 노드가 해당 로그를 파일 형태로 보관합니다.
    3. Promtail이 노드에서 로그를 읽고 라벨을 붙입니다.
    4. Loki가 로그를 저장합니다.
    5. Grafana에서 검색하고 필터링합니다.

    이 구조가 좋은 이유는 애플리케이션 코드를 크게 건드리지 않아도 된다는 거거든요. 이미 컨테이너 표준 출력으로 로그를 잘 남기고 있다면, 인프라 쪽에서 수집 체계를 붙이기 좋습니다.

    실전 구현: Helm으로 Loki와 Promtail 배포하기

    이제 본격적으로 들어가 보겠습니다. 여기서는 많이 쓰는 Helm(헬름) 기반 예시로 설명드릴게요. 실제 운영 환경에서는 스토리지, 보존 기간, 인증, 멀티 테넌시 여부 등을 더 따져야 하지만, 처음 시작할 때는 흐름을 먼저 잡는 게 중요합니다.

    1. 네임스페이스 생성

    kubectl create namespace observability

    저는 보통 모니터링/로깅 계열 리소스를 따로 분리하려고 observability 같은 네임스페이스를 씁니다. 꼭 이 이름일 필요는 없어요.

    2. Helm 저장소 추가

    helm repo add grafana https://grafana.github.io/helm-charts
    helm repo update

    3. Loki values 파일 작성

    처음엔 기본값으로도 올라가긴 하는데, 최소한 배포 형태와 저장 방식은 눈으로 확인하고 가는 게 좋습니다.

    loki:
      auth_enabled: false
    
    singleBinary:
      replicas: 1
    
    gateway:
      enabled: true
    
    monitoring:
      dashboards:
        enabled: true
      rules:
        enabled: true

    테스트나 홈랩에서는 이렇게 단순하게 시작해도 됩니다. 다만 운영에서는 스토리지 백엔드와 고가용성 구성을 별도로 검토하셔야 합니다. 여기서 무작정 단일 인스턴스로 오래 끌고 가면 나중에 확장 시점에 다시 손이 많이 가더라고요.

    4. Loki 설치

    helm install loki grafana/loki -n observability -f loki-values.yaml

    5. Promtail values 파일 작성

    config:
      clients:
        - url: http://loki-gateway.observability.svc.cluster.local/loki/api/v1/push
    
      snippets:
        pipelineStages:
          - cri: {}
    
      positions:
        filename: /run/promtail/positions.yaml
    
      scrapeConfigs:
        - job_name: kubernetes-pods
          kubernetes_sd_configs:
            - role: pod
          relabel_configs:
            - source_labels: [__meta_kubernetes_namespace]
              target_label: namespace
            - source_labels: [__meta_kubernetes_pod_name]
              target_label: pod
            - source_labels: [__meta_kubernetes_pod_container_name]
              target_label: container
            - source_labels: [__meta_kubernetes_pod_label_app]
              target_label: app

    이 부분이 핵심입니다. 어떤 Kubernetes 메타데이터를 라벨로 가져갈지 결정하는 구간이거든요. 제가 실제로 써보니까 namespace, pod, container, app 정도부터 시작하는 게 무난했습니다.

    Kubernetes 로그 수집을 위한 Promtail과 Grafana Loki 구성도

    Promtail DaemonSet이 각 노드의 컨테이너 로그 파일을 읽고 라벨을 붙여 Loki로 보내는 흐름을 설명하는 이미지입니다.

    6. Promtail 설치

    helm install promtail grafana/promtail -n observability -f promtail-values.yaml

    7. Grafana에서 데이터 소스 연결

    Grafana를 이미 쓰고 계신다면 Loki 데이터 소스를 추가하면 됩니다. 같은 클러스터 안에 있다면 서비스 이름으로 연결하는 경우가 많습니다.

    kubectl get svc -n observability

    Grafana Explore 화면에서 Loki를 선택하고 아래처럼 조회해보면 기본 파이프라인이 제대로 도는지 확인할 수 있어요.

    {namespace="default"}

    처음 이 쿼리로 로그가 딱 뜨는 순간, 드디어 됐다! 싶은 느낌이 있습니다. 로그 중앙화는 여기서부터가 시작이거든요.

    운영하면서 유용했던 로그 쿼리 예시

    Loki는 LogQL(로그쿼리언어) 형태로 조회합니다. 익숙해지면 꽤 편합니다.

    {namespace="production", app="nginx"}
    {namespace="production", pod=~"api-.*"}
    {container="backend"} |= "error"
    {app="payments"} |= "timeout"
    • |= 는 특정 문자열 포함 검색에 자주 씁니다
    • 정규식 매칭은 필요한 곳에만 씁니다
    • 라벨 기준 필터를 먼저 좁히고 문자열 검색을 붙이면 보기가 편합니다

    이 부분은 팀 내에서 공통 조회 패턴을 만들어두면 좋습니다. 예를 들어 장애 대응 때 “namespace 먼저, app 다음, error 문자열 마지막” 같은 식으로 말이죠.

    ⚠️ 실제로 많이 겪는 문제와 트러블슈팅

    여기서부터는 제가 꽤 자주 봤던 문제들입니다. 저도 처음엔 헷갈렸는데, 한 번 원리를 이해하고 나면 금방 잡힙니다.

    1. 로그가 아예 안 들어오는 경우

    • Promtail Pod가 정상 실행 중인지 확인합니다
    • Loki push URL이 올바른지 봅니다
    • 네트워크 정책(NetworkPolicy)으로 막히지 않았는지 확인합니다
    • 애플리케이션이 파일이 아니라 표준 출력으로 로그를 남기는지 확인합니다
    kubectl get pods -n observability
    kubectl logs -n observability daemonset/promtail
    kubectl logs -n observability deploy/loki

    2. 라벨이 너무 많아져서 조회가 복잡한 경우

    이건 정말 흔합니다. Kubernetes 메타데이터를 다 가져오고 싶은 마음이 들거든요. 근데 운영해보면 자주 안 쓰는 라벨은 오히려 방해가 됩니다. 중앙 집중형 로깅의 목적은 데이터를 많이 붙이는 게 아니라, 필요한 순간 빨리 찾는 데 있다는 점을 잊지 않는 게 중요합니다.

    3. 특정 Pod 로그만 유독 안 보이는 경우

    보통 라벨 매핑 문제이거나, 애플리케이션 로그 출력 방식 차이인 경우가 많았습니다. 사이드카(sidecar)를 쓰는 구조나 멀티 컨테이너 Pod에서는 컨테이너 이름 기준으로 먼저 좁혀보는 게 좋더라고요.

    4. 과거 로그를 오래 보관하고 싶은 경우

    이건 저장소 설계와 연결됩니다. 홈랩에서는 일단 짧게 가져가도 되는데, 운영에서는 보존 정책(retention policy)을 꼭 먼저 정하셔야 합니다. 로그는 쌓이는 속도가 생각보다 빠릅니다. 처음엔 괜찮다가 어느 날 저장소가 가득 차서 당황하는 경우가 생기거든요.

    검증: Loki Kubernetes 로그가 제대로 모이는지 확인하기

    설치가 끝났다고 바로 안심하면 안 됩니다. 꼭 검증 단계를 거치셔야 합니다. 저는 아래 순서로 확인합니다.

    1. 테스트용 Pod를 띄워 의도적으로 로그를 발생시킵니다.
    2. Promtail 로그에서 수집 관련 에러가 없는지 봅니다.
    3. Grafana Explore에서 namespace와 pod 기준으로 조회합니다.
    4. 문자열 필터로 원하는 로그를 찾을 수 있는지 확인합니다.
    kubectl run log-check --image=busybox --restart=Never -- /bin/sh -c 'i=0; while true; do echo "log-check-$i"; i=$((i+1)); sleep 5; done'

    그 다음 Grafana에서 아래처럼 조회합니다.

    {pod="log-check"}

    이렇게 테스트 로그가 보이면 기본 파이프라인은 정상입니다. 이후엔 에러 패턴, 특정 앱 로그, 운영 네임스페이스 로그를 차례로 점검하면 됩니다.

    Grafana Loki로 Kubernetes 로그를 조회하는 대시보드 이미지

    Grafana Explore 또는 대시보드에서 namespace, pod, app 라벨로 로그를 필터링한 결과 예시 이미지입니다.

    비교: Loki와 다른 로그 수집 접근의 차이

    항목 Loki 중심 구성 전통적 대용량 검색 중심 구성
    초기 진입 난이도 상대적으로 단순한 편 구성 요소가 많은 편
    Grafana 연동 매우 자연스러움 별도 연계 구성이 필요할 수 있음
    라벨 설계 중요도 매우 높음 상대적으로 검색 중심 접근 가능
    홈랩/소규모 시작 부담이 덜함 조금 무거울 수 있음

    이 표를 보면 감이 오실 겁니다. “빠르게 Kubernetes 로그 중앙화를 시작하고 싶다”면 Loki가 꽤 괜찮습니다. 반대로 아주 복잡한 검색 시나리오, 대규모 장기 보관 전략, 조직 표준 스택이 이미 정해져 있다면 다른 선택지가 더 맞을 수도 있어요.

    💡 운영 팁: 제가 나중에 꼭 챙기게 된 것들

    • 라벨 최소화: 처음부터 과하게 넣지 않습니다
    • 보존 정책: 저장소 사용량을 반드시 같이 봅니다
    • 대시보드 표준화: 팀이 자주 보는 쿼리를 정리합니다
    • 애플리케이션 로그 형식: JSON 로그 여부를 팀 기준으로 맞추면 훨씬 편합니다
    • 장애 대응 문서화: “로그가 안 보일 때 체크리스트”를 만들어두면 좋습니다

    특히 JSON 형태 로그를 쓰는 팀이라면 이후 파싱과 필드 추출도 훨씬 수월해집니다. Kubernetes 로그 수집을 이렇게 중앙화하면 메트릭 모니터링과 함께 관측성(Observability, 시스템 상태를 외부 신호로 이해하는 능력)이 한 단계 올라가는 걸 체감하실 겁니다.

    중앙 집중형 로깅 도입 전후 Loki Kubernetes 로그 운영 비교 이미지

    kubectl logs 중심 운영과 Loki 기반 중앙 집중형 로깅 운영의 차이를 한눈에 정리한 비교 이미지입니다.

    자주 묻는 질문

    Q1. Kubernetes 로그 수집은 꼭 Promtail이어야 하나요?

    꼭 그렇진 않습니다. 다만 Loki와 가장 자연스럽게 엮이는 수집기로 많이 사용됩니다. 시작 단계에서는 조합이 단순한 쪽이 유지보수에 유리하더라고요.

    Q2. Grafana Loki만 설치하면 끝인가요?

    아닙니다. 저장소, 보존 정책, 접근 제어, 대시보드 표준화까지 같이 봐야 운영 품질이 올라갑니다. 설치보다 운영 기준을 세우는 게 더 중요합니다.

    Q3. 중앙 집중형 로깅이 왜 필요한가요?

    장애 대응 속도가 달라집니다. 노드와 Pod를 옮겨 다니며 로그를 찾는 시간을 줄일 수 있거든요. 특히 여러 서비스가 동시에 얽히는 환경에서는 체감 차이가 큽니다.

    마무리: Loki Kubernetes 로그 구성, 처음엔 단순하게 시작하세요

    정리해보면 Loki Kubernetes 로그 구성의 핵심은 화려한 기능보다도, 어떤 로그를 어떤 라벨로 모을지를 먼저 정하는 데 있습니다. 저도 처음엔 설정 파일만 붙잡고 씨름했었는데, 결국 답은 단순하더라고요. 필요한 로그를 빨리 찾을 수 있느냐, 장애 때 팀이 같은 화면을 보고 이야기할 수 있느냐, 그게 제일 중요했습니다.

    처음 구축하신다면 작은 범위에서 시작해보세요. 특정 네임스페이스 하나, 서비스 하나부터 붙여보고, 쿼리 패턴을 정리한 다음 확장하는 방식이 훨씬 덜 힘듭니다. 실제로 써보니까 이게 가장 덜 삽질하는 길이었습니다. 혹시 지금 Grafana Loki 도입을 고민 중이시라면, 이번 주말 홈랩에서라도 한 번 꼭 올려보세요. 생각보다 금방 감이 옵니다.

  • [k8s] Prometheus Operator vs 직접 설정: Kubernetes 모니터링 실전 비교 분석

    [k8s] Prometheus Operator vs 직접 설정: Kubernetes 모니터링 실전 비교 분석

    Prometheus Operator vs 직접 설정: Kubernetes 모니터링 실전 비교 분석

    쿠버네티스 운영을 조금만 해보면 결국 만나게 되는 질문이 있습니다. Prometheus Operator vs 직접 설정, 대체 뭐가 더 낫냐는 거죠. 저도 처음엔 “Prometheus(프로메테우스, 시계열 메트릭 모니터링 시스템)면 그냥 띄우면 되는 거 아닌가?” 싶었는데, 실제로 홈랩과 운영 환경에서 둘 다 굴려보니 생각보다 차이가 꽤 크더라고요. 특히 Kubernetes 모니터링을 제대로 붙이려면 서비스 디스커버리(Service Discovery, 대상 자동 발견), 알림 규칙(Alerting Rules, 경고 조건), 그리고 Grafana 연동까지 자연스럽게 이어져야 하거든요.

    이번 글에서는 제가 직접 삽질했던 경험을 바탕으로, Prometheus Operator 방식과 직접 설정 방식을 현실적으로 비교해보겠습니다. 단순히 “이게 더 최신이라 좋다” 같은 얘기는 빼고, 실제 운영 관점에서 어디가 편하고 어디서 귀찮아지는지 정리해볼게요.

    Prometheus Operator와 직접 설정 방식이 쿠버네티스 클러스터 안에서 어떻게 다르게 배치되는지 보여주는 아키텍처 이미지입니다.

    왜 이 비교가 중요한가: Kubernetes 모니터링에서 운영 비용이 갈립니다

    모니터링은 처음 붙일 때보다 나중에 유지보수할 때 진가가 드러납니다. 초반에는 둘 다 잘 돌아가는 것처럼 보여요. 근데 클러스터가 커지고, 애플리케이션이 늘고, 팀원이 늘어나면 설정 방식의 차이가 운영 비용으로 바로 튀어나옵니다.

    • 직접 설정은 구조를 깊게 이해하기 좋고, 제어권이 높습니다.
    • Operator 방식은 선언형(Declarative, 원하는 상태를 정의하는 방식) 운영이 편하고 확장성이 좋습니다.
    • 작은 홈랩에서는 직접 설정이 빠를 때도 있지만, 팀 단위 운영에서는 Operator가 훨씬 덜 피곤한 경우가 많습니다.

    제가 처음 직접 설정으로 시작했을 때는 설정 파일 하나만 고치면 끝날 줄 알았거든요. 근데 대상 서비스가 늘어나고 scrape job이 많아지니까, 어느 순간 prometheus.yml이 점점 거대해졌습니다. 그때부터 “아 이건 사람이 계속 손으로 관리할 구조가 아니구나” 싶더라고요.

    쉽게 말해: Prometheus Operator vs 직접 설정의 핵심 차이

    쉽게 말해, Prometheus Operator는 Prometheus 자체를 쿠버네티스 리소스(Custom Resource, 사용자 정의 리소스)로 관리하게 해주는 방식입니다. 반대로 직접 설정은 Deployment, ConfigMap, ServiceAccount 같은 리소스를 직접 만들고, scrape 설정도 내가 직접 관리하는 방식입니다.

    항목 Prometheus Operator 직접 설정
    설정 관리 ServiceMonitor, PodMonitor, PrometheusRule 같은 CRD 기반 prometheus.yml 직접 수정
    초기 진입 난이도 처음엔 다소 생소함 개념만 알면 바로 시작 가능
    확장성 매우 좋음 대상이 많아질수록 불편
    운영 자동화 높음 낮음
    문제 추적 리소스 구조 이해 필요 설정 파일 기준으로 단순함
    팀 협업 표준화하기 좋음 작성자 의존도가 높아짐

    여기서 중요한 포인트! 둘 중 하나가 절대적으로 우월하다기보다는, 클러스터 규모와 운영 방식에 따라 유리한 선택이 달라집니다. 저도 작은 테스트 클러스터에서는 직접 설정을 아직도 씁니다. 빠르게 확인하기 좋거든요.

    언제 어떤 방식을 고르면 좋은가

    Prometheus Operator가 잘 맞는 경우

    • 여러 네임스페이스(namespace, 논리적 격리 단위)의 워크로드를 지속적으로 모니터링해야 할 때
    • 팀원이 늘어나서 모니터링 리소스를 표준화해야 할 때
    • Alertmanager(알림 관리자), Grafana, rules 관리를 함께 묶고 싶을 때
    • Helm(헬름, 쿠버네티스 패키지 매니저) 기반 운영에 익숙할 때

    직접 설정이 잘 맞는 경우

    • 학습 목적이나 홈랩처럼 단순한 구조일 때
    • Prometheus 내부 설정을 세밀하게 직접 다루고 싶을 때
    • CRD를 추가하고 싶지 않을 때
    • 문제 발생 시 설정 파일 한 장으로 빠르게 디버깅하고 싶을 때

    사실 처음 배울 때는 직접 설정이 개념 잡기 좋습니다. Prometheus가 어떻게 scrape하고, 어떤 target을 찾고, 어떤 식으로 저장하는지 몸으로 익히게 되거든요. 반대로 운영 단계에서는 Operator가 진짜 편해집니다. 이거 써보면 “아, 사람이 yaml 몇 천 줄 들고 싸우면 안 되는구나” 싶습니다 ㅎㅎ

    실전 구현 1: Prometheus Operator로 Kubernetes 모니터링 구성

    제가 보통 가장 무난하게 시작하는 방식은 kube-prometheus-stack 차트를 쓰는 겁니다. Prometheus, Alertmanager, Grafana를 한 번에 올리기 좋고, 커뮤니티에서 널리 쓰는 편이라 자료도 많습니다.

    1. 모니터링 전용 네임스페이스를 생성합니다.
    2. Helm 저장소를 추가합니다.
    3. 차트를 설치합니다.
    4. ServiceMonitor로 수집 대상을 선언합니다.
    kubectl create namespace monitoring
    helm repo add prometheus-community https://prometheus-community.github.io/helm-charts
    helm repo update
    helm install monitoring prometheus-community/kube-prometheus-stack -n monitoring

    설치가 끝나면 Prometheus와 Grafana가 함께 배포됩니다. 여기까지는 꽤 부드럽게 갑니다. 진짜 체감 포인트는 그 다음부터예요. 애플리케이션 하나 추가할 때마다 prometheus.yml을 직접 안 만지고, ServiceMonitor만 선언하면 되거든요.

    apiVersion: monitoring.coreos.com/v1
    kind: ServiceMonitor
    metadata:
      name: sample-app
      namespace: monitoring
    spec:
      selector:
        matchLabels:
          app: sample-app
      namespaceSelector:
        matchNames:
          - app-space
      endpoints:
        - port: metrics
          path: /metrics
          interval: 30s

    이 방식의 장점은 명확합니다. 애플리케이션 쪽 Service에 라벨만 잘 붙어 있으면, 모니터링 설정이 애플리케이션 배포 흐름에 자연스럽게 붙습니다. GitOps(Git옵스, Git 기반 선언형 운영) 하시는 분들이 Operator를 좋아하는 이유가 여기 있습니다.

    ServiceMonitor가 서비스 라벨을 기준으로 메트릭 수집 대상을 찾아가는 흐름을 보여주는 구성 다이어그램입니다.

    실전 구현 2: Prometheus 직접 설정으로 구성하기

    이번엔 직접 설정입니다. 이 방식은 Prometheus가 어떻게 동작하는지 이해하기엔 정말 좋습니다. 저도 처음 구조를 배울 때는 이 방법으로 오래 굴렸습니다. 다만 규모가 커지면 금방 손이 많이 가더라고요.

    1. Prometheus 설정을 담을 ConfigMap을 만듭니다.
    2. RBAC(Role-Based Access Control, 역할 기반 권한 제어)를 설정합니다.
    3. Deployment와 Service를 배포합니다.
    4. targets 페이지에서 수집 상태를 확인합니다.
    apiVersion: v1
    kind: ConfigMap
    metadata:
      name: prometheus-config
      namespace: monitoring
    data:
      prometheus.yml: |
        global:
          scrape_interval: 30s
        scrape_configs:
          - job_name: 'kubernetes-pods'
            kubernetes_sd_configs:
              - role: pod
            relabel_configs:
              - source_labels: [__meta_kubernetes_pod_annotation_prometheus_io_scrape]
                action: keep
                regex: true
              - source_labels: [__meta_kubernetes_pod_annotation_prometheus_io_path]
                action: replace
                target_label: __metrics_path__
                regex: (.+)
              - source_labels: [__address__, __meta_kubernetes_pod_annotation_prometheus_io_port]
                action: replace
                regex: ([^:]+)(?::\d+)?;(\d+)
                replacement: $1:$2
                target_label: __address__
    apiVersion: apps/v1
    kind: Deployment
    metadata:
      name: prometheus
      namespace: monitoring
    spec:
      replicas: 1
      selector:
        matchLabels:
          app: prometheus
      template:
        metadata:
          labels:
            app: prometheus
        spec:
          serviceAccountName: prometheus
          containers:
            - name: prometheus
              image: prom/prometheus
              args:
                - --config.file=/etc/prometheus/prometheus.yml
              ports:
                - containerPort: 9090
              volumeMounts:
                - name: config
                  mountPath: /etc/prometheus
          volumes:
            - name: config
              configMap:
                name: prometheus-config

    직접 설정의 핵심은 relabel_configs를 이해하는 겁니다. 이 부분이 처음엔 진짜 벽처럼 느껴집니다. 저도 여기서 꽤 오래 멈췄었어요. 왜 target이 안 잡히는지 몰라서 annotation(어노테이션, 메타데이터) 오타 하나 찾겠다고 한참 봤던 기억이 납니다.

    대신 이 방식은 구조가 명확합니다. 어떤 설정이 왜 들어갔는지 한 줄씩 따라갈 수 있어요. 학습용으로는 정말 좋습니다.

    Grafana 연동은 어떻게 보나

    Grafana 연동은 두 방식 모두 어렵지 않습니다. 차이는 연결보다도 대시보드와 데이터소스(Data Source, 데이터 공급원) 관리 방식에서 납니다. Operator 스택을 쓰면 Grafana가 함께 올라오는 경우가 많아서 시작이 빠릅니다. 직접 설정은 Prometheus만 먼저 올리고 Grafana를 따로 배포하는 흐름이 일반적입니다.

    kubectl port-forward svc/monitoring-grafana -n monitoring 3000:80
    kubectl port-forward svc/prometheus -n monitoring 9090:9090

    Grafana에서 Prometheus URL을 연결한 뒤, Kubernetes 관련 대시보드를 붙이면 CPU, 메모리, Pod 재시작 수, 노드 상태 등을 한눈에 볼 수 있습니다. 드디어 됐다! 하는 순간이 여기서 오죠. 숫자가 그래프로 보이기 시작하면, 그전까지는 안 보이던 병목이 갑자기 눈에 들어옵니다.

    ⚠️ 실제 겪었던 문제와 트러블슈팅

    여기서부터가 진짜 운영입니다. 설치보다 문제 해결이 더 중요하거든요.

    1. ServiceMonitor를 만들었는데 target이 안 잡힐 때

    • Service 라벨과 ServiceMonitor selector가 일치하는지 확인합니다.
    • metrics 포트 이름이 ServiceMonitor의 endpoints.port와 같은지 봅니다.
    • namespaceSelector가 실제 애플리케이션 네임스페이스를 포함하는지 체크합니다.

    이건 제가 꽤 자주 겪었습니다. 특히 포트 번호가 아니라 포트 이름으로 매칭한다는 걸 놓치면 한참 헤매게 됩니다.

    2. 직접 설정에서 scrape가 안 될 때

    • Pod annotation 키가 정확한지 봅니다.
    • RBAC 권한이 충분한지 확인합니다.
    • Prometheus UI의 Status > Targets에서 에러 메시지를 먼저 봅니다.

    처음엔 Prometheus 로그부터 뒤졌는데, 실제로는 Targets 화면이 더 빠르더라고요. 여기서 중요한 포인트! 모니터링 장애는 대개 설정 오타나 권한 누락에서 시작합니다.

    3. Grafana에 데이터가 안 보일 때

    • Prometheus 데이터소스 URL이 맞는지 확인합니다.
    • Prometheus 쿼리(PromQL, 프로메테우스 질의 언어)에서 메트릭이 실제로 조회되는지 먼저 봅니다.
    • 시간 범위(Time Range)가 너무 짧지 않은지 확인합니다.

    이건 별거 아닌데 은근 자주 나옵니다. 수집은 되고 있는데, 대시보드 시간 범위가 안 맞아서 “왜 빈 화면이지?” 하고 멍해지는 경우가 있거든요. 저도 몇 번 당했습니다 ㅎㅎ

    검증과 결과: 운영해보면 어떤 차이가 나나

    결론부터 말하면, Prometheus Operator vs 직접 설정은 단순한 기능 비교가 아니라 운영 방식의 선택에 가깝습니다.

    관점 Operator 직접 설정
    빠른 시작 Helm 기반으로 빠름 구성요소를 이해하면 빠름
    변경 관리 리소스 단위로 분리되어 편함 중앙 설정 파일이 비대해지기 쉬움
    문제 분석 CRD 구조 이해가 필요 설정 파일 기준으로 직관적
    확장 운영 유리함 점점 수동 작업 증가
    학습 가치 운영 패턴 학습에 좋음 Prometheus 내부 구조 학습에 좋음

    제가 실제로 써보니까, 작은 테스트 환경에서는 직접 설정이 부담이 적었습니다. 반면 운영 서비스가 두세 개를 넘어가고, 여러 네임스페이스에 exporter(exporter, 메트릭 노출 구성요소)가 붙기 시작하면 Operator 쪽이 확실히 편해집니다. 특히 팀원이 함께 건드리는 순간부터 차이가 커져요.

    Grafana 연동 결과로 Kubernetes 모니터링 대시보드를 보여주는 이미지

    Grafana 대시보드와 Prometheus 타깃 상태 화면을 함께 보여주는 결과 검증 이미지입니다.

    자주 묻는 질문 정리

    Q1. 입문자는 어떤 방식부터 시작하는 게 좋을까요?

    제가 추천하는 순서는 이렇습니다. 먼저 직접 설정으로 구조를 이해하고, 운영에는 Operator를 쓰는 방식입니다. 둘 중 하나만 알면 나중에 막힐 때 원인 파악이 어렵더라고요.

    Q2. 무조건 Operator가 정답인가요?

    그건 아닙니다. 싱글 클러스터 홈랩이나 짧은 실험 환경에서는 직접 설정이 더 가볍고 빠를 수 있습니다. 특히 CRD 추가를 최소화하고 싶다면 여전히 좋은 선택입니다.

    Q3. Grafana까지 꼭 같이 써야 하나요?

    필수는 아니지만, 실전에서는 거의 같이 갑니다. Prometheus가 수집과 저장을 담당하고, Grafana가 시각화를 담당하니까 역할이 깔끔하게 나뉘거든요.

    정리: 지금 선택해야 한다면 저는 이렇게 갑니다

    Kubernetes 모니터링을 장기적으로 운영할 계획이라면 저는 대체로 Operator를 권합니다. 선언형 리소스로 관리되고, 팀 협업에도 잘 맞고, 알림 규칙과 확장도 편하거든요. 반대로 학습 목적이 강하거나, 작은 홈랩에서 구조를 이해하고 싶다면 직접 설정으로 한 번 부딪혀보는 것도 아주 좋습니다. 저도 그렇게 배우면서 삽질 좀 했습니다. 근데 그 삽질 덕분에 지금은 문제가 생겨도 어디를 먼저 봐야 하는지 감이 오더라고요.

    혹시 지금 Prometheus Operator vs 직접 설정 사이에서 고민 중이시라면, 질문을 이렇게 바꿔보시면 결정이 쉬워집니다. “내가 지금 배우고 싶은가, 아니면 오래 운영하고 싶은가?” 이거거든요. 답이 전자면 직접 설정, 후자면 Operator 쪽이 보통 맞습니다.

    Prometheus Operator vs 직접 설정 선택 기준을 요약한 비교 이미지

    두 방식의 장단점과 추천 사용 시나리오를 한눈에 요약한 인포그래픽 이미지입니다.

    다음 글에서는 Alertmanager(알림 관리자)와 Slack 같은 채널 연동, 그리고 PromQL 기초 쿼리를 다뤄볼 예정입니다. 이전 글에서 exporter 구성 방법을 보셨다면 이번 내용이 더 잘 이어질 거예요. ✅

  • [모니터링] Grafana Cloud 비용 분석, 자체 Prometheus로 돌아간 이유

    [모니터링] Grafana Cloud 비용 분석, 자체 Prometheus로 돌아간 이유

    [모니터링] Grafana Cloud 비용 분석, 자체 Prometheus로 돌아간 이유

    Grafana Cloud 비용이 예전보다 훨씬 민감하게 느껴지기 시작하면, 그때부터는 단순히 ‘관리형이라 편하다’만으로 설명이 안 되더라고요. 저도 홈랩과 소규모 운영 환경에서 Grafana Cloud를 꽤 편하게 썼었는데, 메트릭(Metrics, 시계열 지표)과 로그(Logs, 시스템/애플리케이션 기록)가 늘어나면서 청구 구조를 다시 뜯어보게 됐습니다. 특히 Grafana Cloud 비용은 사용량이 조금만 늘어도 체감상 훅 올라갈 수 있어서, 모니터링 비용을 어디까지 SaaS로 맡길지 진지하게 다시 보게 되거든요.

    이번 글은 ‘무조건 자체 호스팅이 낫다’는 이야기가 아닙니다. Grafana Cloud 공식 가격 구조를 기준으로 왜 비용이 커지는지, 그리고 어떤 조건에서 자체 호스팅 ROI(Return on Investment, 투자 대비 효과)가 맞아떨어지는지 제가 정리한 기준을 공유해보려는 글입니다. 중간에 실제로 바로 올려볼 수 있는 Prometheus(프로메테우스, 메트릭 수집기) + Grafana(그라파나, 시각화 도구) 구성 예시도 넣어둘게요.

    Grafana Cloud와 자체 Prometheus 구성을 비용 관점에서 비교한 전체 아키텍처 예시입니다.

    1. 왜 Grafana Cloud 비용이 갑자기 아프게 느껴질까

    처음엔 진짜 편합니다. 가입하고, 에이전트 붙이고, 대시보드 몇 개 열면 끝이거든요. 저도 처음엔 이게 뭔가 싶을 정도로 진입 장벽이 낮아서 아주 만족했었습니다. 근데 여기서 중요한 포인트가 있습니다. 편한 구조일수록 과금 단위가 눈에 잘 안 들어온다는 점입니다.

    Grafana 공식 가격 페이지를 보면, Pro 플랜은 월 플랫폼 요금(platform fee)에 더해 사용량 기반 과금이 붙습니다. 메트릭은 active series(액티브 시리즈, 실제로 수집 중인 시계열 개수) 기준이고, 로그와 트레이스는 process / write / retain처럼 단계별 과금 구조가 걸려 있더라고요. 쉽게 말해, 데이터를 많이 넣는 환경에서는 ‘조금 늘었네’라고 생각했는데 청구서는 전혀 조금이 아닐 수 있다는 뜻입니다.

    • 메트릭: active series가 늘면 비용이 바로 반응합니다.
    • 로그: 수집량뿐 아니라 처리와 저장이 분리돼 보여서 체감이 더 큽니다.
    • 트레이스: 장애 분석엔 좋지만, 운영 습관 없이 켜두면 금방 비싸집니다.
    • 보존 기간(retention, 데이터 보관 기간): 길어질수록 관리형 서비스의 장점은 커지지만 비용도 같이 올라갑니다.

    이런 구조 때문에 클라우드 가격이 ‘갑자기 2배 오른 느낌’으로 다가오는 경우가 많습니다. 꼭 단가만 오른 게 아니라, 내가 보내는 데이터 패턴과 과금 기준이 맞물리면서 총액이 급격히 커지는 거죠. 실제로 써보니까, 비용 문제는 제품 성능보다 카디널리티(cardinality, 라벨 조합 폭발) 관리 실패에서 먼저 터지는 경우가 많더라고요.

    2. Grafana Cloud 가격 구조를 쉽게 풀어보면

    공식 가격 페이지 기준으로 현재 눈에 띄는 포인트는 이렇습니다. 글을 읽는 시점에 바뀔 수 있으니, 실제 계약 전에 공식 페이지는 꼭 다시 확인하셔야 합니다.

    항목 공식 페이지 기준 포인트 운영자가 봐야 할 부분
    Metrics Free는 월 10k active series, 14일 보관 라벨 설계가 나쁘면 금방 초과합니다.
    Metrics Pro 월 플랫폼 요금 + 사용량 기반 가격 노드 수보다 series 폭증이 더 위험합니다.
    Logs Free 월 50GB, 14일 보관 테스트 환경은 괜찮지만 운영 로그는 빠듯할 수 있습니다.
    Logs Pro process, write, retain 기반 사용량 과금 수집, 저장, 보관을 따로 봐야 합니다.
    Retention Pro 기준 metrics 13개월, logs/traces 30일 장기 보관이 필요한 조직엔 장점이 큽니다.

    쉽게 말해 이렇습니다. Grafana Cloud 비용은 서버 대수보다도 ‘얼마나 많은 시계열과 데이터를 계속 보내고 있는가’에 더 민감합니다. VM 몇 대 수준에서는 괜찮아 보여도, 쿠버네티스(Kubernetes, 컨테이너 오케스트레이션) 들어가고 라벨이 늘고, 로그를 구조화해서 많이 쌓기 시작하면 얘기가 달라집니다.

    그래서 저는 비용 분석할 때 아래 세 가지부터 봅니다.

    1. active series가 왜 늘고 있는지
    2. scrape interval(스크랩 주기, 수집 간격)이 과한지
    3. 꼭 SaaS에 남겨야 하는 데이터와 로컬에 둬도 되는 데이터를 구분했는지

    3. 자체 호스팅 ROI, 저는 이렇게 계산합니다

    여기서 많이들 실수하는 게 있습니다. 자체 Prometheus로 돌린다고 해서 무조건 싸지 않거든요. 저도 처음엔 ‘VM 하나면 끝 아닌가?’ 싶었는데, 막상 해보면 백업, 디스크, 알람, 업그레이드, 장애 대응까지 다 내 일이 됩니다. 삽질 좀 했습니다 ㅎㅎ

    그래도 자체 호스팅 ROI가 좋아지는 구간은 분명히 있습니다.

    • 메트릭은 많은데 장기 보관이 꼭 필요하지 않을 때
    • 운영 인력이 있어 기본 유지보수를 감당할 수 있을 때
    • 로그와 트레이스를 전부 관리형으로 둘 필요가 없을 때
    • 홈랩, 사내 관제, 내부 서비스처럼 외부 SLA보다 비용 통제가 더 중요할 때

    반대로 아래 조건이면 Grafana Cloud가 여전히 훨씬 편할 수 있습니다.

    • 24×7 대응과 장기 보관이 중요할 때
    • 멀티 리전, 팀 협업, 권한 관리가 이미 복잡할 때
    • 장애 나면 관제 스택을 직접 고칠 사람이 없을 때

    제가 실제로는 이렇게 따집니다. 월 청구서 증가분과 직접 운영할 때 들어가는 VM/디스크/백업 비용 + 관리 시간을 같이 봅니다. 숫자를 억지로 예쁘게 만들 필요는 없고요. 한 달에 두세 번만 대시보드 보고, 보관 기간도 15일~30일이면, 자체 Prometheus 쪽이 생각보다 금방 수지가 맞는 경우가 있습니다.

    4. 그래서 저는 Prometheus + Grafana 조합으로 다시 갔습니다

    이번 선택의 핵심은 단순했습니다. 메트릭은 자체 호스팅, 필요하면 나중에 일부만 외부로 보낸다. Prometheus는 구조가 명확하고, Grafana는 익숙하고, 둘 다 문서가 탄탄합니다. 무엇보다 제가 어디서 비용이 나는지 눈으로 볼 수 있더라고요.

    Prometheus 공식 문서를 보면 로컬 저장소(local storage)는 기본적으로 15일 retention입니다. 그리고 저장소 크기를 제어하려면 --storage.tsdb.retention.time 또는 --storage.tsdb.retention.size를 잡을 수 있습니다. 또 중요한 경고가 하나 있는데, NFS 같은 비POSIX 환경은 권장되지 않습니다. 이거 모르고 네트워크 스토리지에 올렸다가 애매한 문제 겪는 경우 진짜 많습니다.

    Grafana Cloud 비용 절감을 위해 구성한 자체 Prometheus 홈랩 다이어그램

    Docker Compose 기반으로 Prometheus와 Grafana를 엮은 홈랩 구성 예시입니다.

    5. 실전 구현: Docker Compose로 10분 안에 올리기

    복잡하게 시작할 필요 없습니다. 가장 단순하고 관리하기 쉬운 형태로 먼저 띄우는 게 좋습니다. 아래 예시는 Prometheus와 Grafana를 같은 Docker Compose 네트워크에 올리는 방식입니다.

    5-1. 디렉터리 구조

    monitoring/
    ├── docker-compose.yaml
    ├── prometheus/
    │   └── prometheus.yml
    └── grafana/
        └── provisioning/
            └── datasources/
                └── prometheus.yaml

    5-2. docker-compose.yaml

    services:
      prometheus:
        image: prom/prometheus:latest
        container_name: prometheus
        restart: unless-stopped
        command:
          - --config.file=/etc/prometheus/prometheus.yml
          - --storage.tsdb.path=/prometheus
          - --storage.tsdb.retention.time=15d
          - --storage.tsdb.retention.size=20GB
          - --web.enable-lifecycle
        ports:
          - "9090:9090"
        volumes:
          - ./prometheus/prometheus.yml:/etc/prometheus/prometheus.yml:ro
          - prometheus-data:/prometheus
    
      grafana:
        image: grafana/grafana:latest
        container_name: grafana
        restart: unless-stopped
        ports:
          - "3000:3000"
        volumes:
          - grafana-data:/var/lib/grafana
          - ./grafana/provisioning:/etc/grafana/provisioning:ro
        depends_on:
          - prometheus
    
    volumes:
      prometheus-data:
      grafana-data:

    여기서 중요한 포인트는 두 가지입니다. 첫째, retention.time과 retention.size를 둘 다 넣어 디스크 폭주를 막는 것. 둘째, 영속 볼륨(persistent volume)을 꼭 쓰는 것입니다. 안 그러면 컨테이너 다시 뜰 때 데이터가 날아가거든요.

    5-3. prometheus.yml

    global:
      scrape_interval: 15s
      evaluation_interval: 15s
    
    scrape_configs:
      - job_name: prometheus
        static_configs:
          - targets:
              - prometheus:9090

    Prometheus 공식 시작 가이드의 가장 기본적인 예시는 자기 자신을 스크랩하는 구성입니다. 저는 처음에 딱 여기서 시작하시는 걸 추천합니다. 이것만으로도 Prometheus가 정상 수집 중인지 바로 검증할 수 있거든요.

    5-4. Grafana 데이터소스 프로비저닝

    apiVersion: 1
    
    datasources:
      - name: Prometheus
        type: prometheus
        access: proxy
        url: http://prometheus:9090
        isDefault: true
        jsonData:
          httpMethod: POST

    Grafana 공식 문서에도 나오지만, 같은 Compose 네트워크라면 http://prometheus:9090처럼 서비스 이름으로 붙이는 방식이 제일 깔끔합니다. 많은 분들이 여기서 localhost:9090 넣고 왜 안 되지? 하는데, 컨테이너 안에서 localhost는 자기 자신이거든요. 저도 처음엔 여기서 한 번 헷갈렸습니다.

    5-5. 실행

    cd monitoring
    docker compose up -d
    
    docker compose ps
    curl http://localhost:9090/-/ready
    curl http://localhost:3000/api/health

    Prometheus는 http://localhost:9090, Grafana는 http://localhost:3000으로 들어가면 됩니다. Grafana 데이터소스가 자동으로 붙어 있으면 거의 다 된 겁니다. 드디어 됐다! 하는 순간이 여기서 오더라고요.

    Grafana Cloud 비용 대안으로 자체 Prometheus를 연결한 Grafana 설정 이미지

    Grafana에서 Prometheus 데이터소스가 정상 연결된 상태를 보여주는 설정 화면 예시입니다.

    6. 운영하면서 꼭 챙겨야 하는 비용 절감 포인트

    자체 호스팅으로 돌아왔다고 모니터링 비용 문제가 자동 해결되진 않습니다. 그냥 청구서 대신 디스크와 리소스가 문제를 말해줄 뿐이죠. 그래서 아래 기준은 꼭 잡고 가는 편이 좋습니다.

    1. scrape interval을 무작정 5초로 두지 않습니다. 15초나 30초면 충분한 경우가 많습니다.
    2. high cardinality 라벨을 줄입니다. 요청 ID, 세션 ID 같은 값은 거의 독입니다.
    3. 장기 보관이 필요하면 Prometheus 단독보다 Thanos, Mimir 같은 별도 구조를 검토합니다.
    4. 메트릭과 로그를 분리해서 생각합니다. 둘을 한 번에 SaaS에서 빼면 운영 복잡도가 급격히 올라갈 수 있습니다.

    특히 모니터링 비용은 수집량보다도 라벨 설계에서 무너지는 경우가 많습니다. 예를 들어 pod 이름, request path, 사용자별 식별자가 섞이면 active series가 순식간에 불어납니다. 클라우드 가격이 비싸다고 느껴질 때는 서비스 갈아타기 전에 먼저 series 폭증 원인을 보는 게 맞습니다. 이게 정말 중요한 포인트입니다!

    7. ⚠️ 실제로 많이 겪는 트러블슈팅

    • Grafana에서 데이터가 안 보임
      원인: 데이터소스 URL을 localhost:9090으로 넣은 경우가 많습니다. 컨테이너 분리 환경이면 서비스명이나 내부 네트워크 주소를 써야 합니다.
    • 디스크가 생각보다 빨리 참
      원인: retention은 시간만 잡고 size 제한을 안 둔 경우가 많습니다. --storage.tsdb.retention.size를 같이 설정하세요.
    • Prometheus 재시작 후 데이터가 날아감
      원인: 볼륨 마운트가 빠졌을 가능성이 큽니다. 특히 테스트하다가 귀찮아서 빼면 꼭 나중에 후회합니다.
    • NFS에 올렸더니 이상하게 불안정함
      원인: Prometheus 공식 문서에서도 로컬 파일시스템 사용을 강하게 권장합니다. 네트워크 파일시스템은 피하는 편이 안전합니다.

    저는 한때 백업 편하겠다고 네트워크 스토리지를 먼저 떠올렸었는데, 이건 운영 편의보다 안정성이 우선이더라고요. 결국은 로컬 디스크 + 스냅샷/백업 전략으로 다시 정리했습니다.

    8. 검증 결과: 무엇이 좋아졌고 무엇을 잃었나

    직접 운영으로 바꾸고 나면 제일 먼저 느끼는 건 비용 예측 가능성입니다. Grafana Cloud 비용처럼 사용량 급등에 따라 청구서가 튀는 대신, 이제는 VM 크기와 디스크 크기, retention 정책으로 상한선을 제가 결정할 수 있습니다. 이거 진짜 편하더라고요. 적어도 월말에 놀랄 일은 줄어듭니다.

    반대로 잃는 것도 분명합니다.

    • 관리형 서비스의 즉시성
    • 긴 retention과 팀 기능의 편의성
    • 장애 시 벤더에 기대는 심리적 안정감

    그래서 결론은 단순합니다. 메트릭 위주의 소규모~중간 규모 환경이라면 자체 Prometheus는 충분히 매력적입니다. 반면 로그, 트레이스, 장기 보관, 멀티팀 협업이 핵심이면 Grafana Cloud가 여전히 좋은 선택일 수 있습니다. 결국 핵심은 도구 종교가 아니라 ROI와 운영 책임 범위입니다.

    Grafana Cloud 비용 분석 후 자체 Prometheus 전환 결과 대시보드 이미지

    자체 Prometheus 전환 후 Grafana 대시보드와 리소스 사용량을 함께 확인하는 결과 예시입니다.

    9. 정리와 FAQ

    자주 묻는 질문

    • Q. Grafana Cloud를 완전히 버려야 하나요?
      아닙니다. 메트릭만 자체 호스팅하고, 로그나 외부 공유 대시보드는 관리형을 유지하는 혼합형도 충분히 좋습니다.
    • Q. 자체 호스팅 ROI는 언제 좋아지나요?
      청구서 증가 속도보다 VM/스토리지/운영 시간 증가 속도가 느릴 때입니다. 특히 retention이 짧고 운영 범위가 작을수록 유리합니다.
    • Q. 다음 단계는 뭘 보면 좋을까요?
      다음 글에서는 Node Exporter, Alertmanager, 그리고 카디널리티 줄이는 실전 팁을 정리해볼 예정입니다. 이전 글에서 다뤘던 홈랩 스토리지 설계와도 연결해서 보시면 더 이해가 쉬우실 겁니다.

    정리하면 이렇습니다. Grafana Cloud 비용이 부담스럽다고 느껴지는 순간이 오면, 무조건 해지부터 할 필요는 없습니다. 먼저 내 사용량 구조를 보고, 어떤 데이터가 비용을 끌어올리는지 파악한 뒤, 메트릭부터 단계적으로 분리해보세요. 저처럼 한 번 직접 돌려보면, 어떤 환경에서 자체 호스팅이 맞는지 감이 꽤 선명해집니다. 처음엔 헷갈려도, 막상 해보면 생각보다 어렵지 않습니다.

    Grafana Cloud 비용과 자체 호스팅 ROI를 비교한 인포그래픽

    Grafana Cloud와 자체 호스팅 ROI를 한눈에 정리한 비교 인포그래픽 예시입니다.

    참고한 공식 문서

  • [홈랩] Proxmox Grafana 연동: 실시간 시스템 모니터링 대시보드 구축하기

    [홈랩] Proxmox Grafana 연동: 실시간 시스템 모니터링 대시보드 구축하기

    [홈랩] Proxmox Grafana 연동: 실시간 시스템 모니터링 대시보드 구축하기

    홈랩이나 작은 서버실을 굴리다 보면 제일 먼저 드는 생각이 있습니다. “지금 이 서버가 멀쩡한 건가?” 하는 거요. 저도 처음엔 Proxmox VE(프록스목스 가상화 플랫폼) 웹 UI만 열어두고 CPU랑 메모리 그래프만 대충 봤었는데, VM(가상 머신) 몇 대 늘어나고 백업 작업까지 겹치니까 감으로 운영하는 게 한계가 오더라고요. 그래서 정리한 게 바로 Proxmox Grafana 연동입니다. 실시간 모니터링을 붙여두면 장애가 터진 뒤에 보는 게 아니라, 터지기 전에 징후를 읽을 수 있게 되거든요.

    특히 디스크 I/O가 순간적으로 튄다든지, 특정 시간대에 메모리 압박이 몰린다든지, 네트워크 사용량이 평소와 다르게 치솟는다든지 하는 패턴은 대시보드로 봐야 감이 옵니다. 실제로 써보니까 “아, 이 VM 때문에 스토리지가 버벅였구나” 같은 걸 훨씬 빨리 잡게 되더라고요. 여기서 중요한 포인트는, 복잡한 엔터프라이즈 구성을 바로 따라 하기보다 작게 시작해서 계속 확장 가능한 구조로 가는 겁니다.

    Proxmox 호스트, Prometheus, Grafana가 어떤 흐름으로 연결되는지 보여주는 전체 구성 예시입니다.

    왜 Proxmox Grafana 연동이 필요한가요?

    쉽게 말해 Proxmox는 가상화 운영에 강하고, Grafana는 시각화에 강합니다. Proxmox 웹 화면만으로도 기본 상태는 볼 수 있지만, 장기간 추세 확인이나 여러 노드 비교, 경고 기준 잡기에는 조금 아쉬운 부분이 있습니다. 반대로 Grafana는 숫자를 보기 좋게 정리해 주고, 한 화면에 여러 지표를 모아서 보여주기 좋습니다.

    제가 직접 해보니 둘을 묶었을 때 가장 편했던 점은 아래 세 가지였습니다.

    • 실시간 모니터링이 가능해서 순간 부하를 놓치지 않습니다.
    • 대시보드 구축이 쉬워서 CPU, 메모리, 디스크, 네트워크를 한 번에 봅니다.
    • 시스템 성능 추세를 쌓아두면 증설 타이밍을 판단하기 편합니다.

    구성 개념 먼저 잡고 가겠습니다

    저도 처음엔 이게 뭔가 싶었는데, 구조를 한 번만 이해하면 생각보다 단순합니다.

    구성 요소 역할 쉽게 말하면
    Proxmox VE 가상화 호스트 운영 VM과 LXC(리눅스 컨테이너)를 돌리는 본체
    node_exporter 시스템 메트릭 노출 CPU, 메모리, 디스크 같은 숫자를 밖으로 보여주는 창구
    Prometheus 메트릭 수집 및 저장 정해진 주기로 숫자를 긁어와 쌓는 수집기
    Grafana 시각화 쌓인 숫자를 대시보드로 예쁘고 실용적으로 보여주는 도구

    이번 글에서는 가장 무난하게 많이 쓰는 흐름인 Proxmox 호스트 + node_exporter + Prometheus + Grafana 기준으로 설명드릴게요. 이 방식은 홈랩에서도 부담이 적고, 나중에 알람(Alerting)이나 추가 노드 확장도 비교적 자연스럽습니다.

    구축 전 체크할 것들

    설치 들어가기 전에 몇 가지만 확인해 두면 삽질을 많이 줄일 수 있습니다 ㅎㅎ

    1. Proxmox 호스트가 정상 동작 중인지 확인합니다.
    2. Prometheus와 Grafana를 올릴 별도 VM 또는 같은 관리용 서버를 준비합니다.
    3. 방화벽에서 Prometheus 수집 포트와 Grafana 접속 포트를 확인합니다.
    4. 시간 동기화가 맞는지 봅니다. 시간 틀어지면 그래프가 이상하게 보일 수 있거든요.

    참고로 저는 관리용 VM을 따로 두는 편입니다. Proxmox 호스트에 이것저것 다 올릴 수도 있지만, 나중에 분리하고 싶어질 가능성이 높더라고요. 특히 테스트 환경에서는 더 그렇습니다.

    실전 구현 1: Proxmox 호스트에 node_exporter 설치

    먼저 Proxmox 호스트의 시스템 지표를 외부에서 읽게 만들어봅시다. 여기서 사용하는 node_exporter는 Prometheus 생태계에서 가장 널리 쓰이는 시스템 메트릭 수집용 에이전트입니다.

    Debian 계열 기준으로 아래처럼 진행하면 됩니다. Proxmox VE도 Debian 기반이라 흐름은 비슷합니다.

    apt update
    apt install -y prometheus-node-exporter
    systemctl enable --now prometheus-node-exporter
    systemctl status prometheus-node-exporter

    설치가 끝나면 기본적으로 9100 포트에서 메트릭을 노출하게 됩니다. 여기서 중요한 건, 외부에 무작정 열지 말고 관리망에서만 접근 가능하게 두는 겁니다.

    ss -tulpen | grep 9100
    curl http://127.0.0.1:9100/metrics | head

    위 명령에서 숫자가 쭉 나오면 정상입니다. 처음 보면 좀 당황스럽습니다. 저도 “이걸 사람이 어떻게 읽지?” 싶었는데, 사람이 읽는 용도가 아니라 Prometheus가 읽는 형식이라고 생각하시면 됩니다.

    Proxmox Grafana 연동을 위한 node_exporter 메트릭 확인 화면

    node_exporter가 정상적으로 실행되고 메트릭이 노출되는지 확인하는 예시 화면입니다.

    실전 구현 2: Prometheus 설정으로 Proxmox 메트릭 수집

    이제 Prometheus가 Proxmox 호스트의 메트릭을 주기적으로 가져가도록 설정합니다. Prometheus 설정 파일은 보통 prometheus.yml입니다.

    global:
      scrape_interval: 15s
      evaluation_interval: 15s
    
    scrape_configs:
      - job_name: "proxmox-node"
        static_configs:
          - targets:
              - "192.168.0.10:9100"

    여기서 192.168.0.10은 Proxmox 호스트 IP로 바꿔주시면 됩니다. 여러 노드를 운영 중이면 targets에 계속 추가하면 되고요.

    promtool check config /etc/prometheus/prometheus.yml
    systemctl restart prometheus
    systemctl status prometheus

    promtool 검사를 먼저 하는 습관을 들이시면 좋습니다. YAML(야믈, 들여쓰기 기반 설정 형식)은 공백 하나 때문에도 실패하거든요. 저는 여기서 띄어쓰기 때문에 10분 넘게 헤맨 적 있습니다.

    Prometheus 웹 UI에 들어가서 타깃 상태를 확인해 보세요. 상태가 UP으로 보이면 수집이 정상입니다.

    실전 구현 3: Grafana 데이터 소스 연결과 대시보드 구축

    이제부터가 진짜 재미있는 구간입니다. 데이터를 쌓는 것까지 끝났다면, Grafana에서 읽어와 보기 좋은 대시보드로 만들면 됩니다. Proxmox Grafana 연동의 체감 포인트가 여기서 확 옵니다.

    1. Grafana에 로그인합니다.
    2. Data Sources에서 Prometheus를 추가합니다.
    3. Prometheus URL을 입력합니다.
    4. Save & Test로 연결 상태를 확인합니다.
    5. 새 Dashboard를 만들고 패널을 추가합니다.

    Prometheus URL 예시는 보통 아래처럼 넣습니다.

    http://192.168.0.20:9090

    패널에서 바로 써먹기 좋은 기본 쿼리 예시는 이런 식입니다.

    100 - (avg by(instance) (rate(node_cpu_seconds_total{mode="idle"}[5m])) * 100)
    (1 - (node_memory_MemAvailable_bytes / node_memory_MemTotal_bytes)) * 100
    rate(node_network_receive_bytes_total[5m])
    rate(node_disk_read_bytes_total[5m])

    첫 번째는 CPU 사용률, 두 번째는 메모리 사용률, 세 번째와 네 번째는 네트워크 및 디스크 처리량 확인에 많이 씁니다. 꼭 외울 필요는 없습니다. 일단 하나씩 붙여보면서 어떤 값이 나오는지 보는 게 더 빨라요.

    Proxmox Grafana 연동 설정과 대시보드 구축 화면

    Grafana에서 Prometheus를 데이터 소스로 등록하고 기본 패널을 구성하는 예시입니다.

    추천 대시보드 구성

    • 상단: 전체 노드 상태 요약, 업타임, 현재 부하
    • 중단: CPU, 메모리, Load Average(로드 애버리지, 시스템 평균 부하)
    • 하단: 디스크 읽기/쓰기, 네트워크 송수신, 파일시스템 사용률

    혹시 여기서 “VM별로도 더 자세히 보고 싶은데요?” 싶으실 수 있습니다. 그럴 땐 수집 대상을 더 세분화하거나, 별도 exporter(익스포터, 메트릭 노출 도구)를 추가하는 방식으로 확장할 수 있어요. 다만 처음부터 욕심내면 오히려 구조가 꼬이기 쉬워서, 저는 호스트 레벨 모니터링부터 안정화하는 걸 추천드립니다.

    대시보드 설계 팁: 숫자보다 패턴이 중요합니다

    실제로 써보니까 예쁜 대시보드보다 중요한 건 문제 패턴이 바로 보이게 만드는 것이었습니다. 예를 들어 CPU 패널만 크게 놓는 것보다, 같은 시간축에 디스크 I/O와 메모리 사용량을 같이 두는 게 원인 추적에 훨씬 유리합니다.

    패널 보면 좋은 이유 주의할 점
    CPU Usage 부하 급증 구간 확인 짧은 스파이크에만 과민 반응하지 않기
    Memory Usage 누수나 캐시 압박 확인 리눅스 캐시 사용을 오해하지 않기
    Disk I/O 스토리지 병목 파악 백업 시간대와 함께 보기
    Network Throughput 백업, 마이그레이션, 다운로드 패턴 확인 단발성 피크와 지속 부하를 구분하기

    여기서 중요한 포인트! 시스템 성능은 단일 수치보다 상관관계로 봐야 합니다. CPU가 높은데 실제 원인은 디스크 대기 때문인 경우도 있고, 네트워크가 치솟아서 백업이 오래 걸리는 경우도 있거든요.

    ⚠️ 제가 겪었던 문제와 트러블슈팅

    이 파트는 좀 현실적으로 적어보겠습니다. 저도 처음엔 설정 몇 줄 넣으면 끝날 줄 알았는데, 은근히 자잘한 문제를 많이 만났습니다.

    1. Prometheus 타깃이 DOWN으로 보일 때

    • node_exporter 서비스가 실제로 떠 있는지 확인합니다.
    • 포트 접근이 방화벽에서 막히지 않았는지 봅니다.
    • Prometheus 설정의 IP와 포트가 맞는지 다시 확인합니다.
    systemctl status prometheus-node-exporter
    curl http://192.168.0.10:9100/metrics
    journalctl -u prometheus -n 50

    2. 그래프는 나오는데 값이 이상할 때

    이건 대개 쿼리나 단위 해석 문제였습니다. 예를 들어 바이트(bytes)와 비트(bits)를 혼동하면 네트워크 그래프가 엉뚱하게 보이더라고요. 또 메모리 사용량은 캐시 영역 때문에 숫자만 보고 “메모리 꽉 찼네”라고 오해하기 쉽습니다.

    3. 대시보드가 너무 복잡해질 때

    처음엔 이것도 넣고 저것도 넣고 싶어집니다. 저도 그랬고요. 근데 결국 자주 보는 패널만 남더라고요. 운영 화면은 한눈에 이해되는 것이 제일 중요합니다. 디테일한 패널은 별도 탭으로 분리하는 게 좋았습니다.

    4. 시간축이 어긋나 보일 때

    서버 시간 동기화 문제를 꼭 확인하세요. 모니터링에서 시간 꼬이면 진짜 골치 아픕니다. 그래프가 안 맞아 보이는 순간 신뢰도가 확 떨어지거든요.

    Proxmox Grafana 연동 상태를 검증하는 Prometheus 모니터링 화면

    Prometheus에서 수집 대상 상태를 점검하며 문제를 찾는 장면을 표현한 이미지입니다.

    검증: 제대로 붙었는지 어떻게 확인할까요?

    구축이 끝났다면 아래 순서로 검증해 보시면 됩니다.

    1. Prometheus Targets 화면에서 Proxmox 노드가 UP인지 확인합니다.
    2. Grafana 패널에서 최근 15분 데이터가 정상적으로 쌓이는지 봅니다.
    3. 테스트로 부하를 조금 주고 그래프 변화가 바로 반영되는지 확인합니다.

    예를 들어 Proxmox 호스트에서 패키지 업데이트나 파일 복사 작업을 수행해 보면 CPU, 디스크, 네트워크 그래프가 움직이는 걸 바로 볼 수 있습니다. 드디어 됐다! 싶은 순간이 여기입니다. 이 맛에 모니터링 붙이는 거죠.

    apt update
    dd if=/dev/zero of=/tmp/io-test.bin bs=1M count=256 oflag=direct
    rm -f /tmp/io-test.bin

    테스트 명령은 운영 환경 상황을 보고 조심해서 사용하셔야 합니다. 특히 디스크 테스트는 스토리지 성격에 따라 부담이 될 수 있으니 무리하지 않는 선에서 확인하세요.

    정리: 제가 추천하는 최소 구성

    처음 시작하신다면 아래 정도면 충분합니다.

    • Proxmox 호스트마다 node_exporter 설치
    • 별도 관리 VM에 Prometheus 설치
    • Grafana에서 호스트별 대시보드 1개, 전체 요약 대시보드 1개 구성
    • CPU, 메모리, 디스크 I/O, 네트워크만 먼저 안정화

    이 구성이 좋은 이유는 단순합니다. 운영이 쉽고, 나중에 확장도 자연스럽습니다. 실제로 Proxmox Grafana 연동을 해두면 장애 대응 속도가 꽤 달라집니다. 문제가 생긴 뒤 로그를 뒤지는 시간이 줄고, 평소 패턴을 알아야 이상 징후도 빨리 눈에 들어오거든요.

    Proxmox Grafana 연동 완료 후 실시간 시스템 성능 대시보드

    CPU, 메모리, 디스크, 네트워크 지표가 한눈에 보이는 최종 대시보드 요약 이미지입니다.

    마무리: 실시간 모니터링은 사치가 아니라 기본입니다

    예전엔 저도 “작은 홈랩인데 굳이 여기까지 해야 하나?” 싶었습니다. 근데 한 번 붙여보면 생각이 바뀝니다. 실시간 모니터링은 큰 환경에서만 필요한 게 아니라, 오히려 혼자 운영하는 작은 환경일수록 더 중요하더라고요. 사람이 적을수록 대시보드가 대신 봐줘야 하니까요.

    이번 글에서는 가장 보편적인 방식으로 Proxmox Grafana 연동 흐름을 정리해봤습니다. 다음 단계로는 알람 조건을 붙이거나, 여러 Proxmox 노드를 비교하는 대시보드까지 확장해 보시면 좋습니다. 이전 글에서 다룬 백업 전략과 같이 묶어보면 운영 안정성이 훨씬 좋아집니다. 다음 글에서는 Alerting(알러팅, 임계치 기반 경고) 쪽도 따로 다뤄볼 예정입니다.

    혹시 지금 Proxmox는 잘 돌아가는데, 가끔씩 이유 없이 느려지는 순간이 있으신가요? 그럴 때야말로 대시보드가 진짜 힘을 발휘합니다. 저도 처음엔 헷갈렸는데, 한번 구축해 두니까 운영이 훨씬 편해졌습니다. 이거 진짜 편하더라고요.

  • [Linux] rsyslog Loki 마이그레이션: 레거시 로그 시스템 현대화 경험

    [Linux] rsyslog Loki 마이그레이션: 레거시 로그 시스템 현대화 경험

    rsyslog Loki 마이그레이션 경험: 레거시 로그 시스템 현대화

    운영 서버가 늘어나면 로그가 제일 먼저 말을 걸어옵니다. 처음엔 rsyslog 하나로도 잘 굴러가거든요. 파일로 남기고, 필요한 서버로 포워딩하고, 급하면 grep으로 뒤지면 되니까요. 그런데 장애가 길어지고 서버 수가 늘어나면 이야기가 달라집니다. 이번 글은 제가 실제로 진행했던 rsyslog Loki 마이그레이션 경험을 바탕으로, 레거시 로그 시스템을 어떻게 현대화했는지 정리한 내용입니다.

    먼저 현재 시점 기준으로 짚고 갈 점이 하나 있습니다. Promtail은 2026년 3월 2일부로 EOL(지원 종료) 상태라서, 신규 구축이라면 Grafana Alloy도 함께 검토하는 게 맞습니다. 다만 이미 rsyslog와 Promtail을 쓰고 있거나, 단계적으로 Loki로 옮겨야 하는 환경이라면 이 글의 접근은 여전히 꽤 현실적이더라고요. 특히 리눅스 로그 관리, 중앙 집중식 로그, 그리고 조회 동선 단축이 고민이라면 더 그렇습니다.

    저도 처음엔 "rsyslog 잘 돌아가는데 굳이 바꿔야 하나?" 싶었습니다. 막상 옮겨보니 검색성, 라벨(label, 분류용 메타데이터), 대시보드 연동이 확실히 다르더라고요. 반대로 아무 생각 없이 옮기면 기존 syslog 습관 때문에 삽질도 꽤 합니다. 여기서 중요한 포인트는 한 번에 뒤엎지 말고, 수집 계층과 조회 계층을 분리해서 천천히 옮기는 것입니다.

    rsyslog Loki 마이그레이션 전체 아키텍처 다이어그램

    기존 rsyslog 기반 수집과 Promtail, Loki, Grafana가 어떻게 연결되는지 한눈에 보여주는 아키텍처 이미지입니다.

    왜 rsyslog만으로는 점점 버거워졌을까

    rsyslog는 여전히 아주 좋은 도구입니다. 특히 Syslog 생태계에서는 검증이 끝난 축에 가깝습니다. 문제는 "수집은 잘하는데, 분석과 검색은 별도 고민이 필요하다"는 점입니다. 서버 수가 늘고 장애가 복합적으로 얽히기 시작하면, 그 차이가 생각보다 크게 느껴집니다.

    • 서버별 로그 파일 위치가 제각각이면 장애 때 동선이 길어집니다.
    • 포워딩만 해두고 검색 체계가 약하면 결국 SSH 접속 후 grep에 의존하게 됩니다.
    • 애플리케이션 로그와 시스템 로그를 함께 보려면 포맷 통일이 필요합니다.
    • 운영자가 바뀌거나 시간이 지나면 "어디에 뭐가 쌓이는지" 문서보다 실서버가 더 진실이 됩니다.

    제가 겪었던 가장 큰 문제는 장애 시점 상관관계(correlation, 연관 분석)가 너무 느렸다는 점이었습니다. 예를 들어 웹 서버에서 502가 튀고, 뒤에서 인증 서비스가 지연되고, 같은 시간대에 커널 메시지까지 흔들리면 이걸 시간축으로 모아봐야 하거든요. rsyslog만으로 불가능한 건 아니지만, 편하게 하기는 어렵습니다. 그래서 결론은 명확했습니다. 수집은 rsyslog의 장점을 활용하고, 조회와 분석은 Loki 쪽으로 넘기자. 이게 제가 정리한 rsyslog Loki 마이그레이션의 핵심 방향이었습니다.

    rsyslog Loki 마이그레이션에서 Loki와 Promtail을 어떻게 볼까

    쉽게 말해 Loki는 로그 저장소이자 검색 엔진 역할을 하고, Promtail은 로그를 모아서 Loki로 보내는 에이전트입니다. Prometheus가 메트릭을 다루듯이, Loki는 로그를 라벨 기반으로 다루는 느낌이라고 보시면 됩니다. 다만 2026년 기준으로는 Promtail보다 Grafana Alloy가 앞으로의 기본 경로라는 점은 꼭 같이 기억하셔야 합니다.

    구성요소 역할 마이그레이션에서의 포인트
    rsyslog 로그 수집, 필터링, 포워딩 기존 서버 설정을 최대한 유지하면서 다음 수집 계층으로 전달
    Promtail 로그 수신 또는 파일 테일링 기존 환경에서 syslog 수신 지점 또는 파일 수집 지점으로 활용 가능
    Loki 로그 저장 및 질의 라벨 설계가 성패를 좌우
    Grafana 조회, 대시보드, 탐색 운영자가 가장 체감하는 개선 지점
    Grafana Alloy 차세대 수집 에이전트 신규 구축이나 장기 운영 기준으로 우선 검토

    많이 헷갈리는 부분이 하나 있습니다. "Promtail이 파일만 읽는 거 아니었나?" 저도 처음엔 그렇게 생각했었습니다. 그런데 Promtail은 Syslog Receiver 설정도 지원합니다. 그래서 기존 rsyslog가 잘 깔려 있다면, rsyslog가 TCP로 Promtail에 넘기고 Promtail이 Loki로 적재하는 구조가 꽤 현실적입니다. 이 방식이 좋은 이유는 레거시 환경을 한 번에 뜯어고치지 않아도 되기 때문입니다.

    마이그레이션 설계: 한 번에 바꾸지 말고 두 단계로

    제가 추천드리는 방식은 아래 순서입니다. 이 흐름이 rsyslog Loki 마이그레이션에서 제일 덜 아프더라고요.

    1. 1단계: 기존 rsyslog는 유지하고, Promtail 또는 Alloy를 syslog 수신기로 세웁니다.
    2. 2단계: Grafana에서 검색과 대시보드를 검증한 뒤, 필요한 서버부터 파일 수집이나 구조화 로그로 확장합니다.

    이렇게 하면 롤백도 쉽습니다. 장애가 나도 rsyslog는 원래 하던 일을 계속하니까요. 운영에서는 이 안정감이 정말 큽니다.

    rsyslog Loki 마이그레이션 2단계 전환 구성도

    기존 rsyslog를 유지한 채 Promtail을 앞단 수신기로 추가하고, 이후 Loki 조회 환경을 점진적으로 확장하는 전환 방식입니다.

    권장 아키텍처

    • 애플리케이션/시스템 로그 발생
    • 로컬 rsyslog가 표준 syslog 포맷으로 정리
    • rsyslog가 TCP로 Promtail에 전달
    • Promtail이 라벨을 붙여 Loki로 전송
    • Grafana에서 검색, 필터링, 시각화

    중요한 포인트! 라벨은 많이 붙인다고 좋은 게 아닙니다. host, job, facility 정도처럼 조회에 꼭 필요한 축만 먼저 가져가세요. 처음부터 프로그램명, PID, path, 환경명, 팀명, 서비스명까지 다 라벨로 올리면 쿼리보다 라벨 관리가 더 힘들어집니다.

    실전 구현: rsyslog에서 Loki로 넘기는 기본 구성

    이제 실제 설정입니다. 아래 예시는 "Promtail이 syslog를 받고 Loki에 넣는 구성"입니다. 이미 Loki, Grafana, Promtail 서비스가 준비되어 있다는 전제로 적겠습니다. 설치 방식은 배포판 패키지, 바이너리, 컨테이너 등 환경마다 다르니 여기서는 마이그레이션 구성 자체에 집중하겠습니다.

    1. Promtail 설정 준비

    Promtail 설정에는 positions 파일이 자주 등장합니다. 파일 테일링이나 journal 수집에서는 어디까지 읽었는지 기억하는 데 중요하거든요. 다만 이 글처럼 syslog receiver만 쓰는 경로라면 중복 수집 방지의 핵심은 positions 파일보다 수집 경로 분리와 송신 설계에 있습니다. 이 부분은 저도 초반에 헷갈렸습니다.

    sudo mkdir -p /etc/promtail
    sudo mkdir -p /var/lib/promtail
    sudo chown -R promtail:promtail /var/lib/promtail

    다음은 Promtail 설정 예시입니다.

    server:
      http_listen_port: 9080
      grpc_listen_port: 0
    
    positions:
      filename: /var/lib/promtail/positions.yaml
    
    clients:
      - url: http://loki.example.internal:3100/loki/api/v1/push
    
    scrape_configs:
      - job_name: syslog
        syslog:
          listen_address: 0.0.0.0:1514
          listen_protocol: tcp
          idle_timeout: 60s
          label_structured_data: true
          labels:
            job: syslog
        relabel_configs:
          - source_labels: ['__syslog_message_hostname']
            target_label: host
          - source_labels: ['__syslog_message_app_name']
            target_label: app
          - source_labels: ['__syslog_message_severity']
            target_label: severity

    여기서 제가 실제로 많이 썼던 건 relabel_configs입니다. syslog 헤더에서 넘어온 값을 바로 host, app 같은 라벨로 바꿔주면 Grafana 탐색이 훨씬 편해집니다. 처음엔 라벨 이름을 제 멋대로 만들다가 쿼리 통일이 안 돼서 다시 정리했었는데, 운영팀 여러 명이 같이 볼 거면 naming rule부터 맞춰두는 게 좋습니다.

    2. rsyslog에서 Promtail로 포워딩

    rsyslog는 omfwd 모듈로 Promtail 쪽으로 보낼 수 있습니다. TCP를 권장하는 이유는 운영에서 안정성이 더 좋기 때문입니다. UDP는 편하지만 장애 상황에서 조용히 놓치는 메시지가 생기면 답답하더라고요. 특히 Promtail 쪽은 RFC5424 계열 syslog 포맷과 octet-counted framing 조합이 가장 무난했습니다.

    # /etc/rsyslog.d/90-promtail.conf
    *.* action(
      type="omfwd"
      protocol="tcp"
      target="promtail.example.internal"
      port="1514"
      Template="RSYSLOG_SyslogProtocol23Format"
      TCP_Framing="octet-counted"
      KeepAlive="on"
      queue.type="linkedList"
    )

    queue.type="linkedList"를 넣은 이유도 꼭 짚고 넘어가야 합니다. 원격 수신기가 잠깐 죽거나 네트워크가 흔들릴 때, 큐가 없으면 송신 쪽이 막히거나 손실을 체감하기 쉬워집니다. 다만 운영 환경에 따라 디스크 큐나 재시도 옵션까지 더 챙겨야 할 수 있으니, 중요한 서비스라면 여기서 한 번 더 보수적으로 잡는 걸 권합니다.

    3. 설정 검증과 서비스 재시작

    설정 파일을 넣었다고 바로 끝은 아닙니다. 문법 검사를 먼저 하고, 서비스 상태를 짧게라도 확인해야 뒤탈이 적습니다. 이 단계에서 1분만 더 써도 나중에 1시간 덜 헤매더라고요.

    sudo rsyslogd -N1
    sudo systemctl restart rsyslog
    sudo systemctl restart promtail
    sudo systemctl status rsyslog --no-pager
    sudo systemctl status promtail --no-pager

    rsyslog는 재시작 전에 rsyslogd -N1로 문법 검사를 꼭 하세요. 이거 안 하고 바로 재시작했다가 로그 수집 전체가 멈추면 진짜 식은땀 납니다.

    4. 테스트 로그 보내기

    테스트는 꼭 단순해야 합니다. logger 한 줄로 시작하세요. 괜히 복잡한 애플리케이션 로그부터 확인하면 어디서 막혔는지 추적이 어렵습니다.

    logger -t migration-test "rsyslog to promtail to loki test message"
    curl -s http://127.0.0.1:9080/ready
    curl -s http://loki.example.internal:3100/ready

    여기서 ready 응답이 나온다고 끝난 건 아닙니다. 실제로 Grafana Explore에서 라벨이 원하는 대로 붙는지까지 봐야 합니다. 운영에서는 이 마지막 한 단계가 제일 중요하더라고요.

    Promtail 활용과 rsyslog 전달 설정 구성 이미지

    Promtail의 syslog 수신 설정과 rsyslog의 omfwd 전달 관계를 시각적으로 정리한 구성 이미지입니다.

    ⚠️ 실제로 많이 겪는 문제와 해결 방법

    여기부터가 진짜 운영 이야기입니다. 문서만 보면 금방 끝날 것 같았는데, 저는 여기서 시간을 꽤 썼습니다. rsyslog Loki 마이그레이션은 개념보다 디테일에서 더 많이 막히더라고요.

    1. 메시지는 들어오는데 라벨이 예상과 다를 때

    Promtail이 syslog 헤더를 내부 라벨로 들고 오는데, relabel_configs에서 이름을 잘못 참조하면 Grafana에서 host가 비어 보일 수 있습니다. 이 경우는 대부분 입력값 이름을 잘못 쓴 겁니다. 예를 들어 hostname, app-name 같은 식으로 감으로 쓰면 안 되고, Promtail이 제공하는 내부 라벨 이름을 기준으로 맞춰야 합니다.

    • host가 비면 __syslog_message_hostname 확인
    • 앱 이름이 비면 __syslog_message_app_name 확인
    • 심각도가 안 잡히면 __syslog_message_severity 확인

    2. rsyslog는 보냈다고 하는데 Promtail에서 안 받을 때

    이건 네트워크와 포맷 두 가지를 같이 보셔야 합니다. TCP 포트가 열려 있는지 먼저 확인하고, 그다음 syslog 포맷을 맞춰야 합니다. 저도 한 번은 포트는 맞게 열어두고 템플릿을 기본값으로 둬서 Promtail 파싱이 애매하게 꼬인 적이 있었습니다. 그 뒤로는 RSYSLOG_SyslogProtocol23Format을 먼저 의심합니다.

    ss -lntp | grep 1514
    sudo journalctl -u promtail -n 50 --no-pager
    sudo journalctl -u rsyslog -n 50 --no-pager

    3. 중복 수집이 생길 때

    이 부분도 자주 나옵니다. 기존에 파일 테일링과 syslog 포워딩을 동시에 물려두면 같은 로그가 두 번 들어갈 수 있습니다. 특히 /var/log/messages를 Promtail이 읽고 있는데, 같은 메시지를 rsyslog가 또 syslog receiver로 보내면 조회 화면에서 두 줄로 보여요. 처음엔 "Loki가 복제했나?" 싶었는데 아니더라고요. 수집 경로를 한 로그 소스당 하나로 정리해야 합니다.

    4. 라벨을 너무 많이 붙여서 쿼리가 무거워질 때

    라벨은 검색에 좋지만, 남발하면 관리 포인트가 폭증합니다. 저는 초기에 프로그램명, 파일경로, 환경명, 인스턴스명, 팀명까지 다 넣었다가 나중에 정리하느라 더 힘들었습니다. 운영에서 오래 가는 구성은 의외로 단순합니다.

    항목 처음 욕심낸 구성 지금 추천하는 구성
    host 사용 사용
    job 사용 사용
    app 사용 선택적 사용
    path 라벨로 사용 가급적 지양
    pid 라벨로 사용 지양
    team/env 모두 라벨화 정말 필요한 것만

    검증: rsyslog Loki 마이그레이션이 제대로 끝났는지 확인하는 방법

    설정이 끝났다고 바로 성공은 아닙니다. 운영에서는 "수집된다"보다 "원하는 방식으로 검색된다"가 더 중요합니다. 저는 아래 체크리스트로 마이그레이션 완료 여부를 봤습니다.

    1. 테스트 메시지가 Loki에 들어오는지 확인
    2. host 라벨로 서버별 필터링이 되는지 확인
    3. 같은 시간대 다른 서버 로그를 한 화면에서 비교 가능한지 확인
    4. 기존 rsyslog 경로와 신규 Loki 경로 결과가 크게 어긋나지 않는지 샘플 비교
    5. 장애 상황에서 운영자가 SSH보다 Grafana를 먼저 열게 되는지 확인

    Grafana Explore에서는 보통 이런 식으로 보기 시작했습니다.

    {job="syslog",host="web-01"}
    {job="syslog",app="nginx"}
    {job="syslog",severity="err"}

    드디어 원하는 대로 host 기준으로 잘 걸리고, 애플리케이션별로도 묶이기 시작하면 그때부터 체감이 옵니다. "아, 이제 장애 볼 때 여기부터 보면 되겠구나" 하는 느낌이요. 이거 진짜 편하더라고요.

    Grafana Loki에서 중앙 집중식 로그를 검색하는 결과 화면

    Grafana Explore에서 host, app, severity 라벨로 로그를 필터링하고 시간축으로 비교하는 결과 화면 이미지입니다.

    마이그레이션 이후 운영 방식이 어떻게 바뀌었나

    가장 큰 변화는 로그 확인 동선이 짧아졌다는 점입니다. 예전에는 "어느 서버지? 어떤 파일이지? 압축됐나? rotate됐나?"부터 시작했는데, 지금은 일단 Grafana에서 시간대와 호스트를 좁혀보고 필요할 때만 서버에 들어갑니다. 중앙 집중식 로그 체계의 장점이 여기서 확실히 보입니다.

    • 장애 초동 대응 속도가 빨라집니다.
    • 서버별 로그 위치를 전부 외우지 않아도 됩니다.
    • 운영 인수인계가 쉬워집니다.
    • 애플리케이션 로그와 시스템 로그를 함께 보기 편해집니다.

    물론 단점도 있습니다. Loki 쪽 저장 정책, 라벨 설계, 대시보드 표준화는 결국 운영팀이 책임져야 합니다. 그래서 저는 마이그레이션을 "도구 교체"보다 운영 습관 교정에 가깝게 봅니다. 혹시 지금도 grep과 SSH에 너무 의존하고 계신가요? 그렇다면 rsyslog를 버리라는 뜻이 아니라, 조회 계층만이라도 현대화해보시라고 말씀드리고 싶네요.

    정리와 다음 단계

    rsyslog Loki 마이그레이션은 생각보다 거창한 프로젝트가 아닐 수도 있습니다. 핵심은 rsyslog를 적으로 보지 않는 겁니다. 기존 수집 안정성은 살리고, Promtail 활용 또는 Alloy 전환을 통해 Loki에 연결해서 검색 경험을 개선하면 됩니다. 제가 직접 해보니 한 번에 완벽하게 옮기려는 순간부터 어려워지더라고요. 반대로 syslog receiver 하나 붙이고, 라벨 몇 개만 정리해도 금방 효과가 납니다.

    정리하면 이렇습니다.

    • 수집은 보수적으로: 기존 rsyslog를 유지합니다.
    • 조회는 현대적으로: Loki와 Grafana로 검색 동선을 줄입니다.
    • 라벨은 절제해서: host, job 같은 핵심부터 시작합니다.
    • 중복 수집은 반드시 제거: 파일 테일링과 syslog 전달 경로를 겹치지 않게 합니다.

    다음 글에서는 Loki 쿼리 정리와 라벨 설계 실전, 그리고 systemd-journald와 함께 가져갈 때 어떤 점을 조심해야 하는지 다뤄볼 예정입니다. 블로그의 이전 글에서 다뤘던 로그 로테이션 설계 내용과 연결해서 보시면 흐름이 더 잘 잡히실 거예요.

    rsyslog와 Loki 기반 로그 시스템 현대화 비교 인포그래픽

    레거시 rsyslog 중심 운영과 Loki 기반 현대화 운영의 차이를 요약 비교한 인포그래픽 이미지입니다.

    자주 묻는 질문

    Q1. rsyslog를 완전히 없애야 하나요?

    아닙니다. 많은 환경에서 rsyslog는 여전히 좋은 전처리와 전달 계층입니다. 저도 처음엔 완전 교체를 고민했는데, 실제로는 공존 전략이 훨씬 안정적이었습니다.

    Q2. Promtail은 파일만 읽는 도구인가요?

    아닙니다. syslog 수신 구성도 가능합니다. 다만 현재는 Promtail이 EOL이라서, 새로 시작하는 환경이라면 Grafana Alloy를 먼저 검토하는 편이 맞습니다.

    Q3. 처음부터 구조화 로그(JSON)를 강제해야 하나요?

    꼭 그렇지는 않습니다. 저는 먼저 중앙 수집과 조회 체계를 만들고, 그다음 서비스별로 구조화 로그를 넓혀갔습니다. 순서를 잘 잡는 게 중요합니다.

    Q4. 가장 먼저 챙길 검증 포인트는 뭔가요?

    중복 수집 여부와 라벨 품질입니다. 로그가 들어오는 것만 보면 반쪽 성공입니다. 검색이 잘 되어야 진짜 성공이거든요.

  • [Proxmox] Proxmox API 활용, Grafana 연동을 통한 자원 사용량 모니터링 및 자동화 사례

    [Proxmox] Proxmox API 활용, Grafana 연동을 통한 자원 사용량 모니터링 및 자동화 사례

    [인프라] Proxmox API Grafana 연동으로 자원 사용량 모니터링과 자동화 사례

    홈랩이나 소규모 가상화 환경을 굴리다 보면, 처음에는 Proxmox VE(프록스목스 가상화 환경) 웹 UI만 봐도 충분하다고 느끼실 수 있습니다. 저도 그랬거든요. 그런데 VM이 몇 대만 넘어가도 CPU, Memory(메모리), Storage(스토리지) 사용량이 순간적으로 튀는 구간이 보이고, 그때마다 사람이 직접 들어가 확인하는 방식은 금방 한계가 오더라고요. 그래서 이번 글에서는 Proxmox API Grafana 조합으로 자원 사용량을 한눈에 보고, 특정 조건에서는 자동화까지 연결한 실제 운영 패턴을 정리해보겠습니다. Proxmox 모니터링과 API 자동화, Grafana 연동이 왜 같이 가야 하는지, 제가 직접 해보면서 느낀 삽질 포인트까지 솔직하게 적어보겠습니다.

    특히 이런 분들께 잘 맞습니다. VM 수가 늘면서 자원 사용량을 장기적으로 보고 싶으신 분, 장애 직전의 징후를 미리 잡고 싶으신 분, 그리고 반복 확인 작업을 자동화하고 싶으신 분이요. 여기서 중요한 포인트! 단순히 대시보드만 예쁘게 만드는 게 목적이 아니라, 운영 판단 속도를 올리는 것이 핵심입니다.

    Proxmox API Grafana 연동 전체 흐름을 보여주는 아키텍처 예시입니다. Proxmox 노드, 메트릭 수집 스크립트, 시각화 계층의 관계를 한눈에 볼 수 있게 배치하면 이해가 훨씬 쉬워집니다.

    왜 Proxmox API Grafana 구성이 중요한가

    쉽게 말해 Proxmox API는 현재 상태를 꺼내오는 창구이고, Grafana는 그 상태를 사람이 판단하기 좋은 형태로 보여주는 대시보드입니다. 둘을 따로 보면 평범한데, 같이 묶으면 운영 품질이 꽤 달라집니다.

    예를 들어 웹 UI에서는 지금 CPU가 높은지 낮은지 바로 볼 수는 있어도, 지난 일주일 동안 특정 VM이 언제부터 메모리를 먹기 시작했는지, 백업 시간대와 I/O 부하가 겹쳤는지 같은 맥락은 금방 흐려집니다. 실제로 써보니까, 이 부분이 사람이 체감하는 운영 난이도를 크게 갈라놓더라고요.

    • Proxmox API: 노드, VM, 컨테이너(CT), 스토리지 상태를 JSON 형태로 조회
    • Grafana: 시계열 그래프, 표, 상태 패널로 이상 징후 시각화
    • 자동화: 임계치 초과 시 알림 또는 후속 작업 실행

    저는 초반에 “그냥 필요한 순간에 UI 들어가서 보면 되지 않을까?”라고 생각했었는데요. 막상 밤에 부하가 튀고, 다음 날 와서 원인을 보려니 이미 지나간 데이터는 감으로만 추적하게 되더라고요. 그때부터 API 기반 수집을 붙였습니다. 드디어 됐다 싶은 순간이 있었던 게, 장애가 나기 전에 패턴이 보이기 시작했다는 점이었습니다.

    핵심 개념 정리: API 자동화와 Proxmox 모니터링

    Proxmox API는 무엇을 주는가

    Proxmox VE는 REST API(레스트 API, HTTP 기반 관리 인터페이스)를 제공합니다. 이 API로 노드 목록, VM 상태, CPU 사용량, 메모리 점유, 디스크 상태 같은 정보를 조회할 수 있습니다. 인증은 보통 API Token(토큰 인증)이나 세션 기반으로 처리합니다.

    여기서 주의하실 점은, API가 만능은 아니라는 겁니다. 현재값(current) 조회에는 아주 편하지만, 장기 보관과 비교 분석은 별도 저장 계층이 있어야 합니다. 그래서 Grafana를 붙일 때도 대개는 중간에 메트릭 저장소나 수집 스크립트를 둡니다.

    Grafana는 어디서 빛나는가

    Grafana는 단순 그래프 툴이 아니라, 운영자가 “그래서 지금 뭘 해야 하지?”를 판단하게 해주는 시각화 도구에 가깝습니다. CPU 평균, 메모리 사용률, VM별 트렌드, 노드별 비교, 이상치 탐지에 강하거든요.

    구성 요소 역할 운영 포인트
    Proxmox API 실시간 상태 조회 인증과 요청 빈도 관리가 중요
    수집 스크립트 API 응답을 메트릭 형태로 변환 실패 시 재시도와 로그 필요
    Prometheus 시계열 메트릭 저장 스크랩 주기와 보존 기간 설계
    Grafana 대시보드/알림 운영자 시점 패널 구성 필요

    혹시 이런 경험 있으신가요? 숫자는 많은데, 막상 어떤 VM이 문제인지 바로 안 보이는 상황이요. 저는 딱 그랬습니다. 그래서 패널을 예쁘게 만드는 것보다, 노드 단위와 VM 단위를 분리해서 보는 구조가 더 중요하다는 걸 뒤늦게 배웠습니다.

    실전 구현 1: Proxmox API 토큰과 수집 흐름 만들기

    제가 실제로 안정적으로 썼던 방식은 이렇습니다. Proxmox API에서 값을 읽고, Python(파이썬) 스크립트로 필요한 필드만 정리한 뒤, Prometheus exporter(프로메테우스 익스포터, 메트릭 노출기) 형태로 내보내고, Grafana에서 이를 시각화하는 구조입니다. Grafana가 직접 API를 두드리는 방식도 가능은 하지만, 운영해보니 중간 계층을 두는 편이 훨씬 관리가 편하더라고요.

    1. Proxmox에서 읽기 전용 API Token 생성
    2. 수집 대상 노드와 VM 범위 정의
    3. Python 스크립트로 API 호출 및 메트릭 변환
    4. Prometheus가 주기적으로 수집
    5. Grafana 대시보드와 알림 정책 구성

    1. API 토큰 준비

    실서비스든 홈랩이든, 자동화에는 계정 분리가 기본입니다. 관리자 계정을 그대로 물리는 건 추천드리지 않습니다. 최소 권한 원칙(Principle of Least Privilege, 최소 권한 원칙)으로 읽기 전용 토큰을 따로 만드시는 게 좋습니다.

    export PVE_HOST="https://proxmox.example.local:8006"
    export PVE_TOKEN_ID="monitor@pve!grafana"
    export PVE_TOKEN_SECRET="YOUR_TOKEN_SECRET"
    

    환경 변수로 분리해두면 스크립트 수정 없이 운영하기 편합니다. 저는 처음에 토큰 문자열을 코드 안에 박아뒀다가, 나중에 회전(rotation)할 때 꽤 귀찮았거든요.

    2. API 확인

    먼저 가장 단순한 조회부터 붙여보면 감이 옵니다.

    curl -k -H "Authorization: PVEAPIToken=${PVE_TOKEN_ID}=${PVE_TOKEN_SECRET}" \
      "${PVE_HOST}/api2/json/nodes"
    

    응답은 JSON 형태로 오고, 여기서 노드 이름을 먼저 확인할 수 있습니다. 그다음 특정 노드의 상태를 조회합니다.

    NODE="pve01"
    curl -k -H "Authorization: PVEAPIToken=${PVE_TOKEN_ID}=${PVE_TOKEN_SECRET}" \
      "${PVE_HOST}/api2/json/nodes/${NODE}/status"
    

    이 단계에서 API 응답 구조를 손으로 한 번 읽어보시는 걸 추천드립니다. 제가 직접 해보니, 어떤 필드를 지표로 쓸지 이때 정리해두면 이후 Grafana 패널 설계가 훨씬 빨라집니다.

    Proxmox API 응답과 메트릭 수집 흐름을 보여주는 Grafana 연동 이미지

    API 응답 JSON에서 CPU, 메모리, 디스크 필드를 골라 메트릭으로 바꾸는 과정을 표현한 이미지 자리입니다. 중간 수집 계층의 역할을 보여주면 실전 흐름 이해에 도움이 됩니다.

    실전 구현 2: Python으로 메트릭 변환하고 Grafana 연동하기

    여기서는 예시로 간단한 Python 스크립트를 사용하겠습니다. 핵심은 Proxmox API 응답을 가져와서 Prometheus가 읽기 좋은 텍스트 포맷으로 내보내는 겁니다.

    import os
    import requests
    from flask import Flask, Response
    
    app = Flask(__name__)
    
    PVE_HOST = os.environ["PVE_HOST"]
    PVE_TOKEN_ID = os.environ["PVE_TOKEN_ID"]
    PVE_TOKEN_SECRET = os.environ["PVE_TOKEN_SECRET"]
    VERIFY_TLS = False
    
    
    def pve_get(path: str):
        headers = {
            "Authorization": f"PVEAPIToken={PVE_TOKEN_ID}={PVE_TOKEN_SECRET}"
        }
        r = requests.get(f"{PVE_HOST}{path}", headers=headers, verify=VERIFY_TLS, timeout=10)
        r.raise_for_status()
        return r.json()["data"]
    
    
    @app.route("/metrics")
    def metrics():
        lines = []
        nodes = pve_get("/api2/json/nodes")
    
        for node in nodes:
            node_name = node["node"]
            status = pve_get(f"/api2/json/nodes/{node_name}/status")
    
            cpu = status.get("cpu", 0)
            maxmem = status.get("memory", {}).get("total", 0) if isinstance(status.get("memory"), dict) else 0
            usedmem = status.get("memory", {}).get("used", 0) if isinstance(status.get("memory"), dict) else 0
    
            lines.append(f'proxmox_node_cpu_ratio{{node="{node_name}"}} {cpu}')
            lines.append(f'proxmox_node_memory_used_bytes{{node="{node_name}"}} {usedmem}')
            lines.append(f'proxmox_node_memory_total_bytes{{node="{node_name}"}} {maxmem}')
    
        body = "\n".join(lines) + "\n"
        return Response(body, mimetype="text/plain; version=0.0.4")
    
    
    if __name__ == "__main__":
        app.run(host="0.0.0.0", port=9108)
    

    여기서 한 가지 말씀드리면, 실제 API 응답 필드 구조는 환경에 따라 확인이 필요합니다. 그래서 처음부터 모든 리소스를 다 넣기보다, CPU와 메모리처럼 운영 판단에 바로 쓰이는 값부터 시작하는 편이 좋습니다. 저도 처음엔 욕심내서 디스크, 네트워크, VM 상태, 백업 작업까지 한 번에 넣으려다가 오히려 디버깅 시간이 길어졌습니다.

    Prometheus 스크랩 설정

    scrape_configs:
      - job_name: "proxmox-api-exporter"
        metrics_path: /metrics
        static_configs:
          - targets:
              - "proxmox-exporter.local:9108"
    

    이제 Grafana에서는 Prometheus 데이터 소스를 연결하고 패널을 만듭니다. 예를 들면 이런 쿼리들이 기본 뼈대가 됩니다.

    proxmox_node_cpu_ratio * 100
    
    (proxmox_node_memory_used_bytes / proxmox_node_memory_total_bytes) * 100
    

    Grafana 연동에서 중요한 건 패널 개수보다 뷰의 목적입니다. 저는 보통 아래처럼 나눕니다.

    • 상단: 노드별 CPU, 메모리 전체 상태
    • 중단: VM별 Top N 사용량
    • 하단: 지난 24시간 변화량과 이상 구간

    이 구성이 생각보다 편합니다. 문제를 위에서 아래로 좁혀 들어가기 좋거든요.

    실전 구현 3: API 자동화로 반복 작업 줄이기

    이제 대시보드가 보이기 시작하면, 다음 단계는 자동화입니다. 저는 처음에 알림만 붙였다가, 나중에는 특정 조건에서 후속 작업을 자동으로 실행하는 구조까지 확장했습니다. 여기서 말하는 자동화는 무조건 VM을 강제로 끄는 위험한 방식이 아니라, 안전한 선에서 운영자 개입을 줄이는 보조 자동화입니다.

    예를 들면 이런 식입니다.

    1. 특정 노드 메모리 사용률이 일정 시간 이상 높게 유지됨
    2. Grafana Alerting(알림) 또는 별도 스크립트가 Webhook(웹훅)을 호출
    3. Webhook 수신 스크립트가 Slack, 메일, 또는 내부 운영 채널로 통보
    4. 필요 시 사전 정의된 Ansible(앤서블, 자동화 도구) 작업 실행

    저는 여기서 “자동 복구”라는 말을 쉽게 쓰지 않습니다. 자동화는 편하지만, 잘못 걸면 장애를 키우거든요. 대신 알림 + 안전한 후속 조치 구조가 현실적이었습니다.

    import requests
    
    THRESHOLD = 0.90
    
    
    def notify_if_high(node_name, memory_ratio):
        if memory_ratio >= THRESHOLD:
            requests.post(
                "https://hooks.example.local/proxmox-alert",
                json={
                    "node": node_name,
                    "metric": "memory",
                    "ratio": memory_ratio,
                    "message": f"{node_name} memory usage is high"
                },
                timeout=5,
            )
    

    작게 시작하시는 걸 추천드립니다. 예를 들면 “임계치 초과 시 알림”까지만 먼저 붙여도 운영 피로도가 꽤 줄어듭니다. 그다음에 스냅샷 정리, 백업 전 상태 점검, 테스트 VM 정리 같은 보조 자동화를 단계적으로 넣는 게 안전합니다.

    Proxmox 모니터링과 Grafana 연동 결과를 보여주는 운영 대시보드 이미지

    노드 CPU, 메모리 추이 그래프와 임계치 초과 알림 흐름을 함께 보여주는 이미지 자리입니다. 결과가 머릿속에 바로 그려지게 만드는 용도로 좋습니다.

    ⚠️ 제가 겪었던 문제들: 인증, TLS, 지표 해석

    여기 구간은 정말 중요합니다. 문서만 보면 금방 될 것 같았는데, 실제로는 여기서 삽질을 좀 했습니다 ㅎㅎ

    1. API 인증은 되는데 일부 엔드포인트가 비어 보이는 문제

    원인은 대부분 권한 범위였습니다. 토큰이 살아 있어도 읽기 권한이 필요한 경로에 충분히 부여되지 않으면 응답이 제한적으로 보일 수 있습니다. 관리자 토큰으로 대충 해결하기보다, 어떤 리소스를 읽어야 하는지 먼저 정리하고 권한을 맞추시는 게 좋습니다.

    2. 사설 인증서(Private CA) 때문에 요청 실패

    홈랩에서는 TLS(전송 계층 보안) 인증서를 자체 서명으로 쓰는 경우가 많죠. 저도 처음엔 요청마다 인증서 검증 오류가 났습니다. 개발 단계에서만 검증을 끄고, 운영 단계에서는 신뢰할 수 있는 CA를 배포하는 쪽이 맞습니다. 검증 비활성화는 임시 조치라고 생각하셔야 합니다.

    3. CPU 비율과 메모리 절대값을 한 패널에 섞어놓은 실수

    이거 진짜 헷갈리더라고요. 초반엔 한 패널에 다 넣었다가 그래프 해석이 너무 어려웠습니다. 비율(%)과 절대값(Bytes)은 분리해서 보는 게 맞습니다. 운영자는 예쁜 그래프보다 빠른 판단이 중요하거든요.

    4. 스크랩 주기를 너무 짧게 잡은 문제

    수집 주기를 과하게 짧게 잡으면 API 요청 수만 늘고, 얻는 실익은 크지 않을 수 있습니다. 특히 홈랩처럼 자원이 넉넉하지 않은 환경에서는 더 그렇습니다. 저는 처음엔 촘촘하게 잡아야 정확할 줄 알았는데, 실제로는 운영 목적에 맞는 간격이 더 중요했습니다.

    • 실시간 장애 대응이 목적이면 짧은 주기
    • 용량 계획(capacity planning, 용량 계획)이 목적이면 중간 주기
    • 장기 추세 분석이 목적이면 보존 정책이 더 중요

    검증: 대시보드에서 무엇이 보이면 성공인가

    모니터링은 붙였다고 끝이 아닙니다. 검증 기준이 있어야 합니다. 제가 보는 기준은 아래와 같습니다.

    1. 노드별 CPU, 메모리 사용률이 시간 흐름으로 안정적으로 보이는가
    2. 특정 VM의 급격한 사용량 증가가 구분되는가
    3. 백업, 배치 작업, 업데이트 시간대와 부하 상관관계가 보이는가
    4. 임계치 초과 시 알림이 중복 없이 적절히 오는가

    이 정도만 확보돼도 Proxmox 모니터링 체계가 운영에 실제 도움이 되기 시작합니다. 숫자를 모으는 것과 운영에 쓰는 건 다르거든요. 저는 Grafana에서 하루 뷰, 7일 뷰, 30일 뷰를 나눠두니 체감이 확 달랐습니다. 하루 뷰는 장애 분석용, 7일 뷰는 패턴 확인용, 30일 뷰는 증설 판단용으로 쓰기 좋았습니다.

    그리고 의외로 유용했던 게 표(Table) 패널입니다. Top N VM 목록을 표로 뽑아두면, 그래프보다 바로 눈에 들어오는 경우가 많습니다. 특히 야간에 급한 상황에서는요.

    Proxmox API Grafana 기반 자원 사용량 시각화 결과 이미지

    Grafana에서 CPU, 메모리 추이를 시각화하고 VM별 Top N 표를 함께 보여주는 결과 예시 이미지 자리입니다. 모니터링 완성 상태를 전달하기 좋습니다.

    정리: 제가 다시 구성한다면 이렇게 하겠습니다

    지금 다시 처음부터 구성한다면, 저는 이렇게 갑니다.

    • 1단계: Proxmox API로 노드/VM 기본 지표만 수집
    • 2단계: Prometheus에 저장하고 Grafana에서 노드/VM 대시보드 분리
    • 3단계: 알림 추가
    • 4단계: 안전한 범위의 API 자동화 연결

    중요한 건 처음부터 모든 걸 다 하려 하지 않는 겁니다. 저도 처음엔 “이왕 하는 김에 완벽하게” 갔다가 시간이 꽤 들었어요. 그런데 운영은 결국 지속 가능해야 하더라고요. 작게 시작해서 점진적으로 확장하는 쪽이 훨씬 오래 갑니다.

    이번 글의 핵심을 짧게 정리하면 이렇습니다. Proxmox API Grafana 조합은 단순 시각화 도구가 아니라, 운영 판단 체계를 만드는 기반입니다. API 자동화는 반복 작업을 줄여주고, Grafana 연동은 문제를 더 빨리 보게 해줍니다. 둘이 합쳐질 때 가치가 커집니다.

    다음 글에서는 Proxmox 백업 작업과 알림 흐름을 더 세밀하게 묶는 방법, 그리고 장기 보존 지표를 기준으로 증설 시점을 판단하는 방법도 다뤄볼 예정입니다. 이전 글에서 홈랩 네트워크 분리와 스토리지 구성 이야기를 보셨다면, 이번 구성과 같이 연결해서 보시면 훨씬 이해가 잘 되실 겁니다.

    구성 요소, 장점, 주의사항, 자동화 확장 단계를 한 장으로 요약하는 인포그래픽 자리입니다. 글 마무리 직전에 넣으면 복습용으로 좋습니다.

    자주 묻는 질문

    Grafana가 Proxmox API를 직접 읽어야 하나요?

    반드시 그럴 필요는 없습니다. 제가 운영해보니 중간 수집 계층을 두는 편이 안정적이었습니다. API 응답을 바로 시각화하는 것보다 메트릭 구조를 정리한 뒤 보여주는 쪽이 관리가 쉽습니다.

    API 자동화는 어디까지 붙이는 게 좋을까요?

    처음에는 알림과 로그 수집 정도가 적당합니다. 운영 흐름이 충분히 검증된 뒤에 후속 작업 자동화를 넣는 게 안전합니다.

    Proxmox 모니터링에서 가장 먼저 볼 지표는 무엇인가요?

    노드 CPU, 메모리 사용률, 그리고 VM별 상위 사용량 목록부터 시작하시면 됩니다. 이 세 가지가 문제 파악 속도를 가장 많이 올려줍니다.

  • [k8s] OpenTelemetry K8s 모니터링, 비용 효율적인 구축 전략

    [k8s] OpenTelemetry K8s 모니터링, 비용 효율적인 구축 전략

    OpenTelemetry K8s 모니터링, 비용 효율적인 구축 전략

    안녕하세요, 13년차의 서버실 주인장입니다. 😎

    요즘 Kubernetes(쿠버네티스) 환경에서 애플리케이션을 운영하는 건 거의 기본이 되었죠. 근데 이 복잡한 환경을 제대로 모니터링하는 게 정말 쉽지 않더라고요. 특히 OpenTelemetry K8s 모니터링은 분산 시스템의 가시성(Observability)을 확보하는 데 필수적인데, 이걸 어떻게 구축해야 할지 막막한 분들이 많으실 거예요.

    비용 문제도 무시할 수 없죠. 상용 모니터링 솔루션은 비싸고, 직접 구축하려니 삽질이 이만저만이 아니거든요. 😅

    오늘은 제가 직접 Kubernetes 모니터링을 OpenTelemetry로 구축하면서 겪었던 삽질과, 어떻게 하면 비용 효율적인 구축 전략을 가져갈 수 있는지 제 경험을 바탕으로 이야기해보려 합니다. 초기엔 저도 뭐가 뭔지 헷갈렸는데, 결국 해내고 나니 뿌듯하더라고요. 함께 가시죠! 💪

    OpenTelemetry를 활용한 Kubernetes 모니터링 아키텍처는 위 그림처럼 구성할 수 있습니다. 데이터를 수집하고 백엔드로 보내는 과정이 깔끔하죠.

    개념 설명: OpenTelemetry, K8s 모니터링의 핵심

    자, 그럼 핵심 개념부터 간단히 짚고 넘어갈까요?

    • Observability(옵저버빌리티): 시스템 내부 상태를 외부에서 추론할 수 있는 능력입니다. 주로 Metrics(메트릭), Logs(로그), Traces(트레이스) 세 가지 기둥으로 구성되거든요. 이 세 가지를 제대로 봐야 시스템에서 무슨 일이 일어나는지 파악할 수 있죠.
    • OpenTelemetry(오픈텔레메트리): 이 옵저버빌리티 데이터를 수집하고, 처리하고, 내보내는 표준화된 프레임워크입니다. 벤더 종속성을 줄여주는 엄청난 장점이 있어요. 예전에는 각 모니터링 솔루션마다 에이전트를 다르게 심고 그랬었는데, OpenTelemetry 덕분에 한 번만 계측(Instrumentation)하면 다양한 백엔드로 데이터를 보낼 수 있게 된 거죠. 이게 진짜 편하더라고요!
    • Kubernetes 모니터링: K8s 클러스터 내의 Pod(파드), Node(노드), Deployment(디플로이먼트) 등의 상태와 성능을 지속적으로 관찰하는 활동입니다. CPU 사용량, 메모리, 네트워크 트래픽부터 애플리케이션 로그, 에러 트레이스까지 다 포함되거든요.
    • 비용 분석: 모니터링 솔루션은 데이터 수집량에 따라 비용이 천차만별입니다. 특히 클라우드 환경에서는 데이터 전송량, 저장량, 쿼리량 등에 따라 과금되기 때문에, 불필요한 데이터를 줄이고 효율적으로 관리하는 전략이 정말 중요하더라고요. 놓치면 배보다 배꼽이 더 커질 수 있거든요.

    실전 구현: OpenTelemetry Collector와 백엔드 구축

    이제 본격적으로 OpenTelemetry Collector를 K8s에 배포하고, 데이터를 수집하는 방법을 알아볼게요. 저는 비용 효율성을 위해 Prometheus(프로메테우스) + Grafana(그라파나) 조합으로 메트릭을, Loki(로키)로 로그를, Jaeger(예거)로 트레이스를 수집하는 방법을 선호합니다. 다 오픈소스라서 초기 비용 부담이 적거든요. 제 홈랩에서도 이 조합으로 잘 쓰고 있습니다. 👍

    먼저 OpenTelemetry Collector를 DaemonSet(데몬셋)으로 배포해서 각 노드에서 데이터를 수집하도록 설정합니다. 이게 가장 일반적이고 안정적인 방법이에요.

    # opentelemetry-collector-daemonset.yaml
    apiVersion: apps/v1
    kind: DaemonSet
    metadata:
      name: otel-collector
      namespace: monitoring
      labels:
        app: otel-collector
    spec:
      selector:
        matchLabels:
          app: otel-collector
      template:
        metadata:
          labels:
            app: otel-collector
        spec:
          serviceAccountName: otel-collector
          containers:
          - name: otel-collector
            image: otel/opentelemetry-collector:0.87.0 # 최신 안정 버전 확인 필요합니다. 공식 도커 허브를 참고하세요!
            command: ["--config=/conf/otel-collector-config.yaml"]
            volumeMounts:
            - name: otel-collector-config-vol
              mountPath: /conf
            - name: host-proc
              mountPath: /proc
              readOnly: true
            - name: host-sys
              mountPath: /sys
              readOnly: true
            securityContext:
              privileged: true # 노드 메트릭 수집을 위해 필요할 수 있습니다. 보안에 유의하세요.
          volumes:
          - name: otel-collector-config-vol
            configMap:
              name: otel-collector-config
          - name: host-proc
            hostPath:
              path: /proc
          - name: host-sys
            hostPath:
              path: /sys
    

    다음은 ConfigMap(컨피그맵)으로 OpenTelemetry Collector의 설정을 정의합니다. 여기서 중요한 건 어떤 데이터를 수집해서 어디로 보낼지 정의하는 부분이에요. Receivers, Processors, Exporters가 핵심이죠.

    # opentelemetry-collector-config.yaml
    apiVersion: v1
    kind: ConfigMap
    metadata:
      name: otel-collector-config
      namespace: monitoring
    data:
      otel-collector-config.yaml: |
        receivers:
          otlp:
            protocols:
              grpc:
              http:
          prometheus:
            config:
              scrape_configs:
                - job_name: 'kubernetes-nodes'
                  scrape_interval: 15s
                  kubernetes_sd_configs:
                    - role: node
                  relabel_configs:
                    - action: labelmap
                      regex: __meta_kubernetes_node_label_(.+)
                    - target_label: __address__
                      replacement: kubernetes.default.svc:443
                    - source_labels: [__meta_kubernetes_node_name]
                      regex: (.+)
                      target_label: __metrics_path__
                      replacement: /api/v1/nodes/${1}/proxy/metrics
                - job_name: 'kubernetes-pods'
                  kubernetes_sd_configs:
                    - role: pod
                  relabel_configs:
                    - source_labels: [__meta_kubernetes_pod_annotation_prometheus_io_scrape]
                      action: keep
                      regex: true
                    - source_labels: [__meta_kubernetes_pod_annotation_prometheus_io_path]
                      action: replace
                      target_label: __metrics_path__
                      regex: (.+)
                    - source_labels: [__address__, __meta_kubernetes_pod_annotation_prometheus_io_port]
                      action: replace
                      regex: ([^:]+)(?::\d+)?;(\d+)
                      target_label: __address__
                      replacement: $1:$2
                    - action: labelmap
                      regex: __meta_kubernetes_pod_label_(.+)
                    - source_labels: [__meta_kubernetes_namespace]
                      action: replace
                      target_label: kubernetes_namespace
                    - source_labels: [__meta_kubernetes_pod_name]
                      action: replace
                      target_label: kubernetes_pod_name
        
        processors:
          batch:
            send_batch_size: 1000
            timeout: 5s
          memory_limiter:
            limit_mib: 200
            spike_limit_mib: 50
          resourcedetection:
            detectors: [env, system, kubernetes]
            timeout: 2s
            kubernetes:
              pod_association:
                - from: cgroup
                - from: resource_attribute
                  key: k8s.pod.uid
          attributes:
            actions:
              - key: host.name
                action: delete
              - key: host.id
                action: delete
              - key: os.type
                action: delete
        
        exporters:
          prometheus:
            endpoint: "0.0.0.0:8889" # Prometheus가 이 엔드포인트를 스크래핑하여 메트릭 수집
          prometheusremotewrite:
            endpoint: "http://prometheus-server.monitoring.svc.cluster.local:9090/api/v1/write" # Prometheus Remote Write API
          otlp/logs:
            endpoint: "loki.monitoring.svc.cluster.local:3100" # Loki OTLP/HTTP Endpoint
            tls:
              insecure: true # 개발 환경에서만 사용하세요. 프로덕션에서는 TLS 구성이 필요합니다.
          otlp/traces:
            endpoint: "jaeger-collector.monitoring.svc.cluster.local:14250" # Jaeger gRPC Endpoint
            tls:
              insecure: true # 개발 환경에서만 사용하세요. 프로덕션에서는 TLS 구성이 필요합니다.
    
        service:
          pipelines:
            metrics:
              receivers: [otlp, prometheus]
              processors: [resourcedetection, attributes, batch, memory_limiter]
              exporters: [prometheus, prometheusremotewrite] # prometheus는 메트릭 노출, prometheusremotewrite는 원격 Prometheus로 전송
            logs:
              receivers: [otlp]
              processors: [resourcedetection, attributes, batch, memory_limiter]
              exporters: [otlp/logs]
            traces:
              receivers: [otlp]
              processors: [resourcedetection, attributes, batch, memory_limiter]
              exporters: [otlp/traces]
    

    여기서 exporters 부분을 보면 Prometheus, Loki, Jaeger로 데이터를 보내도록 설정한 걸 볼 수 있죠. 각 백엔드에 맞게 엔드포인트를 지정해주면 됩니다. 특히 processors 섹션에서 attributes를 사용해서 불필요한 메트릭 속성들을 제거하는 게 비용 효율적인 모니터링에 큰 도움이 되더라고요. 클라우드에서 데이터 전송량이나 저장량 줄이는 데 효과 만점입니다. 💡

    OpenTelemetry Collector와 모니터링 백엔드 상세 구성도

    OpenTelemetry Collector와 모니터링 백엔드 간의 상세 데이터 흐름 구성도입니다. 이 그림을 보면서 각 컴포넌트가 어떻게 연결되는지 쉽게 이해할 수 있을 거예요.

    주의사항/트러블슈팅: 삽질 피하기! ⚠️

    제가 이 부분에서 삽질을 좀 많이 했었습니다. 여러분은 이런 실수 안 하시길 바라면서 몇 가지 중요한 주의사항과 해결법을 공유해드릴게요. 멘토의 조언이라고 생각해주세요! 😉

    • ⚠️ 권한 문제: OpenTelemetry Collector가 노드 메트릭을 제대로 수집하려면 host-proc, host-sys 마운트와 privileged: true 설정이 필요할 수 있거든요. 보안상 민감한 부분이니 필요한 최소한의 권한만 부여하는 게 중요해요. 처음엔 권한 부족으로 메트릭이 안 들어와서 한참 헤맸습니다.
    • ⚠️ 설정 파일 오타: YAML 파일은 스페이스 하나에도 민감하죠. 특히 ConfigMap에 data 아래에 otel-collector-config.yaml: | 부분의 들여쓰기를 조심하세요. 오타 하나 때문에 Collector가 시작도 안 되는 경우가 허다하거든요. kubectl logs로 Collector Pod의 로그를 꼭 확인하세요.
    • ⚠️ 네트워크 문제: 백엔드(Prometheus, Loki, Jaeger)의 서비스 이름과 포트가 정확한지 확인해야 합니다. 특히 K8s 클러스터 내에서 service.namespace.svc.cluster.local 형태로 접근하는 게 일반적이에요. 방화벽이나 NetworkPolicy(네트워크 정책) 때문에 통신이 안 되는 경우도 많으니 kubectl exec로 Collector Pod에 들어가서 curl 등으로 연결 테스트를 해보는 게 좋습니다.
    • 💡 데이터 과부하: OpenTelemetry Collector의 memory_limiter와 batch 프로세서를 적절히 설정해서 Collector가 과도한 리소스를 사용하거나, 데이터 전송에 병목이 생기는 걸 방지해야 합니다. 저도 한 번 Collector가 메모리 폭주해서 노드가 비정상적으로 동작하는 바람에 새벽에 호출된 적이 있습니다… 😅

    검증/결과: 모니터링 대시보드 확인

    이제 모든 설정이 끝났으니, 제대로 동작하는지 확인해볼 시간입니다! 🎉 드디어 됐다! 하고 외칠 준비 되셨죠?

    1. 먼저 Grafana(그라파나)에 접속해서 Prometheus 데이터 소스를 추가하고, Kubernetes 노드/파드 메트릭 대시보드를 임포트해보세요. 저는 보통 Node Exporter Full이나 Kubernetes / Kubelet 대시보드를 사용합니다.
    2. 로그는 Loki에 쌓인 데이터를 Grafana의 Explore(탐색) 기능으로 확인하거나, Loki 전용 대시보드를 만들어 볼 수 있습니다. logcli 같은 도구로도 확인 가능하고요.
    3. 트레이스는 Jaeger UI에 접속해서 애플리케이션에서 보낸 트레이스가 잘 수집되는지 확인합니다. 서비스 이름과 오퍼레이션 이름으로 검색해보면 되겠죠.

    OpenTelemetry K8s 모니터링 Grafana 대시보드 예시

    OpenTelemetry로 수집한 Kubernetes 메트릭을 Grafana 대시보드에서 시각화한 모습입니다. 이렇게 한눈에 시스템 상태를 파악할 수 있으면 얼마나 든든한지 몰라요!

    마무리: 비용 효율과 미래를 위한 전략

    오늘은 OpenTelemetry K8s 모니터링을 비용 효율적으로 구축하는 전략에 대해 제 경험을 공유해드렸습니다.

    가장 중요한 포인트는 OpenTelemetry를 통해 특정 벤더에 종속되지 않고, 오픈소스 백엔드(Prometheus, Grafana, Loki, Jaeger)를 활용하여 초기 구축 비용을 최소화하는 것이었습니다. 이 조합은 특히 홈랩이나 소규모 프로젝트에서 빛을 발하더라고요.

    특히 OpenTelemetry Collector의 processors를 활용하여 불필요한 데이터를 필터링하고, 샘플링(Sampling) 전략을 적용하는 것이 클라우드 환경에서 비용 분석 및 절감에 큰 영향을 미친다는 점을 꼭 기억해주세요. 제가 이 부분에서 시행착오를 많이 겪었거든요. 데이터 양을 줄이는 게 진짜 중요합니다!

    Kubernetes 모니터링은 한 번 구축했다고 끝이 아닙니다. 지속적으로 데이터를 분석하고, 대시보드를 개선하며, 새로운 요구사항에 맞춰 시스템을 확장해나가야 하거든요. OpenTelemetry는 앞으로도 옵저버빌리티 분야에서 핵심적인 역할을 할 것이 분명합니다. 여러분의 환경에 맞춰 최적의 비용 효율적인 구축 전략을 찾아보시길 바랍니다. 다음 기회에 심화 내용을 다뤄볼게요! 😊

    OpenTelemetry를 활용한 비용 효율적인 Kubernetes 모니터링 이점

    OpenTelemetry를 통한 모니터링 구축은 단순히 기술적인 선택을 넘어, 장기적인 관점에서 비용 효율성과 유연성을 확보하는 전략적인 결정이 될 수 있습니다.

  • [k8s] 쿠버네티스 모니터링: Prometheus & Grafana 구축 및 대시보드 활용 가이드

    [k8s] 쿠버네티스 모니터링: Prometheus & Grafana 구축 및 대시보드 활용 가이드

    🚀 쿠버네티스 모니터링, 왜 중요할까요?

    안녕하세요, 13년차의 서버실 주인장입니다. 오늘은 쿠버네티스 모니터링의 핵심이라고 할 수 있는 Prometheus(프로메테우스)와 Grafana(그라파나) 구축 경험을 공유해볼까 합니다. 쿠버네티스 환경을 운영하다 보면 ‘도대체 내 파드는 잘 돌고 있나?’, ‘CPU 사용량이 왜 이렇게 높지?’, ‘메모리 누수가 생긴 건 아닐까?’ 같은 고민을 하게 되죠.

    저도 처음 쿠버네티스를 도입했을 때, 여러 파드들이 여기저기서 돌아다니는데 이걸 어떻게 한눈에 볼 수 있을까 막막했어요. 로그를 일일이 뒤져보는 것도 한계가 있고요. 그때 제 눈을 번쩍 뜨이게 한 것이 바로 Prometheus와 Grafana 조합이었습니다. 이 두 가지 도구 덕분에 제 홈랩의 쿠버네티스 클러스터는 24시간 감시 체제를 갖추게 되었고, 문제가 생기면 빠르게 파악하고 조치할 수 있게 됐죠. 마치 제 서버실에 똑똑한 비서 한 명을 들인 기분이랄까요?

    이번 글에서는 이 강력한 모니터링 스택을 어떻게 구축하고, 어떤 대시보드를 활용하면 좋을지 제 경험을 녹여서 자세히 알려드리겠습니다. 삽질했던 부분들도 솔직하게 공유할 테니, 여러분은 저처럼 헤매지 않으시길 바랍니다! 자, 그럼 시작해볼까요?

    쿠버네티스 환경에서 Prometheus와 Grafana를 이용한 모니터링 시스템의 전체 아키텍처 다이어그램입니다.

    💡 Prometheus와 Grafana, 핵심 개념 파헤치기

    자, 이제 본론으로 들어가서 쿠버네티스 모니터링의 양대 산맥인 Prometheus(프로메테우스)와 Grafana(그라파나)에 대해 좀 더 깊이 있게 알아볼까요? 처음엔 이름도 어렵고, 뭐가 뭔지 헷갈렸는데, 사실 원리만 이해하면 생각보다 간단하더라고요.

    Prometheus (프로메테우스): 지표 수집의 달인

    Prometheus는 오픈 소스 모니터링 시스템으로, 시계열 데이터베이스(Time-series Database, TSDB)를 기반으로 합니다. 쉽게 말해, 시간의 흐름에 따라 변화하는 다양한 지표(Metrics)들을 수집하고 저장하는 데 특화된 도구거든요. 기존의 많은 모니터링 시스템이 에이전트가 데이터를 서버로 밀어 넣는 Push 방식이었다면, Prometheus는 대상으로부터 데이터를 Pull(가져오는) 방식을 사용합니다. 이 방식은 서비스 디스커버리(Service Discovery)와 결합될 때 쿠버네티스 같은 동적인 환경에서 정말 큰 시너지를 내거든요.

    • Metrics (메트릭, 지표 데이터): CPU 사용량, 메모리 사용량, 네트워크 트래픽 등 서버나 애플리케이션의 상태를 나타내는 수치 데이터입니다.
    • Exporters (익스포터): Prometheus가 지표를 가져올 수 있도록 데이터를 노출하는 작은 에이전트예요. 예를 들어, 서버의 OS 지표를 수집하는 Node Exporter나 쿠버네티스 노드/파드의 지표를 수집하는 cAdvisor 같은 것들이죠.
    • Service Discovery (서비스 디스커버리): 쿠버네티스 환경에서는 파드(Pod)가 수시로 생성되고 사라집니다. Prometheus는 이런 변화를 감지해서 자동으로 새로운 모니터링 대상을 찾아냅니다. 정말 편리하더라고요.

    Grafana (그라파나): 시각화의 마법사

    Prometheus가 지표를 열심히 수집하고 저장해놨다면, Grafana는 그 데이터를 멋진 그래프와 대시보드로 시각화해주는 도구입니다. 복잡한 숫자들을 한눈에 알아보기 쉽게 보여주니까, 이상 징후를 빠르게 파악하고 문제 해결에 집중할 수 있게 도와주죠. 처음에는 Grafana UI가 좀 어려웠는데, 몇 번 써보니 이거 진짜 물건이더라고요! 다양한 데이터 소스(Prometheus 외에도 많은 DB를 지원합니다)를 연결해서 대시보드를 만들 수 있고, 커스텀도 자유롭습니다.

    🛠️ 실전! Helm으로 Prometheus & Grafana 배포하기

    이제 이론은 충분히 봤으니, 실제로 쿠버네티스 클러스터에 Prometheus와 Grafana를 배포해보겠습니다. 저는 Helm(헬름)을 이용하는 것을 선호하는데, 복잡한 쿠버네티스 리소스들을 한 번에 쉽게 배포하고 관리할 수 있거든요. 마치 패키지 매니저처럼요!

    사전 준비물

    1. 동작하는 쿠버네티스 클러스터 (저는 홈랩에서 Kubeadm으로 구성한 클러스터를 사용했습니다.)
    2. Helm v3 이상 설치
    3. (선택 사항) PersistentVolume(영구 볼륨)을 위한 StorageClass(스토리지 클래스) 설정 (데이터 유실 방지를 위해 권장합니다)

    Step 1: Helm Repository 추가

    Prometheus와 Grafana를 포함하는 <code>kube-prometheus-stack은 Helm 차트로 제공됩니다. 먼저 Helm 레포지토리를 추가해주세요.

    helm repo add prometheus-community https://prometheus-community.github.io/helm-charts
    helm repo update

    Step 2: Prometheus 스택 배포

    이제 kube-prometheus-stack을 배포할 차례입니다. 이 차트 안에는 Prometheus, Grafana, Alertmanager(알림 관리자), Kube-State-Metrics(쿠버네티스 상태 지표 수집기), Node Exporter(노드 지표 수집기) 등 쿠버네티스 모니터링에 필요한 모든 것이 한 번에 들어있어서 정말 편합니다. 저는 보통 monitoring 네임스페이스에 배포합니다.

    ⚠️ 중요: 프로덕션 환경에서는 values.yaml 파일을 통해 스토리지 클래스, 리소스 제한, 서비스 타입 등을 반드시 커스터마이징해야 합니다. 저는 홈랩이라 기본 설정으로 진행했지만, 여러분은 꼭 신경 써주세요!

    # values.yaml 파일 예시 (간단하게 스토리지 클래스만 지정)
    # my-prometheus-values.yaml
    
    prometheus:
      prometheusSpec:
        storageSpec:
          volumeClaimTemplate:
            spec:
              storageClassName: my-storage-class # 본인의 StorageClass 이름으로 변경
              resources:
                requests:
                  storage: 10Gi
    
    grafana:
      persistence:
        enabled: true
        storageClassName: my-storage-class # 본인의 StorageClass 이름으로 변경
        size: 5Gi
    

    이제 위 values.yaml 파일을 적용하여 배포합니다.

    helm install prometheus prometheus-community/kube-prometheus-stack \
      --namespace monitoring --create-namespace \
      -f my-prometheus-values.yaml # 커스터마이징한 values.yaml 파일 적용

    배포가 완료되면 kubectl get pods -n monitoring 명령어로 파드들이 잘 떠 있는지 확인해보세요. 모든 파드가 Running 상태라면 성공입니다! 🎉

    Step 3: Grafana 접속 및 초기 설정

    Grafana는 기본적으로 ClusterIP 타입의 서비스로 배포됩니다. 외부에서 접속하려면 Ingress(인그레스, 외부 트래픽 진입점)를 설정하거나, 간단하게 포트 포워딩(Port-forwarding)을 이용할 수 있어요. 저는 테스트를 위해 포트 포워딩을 자주 사용합니다.

    kubectl port-forward svc/prometheus-grafana 3000:80 -n monitoring

    이제 웹 브라우저에서 http://localhost:3000으로 접속해보세요. 초기 로그인 정보는 다음과 같습니다.

    • User (사용자): admin
    • Password (비밀번호): prom-operator (또는 kubectl get secret prometheus-grafana -n monitoring -o jsonpath='{.data.admin-password}' | base64 --decode 명령어로 확인)

    로그인 후에는 비밀번호 변경을 요청할 겁니다. 안전하게 변경해주세요!

    Grafana에서 Prometheus 데이터 소스를 추가하는 설정 화면입니다.

    📊 나만의 쿠버네티스 대시보드 만들기 & 활용하기

    Grafana에 접속했다면 이제 Prometheus 데이터를 시각화할 차례예요. kube-prometheus-stack 덕분에 Prometheus 데이터 소스는 이미 설정되어 있을 겁니다. 혹시 없다면, Configuration > Data Sources에서 Prometheus를 추가하고 URL을 http://prometheus-kube-prometheus-prometheus.monitoring.svc.cluster.local:9090 (네임스페이스와 서비스 이름에 따라 다를 수 있음)으로 설정하면 됩니다.

    기본 대시보드 활용하기

    kube-prometheus-stack은 기본적으로 여러 유용한 대시보드들을 Grafana에 자동으로 임포트해줍니다. 왼쪽 메뉴에서 Dashboards > Manage로 이동해보세요. 아마 Kubernetes / Compute Resources, Node Exporter Full 같은 대시보드들을 볼 수 있을 겁니다. 저도 처음엔 이 대시보드들만으로도 충분히 모니터링이 가능해서 정말 편하더라고요.

    Grafana Labs 공유 대시보드 임포트하기

    만약 더 다양한 대시보드를 원한다면, Grafana Labs 웹사이트(https://grafana.com/grafana/dashboards/)에서 다른 사람들이 공유한 대시보드를 임포트할 수 있습니다. 예를 들어, Node Exporter Full 대시보드(ID: 1860)나 Kubernetes Cluster Overview(ID: 12150) 같은 것들이 인기가 많죠.

    1. Grafana 좌측 메뉴에서 + > Import를 클릭합니다.
    2. Import via grafana.com dashboard 칸에 대시보드 ID (예: 1860)를 입력하고 Load를 클릭합니다.
    3. 대시보드 이름, 폴더를 설정하고, Prometheus 데이터 소스를 선택한 후 Import를 클릭합니다.

    짜잔! 멋진 대시보드가 눈앞에 펼쳐질 겁니다. 🤩

    나만의 대시보드 커스터마이징

    기존 대시보드를 활용하는 것도 좋지만, 특정 애플리케이션이나 서비스에 특화된 대시보드 구축은 필수입니다. 저는 주로 복제(Duplicate) 기능을 이용해서 기존 대시보드를 복사한 다음, 필요한 패널(Panel)을 추가하거나 수정하는 방식으로 커스터마이징합니다. PromQL(프로메테우스 쿼리 언어)을 조금만 익히면 원하는 지표를 자유자재로 뽑아낼 수 있거든요.

    Prometheus와 Grafana를 통해 구현된 쿠버네티스 클러스터 모니터링 대시보드 예시입니다.

    ⚠️ 삽질 대잔치! 트러블슈팅 경험담

    인프라 엔지니어의 삶은 삽질의 연속이죠. 저도 Prometheus & Grafana 구축 과정에서 몇 번의 삽질을 경험했어요. 여러분은 이런 문제들을 미리 알고 피하시길 바랍니다.

    1. PersistentVolumeClaim (PVC) Pending 문제

    증상: Prometheus나 Grafana 파드가 Pending 상태에서 벗어나지 못하고, PVC가 Pending으로 남아있을 때입니다.

    원인: 대부분 StorageClass가 없거나, 잘못 지정되었을 때 발생합니다. Prometheus는 데이터를 저장하기 위해 영구 스토리지를 써야 하는데, 이를 위한 StorageClass가 없으면 볼륨을 프로비저닝할 수 없거든요.

    해결: 클러스터에 NFS CSI Driver나 Longhorn 같은 동적 프로비저너를 설치하고, 해당 StorageClass를 values.yaml에 올바르게 지정해주세요. 저는 처음에 이 부분을 놓쳐서 한참 헤맸습니다. 🤦‍♂️

    2. 리소스 부족으로 인한 OOMKilled

    증상: Prometheus 파드가 자꾸 재시작되면서 OOMKilled(Out Of Memory Killed) 오류가 발생합니다.

    원인: Prometheus는 수집하는 지표의 양이 많아질수록 메모리 사용량이 늘어나요. 기본 설정된 리소스 제한(Resource Limits)이 클러스터 규모에 비해 너무 낮을 때 발생하는 거죠.

    해결: values.yaml에서 Prometheus 파드의 resources.requests와 resources.limits를 적절히 늘려주세요. 특히 memory 부분을 여유 있게 설정하는 게 중요합니다. 너무 많이 늘리면 다른 파드에 영향을 줄 수 있으니, 모니터링하면서 점진적으로 조정하는 것을 추천합니다.

    3. Prometheus가 타겟을 찾지 못하는 문제

    증상: Grafana 대시보드에서 데이터가 보이지 않거나, Prometheus UI의 Targets 페이지에서 특정 파드가 DOWN 상태로 표시될 때입니다.

    원인: Prometheus의 서비스 디스커버리 설정이 잘못되었거나, 파드에 올바른 레이블(Label)이 지정되지 않았을 때, 혹은 네트워크 정책(Network Policy) 등으로 인해 Prometheus가 파드의 익스포터에 접근하지 못할 때 발생합니다.

    해결:

    • 해당 파드에 Prometheus가 찾을 수 있는 annotations나 labels가 잘 붙어있는지 확인합니다. (예: prometheus.io/scrape: "true")
    • ServiceMonitor 또는 PodMonitor 리소스가 올바르게 정의되어 있는지 확인합니다.
    • 네트워크 정책이 Prometheus 파드에서 대상 파드로의 트래픽을 허용하는지 검토합니다.

    제가 직접 커스텀 애플리케이션을 모니터링할 때 이 문제로 고생 좀 했어요. 애플리케이션 파드에 어노테이션을 빼먹어서 그랬더라고요. ㅎㅎ

    ✅ 구축 결과 확인 및 다음 단계 제안

    이제 여러분의 쿠버네티스 클러스터는 Prometheus와 Grafana라는 강력한 모니터링 시스템을 갖추게 되었습니다. Grafana 대시보드를 통해 노드의 CPU/메모리 사용량, 파드의 상태, 네트워크 트래픽 등 다양한 지표들을 한눈에 볼 수 있을 겁니다. 문제가 발생하면 즉시 알 수 있고, 미리 예방할 수도 있게 되는 거죠. 정말 뿌듯하지 않나요? 🎉

    저도 처음 이 대시보드를 보면서 ‘드디어 됐다!’ 싶었던 기억이 생생하네요. 덕분에 제 홈랩 클러스터가 훨씬 더 안정적으로 운영되고 있습니다.

    다음 단계로 나아가기

    여기서 멈추지 마세요! 쿠버네티스 모니터링은 계속 발전해야 합니다. 몇 가지 다음 단계를 제안해봅니다.

    • Alertmanager(알림 관리자) 설정: Prometheus가 수집한 지표를 기반으로 알림(Alert)을 생성하고, 이를 Slack, 이메일, PagerDuty 등으로 전송하도록 설정해보세요. 저는 슬랙으로 알림을 받는데, 긴급 상황 발생 시 정말 유용합니다.
    • Custom Exporter 개발: 여러분의 특정 애플리케이션에서만 나오는 커스텀 지표를 수집하고 싶다면, 직접 익스포터를 개발해보는 것도 좋은 경험입니다. Python이나 Go 언어로 쉽게 만들 수 있어요.
    • 장기 지표 저장 (Long-term Storage): Prometheus는 기본적으로 로컬 스토리지를 써요. 장기간 지표를 보관하고 싶다면 Thanos(타노스)나 Cortex(코텍스) 같은 솔루션을 연동하여 스케일 아웃 및 장기 보관 기능을 추가할 수 있습니다.

    Prometheus 및 Grafana 기반 쿠버네티스 모니터링 시스템의 주요 이점과 활용 방안을 요약한 인포그래픽입니다.

    맺음말: 13년차 엔지니어의 조언

    쿠버네티스 모니터링은 클러스터 운영의 핵심이자, 인프라 엔지니어의 역량을 보여주는 중요한 부분입니다. 처음에는 어렵게 느껴질 수 있지만, 이렇게 직접 구축하고 활용해보면서 얻는 경험은 그 어떤 이론보다 값지다고 생각합니다. 저도 13년차 엔지니어이지만, 여전히 새로운 기술을 배우고 직접 손으로 만져보면서 배우는 것이 가장 즐겁고 효과적하더라고요.

    오늘 제가 공유한 내용이 여러분의 쿠버네티스 여정에 작은 도움이 되었기를 바랍니다. 혹시 진행 중에 궁금한 점이나 막히는 부분이 있다면 언제든지 댓글로 남겨주세요. 제가 아는 선에서 최대한 도와드리겠습니다. 다음에는 Alertmanager 설정이나 Custom Exporter 개발 경험에 대해서도 다뤄볼 예정이니 기대해주세요!

    다음 글에서 또 만나요! ✋