13년차의 서버실

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

[카테고리:] k8s

  • [인프라] Knative 성능 벤치마크, 실제 트래픽 증가에 따른 서빙 체크 포인트

    [인프라] Knative 성능 벤치마크, 실제 트래픽 증가에 따른 서빙 체크 포인트

    [인프라] Knative 성능 벤치마크, 실제 트래픽 증가에 따른 서빙 체크 포인트

    Knative 성능 벤치마크를 직접 해보려는 분들은 대개 비슷한 고민을 하더라고요. 평소엔 조용한 서비스인데, 특정 시간에 요청이 몰리면 Knative Serving이 어디까지 버텨주는지, 그리고 서버리스(Serverless)의 자동 확장이 정말 실전에 맞게 움직이는지 확인하고 싶은 거죠. 저도 홈랩에서 처음 테스트했을 때는 “오토스케일링이 알아서 되겠지” 하고 가볍게 봤다가, 콜드 스타트와 동시성 때문에 삽질 좀 했습니다 ㅎㅎ

    특히 운영 입장에서 중요한 건 숫자 하나가 아니라 트래픽 증가 구간에서 어떤 컴포넌트가 먼저 흔들리는지를 아는 겁니다. CPU가 먼저 차는지, Activator가 병목이 되는지, Ingress 레이어에서 지연이 생기는지 봐야 하거든요. 이번 글에서는 제가 실제로 자주 쓰는 방식대로, 과장된 수치 없이 Knative 성능 벤치마크를 어떻게 설계하고 해석하면 되는지 정리해보겠습니다.

    Knative 성능 벤치마크를 위한 Knative Serving 아키텍처와 트래픽 흐름 다이어그램

    Knative Serving의 요청 흐름과 오토스케일링 관련 컴포넌트를 한눈에 보는 구성도입니다.

    1. 왜 Knative Serving 성능 테스트가 까다로운가

    쉽게 말해 Knative는 단순한 Deployment 하나를 때리는 구조가 아닙니다. 요청은 보통 Route, Revision, Queue-Proxy, 그리고 상황에 따라 Activator를 거치게 됩니다. 그래서 같은 애플리케이션 코드를 올려도 일반 Kubernetes Deployment와 응답 패턴이 꽤 다르게 나옵니다.

    • Scale to Zero: 유휴 상태에선 파드를 0으로 줄였다가 다시 띄웁니다.
    • Concurrency 기반 확장: CPU만 보는 게 아니라 요청 동시성도 핵심 기준입니다.
    • Revision 단위 배포: 새 설정이 들어가면 새 리비전이 생기므로 비교 테스트가 편합니다.
    • 네트워크 경로 증가: 인그레스와 프록시 홉이 늘어나면 지연 해석이 달라집니다.

    여기서 중요한 포인트! Knative 성능 벤치마크는 “최대 RPS가 얼마냐”만 보는 테스트가 아닙니다. 트래픽이 늘어날 때 응답 시간이 어떻게 변하는지, 그리고 자동 확장이 몇 초 안에 따라붙는지를 함께 봐야 의미가 있습니다.

    2. 벤치마크 전에 잡아야 할 기준

    제가 직접 해보니, 테스트 전에 기준을 안 잡으면 결과가 거의 쓸모가 없더라고요. 처음엔 저도 그냥 부하 도구부터 돌렸었는데, 나중에 보니까 어떤 값이 애플리케이션 때문인지, 어떤 값이 플랫폼 때문인지 분리가 안 되더라고요.

    2-1. 최소한 이 네 가지는 고정하세요

    1. 애플리케이션 응답 형태: CPU 바운드인지, I/O 바운드인지 구분합니다.
    2. 동시성 목표: containerConcurrency를 명시할지 결정합니다.
    3. 오토스케일 기준: target concurrency, min/max scale 범위를 정합니다.
    4. 측정 구간: 콜드 스타트 포함 여부와 워밍 상태를 분리합니다.

    실무에서는 보통 두 번 봅니다. 한 번은 콜드 스타트 포함 시나리오, 한 번은 이미 파드가 떠 있는 상태죠. 이 둘을 섞으면 해석이 틀어집니다.

    2-2. 어떤 지표를 보면 되나

    지표 왜 중요한가 해석 팁
    RPS/Throughput 전체 처리량 확인 상승하다가 평평해지면 병목 가능성이 큽니다.
    P95, P99 Latency 꼬리 지연 확인 평균보다 훨씬 중요할 때가 많습니다.
    Pod Count 확장 반응 확인 요청 증가와 함께 자연스럽게 늘어나는지 봅니다.
    Error Rate 품질 저하 감지 5xx가 생기면 네트워크/백엔드 구간을 같이 확인합니다.

    3. 실전용 테스트 환경 구성

    이 글에서는 가장 단순한 HTTP echo 계열 서비스 대신, 약간의 대기 시간을 줄 수 있는 애플리케이션을 두고 확인하는 방식을 권장합니다. 이유는 간단합니다. 너무 가벼운 앱은 네트워크 오버헤드만 보이고, 너무 무거운 앱은 앱 병목만 보여서 Knative 특성이 잘 안 드러나거든요.

    아래 예시는 Knative Service 리소스입니다. 실제 테스트에선 여러분이 보유한 검증된 컨테이너 이미지를 넣으시면 됩니다.

    apiVersion: serving.knative.dev/v1
    kind: Service
    metadata:
      name: benchmark-app
    spec:
      template:
        metadata:
          annotations:
            autoscaling.knative.dev/min-scale: "0"
            autoscaling.knative.dev/max-scale: "10"
            autoscaling.knative.dev/target: "10"
        spec:
          containerConcurrency: 10
          containers:
            - image: gcr.io/knative-samples/helloworld-go:latest
              ports:
                - containerPort: 8080
              env:
                - name: TARGET
                  value: "knative-benchmark"

    배포는 일반적인 kubectl 흐름으로 진행하면 됩니다.

    kubectl apply -f knative-service.yaml
    kubectl get ksvc benchmark-app
    kubectl get revision
    kubectl get pods -w

    테스트 전에는 라우트 URL을 먼저 확인해 두세요.

    kubectl get ksvc benchmark-app -o jsonpath='{.status.url}'
    Knative 성능 벤치마크 설정에서 오토스케일링 파라미터를 설명하는 구성 이미지

    서비스 정의에서 동시성, 최소/최대 스케일, 타깃 값을 어떻게 잡는지 보여주는 이미지입니다.

    4. 트래픽 증가 시나리오를 이렇게 나누면 해석이 쉬워집니다

    제가 실제로 써보니까 한 번에 큰 부하를 주는 것보다, 단계형(step load)으로 올리는 편이 훨씬 유용했습니다. 트래픽 증가 구간에서 어느 시점부터 지연이 튀는지 보여주기 좋거든요.

    1. 기본 응답 확인: 단일 요청으로 정상 동작과 헤더를 확인합니다.
    2. 저부하 구간: 낮은 동시성으로 워밍 상태 지연을 봅니다.
    3. 중간 부하 구간: 오토스케일이 개입하기 시작하는지 봅니다.
    4. 고부하 구간: P95/P99 지연과 에러율 변화를 봅니다.
    5. 유휴 복귀: 다시 요청을 끊고 scale to zero 동작을 확인합니다.

    간단한 부하 테스트는 hey 같은 도구로도 충분합니다. 특별히 복잡한 시나리오가 아니라면 시작은 이걸로 해보세요.

    URL=$(kubectl get ksvc benchmark-app -o jsonpath='{.status.url}')
    hey -z 30s -c 10 "$URL"
    hey -z 30s -c 30 "$URL"
    hey -z 30s -c 50 "$URL"

    좀 더 긴 시나리오를 만들고 싶다면 k6 같은 도구를 쓰는 것도 좋습니다. 아래는 단계적으로 가상 사용자 수를 올리는 예시입니다.

    import http from 'k6/http';
    import { sleep } from 'k6';
    
    export const options = {
      stages: [
        { duration: '30s', target: 5 },
        { duration: '30s', target: 20 },
        { duration: '30s', target: 50 },
        { duration: '30s', target: 0 }
      ]
    };
    
    export default function () {
      http.get(__ENV.TARGET_URL);
      sleep(1);
    }
    k6 run -e TARGET_URL="$URL" load-test.js

    여기서 핵심은 숫자를 크게 만드는 게 아닙니다. 같은 서비스 정의로 트래픽 증가 패턴을 반복 가능하게 재현하는 게 훨씬 더 중요합니다.

    5. ⚠️ 제가 자주 겪었던 문제와 해결 방법

    이 부분이 사실 제일 중요합니다. 테스트는 돌렸는데 결과가 이상하게 튀는 경우가 많거든요. 저도 처음엔 앱 코드 문제인 줄 알았는데, 실제로는 Knative 레이어나 클러스터 리소스 설정이 원인이었던 적이 꽤 있었습니다.

    5-1. 콜드 스타트와 워밍 테스트를 섞어버린 경우

    가장 흔한 실수입니다. 첫 요청 지연이 큰데 그걸 전체 성능 저하로 오해하는 거죠. 해결은 단순합니다.

    • 콜드 스타트 측정은 유휴 상태 이후 첫 요청만 따로 봅니다.
    • 워밍 성능은 미리 몇 번 호출한 뒤 별도 구간에서 측정합니다.
    • Knative 성능 벤치마크 결과표도 두 항목으로 나누는 편이 좋습니다.

    5-2. containerConcurrency를 기본값에만 맡긴 경우

    애플리케이션이 요청당 메모리를 많이 쓰거나, 반대로 가벼운 API인데 너무 보수적으로 잡혀 있으면 확장 패턴이 왜곡됩니다. 특히 Queue-Proxy를 거치는 구조에서는 동시성 설정이 생각보다 체감에 크게 들어옵니다.

    5-3. 클러스터 노드 자원이 먼저 부족한 경우

    이건 홈랩에서 진짜 자주 나옵니다. Knative가 못 버틴 게 아니라, 노드가 새 파드를 올릴 여유가 없는 겁니다. CPU 요청량(requests)과 제한(limits), 이미지 풀링 시간, 스토리지 성능을 같이 봐야 합니다.

    5-4. Ingress 레이어의 영향

    Ingress 설정에 따라 지연 차이가 보일 수 있습니다. 그래서 가능하면 애플리케이션 로그만 보지 말고, 인그레스 컨트롤러와 Knative 관련 컨트롤 플레인 상태도 같이 체크하세요.

    kubectl get pods -A
    kubectl top pods -A
    kubectl describe ksvc benchmark-app
    kubectl logs -l serving.knative.dev/service=benchmark-app --all-containers=true
    Knative 성능 벤치마크 결과에서 파드 수 증가와 지연 시간 변화를 보는 대시보드 이미지

    트래픽 상승에 따라 파드 수와 지연 시간이 어떻게 변하는지 같이 보는 대시보드 예시입니다.

    6. 결과는 어떻게 읽어야 하나

    벤치마크 결과를 볼 때 제가 제일 먼저 보는 건 평균이 아니라 P95/P99 Latency입니다. 평균은 멀쩡한데 꼬리 지연만 확 튀는 경우가 꽤 많거든요. 사용자는 그 느린 요청을 체감합니다.

    보통 해석은 이렇게 가져가면 됩니다.

    관찰 현상 의심 지점 다음 액션
    RPS는 유지되는데 P95만 상승 오토스케일 반응 지연 또는 큐잉 증가 target concurrency와 min scale 검토
    고부하에서 5xx 발생 앱 리소스 부족, 인그레스, 백엔드 의존성 애플리케이션 로그와 노드 상태 확인
    첫 요청만 매우 느림 콜드 스타트 scale to zero 정책과 워밍 전략 분리 검토
    파드 수가 기대보다 안 늘어남 오토스케일 설정 또는 클러스터 자원 한계 autoscaler 설정과 스케줄링 상태 확인

    제가 직접 해보니 좋은 결과란 “숫자가 무조건 높은 상태”가 아니라, 트래픽 증가에 따라 파드 수와 지연이 예측 가능하게 움직이는 상태더라고요. 운영은 재현성과 설명 가능성이 정말 중요하거든요.

    7. 검증 체크리스트와 운영 관점 팁

    실전 반영 전에 아래 체크리스트를 한 번 돌려보시면 좋습니다. 여기서 중요한 포인트! Knative 성능 벤치마크는 한 번 하고 끝내는 문서가 아니라, 리비전이 바뀔 때마다 비교 기준으로 남겨야 합니다.

    • ✅ 동일한 이미지와 동일한 요청 패턴으로 반복 테스트했는가
    • ✅ 콜드 스타트와 워밍 상태를 분리했는가
    • ✅ P95/P99, 에러율, 파드 수를 함께 기록했는가
    • ✅ 노드 자원 부족과 애플리케이션 병목을 구분했는가
    • ✅ Revision 단위로 결과를 보관했는가

    추가로, 이전 글에서 다뤘던 Kubernetes 리소스 요청량 설계와 함께 보시면 훨씬 이해가 빠릅니다. 다음 글에서는 Knative Serving에서 min scale과 scale to zero를 운영 비용 관점에서 어떻게 조정하는지 이어서 다뤄볼 예정입니다.

    8. 자주 묻는 질문

    Q1. 부하 도구는 무엇을 써야 하나요?

    가볍게 시작할 땐 hey면 충분합니다. 요청 패턴을 더 세밀하게 만들고 싶으면 k6가 편하더라고요.

    Q2. Scale to Zero는 벤치마크에서 꺼야 하나요?

    목적에 따라 다릅니다. 운영 현실을 보고 싶다면 켠 상태도 꼭 측정해야 합니다. 다만 워밍 성능과 섞지는 마세요.

    Q3. 수치가 환경마다 너무 다르게 나오는데 정상인가요?

    네, 정상입니다. 클러스터 크기, 네트워크, 인그레스 종류, 이미지 크기, 앱 특성이 모두 영향을 줍니다. 그래서 절대값보다 비교 기준이 중요합니다.

    Knative 성능 벤치마크 결과 해석 체크리스트와 비교 요약 인포그래픽

    콜드 스타트, 워밍 성능, 파드 확장, 지연 구간을 한 번에 정리한 요약 인포그래픽입니다.

    9. 마무리

    이번 글에서는 실전 기준으로 Knative 성능 벤치마크를 어떻게 설계하고, 트래픽 증가 상황에서 무엇을 봐야 하는지 정리해봤습니다. 처음엔 저도 “오토스케일이 되니까 그냥 잘 되겠지” 싶었는데, 실제로 써보니까 동시성 설정, 콜드 스타트 분리, 인그레스 영향, 클러스터 자원 상태를 같이 봐야 결과가 말이 되더라고요.

    결국 중요한 건 화려한 숫자보다 반복 가능한 테스트 절차입니다. 여러분 환경에서도 먼저 작은 단계형 테스트부터 시작해 보세요. 드디어 됐다! 싶은 순간이 오면, 그다음엔 리비전 비교와 비용 최적화까지 연결하시면 됩니다. 운영 관점에서 보면 이 흐름이 제일 오래 갑니다. 혹시 비슷한 삽질 하신 적 있으신가요? 그런 경험이 오히려 제일 좋은 기준이 되더라고요.

  • [k8s] ArgoCD 도입 실패 사례 분석: GitOps 전환 시 흔한 실수와 방지 전략

    [k8s] ArgoCD 도입 실패 사례 분석: GitOps 전환 시 흔한 실수와 방지 전략

    [DevOps] ArgoCD 도입 실패 사례 분석과 GitOps 실수 방지

    ArgoCD 도입 실패 이야기는 생각보다 흔합니다. 저도 처음엔 GitOps(깃옵스, Git을 단일 진실 공급원으로 삼는 운영 방식)만 붙이면 배포가 깔끔해질 줄 알았거든요. 그런데 실제로 해보니, ArgoCD(아르고CD, Kubernetes 선언형 배포 도구)를 넣는 순간 오히려 배포가 더 복잡해지는 팀도 많았습니다. 특히 CI/CD 전환 사례를 보면, 기술 문제가 아니라 역할 분리, 저장소 구조, 승인 흐름 같은 운영 설계에서 먼저 무너지는 경우가 많더라고요. 이번 글은 제가 현업과 홈랩에서 반복해서 본 ArgoCD 도입 실패 패턴을 중심으로, 왜 그런 일이 생기는지와 어떻게 피해야 하는지를 정리해보겠습니다.

    혹시 이런 경험 있으신가요? 배포 자동화는 넣었는데 누가 어떤 값을 바꿨는지 더 헷갈리고, 장애가 나면 Git이 문제인지 클러스터가 문제인지부터 추적하게 되는 상황 말입니다. 여기서 중요한 포인트는, ArgoCD 자체가 문제라기보다 GitOps 실수가 누적되면서 운영 복잡도가 폭발한다는 점입니다.

    ArgoCD 도입 실패와 GitOps 전환 흐름을 설명하는 아키텍처 이미지

    Git 저장소, CI 파이프라인, ArgoCD, Kubernetes 클러스터 사이의 흐름과 실패 포인트를 한눈에 보여주는 개요 이미지입니다.

    1. 왜 ArgoCD 도입 실패가 반복될까요?

    쉽게 말해 ArgoCD는 배포 버튼을 없애는 도구가 아니라, 변경 관리 방식 자체를 바꾸는 도구입니다. 그래서 예전 CI/CD에서는 잘 통하던 습관이 GitOps로 오면 바로 문제를 만듭니다. 예를 들면 이런 식입니다.

    • 운영값을 Git이 아니라 사람 손으로 클러스터에서 직접 수정함
    • 애플리케이션 코드 저장소와 배포 매니페스트 저장소의 책임이 불명확함
    • 자동 동기화(auto-sync)를 켰는데 승인 절차는 그대로 수동 운영을 기대함
    • Helm(헬름, Kubernetes 패키지 관리 도구) 값 파일이 환경별로 제멋대로 늘어남
    • 장애가 나도 누가 마지막 변경을 만들었는지 추적이 어려움

    저도 처음엔 이게 뭔가 싶었는데, 결국 핵심은 하나였습니다. ArgoCD는 배포 도구이면서 동시에 운영 규율을 강제하는 도구라는 점입니다. 팀이 그 규율을 합의하지 않은 상태에서 도입하면, ArgoCD 문제점처럼 보이는 현상이 사실은 프로세스 문제로 터집니다.

    2. GitOps와 ArgoCD를 아주 쉽게 설명해보면

    GitOps는 “실제 운영 상태는 Git에 적힌 선언대로 맞춘다”는 철학입니다. ArgoCD는 그 선언과 클러스터 상태를 계속 비교해서 drift(드리프트, 선언과 실제 상태가 어긋난 상태)를 감지하고 맞춰주는 역할을 하죠.

    예전 방식은 대체로 이랬습니다. CI 서버가 빌드하고, 누군가 kubectl(쿠버네티스 CLI)이나 Helm으로 운영 클러스터에 직접 배포합니다. 반면 GitOps 방식은 배포 변경도 Pull Request(PR, 변경 제안 요청)로 남고, 승인 후 Git이 바뀌면 ArgoCD가 그걸 따라갑니다. 감사 추적(audit trail, 변경 이력 추적)이 되는 대신, 우회 수정이 어려워집니다. 이 점이 장점이자 초반 저항 포인트입니다.

    항목 기존 CI/CD GitOps + ArgoCD
    배포 트리거 파이프라인 또는 운영자 수동 실행 Git 변경 반영
    변경 이력 파이프라인 로그 중심 Git 커밋과 PR 중심
    긴급 수정 클러스터에서 직접 수정 가능 직접 수정 시 drift 발생
    권한 통제 클러스터 권한 중심 저장소 권한과 승인 흐름 중요
    실패 원인 스크립트 불안정, 환경 차이 저장소 구조, 책임 분리 실패

    그래서 ArgoCD 도입 실패를 줄이려면 설치보다 운영 모델을 먼저 설계해야 합니다. 이걸 건너뛰면 나중에 진짜 많이 돌아갑니다. 저도 삽질 좀 했습니다 ㅎㅎ

    3. 실제로 많이 본 실패 사례 4가지

    3-1. 저장소 구조를 너무 늦게 정한 경우

    가장 흔한 실수입니다. 앱 소스와 배포 설정이 한 저장소에 섞여 있거나, 반대로 너무 잘게 쪼개져서 어디를 기준으로 봐야 하는지 모호한 경우죠. 처음엔 편해 보였는데, 팀이 커질수록 충돌이 심해집니다. 누가 이미지 태그를 관리하고, 누가 replica 수를 바꾸고, 누가 Ingress(인그레스, 외부 트래픽 진입점)를 수정하는지 경계가 안 잡히거든요.

    3-2. 자동 동기화만 켜고 승인 체계를 안 만든 경우

    auto-sync는 정말 편합니다. 드디어 됐다! 싶은 순간이 오거든요. 근데 여기서 바로 사고가 납니다. 운영 반영 전 검토가 필요한 팀인데도 자동 배포를 먼저 켜버리면, 잘못된 값 하나가 바로 프로덕션으로 갑니다. 도구는 빨라졌는데 프로세스는 그대로인 상태죠.

    3-3. Secret 관리 방식을 정하지 않은 경우

    GitOps 실수에서 빠지지 않는 항목입니다. 민감 정보(Secret)를 평문으로 저장하면 안 되고, 그렇다고 운영자가 클러스터에만 몰래 만들어두면 Git과 실제 상태가 분리됩니다. 저는 이 부분에서 팀마다 가장 오래 멈추는 걸 많이 봤습니다. Sealed Secrets(시일드 시크릿)나 External Secrets Operator 같은 접근을 검토하되, 핵심은 “Git에 무엇을 남기고 실제 값은 어디서 주입할지”를 팀 단위로 합의하는 겁니다.

    3-4. Drift를 장애로 볼지, 운영 유연성으로 볼지 합의가 없는 경우

    운영자가 급한 패치를 직접 넣는 문화가 남아 있으면 ArgoCD는 계속 OutOfSync(아웃오브싱크) 상태를 만들 겁니다. 이걸 경고로 볼지, 바로 되돌릴지, 특정 리소스는 예외로 둘지 정하지 않으면 경보만 쌓이고 신뢰가 깨집니다. 이 지점이 대표적인 ArgoCD 문제점처럼 보이는데, 사실은 정책 부재에 가깝습니다.

    4. 실전 구현: 실패 확률을 낮추는 최소 전환 절차

    제가 직접 해보니, 처음부터 전 서비스에 GitOps를 거는 것보다 작은 서비스 하나로 운영 규칙을 검증하는 게 훨씬 낫더라고요. 아래는 많이 무리하지 않는 최소 절차입니다.

    1. 배포 대상 네임스페이스(namespace) 하나를 파일럿으로 고릅니다.
    2. 애플리케이션 코드 저장소와 배포 매니페스트 저장소의 책임을 분리합니다.
    3. ArgoCD 프로젝트(AppProject)로 허용 대상 클러스터/네임스페이스를 제한합니다.
    4. 자동 동기화는 바로 켜지 말고, 먼저 수동 sync로 운영 흐름을 익힙니다.
    5. 변경 승인 기준을 PR 템플릿과 리뷰 규칙으로 문서화합니다.
    6. Drift 발생 시 대응 절차를 정합니다.

    예시로는 아래처럼 시작하면 무난합니다.

    kubectl create namespace argocd
    kubectl apply -n argocd -f https://raw.githubusercontent.com/argoproj/argo-cd/stable/manifests/install.yaml
    kubectl get pods -n argocd

    설치 자체보다 더 중요한 건 프로젝트 경계를 먼저 두는 일입니다.

    apiVersion: argoproj.io/v1alpha1
    kind: AppProject
    metadata:
      name: sample-project
      namespace: argocd
    spec:
      description: sample project for controlled GitOps rollout
      sourceRepos:
        - 'https://github.com/example/platform-manifests.git'
      destinations:
        - namespace: sample-app
          server: 'https://kubernetes.default.svc'
      clusterResourceWhitelist:
        - group: '*'
          kind: '*'

    그 다음 애플리케이션은 이렇게 붙일 수 있습니다.

    apiVersion: argoproj.io/v1alpha1
    kind: Application
    metadata:
      name: sample-app
      namespace: argocd
    spec:
      project: sample-project
      source:
        repoURL: 'https://github.com/example/platform-manifests.git'
        targetRevision: main
        path: apps/sample-app/overlays/prod
      destination:
        server: 'https://kubernetes.default.svc'
        namespace: sample-app
      syncPolicy: {}

    여기서 일부러 자동 동기화 설정을 비워둔 것이 포인트입니다. 처음엔 수동 sync로 팀이 변경 흐름을 이해하게 만드는 게 좋습니다. 자동화는 익숙해진 뒤에 켜도 늦지 않습니다.

    ArgoCD 도입 실패를 줄이기 위한 AppProject와 저장소 구조 구성 이미지

    AppProject 경계, Application 연결, PR 승인 후 반영되는 흐름을 시각적으로 설명하는 이미지입니다.

    5. CI/CD 전환 사례에서 특히 조심해야 할 체크포인트

    기존 파이프라인에서 이미지 빌드까지는 잘 돌아가는데 GitOps로 넘기면서 꼬이는 경우가 많습니다. 보통 CI는 artifact(아티팩트, 배포 가능한 결과물)를 만들고, CD는 배포를 실행합니다. GitOps에선 이 경계가 바뀝니다. CI가 직접 배포하지 않고, 이미지 태그나 차트 값을 Git에 반영하는 식으로 역할이 이동하죠.

    예를 들면 이런 방식입니다.

    # CI job example
    export IMAGE_TAG=${GIT_COMMIT_SHA}
    sed -i "s/tag: .*/tag: ${IMAGE_TAG}/" apps/sample-app/overlays/prod/values.yaml
    git add apps/sample-app/overlays/prod/values.yaml
    git commit -m "chore: deploy sample-app ${IMAGE_TAG}"
    git push origin main

    이 방식은 단순하지만, 바로 main 브랜치에 반영하면 위험합니다. 제가 추천하는 건 별도 배포 브랜치나 PR 자동 생성 방식입니다. 사람이 마지막으로 한 번 더 보고 머지하는 흐름이 초반 안정화에 꽤 도움이 됩니다.

    • 프로덕션 반영은 PR 승인 후에만 가능하게 설정
    • 리뷰어를 플랫폼 담당자와 서비스 담당자로 분리
    • 롤백 기준을 Git revert 중심으로 문서화
    • 수동 kubectl 적용은 예외 상황에서만 허용

    이런 기본선만 있어도 CI/CD 전환 사례에서 실패 확률이 꽤 내려갑니다.

    6. ⚠️ 트러블슈팅: 제가 실제로 많이 본 문제와 해결법

    여기서부터는 정말 많이 부딪히는 부분들입니다. 처음엔 저도 “왜 sync는 성공인데 앱은 안 뜨지?” 같은 상황을 자주 만났거든요.

    증상 원인 해결 방향
    OutOfSync가 계속 발생 운영자가 클러스터에서 직접 수정 직접 수정 금지 원칙 정리, 예외 리소스만 ignore 설정 검토
    Sync 성공인데 서비스 장애 매니페스트 문법은 맞지만 런타임 의존성 누락 readinessProbe, Secret 참조, ConfigMap 값 검증 강화
    배포가 너무 자주 일어남 이미지 태그나 공통 값 파일이 과도하게 변경됨 환경별 경로 분리, 변경 범위 최소화
    리뷰 병목 발생 모든 변경이 한 저장소에 몰림 팀 단위 경계 재설계, CODEOWNERS 활용
    롤백이 헷갈림 Git revert와 수동 핫픽스가 섞임 롤백 절차를 Git 기준으로 단일화

    6-1. ignoreDifferences 남용

    ArgoCD에는 특정 필드 차이를 무시하는 기능이 있습니다. 편하긴 한데, 이걸 남용하면 drift 감지 의미가 사라집니다. 정말 컨트롤러가 자동으로 바꾸는 필드처럼 불가피한 경우에만 제한적으로 쓰는 게 맞습니다.

    6-2. Helm 값 파일 난립

    환경이 늘수록 values 파일이 너무 많아집니다. dev, stage, prod는 그렇다 쳐도 팀별 패치, 긴급 패치, 지역별 패치가 늘어나면 나중에 아무도 구조를 설명 못 합니다. 저도 홈랩에서 비슷하게 풀었다가, 결국 Kustomize(커스터마이즈, 오버레이 기반 설정 관리)와 역할을 분리하면서 정리했었습니다.

    6-3. 알림 없이 운영

    Sync 실패나 Health degraded(헬스 저하) 이벤트를 아무도 못 받으면, ArgoCD UI를 매번 열어보기 전까지 장애를 놓치게 됩니다. 알림 체계는 초반부터 붙이는 게 좋습니다. 최소한 운영 채널로 실패 이벤트는 전달되게 구성해두세요.

    7. 검증: 전환이 잘 되고 있는지 어떻게 확인할까

    성공 기준도 미리 정의해야 합니다. 그냥 “ArgoCD가 떴다”로 끝내면 안 됩니다. 저는 보통 아래 항목으로 봅니다.

    1. 배포 변경이 모두 PR과 커밋으로 추적되는가
    2. 직접 클러스터 수정 비율이 줄고 있는가
    3. 장애 시 마지막 변경점 확인 시간이 짧아졌는가
    4. 롤백 절차가 Git revert 기준으로 일관되게 동작하는가
    5. 서비스별 소유권(owner)이 저장소 구조와 일치하는가

    ArgoCD UI에서 Health, Sync 상태를 보는 것도 좋지만, 그것만으론 부족합니다. 진짜 중요한 건 운영팀과 개발팀이 같은 변경 이력을 보고 같은 언어로 이야기하게 됐는지입니다. 이게 되면 도입이 절반은 성공한 겁니다. 실제로 써보니까 배포 속도보다 커뮤니케이션 비용이 더 크게 줄더라고요.

    ArgoCD 도입 실패 검증을 위한 Sync와 Health 상태 대시보드 이미지

    배포 상태 확인, 이상 징후 탐지, 롤백 판단 포인트를 한눈에 보여주는 결과 검증 이미지입니다.

    8. 정리 FAQ: 많이 받는 질문

    Q1. ArgoCD는 무조건 자동 동기화로 써야 하나요?

    아닙니다. 초반에는 수동 sync가 오히려 안전합니다. 팀이 GitOps 흐름에 익숙해지고 승인 절차가 자리 잡으면 그때 auto-sync를 검토해도 됩니다.

    Q2. 기존 CI/CD를 전부 버려야 하나요?

    그건 아닙니다. 빌드와 테스트는 CI가 계속 담당하고, 배포 실행만 Git 기반으로 넘기는 식이 일반적입니다.

    Q3. ArgoCD 문제점은 결국 도구 한계 아닌가요?

    일부는 맞지만, 현장에서 보이는 대부분은 정책과 구조 문제였습니다. 특히 저장소 책임 분리와 승인 체계가 약하면 같은 문제가 반복됩니다.

    Q4. 작은 팀도 GitOps가 필요할까요?

    작은 팀도 필요할 수 있습니다. 다만 처음부터 무겁게 가지 말고, 단일 서비스와 단순한 저장소 구조로 시작하는 편이 좋습니다.

    ArgoCD 도입 실패 방지 전략과 GitOps 실수 비교 요약 이미지

    도입 전후 비교, 실패 패턴, 예방 전략을 요약한 인포그래픽 형태의 정리 이미지입니다.

    9. 마무리: ArgoCD 도입 실패를 줄이는 진짜 핵심

    ArgoCD 도입 실패는 대개 설치 실패가 아니라 운영 모델 설계 실패입니다. GitOps는 도구를 붙이는 프로젝트가 아니라, 변경을 기록하고 승인하고 되돌리는 방식을 다시 정의하는 작업이거든요. 저도 처음엔 UI가 예쁘고 sync가 자동으로 돌아가니까 금방 안정화될 줄 알았는데, 실제론 저장소 구조와 팀 규칙을 먼저 잡아야 효과가 났습니다.

    정리하면 이렇습니다. GitOps 실수를 줄이려면 작은 범위로 시작하고, 수동 sync로 흐름을 익히고, 저장소 책임과 승인 규칙을 먼저 고정해야 합니다. 그리고 drift, Secret, 롤백 기준을 문서로 남겨야 합니다. 이 4가지만 해도 현장에서 체감 차이가 큽니다.

    다음 글에서는 App of Apps 패턴과 멀티 클러스터 운영에서 어디까지 표준화해야 하는지 다뤄볼 예정입니다. 이전 글에서 다뤘던 Kubernetes 배포 기본기와 함께 보시면 흐름이 더 잘 잡히실 겁니다. 혹시 지금 ArgoCD 도입 실패를 겪고 계시다면, 설치 로그보다 먼저 운영 규칙부터 점검해보세요. 그게 생각보다 훨씬 빠른 지름길입니다. 🎉

  • [k8s] 쿠버네티스 RBAC 보안 강화 체크리스트: 최소 권한 원칙 적용 가이드

    [k8s] 쿠버네티스 RBAC 보안 강화 체크리스트: 최소 권한 원칙 적용 가이드

    [Kubernetes] 쿠버네티스 RBAC 보안 강화 체크리스트

    쿠버네티스 RBAC 보안은 클러스터 운영에서 생각보다 빨리 발목을 잡는 주제입니다. 처음엔 워크로드만 잘 뜨면 된다고 생각했었는데, 실제 운영에 들어가면 누가 어디까지 볼 수 있고, 무엇을 수정할 수 있는지부터 꼬이더라고요. 저도 홈랩에서 Kubernetes(쿠버네티스, 컨테이너 오케스트레이션 플랫폼) 클러스터를 굴리면서 서비스 계정 하나를 너무 넓게 열어뒀다가, 나중에 권한 정리하느라 삽질 좀 했습니다 ㅎㅎ 그래서 오늘은 쿠버네티스 RBAC 보안을 기준으로, 실무에서 바로 점검할 수 있는 체크리스트 형태로 정리해보겠습니다. 특히 k8s 권한 관리가 막막한 분, RBAC 최소 권한을 어디서부터 적용해야 할지 헷갈리는 분께 실질적인 도움이 될 거라고 생각합니다.

    이 글은 특정 벤더 기능이 아니라 Kubernetes 기본 RBAC(Role-Based Access Control, 역할 기반 접근 제어)를 중심으로 설명합니다. 즉, 대부분의 표준 클러스터에서 바로 적용 가능한 실전 내용만 담았습니다.

    쿠버네티스 RBAC 보안 아키텍처 개요 이미지

    RBAC의 큰 흐름을 한 장으로 보면, 왜 최소 권한이 중요한지 훨씬 빨리 감이 옵니다.

    1. 왜 쿠버네티스 RBAC 보안이 먼저냐

    많은 분들이 보안이라고 하면 NetworkPolicy(네트워크폴리시, 네트워크 접근 제어)나 이미지 스캔부터 떠올리시는데요. 근데 여기서 중요한 포인트! 권한이 과하면 그 뒤 보안 장치들이 의미가 많이 줄어듭니다. 읽기 전용이어야 할 계정이 Secret(시크릿, 민감 정보 객체)을 읽을 수 있다거나, 특정 네임스페이스만 다뤄야 하는 자동화 계정이 클러스터 전체를 수정할 수 있다면 문제는 금방 커지더라고요.

    제가 직접 해보니 RBAC는 꼭 사고 대응 때문에만 필요한 게 아니었습니다. 운영자끼리 역할을 분리할 때도 좋고, CI/CD 파이프라인이 쓸 계정을 분리할 때도 좋고, 나중에 감사(Audit, 행위 추적)할 때도 훨씬 편해지더라고요. 누가 왜 그 권한을 갖는지 설명할 수 있어야 관리가 됩니다.

    2. RBAC를 쉽게 말하면: 누가, 어디서, 뭘 하느냐

    쉽게 말해 RBAC는 세 가지를 묶는 구조입니다.

    • 누가: User(사용자), Group(그룹), ServiceAccount(서비스어카운트, 파드가 쓰는 계정)
    • 어디서: Namespace(네임스페이스, 논리적 격리 단위) 또는 클러스터 전체
    • 뭘 하느냐: verbs(동작)와 resources(리소스)

    여기서 자주 헷갈리는 게 Role과 ClusterRole 차이입니다. 저도 처음엔 이게 뭔가 싶었는데, 정리하면 꽤 단순합니다.

    구성 요소 범위 용도 예시
    Role 특정 Namespace 네임스페이스 내부 권한 정의 dev 네임스페이스의 Pod 조회
    ClusterRole 클러스터 전체 또는 공통 리소스 광범위 권한 또는 공통 읽기 권한 정의 노드 조회, 전체 네임스페이스 읽기
    RoleBinding 특정 Namespace Role 또는 ClusterRole을 특정 주체에 연결 개발자 그룹에 dev 조회 권한 부여
    ClusterRoleBinding 클러스터 전체 ClusterRole을 클러스터 범위로 연결 운영팀에 클러스터 전역 읽기 권한 부여

    즉, RBAC 최소 권한의 핵심은 필요한 주체에게 필요한 리소스만, 필요한 동작만 허용하는 겁니다. 말은 쉬운데 실제로는 여기서 많이 넓어지더라고요. 특히 * 와일드카드, 무심코 준 cluster-admin, 그리고 서비스 계정 재사용이 흔한 함정입니다.

    3. 쿠버네티스 보안 체크리스트: 먼저 이것부터 보세요

    운영 중인 클러스터가 있다면 아래 항목부터 점검해보시면 됩니다. 저는 새 클러스터를 만들 때도 이 리스트부터 잡고 시작합니다.

    1. cluster-admin 바인딩 확인: 정말 필요한 주체만 갖고 있는지 봅니다.
    2. ServiceAccount 분리: 애플리케이션별, 작업별로 계정을 나눕니다.
    3. 와일드카드 금지: resources, verbs에 * 사용을 최대한 피합니다.
    4. Secret 접근 최소화: 꼭 필요한 워크로드만 읽게 합니다.
    5. Namespace 단위 분리: 팀, 환경, 서비스 기준으로 경계를 명확히 둡니다.
    6. 읽기와 쓰기 분리: 조회 전용 계정과 변경 가능 계정을 나눕니다.
    7. 권한 검증 자동화: kubectl auth can-i로 배포 전에 확인합니다.
    8. 휴면 계정 정리: 더 이상 쓰지 않는 RoleBinding, ClusterRoleBinding 제거합니다.
    9. 기본 토큰 사용 점검: default ServiceAccount에 불필요한 권한을 주지 않습니다.
    10. 감사 로그 연계 검토: 누가 어떤 API를 호출했는지 추적 가능한 구조를 만듭니다.

    혹시 이런 경험 있으신가요? 급해서 일단 권한부터 열고, 나중에 줄이자고 생각했는데 그 나중이 안 오는 경우요. 실제로 써보니까 RBAC는 처음에 30분 더 쓰는 게 나중에 몇 시간을 아껴줍니다.

    4. 실전 구현: 네임스페이스 단위로 RBAC 최소 권한 적용하기

    이제 예제로 가보겠습니다. 시나리오는 단순합니다. ops-viewer라는 ServiceAccount가 production 네임스페이스 안에서 Pod와 Deployment만 읽을 수 있게 만들겠습니다. 수정, 삭제, Secret 조회는 못 하게 두는 방식입니다. 이런 식으로 시작하면 k8s 권한 관리가 훨씬 명확해집니다.

    4-1. 네임스페이스와 서비스 계정 만들기

    kubectl create namespace production
    kubectl -n production create serviceaccount ops-viewer

    여기서 서비스 계정을 애플리케이션용 계정과 섞지 않는 게 중요합니다. 저는 예전에 배치 작업과 운영 조회 계정을 하나로 묶었다가, 생각보다 많은 권한이 전파되더라고요.

    4-2. Role 정의

    apiVersion: rbac.authorization.k8s.io/v1
    kind: Role
    metadata:
      name: pod-deploy-readonly
      namespace: production
    rules:
    - apiGroups: [""]
      resources: ["pods"]
      verbs: ["get", "list", "watch"]
    - apiGroups: ["apps"]
      resources: ["deployments"]
      verbs: ["get", "list", "watch"]

    포인트는 명확합니다. pods, deployments만 읽을 수 있게 열었습니다. 여기서 Secret이나 ConfigMap까지 습관적으로 넣지 않는 게 핵심입니다. 진짜 필요한지부터 따져봐야 합니다.

    4-3. RoleBinding 연결

    apiVersion: rbac.authorization.k8s.io/v1
    kind: RoleBinding
    metadata:
      name: pod-deploy-readonly-binding
      namespace: production
    subjects:
    - kind: ServiceAccount
      name: ops-viewer
      namespace: production
    roleRef:
      apiGroup: rbac.authorization.k8s.io
      kind: Role
      name: pod-deploy-readonly

    이제 이 ServiceAccount는 production 네임스페이스 내부의 조회 권한만 갖습니다. 클러스터 전체 권한이 아니라는 점이 중요합니다. 바로 이 경계 설정이 쿠버네티스 RBAC 보안의 기본입니다.

    쿠버네티스 RBAC 보안의 네임스페이스 권한 구성 이미지

    실전에서는 Role과 Binding 연결 관계를 그림으로 한 번 정리해두면 팀원 온보딩 때 정말 편합니다.

    4-4. 적용 명령

    kubectl apply -f role.yaml
    kubectl apply -f rolebinding.yaml

    4-5. 권한 검증

    kubectl auth can-i get pods \
      --as=system:serviceaccount:production:ops-viewer \
      -n production
    
    kubectl auth can-i get secrets \
      --as=system:serviceaccount:production:ops-viewer \
      -n production
    
    kubectl auth can-i delete deployments \
      --as=system:serviceaccount:production:ops-viewer \
      -n production

    정상이라면 첫 번째는 yes, 나머지는 no에 가깝게 나와야 합니다. 드디어 됐다! 싶은 순간이 여기입니다. RBAC는 적용보다 검증이 더 중요하거든요.

    5. 실무 체크포인트: ClusterRole은 언제 써야 하나

    모든 걸 Role로만 처리할 수는 없습니다. 예를 들어 여러 네임스페이스에서 공통 조회가 필요하거나, Node(노드), Namespace 같은 클러스터 범위 리소스를 읽어야 하는 경우엔 ClusterRole이 맞습니다. 다만 ClusterRole을 쓸 때도 바인딩 범위를 생각해야 합니다.

    예를 들어 ClusterRole 자체는 공통 읽기 정책으로 만들고, 실제 부여는 Namespace별 RoleBinding으로 제한하는 방식도 가능합니다. 이 패턴이 꽤 유용합니다. 권한 정의는 재사용하고, 적용 범위는 좁히는 거죠.

    apiVersion: rbac.authorization.k8s.io/v1
    kind: ClusterRole
    metadata:
      name: view-pods-common
    rules:
    - apiGroups: [""]
      resources: ["pods"]
      verbs: ["get", "list", "watch"]

    이렇게 만들어두고 필요한 네임스페이스에서 RoleBinding으로 참조하면 운영이 조금 더 단정해집니다. 저는 환경이 여러 개일 때 이 방식을 자주 씁니다.

    6. ⚠️ 주의사항과 트러블슈팅: 제가 실제로 많이 헷갈렸던 부분

    쿠버네티스 보안 체크리스트에서 자주 놓치는 함정을 몇 가지 적어보겠습니다. 저도 처음엔 꽤 많이 틀렸습니다.

    • default ServiceAccount 사용: 아무 설정 없이 파드가 default 계정을 쓰는 경우가 많습니다. 이 계정에 권한이 붙어 있으면 의도치 않은 확장이 생깁니다.
    • Secret 읽기 권한 과다: Pod 조회만 필요했는데 디버깅 편하다고 Secret 읽기까지 열어두더라고요. 이건 생각보다 위험합니다.
    • ClusterRoleBinding 남발: 편해서 전역 바인딩을 쓰다 보면, 나중에 어느 팀이 무엇을 할 수 있는지 안 보입니다.
    • verbs 누락 또는 과다: list만 필요한데 create, delete까지 들어가 있는 경우가 있습니다.
    • 서브리소스 누락: pods/log 같은 서브리소스 접근이 필요한데 본 리소스만 열어서 안 되는 경우도 많습니다.

    예를 들어 로그 조회가 안 될 때는 이런 식으로 서브리소스를 분리해줘야 합니다.

    apiVersion: rbac.authorization.k8s.io/v1
    kind: Role
    metadata:
      name: pod-log-reader
      namespace: production
    rules:
    - apiGroups: [""]
      resources: ["pods", "pods/log"]
      verbs: ["get", "list", "watch"]

    처음엔 Pod 읽기 권한이 있으면 로그도 되겠지 싶었는데, 여기서 막히더라고요. 이런 디테일이 RBAC에서 은근 많습니다.

    문제가 생겼을 때 확인 순서

    1. kubectl auth can-i로 해당 주체 기준 권한을 확인합니다.
    2. Role/ClusterRole의 resources, verbs, apiGroups가 맞는지 봅니다.
    3. RoleBinding이 올바른 네임스페이스에 연결됐는지 확인합니다.
    4. 서비스 계정 이름과 네임스페이스가 정확한지 다시 봅니다.
    5. 서브리소스가 필요한 작업인지 확인합니다.
    쿠버네티스 RBAC 보안 권한 검증 흐름 이미지

    권한 검증 흐름을 따로 정리해두면 트러블슈팅 시간이 확실히 줄어듭니다.

    7. 검증과 운영 결과: RBAC 최소 권한이 주는 실제 이점

    RBAC 최소 권한을 적용하고 나면 체감되는 변화가 분명합니다. 이거 진짜 편하더라고요.

    • 장애 대응 시 누가 무엇을 바꿀 수 있는지 명확해집니다.
    • 자동화 계정과 사람 계정의 역할이 분리됩니다.
    • 실수로 인한 삭제나 수정 범위를 줄일 수 있습니다.
    • 감사와 변경 이력 추적이 쉬워집니다.
    • 새 팀원에게 권한 구조를 설명하기 쉬워집니다.

    검증할 때는 아래 항목을 한 번 더 보시면 좋습니다.

    1. 서비스 계정별 허용 동작 목록이 문서화되어 있는가
    2. 네임스페이스를 넘는 불필요한 권한이 없는가
    3. Secret, Role, RoleBinding 수정 권한이 꼭 필요한 주체에만 있는가
    4. 휴면 바인딩이 남아 있지 않은가
    5. 정기 점검 시나리오가 있는가

    특히 운영 문서에 단순히 YAML만 남기지 말고, 왜 이 권한이 필요한지도 같이 적어두세요. 나중에 본인이 봐도 살짝 감동합니다. 저는 예전 설정 파일만 덩그러니 남겨놨다가, 몇 달 뒤에 제가 만든 정책을 제가 못 읽겠더라고요.

    8. 자주 묻는 질문: k8s 권한 관리에서 많이 나오는 질문

    Q1. 읽기 전용 계정인데 왜 로그가 안 보일까요?

    pods만 열고 pods/log를 빼먹은 경우가 많습니다. 서브리소스 권한을 따로 확인해보세요.

    Q2. Role만 쓰면 안 되나요?

    네임스페이스 내부만 다루면 Role로 충분한 경우가 많습니다. 하지만 클러스터 범위 리소스나 공통 정책 재사용이 필요하면 ClusterRole이 더 적합합니다.

    Q3. RBAC 최소 권한은 얼마나 잘게 쪼개야 하나요?

    정답은 없습니다. 다만 사람별로가 아니라 역할별로 나누는 쪽이 운영하기 쉽습니다. 배포 전용, 조회 전용, 로그 조회 전용처럼 나누는 방식이 실무적입니다.

    Q4. Secret 접근은 정말 따로 봐야 하나요?

    네, 저는 따로 봐야 한다고 생각합니다. Secret은 영향도가 커서 다른 읽기 권한과 한 묶음으로 주지 않는 편이 안전합니다.

    쿠버네티스 RBAC 보안 최소 권한 적용 전후 비교 이미지

    최소 권한 전후 차이를 시각화하면 팀 설득이나 운영 표준화에 꽤 도움이 됩니다.

    9. 마무리: 쿠버네티스 RBAC 보안은 결국 운영 습관입니다

    쿠버네티스 RBAC 보안은 어려운 개념이라기보다, 귀찮아서 미루기 쉬운 운영 습관에 가깝습니다. 저도 처음엔 일단 되게 만드는 쪽으로 갔었는데, 실제로 써보니까 결국 돌아와서 정리하게 되더라고요. 그래서 처음부터 RBAC 최소 권한 기준으로 설계하는 게 낫습니다.

    오늘 내용은 체크리스트 중심으로 정리했지만, 다음 단계에서는 ServiceAccount 토큰 관리, Admission Controller(어드미션 컨트롤러, 요청 검증/제어), NetworkPolicy와 함께 묶어서 보시면 훨씬 좋습니다. 이전 글에서 다뤘던 네임스페이스 분리 전략이 있다면 같이 연결해서 보셔도 좋고요. 다음 글에서는 쿠버네티스 보안 체크리스트를 확장해서 Pod Security와 Secret 관리까지 묶어 다뤄볼 예정입니다.

    정리하자면 이렇습니다. 권한은 넓게 주는 순간 편하지만, 운영은 그때부터 복잡해집니다. 반대로 처음부터 좁게 주면 조금 번거롭지만, 나중에 훨씬 덜 흔들립니다. 저는 후자가 맞더라고요.

  • [k8s] Rancher 2.x에서 차세대로 마이그레이션: 실제 경험과 주요 변경점

    [k8s] Rancher 2.x에서 차세대로 마이그레이션: 실제 경험과 주요 변경점

    안녕하세요, 13년차 서버실 지킴이입니다. 오늘은 많은 분들이 고민하고 계실 법한 주제, 바로 Rancher 2.x 환경을 차세대 쿠버네티스 관리 아키텍처로 전환하는 경험에 대해 이야기해볼게요. 제목에는 ‘Rancher 3.x’라는 표현을 썼지만, 사실 직접적인 ‘Rancher 3.x’라는 버전이 명확하게 출시된 것은 아닙니다. 대신, Rancher를 활용한 쿠버네티스 관리 방식이 점차 진화하면서, 기존 2.x 시절의 방식과는 크게 달라진 미래 지향적인 아키텍처로의 전환 과정을 ‘3.x 마이그레이션’이라는 개념으로 풀어보려고 해요. 즉, 단순히 버전을 올리는 것을 넘어, 더 효율적이고 안정적인 쿠버네티스 운영을 위한 근본적인 변화를 고민하는 시간이라고 보시면 되겠습니다.

    저도 홈랩에서부터 시작해서 프로덕션 환경까지 다양한 규모의 쿠버네티스 클러스터를 Rancher 2.x로 관리해왔어요. 처음에는 하나의 Rancher 서버로 모든 클러스터를 중앙에서 관리하는 방식이 정말 편하더라고요. 하지만 클러스터의 수가 늘어나고, 요구사항이 복잡해지면서 중앙 집중형 관리의 한계를 느끼게 됐습니다. 특히, Rancher 서버 자체의 안정성이나 업그레이드 부담, 그리고 GitOps(깃옵스)와 같은 최신 트렌드를 통합하는 데 대한 고민이 많았거든요. 그래서 ‘이제는 좀 더 분산되고 선언적인 방식으로 가야 하지 않을까?’ 하는 생각을 하게 됐습니다. 이런 고민을 하고 계신 분들이라면 오늘 제 이야기가 작은 팁이라도 될 수 있을 겁니다. 제가 직접 삽질해가며 얻은 경험들을 솔직하게 공유해볼게요!

    개념 설명: Rancher 2.x와 차세대 아키텍처의 차이

    먼저, 우리가 이야기하는 Rancher 2.x는 보통 RKE1(Rancher Kubernetes Engine 1) 기반의 쿠버네티스 클러스터들을 Rancher Management Server(랜처 관리 서버)가 중앙에서 프로비저닝하고 관리하는 형태를 의미합니다. 웹 UI를 통해 클러스터를 생성하고, 워크로드를 배포하며, 모니터링까지 한곳에서 할 수 있었죠. 정말 편리하고 직관적입니다. 하지만 단점도 명확해요.

    • 중앙 집중형 의존성: Rancher Management Server에 장애가 발생하면 모든 하위 클러스터 관리에 문제가 생길 수 있습니다.
    • 관리 복잡성 증가: 클러스터가 많아질수록 관리 서버 자체의 부담도 커집니다.
    • GitOps 통합의 어려움: UI 기반의 작업이 많아 GitOps 파이프라인과 완벽하게 통합하기 쉽지 않은 부분이 있었습니다.

    그렇다면 여기서 말하는 ‘차세대 아키텍처’ 혹은 ‘3.x스러운’ 접근 방식은 뭘까요? 저는 주로 RKE2(Rancher Kubernetes Engine 2)나 K3s(케이쓰리s)와 같은 경량화되거나 보안이 강화된 쿠버네티스 배포판을 활용하고, GitOps 원칙을 적극적으로 도입하여 선언적(Declarative)으로 클러스터와 애플리케이션을 관리하는 방식을 의미한다고 봐요. 이제 더 이상 Rancher Management Server가 클러스터의 모든 것을 직접 제어하기보다는, 클러스터 자체의 견고함과 Git을 통한 선언적 관리에 초점을 맞추는 거죠. Rancher는 이런 클러스터들을 통합적으로 보여주고 관리하는 ‘플랫폼’으로서의 역할에 더 집중하게 됩니다.

    Rancher 2.x 중앙 집중형 관리와 차세대 분산형 GitOps 아키텍처 비교 다이어그램

    Rancher 2.x의 중앙 집중형 관리 방식과 차세대 분산형 GitOps 아키텍처의 주요 차이점을 시각적으로 보여주는 다이어그램입니다.

    실전 구현: 차세대 클러스터 환경 구축 전략

    기존 Rancher 2.x 환경을 ‘마이그레이션’하는 것은 단순히 버전을 올리는 것이 아니라, 새로운 클러스터를 구축하고 워크로드를 이전하는 과정에 가깝습니다. 제가 홈랩에서 여러 번 시도해본 결과, 크게 두 가지 접근 방식이 있더라고요.

    1. 새로운 RKE2/K3s 클러스터 프로비저닝

    먼저, 기존 Rancher 2.x 관리 서버에서 새로운 RKE2나 K3s 클러스터를 프로비저닝하는 방법을 소개할게요. Rancher 2.6 버전부터는 RKE2/K3s 클러스터 생성을 공식적으로 지원해서 훨씬 수월해졌습니다.

    1. Rancher UI 접속: 기존 Rancher Management Server의 웹 UI에 접속합니다.
    2. 클러스터 생성 메뉴 진입: ‘클러스터’ 탭에서 ‘클러스터 생성’ 버튼을 클릭합니다.
    3. RKE2/K3s 선택: ‘Rancher Kubernetes Engine 2 (RKE2)’ 또는 ‘K3s’를 선택합니다. 저는 보안과 성능을 고려해 RKE2를 선호하는 편입니다.
    4. 노드 구성 및 옵션 설정: 컨트롤 플레인(Control Plane), etcd, 워커(Worker) 노드를 구성하고 필요한 네트워크, CNI(Container Network Interface, 컨테이너 네트워크 인터페이스) (예: Canal, Calico 등) 옵션을 설정합니다. 이때, 클러스터의 고가용성(High Availability, HA)을 위해 컨트롤 플레인 노드를 최소 3개 이상으로 구성하는 것이 중요합니다.
    5. 클러스터 생성: 모든 설정을 마치고 클러스터를 생성하면, Rancher가 백그라운드에서 노드에 에이전트를 설치하고 RKE2/K3s를 배포합니다.

    다음은 RKE2 클러스터를 생성할 때 필요한 기본적인 설정 예시입니다.

    # 클러스터 생성 시 RKE2/K3s 설정 예시 (Rancher UI에서 구성)
    kubernetes_version: v1.27.x-rke2r1 # 원하는 RKE2 버전 선택
    cni: canal # CNI 플러그인 선택 (calico, cilium 등)
    cloud_provider: 
      name: aws # 클라우드 환경에 맞춰 설정 (baremetal, azure, vsphere 등)
    agent_options:
      node_taints:
        - "CriticalAddonsOnly=true:NoExecute"
      labels:
        - "node-role.kubernetes.io/control-plane=true"
        - "node-role.kubernetes.io/etcd=true"
    # 노드 추가는 Rancher UI에서 직접 진행하거나, Machine Group을 통해 자동화 가능
    

    이렇게 새 클러스터를 만들고 나면, 이제 기존 워크로드들을 새로운 클러스터로 이전할 준비가 된 겁니다. 이게 생각보다 쉽지 않아요. 애플리케이션 의존성부터 데이터 마이그레이션까지 고려할 게 많거든요. 제가 초반에 이걸 간과해서 밤샘 삽질을 좀 했습니다. 😅

    Rancher UI에서 RKE2 클러스터를 생성하는 화면 예시

    Rancher UI를 통해 새로운 RKE2 클러스터를 생성하는 화면 예시입니다. 여기서 다양한 옵션을 설정할 수 있습니다.

    2. 워크로드 및 데이터 마이그레이션

    가장 중요한 단계입니다. 워크로드 마이그레이션은 서비스 중단 시간을 최소화하는 방향으로 계획해야 해요. 몇 가지 팁을 드리자면:

    • 상태 없는(Stateless) 애플리케이션 먼저: 웹 서버, API 게이트웨이 등 상태를 저장하지 않는 애플리케이션부터 이전하여 위험을 줄입니다. Helm(헬름)이나 GitOps 툴(예: Argo CD, Flux CD)을 활용하면 배포를 선언적으로 관리하고 쉽게 이전할 수 있어요.
    • 상태 있는(Stateful) 애플리케이션: 데이터베이스와 같은 상태 있는 애플리케이션은 velero(벨레로)와 같은 백업 및 복구 툴을 사용하거나, 클라우드 제공업체의 볼륨 스냅샷 기능을 활용하여 데이터를 이전합니다. 이 과정에서 네트워크 지연(Latency)이나 데이터 정합성(Data Consistency)에 문제가 없는지 꼼꼼히 확인해야 해요.
    • 네트워크 설정: Ingress(인그레스, 외부 트래픽 진입점) 컨트롤러, Service(서비스) 타입, ExternalDNS(외부 DNS) 설정 등을 새 클러스터에 맞게 재구성해야 합니다. 특히 DNS 레코드를 변경할 때는 TTL(Time-To-Live, 캐시 유지 시간)을 짧게 설정하여 롤백에 대비하는 것이 좋습니다.
    # Argo CD를 이용한 GitOps 배포 예시
    # 새 클러스터에 Argo CD 설치 후, Git 리포지토리 연결
    
    # 1. Argo CD 설치 (새 클러스터에)
    kubectl create namespace argocd
    kubectl apply -n argocd -f https://raw.githubusercontent.com/argoproj/argo-cd/stable/manifests/install.yaml
    
    # 2. Argo CD CLI 설치 및 초기 비밀번호 확인
    # (생략)
    
    # 3. 애플리케이션 정의 (예: my-app.yaml)
    # applications/my-app.yaml 파일 생성
    # apiVersion: argoproj.io/v1alpha1
    # kind: Application
    # metadata:
    #   name: my-webapp
    #   namespace: argocd
    # spec:
    #   project: default
    #   source:
    #     repoURL: https://github.com/my-org/my-app-configs.git # 애플리케이션 설정이 있는 Git 레포지토리
    #     targetRevision: HEAD
    #     path: dev # Git 레포지토리 내 경로
    #   destination:
    #     server: https://kubernetes.default.svc
    #     namespace: my-webapp-prod # 배포할 네임스페이스
    #   syncPolicy:
    #     automated:
    #       prune: true
    #       selfHeal: true
    
    # 4. Argo CD에 애플리케이션 등록
    argocd app create my-webapp --repo https://github.com/my-org/my-app-configs.git --path dev --dest-server https://kubernetes.default.svc --dest-namespace my-webapp-prod
    

    이런 GitOps 툴을 활용하면, 기존 클러스터에서 사용하던 매니페스트(Manifest) 파일들을 Git 레포지토리에 올리고, 새 클러스터에 Argo CD를 설치하여 동기화하는 방식으로 쉽게 워크로드를 이전할 수 있어요. 코드로 인프라를 관리하는(Infrastructure as Code, IaC) 경험은 정말 혁신적입니다!

    ⚠️ 주의사항 및 트러블슈팅: 삽질 경험 공유

    제가 이 ‘차세대 전환’을 하면서 겪었던 몇 가지 삽질과 해결책들을 공유해볼게요.

    1. RKE1과 RKE2/K3s의 설정 차이: RKE1은 cluster.yml 파일을 기반으로 클러스터를 구성했지만, RKE2/K3s는 /etc/rancher/rke2/config.yaml (또는 k3s) 파일을 사용하거나 Helm 차트 등을 통해 더 세분화된 설정을 합니다. 기존 RKE1의 커스텀 설정(예: 추가 컨테이너 런타임 옵션, CNI 플러그인 설정)을 그대로 옮기려다 호환성 문제로 고생 좀 했어요. 새로운 배포판의 문서(Documentation)를 꼼꼼히 확인하는 것이 정말 중요합니다.
    2. StorageClass(스토리지 클래스) 호환성: 기존 클러스터에서 사용하던 PersistentVolume(영구 볼륨)과 PersistentVolumeClaim(영구 볼륨 클레임)은 StorageClass에 따라 다르게 동작할 수 있습니다. 특히 클라우드 환경이 변경되거나 스토리지 솔루션이 달라지면, 새로운 StorageClass를 정의하고 기존 PV/PVC를 마이그레이션해야 해요. 저는 홈랩에서 Longhorn(롱혼)을 사용하는데, 새 클러스터에 Longhorn을 재설치하고 데이터를 옮기는 과정에서 네트워크 설정 문제로 볼륨이 마운트되지 않아 애먹었습니다. 😅
    3. Cilium(실리움) CNI 도입 시 주의사항: 최근 Cilium이 성능과 보안 면에서 각광받고 있어서 저도 도입을 고려했는데, 기존 CNI(예: Canal)에서 Cilium으로 변경할 때는 네트워크 정책(Network Policy)과의 호환성, kube-proxy(쿠베 프록시) 없이 동작하는 모드(Direct Routing) 설정 등 고려할 사항이 많아요. 잘못하면 클러스터 내부 통신이 마비될 수 있으니 충분한 테스트 환경에서 검증해야 합니다.
    4. Rancher Management Server의 역할 변화: 기존에는 Rancher 서버가 모든 것을 다 해주는 느낌이었다면, 이제는 ‘관측성(Observability)’과 ‘정책 관리(Policy Management)’, 그리고 ‘클러스터 수명 주기 관리(Cluster Lifecycle Management)’에 더 집중하게 됩니다. 즉, 클러스터 내부의 복잡한 운영은 GitOps 툴과 같은 다른 도구들에게 맡기고, Rancher는 그 위에서 통합된 뷰를 제공하는 역할로 전환되는 거죠. 이 역할을 이해하지 못하면 ‘왜 Rancher가 예전처럼 클러스터 설정을 다 해주지 않지?’ 하고 헤맬 수 있습니다.

    검증 및 결과: 안정적인 차세대 환경 확인

    모든 워크로드 마이그레이션이 완료되었다면, 새로운 클러스터가 제대로 동작하는지 꼼꼼히 검증해야 합니다. 다음은 제가 주로 확인하는 항목들입니다.

    • 애플리케이션 정상 동작 확인: 모든 서비스의 엔드포인트에 접속하여 기능이 정상적으로 동작하는지 확인합니다. 특히 로깅(Logging)과 모니터링(Monitoring) 시스템이 제대로 연동되는지 확인하는 것이 중요해요.
    • 리소스 사용량 모니터링: Grafana(그라파나), Prometheus(프로메테우스) 등의 툴을 통해 CPU, 메모리, 네트워크, 디스크 I/O 등 클러스터 리소스 사용량을 면밀히 모니터링합니다. 기존 클러스터와 비교하여 비정상적인 패턴이 없는지 확인해야 합니다.
    • 클러스터 컴포넌트 상태: kubectl get pods -A 명령어로 모든 네임스페이스의 파드(Pod) 상태를 확인하고, kubectl get nodes로 노드 상태를 확인하여 문제가 없는지 점검합니다.
    • 데이터 정합성 검증: 상태 있는 애플리케이션의 경우, 이전된 데이터가 정확한지, 쓰기/읽기 작업이 문제없이 이루어지는지 반드시 확인해야 합니다.

    이 모든 검증을 마치고 나면, 드디어 새로운 차세대 Rancher 환경이 안정적으로 운영되는 것을 확인할 수 있어요. 이 뿌듯함이란! 🎉

    새롭게 마이그레이션된 Rancher 환경의 클러스터 대시보드

    새롭게 마이그레이션된 Rancher 환경에서 클러스터의 전반적인 상태를 보여주는 대시보드 화면입니다.

    마무리: 배운 점과 다음 단계

    Rancher 2.x에서 차세대 쿠버네티스 관리 환경으로의 전환은 단순히 소프트웨어 버전을 올리는 작업이 아니었습니다. 이는 클러스터 아키텍처, 운영 방식, 그리고 인프라 엔지니어의 역할에 대한 근본적인 재정의 과정이라고 생각해요. 저도 이 과정을 거치면서 많은 것을 배우고 삽질도 정말 많이 했습니다. 하지만 그 덕분에 GitOps의 중요성, RKE2/K3s의 장점, 그리고 Rancher가 나아가야 할 방향에 대해 더 깊이 이해하게 되었죠.

    Rancher 환경 전환 시 고려해야 할 핵심 사항 요약 인포그래픽

    Rancher 환경 전환 시 고려해야 할 핵심 사항들을 요약한 인포그래픽입니다.

    이번 마이그레이션을 통해 얻은 주요 교훈은 다음과 같습니다.

    • 계획의 중요성: 충분한 사전 계획 없이는 성공적인 마이그레이션은 불가능해요. 의존성 파악, 백업/복구 전략, 롤백 계획 등 모든 것을 미리 준비해야 합니다.
    • GitOps의 힘: 선언적인 코드로 인프라와 애플리케이션을 관리하는 GitOps는 복잡한 마이그레이션을 훨씬 수월하게 만들고, 향후 운영의 안정성을 높여줍니다.
    • 문서화의 중요성: 모든 변경 사항과 결정 사항을 문서화하여 팀원들과 공유하고, 향후 트러블슈팅에 활용해야 합니다.

    이제 새로운 클러스터에서 더 안정적이고 효율적인 쿠버네티스 운영을 할 수 있게 되었어요. 다음 단계로는 클러스터의 보안 강화(Security Hardening), 자동화된 재해 복구(Automated Disaster Recovery) 시스템 구축, 그리고 멀티 클러스터 환경에서의 서비스 메시(Service Mesh) 도입 등을 고민해볼 예정입니다. 여러분도 혹시 비슷한 고민을 하고 계시다면, 주저하지 말고 새로운 아키텍처로의 전환을 시도해보세요. 물론 삽질은 필수겠지만, 그만큼 얻는 것도 많을 겁니다! 궁금한 점이 있다면 언제든 댓글 남겨주세요. 다음 포스팅에서 또 재미있는 이야기로 찾아뵙겠습니다!

  • [k8s] Argo CD 멀티 클러스터 동기화 문제 해결: 실제 운영 사례와 디버깅 팁

    [k8s] Argo CD 멀티 클러스터 동기화 문제 해결: 실제 운영 사례와 디버깅 팁

    Argo CD 멀티 클러스터 동기화 문제 해결: 실제 운영 사례와 디버깅 팁

    안녕하세요, 13년차 서버실 지킴이입니다. 요즘 쿠버네티스(Kubernetes) 환경에서 GitOps(깃옵스)를 도입하는 기업들이 정말 많죠? 저도 홈랩과 회사 프로젝트에서 Argo CD(아르고 CD)를 활용해서 여러 쿠버네티스 클러스터를 관리하고 있는데요. 처음엔 “와, 이거 정말 편하겠다!” 싶었는데, 막상 실제 운영 환경에서 멀티 클러스터(Multi-Cluster) 동기화 문제를 만나면 머리가 지끈거릴 때가 많더라고요.

    특히 여러 클러스터에 동일한 애플리케이션을 배포하거나, 환경별로 미묘하게 다른 설정을 적용해야 할 때 ApplicationSet(애플리케이션셋)을 쓰면 정말 유용하거든요. 그런데 간혹 특정 클러스터만 동기화가 안 되거나, 알 수 없는 에러로 삽질을 거듭하곤 해요. 제가 직접 겪었던 Argo CD 멀티 클러스터 동기화 문제들과 그 해결 과정을 솔직하게 공유해볼까 해요. 혹시 비슷한 경험으로 고생하고 계시다면, 이 글이 작은 힌트라도 되었으면 좋겠네요! 💡

    Argo CD 멀티 클러스터 관리 아키텍처: Git을 중심으로 Argo CD가 여러 쿠버네티스 클러스터에 애플리케이션을 배포하고 동기화하는 흐름을 보여줍니다.

    Argo CD, GitOps, 그리고 멀티 클러스터, 이게 뭔가요?

    본격적인 문제 해결에 앞서, 핵심 개념들을 간단히 짚고 넘어갈게요. “아, 이건 다 아는데!” 하시는 분들도 계시겠지만, 혹시 처음 접하시는 분들을 위해 쉽게 풀어 설명해 드릴게요.

    • Argo CD (아르고 CD): 쿠버네티스 환경에서 GitOps를 구현하기 위한 대표적인 선언적(Declarative) CD(Continuous Delivery, 지속적 배포) 툴입니다. Git 저장소를 애플리케이션의 ‘원본 소스(Single Source of Truth)’로 삼아, 쿠버네티스 클러스터의 실제 상태가 Git에 정의된 상태와 일치하도록 지속적으로 동기화(Synchronization)를 시도하죠. 즉, Git에 코드를 푸시하면 Argo CD가 알아서 클러스터에 배포해주는 방식입니다.

    • GitOps (깃옵스): Git을 운영의 중심(Operational Hub)으로 삼아 인프라와 애플리케이션의 모든 상태를 관리하는 방식입니다. 모든 변경 사항이 Git에 기록되므로, 누가 언제 무엇을 변경했는지 추적하기 쉽고, 문제가 생겼을 때 쉽게 롤백(Rollback)할 수 있다는 장점이 있습니다. “Git에서 정의한 대로 클러스터 상태를 유지한다”는 철학이죠.

    • 멀티 클러스터 (Multi-Cluster): 여러 개의 쿠버네티스 클러스터를 동시에 관리하는 환경을 의미합니다. 개발, 스테이징, 프로덕션 환경을 분리하거나, 재해 복구(Disaster Recovery)를 위해 여러 리전에 클러스터를 운영할 때 등 다양한 이유로 멀티 클러스터 환경을 구축합니다. Argo CD는 하나의 중앙 집중식(Centralized) 컨트롤 플레인(Control Plane)으로 여러 원격 클러스터(Remote Cluster)를 관리할 수 있게 해줍니다.

    Argo CD 멀티 클러스터 설정과 흔한 문제 시나리오

    Argo CD를 이용해 멀티 클러스터를 관리하려면, 먼저 Argo CD 컨트롤 플레인이 설치된 클러스터(보통 ‘관리 클러스터’)에 다른 클러스터들을 등록해야 합니다. argocd cluster add 명령어가 이걸 해주죠. 이때 Argo CD가 원격 클러스터에 접근할 수 있는 ServiceAccount와 ClusterRoleBinding을 생성해줍니다.

    그리고 여러 클러스터에 애플리케이션을 배포할 때는 주로 ApplicationSet을 사용합니다. 예를 들어, 다음과 같은 ApplicationSet으로 여러 클러스터에 nginx-app을 배포한다고 가정해봅시다.

    apiVersion: argoproj.io/v1alpha1
    kind: ApplicationSet
    metadata:
      name: my-nginx-appset
    spec:
      generators:
      - clusters: {}
      template:
        metadata:
          name: '{{name}}-nginx-app'
        spec:
          project: default
          source:
            repoURL: https://github.com/my-org/my-gitops-repo.git
            targetRevision: HEAD
            path: apps/nginx
          destination:
            server: '{{server}}'
            namespace: default
          syncPolicy:
            automated:
              prune: true
              selfHeal: true
    

    이렇게 설정하면 Argo CD가 등록된 모든 클러스터에 apps/nginx 경로의 매니페스트를 배포하려고 시도합니다. 그런데 여기서 문제가 발생하곤 해요. 어떤 클러스터는 잘 동기화(SYNCED)되는데, 다른 클러스터는 계속 OutOfSync 상태이거나 Failed 상태를 벗어나지 못하는 거죠. “아니, 분명 다 똑같이 설정했는데 왜 이럴까?” 하는 생각이 절로 듭니다. 저도 처음엔 정말 막막했는데, 몇 가지 공통적인 원인이 있더라고요. 😅

    Argo CD UI의 ApplicationSet 대시보드: 문제 발생 상황

    Argo CD UI의 ApplicationSet 대시보드: 여러 클러스터에 배포된 애플리케이션들의 동기화 상태를 한눈에 볼 수 있으며, 문제가 발생한 애플리케이션을 쉽게 식별할 수 있습니다.

    ⚠️ 실제 운영 사례로 본 Argo CD 동기화 문제와 디버깅 팁

    제가 13년 동안 쌓은 삽질 경험을 바탕으로, Argo CD 멀티 클러스터 환경에서 자주 발생하는 동기화 문제와 그 해결책을 알려드릴게요. 하나씩 체크하다 보면 분명 원인을 찾을 수 있을 겁니다!

    1. RBAC (Role-Based Access Control) 권한 문제
      가장 흔하면서도 놓치기 쉬운 문제예요. Argo CD 컨트롤 플레인이 관리 대상 클러스터에 배포할 권한이 없는 경우입니다. argocd cluster add 명령어가 자동으로 필요한 권한을 생성해주지만, 간혹 수동으로 클러스터를 추가했거나, 보안 정책상 특정 권한이 누락된 경우가 있거든요.

      💡 디버깅 팁:

      • 관리 대상 클러스터에서 kubectl get serviceaccount argocd-manager -n argocd 명령어로 argocd-manager ServiceAccount가 잘 생성되었는지 확인하세요.
      • 이 ServiceAccount에 연결된 ClusterRoleBinding과 ClusterRole의 권한을 확인해보세요. 보통 cluster-admin 권한이 부여되는데, 만약 특정 리소스에 대한 권한만 있다면 해당 리소스 배포가 실패할 수 있거든요. kubectl describe clusterrole argocd-manager-role 명령으로 권한 목록을 볼 수 있습니다.
      • 특히 ServiceAccount가 아닌 다른 방식으로 인증(예: kubeconfig 파일)을 사용한다면, 해당 kubeconfig 파일에 정의된 사용자에게 충분한 권한이 있는지 확인해야 합니다.
    2. 네트워크 연결 문제
      Argo CD 서버가 관리 대상 클러스터의 쿠버네티스 API 서버에 접근할 수 없는 경우네요. 방화벽, VPN, VPC 피어링 등 네트워크 구성을 꼼꼼히 확인해야 합니다. “어제까진 잘 됐는데?” 하다가 네트워크 변경 때문에 막히는 경우가 꽤 있거든요.

      💡 디버깅 팁:

      • Argo CD UI에서 해당 클러스터의 상태가 Unavailable인지 확인하세요.
      • Argo CD 컨트롤러 파드(Pod)에서 관리 대상 클러스터의 API 서버로 curl 같은 명령어로 접속을 시도해보세요. 파드에 접속하는 방법은 kubectl exec -it <argocd-repo-server-pod> -n argocd -- bash 후 curl -k https://<cluster-api-server-ip>:<port>/healthz 와 같이 시도해볼 수 있습니다.
      • argocd cluster add 시 입력한 API 서버 주소가 올바른지 다시 한번 확인해보세요. 내부망 주소여야 할 때 외부망 주소를 입력하거나, 그 반대인 경우도 있거든요.
    3. ApplicationSet 설정 오류
      ApplicationSet의 generator나 template 설정이 잘못된 경우예요. 특히 cluster 필터링이나 Git 저장소 경로(path)를 잘못 지정했을 때 문제가 발생하곤 합니다.

      💡 디버깅 팁:

      • argocd appset get <application-set-name> 명령으로 ApplicationSet의 현재 상태와 생성된 Application 목록을 확인해보세요.
      • ApplicationSet의 template 섹션에서 source.path가 Git 저장소의 실제 경로와 일치하는지 확인하세요. 대소문자나 오타가 있을 수 있거든요.
      • generator에서 특정 클러스터만 선택하도록 설정했다면, 해당 클러스터의 라벨(labels)이 selector와 정확히 일치하는지 확인해보세요.
    4. 배포하려는 리소스 매니페스트 오류
      Git 저장소에 있는 쿠버네티스 매니페스트(YAML 파일) 자체에 문제가 있는 경우네요. 문법 오류, 잘못된 필드 이름, 존재하지 않는 StorageClass 참조 등이 있을 수 있거든요.

      💡 디버깅 팁:

      • Argo CD UI에서 Application 상태를 확인하고, Events(이벤트) 탭이나 Logs(로그) 탭을 자세히 살펴보세요. 어떤 리소스에서 어떤 에러가 발생했는지 상세하게 나옵니다. 예를 들어, "admission webhook denied the request" 같은 메시지는 Admission Controller(어드미션 컨트롤러)나 OPA Gatekeeper 같은 정책 엔진에 의해 배포가 거부되었음을 의미할 수 있어요.
      • 해당 클러스터에 직접 kubectl apply -f <problematic-manifest.yaml> --dry-run=client 로 배포를 시도하여 문법 오류 등을 미리 확인해보세요.
      • kubectl describe <resource-type> <resource-name> -n <namespace> 명령으로 대상 클러스터에 배포된(혹은 배포 실패한) 리소스의 상세 상태를 확인하세요.
    5. Argo CD 컨트롤러 파드 문제
      아주 드물지만, Argo CD 자체의 argocd-application-controller나 argocd-repo-server 파드에 문제가 생겨 동기화가 제대로 작동하지 않을 수 있어요. 리소스 부족, 네트워크 문제, 버그 등이 원인일 수 있거든요.

      💡 디버깅 팁:

      • kubectl get pods -n argocd 명령으로 Argo CD 관련 파드들이 모두 Running 상태인지 확인해보세요.
      • 문제 있어 보이는 파드의 로그를 확인해보세요: kubectl logs -f <argocd-pod-name> -n argocd. 특히 argocd-application-controller 로그에 동기화 관련 오류 메시지가 나타날 수 있거든요.
      • 파드를 재시작하거나, 리소스(CPU, Memory)를 늘려주는 것도 방법이 될 수 있습니다.

    ✅ 문제 해결 후 검증하기

    위의 팁들을 바탕으로 문제를 해결했다면, 이제 제대로 동기화가 되는지 확인해야겠죠? 드디어 SYNCED 상태를 봤을 때의 그 쾌감이란! 🎉

    1. Argo CD UI/CLI 확인
      가장 먼저 Argo CD UI에 접속해서 해당 Application 또는 ApplicationSet의 상태가 Synced 그리고 Healthy로 표시되는지 확인합니다. CLI를 선호한다면 argocd app list 나 argocd app get <application-name> 명령어를 사용해보세요.

    2. 대상 클러스터 직접 확인
      Argo CD UI/CLI에서 Synced로 표시되더라도, 혹시 모르니 해당 클러스터에 접속해서 kubectl get <resource-type> -n <namespace> 명령으로 실제로 리소스가 배포되었는지, 상태는 어떤지 직접 확인하는 게 좋습니다. 특히 Deployment나 StatefulSet의 파드들이 정상적으로 Running 상태인지 확인해 주세요.

    3. 새로운 변경사항 푸시 테스트
      Git 저장소에 간단한 변경사항(예: ConfigMap 내용 변경)을 푸시해서 Argo CD가 변경을 감지하고 자동으로 동기화하는지 확인해봅니다. 이 과정이 원활하게 진행된다면 성공적으로 문제를 해결한 거예요!

    Argo CD UI의 성공적인 동기화 대시보드

    성공적인 Argo CD 동기화 대시보드: 모든 애플리케이션이 문제없이 배포되고 동기화되어 안정적인 운영 상태를 보여줍니다.

    마무리하며: 삽질은 경험이 되고, 경험은 자산이 됩니다.

    오늘은 Argo CD 멀티 클러스터 동기화 문제 해결에 대한 저의 경험과 디버깅 팁을 공유해드렸습니다. 솔직히 저도 처음엔 정말 막막해서 밤늦게까지 삽질 좀 했거든요. “왜 안 되는 거지?” 하면서 클러스터 여기저기를 들쑤시고 다녔던 기억이 생생해요. 😂

    하지만 이런 삽질 과정이 결국 저의 노하우가 되고, 여러분 같은 동료 인프라 엔지니어분들께 도움이 되는 자산이 된다는 사실을 깨달았습니다. Argo CD는 정말 강력한 툴이지만, 그만큼 복잡한 환경에서는 예상치 못한 문제들이 발생할 수 있어요. 중요한 건 문제를 만났을 때 당황하지 않고, 차근차근 원인을 찾아 해결해나가는 자세라고 생각합니다.

    이번 글이 Argo CD 멀티 클러스터 환경에서 고군분투하는 분들께 조금이나마 도움이 되었기를 바랍니다. 다음 글에서는 Argo CD의 Progressive Delivery(점진적 배포) 전략인 Argo Rollouts에 대해 다뤄볼게요. 그때까지 GitOps 즐겁게 운영하시길 바랍니다! 궁금한 점이 있다면 언제든 댓글 남겨주세요! 😊

    Argo CD 멀티 클러스터 동기화 문제 해결 체크리스트: RBAC, 네트워크, ApplicationSet 설정, 매니페스트 오류, Argo CD 파드 상태 등 주요 점검 사항을 요약한 인포그래픽입니다.

  • [k8s] Kubernetes 스토리지: Longhorn vs Rook-Ceph 성능 벤치마크

    [k8s] Kubernetes 스토리지: Longhorn vs Rook-Ceph 성능 벤치마크

    안녕하세요, 13년차 서버실 지킴이입니다. 🤓

    Kubernetes(쿠버네티스) 환경에서 애플리케이션을 운영하다 보면, 영구 스토리지(Persistent Storage)의 중요성을 정말 뼈저리게 느끼게 됩니다. Pod(파드)가 재시작되거나 다른 노드로 옮겨가도 데이터는 안전하게 보존되어야 하니까요. 특히 저처럼 홈랩(Homelab)에서 이것저것 실험하며 삽질을 즐기는 사람이라면, 안정적이고 성능 좋은 스토리지를 찾는 데 꽤 많은 시간을 투자하게 되죠. 저도 그랬거든요! 🤔

    오늘은 제가 직접 홈랩에서 Longhorn(롱혼)과 Rook-Ceph(룩-세프) 두 가지 Kubernetes 영구 스토리지 솔루션을 설치하고, FIO(Flexible I/O Tester) 벤치마크 툴로 성능을 비교해본 경험을 공유해드리려고 합니다. 과연 어떤 녀석이 제 환경에 더 적합했을까요? 저의 삽질 여정을 따라오시면서 여러분의 Kubernetes 스토리지 선택에 도움이 되시길 바랍니다!

    왜 영구 스토리지가 필요할까요?

    Kubernetes는 기본적으로 컨테이너화된 애플리케이션을 배포하고 관리하는 데 최적화되어 있어요. 그런데 컨테이너는 휘발성(ephemeral)이라는 특징을 가지고 있거든요. 즉, 컨테이너가 죽거나 재시작되면 그 안에 저장된 데이터는 사라져 버린다는 뜻이죠. 데이터베이스나 파일 서버처럼 데이터를 영구적으로 보관해야 하는 애플리케이션에는 치명적일 수 있습니다.

    이런 문제를 해결하기 위해 Kubernetes에서는 영구 볼륨(Persistent Volume, PV)과 영구 볼륨 클레임(Persistent Volume Claim, PVC)이라는 개념을 도입했어요. 쉽게 말해, 스토리지 시스템으로부터 저장 공간을 할당받아 Pod가 데이터를 안정적으로 쓰고 읽을 수 있게 해주는 기능이라고 보시면 됩니다. 그리고 이런 영구 볼륨을 동적으로 프로비저닝(provisioning)해주는 역할을 하는 것이 바로 CSI(Container Storage Interface) 드라이버를 기반으로 하는 분산 스토리지 솔루션들이죠. 오늘 다룰 Longhorn과 Rook-Ceph가 바로 그런 친구들입니다.

    Kubernetes 영구 스토리지 아키텍처 개요

    Kubernetes 클러스터에서 영구 스토리지가 어떻게 작동하는지 대략적인 아키텍처를 그려봤어요. Pod가 PVC를 요청하면, CSI 드라이버가 백엔드 스토리지 시스템에 PV를 생성하고 Pod에 연결해주는 방식이죠. 이 과정에서 Longhorn이나 Rook-Ceph 같은 분산 스토리지 솔루션이 그 백엔드 역할을 하는 겁니다.

    Longhorn과 Rook-Ceph, 넌 누구니?

    본격적인 벤치마크에 앞서, 두 솔루션에 대해 간략하게 알아볼까요? 저도 처음엔 이름만 듣고 뭐가 뭔지 헷갈렸거든요. 😅

    Longhorn (롱혼)

    • 특징: Rancher Labs에서 개발한 오픈소스 분산 블록 스토리지 솔루션이에요. Kubernetes 위에서 컨테이너 형태로 동작하며, 각 노드의 로컬 스토리지를 모아 분산 볼륨을 생성합니다. CSI 드라이버를 기본으로 제공해서 Kubernetes와 통합이 정말 쉬워요. 제가 직접 써보니, 설치도 비교적 간단하고 웹 UI가 직관적이어서 관리하기 편하더라고요. 홈랩이나 소규모 환경에 많이 추천되는 이유를 알겠더군요.
    • 장점: 가벼움, 설치 및 관리 용이, 스냅샷/백업/복원 기능 내장, DR(재해 복구) 지원.

    Rook-Ceph (룩-세프)

    • 특징: Rook는 Kubernetes 네이티브 스토리지 오케스트레이터이고, Ceph(세프)는 강력하고 성숙한 오픈소스 분산 스토리지 시스템이에요. Rook는 Ceph를 Kubernetes 클러스터 위에 배포하고 관리하는 오퍼레이터(Operator) 역할을 합니다. 오브젝트 스토리지(Object Storage), 블록 스토리지(Block Storage), 파일 스토리지(File Storage)를 모두 지원하는 만능 재주꾼이죠. 다만, Ceph 자체가 워낙 복잡한 시스템이라 Rook를 통해 배포해도 초기 설정과 관리에 공수가 좀 들어가는 편이에요. 대규모 프로덕션 환경에서 많이 사용됩니다.
    • 장점: 뛰어난 확장성, 높은 가용성, 다양한 스토리지 타입 지원, 강력한 성능(하드웨어에 따라).

    두 솔루션의 주요 특징을 표로 정리해봤어요.

    구분 Longhorn Rook-Ceph
    개발사/기반 Rancher Labs / 분산 블록 스토리지 Rook (오퍼레이터) + Ceph (분산 스토리지)
    스토리지 타입 블록 스토리지 블록, 오브젝트, 파일 스토리지
    설치 난이도 쉬움 (Helm) 중간 ~ 어려움 (kubectl apply)
    관리 UI 직관적인 웹 UI Ceph Dashboard (별도 설치), Grafana 연동
    확장성 중간 (수십 TB 규모) 매우 높음 (페타바이트 규모)
    주요 사용처 홈랩, 소규모 개발/테스트, 엣지 컴퓨팅 대규모 프로덕션, 클라우드 인프라

    벤치마크 환경 구축하기

    저의 홈랩 환경은 다음과 같았습니다. 실제 벤치마크 결과는 하드웨어 스펙, 네트워크 환경, Kubernetes 설정 등에 따라 크게 달라질 수 있다는 점을 미리 말씀드려요! ⚠️

    • Kubernetes Cluster: 3 Node (1 Master, 2 Worker)
    • OS: Ubuntu Server 22.04 LTS
    • CPU: Intel i5-10400 (각 노드당 6코어 12스레드)
    • RAM: 32GB (각 노드당)
    • Storage: NVMe SSD 500GB (각 노드당, 스토리지용으로 할당)
    • Network: 1Gbps Ethernet

    벤치마크 툴로는 FIO (Flexible I/O Tester)를 사용했어요. FIO는 디스크 I/O 성능을 측정하는 데 널리 사용되는 강력한 도구예요. 순차 읽기/쓰기, 랜덤 읽기/쓰기 등 다양한 패턴으로 I/O를 발생시켜 실제 워크로드와 유사한 환경을 만들 수 있거든요.

    Longhorn 설치 및 설정

    Longhorn은 Helm(헬름) 차트를 이용하면 정말 쉽게 설치할 수 있어요. 저도 처음엔 혹시나 복잡할까 봐 걱정했는데, 생각보다 너무 간단해서 놀랐어요. 🎉

    1. Helm Repository 추가:
      helm repo add longhorn https://charts.longhorn.io
      helm repo update
      
    2. Longhorn 설치: (기본 설정으로 설치했습니다)
      helm install longhorn longhorn/longhorn --namespace longhorn-system --create-namespace
      
    3. Longhorn UI 접속:

      설치가 완료되면, Longhorn UI에 접속할 수 있도록 Ingress(인그레스, 외부 트래픽 진입점)나 NodePort(노드포트)를 설정해줘요. 저는 간단하게 NodePort로 열어서 접속했어요.

      kubectl -n longhorn-system get svc longhorn-frontend
      # 출력되는 NodePort를 확인하여 접속
      
    4. StorageClass 확인 및 볼륨 생성:

      Longhorn이 설치되면 기본적으로 longhorn이라는 StorageClass(스토리지클래스)가 생성돼요. 이걸 이용해서 PVC를 생성하고 Pod에 마운트하면 끝입니다.

      apiVersion: v1
      kind: PersistentVolumeClaim
      metadata:
        name: longhorn-pvc
      spec:
        accessModes:
          - ReadWriteOnce
        storageClassName: longhorn
        resources:
          requests:
            storage: 10Gi
      

    Longhorn 웹 UI에 접속하면 현재 클러스터의 스토리지 상태, 노드별 디스크 사용량, 볼륨 목록 등을 한눈에 확인할 수 있어요. 시각적으로 깔끔하고 직관적이라서 관리하기 정말 편하더라고요. 💡

    Longhorn 웹 UI 대시보드 화면

    Longhorn 대시보드 화면이에요. 생성된 볼륨, 노드의 스토리지 상태 등을 쉽게 확인할 수 있어요.

    Rook-Ceph 설치 및 설정

    Rook-Ceph는 Longhorn보다 설정할 부분이 많아서, 처음엔 “이게 다 뭔가…” 싶었어요. 하지만 공식 문서(Official Documentation)를 차근차근 따라가면 충분히 설치할 수 있어요. 저는 helm 대신 kubectl apply -f 방식으로 진행했습니다.

    1. Rook Operator 배포:

      먼저 Rook Operator를 배포해요. 이 오퍼레이터가 Ceph 클러스터를 관리하는 역할을 합니다.

      git clone --single-branch --branch v1.11.x https://github.com/rook/rook.git
      cd rook/deploy/examples
      kubectl create -f crds.yaml -f common.yaml -f operator.yaml
      
    2. Ceph Cluster 배포:

      Ceph 클러스터를 배포해요. 이 과정에서 어떤 디스크를 Ceph 스토리지로 사용할지 지정해줘야 해요. 저는 각 워커 노드의 NVMe SSD를 사용하도록 설정했습니다.

      kubectl create -f cluster.yaml
      

      cluster.yaml 파일에서 storage 섹션에 useAllNodes: true와 useAllDevices: true를 설정하여 모든 노드의 모든 디바이스를 사용하도록 했어요. 실제 운영 환경에서는 특정 디스크만 사용하도록 명시하는 것이 좋습니다.

    3. Ceph Block Pool 및 StorageClass 생성:

      Ceph 클러스터가 안정화되면, 블록 스토리지를 위한 CephBlockPool(세프 블록 풀)과 StorageClass를 생성해요.

      kubectl create -f csi/rbd/storageclass.yaml
      

      storageclass.yaml 파일은 다음과 비슷하게 생겼을 겁니다.

      apiVersion: ceph.rook.io/v1
      kind: CephBlockPool
      metadata:
        name: replicapool
        namespace: rook-ceph
      spec:
        failureDomain: host
        replicated:
          size: 3 # 데이터 복제본 수
      ---
      apiVersion: storage.k8s.io/v1
      kind: StorageClass
      metadata:
        name: rook-ceph-block
      provisioner: rook-ceph.rbd.csi.ceph.com
      parameters:
        clusterID: rook-ceph
        pool: replicapool
        imageFormat: "2"
        imageFeatures: "layering"
        csi.storage.k8s.io/provisioner-secret-name: rook-csi-rbd-provisioner
        csi.storage.k8s.io/provisioner-secret-namespace: rook-ceph
        csi.storage.k8s.io/node-stage-secret-name: rook-csi-rbd-node
        csi.storage.k8s.io/node-stage-secret-namespace: rook-ceph
      reclaimPolicy: Delete
      allowVolumeExpansion: true
      mountOptions:
        - discard
      
    4. PVC 생성:

      Longhorn과 마찬가지로, 생성된 rook-ceph-block StorageClass를 이용해 PVC를 생성해요.

      apiVersion: v1
      kind: PersistentVolumeClaim
      metadata:
        name: rook-ceph-pvc
      spec:
        accessModes:
          - ReadWriteOnce
        storageClassName: rook-ceph-block
        resources:
          requests:
            storage: 10Gi
      
    Rook-Ceph on Kubernetes 클러스터 구성도

    Rook-Ceph 클러스터의 내부 구성도예요. Ceph의 여러 구성요소(MON, OSD, MGR)가 Pod 형태로 Kubernetes 클러스터 위에서 동작하는 것을 볼 수 있어요.

    FIO 벤치마크 실행 및 결과 분석

    두 스토리지 솔루션의 PVC를 각각 생성한 후, FIO를 실행할 Pod를 띄워 벤치마크를 진행했어요. 저는 주로 랜덤 읽기/쓰기(Random Read/Write)와 순차 읽기/쓰기(Sequential Read/Write) 성능을 중점적으로 살펴봤습니다. 블록 크기(Block Size)는 4KB와 1MB로 다양하게 테스트해봤거든요.

    FIO Pod를 위한 YAML 예시예요. 이 Pod가 PVC를 마운트하여 FIO 테스트를 수행합니다.

    apiVersion: v1
    kind: Pod
    metadata:
      name: fio-test-pod
    spec:
      restartPolicy: Never
      containers:
      - name: fio-container
        image: ghcr.io/fio/fio:latest # FIO 이미지를 사용합니다.
        command: ["/bin/bash", "-c"]
        args:
          - |
            mkdir -p /mnt/data
            fio --name=random-write --ioengine=libaio --iodepth=64 --rw=randwrite --bs=4k --size=1G --numjobs=1 --runtime=60 --group_reporting --filename=/mnt/data/testfile
            fio --name=random-read --ioengine=libaio --iodepth=64 --rw=randread --bs=4k --size=1G --numjobs=1 --runtime=60 --group_reporting --filename=/mnt/data/testfile
            fio --name=sequential-write --ioengine=libaio --iodepth=16 --rw=write --bs=1M --size=2G --numjobs=1 --runtime=60 --group_reporting --filename=/mnt/data/testfile_seq
            fio --name=sequential-read --ioengine=libaio --iodepth=16 --rw=read --bs=1M --size=2G --numjobs=1 --runtime=60 --group_reporting --filename=/mnt/data/testfile_seq
        volumeMounts:
        - name: test-volume
          mountPath: /mnt/data
      volumes:
      - name: test-volume
        persistentVolumeClaim:
          claimName: longhorn-pvc # 또는 rook-ceph-pvc
    

    여러 번의 테스트를 통해 제가 관찰한 결과는 대략 이랬어요. (⚠️ 이 수치는 제 특정 홈랩 환경에서 얻은 결과이며, 환경에 따라 크게 달라질 수 있음을 다시 한번 강조합니다!)

    테스트 항목 (4KB BS) Longhorn (평균) Rook-Ceph (평균) 비고
    랜덤 쓰기 IOPS 약 1,500 ~ 2,500 약 3,000 ~ 5,000 Rook-Ceph가 우위
    랜덤 쓰기 대역폭 (MB/s) 약 6 ~ 10 약 12 ~ 20 Rook-Ceph가 우위
    랜덤 읽기 IOPS 약 2,000 ~ 3,500 약 4,000 ~ 6,500 Rook-Ceph가 우위
    랜덤 읽기 대역폭 (MB/s) 약 8 ~ 14 약 16 ~ 26 Rook-Ceph가 우위
    테스트 항목 (1MB BS) Longhorn (평균) Rook-Ceph (평균) 비고
    순차 쓰기 대역폭 (MB/s) 약 80 ~ 120 약 150 ~ 250 Rook-Ceph가 우위
    순차 읽기 대역폭 (MB/s) 약 100 ~ 150 약 200 ~ 300 Rook-Ceph가 우위

    결과를 보면, 제 홈랩 환경에서는 Rook-Ceph가 전반적으로 Longhorn보다 더 높은 IOPS와 대역폭 성능을 보여줬어요. 특히 작은 블록 크기의 랜덤 I/O에서 Ceph의 강점이 두드러지더라고요. Longhorn은 복제본(replica) 수가 늘어날수록 성능 하락이 좀 더 눈에 띄는 경향이 있었고, Ceph는 안정적으로 성능을 유지했습니다.

    Longhorn과 Rook-Ceph FIO 벤치마크 결과 비교 그래프

    Longhorn과 Rook-Ceph의 FIO 벤치마크 결과를 시각적으로 비교한 그래프예요. Rook-Ceph가 전반적으로 높은 성능을 보였습니다.

    삽질 경험과 트러블슈팅 ⚠️

    솔직히 말씀드리면, 순조롭게만 진행된 건 아니었어요. 삽질 좀 했습니다 ㅎㅎ. 몇 가지 기억에 남는 경험을 공유해볼게요.

    • Longhorn: 네트워크 대역폭과 복제본 수
      처음 Longhorn을 설치하고 테스트했을 때, 생각보다 성능이 안 나와서 당황했어요. 알고 보니, Longhorn은 네트워크를 통해 볼륨 데이터를 복제(replication)하기 때문에, 노드 간 네트워크 대역폭이 정말 중요하더라고요. 제 1Gbps 네트워크 환경에서는 복제본 수를 3개로 설정했을 때 쓰기 성능이 꽤 많이 떨어지는 것을 확인했어요. 복제본 수가 늘어날수록 안정성은 높아지지만, 그만큼 네트워크 오버헤드(overhead)가 커져서 성능에 영향을 미친다는 점! 홈랩에서는 2개로 줄여서 사용하니 훨씬 나아졌습니다.
    • Rook-Ceph: OSD 인식 문제와 초기 설정
      Rook-Ceph는 초기 설정이 Longhorn보다 훨씬 복잡했어요. 특히 OSD(Object Storage Daemon)가 디스크를 제대로 인식하지 못해서 한참을 헤맸거든요. 디스크가 이미 파티셔닝(partitioning)되어 있거나, 이전에 다른 용도로 사용된 흔적이 남아있으면 Rook-Ceph가 제대로 디스크를 잡지 못하는 경우가 있더라고요. ceph-volume lvm zap --destroy /dev/sdX 같은 명령어로 디스크를 완전히 초기화해주거나, lsblk -f 명령어로 디스크의 파일 시스템(filesystem) 정보를 꼼꼼히 확인해서 해결했어요. Ceph의 CRD(Custom Resource Definition)와 설정 파일에 대한 이해가 필요하다는 것을 다시 한번 깨달았습니다.

    결론 및 선택 가이드

    제 홈랩 벤치마크 경험을 바탕으로 Longhorn과 Rook-Ceph에 대한 저의 생각을 정리해봤어요.

    솔루션 장점 단점 추천 시나리오
    Longhorn
    • 설치 및 관리가 매우 쉬움
    • 직관적인 웹 UI 제공
    • 스냅샷, 백업, 재해 복구 기능 내장
    • 가벼운 리소스 사용
    • 네트워크 대역폭에 민감 (복제본 수 증가 시)
    • Rook-Ceph 대비 낮은 최대 성능
    • 블록 스토리지에 한정
    • 홈랩, 개발/테스트 환경
    • 소규모 프로덕션 (수십 TB 이하)
    • 간편한 관리와 사용성을 중시할 때
    Rook-Ceph
    • 최고 수준의 성능 (적절한 하드웨어 시)
    • 뛰어난 확장성 (페타바이트 규모)
    • 블록, 오브젝트, 파일 스토리지 모두 지원
    • 엔터프라이즈급 안정성과 기능
    • 설치 및 설정 난이도가 높음
    • 초기 학습 곡선이 김
    • 상대적으로 많은 리소스 사용
    • 문제 발생 시 트러블슈팅 복잡
    • 대규모 프로덕션 환경
    • 고성능, 고가용성이 필수적인 경우
    • 다양한 스토리지 타입이 필요한 경우

    제 홈랩에서는 아무래도 설치 및 관리의 용이성 때문에 Longhorn에 손이 더 자주 가더라고요. 하지만 성능 자체만 놓고 본다면 Rook-Ceph가 확실히 우위를 점했어요. 결국 어떤 Kubernetes 스토리지 솔루션을 선택할지는 여러분의 환경과 요구사항에 따라 달라진다는 것이 저의 결론입니다.

    여러분도 직접 설치해보시고, 여러분의 워크로드에 맞는 벤치마크를 수행해보시면 좋은 인사이트를 얻으실 수 있을 거예요. 저의 삽질 경험이 여러분의 시행착오를 조금이나마 줄여줄 수 있다면 좋겠습니다! 😊

    다음 글에서는 Kubernetes에서 Grafana(그라파나)와 Prometheus(프로메테우스)를 이용해 스토리지 성능을 모니터링하는 방법에 대해 다뤄볼 예정이에요. 기대해주세요!

    Longhorn과 Rook-Ceph 중 어떤 솔루션이 당신에게 맞을지 요약한 인포그래픽입니다.

  • [k8s] Argo CD 멀티 클러스터 GitOps 베스트 프랙티스 체크리스트

    [k8s] Argo CD 멀티 클러스터 GitOps 베스트 프랙티스 체크리스트

    Argo CD 멀티 클러스터 GitOps 베스트 프랙티스 체크리스트

    안녕하세요, 13년차의 서버실 운영자입니다. 오늘은 제가 홈랩과 회사에서 Argo CD 멀티 클러스터 환경을 구축하면서 겪었던 일들과, 여러분이 효율적인 GitOps 베스트 프랙티스를 적용할 수 있도록 돕는 GitOps 체크리스트를 공유해드리려고 합니다.

    요즘 Kubernetes 다중 클러스터 관리는 선택이 아니라 필수가 되어가고 있죠. 개발, 스테이징, 프로덕션 환경이 따로 있거나, DR(재해 복구)을 위해 여러 리전에 클러스터를 두는 경우가 많습니다. 근데 이 클러스터들을 일일이 관리하는 게 보통 일이 아니더라고요. 직접 해보니 삽질 좀 했습니다. (ㅎㅎ)

    이런 고민을 하시는 분들을 위해, Argo CD를 활용한 멀티 클러스터 GitOps의 개념부터 실전 전략, 그리고 제가 직접 겪었던 트러블슈팅 경험까지 솔직하게 풀어보겠습니다. 이 글을 통해 여러분의 Argo CD 배포 전략이 한층 더 견고해지길 바랍니다. 드디어 배포가 편해지는 그 날을 위해!

    Argo CD 멀티 클러스터 GitOps 아키텍처 다이어그램

    Argo CD를 이용한 멀티 클러스터 GitOps의 전체 아키텍처는 위 그림처럼 구성할 수 있습니다. 중앙의 Argo CD가 여러 클러스터를 관리하는 형태죠.

    Argo CD와 GitOps, 그리고 멀티 클러스터 관리 핵심 개념

    우선, 핵심 개념부터 쉽고 편하게 짚고 넘어가 볼까요? 제가 처음 Argo CD를 접했을 때를 생각하면서 설명해 드릴게요.

    GitOps: Git이 진리의 원천입니다

    GitOps(깃옵스)는 말 그대로 Git을 운영(Operations)의 중심으로 삼는 방식입니다. 모든 인프라와 애플리케이션의 상태를 Git 리포지토리에 선언적으로 정의하고, 이 Git 리포지토리의 변경사항이 자동으로 실제 환경에 반영되도록 하거든요. 쉽게 말해, kubectl apply -f를 사람이 직접 하는 게 아니라, Git에 커밋만 하면 시스템이 알아서 해주는 거죠. 제가 처음 이걸 알았을 때, ‘와, 이거 진짜 편하겠다!’ 싶었어요.

    GitOps의 장점은 명확합니다:

    • 버전 관리(Version Control): 모든 변경 이력을 Git에서 확인할 수 있어요. 누가 언제 뭘 바꿨는지 투명하게 알 수 있죠.
    • 자동화(Automation): 수동 작업이 줄어들어 휴먼 에러를 최소화하고, 배포 속도를 높일 수 있습니다.
    • 복원력(Resilience): 문제가 발생하면 Git의 이전 상태로 쉽게 롤백(Rollback)할 수 있습니다.
    • 협업(Collaboration): 개발팀과 운영팀이 Git을 통해 더 효율적으로 협업할 수 있습니다.

    Argo CD: GitOps를 Kubernetes에 현실로 만들어주는 도구

    그럼 Argo CD(아르고 CD)는 뭘까요? Argo CD는 선언적(Declarative) GitOps 지속적 배포(Continuous Delivery) 도구거든요. Kubernetes(쿠버네티스) 애플리케이션의 배포와 라이프사이클 관리를 Git에서 정의된 상태에 따라 자동으로 동기화(Sync)해주는 역할을 해요. 제가 써보니까, 복잡한 배포 파이프라인을 구축하는 수고를 엄청나게 덜어주더라고요.

    멀티 클러스터 관리: 복잡성을 단순화하기

    여러 개의 Kubernetes 클러스터를 관리하는 건 마치 여러 대의 서버를 손으로 직접 관리하는 것과 비슷해요. 하나만 관리할 때는 괜찮지만, 두 개, 세 개… 점점 늘어나면 감당하기 어려워집니다. Kubernetes 다중 클러스터 관리는 이런 복잡성을 줄이고 일관성을 유지하기 위한 전략이 필요해요. Argo CD는 이 문제를 ApplicationSet(애플리케이션셋)이라는 기능을 통해 아주 우아하게 해결해 줍니다. 처음엔 이게 뭔가 싶었는데, 써보니 진짜 물건이더라고요!

    실전 구현: Argo CD 멀티 클러스터 환경 설정 베스트 프랙티스

    이제 이론을 바탕으로 실제로 어떻게 구성하는지 알아볼 시간입니다. 제가 홈랩에서 여러 시도를 해보고, 회사에서 적용하면서 얻은 노하우들을 풀어드릴게요.

    1. Argo CD Control Plane 설치

    먼저, Argo CD가 설치될 메인 클러스터, 즉 Control Plane(컨트롤 플레인) 클러스터가 필요합니다. 이곳에서 모든 배포를 관장하게 됩니다. 기본적인 Argo CD 설치는 공식 문서에 잘 나와 있는데, 간단히 요약해볼게요.

    
    kubectl create namespace argocd
    kubectl apply -n argocd -f https://raw.githubusercontent.com/argoproj/argo-cd/stable/manifests/install.yaml
    

    설치 후에는 Argo CD UI에 접속하여 초기 비밀번호를 설정하고 로그인할 수 있습니다.

    2. Managed Clusters(관리 대상 클러스터) 등록

    다음으로, Argo CD가 관리할 다른 Kubernetes 클러스터들을 등록해야 합니다. 저는 개발, 스테이징, 프로덕션 클러스터를 각각 등록했거든요. Argo CD는 kubectl 명령어를 통해 쉽게 클러스터를 등록할 수 있도록 해줍니다.

    
    # 먼저 Argo CD CLI를 설치합니다.
    brew install argocd # macOS 기준
    
    # Argo CD API 서버에 로그인합니다.
    argocd login <ARGOCD_SERVER_IP_OR_HOSTNAME>
    
    # 관리 대상 클러스터의 kubeconfig 컨텍스트로 전환합니다.
    kubectl config use <MANAGED_CLUSTER_CONTEXT_NAME>
    
    # 현재 컨텍스트의 클러스터를 Argo CD에 등록합니다.
    argocd cluster add <MANAGED_CLUSTER_CONTEXT_NAME>
    

    이 명령어를 실행하면 Argo CD가 해당 클러스터에 필요한 RBAC(Role-Based Access Control) 권한을 자동으로 설정하고, 클러스터를 관리 목록에 추가합니다. 이게 정말 편리하더라고요. 제가 일일이 RBAC을 설정할 필요가 없어서 좋았어요.

    Argo CD UI에서 여러 Kubernetes 클러스터가 관리되는 모습

    Argo CD UI에 접속하면 이렇게 등록된 여러 클러스터들이 한눈에 보입니다. 각 클러스터의 상태도 직관적으로 확인할 수 있죠.

    3. ApplicationSet 활용: 멀티 클러스터 배포의 꽃!

    수동으로 각 클러스터에 Application(애플리케이션)을 생성하는 건 비효율적입니다. 여기서 ApplicationSet이 빛을 발합니다. ApplicationSet은 여러 클러스터에 동일하거나 유사한 형태의 Application을 자동으로 생성해주는 CRD(Custom Resource Definition)거든요. 제가 처음엔 Application을 복사 붙여넣기 했었는데, ApplicationSet을 알고 나서는 ‘아, 이래서 쓰는구나!’ 하고 무릎을 탁 쳤습니다.

    ApplicationSet을 사용하면 Git 리포지토리의 특정 경로에 있는 매니페스트를 여러 클러스터에 배포하거나, 클러스터 이름에 따라 다른 설정 값을 주입하는 등의 고급 배포 전략을 구현할 수 있습니다.

    예시 YAML 코드를 한번 볼까요? 저는 Git 제너레이터를 이용해서 특정 Git 경로의 폴더들을 클러스터로 배포하는 방식을 즐겨 사용합니다.

    
    apiVersion: argoproj.io/v1alpha1
    kind: ApplicationSet
    metadata:
      name: my-multi-cluster-app
    spec:
      generators:
      - git:
          repoURL: https://github.com/my-org/my-gitops-repo.git
          revision: HEAD
          directories:
          - path: clusters/dev/*
          - path: clusters/stg/*
          - path: clusters/prod/*
      template:
        metadata:
          name: '{{path.basename}}-app'
          labels:
            app.kubernetes.io/managed-by: argocd
        spec:
          project: default
          source:
            repoURL: https://github.com/my-org/my-gitops-repo.git
            targetRevision: HEAD
            path: '{{path}}'
          destination:
            server: '{{path.basename | clusterServer}}' # 클러스터 이름에 따라 서버 URL 매핑
            namespace: default
          syncPolicy:
            automated:
              prune: true
              selfHeal: true
            syncOptions:
              - CreateNamespace=true
    

    위 예시에서는 clusters/dev, clusters/stg, clusters/prod 폴더 각각을 하나의 GitOps Application으로 인식하고, 해당 폴더 이름에 매핑되는 클러스터에 배포하도록 설정한 거예요. {{path.basename | clusterServer}}와 같은 템플릿 문법을 활용해서 클러스터의 서버 URL을 동적으로 주입할 수 있습니다. 물론 clusterServer 같은 함수는 직접 구현하거나, Argo CD의 List 제너레이터 등 다른 제너레이터를 활용하여 클러스터 정보를 직접 명시할 수도 있습니다.

    Argo CD 멀티 클러스터 GitOps 베스트 프랙티스 체크리스트

    이제 제가 경험하면서 중요하다고 느꼈던 Argo CD 멀티 클러스터 GitOps 베스트 프랙티스들을 체크리스트 형태로 정리해 보았습니다. 이대로만 따라 하셔도 웬만한 삽질은 피할 수 있을 거예요!

    1. ✅ 단일 Git 리포지토리(Single Source of Truth) 사용: 모든 클러스터와 애플리케이션의 상태는 하나의 Git 리포지토리에서 관리하는 것이 좋습니다. 폴더 구조를 잘 정리해서 혼란을 줄이세요. (예: repo/clusters/dev, repo/clusters/prod, repo/apps/my-app)
    2. ✅ ApplicationSet 적극 활용: 멀티 클러스터 배포의 핵심입니다. 클러스터별 배포, 환경별 차이점 관리 등을 ApplicationSet으로 자동화하세요.
    3. ✅ Helm(헬름) 또는 Kustomize(커스터마이즈)로 설정 관리: 환경(dev, stg, prod)별로 다른 설정이 필요할 때, Helm Values나 Kustomize Overlays를 사용하여 매니페스트의 차이를 관리합니다. 저는 Helm을 주로 사용하는데, 템플릿 기능이 강력해서 유연하게 대응할 수 있더라고요.
    4. ✅ RBAC(Role-Based Access Control) 최소 권한 원칙 준수: Argo CD 컨트롤 플레인과 각 관리 대상 클러스터 간의 통신 시, Argo CD가 필요한 최소한의 권한만 가지도록 RBAC을 설정해야 합니다. 보안은 아무리 강조해도 지나치지 않아요!
    5. ✅ Secret(시크릿) 관리 전략 수립: 민감 정보는 Git에 직접 올리지 않고, HashiCorp Vault, Sealed Secrets, External Secrets Operator 같은 도구를 사용하여 안전하게 관리해야 합니다.
    6. ✅ 자동 동기화(Automated Sync) 및 Self-Heal(자가 복구) 활성화: Git의 변경사항이 자동으로 클러스터에 반영되고, 클러스터의 상태가 Git과 다를 경우 자동으로 복구되도록 설정합니다. 이게 GitOps의 가장 큰 매력 중 하나죠.
    7. ✅ Rollback(롤백) 전략 수립 및 테스트: 문제가 발생했을 때 신속하게 이전 버전으로 롤백할 수 있도록 전략을 세우고, 실제 롤백 테스트를 주기적으로 수행하세요.
    8. ✅ 모니터링(Monitoring) 및 로깅(Logging) 구축: Argo CD의 상태, 배포 이력, 각 클러스터의 애플리케이션 상태 등을 모니터링하고 로깅 시스템에 연동하여 가시성을 확보해야 합니다. Prometheus(프로메테우스)와 Grafana(그라파나)는 국룰이죠.
    9. ✅ PreSync/PostSync Hooks(훅) 활용: 배포 전후에 특정 작업을 수행해야 할 경우, PreSync/PostSync Hooks를 사용하여 데이터베이스 마이그레이션이나 캐시 초기화 같은 작업을 자동화할 수 있습니다.

    ⚠️ 삽질 경험 & 트러블슈팅: 제가 겪었던 문제들

    13년차 엔지니어도 삽질은 피할 수 없는 운명입니다. 제가 Argo CD 멀티 클러스터를 구축하면서 겪었던 몇 가지 삽질과 해결책을 공유해 드릴게요.

    1. 네트워크 연결 문제: 방화벽은 항상 제 발목을 잡죠

    문제: Argo CD Control Plane에서 Managed Cluster로 접근이 안 되는 경우가 있었습니다. 클러스터가 다른 VPC나 다른 데이터센터에 있을 때 주로 발생하더라고요.

    해결: 뻔하지만 가장 중요한 건 방화벽(Firewall)과 네트워크 ACL(Access Control List) 설정입니다. Argo CD Control Plane이 Managed Cluster의 Kubernetes API 서버에 접근할 수 있도록 네트워크 경로를 열어줘야 합니다. 보통 443 포트를 사용하죠. 저는 보안 그룹 설정을 빼먹어서 한참 헤맸습니다. 😭

    2. RBAC 권한 부족: ‘Forbidden’ 메시지는 언제나 당황스럽습니다

    문제: Argo CD가 특정 클러스터에 애플리케이션을 배포하려는데 Forbidden 에러가 뜨는 경우가 있었습니다. ApplicationSet이 Application을 생성하지 못하거나, Application이 특정 리소스를 생성하지 못하는 상황이었죠.

    해결: Argo CD가 Managed Cluster에 설치하는 argocd-manager ServiceAccount(서비스 어카운트)의 RBAC 권한을 확인해야 합니다. ClusterRole 또는 Role이 필요한 verbs(get, list, watch, create, update, patch, delete)와 resources(pods, deployments, services 등)를 가지고 있는지 점검해야 합니다. 저는 CustomResourceDefinition(CRD)을 배포하려는데 권한이 없어서 한참 고생했어요. CRD는 특별한 권한이 필요하거든요.

    3. Sync Status ‘Out Of Sync’: Git과 실제 상태가 다를 때

    문제: Argo CD UI에서 분명히 Sync를 했는데 계속 Out Of Sync 상태로 남아있는 경우가 있었습니다. 특히 Helm 차트를 사용할 때 자주 발생했죠.

    해결: 여러 원인이 있을 수 있습니다. 첫째, Helm Hooks(훅)가 제대로 동작하지 않거나, helm.sh/hook-delete-policy 같은 주석이 설정되어 있지 않은 경우. 둘째, CRD가 먼저 배포되지 않은 상태에서 해당 CRD를 사용하는 리소스가 배포되려 할 때. 셋째, 클러스터 내부의 컨트롤러가 Git에 없는 변경을 일으키는 경우. 넷째, resource.customizations 설정을 통해 특정 리소스의 필드를 무시하도록 설정하는 방법도 있습니다. 저는 특히 CRD 배포 순서 때문에 많이 헷갈렸는데, PreSync Hook을 이용하거나, ApplicationSet에서 CRD Application을 먼저 배포하도록 순서를 조정해서 해결했습니다.

    검증 및 결과: 이제 배포가 이렇게 편해집니다!

    이런 삽질과 노하우를 바탕으로 Argo CD 멀티 클러스터 GitOps 환경을 제대로 구축하고 나니, 정말 배포의 패러다임이 바뀌는 것을 느꼈습니다. 제가 직접 Git에 커밋하고 푸시만 하면, 개발, 스테이징, 프로덕션 클러스터에 알아서 척척 배포되는 모습을 보면 정말 뿌듯하더라고요.

    • 🎉 일관성 있는 배포: 모든 클러스터에 동일한 방식으로 애플리케이션이 배포됩니다.
    • 🎉 배포 속도 향상: 수동 작업이 사라지고, Git 변경만으로 배포가 완료됩니다.
    • 🎉 가시성 확보: Argo CD UI에서 모든 클러스터의 애플리케이션 상태를 한눈에 파악할 수 있습니다.
    • 🎉 안정성 증가: 잘못된 배포는 Git 롤백으로 쉽게 되돌릴 수 있습니다.
    Argo CD 대시보드에서 멀티 클러스터 배포 성공 현황

    위 그림처럼 Argo CD 대시보드에서 여러 클러스터에 걸쳐 배포된 애플리케이션들의 상태를 실시간으로 확인할 수 있습니다. 모든 것이 ‘Synced’ 상태일 때의 그 쾌감이란! (웃음)

    마무리: 더 나은 GitOps 여정을 위해

    오늘은 Argo CD 멀티 클러스터 GitOps에 대한 저의 경험과 베스트 프랙티스 체크리스트를 공유해드렸습니다. 처음에는 복잡하게 느껴질 수 있지만, 한번 구축하고 나면 정말 강력한 배포 시스템을 손에 넣게 될 겁니다. 저도 처음엔 헷갈렸는데, 계속 시도하고 삽질하면서 익숙해지더라고요. 독자 여러분도 이 글을 통해 성공적인 GitOps 여정을 시작하시길 바랍니다.

    혹시 GitOps 환경에서 더 깊이 있는 보안 강화나, CI(Continuous Integration) 파이프라인과의 연동에 대해 궁금하시다면, 다음 글에서 다룰 예정이니 기대해주세요!

    Argo CD 멀티 클러스터 GitOps 베스트 프랙티스 요약 체크리스트

    지금까지의 내용을 요약한 체크리스트입니다. 여러분의 GitOps 환경을 점검할 때 유용하게 활용되길 바랍니다.

  • [k8s] Argo CD 멀티 클러스터 GitOps 도입 사례: 운영 노하우와 도전 과제

    [k8s] Argo CD 멀티 클러스터 GitOps 도입 사례: 운영 노하우와 도전 과제

    [인프라] Argo CD 멀티 클러스터 GitOps 도입 사례: 운영 노하우와 도전 과제

    안녕하세요, 13년차의 서버실 운영자입니다. 오늘은 제가 직접 겪었던 경험을 바탕으로 Argo CD 멀티 클러스터 GitOps 도입 사례에 대해 이야기해볼까 합니다. 쿠버네티스(Kubernetes)를 운영하다 보면 자연스럽게 여러 클러스터를 관리해야 하는 상황에 부딪히게 되죠. 개발, 스테이징, 프로덕션 환경을 분리하거나, 재해 복구(Disaster Recovery)를 위해 지리적으로 분산된 클러스터를 운영하는 경우도 많고요. 처음엔 각각의 클러스터에 배포하는 것도 정말 힘들었는데, 이 모든 것을 효율적으로 관리하려니 골머리가 지끔했었습니다. 혹시 이런 경험 있으신가요?

    저도 처음엔 수동 배포와 스크립트의 늪에서 헤맸습니다. 그러다 GitOps(깃옵스)라는 개념을 접하고, 특히 Argo CD(아르고 CD)가 이 문제를 해결해 줄 수 있다는 걸 알게 되었죠. 특히 여러 클러스터를 한 곳에서 관리할 수 있는 Argo CD 멀티 클러스터 기능은 정말 반가웠습니다. 오늘은 이 기능을 도입하면서 제가 겪었던 삽질과 노하우, 그리고 얻었던 운영 효율성에 대해 솔직하게 풀어보려 합니다.

    Argo CD 멀티 클러스터 GitOps 아키텍처 다이어그램

    Argo CD 멀티 클러스터 GitOps의 전체 아키텍처 다이어그램입니다. 중앙의 Argo CD 컨트롤 플레인이 여러 쿠버네티스 클러스터에 애플리케이션을 배포하고 관리하는 모습을 보여줍니다.

    GitOps와 Argo CD, 그리고 멀티 클러스터 관리

    먼저, GitOps(깃옵스)가 뭔지 간단히 짚고 넘어가 보겠습니다. 쉽게 말하면, Git(깃) 저장소를 진리의 원천(Source of Truth)으로 삼아 인프라와 애플리케이션 배포를 관리하는 방식이에요. 모든 변경 사항은 Git에 기록되고, Git의 상태와 실제 클러스터의 상태를 일치시키는 것이 핵심입니다. 이렇게 하면 누가 언제 무엇을 변경했는지 추적하기 쉽고, 문제가 생겼을 때 이전 상태로 되돌리기도(Rollback) 훨씬 수월하죠.

    그리고 Argo CD(아르고 CD)는 이런 GitOps 원칙을 쿠버네티스 환경에서 구현하도록 도와주는 선언적(Declarative) GitOps 지속적 배포(Continuous Delivery) 도구입니다. Git 저장소에 정의된 상태를 주기적으로 감지해서 쿠버네티스 클러스터의 실제 상태와 비교하고, 다르면 Git의 상태에 맞춰 동기화(Sync)해줍니다. 정말 편리하더라고요.

    그렇다면 멀티 클러스터 관리(Multi-Cluster Management)는 뭘까요? Argo CD는 한 개의 인스턴스로 여러 개의 쿠버네티스 클러스터에 배포를 관리할 수 있는 기능을 제공합니다. 메인 Argo CD가 설치된 클러스터(저는 이걸 컨트롤 플레인 클러스터(Control Plane Cluster)라고 부릅니다)에서 여러 타겟 클러스터(Target Cluster)들을 등록하고, 각각의 클러스터에 어떤 애플리케이션을 어떤 버전으로 배포할지 Git을 통해 지시하는 방식이에요. 덕분에 여러 환경에 동일한 애플리케이션을 일관성 있게 배포하고 관리하는 게 훨씬 쉬워졌습니다. 💡

    실전 구현: Argo CD 멀티 클러스터 환경 구축하기

    자, 이제 실제로 어떻게 구성했는지 살펴보겠습니다. 저는 세 개의 클러스터를 준비했는데, 하나는 Argo CD가 설치될 컨트롤 플레인 클러스터, 그리고 나머지 두 개는 애플리케이션이 배포될 타겟 클러스터입니다. 모든 클러스터는 kubeconfig(쿠브콘피그)를 통해 접근할 수 있도록 설정되어 있다고 가정하겠습니다.

    1. Argo CD 설치 및 타겟 클러스터 등록

    먼저, 컨트롤 플레인 클러스터에 Argo CD를 설치합니다. 이건 공식 문서에 잘 나와 있으니 간단하게 넘어갈 테고, 핵심은 타겟 클러스터를 Argo CD에 등록하는 것입니다. Argo CD CLI를 사용하면 정말 간단하게 등록할 수 있어요.

    
    # Argo CD CLI 설치 (공식 문서 참고)
    # brew install argocd
    
    # Argo CD 로그인 (admin 계정 패스워드는 초기 설치 시 자동으로 생성됩니다)
    argocd login <ARGOCD_SERVER_IP_OR_HOSTNAME>
    
    # 타겟 클러스터 등록
    # kubeconfig에 등록된 클러스터 이름을 사용합니다.
    # 제 경우엔 dev-cluster와 prod-cluster라는 이름으로 등록되어 있었죠.
    argocd cluster add dev-cluster --name dev-cluster-region-a
    argocd cluster add prod-cluster --name prod-cluster-region-b
    
    # 등록된 클러스터 목록 확인
    argocd cluster list
    

    이렇게 하면 Argo CD가 해당 클러스터에 접근해서 애플리케이션을 배포할 수 있는 권한을 가지게 됩니다. 중요한 부분은 RBAC(Role-Based Access Control, 역할 기반 접근 제어) 설정인데, Argo CD가 타겟 클러스터에서 필요한 리소스(Deployment, Service 등)를 생성/수정/삭제할 수 있도록 적절한 권한을 부여해야 합니다. 저는 처음엔 이걸 놓쳐서 “왜 배포가 안 될까?” 한참 삽질했었습니다. ⚠️

    Argo CD UI 클러스터 목록 스크린샷

    Argo CD 웹 UI에 등록된 dev-cluster-region-a와 prod-cluster-region-b 클러스터의 목록과 상태를 보여주는 화면입니다. 모든 클러스터가 Healthy 상태로 나타나 있네요.

    2. Git 저장소 구조화: App of Apps 패턴

    멀티 클러스터 환경에서 Git 저장소를 효율적으로 관리하는 방법 중 하나는 App of Apps 패턴(App of Apps Pattern)입니다. 하나의 최상위 Argo CD Application이 여러 하위 Application들을 관리하는 방식이에요. 저는 다음과 같이 Git 저장소를 구성했습니다.

    
    .
    ├── applications/
    │   ├── base/ # 공통 애플리케이션 정의 (예: Ingress Controller, Cert Manager)
    │   └── microservices/ # 마이크로서비스별 애플리케이션 정의
    ├── clusters/
    │   ├── dev-cluster-region-a/ # 개발 클러스터별 설정
    │   │   └── root-app.yaml
    │   └── prod-cluster-region-b/ # 프로덕션 클러스터별 설정
    │       └── root-app.yaml
    └── environments/
        ├── dev/ # 개발 환경별 값 (values.yaml for Helm)
        └── prod/ # 프로덕션 환경별 값 (values.yaml for Helm)
    

    각 클러스터 폴더 안의 `root-app.yaml`은 해당 클러스터에 배포될 모든 하위 애플리케이션을 정의하는 최상위 Argo CD Application입니다. 예를 들어 `dev-cluster-region-a/root-app.yaml`은 다음과 같이 작성할 수 있죠.

    
    # clusters/dev-cluster-region-a/root-app.yaml
    apiVersion: argoproj.io/v1alpha1
    kind: Application
    metadata:
      name: dev-cluster-root-app
      namespace: argocd
    spec:
      project: default
      source:
        repoURL: https://github.com/my-org/my-gitops-repo.git # 본인의 Git 저장소 URL
        targetRevision: HEAD
        path: applications # 하위 애플리케이션 정의들이 있는 경로
      destination:
        server: https://kubernetes.default.svc # 이 Application은 Argo CD가 설치된 클러스터에 적용
        namespace: argocd # Argo CD가 Application 리소스를 관리하는 네임스페이스
      syncPolicy:
        automated:
          prune: true
          selfHeal: true
        syncOptions:
          - CreateNamespace=true
    

    그리고 `applications/` 경로 안에는 실제 배포될 애플리케이션들의 정의가 들어갑니다. 예를 들어, `applications/microservices/my-service.yaml`은 다음과 같을 수 있어요. 여기서 ApplicationSet(애플리케이션셋)을 사용하면 여러 클러스터에 동일한 애플리케이션을 배포하는 것이 훨씬 유연해집니다.

    
    # applications/microservices/my-service.yaml
    apiVersion: argoproj.io/v1alpha1
    kind: ApplicationSet
    metadata:
      name: my-service-all-clusters
      namespace: argocd
    spec:
      generators:
      - list:
          elements:
          - cluster: dev-cluster-region-a # Argo CD에 등록된 클러스터 이름
            url: https://kubernetes.default.svc # 타겟 클러스터의 API 서버 URL
            name: dev
          - cluster: prod-cluster-region-b
            url: https://kubernetes.default.svc
            name: prod
      template:
        metadata:
          name: my-service-{{name}} # 클러스터 이름에 따라 Application 이름이 생성됩니다 (예: my-service-dev, my-service-prod)
          namespace: default
        spec:
          project: default
          source:
            repoURL: https://github.com/my-org/my-app-helm-charts.git # 애플리케이션 Helm 차트 저장소
            targetRevision: 1.0.0
            path: my-service
            helm:
              values: |
                replicaCount: 2
                image:
                  tag: "1.0.0-{{name}}" # 환경별 이미지 태그 (예: 1.0.0-dev, 1.0.0-prod)
                ingress:
                  host: my-service.{{name}}.example.com
          destination:
            server: "{{url}}" # 위에서 정의된 타겟 클러스터의 URL
            namespace: default
          syncPolicy:
            automated:
              prune: true
              selfHeal: true
            syncOptions:
              - CreateNamespace=true
    

    위 `ApplicationSet` 예시는 `list` 제너레이터를 사용해서 `dev`와 `prod` 두 환경에 `my-service`를 배포하도록 정의하고 있습니다. 각 환경에 맞는 `values`를 `helm` 섹션에서 오버라이드(Override)할 수 있어서 정말 유용해요. 저는 Helm(헬름) 차트를 주로 사용하는데, Kustomize(커스터마이즈)나 일반 YAML도 물론 지원합니다.

    ⚠️ 삽질 경험과 운영 노하우

    Argo CD 멀티 클러스터를 운영하면서 몇 가지 정말 잊지 못할 경험들이 있습니다. 독자분들은 저와 같은 실수를 반복하지 않으시길 바라며 몇 가지 중요한 팁을 공유합니다.

    1. RBAC 권한 문제

    가장 흔하고 고통스러운 문제예요. Argo CD가 타겟 클러스터에 배포할 때, 필요한 권한이 없어서 배포가 실패하는 경우가 정말 많습니다. Argo CD를 등록할 때 부여하는 권한은 ServiceAccount(서비스 어카운트)를 통해 부여되는데, 이 서비스 어카운트가 타겟 클러스터에서 ClusterRole(클러스터 롤)과 ClusterRoleBinding(클러스터 롤 바인딩)을 통해 적절한 권한을 가지고 있는지 반드시 확인해야 합니다. 저는 처음엔 `admin` 권한을 무심코 줬다가 보안 팀에게 한소리 듣고, 나중에는 필요한 최소한의 권한만 부여하도록 변경했습니다. 💡

    
    # 예시: Argo CD ServiceAccount에 필요한 ClusterRoleBinding 부여 (타겟 클러스터에서 실행)
    apiVersion: rbac.authorization.k8s.io/v1
    kind: ClusterRoleBinding
    metadata:
      name: argocd-manager-role-binding
    subjects:
    - kind: ServiceAccount
      name: argocd-manager # Argo CD가 사용하는 ServiceAccount 이름
      namespace: argocd # Argo CD가 설치된 네임스페이스
    roleRef:
      apiGroup: rbac.authorization.k8s.io
      kind: ClusterRole
      name: cluster-admin # 임시로 전체 권한 부여. 실제 운영에서는 더 세분화된 Role을 사용하세요.
    

    실제 운영에서는 `cluster-admin` 대신 `edit`이나 `view` 같은 기본 Role을 조합하거나, 특정 리소스에 대한 `get`, `list`, `watch`, `create`, `update`, `patch`, `delete` 권한을 명시적으로 부여하는 커스텀 ClusterRole을 만들어서 사용하는 게 훨씬 안전합니다.

    2. 네트워크 연결 및 방화벽

    Argo CD 컨트롤 플레인 클러스터에서 타겟 클러스터의 API 서버에 접근할 수 있어야 합니다. 만약 클러스터들이 서로 다른 네트워크에 있거나, 방화벽(Firewall) 정책이 엄격하다면 연결 문제가 발생할 수 있죠. 저는 회사 보안 정책 때문에 VPC 피어링(VPC Peering)이나 VPN(Virtual Private Network) 설정을 통해 연결을 확보해야 했어요. 핑(Ping) 테스트나 `kubectl`로 직접 연결해보면서 연결성을 확인하는 것이 정말 중요합니다.

    3. 시크릿 관리(Secret Management)

    여러 클러스터에 배포되는 애플리케이션들은 데이터베이스 비밀번호나 API 키 같은 민감한 정보(Secret)들을 필요로 합니다. 이걸 Git에 그대로 올릴 수는 없겠죠. 저는 External Secrets Operator(외부 시크릿 오퍼레이터)와 Vault(볼트)를 연동해서 사용하거나, Sealed Secrets(실드 시크릿)를 활용해서 시크릿을 안전하게 관리했습니다. Git에 암호화된 형태로 저장하고, 각 클러스터에서 복호화해서 사용하는 방식이에요. 이 부분은 보안상 정말 중요하니 깊이 있게 고민해야 합니다.

    4. 설정 드리프트(Configuration Drift)

    GitOps의 핵심은 Git 저장소의 상태와 실제 클러스터의 상태가 일치해야 한다는 거예요. 그런데 운영 중에 누군가 클러스터에서 직접 리소스를 수정해서 Git과 클러스터의 상태가 달라지는 설정 드리프트(Configuration Drift)가 발생할 수 있습니다. Argo CD는 이런 드리프트를 감지하고 자동으로 동기화(Self-Heal)하거나, 수동으로 동기화할 수 있는 기능을 제공합니다. 하지만 근본적으로는 클러스터에 직접 접근해서 변경하는 것을 정책적으로 금지하고, 모든 변경은 Git을 통해서만 이루어지도록 강제하는 게 중요합니다.

    🎉 Argo CD 멀티 클러스터 도입 후기 및 성과

    숱한 삽질 끝에 Argo CD 멀티 클러스터 GitOps 환경을 성공적으로 구축하고 운영하게 되었습니다. 그 결과는 정말 놀라웠어요.

    • 배포 일관성 및 안정성 향상: 개발, 스테이징, 프로덕션 클러스터에 동일한 버전의 애플리케이션을 일관된 방식으로 배포할 수 있게 되었습니다. 수동 작업으로 인한 휴먼 에러(Human Error)가 정말 줄었죠.
    • 배포 속도 단축: Git에 코드를 푸시(Push)만 하면 Argo CD가 자동으로 감지하고 배포를 시작합니다. CI/CD 파이프라인(Pipeline)과 연동하여 개발자들이 훨씬 빠르게 변경 사항을 적용할 수 있게 되었어요.
    • 쉬운 롤백(Rollback): 문제가 발생했을 때, Git의 이전 커밋(Commit)으로 되돌리는 것만으로 애플리케이션을 이전 상태로 쉽게 롤백할 수 있습니다. 비상 상황에서 정말 큰 도움이 되더군요.
    • 운영 가시성 확보: Argo CD UI를 통해 모든 클러스터의 애플리케이션 상태를 한눈에 확인할 수 있게 되었습니다. 어떤 애플리케이션이 어느 클러스터에 어떤 버전으로 배포되어 있는지 파악하기가 정말 쉬워졌어요.
    Argo CD UI 멀티 클러스터 애플리케이션 상태 대시보드

    Argo CD 웹 UI에서 dev-cluster와 prod-cluster에 배포된 여러 애플리케이션들의 동기화 상태와 Health 상태를 한눈에 보여주는 대시보드 화면입니다. 모든 애플리케이션이 Sync’d and Healthy 상태를 나타내고 있네요.

    Argo CD 멀티 클러스터 도입 전후 비교

    구분 도입 전 (수동/스크립트 기반) 도입 후 (Argo CD 멀티 클러스터 GitOps)
    배포 방식 클러스터별 수동 `kubectl` 적용 또는 쉘 스크립트 실행 Git 커밋 기반 자동 동기화 (선언적)
    배포 일관성 환경별 설정 차이 발생 가능성 높음, 휴먼 에러 빈번 Git을 통한 일관된 설정 적용, 휴먼 에러 최소화
    롤백 용이성 이전 상태 복구 어려움, 시간 소요 Git 커밋 되돌리기로 빠르고 안정적인 롤백
    운영 가시성 각 클러스터에 개별 접근하여 상태 확인 단일 Argo CD UI에서 모든 클러스터 및 애플리케이션 상태 확인
    보안 및 감사 수동 변경 이력 추적 어려움 Git 변경 이력을 통한 완벽한 감사 추적

    위 표에서 보시는 것처럼, Argo CD 멀티 클러스터 GitOps는 인프라 운영 방식에 혁신적인 변화를 가져다주었습니다. 특히 여러 클러스터를 관리해야 하는 복잡한 환경에서는 그 진가가 더욱 빛을 발하더군요.

    마무리하며: 배운 점과 다음 도전 과제

    오늘은 제가 Argo CD 멀티 클러스터 GitOps를 도입하면서 겪었던 과정과 노하우, 그리고 얻었던 성과에 대해 이야기해봤습니다. 처음엔 낯선 개념과 복잡한 설정 때문에 막막하기도 했지만, 한번 구축하고 나니 인프라 운영의 질이 한 단계 높아지는 걸 체감할 수 있었습니다. 특히 쿠버네티스 멀티 클러스터 관리에 대한 고민이 많으셨던 분들께 저의 Argo CD GitOps 사례가 작은 도움이 되었으면 좋겠어요.

    물론 아직 도전 과제는 남아있습니다. 예를 들어, 프로그레시브 딜리버리(Progressive Delivery)를 위해 Argo Rollouts(아르고 롤아웃)과 연동하거나, 더 복잡한 클러스터 간 의존성을 관리하는 방법, 그리고 비용 최적화와 같은 부분은 앞으로도 계속 고민하고 실험해봐야 할 영역입니다. 💡

    저처럼 GitOps 도입 후기를 찾고 계셨던 분들이라면, Argo CD를 적극적으로 검토해보시길 추천합니다. 직접 해보면 생각보다 어렵지 않고, 얻는 이점은 훨씬 크다는 걸 느끼실 겁니다. 다음번에는 더 깊이 있는 주제로 찾아오겠습니다. 긴 글 읽어주셔서 감사합니다! 궁금한 점이 있다면 언제든지 댓글로 남겨주세요.

  • [k8s] Kustomize와 Helm, K8s 설정 관리 도구 실측 성능 비교

    [k8s] Kustomize와 Helm, K8s 설정 관리 도구 실측 성능 비교

    Kustomize와 Helm, K8s 설정 관리 도구 실측 성능 비교: 어떤 놈이 더 빠를까요?

    안녕하세요, 13년차 서버실 지킴이입니다. 오늘도 여전히 복잡한 인프라의 세계 속에서 삽질하고 계실 독자분들을 위해 제 경험을 풀어볼까 합니다. 😅

    Kubernetes(쿠버네티스, 이하 K8s) 환경에서 애플리케이션을 배포하고 관리하다 보면, YAML 파일의 홍수에 빠지는 경험, 다들 있으실 겁니다. 이 수많은 설정 파일들을 어떻게 효과적으로 관리할까? 바로 여기서 Kustomize(커스터마이즈)와 Helm(헬름) 같은 K8s 설정 관리(Configuration Management) 도구들이 등장하죠.

    두 도구 모두 강력한 기능을 제공하지만, 실제 운영 환경에서는 ‘과연 어떤 도구가 더 빠르고 효율적일까?’ 하는 고민을 많이 하게 됩니다. 특히 CI/CD 파이프라인에서 빌드 시간이 길어지면 개발자의 생산성에도 영향을 미치거든요. 그래서 오늘은 제가 직접 두 도구를 사용해보면서 느꼈던 Kustomize vs Helm 성능 비교와 최적화 전략에 대해 이야기해볼게요. 멘토처럼 솔직한 경험담과 함께요! 💡

    Kubernetes 설정 관리를 위한 Kustomize와 Helm 워크플로우 비교 다이어그램

    –>

    Kubernetes 설정 관리를 위한 Kustomize와 Helm 워크플로우 비교 다이어그램

    1. Kustomize와 Helm, 넌 누구냐? 🤔

    먼저 두 도구가 정확히 어떤 역할을 하는지, 개념부터 확실히 잡고 가볼까요?

    1.1. Kustomize: K8s 네이티브 설정 템플릿

    Kustomize는 Kubernetes 네이티브 설정 관리(Kubernetes native configuration management) 도구입니다. 쉽게 말해, K8s가 YAML 파일을 처리하는 방식과 매우 유사하게 동작해요. 템플릿 엔진을 사용하지 않고, 기존 YAML 파일(Base)에 덧붙이는(Overlay) 방식으로 설정을 변경합니다.

    • 선언적(Declarative): 최종 상태를 선언하는 방식이라 직관적입니다.
    • 패치(Patch) 기반: 원본 파일을 직접 수정하지 않고, 필요한 부분만 덮어쓰는 형식이에요.
    • 경량화(Lightweight): K8s 내부에 통합되어 별도의 바이너리 설치 없이 kubectl 명령어에 포함되어 있습니다. (kubectl kustomize 또는 kustomize build)

    1.2. Helm: K8s의 패키지 매니저

    Helm은 K8s를 위한 패키지 매니저(Package Manager)입니다. 마치 Ubuntu의 apt나 CentOS의 yum처럼, K8s 애플리케이션을 차트(Chart)라는 형태로 패키징하고 배포하며 관리할 수 있게 해줘요.

    • 템플릿 엔진(Templating Engine): Go 템플릿(Go Template) 문법을 사용하여 YAML 파일을 동적으로 생성합니다. values.yaml 파일로 변수를 주입하죠.
    • 릴리즈(Release) 관리: 배포된 애플리케이션의 버전을 관리하고, 업그레이드 및 롤백을 쉽게 할 수 있습니다.
    • 의존성 관리(Dependency Management): 다른 차트를 하위 차트(subchart)로 포함시켜 복잡한 애플리케이션 스택을 한 번에 배포할 수 있어요.

    2. 실전 구현: 어떻게 비교할까? 🛠️

    두 도구의 성능을 비교하려면, 동일한 조건에서 최대한 유사한 작업을 수행하게 해야겠죠? 제가 홈랩에서 간단한 웹 애플리케이션을 배포하면서 비교했던 방법을 공유해볼게요.

    2.1. Kustomize로 YAML 빌드하기

    먼저 Kustomize는 kustomization.yaml 파일을 작성하여 여러 YAML 파일을 조합하고 패치합니다. 예를 들어, 개발 환경과 운영 환경에 따라 리소스의 replica 수나 이미지 태그를 다르게 적용하는 시나리오를 가정해봅시다.

    # base/deployment.yaml
    apiVersion: apps/v1
    kind: Deployment
    metadata:
      name: my-app
    spec:
      replicas: 1
      template:
        spec:
          containers:
          - name: my-app
            image: my-repo/my-app:1.0.0
    
    # overlays/dev/kustomization.yaml
    apiVersion: kustomize.config.k8s.io/v1beta1
    kind: Kustomization
    resources:
    - ../../base
    patches:
    - path: patch-dev.yaml
    
    # overlays/dev/patch-dev.yaml
    apiVersion: apps/v1
    kind: Deployment
    metadata:
      name: my-app
    spec:
      replicas: 2 # 개발 환경은 2개로
    
    

    이렇게 구성된 Kustomize 프로젝트는 다음 명령어로 최종 YAML을 생성합니다.

    time kustomize build overlays/dev > dev-app.yaml
    

    time 명령어를 붙여서 실행 시간을 측정하는 거죠. 간단하죠? ⏱️

    2.2. Helm으로 차트 렌더링하기

    Helm은 차트 디렉토리 구조와 values.yaml 파일을 사용해서 YAML을 렌더링합니다. 마찬가지로 개발 환경과 운영 환경에 따라 설정을 다르게 해볼게요.

    # my-app-chart/templates/deployment.yaml
    apiVersion: apps/v1
    kind: Deployment
    metadata:
      name: {{ .Release.Name }}-{{ .Chart.Name }}
    spec:
      replicas: {{ .Values.replicaCount }}
      template:
        spec:
          containers:
          - name: {{ .Chart.Name }}
            image: {{ .Values.image.repository }}:{{ .Values.image.tag }}
    
    # my-app-chart/values.yaml (기본값)
    replicaCount: 1
    image:
      repository: my-repo/my-app
      tag: 1.0.0
    
    # my-app-chart/values-dev.yaml (개발 환경 오버라이드)
    replicaCount: 2
    image:
      tag: 1.0.0-dev
    

    Helm 차트는 다음 명령어로 최종 YAML을 렌더링합니다.

    time helm template my-app my-app-chart -f my-app-chart/values-dev.yaml > dev-app-helm.yaml
    

    마찬가지로 time 명령어로 렌더링 시간을 측정합니다. 💡

    Kustomize 오버레이와 Helm 차트 values.yaml 파일 구조 시각화

    –>

    Kustomize 오버레이와 Helm 차트 values.yaml 파일 구조 시각화

    3. 주의사항과 삽질 경험 ⚠️

    단순히 time 명령어를 쓰는 것만으로는 완벽한 비교가 어렵더라고요. 제가 겪었던 삽질 경험을 토대로 몇 가지 주의사항을 공유합니다.

    3.1. Helm 복잡성과 의존성 관리 오버헤드

    Helm은 Go 템플릿을 사용하고, 복잡한 의존성 관리(Dependency Management) 기능을 제공합니다. 차트 내에 수많은 하위 차트(subchart)가 있거나, 템플릿 로직이 복잡해질수록 렌더링 시간이 기하급수적으로 늘어날 수 있어요. 제가 처음엔 너무 많은 헬름 차트를 한 번에 묶었다가 렌더링에만 수십 초씩 걸려서 깜짝 놀랐거든요. 😅

    반면 Kustomize는 단순히 YAML 파일을 병합하고 패치하는 방식이라, 상대적으로 오버헤드가 적습니다. 하지만 패치 파일이 너무 많아지거나, 복잡한 jsonPatch를 사용하면 가독성이 떨어지고 디버깅이 어려워지는 단점이 있습니다.

    3.2. 캐싱(Caching)과 컨테이너 환경

    CI/CD 파이프라인에서 실행할 때는 도커 컨테이너 환경에서 실행하는 경우가 많죠. 이때 도구 바이너리 로딩 시간이나 컨테이너 이미지 크기도 성능에 영향을 줄 수 있습니다. Helm은 별도의 바이너리가 필요하고, Kustomize는 kubectl에 통합되어 있거나 단독 바이너리를 사용합니다. 아주 미세한 차이지만, 빌드 횟수가 많아지면 무시할 수 없는 요소가 됩니다.

    3.3. ‘실측’의 의미: 실제 배포까지의 시간

    단순히 YAML 파일을 생성하는 시간뿐만 아니라, K8s API 서버에 리소스를 배포하고 적용하는 시간까지 고려해야 진정한 실측 성능(Real-world Performance)이라고 할 수 있습니다. kubectl apply -f 또는 helm upgrade --install 명령어가 실제로 얼마나 걸리는지도 함께 측정해봐야 합니다.

    4. 검증 및 결과: 무엇이 더 빠를까? 🚀

    결론부터 말씀드리면, ‘케바케(Case by Case)’입니다. 😅 하지만 제가 여러 프로젝트에서 직접 사용해보고 측정해본 결과, 다음과 같은 일반적인 경향을 발견했습니다.

    4.1. Kustomize의 장점 (대규모 프로젝트 초기 빌드/변경)

    • 빠른 빌드 시간: 단순 YAML 병합 및 패치 방식이라 템플릿 엔진의 오버헤드가 없습니다. 수백 개의 리소스가 있어도 빌드 자체는 상당히 빠르게 완료되는 편입니다.
    • K8s 네이티브 통합: kubectl 명령어에 포함되어 있어 별도의 도구 설치 및 관리 부담이 적습니다.
    • 예측 가능한 결과: 템플릿 로직이 없어 결과 YAML이 직관적이고 예측하기 쉽습니다.

    4.2. Helm의 장점 (복잡한 템플릿/패키징)

    • 강력한 템플릿 기능: Go 템플릿을 활용해 복잡한 조건부 로직이나 반복문 등을 구현하기 용이합니다.
    • 패키지 관리의 용이성: 재사용 가능한 차트 형태로 애플리케이션을 배포하고 관리하는 데 최적화되어 있습니다. 외부 차트를 쉽게 가져다 쓸 수 있고요.
    • 릴리즈 히스토리 관리: 배포된 애플리케이션의 버전 관리와 롤백이 매우 편리합니다.

    4.3. 성능에 영향을 미치는 주요 요인

    어떤 도구를 쓰든 다음 요소들이 성능에 큰 영향을 줍니다.

    1. 생성되는 YAML 리소스의 수: 많을수록 처리 시간이 길어집니다.
    2. Helm 차트의 복잡성: 템플릿 내의 조건문, 반복문, 함수 호출 등이 많을수록 렌더링 시간이 길어집니다.
    3. Kustomize 패치의 수와 복잡성: 너무 많은 패치나 복잡한 jsonPatch는 처리 시간을 늘릴 수 있습니다.
    4. 의존성(Dependency) 관리: 특히 Helm에서 서브 차트의 수가 많아지면 초기 로딩 및 렌더링 오버헤드가 발생합니다.
    5. 실행 환경의 성능: CI/CD 에이전트의 CPU, 메모리, 디스크 I/O도 영향을 미칩니다.

    제가 실제 측정해보니, 리소스 수가 적을 때는 두 도구 간의 빌드 시간 차이가 미미했지만, 수백 개 이상의 리소스를 다루거나 Helm 차트의 템플릿 로직이 복잡해질수록 Helm의 렌더링 시간이 Kustomize의 빌드 시간보다 눈에 띄게 길어지는 경향을 보였습니다. ⚠️

    Kustomize와 Helm 빌드 시간 측정 및 성능 비교 결과

    –>

    Kustomize와 Helm 빌드 시간 측정 및 성능 비교 결과

    5. K8s 설정 관리 최적화 전략 ⚙️

    결국 중요한 건 ‘어떤 도구가 절대적으로 빠르냐’가 아니라, ‘어떤 도구를 어떻게 사용해서 우리 환경에 최적화하느냐’입니다.

    • Kustomize 최적화:
      • 베이스(Base) 재사용: 공통된 설정은 베이스로 만들고, 오버레이는 최소한의 변경만 하도록 구성합니다.
      • 패치 최소화: 불필요하게 작은 단위로 패치를 나누기보다, 응집도 있는 패치를 사용합니다.
      • GitOps 워크플로우: Kustomize는 GitOps와 궁합이 좋습니다. Flux CD나 Argo CD 같은 도구와 함께 사용하면 변경 사항을 자동으로 감지하고 적용할 수 있어요.
    • Helm 차트 최적화:
      • 템플릿 복잡성 줄이기: Go 템플릿 내의 복잡한 로직을 최소화하고, 필요한 경우 별도의 스크립트나 도구로 전처리하는 것을 고려합니다.
      • 서브 차트 의존성 관리: 꼭 필요한 경우에만 서브 차트를 사용하고, 불필요한 의존성은 제거합니다. 서브 차트가 많으면 관리가 어려워지더라고요.
      • --atomic, --wait 옵션 활용: 배포 시 안정성을 높이지만, 이 옵션들이 배포 시간을 늘릴 수 있다는 점을 인지하고 적절히 사용해야 합니다.
      • 캐싱 활용: CI/CD 환경에서 Helm dependency update 등의 과정을 캐싱하여 시간을 절약할 수 있습니다.

    저는 개인적으로 간단하고 직관적인 애플리케이션은 Kustomize를, 복잡한 의존성을 가진 상용 솔루션이나 여러 마이크로서비스를 묶어 배포해야 할 때는 Helm을 선호하는 편입니다. 두 도구를 혼용(Hybrid)하여 사용하는 방법도 좋은 전략이 될 수 있어요. 예를 들어, Helm 차트를 Kustomize의 베이스로 사용하고, 그 위에 환경별 패치를 적용하는 방식이죠. 🤯

    Kustomize와 Helm의 주요 기능 및 장단점 비교 인포그래픽

    –>

    Kustomize와 Helm의 주요 기능 및 장단점 비교 인포그래픽

    6. 마무리: 우리의 삽질은 계속된다! 🎉

    오늘은 Kustomize와 Helm이라는 두 가지 강력한 K8s 설정 관리 도구의 성능 비교와 최적화 전략에 대해 이야기해봤습니다. 어느 한쪽이 ‘무조건 최고다’라고 말하기는 어렵고, 각자의 장단점과 사용 환경에 따라 선택이 달라질 수 있다는 점이 핵심입니다.

    저도 처음엔 ‘어떤 게 더 좋지?’ 하면서 벤치마크 숫자놀음에 집착했었는데요, 결국 중요한 건 ‘우리 팀의 워크플로우에 얼마나 잘 맞고, 유지보수가 쉬우며, 안정적인가’ 하는 점이더라고요. 성능 측정은 그 판단을 돕는 하나의 지표일 뿐입니다. 여러분도 직접 사용해보면서 자신만의 최적의 방법을 찾아보시길 바랍니다. 혹시 더 좋은 Helm 차트 최적화나 Kustomize 장점 활용 팁이 있다면 댓글로 공유해주세요! 다음 글에서는 Kustomize와 Helm을 GitOps 환경에서 연동하는 방법에 대해 더 깊이 다뤄볼 예정입니다. 기대해주세요! 😉

  • [K8s] Pod Security Admission 1년 사용 후기 및 실수담

    [K8s] Pod Security Admission 1년 사용 후기 및 실수담

    K8s Pod Security Admission, 1년 사용 후기 및 실수담

    안녕하세요, 13년차 서버실 주인장입니다. 오늘은 Kubernetes(이하 K8s) 환경에서 보안을 한층 강화해주는 Pod Security Admission(PSA)에 대해 이야기해보려 합니다. 제가 운영하는 홈랩 환경에서 PSA를 도입한 지 어느덧 1년이 되었는데요, 처음에는 조금 헷갈렸지만 지금은 없어서는 안 될 기능이 되었답니다. 오늘은 1년 동안 PSA를 사용하면서 겪었던 시행착오와 함께, 어떻게 하면 좀 더 효율적으로 PSA를 활용할 수 있을지에 대한 경험을 솔직하게 공유해 드릴게요. 혹시 K8s 보안에 대해 고민하고 계셨다면, 오늘 제 이야기가 작게나마 도움이 되기를 바랍니다. 😊

    Kubernetes 클러스터의 전반적인 아키텍처와 Pod Security Admission이 어떤 위치에 있는지 보여주는 다이어그램

    K8s Pod Security Admission, 왜 필요할까요?

    K8s는 유연하고 강력한 컨테이너 오케스트레이션 도구이지만, 그만큼 보안 설정에 신경 써야 할 부분이 많습니다. 특히 Pod(파드)는 K8s의 가장 기본적인 배포 단위인데요, 이 Pod가 실행될 때 어떤 보안 정책을 따라야 하는지 명확하게 제어하지 않으면 예상치 못한 보안 취약점이 발생할 수 있습니다. 예를 들어, 특권(privileged) 컨테이너가 실수로 실행되거나, 호스트 파일 시스템에 접근하는 등의 위험한 상황이 생길 수 있죠.

    이런 문제를 해결하기 위해 K8s에서는 Pod Security Admission(PSA)이라는 기능을 제공합니다. 쉽게 말해, Pod를 생성하거나 업데이트할 때 미리 정의된 보안 기준에 부합하는지 자동으로 검사하고, 기준에 맞지 않으면 해당 Pod의 생성을 막아주는(Admission Controller) 기능이라고 생각하시면 됩니다. 💡

    Pod Security Admission, 어떻게 작동하나요?

    PSA는 K8s API 서버의 Admission Controller 중 하나로 작동합니다. Pod 생성 요청이 API 서버에 전달되면, PSA는 해당 Pod가 특정 Pod Security Standards(PSS)를 준수하는지 확인합니다. PSS에는 크게 세 가지 레벨이 있습니다:

    • Restricted (제한): 가장 엄격한 보안. Pod는 격리되고 제한된 권한만 가지며, 최신 보안 기능(예: Seccomp, AppArmor, SELinux)을 사용해야 합니다.
    • Baseline (기준): 최소한의 보안을 보장. 알려진 취약점을 악용하기 어려운 수준으로, 대부분의 워크로드에 권장됩니다.
    • Privileged (특권): 가장 낮은 수준의 보안. 컨테이너가 호스트 시스템에 대한 거의 모든 권한을 갖게 되므로, 매우 신중하게 사용해야 합니다.

    이 세 가지 레벨 외에도, 각 네임스페이스(Namespace)별로 Enforce, Audit, Warn 모드를 설정할 수 있습니다.

    • 1. Enforce (강제): 보안 정책을 위반하는 Pod의 생성을 차단합니다. 가장 강력한 모드죠.
    • 2. Audit (감사): 정책을 위반하더라도 Pod 생성을 차단하지는 않지만, 해당 이벤트를 로그로 기록합니다. 보안 감사에 유용합니다.
    • 3. Warn (경고): 정책을 위반하는 Pod에 대해 사용자에게 경고 메시지를 보냅니다. Pod 생성은 허용됩니다.

    실전! Pod Security Admission 설정하기 (제 경험담)

    제가 처음 PSA를 도입할 때 가장 헷갈렸던 부분이 바로 이 네임스페이스별 정책 설정이었습니다. 저희 홈랩에는 개발용, 테스트용, 운영용 등 다양한 환경의 네임스페이스가 있었기 때문에, 각기 다른 보안 정책을 적용하고 싶었거든요.

    K8s 클러스터 전체에 PSA를 활성화하는 것은 API 서버 설정에서 간단히 할 수 있습니다. 하지만 실제로는 각 네임스페이스별로 정책을 세밀하게 조정하는 것이 중요합니다. 저는 다음과 같은 방식으로 설정을 진행했습니다.

    1단계: 네임스페이스별 레이블 설정

    먼저, 각 네임스페이스에 어떤 보안 정책을 적용할지 명시하는 레이블을 붙여줍니다. 예를 들어, 보안이 중요한 운영 네임스페이스에는 pod-security.kubernetes.io/enforce=baseline과 같이 설정할 수 있습니다.

    kubectl label --overwrite ns production pod-security.kubernetes.io/enforce=baseline
    kubectl label --overwrite ns production pod-security.kubernetes.io/audit=baseline
    kubectl label --overwrite ns production pod-security.kubernetes.io/warn=baseline
    
    kubectl label --overwrite ns development pod-security.kubernetes.io/enforce=privileged
    kubectl label --overwrite ns development pod-security.kubernetes.io/audit=baseline
    kubectl label --overwrite ns development pod-security.kubernetes.io/warn=baseline
    
    네임스페이스별 Pod Security Admission 정책 설정 예시

    각 네임스페이스에 할당된 Pod Security Standards 레벨과 모드를 보여주는 예시 화면

    2단계: PSA 동작 확인 (Audit 모드 활용)

    처음부터 enforce 모드로 설정하면, 예상치 못한 Pod 배포 실패로 인해 서비스 장애가 발생할 수 있습니다. 그래서 저는 먼저 audit 모드를 활용하여 어떤 Pod들이 보안 정책을 위반하는지 파악하는 단계를 거쳤습니다. K8s API 서버 감시 로그를 주기적으로 확인하면서, 어떤 Pod가 어떤 이유로 위반되는지 분석했죠.

    💡 팁: kube-apiserver의 감시 로그(audit log)를 통해 PSA 관련 감사 정보를 확인할 수 있습니다. 로컬 클러스터에서는 kubectl describe nodes 또는 클러스터 설정에 따라 로그 파일에서 감시 로그를 조회할 수 있습니다.

    3단계: Enforce 모드로 전환 및 검증

    Audit 모드를 통해 문제를 파악하고 수정했다면, 이제 enforce 모드로 전환할 차례입니다. enforce 모드로 전환한 후, 중요한 워크로드부터 순차적으로 배포해보면서 문제가 없는지 꼼꼼하게 검증했습니다.

    kubectl label --overwrite ns production pod-security.kubernetes.io/enforce=baseline
    

    Pod Security Admission 정책을 위반했을 때 API 서버 로그에 기록되는 내용

    1년간 사용해보니… 삽질과 깨달음

    PSA를 1년 가까이 사용하면서 정말 많은 것을 배웠습니다. 처음에는 단순히 PSS 레벨을 설정하면 되는 줄 알았는데, 실제로는 Pod의 설정 하나하나가 PSS와 충돌할 수 있다는 것을 깨달았죠.

    가장 흔하게 겪었던 실수담은 바로 privileged: true 설정이었습니다. 저희 팀에서 사용하는 특정 사이드카(Sidecar) 컨테이너가 네트워킹 관련 기능을 위해 이 설정을 필요로 했는데, restricted 또는 baseline PSS에서는 당연히 막히더라고요. 처음에는 왜 Pod 생성이 안 되는지 한참을 헤맸습니다. 😂

    이런 문제를 해결하기 위해 다음과 같은 방법을 사용했습니다:

    • Pod Security Admission 이해하기: Pod Security Policies(PSP)는 K8s 1.25에서 deprecated 되었고 1.28에서 완전히 제거되었습니다. 대신 PSA로 전환하는 과정에서, PSA는 훨씬 간결하고 명확하게 정책을 적용할 수 있다는 걸 체감했습니다.
    • Pod Spec 검토 및 수정: 사이드카 컨테이너의 Pod Spec을 면밀히 검토하여, privileged: true 설정 없이도 동일한 기능을 구현할 수 있는지 확인했습니다. 결국, 필요한 권한만 최소한으로 부여하도록 수정하여 baseline PSS를 만족시킬 수 있었습니다.
    • Audit 모드를 적극 활용: 새로운 애플리케이션을 배포하거나 기존 설정을 변경할 때, 바로 enforce 모드로 전환하기보다는 audit 모드로 먼저 테스트하면서 잠재적인 충돌을 미리 파악하는 습관을 들였습니다.

    PSA는 K8s 클러스터의 보안 수준을 크게 향상시켜주는 강력한 기능입니다. 하지만 모든 Pod가 완벽하게 PSS를 준수하는 것은 아니므로, Service Account, RBAC(Role-Based Access Control)와 함께 종합적으로 고려하여 보안 전략을 수립하는 것이 중요합니다.

    Pod Security Admission과 Pod Security Policy의 주요 차이점 비교

    Pod Security Admission과 이전의 Pod Security Policy의 주요 차이점을 비교한 표

    결론: K8s 보안, PSA로 한 단계 업그레이드하세요!

    Pod Security Admission은 K8s 환경의 보안을 강화하는 데 필수적인 요소입니다. 1년간의 경험을 통해 PSA가 단순히 복잡한 설정이 아니라, 실질적인 보안 위협을 줄여주는 강력한 방어선이라는 것을 체감했습니다.

    물론 초기 설정 과정에서 시행착오를 겪을 수 있습니다. 하지만 audit 모드를 활용하고, Pod Spec을 꼼꼼히 검토하는 습관을 들인다면, 충분히 안정적으로 PSA를 운영할 수 있더라고요.

    혹시 아직 PSA를 도입하지 않으셨다면, 지금 바로 시작해보시는 것을 강력히 추천합니다! 먼저 개발 네임스페이스부터 baseline PSS로 설정하고 audit 모드로 운영해보면서 점차 확대해나가는 것을 권장합니다.

    다음 글에서는 K8s 네트워크 보안의 또 다른 핵심 요소인 Network Policy에 대해 다뤄볼 예정이니, 많은 기대 부탁드립니다! 😉