13년차의 서버실

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

[카테고리:] k8s

  • [k8s] GKE WireGuard 네트워크 장애: 디버깅 및 해결 사례 연구

    [k8s] GKE WireGuard 네트워크 장애: 디버깅 및 해결 사례 연구

    [k8s] GKE WireGuard 네트워크 장애: 디버깅 및 해결 사례 연구

    안녕하세요, 13년차 서버실 지킴이입니다. 오늘은 제가 최근 GKE (Google Kubernetes Engine) 환경에서 WireGuard를 쓰다가 겪었던 네트워크 장애 경험과, 그걸 해결하기 위해 삽질했던 과정을 솔직하게 공유해볼게요. 😅 아마 인프라 엔지니어 분들이라면 누구나 한 번쯤은 복잡한 네트워크 문제로 밤샘 디버깅을 해본 경험이 있으실 거더라고요. 특히 쿠버네티스(Kubernetes) 같은 동적인 환경에서는 예측 불가능한 변수가 많아 정말 골치 아플 때가 많습니다. 저도 이번에 제대로 당했는데, 결국 해결하고 나니 또 하나 배우는 게 있네요. 💡

    이번 글에서는 GKE에서 WireGuard를 운영하면서 발생했던 특정 네트워크 통신 문제를 어떻게 발견하고, 어떤 도구들을 사용해서 원인을 분석했으며, 최종적으로 어떤 방법으로 해결했는지 자세히 이야기해 드릴게요. 혹시 비슷한 문제로 고민하고 계신 분들에게 작은 도움이 되었으면 좋겠습니다.

    GKE 클러스터와 WireGuard VPN 터널이 연결된 전체 아키텍처의 개념도입니다.

    GKE와 WireGuard, 왜 함께 쓰려 했을까요?

    먼저, 왜 제가 GKE 클러스터에 WireGuard를 도입하려고 했는지부터 말씀드려야겠네요. 사실 GKE 자체적으로도 훌륭한 네트워크 기능들을 제공합니다. VPC Native 클러스터는 Private IP를 사용하고, Cloud VPN이나 Interconnect를 통해 온프레미스(On-Premise) 환경과도 쉽게 연결할 수 있거든요. 그럼에도 불구하고 제가 WireGuard를 선택한 이유는 크게 두 가지였습니다.

    • 성능과 간결함 (Performance & Simplicity): WireGuard는 다른 VPN 솔루션들에 비해 오버헤드(Overhead)가 정말 적고, 설정도 간결하더라고요. 홈랩에서 다양한 테스트를 해봤는데 성능이 정말 만족스러웠거든요. 복잡한 IPsec 설정에 비하면 정말 ‘혁명’ 같았습니다.
    • 특정 서비스의 보안 강화 및 멀티 클러스터 네트워킹: 특정 마이크로서비스(Microservice) 간의 통신을 더욱 안전하게 암호화하고, 나아가 다른 클라우드 환경이나 온프레미스에 있는 또 다른 쿠버네티스 클러스터와 안전하게 연결하고 싶었습니다. GKE의 기본 네트워킹을 보완하는 개념으로 접근한 거죠.

    쉽게 말해, GKE의 기본 네트워크 인프라는 유지하되, 그 위에 특정 트래픽에 대해서만 WireGuard 터널(Tunnel)을 만들어서 보안과 유연성을 동시에 잡으려는 시도였습니다. 🚀

    GKE에 WireGuard 실전 구현 (그리고 문제의 시작)

    GKE에 WireGuard를 배포하는 방법은 여러 가지가 있겠지만, 저는 각 노드(Node)에 WireGuard 인터페이스를 생성하고 설정을 유지하기 위해 DaemonSet을 활용했습니다. DaemonSet은 모든 노드에 파드(Pod)를 하나씩 배포해주니까, WireGuard를 인프라 레벨에서 관리하기에 딱 맞겠다 싶었거든요.

    간단한 흐름은 이렇습니다.

    1. WireGuard 커널 모듈이 설치된 베이스 이미지 준비 (또는 initContainer 활용).
    2. 각 노드의 파드에서 WireGuard 인터페이스(wg0) 생성 및 설정.
    3. 다른 피어(Peer)들과의 연결 설정 (PublicKey, Endpoint, AllowedIPs).
    4. 필요한 라우팅 테이블(Routing Table) 및 iptables 규칙 추가.

    초기 배포는 나름 순조로웠습니다. DaemonSet으로 WireGuard 파드를 띄우고, 각 노드에 wg0 인터페이스가 잘 생성되는 것을 확인했거든요. kubectl exec -it [wireguard-pod] -- wg show 명령어로 상태를 확인해보니 피어들과의 핸드셰이크(Handshake)도 정상적으로 이루어지는 것처럼 보였어요. 🎉

    apiVersion: apps/v1
    kind: DaemonSet
    metadata:
      name: wireguard-node
      namespace: kube-system
    spec:
      selector:
        matchLabels:
          app: wireguard-node
      template:
        metadata:
          labels:
            app: wireguard-node
        spec:
          hostNetwork: true # 노드 네트워크 직접 사용
          hostPID: true # 프로세스 네임스페이스 공유
          containers:
          - name: wireguard
            image: <your-wireguard-image>
            securityContext:
              privileged: true # 특권 모드 활성화
              capabilities:
                add:
                - NET_ADMIN
                - SYS_MODULE
            volumeMounts:
            - name: lib-modules
              mountPath: /lib/modules
              readOnly: true
            - name: wg-config
              mountPath: /etc/wireguard
            command: ["sh", "-c"]
            args: 
              - |-
                # WireGuard 커널 모듈 로드
                modprobe wireguard
                # WireGuard 인터페이스 및 라우팅 설정 스크립트 실행
                /usr/local/bin/setup_wireguard.sh
          volumes:
          - name: lib-modules
            hostPath:
              path: /lib/modules
          - name: wg-config
            configMap:
              name: wireguard-config
              items:
              - key: wg0.conf
                path: wg0.conf
    

    이렇게 설정하고, ConfigMap에 각 노드의 WireGuard 설정 파일(wg0.conf)을 넣어서 배포했습니다. 초기에는 내부 서비스 간 통신이나 외부 WireGuard 피어와의 통신도 잘 되는 듯했어요. 그런데….

    GKE DaemonSet을 이용한 WireGuard 설정 YAML과 WireGuard `wg0.conf` 파일 예시

    WireGuard 설정을 위한 DaemonSet YAML과 wg0.conf 파일의 구성 예시입니다.

    ⚠️ 삽질의 시작: 네트워크 장애 발생 및 쿠버네티스 트러블슈팅

    문제는 GKE 노드가 재시작되거나, 특정 네트워크 이벤트를 겪은 후에 발생했습니다. 갑자기 WireGuard 터널을 통해 통신해야 하는 파드들이 서로 연결되지 않는 현상이 나타나기 시작한 겁니다. 처음엔 ‘이게 뭔가?’ 싶었죠. 🤯

    증상

    • WireGuard 터널을 사용하는 파드(Pod) 간의 통신 불능.
    • wg show 명령으로는 터널이 up 상태이고 피어들도 연결된 것처럼 보임.
    • 하지만 ping이나 curl 같은 기본적인 네트워크 명령어조차 실패.

    디버깅 과정

    저는 다음과 같은 단계로 디버깅을 시작했습니다.

    1. wg show 확인: 가장 먼저 WireGuard 자체의 상태를 확인했습니다. 아까 말씀드렸듯이, 터널은 정상적으로 보였거든요. latest handshake 시간도 최근으로 업데이트되고 있었고요.
    2. ip a, ip route 확인: WireGuard 인터페이스(wg0)가 정상적으로 IP를 가지고 있는지, 그리고 WireGuard 서브넷(Subnet)으로 가는 라우팅 테이블이 제대로 설정되어 있는지 확인했습니다. 여기서 이상한 점을 발견했습니다. 특정 노드에서는 WireGuard 서브넷으로 가는 라우팅 규칙이 사라져 있거나, GKE의 자체 네트워킹과 충돌하는 듯한 규칙이 혼재되어 있었습니다.
    3. iptables -L -n -v 확인: 라우팅 문제가 아니라 iptables 규칙 문제일 수도 있겠다 싶어서 확인해봤거든요. GKE는 자체적으로 복잡한 iptables 규칙들을 관리하는데, 제가 추가한 WireGuard 관련 규칙들이 제대로 적용되지 않거나, GKE의 규칙에 의해 덮어씌워지는 경우가 있었습니다. 특히 FORWARD 체인에서 문제가 발생할 가능성이 높다고 판단했어요.
    4. tcpdump 활용: 실제 패킷(Packet)이 어디까지 도달하는지 확인하기 위해 tcpdump를 사용했습니다. WireGuard 인터페이스(wg0)와 물리 인터페이스(eth0 등)에서 동시에 패킷을 캡처해보니, 파드에서 WireGuard 서브넷으로 나가는 패킷은 wg0으로 들어오지만, 실제 암호화되어 외부로 나가는 트래픽이 없거나, 혹은 돌아오는 응답이 중간에 사라지는 것을 확인했습니다.
    5. GKE 노드 재시작 테스트: 가장 결정적인 단서는 GKE 노드를 재시작할 때마다 문제가 발생한다는 것이었어요. 노드가 재시작되면 WireGuard DaemonSet 파드도 다시 시작되지만, 그 과정에서 네트워크 설정의 영속성(Persistence)이 깨지는 것이 분명했거든요.

    원인 분석: GKE의 자체 네트워킹과 WireGuard의 미묘한 충돌

    결론적으로 원인은 GKE의 자체 네트워킹 시스템과 WireGuard의 라우팅 및 iptables 설정이 충돌하거나, 혹은 부팅 시점의 Race Condition 때문이라는 것을 알게 되었습니다. GKE는 각 노드에 파드 IP를 할당하고, 복잡한 라우팅과 iptables 규칙을 관리합니다. 여기에 WireGuard가 별도의 터널 인터페이스를 만들고 라우팅 규칙을 추가하면서, 특정 상황에서 GKE의 기존 규칙이 WireGuard 규칙을 덮어쓰거나, WireGuard 규칙이 GKE 트래픽을 예상치 못한 곳으로 보내버리는 문제가 발생했던 거였거든요.

    특히 노드 재시작 시, GKE의 네트워킹이 먼저 설정을 완료하고 나서 WireGuard DaemonSet이 동작하면서, WireGuard가 추가하는 규칙들이 제대로 자리 잡지 못하는 경우가 있었습니다. 😩

    ✅ 해결책: 네트워크 설정의 영속성 확보

    이 문제를 해결하기 위해 여러 방법을 시도해봤는데, 가장 효과적이었던 방법은 네트워크 설정의 영속성을 강화하고, WireGuard 설정 스크립트가 GKE의 네트워킹 초기화 이후에 안정적으로 실행되도록 하는 것이었어요.

    1. PostUp/PostDown 스크립트 활용 및 영속성 강화

    WireGuard는 wg0.conf 파일 내에 PostUp 및 PostDown 명령어를 정의할 수 있습니다. 저는 여기에 필요한 라우팅 규칙과 iptables 규칙을 명시적으로 추가하고, wg-quick up wg0 명령어를 통해 이 스크립트들이 실행되도록 했습니다. DaemonSet의 command 섹션에서 이 부분을 좀 더 견고하게 만들었거든요.

    # /usr/local/bin/setup_wireguard.sh 내용 예시
    
    #!/bin/bash
    
    # WireGuard 커널 모듈 로드
    modprobe wireguard
    
    # GKE CNI 초기화를 위해 잠시 대기 (노드마다 다를 수 있음)
    sleep 10
    
    # /etc/wireguard/wg0.conf 파일에 PostUp/PostDown 설정 포함
    # 예시: PostUp = ip route add 10.10.0.0/16 dev wg0; iptables -A FORWARD -i wg0 -j ACCEPT; iptables -A FORWARD -o wg0 -j ACCEPT
    
    # WireGuard 인터페이스 활성화
    wg-quick up wg0
    
    # 설정이 유실되지 않도록 주기적으로 모니터링
    while true; do
      sleep 300
      # 필요시 wg0 상태 체크 및 재설정 로직
    done
    

    또한, WireGuard DaemonSet 파드가 시작될 때마다 이 setup_wireguard.sh 스크립트가 실행되도록 하고, 스크립트 내부에서 GKE 네트워킹이 완전히 준비될 때까지 일정 시간 대기하는 로직을 추가했습니다.

    2. AllowedIPs 정확한 설정

    wg0.conf 파일의 각 피어(Peer)에 대한 AllowedIPs 설정을 더욱 정확하게 지정했어요. 예를 들어, 특정 피어의 WireGuard IP만 허용하는 것이 아니라, 해당 피어 뒤에 있는 서브넷 전체를 AllowedIPs에 포함시켜 라우팅이 명확하게 이루어지도록 했습니다. 이건 WireGuard가 패킷을 어디로 포워딩할지 결정하는 정말 중요한 요소거든요.

    [Peer]
    PublicKey = <peer-public-key>
    Endpoint = <peer-endpoint>:51820
    AllowedIPs = 10.10.0.0/16, 192.168.10.0/24 # 정확한 서브넷 명시
    PersistentKeepalive = 25
    

    이 두 가지 방법을 적용하고 GKE 노드를 재부팅해보니, 드디어 문제가 해결되었습니다! 🎉 재부팅 후에도 WireGuard 터널을 통한 통신이 정상적으로 이루어졌고, 파드 간 연결도 원활했습니다. 정말이지 며칠 밤낮으로 씨름했던 문제가 해결되니 얼마나 기뻤는지 모릅니다.

    WireGuard 터널의 정상 작동을 확인하는 `wg show` 명령어 출력 및 네트워크 트래픽 모니터링 그래프

    WireGuard 터널의 정상 작동을 확인하는 wg show 명령어 출력과 정상적인 네트워크 트래픽 그래프입니다.

    마무리하며: GKE와 커스텀 네트워크 솔루션 통합 시 교훈

    이번 GKE WireGuard 네트워크 장애 해결 사례를 통해 제가 얻은 교훈은 다음과 같습니다.

    1. 관리형 서비스와 커스텀 솔루션의 경계 이해: GKE 같은 관리형 쿠버네티스 서비스는 자체적인 네트워크 관리 로직을 가지고 있습니다. 여기에 WireGuard 같은 커스텀 네트워크 솔루션을 통합할 때는 GKE의 기본 네트워킹 동작 방식을 정확히 이해하고, 충돌이 발생하지 않도록 주의해야 합니다. 특히 라우팅 테이블과 iptables 규칙은 가장 민감한 부분이거든요.
    2. 네트워크 설정의 영속성 확보: 쿠버네티스 노드는 언제든 재시작될 수 있습니다. 이때 수동으로 설정했던 네트워크 규칙들이 유실되지 않도록 DaemonSet의 command나 initContainer를 통해 영속적인 스크립트 실행 환경을 구축하는 것이 정말 중요합니다.
    3. 꼼꼼한 네트워크 디버깅 도구 활용: ip route, iptables, tcpdump, wg show 등 기본적인 네트워크 디버깅 도구들은 아무리 강조해도 지나치지 않습니다. 눈에 보이는 문제가 아니라, 실제 패킷의 흐름을 추적하는 것이 문제 해결의 핵심이거든요.
    4. 문서화 및 철저한 테스트: 복잡한 네트워크 설정을 적용할 때는 반드시 상세한 문서화를 해두고, 노드 재시작 등 다양한 시나리오에서 충분한 테스트를 거쳐야 합니다. 저도 이번에 테스트 시나리오를 좀 더 촘촘히 짰어야 했는데, 초기 검증이 미흡했던 점이 아쉬웠어요.

    GKE 운영 환경에서 커스텀 네트워크 솔루션을 도입하는 것은 분명 도전적인 일이지만, 잘만 활용하면 서비스의 유연성과 보안을 크게 향상시킬 수 있습니다. 이번 삽질 경험이 여러분의 GKE 운영에 작은 도움이 되기를 바라며, 다음번에는 또 다른 홈랩 삽질기를 들고 찾아오겠습니다! 😊

    GKE WireGuard 통합 시 고려해야 할 중요 체크리스트 인포그래픽

    GKE와 WireGuard를 통합할 때 고려해야 할 핵심 사항들을 요약한 체크리스트 인포그래픽입니다.

  • [Kubernetes] Cilium CNI 성능 벤치마크: Calico, Flannel과 직접 비교

    [Kubernetes] Cilium CNI 성능 벤치마크: Calico, Flannel과 직접 비교

    [Kubernetes] Cilium CNI 성능 벤치마크: Calico, Flannel과 직접 비교

    안녕하세요, 13년차 서버실 지킴이입니다. 오늘은 Kubernetes(쿠버네티스) 환경에서 가장 중요한 요소 중 하나인 CNI(Container Network Interface, 컨테이너 네트워크 인터페이스) 솔루션들의 성능을 제가 직접 벤치마크해본 경험을 공유하려고 해요. 특히 요즘 핫한 Cilium(실리움)이 기존의 Calico(칼리코), Flannel(플라넬)과 비교해서 얼마나 뛰어난지 궁금했거든요.

    인프라 엔지니어로 일하다 보면 ‘네트워크 성능이 왜 이렇게 느리지?’ 하는 답답함을 겪을 때가 많습니다. 특히 마이크로서비스 아키텍처에서는 Pod(파드) 간의 통신이 엄청나게 빈번하게 일어나기 때문에, CNI의 선택이 전체 애플리케이션 성능에 결정적인 영향을 미치죠. 저도 홈랩에서 이것저것 실험해보면서 이 문제로 삽질을 좀 했거든요. 그래서 이번 기회에 주요 CNI 솔루션들을 직접 비교해보면서 그 차이를 피부로 느껴보고 싶었습니다.

    CNI란 뭐고 어떤 종류가 있을까?

    먼저 CNI가 뭔지 간단하게 짚고 넘어갈게요. CNI는 컨테이너 런타임과 네트워크 플러그인 간의 표준 인터페이스를 정의한 규약입니다. 쉽게 말해, Kubernetes Pod들이 어떻게 서로 통신하고 외부와 연결될지 결정하는 ‘네트워크 길잡이’ 역할을 하는 거죠.

    • Flannel (플라넬): 가장 단순하고 설치가 쉬운 CNI 중 하나입니다. 주로 Overlay Network(오버레이 네트워크) 방식인 VXLAN(Virtual Extensible LAN)을 사용해요. 설정이 간단해서 초보자들이나 소규모 클러스터에서 많이 선택하지만, 성능 오버헤드가 좀 있는 편입니다.
    • Calico (칼리코): 네트워크 정책(Network Policy) 기능이 강력하고 성능도 준수해서 많은 프로덕션 환경에서 사용됩니다. IP-in-IP 터널링이나 BGP(Border Gateway Protocol) 라우팅 방식을 주로 쓰는데, 특히 BGP 모드에서는 오버헤드가 적어서 좋은 성능을 보여주죠. 보안 기능도 뛰어나고요.
    • Cilium (실리움): 오늘 주인공이죠! eBPF(extended Berkeley Packet Filter, 확장된 버클리 패킷 필터)라는 기술을 기반으로 합니다. eBPF는 리눅스 커널 내부에서 프로그램을 실행할 수 있게 해주는 기술인데, 이걸 활용해서 Cilium은 컨테이너 네트워크 트래픽을 커널 레벨에서 직접 처리합니다. 이 덕분에 기존 CNI들이 가졌던 성능 오버헤드를 크게 줄이고, 더 세밀한 네트워크 정책과 가시성(Observability)을 제공할 수 있게 되는 거예요. 처음엔 이게 뭔가 싶었는데, 써보니 진짜 매력적이더라고요.
    Flannel, Calico, Cilium CNI 솔루션의 네트워크 아키텍처 비교 다이어그램

    이 이미지는 Flannel, Calico, Cilium 각 CNI 솔루션의 네트워크 아키텍처를 시각적으로 비교하여, 데이터 플레인 처리 방식의 차이를 보여줍니다.

    실전 구현: 벤치마크 환경 준비와 테스트 방법

    자, 그럼 이제 제가 어떻게 벤치마크를 진행했는지 공유해볼게요. 홈랩에 Kubernetes 클러스터를 kubeadm으로 구성했고, 각 CNI를 순서대로 설치해가며 성능을 측정했습니다.

    1. Cilium CNI 벤치마크를 위한 환경 준비

    저는 3노드(마스터 1, 워커 2) Kubernetes 클러스터를 사용했습니다. 테스트의 공정성을 위해 각 CNI를 설치하기 전에는 항상 클러스터를 초기화하고 깨끗한 상태에서 시작했어요. 벤치마크 도구로는 네트워크 성능 측정에 널리 사용되는 netperf를 선택했습니다. TCP_STREAM(대역폭), TCP_RR(요청/응답 지연 시간) 두 가지 모드로 측정했어요.

    
    # netperf 설치 (Ubuntu 기준)
    sudo apt update
    sudo apt install netperf -y
    
    # 벤치마크용 Pod 배포 예시
    kubectl apply -f - <

    각 CNI를 설치한 후, netperf-server Pod를 배포하고 다른 Pod에서 netperf 클라이언트를 실행하여 서버 Pod로 트래픽을 보냈습니다. Pod-to-Pod 통신과 Pod-to-Service 통신 두 가지 시나리오를 모두 측정했어요.

    2. Cilium 포함 각 CNI 설치 및 성능 측정

    1. Flannel 설치 및 측정:
      
      kubectl apply -f https://raw.githubusercontent.com/flannel-io/flannel/master/Documentation/kube-flannel.yml
      # Pod Ready 확인 후 netperf 측정
      
    2. Calico 설치 및 측정:
      
      kubectl apply -f https://docs.tigera.io/calico/latest/manifests/calico.yaml
      # Pod Ready 확인 후 netperf 측정
      
    3. Cilium 설치 및 성능 측정:
      
      helm repo add cilium https://helm.cilium.io/
      helm install cilium cilium/cilium --version 1.15.5 \
        --namespace kube-system \
        --set ipam.mode=kubernetes \
        --set tunnel=vxlan \
        --set egressGateway.enabled=true # 예시 설정
      # Pod Ready 확인 후 netperf 측정
      

    ⚠️ 주의사항: 각 CNI를 설치하기 전에 기존 CNI를 완전히 삭제하고 클러스터를 초기화하거나, CNI 관련 리소스를 제거해야 합니다. 그렇지 않으면 네트워크 충돌로 Pod들이 정상적으로 시작되지 않을 수 있거든요. 제가 처음엔 이걸 놓쳐서 Pod들이 Pending(대기) 상태에서 벗어나지 못하는 삽질을 좀 했습니다 ㅎㅎ.

    이 이미지는 Kubernetes 클러스터에 Cilium CNI를 helm을 이용하여 설치하는 과정을 보여주는 터미널 스크린샷입니다.

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

    솔직히 말씀드리면, Cilium을 처음 설치할 때 좀 애먹었습니다. kubeadm으로 구성한 클러스터에서 Cilium Pod들이 CrashLoopBackOff(크래시 루프백 오프) 상태에 빠지더라고요. 확인해보니 커널 버전 문제와 eBPF 관련 의존성 설정이 제대로 안 된 경우였습니다. Cilium은 eBPF 기반이라 리눅스 커널 버전이 어느 정도 이상이어야 하고, 특정 커널 모듈이나 설정이 활성화되어 있어야 하거든요. 예를 들어, CONFIG_BPF_JIT 같은 커널 옵션이 활성화되어 있는지 확인해야 합니다.

    이런 문제 때문에 Cilium 설치 전에 공식 문서를 꼼꼼히 읽어보고, cilium preflight check 같은 명령어로 환경을 미리 점검하는 게 정말 중요합니다. 덕분에 커널 컴파일 옵션까지 찾아보는 등 깊은 공부를 하게 됐네요. 역시 삽질은 최고의 공부 방법입니다!

    검증 결과: Cilium CNI의 성능은 정말 압도적일까?

    수많은 테스트와 삽질 끝에 얻은 결과는 예상대로였습니다. Cilium이 Calico, Flannel 대비 전반적으로 더 우수한 네트워크 성능을 보여줬거든요.

    • Throughput (대역폭): 특히 대량의 데이터를 전송하는 TCP_STREAM 테스트에서 Cilium은 Calico나 Flannel보다 더 높은 처리량을 기록했습니다. eBPF 덕분에 커널 레벨에서 패킷을 직접 처리하면서 컨텍스트 스위칭(Context Switching) 오버헤드가 크게 줄어든 거 같아요.
    • Latency (지연 시간): 요청-응답(TCP_RR) 테스트에서도 Cilium이 가장 낮은 지연 시간을 보여줬습니다. 이는 마이크로서비스 간의 빈번한 API 호출에 있어 정말 중요한 이점이거든요. 애플리케이션의 반응성이 훨씬 좋아지는 거죠.

    물론, 테스트 환경이나 네트워크 구성에 따라 결과는 달라질 수 있습니다. 하지만 제 홈랩 환경에서는 Cilium의 성능 향상이 눈에 띄게 확인되었어요. 특히 Pod 간의 통신이 잦은 환경이라면 Cilium CNI의 도입을 진지하게 고려해볼 만하다고 생각합니다.

    Cilium, Calico, Flannel CNI 성능 벤치마크 결과 비교 그래프

    이 이미지는 Cilium, Calico, Flannel 각 CNI 솔루션의 네트워크 Throughput(대역폭)과 Latency(지연 시간) 벤치마크 결과를 보여주는 비교 그래프입니다.

    결론: Cilium은 미래의 CNI 표준이 될까?

    이번 벤치마크를 통해 Cilium의 강력한 성능을 직접 확인할 수 있었습니다. eBPF라는 혁신적인 기술을 기반으로 기존 CNI의 한계를 뛰어넘는 모습을 보여줬네요. 특히 고성능이 요구되는 환경이나 복잡한 네트워크 정책, 그리고 뛰어난 가시성이 필요한 곳이라면 Cilium은 정말 훌륭한 선택지가 될 겁니다.

    하지만 Cilium이 만능은 아닙니다. eBPF에 대한 이해가 필요하고, 상대적으로 커널 의존성이 높아서 환경 구성에 더 신경 써야 할 부분이 있어요. 설치와 설정도 Calico나 Flannel보다는 복잡할 수 있다는 점도 고려해야 합니다.

    결론적으로, 간단하고 빠른 배포가 우선이라면 Flannel, 안정적인 성능과 강력한 네트워크 정책이 필요하다면 Calico, 그리고 최고의 성능과 보안, 고급 가시성을 원한다면 Cilium을 고려해보시길 추천합니다. 저도 이제 프로덕션 환경에서 Cilium을 더 적극적으로 도입해볼까 고민 중입니다.

    다음번엔 Cilium의 네트워크 정책(Network Policy) 기능과 서비스 메시(Service Mesh) 연동에 대해 더 자세히 다뤄볼 예정이니 기대해주세요! 긴 글 읽어주셔서 감사합니다.

    Flannel, Calico, Cilium CNI 솔루션 장단점 및 추천 시나리오 요약 인포그래픽

    이 이미지는 Flannel, Calico, Cilium 각 CNI 솔루션의 주요 특징, 장점, 단점 및 추천 사용 시나리오를 요약 비교한 인포그래픽입니다.

  • [k8s] 쿠버네티스 Secret 관리 베스트 프랙티스: 민감 데이터 보안 강화 전략

    [k8s] 쿠버네티스 Secret 관리 베스트 프랙티스: 민감 데이터 보안 강화 전략

    도입부: 민감 데이터, 이렇게 방치해도 될까요?

    안녕하세요, 13년차 서버실 지킴이입니다. 쿠버네티스(Kubernetes)를 운영하다 보면 정말 많은 난관에 부딪히게 되죠. 그중에서도 민감 데이터(Sensitive Data) 관리는 늘 머리 아픈 숙제였어요. 저도 처음엔 별생각 없이 Secret 리소스를 사용했었는데, 시간이 지날수록 ‘이대로 괜찮을까?’ 하는 불안감이 커지더라고요. 개발자들이 접속 정보, API 키 같은 걸 그냥 Secret에 넣고 쓰는 모습을 보면서 ‘언젠가 터지겠구나’ 싶었거든요.

    실제로 쿠버네티스 환경에서 Secret 관리가 제대로 되지 않아 보안 사고로 이어진 사례도 심심치 않게 들려옵니다. 외부 공격은 물론이고, 내부에서도 불필요한 접근 권한 때문에 문제가 생기기도 하고요. 그래서 오늘은 제가 13년간 인프라 엔지니어로 일하며 겪었던 경험과 홈랩에서 직접 실험해본 것들을 바탕으로, 쿠버네티스 Secret 관리 베스트 프랙티스 체크리스트를 공유해드리려고 합니다. 민감 데이터를 안전하게 보호하기 위한 전략들을 함께 알아볼까요?

    쿠버네티스 클러스터 내 Secret 관리의 중요성을 보여주는 개요 다이어그램

    쿠버네티스 클러스터 내 Secret 관리의 중요성을 보여주는 개요 다이어그램입니다.

    쿠버네티스 Secret, 넌 누구니? (개념 설명)

    먼저, 쿠버네티스 Secret이 정확히 무엇인지부터 짚고 넘어갈게요. 쿠버네티스 Secret(시크릿)은 말 그대로 민감한 정보(Sensitive Information)를 저장하기 위한 오브젝트입니다. 데이터베이스 암호, OAuth 토큰, SSH 키 등을 여기에 저장하고 파드(Pod)에 주입해서 사용하죠. 흔히 환경 변수나 파일 형태로 파드에 마운트(Mount)해서 애플리케이션이 접근하도록 합니다.

    쉽게 말해, 컨테이너 이미지에 직접 민감 정보를 하드코딩(Hard-coding)하거나 YAML 매니페스트에 평문(Plaintext)으로 노출하는 대신, 쿠버네티스 자체적으로 제공하는 저장소를 이용하는 방식이라고 보시면 됩니다. 그런데 여기서 중요한 포인트! 쿠버네티스 Secret은 기본적으로 Base64(베이스64) 인코딩만 되어 있을 뿐, 암호화(Encryption)되어 있지 않습니다. 이 말은 인코딩된 문자열을 누구나 쉽게 디코딩해서 원본 값을 볼 수 있다는 뜻이에요. 이걸 모르고 Secret이 완전히 안전하다고 생각했다간 큰코다칠 수 있습니다.

    Secret 관리, 어떤 점이 문제일까요? (삽질 경험 공유)

    저도 처음엔 ‘그래도 쿠버네티스에서 제공하는 거니까 안전하겠지!’ 하고 막연하게 생각했었어요. 그래서 개발팀에서 요청하는 대로 DB 접속 정보나 외부 API 키를 kubectl create secret generic 명령어로 뚝딱 만들어서 배포했었죠. 그러다가 문득 kubectl get secret <secret-name> -o yaml 명령어를 쳐봤는데, 인코딩된 값들이 너무 쉽게 디코딩되는 걸 보고 깜짝 놀랐습니다. ‘아, 이건 아니구나’ 싶더라고요. 사실 Secret의 가장 큰 문제점은 다음과 같습니다.

    • Base64 인코딩은 암호화가 아니다: 위에서 설명했듯이, 누구나 쉽게 원본 값을 볼 수 있다는 점이 가장 치명적입니다.
    • etcd(엣시디)에 평문 저장 가능성: 쿠버네티스의 모든 오브젝트는 etcd라는 분산 키-값 저장소에 저장됩니다. etcd 자체가 암호화되어 있지 않다면, Secret 내용이 그대로 노출될 수 있습니다.
    • 접근 제어의 복잡성: Secret에 대한 접근 권한을 세밀하게 제어하지 않으면, 불필요한 사용자나 파드가 민감 정보에 접근할 수 있게 됩니다. RBAC(Role-Based Access Control) 설정을 잘못하면 문제가 생기죠.
    • GitOps(깃옵스) 환경과의 충돌: Secret을 Git 리포지토리에 저장하고 싶은데, 평문으로 올릴 수는 없잖아요? 그렇다고 인코딩된 값을 올리는 것도 보안상 좋지 않습니다. 버전 관리와 보안 사이에서 딜레마에 빠지게 됩니다.

    이런 문제점들 때문에 제가 밤늦게까지 홈랩에서 씨름하며 여러 솔루션을 찾아보고 적용해봤었죠. 삽질 좀 했습니다 ㅎㅎ

    민감 데이터 보안 강화 전략 체크리스트 (베스트 프랙티스)

    이제 본격적으로 쿠버네티스 Secret 관리 베스트 프랙티스 체크리스트를 공유해드릴게요. 이 전략들을 하나씩 적용해나가시면 훨씬 안전한 쿠버네티스 환경을 만들 수 있을 겁니다.

    1. etcd 암호화 (Encryption at Rest)

    가장 기본 중의 기본입니다. 쿠버네티스 클러스터의 핵심 데이터 저장소인 etcd에 저장되는 모든 데이터를 암호화해야 합니다. 특히 Secret 오브젝트는 반드시 암호화해야 합니다. 이를 Encryption at Rest(저장 데이터 암호화)라고 부르는데요, kube-apiserver(쿠브-API서버) 설정을 통해 Secret 리소스만 선택적으로 암호화할 수 있습니다.

    2. RBAC(Role-Based Access Control)으로 Secret 접근 제어

    누가 어떤 Secret에 접근할 수 있는지 RBAC를 통해 세밀하게 제어해야 합니다. 최소 권한 원칙(Principle of Least Privilege)을 적용하여, 꼭 필요한 사용자나 파드에게만 필요한 Secret에 대한 읽기 권한을 부여해야 합니다. 예를 들어, 특정 네임스페이스(Namespace)의 파드만 해당 네임스페이스의 Secret을 사용할 수 있도록 제한하는 것이죠.

    3. 외부 Secret 관리 솔루션 활용

    쿠버네티스 기본 Secret의 한계를 보완하기 위해 외부 Secret 관리 솔루션을 적극적으로 고려해보세요. 제가 홈랩에서도 여러 솔루션을 테스트해봤는데, 정말 편하더라고요.

    • HashiCorp Vault(하시코프 볼트): 중앙 집중식 Secret 관리 솔루션의 대명사입니다. 동적 Secret 생성, Secret 리스(Lease), 감사 로그(Audit Log) 등 강력한 기능을 제공합니다. 쿠버네티스와의 연동도 잘 되어 있어서 많은 기업에서 사용하고 있습니다.
    • Sealed Secrets(실드 시크릿): Bitnami에서 개발한 솔루션으로, Secret을 암호화하여 Git 리포지토리에 안전하게 저장할 수 있게 해줍니다. 클러스터 내의 컨트롤러(Controller)가 암호화된 SealedSecret을 복호화하여 일반 Secret으로 만들어줍니다. GitOps 환경에서 특히 유용하죠.
    • 클라우드 제공 Secret Manager: AWS Secrets Manager, Google Secret Manager, Azure Key Vault 등 클라우드 서비스에서 제공하는 Secret 관리 솔루션을 활용하는 것도 좋은 방법입니다.
    쿠버네티스와 외부 Secret 관리 솔루션(Vault, Sealed Secrets) 연동 아키텍처 예시입니다.

    쿠버네티스와 외부 Secret 관리 솔루션(Vault, Sealed Secrets) 연동 아키텍처 예시입니다.

    4. Kubelet Secret 볼륨 암호화 (KMS Provider)

    파드에 마운트(Mount)되는 Secret 볼륨은 tmpfs(임시 파일 시스템)에 저장되지만, 만약 Kubelet(쿠블릿) 노드가 탈취당했을 경우 메모리 덤프 등을 통해 Secret에 접근할 위험이 있습니다. 클라우드 환경에서는 KMS(Key Management Service) Provider를 활용하여 Secret 볼륨을 암호화할 수 있습니다. 예를 들어 AWS EKS나 GCP GKE에서는 KMS를 etcd 암호화뿐만 아니라 Secret 볼륨 암호화에도 활용할 수 있습니다.

    5. Secret 변경 시 애플리케이션 재시작/재배포

    쿠버네티스 Secret은 파드에 환경 변수나 볼륨으로 주입되는데, Secret의 내용이 변경되어도 파드는 자동으로 업데이트된 Secret을 로드하지 않습니다. 즉, 변경 사항을 적용하려면 해당 파드를 재시작(Restart)하거나 재배포(Redeploy)해야 합니다. 이 점을 잊고 ‘왜 Secret 바꿨는데 적용이 안 되지?’ 하고 저처럼 삽질하는 일이 없으시길 바랍니다. Deployment(디플로이먼트)의 Hash(해시) 기반 롤링 업데이트(Rolling Update)를 활용하거나, Reloader 같은 툴을 사용하면 좀 더 자동화할 수 있습니다.

    6. Secret Rotation (정기적 교체)

    아무리 강력하게 암호화하고 접근 제어를 해도, Secret이 영원히 안전하다고 보장할 수는 없습니다. 따라서 Secret을 정기적으로 교체(Rotation)하는 정책을 수립하고 자동화하는 것이 중요합니다. 예를 들어 데이터베이스 암호는 3개월마다, API 키는 6개월마다 교체하는 식이죠. 외부 Secret 관리 솔루션들은 이러한 Secret Rotation 기능을 자체적으로 제공하기도 합니다.

    실전 적용 가이드: etcd 암호화와 Sealed Secrets 예시

    이론만으로는 부족하죠! 제가 직접 적용해봤던 etcd 암호화와 Sealed Secrets의 간단한 예시를 보여드릴게요.

    etcd 암호화 설정

    kube-apiserver 설정을 수정하여 etcd에 저장되는 Secret을 암호화할 수 있습니다. EncryptionConfiguration API를 사용하는데, AES-CBC(고급 암호화 표준-Cipher Block Chaining) 방식이 널리 사용됩니다.

    apiVersion: apiserver.config.k8s.io/v1
    kind: EncryptionConfiguration
    resources:
      - resources:
          - secrets
        providers:
          - aescbc:
              keys:
                - secretbox:
                    secret: <YOUR_AES_KEY_BASE64> # Base64 인코딩된 32바이트 AES 키
          - identity: {}
          - secretbox: {}
    

    여기서 <YOUR_AES_KEY_BASE64>는 직접 생성한 AES 키를 Base64 인코딩한 값입니다. 이 키는 안전하게 보관해야 합니다. 이 설정 파일을 kube-apiserver에 적용하면, 이후 생성되는 Secret들은 모두 etcd에 암호화된 상태로 저장됩니다. 기존 Secret들도 재작성(rewrite)해야 암호화가 적용됩니다.

    Sealed Secrets 도입

    Sealed Secrets는 GitOps 환경에서 Secret을 안전하게 관리하기 위한 좋은 방법입니다. 먼저 클러스터에 Sealed Secrets 컨트롤러를 설치합니다.

    # 컨트롤러 설치 (helm 사용 예시)
    helm repo add sealed-secrets https://bitnami-labs.github.io/sealed-secrets
    helm repo update
    helm install sealed-secrets sealed-secrets/sealed-secrets -n kube-system
    
    # public key 추출
    kubeseal --fetch-cert > public-cert.pem
    

    그다음, 일반 Secret YAML 파일을 kubeseal CLI 툴을 사용하여 암호화합니다.

    # original-secret.yaml (평문 Secret 예시)
    apiVersion: v1
    kind: Secret
    metadata:
      name: my-app-secret
      namespace: default
    data:
      username: dXNlcg==
      password: cGFzcw==
    type: Opaque
    
    # Secret 암호화
    cat original-secret.yaml | kubeseal --cert public-cert.pem --format yaml > sealed-secret.yaml
    

    이렇게 생성된 sealed-secret.yaml 파일은 암호화되어 Git 리포지토리에 안전하게 저장할 수 있습니다. 클러스터 내의 Sealed Secrets 컨트롤러가 이 파일을 감지하고 자동으로 복호화하여 일반 Secret으로 만들어줍니다.

    Sealed Secrets의 작동 원리를 보여주는 시퀀스 다이어그램입니다.

    Sealed Secrets의 작동 원리를 보여주는 시퀀스 다이어그램입니다.

    제가 겪은 트러블슈팅: 권한 문제와 재배포

    이런 설정들을 적용하다 보면 예상치 못한 문제에 부딪히기 마련이죠. 제가 가장 많이 겪었던 ‘삽질’은 바로 RBAC 권한 문제였습니다. Secret에 대한 접근 권한을 너무 강하게 제한했더니, 정작 애플리케이션 파드가 Secret을 읽지 못해서 배포가 실패하는 경우가 많았어요. 에러 메시지에 permission denied나 secret not found가 뜨면 정말 머리아파죠.

    해결책은 간단했습니다. Role과 RoleBinding을 세밀하게 조정하는 것이죠. 특정 네임스페이스의 ServiceAccount(서비스 계정)에 해당 네임스페이스 내의 Secret에 대한 get, list, watch 권한만 부여하도록 했습니다. 그리고 kubectl auth can-i get secrets --as=system:serviceaccount:<namespace>:<serviceaccount-name> 명령어로 실제 권한을 꼼꼼히 확인하는 습관을 들였어요.

    또 하나는 위에서 언급했던 Secret 변경 후 파드 재배포 문제였습니다. Secret만 바꾸고 파드를 재시작하지 않아서 한참을 헤매다가 결국 kubectl rollout restart deployment <deployment-name> 명령어를 날려야 해결되는 걸 보고 허탈했던 기억이 있네요. 자동화 툴을 사용하기 전까지는 배포 스크립트에 반드시 재시작 로직을 포함시키는 것이 중요합니다.

    마무리하며: 안전한 쿠버네티스 운영을 위한 필수 요소

    오늘은 쿠버네티스 Secret 관리의 중요성과 함께, 제가 직접 겪고 배운 민감 데이터 보안 강화 전략 체크리스트를 공유해드렸습니다. 사실 쿠버네티스 Secret은 그 자체로 완벽한 보안 솔루션이라기보다는, 다른 보안 도구들과 함께 사용될 때 비로소 제 역할을 하는 퍼즐 조각이라고 생각합니다.

    정리하자면:

    1. etcd 암호화는 기본 중의 기본!
    2. RBAC로 Secret 접근 권한을 꼼꼼히 관리하기.
    3. Sealed Secrets나 Vault 같은 외부 솔루션으로 보안 강화 및 GitOps 환경 통합.
    4. KMS Provider를 활용한 Secret 볼륨 암호화 고려.
    5. Secret 변경 시 파드 재시작/재배포 잊지 말기.
    6. Secret Rotation으로 주기적인 보안 강화.

    이 체크리스트를 바탕으로 여러분의 쿠버네티스 환경이 더욱 안전해지기를 바랍니다. 민감 데이터는 언제나 최우선으로 보호해야 할 대상이니까요. 다음 글에서는 특정 외부 Secret 관리 솔루션을 더 깊이 파고드는 내용을 다뤄볼까 합니다. 기대해주세요!

    안전한 쿠버네티스 Secret 관리를 위한 핵심 체크리스트 요약 인포그래픽입니다.

    안전한 쿠버네티스 Secret 관리를 위한 핵심 체크리스트 요약 인포그래픽입니다.

  • [k8s] K3s와 AWX 통합 사례 연구: 경량 Kubernetes 자동화 워크플로우 구축

    [k8s] K3s와 AWX 통합 사례 연구: 경량 Kubernetes 자동화 워크플로우 구축

    안녕하세요, 13년차의 서버실입니다. 오늘은 제가 홈랩에서 직접 경험하고 삽질하면서 얻은 지식 하나를 여러분과 공유해볼게요. 바로 K3s(케이쓰리쓰)와 AWX(에이더블유엑스)를 통합하여 경량 Kubernetes(쿠버네티스) 환경에서 자동화 워크플로우를 구축하는 사례입니다.

    작은 규모의 인프라나 홈랩에서 Kubernetes를 운영하다 보면, 리소스 제약 때문에 고민이 많아지죠. 게다가 반복적인 배포나 설정 변경 작업을 수동으로 하다 보면 시간 낭비는 물론이고 휴먼 에러 발생 확률도 높아지고요. 저도 “이걸 어떻게 하면 좀 더 효율적으로 관리할 수 있을까?” 하는 고민에 빠져있었거든요. 그러다가 경량 Kubernetes인 K3s와 Ansible(앤서블) 기반의 자동화 플랫폼인 AWX의 조합을 떠올리게 됐습니다.

    이 둘을 잘 엮으면 리소스 효율적인 환경에서 강력한 자동화 시스템을 만들 수 있겠다는 확신이 들었죠. 그래서 직접 부딪혀가며 구축해봤고, 그 과정과 삽질 경험을 솔직하게 풀어보려 합니다. 혹시 여러분도 비슷한 고민을 하고 계셨다면, 이 글이 좋은 가이드가 될 수 있을 거예요. 💡

    K3s와 AWX를 통합한 자동화 워크플로우의 전체 아키텍처 다이어그램

    K3s 클러스터 위에 AWX가 배포되어 외부 Git 리포지토리의 Ansible 플레이북을 가져와 다른 K3s/Kubernetes 클러스터에 배포하는 통합 아키텍처 다이어그램입니다.

    K3s와 AWX, 왜 이 조합일까요?

    먼저, 이 두 가지 기술이 무엇인지, 그리고 왜 함께 사용하면 시너지가 나는지 간단하게 짚고 넘어가겠습니다.

    K3s: 가볍지만 강력한 경량 Kubernetes

    K3s(케이쓰리쓰)는 Rancher Labs(랜처 랩스)에서 만든 경량 Kubernetes(쿠버네티스) 배포판입니다. 이름에서 알 수 있듯이 ‘K8s(케이츠) – 5 = K3s’라는 유머러스한 의미를 가지고 있어요. 그만큼 바이너리 크기가 작고, 메모리 사용량도 적으니까요. 일반적인 Kubernetes는 컨트롤 플레인(Control Plane) 구성 요소들이 많은 리소스를 요구하는데, K3s는 SQLite를 기본 데이터베이스로 사용하고 불필요한 기능을 제거해서 엣지 컴퓨팅(Edge Computing), IoT(사물 인터넷), 또는 저사양 환경에 정말 딱 맞습니다. 제가 홈랩에서 운영하는 라즈베리 파이(Raspberry Pi) 클러스터 같은 곳에 정말 찰떡이더라고요. ✅

    AWX: Ansible 자동화 플랫폼의 중앙 허브

    AWX(에이더블유엑스)는 Red Hat(레드햇)의 Ansible Tower(앤서블 타워)의 오픈소스 업스트림 프로젝트입니다. Ansible(앤서블)은 강력한 IT 자동화 도구인데, AWX는 이 Ansible 플레이북(Playbook)들을 웹 UI를 통해 중앙에서 관리하고 실행할 수 있게 해줍니다. 그냥 복잡한 커맨드 라인(Command Line) 없이도 프로젝트, 인벤토리(Inventory), 자격 증명(Credential) 등을 관리하고, 잡 템플릿(Job Template)을 만들어 반복적인 작업을 예약하거나 실행 결과를 쉽게 확인할 수 있죠. 특히 팀 단위로 자동화 작업을 공유하고 접근 제어를 해야 할 때 진짜 빛을 발합니다. 🎉

    통합의 시너지: 경량 K3s 위의 자동화 플랫폼

    저는 K3s의 가벼움 위에 AWX를 올려서 경량 Kubernetes 환경을 위한 자동화 허브를 구축하고 싶었습니다. K3s에서 돌아가는 애플리케이션의 배포나 설정을 AWX를 통해 관리하려는 거였거든요. 예를 들어, 새로운 컨테이너 이미지를 빌드하면 AWX가 자동으로 K3s 클러스터에 배포하도록 하거나, 특정 서비스의 스케일링(Scaling) 작업을 AWX 잡 템플릿으로 만들어서 필요할 때마다 클릭 한 번으로 실행하는 식입니다. 이렇게 하면 인프라 관리가 정말 수월해지더라고요. 💡

    실전 구현: K3s 위에 AWX 배포하기

    이제 제가 직접 K3s 클러스터에 AWX를 배포했던 과정을 단계별로 설명해 드릴게요. 저는 이미 K3s 클러스터가 구성되어 있다는 가정하에 진행했습니다. 아직 K3s 설치가 안 되어 있다면, 다음 명령어로 간단하게 설치할 수 있습니다.

    curl -sfL https://get.k3s.io | sh -

    1. AWX Operator 설치

    AWX는 Kubernetes 환경에 AWX Operator(오퍼레이터)를 통해 배포하는 것이 가장 일반적입니다. Operator는 특정 애플리케이션(여기서는 AWX)을 Kubernetes의 컨트롤러처럼 관리해주는 도구라고 생각하시면 돼요. 배포부터 업데이트, 스케일링까지 알아서 처리해주니까요.

    AWX Operator를 설치하려면 공식 AWX Operator 저장소에서 최신 설치 가이드를 확인하시고, 다음 명령어로 설치합니다.

    kubectl apply -f https://raw.githubusercontent.com/ansible/awx-operator/devel/deploy/operator.yaml

    이 명령어가 AWX Operator와 필요한 CRD(Custom Resource Definition, 사용자 정의 리소스 정의)를 모두 설치해줍니다. CRD는 Kubernetes가 AWX라는 새로운 리소스 타입을 이해할 수 있도록 해주는 설정 파일이거든요. 이 과정을 거치면 awx-operator 파드(Pod)가 실행되면서 AWX 인스턴스를 배포할 준비가 완료됩니다.

    2. AWX 인스턴스 배포

    Operator가 준비되었다면, 이제 우리가 원하는 AWX 인스턴스를 생성할 차례입니다. AWX라는 Custom Resource(CR) 객체를 생성하면, Operator가 이 CR을 감지하고 실제 AWX 애플리케이션을 배포해줍니다. 저는 awx.yaml이라는 파일을 만들어서 다음과 같이 설정했습니다.

    apiVersion: awx.ansible.com/v1beta1
    kind: AWX
    metadata:
      name: my-awx
    spec:
      # AWX Operator가 배포할 AWX 인스턴스의 이름
      # 여기서는 my-awx로 지정했습니다.
    
      # ingressType: Ingress를 사용하여 Kubernetes Ingress를 통해 AWX에 접근하도록 설정합니다.
      # K3s는 기본적으로 Traefik Ingress Controller를 포함하고 있어 편리합니다.
      ingressType: Ingress
      # ingress_host: AWX에 접근할 호스트 이름을 지정합니다.
      # 실제 환경에서는 DNS에 이 호스트를 등록해야 합니다.
      ingress_host: awx.myhomelab.local
      
      # 기타 설정 (필요에 따라 주석 해제 및 수정)
      # postgres_storage_class: AWX 데이터베이스를 위한 Persistent Volume Claim(PVC)의 StorageClass를 지정합니다.
      # 홈랩 환경에서는 hostPath나 local-storage 등을 사용할 수 있습니다.
      # postgres_storage_class: standard
      
      # web_extra_volume_mounts: AWX 웹 파드에 추가 볼륨을 마운트할 때 사용합니다.
      # e.g., 인증서 마운트 등
      # tasks_extra_volume_mounts: AWX 태스크 파드에 추가 볼륨을 마운트할 때 사용합니다.
      
      # image_version: 사용할 AWX 이미지 버전 (특정 버전을 고정할 경우)
      # image_version: "23.3.0"
      
      # resource_requirements: AWX 파드들의 리소스 요청/제한을 설정합니다.
      # 작은 환경에서는 이 부분을 적절히 조절해야 합니다.
      # web_resource_requirements:
      #   requests:
      #     cpu: 500m
      #     memory: 1Gi
      #   limits:
      #     cpu: 1000m
      #     memory: 2Gi
    

    이 파일을 저장하고 kubectl apply -f awx.yaml 명령어를 실행하면 AWX Operator가 AWX 인스턴스에 필요한 Deployment(디플로이먼트), Service(서비스), Ingress(인그레스), Persistent Volume Claim(PVC) 등을 자동으로 생성하기 시작합니다.

    K3s 클러스터에 AWX 파드들이 정상적으로 실행 중임을 나타내는 터미널 화면

    AWX 웹 UI의 로그인 화면 또는 kubectl get pods -n awx 명령어를 실행했을 때 AWX 관련 파드들이 모두 Running 상태인 것을 보여주는 스크린샷입니다.

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

    제가 이 과정을 진행하면서 겪었던 몇 가지 삽질 경험과 해결 방법을 공유합니다. 여러분은 저처럼 헤매지 않으시길 바라요! 😂

    1. 리소스 부족 문제

    K3s는 가볍지만, AWX는 생각보다 많은 리소스를 필요로 합니다. 특히 데이터베이스(PostgreSQL)와 웹, 태스크 파드들이 동시에 돌아가기 때문에, 2GB RAM 이하의 시스템에서는 버벅이거나 파드가 계속 재시작되는 문제가 발생할 수 있어요. 최소 4GB RAM, 2코어 CPU 이상을 권장합니다. 저도 처음엔 라즈베리 파이 4(4GB 모델)에서 돌렸는데, 다른 서비스들과 함께 돌리니 정말 아슬아슬하더라고요. 결국 8GB 모델로 업그레이드하거나, AWX 전용 노드를 따로 두는 것을 고려하게 됐습니다.

    해결책: awx.yaml 파일의 resource_requirements 섹션을 통해 각 파드의 리소스 요청(requests)과 제한(limits)을 조절할 수 있습니다. 하지만 너무 낮추면 성능 문제가 발생하니, 하드웨어 사양을 충분히 확보하는 것이 최고의 방법입니다.

    2. Persistent Volume(영구 볼륨) 설정

    AWX는 데이터베이스(PostgreSQL)와 작업 실행 로그 등을 저장하기 위해 Persistent Volume(PV, 영구 볼륨)이 필요합니다. K3s는 기본적으로 local-path-provisioner(로컬 패스 프로비저너)를 내장하고 있어서 별도의 StorageClass(스토리지 클래스) 설정 없이도 PVC(Persistent Volume Claim)를 생성하면 자동으로 PV가 프로비저닝(Provisioning)됩니다. 하지만 이 방식은 특정 노드에 데이터가 종속되기 때문에 노드 장애 시 데이터 손실 위험이 있습니다.

    해결책: 홈랩 환경에서는 간단하게 hostPath 타입을 사용하여 특정 경로에 데이터를 저장할 수 있지만, 좀 더 안정적인 환경을 원한다면 NFS(네트워크 파일 시스템) 서버를 구축하고 NFS CSI Driver(드라이버)를 설치하여 공유 스토리지를 사용하는 것이 좋습니다. 저도 NFS를 사용해서 여러 노드에서 AWX 파드들이 유연하게 움직일 수 있도록 구성했거든요.

    3. Ingress(인그레스) 접근 문제

    ingress_host를 설정했지만, 웹 브라우저에서 접속이 안 되는 경우가 있었습니다. K3s는 기본적으로 Traefik(트래픽) Ingress Controller(인그레스 컨트롤러)를 내장하고 있어 편리합니다. 하지만 제 경우에는 다음과 같은 문제가 있었습니다.

    • DNS 설정: awx.myhomelab.local과 같은 호스트 이름을 사용하려면, 홈랩 내 DNS 서버에 해당 호스트를 등록하거나, 접속하려는 PC의 /etc/hosts (Linux/macOS) 또는 C:\Windows\System32\drivers\etc\hosts (Windows) 파일에 IP 주소와 호스트 이름을 직접 매핑해주어야 합니다.
      # /etc/hosts 예시
      192.168.1.100 awx.myhomelab.local # K3s 마스터 노드의 IP 주소
    • Traefik 설정: 가끔 Traefik이 외부 트래픽을 제대로 라우팅(Routing)하지 못하는 경우가 있는데, K3s 설치 시 Traefik 관련 옵션을 확인하거나, Traefik 대시보드(보통 http://<k3s_master_ip>:8080/dashboard/)에서 Ingress Route(인그레스 라우트)가 제대로 생성되었는지 확인해야 합니다.

    해결책: 저는 /etc/hosts 파일을 수정하고, kubectl get ingress -n awx 명령어로 AWX Ingress 리소스가 정상적으로 생성되었는지 확인하면서 문제를 해결했습니다.

    검증 및 결과: AWX로 K3s 자동화하기

    여러 삽질 끝에 드디어 AWX가 K3s 클러스터 위에 성공적으로 배포되었습니다! 🎉 이제 웹 브라우저를 열고 설정했던 ingress_host로 접속하면 AWX 로그인 화면이 보일 겁니다. 초기 관리자 비밀번호는 AWX Operator가 Secret(시크릿)으로 생성해두는데, 다음 명령어로 확인할 수 있습니다.

    kubectl get secret my-awx-admin-password -o jsonpath='{.data.password}' | base64 --decode

    로그인 후, 저는 간단한 Ansible 플레이북을 만들어서 K3s 클러스터의 노드 목록을 조회하는 작업을 자동화해봤습니다. AWX에서 Project(프로젝트), Inventory(인벤토리), Credential(자격 증명)을 설정하고 Job Template(잡 템플릿)을 생성한 뒤 실행하니, 깔끔하게 K3s 노드 정보가 출력되는 것을 확인할 수 있었습니다. 이 화면을 보는 순간, 그동안의 고생이 눈 녹듯 사라지더라고요! 정말 뿌듯했어요. 😄

    AWX 웹 UI에서 K3s 노드 목록을 조회하는 Ansible 잡이 성공적으로 실행된 결과 화면

    AWX 웹 UI에서 Ansible 플레이북이 성공적으로 실행되어 K3s 클러스터의 노드 목록을 출력하는 잡 실행 결과 화면 스크린샷입니다. 초록색 성공 메시지와 함께 결과가 표시됩니다.

    마무리: 경량 Kubernetes 자동화, 여러분도 해보세요!

    K3s와 AWX를 통합하여 경량 Kubernetes 환경에서 자동화 워크플로우를 구축한 경험은 저에게 정말 값진 시간이었습니다. 비록 중간중간 삽질도 많이 했지만, 그 과정에서 얻은 지식과 해결 능력은 어떤 책에서도 배울 수 없는 것이었거든요.

    주요 배운 점:

    • K3s는 가볍지만, AWX처럼 리소스를 많이 쓰는 애플리케이션을 올릴 때는 충분한 하드웨어 리소스 계획이 필요하다는 것.
    • Persistent Volume 설정은 안정적인 운영을 위한 핵심이라는 것. (홈랩이라도 NFS는 정말 중요합니다.)
    • Kubernetes Ingress와 DNS 설정은 항상 꼼꼼하게 확인해야 한다는 것.
    • AWX Operator를 사용하면 복잡한 AWX 배포를 Kubernetes 스타일로 정말 간단하게 할 수 있다는 것.

    이 조합은 특히 저처럼 홈랩을 운영하거나, 소규모 팀에서 효율적인 인프라 자동화를 목표로 할 때 정말 강력한 솔루션이 될 수 있다고 확신합니다. 여러분도 직접 K3s와 AWX를 설치하고 이것저것 만져보면서 자신만의 자동화 워크플로우를 구축해보시길 강력히 추천합니다. 직접 해보면서 얻는 경험만큼 값진 건 없으니까요! 💪

    다음 글에서는 AWX를 이용한 좀 더 복잡한 GitOps(깃옵스) 파이프라인 구축에 대해 더 깊이 다뤄볼 예정입니다. 기대해주세요! 😄

    K3s와 AWX 통합으로 얻을 수 있는 주요 장점을 시각적으로 요약한 인포그래픽

    K3s와 AWX 통합의 주요 장점 (예: 리소스 효율성, 중앙 집중식 자동화, 빠른 배포, 간편한 관리)을 시각적으로 요약한 인포그래픽입니다.

  • [k8s] Kubernetes Operator 활용 사례: 데이터베이스 관리 자동화로 운영 효율 높이기

    [k8s] Kubernetes Operator 활용 사례: 데이터베이스 관리 자동화로 운영 효율 높이기

    Kubernetes Operator 활용 사례: 데이터베이스 관리 자동화로 운영 효율 높이기

    안녕하세요, 13년차 서버실 지킴이입니다. 오늘은 쿠버네티스(Kubernetes, 컨테이너 오케스트레이션 플랫폼) 환경에서 데이터베이스(Database, DB)를 운영하며 겪었던 삽질과 그 해결책, 바로 쿠버네티스 오퍼레이터(Kubernetes Operator) 활용 경험을 여러분과 공유해볼까 합니다. 특히 데이터베이스처럼 상태 저장 애플리케이션(Stateful Application)을 쿠버네티스 위에서 안정적으로 운영하는 건 정말 만만치 않은 일이거든요. 혹시 이런 경험 있으신가요? 😥

    저도 처음엔 단순히 컨테이너화해서 배포하면 다 될 줄 알았습니다. 그런데 막상 해보니 백업, 복구, 스케일링, 고가용성(High Availability, HA) 구성까지, 수동으로 하려니 손이 너무 많이 가더라고요. 야간에 장애라도 나면 식은땀이 줄줄 흘렀죠. 그러다가 우연히 오퍼레이터라는 개념을 접하게 됐고, ‘이거다!’ 싶어서 바로 홈랩에 적용해봤습니다. 결과는 대성공이었죠. 운영 효율이 정말 몰라보게 좋아졌어요! 🎉

    쿠버네티스 오퍼레이터가 데이터베이스를 자동 관리하는 아키텍처 다이어그램

    쿠버네티스 오퍼레이터는 사용자 정의 자원(Custom Resource)을 통해 복잡한 애플리케이션을 쿠버네티스 안에서 자동 관리하는 모습을 보여줍니다.

    1. 쿠버네티스 오퍼레이터, 쉽게 말해 뭐죠?

    오퍼레이터는 한마디로 쿠버네티스 API를 확장해서 특정 애플리케이션의 운영 지식(Operational Knowledge)을 소프트웨어로 자동화한 것이라고 보시면 됩니다. 마치 숙련된 인프라 엔지니어가 24시간 상주하면서 데이터베이스를 관리해주는 것과 같아요. 쿠버네티스의 컨트롤러(Controller) 패턴과 사용자 정의 자원(Custom Resource Definition, CRD)을 활용해서 만들어지죠.

    • CRD (Custom Resource Definition): 쿠버네티스에 없는 새로운 API 객체(Object)를 정의할 수 있게 해줍니다. 예를 들어, ‘PostgreSQL’이라는 새로운 자원을 정의하고 싶다면 CRD를 만들 수 있어요.
    • 컨트롤러 (Controller): 정의된 CRD의 상태를 지속적으로 감시하고, 사용자가 원하는 상태(Desired State)와 실제 상태(Actual State)를 맞춰주는 역할을 합니다. 예를 들어, 사용자가 PostgreSQL 인스턴스 3개를 요청하면, 컨트롤러가 알아서 Pod를 3개 띄우고 복제(Replication)까지 설정해주는 식이죠.

    이게 왜 중요하냐면, 데이터베이스처럼 복잡한 상태 저장 애플리케이션은 단순히 컨테이너화하는 것만으로는 부족하거든요. 스케일링, 백업, 복원, 업그레이드, 장애 조치(Failover) 같은 작업들은 애플리케이션의 특성을 깊이 이해하고 있어야 합니다. 오퍼레이터는 이런 운영 지식을 코드로 만들어서, 우리가 직접 손댈 필요 없이 쿠버네티스 플랫폼 위에서 자동으로 처리하게 해주는 겁니다. 정말 편하더라고요!

    2. 왜 데이터베이스 관리에 오퍼레이터가 필요할까요?

    쿠버네티스는 본질적으로 무상태(Stateless) 애플리케이션에 최적화되어 있습니다. Pod가 언제 죽고 다시 생성될지 모르니, 중요한 데이터는 외부에 저장하라는 철학이죠. 하지만 데이터베이스는 핵심 중의 핵심 상태 저장(Stateful) 애플리케이션입니다. 이런 DB를 쿠버네티스 위에서 운영하려면 다음과 같은 문제에 부딪히게 됩니다.

    • 백업 및 복구(Backup & Restore): 주기적인 백업과 장애 시 신속한 복구는 필수인데, 이를 쿠버네티스 환경에 맞춰 자동화하는 것이 어렵습니다.
    • 고가용성(High Availability): 마스터-슬레이브(Master-Slave) 구조나 클러스터 구성으로 장애에 대비해야 하는데, Pod의 라이프사이클에 맞춰 동적으로 관리하기가 복잡합니다.
    • 스케일링(Scaling): 트래픽 증가에 따라 데이터베이스 인스턴스를 늘리거나 줄이는 작업도 수동으로는 어렵습니다.
    • 업그레이드(Upgrade): 무중단 업그레이드를 하려면 데이터베이스 버전별 특성을 고려해야 해서 많은 노력이 필요합니다.

    이런 문제들을 해결하기 위해 제가 직접 스크립트를 짜고 CronJob을 돌려보고… 정말 삽질 많이 했습니다. 하지만 오퍼레이터를 도입하고 나서는 이런 고민이 상당 부분 사라졌어요. 오퍼레이터가 알아서 DB의 상태를 모니터링하고, 백업을 수행하며, 장애가 발생하면 자동으로 페일오버까지 처리해주니, 정말 든든하더라고요.

    3. 실전 구현: 가상의 데이터베이스 오퍼레이터로 관리하기

    이제 실제로 어떻게 오퍼레이터를 활용하는지 간단한 예시를 통해 보여드릴게요. 여기서는 특정 데이터베이스 오퍼레이터의 이름을 직접 언급하기보다는, 개념적인 MyDatabase 오퍼레이터를 사용하겠습니다. 실제로는 Percona Operator for MySQL, Crunchy Data’s PostgreSQL Operator 같은 검증된 솔루션들이 많이 있습니다.

    가장 먼저 오퍼레이터 자체를 쿠버네티스 클러스터에 배포해야 합니다. 대부분 Helm Chart나 YAML 파일을 제공하니 어렵지 않아요. 배포가 완료되면, 이제 우리가 원하는 데이터베이스 인스턴스를 사용자 정의 자원(Custom Resource) 형태로 정의할 수 있게 됩니다.

    apiVersion: mydatabase.example.com/v1alpha1 # CRD에서 정의한 API 버전
    kind: MyDatabase                     # CRD에서 정의한 Kind
    metadata:
      name: my-prod-db
    spec:
      version: "14.5"                      # 원하는 데이터베이스 버전
      replicas: 3                          # 복제본 수 (고가용성)
      storageSize: 100Gi                   # 데이터 저장 공간
      backup:
        enabled: true
        schedule: "0 2 * * *"            # 매일 새벽 2시 백업
        retentionDays: 7                   # 7일치 백업 보관
      monitoring:
        enabled: true
      # ... 그 외 데이터베이스별 세부 설정들
    

    위 YAML 파일을 my-prod-db.yaml로 저장하고 kubectl apply -f my-prod-db.yaml 명령을 실행하면, MyDatabase 오퍼레이터가 이 요청을 감지하고 다음과 같은 작업을 수행합니다.

    1. MyDatabase CR(Custom Resource)에 정의된 스펙(Spec)을 파싱합니다.
    2. 지정된 버전(14.5)과 복제본 수(3개)에 맞춰 Pod, PersistentVolumeClaim(PVC), Service 같은 표준 쿠버네티스 자원들을 생성합니다.
    3. Pod들 간에 데이터베이스 복제 구성을 자동으로 수행합니다.
    4. 백업 스케줄(매일 새벽 2시)에 맞춰 백업 Pod를 실행하고, 지정된 스토리지에 데이터를 저장합니다.
    5. 데이터베이스 상태를 지속적으로 모니터링하며, 문제가 발생하면 자동으로 재시작하거나 페일오버를 수행합니다.
    쿠버네티스 대시보드에서 데이터베이스 오퍼레이터가 관리하는 Pod 상태

    쿠버네티스 대시보드에서 데이터베이스 오퍼레이터가 배포한 여러 컴포넌트(Pod, Service, PVC 등)와 그 상태를 한눈에 확인할 수 있습니다.

    4. ⚠️ 주의사항 및 트러블슈팅: 삽질은 국룰이죠!

    물론 오퍼레이터가 만능은 아닙니다. 저도 처음엔 ‘이거 하나면 다 되겠지!’ 생각했지만, 몇 번의 삽질을 통해 중요한 교훈을 얻었죠.

    • CRD 스펙 이해 부족: 오퍼레이터마다 CRD의 스펙이 다릅니다. 제가 사용하려던 백업 설정이 사실은 다른 필드에 있었던 적도 있어요. 반드시 해당 오퍼레이터의 공식 문서를 꼼꼼히 읽어봐야 합니다. 특히 버전별로 스펙이 달라지는 경우도 있으니 주의하세요.
    • PersistentVolume (PV) 문제: 데이터베이스는 PV를 사용하는데, PV 프로비저닝(Provisioning)에 문제가 생기거나 스토리지 클래스(StorageClass) 설정이 잘못되면 Pod가 Pending 상태에 머무는 경우가 많습니다. kubectl describe pod <pod-name>과 kubectl get events로 이벤트를 확인해서 원인을 찾아야 합니다.
    • 네트워크 설정: 데이터베이스 클러스터 내 통신이나 외부 애플리케이션과의 통신을 위해 Service와 Ingress(인그레스, 외부 트래픽 진입점) 설정을 잘 해주어야 합니다. 특히 StatefulSet을 사용하는 경우 Pod의 고정된 네트워크 ID를 활용하는 경우가 많으니 이 점도 고려해야 합니다.
    • 로그 확인의 중요성: 오퍼레이터 컨트롤러 Pod의 로그(kubectl logs -f <operator-pod-name>)를 확인하면 어떤 작업을 수행 중인지, 어떤 에러가 발생했는지 상세히 알 수 있습니다. 문제가 생기면 제일 먼저 확인해야 할 곳이죠.

    한번은 백업 스케줄을 설정했는데 백업이 계속 실패하는 거예요. 알고 보니 스토리지 크레덴셜(Credential) 설정이 잘못되어 외부 S3 버킷에 접근을 못 하고 있었던 거죠. 오퍼레이터 로그를 보고 나서야 겨우 해결했습니다. 삽질은 국룰이더라고요! ㅎㅎ

    5. 검증 및 결과: 드디어 안정적인 DB 운영!

    이런 시행착오를 겪으며 오퍼레이터를 제대로 이해하고 적용하자, 정말 운영 환경이 안정적으로 변했습니다. kubectl get mydatabase 명령으로 제가 배포한 데이터베이스 인스턴스들의 상태를 한눈에 볼 수 있게 되었고, Health Status나 백업 상태 등 중요한 정보를 쉽게 확인할 수 있었어요. 🎉

    $ kubectl get mydatabase
    NAME         VERSION   REPLICAS   STATUS    BACKUP_LAST_SUCCESS   AGE
    my-prod-db   14.5      3          Running   2023-10-26T02:00:00Z  3d
    my-dev-db    12.7      1          Running   -
    

    가장 좋았던 점은 바로 심리적인 안정감이었습니다. 밤에 잠을 자다가도 ‘혹시 DB 장애 나지 않았을까?’ 하는 불안감이 사라졌거든요. 백업과 복구 테스트도 오퍼레이터 덕분에 훨씬 쉬워졌고, 새로운 데이터베이스 인스턴스를 띄우는 시간도 단축되었습니다. 개발팀에서도 ‘DB 요청이 이렇게 빨리 처리되다니!’ 하며 놀라더라고요.

    데이터베이스 오퍼레이터 모니터링 대시보드의 건강 및 백업 성공률 그래프

    오퍼레이터가 제공하는 모니터링 대시보드에서 데이터베이스 클러스터의 전반적인 건강 상태와 백업 성공률을 시각적으로 확인하며 안정적인 운영을 검증합니다.

    6. 운영 효율 비교: 수동 vs. 오퍼레이터

    제가 직접 경험한 바에 따르면, 데이터베이스 운영 방식에 따른 효율 차이는 극명했습니다. 아래 표를 보시면 그 차이를 더 확실히 느끼실 수 있을 거예요.

    항목 수동 데이터베이스 관리 쿠버네티스 오퍼레이터 활용
    배포 시간 며칠 ~ 몇 주 (수동 설치, 설정, 복제 구성 등) 몇 분 ~ 몇 시간 (CRD 정의 후 적용)
    고가용성 수동 구성 및 모니터링, 장애 시 수동 복구 자동 복제, 자동 장애 감지 및 페일오버
    백업/복구 수동 스크립트 작성, 스케줄링, 복구 절차 복잡 자동 백업 스케줄링, 간편한 복구 명령
    스케일링 수동 인스턴스 추가, 복제 설정 변경 CRD Spec의 replicas 필드 변경으로 자동 스케일링
    업그레이드 복잡한 무중단 업그레이드 절차, 다운타임 위험 자동 롤링 업그레이드, 다운타임 최소화
    운영 복잡성 높음 (전문 지식 및 지속적인 수동 작업 필요) 낮음 (선언적 관리, 운영 지식 내재화)

    7. 마무리: 자동화, 이제 선택이 아닌 필수!

    쿠버네티스 오퍼레이터를 활용한 데이터베이스 관리 자동화는 저에게 정말 신세계였습니다. 처음에는 학습 비용과 삽질이 있었지만, 장기적으로 봤을 때 운영팀의 업무 부담을 줄이고 서비스 안정성을 크게 높이는 데 결정적인 역할을 했습니다. 특히 데이터베이스처럼 중요하고 복잡한 애플리케이션을 쿠버네티스 위에서 운영해야 한다면, 오퍼레이터는 이제 선택이 아니라 필수라고 감히 말씀드리고 싶네요.

    물론 모든 오퍼레이터가 완벽한 건 아닙니다. 각자의 환경과 데이터베이스 종류에 맞는 검증된 오퍼레이터를 신중하게 선택하고, 충분히 테스트해보는 과정은 여전히 중요합니다. 저도 아직 탐험할 부분이 많거든요! 다음번에는 또 다른 쿠버네티스 활용 사례나 홈랩에서 얻은 재미있는 경험담으로 찾아오겠습니다. 궁금한 점이 있다면 언제든지 댓글로 남겨주세요! 😉

    만족스러운 인프라 엔지니어와 안정적인 쿠버네티스 데이터베이스 클러스터

    인프라 엔지니어가 쿠버네티스 오퍼레이터 덕분에 안정적으로 운영되는 데이터베이스 클러스터를 보며 만족감을 느끼는 모습을 표현합니다.

  • [k8s] Helm 차트 관리의 진화: GitOps 시대의 베스트 프랙티스 분석

    [k8s] Helm 차트 관리의 진화: GitOps 시대의 베스트 프랙티스 분석

    안녕하세요, 13년차의 서버실입니다. 제가 처음 쿠버네티스(Kubernetes)를 접했을 때를 생각하면, 마치 새로운 대륙을 발견한 콜럼버스처럼 설레면서도 막막했던 기억이 나네요. 특히 애플리케이션 배포와 관리는 정말이지 끝없는 숙제 같았어요. 처음엔 kubectl apply -f 명령어로 YAML(야믈) 파일을 직접 하나하나 적용했었죠. 그러다 Helm(헬름, 쿠버네티스 패키지 매니저)을 만나고 나서야 비로소 숨통이 트이는 느낌이었습니다.

    Helm은 복잡한 쿠버네티스 애플리케이션을 패키징하고 배포하는 데 정말 혁신적인 도구였어요. 그런데 시간이 지나고 관리해야 할 차트(Chart)가 늘어나면서, 또 다른 고민이 생기더라고요. ‘이 많은 차트들을 어떻게 효과적으로 관리하고, 배포 이력을 추적하며, 안정적으로 운영할 수 있을까?’ 하는 문제였습니다. 수동으로 helm upgrade를 반복하는 건 실수 투성이였고, CI/CD(지속적 통합/지속적 배포) 파이프라인에 Helm 명령어를 넣는 것도 생각보다 손이 많이 갔거든요. ⚠️

    그러던 와중에 GitOps(깃옵스, Git 기반 운영 방식)라는 개념을 접하게 됐습니다. ‘아, 이거다!’ 싶었죠. 인프라와 애플리케이션의 상태를 Git 리포지토리(Repository)에 코드 형태로 정의하고, 이 Git을 유일한 진실의 원천(Single Source of Truth)으로 삼아 자동으로 클러스터 상태를 동기화하는 방식. 오늘은 이 GitOps 시대에 Helm 차트를 어떻게 하면 스마트하게 관리할 수 있는지, 제가 직접 홈랩에서 겪었던 경험과 함께 베스트 프랙티스(Best Practice)를 분석해 보려고 합니다. 여러분의 쿠버네티스 배포 여정에 이 글이 작은 등불이 되기를 바랍니다!

    GitOps 기반 Helm 차트 관리 아키텍처 개요 다이어그램

    GitOps 기반 Helm 차트 관리의 전체적인 아키텍처를 보여줍니다. 개발자가 Git에 변경사항을 푸시하면, GitOps 오퍼레이터(예: Flux CD)가 이를 감지하여 쿠버네티스 클러스터에 Helm 차트를 배포하는 흐름입니다.

    Helm과 GitOps, 그 관계를 파헤치다

    먼저 핵심 개념들을 잠시 짚고 넘어가 볼까요? 이미 잘 아시는 분도 많겠지만, 혹시 처음 접하는 분들을 위해 쉽게 설명해 드릴게요.

    • Helm (헬름): 쿠버네티스 패키지 매니저예요. 복잡한 애플리케이션을 차트(Chart)라는 패키지 형태로 정의하고, 이를 쉽게 설치, 업데이트, 삭제할 수 있도록 도와줍니다. 마치 리눅스의 apt나 yum처럼이죠. Deployment, Service, Ingress(인그레스, 외부 트래픽 진입점) 등 여러 쿠버네티스 리소스(Resource)들을 하나의 묶음으로 관리할 수 있게 해줘요.
    • GitOps (깃옵스): 쉽게 말해, Git을 중심으로 모든 것을 운영하는 방식입니다. 애플리케이션 코드뿐만 아니라, 인프라 구성(Infrastructure as Code)까지 전부 Git 리포지토리에 저장하고 관리합니다. 그리고 Git 리포지토리의 변경 사항이 감지되면, GitOps 에이전트(Agent)가 자동으로 쿠버네티스 클러스터에 배포하거나 상태를 동기화(Reconciliation)하는 구조예요. 사람이 직접 명령어를 입력할 필요 없이, Git에 커밋(Commit)만 하면 배포가 이뤄지는 거죠. 🎉

    그럼 Helm과 GitOps가 만나면 어떤 시너지를 낼까요? 기존에는 Helm 명령어를 CI/CD 파이프라인에서 실행하거나, 개발자가 직접 터미널에서 입력해서 배포했었죠. 하지만 GitOps를 도입하면, Helm 차트의 설정 파일(values.yaml)이나 차트 자체의 버전 변경을 Git에 커밋하는 것만으로 배포가 자동으로 트리거(Trigger)됩니다. ‘선언적(Declarative)’으로 상태를 정의하고, ‘자동으로 동기화(Automated Synchronization)’되는 거죠. 이 덕분에 배포의 투명성, 안정성, 감사(Audit) 용이성이 크게 향상됩니다. 제가 직접 해보니, 이게 진짜 편하더라고요!

    실전! GitOps 기반 Helm 차트 관리 구현: Flux CD를 중심으로

    홈랩에서 다양한 GitOps 툴을 실험해 봤는데, 개인적으로는 Flux CD(플럭스 CD)가 Helm 차트 관리에 참 잘 맞았어요. 물론 Argo CD(아르고 CD)도 훌륭한 대안이고요. 오늘은 Flux CD를 활용해서 GitOps 기반 Helm 차트 관리 환경을 구축하는 방법을 단계별로 설명해 드릴게요. 따라오시면 여러분도 쉽게 구현하실 수 있을 겁니다.

    1. Flux CD 설치 및 초기 설정

      먼저 쿠버네티스 클러스터(Cluster)에 Flux CD를 설치해야 합니다. Flux CLI(커맨드 라인 인터페이스)를 사용하면 정말 쉽게 설치할 수 있어요.

      
      # Flux CLI 설치 (macOS 기준, 다른 OS는 공식 문서 참고)
      brew install fluxcd/tap/flux
      
      # Flux CD 초기화 및 Git 리포지토리 연동
      # 여기서 your-git-repo는 GitOps 설정을 저장할 리포지토리 주소입니다.
      # --branch main은 기본 브랜치를 main으로 설정하는 것이고요.
      # --path clusters/my-cluster는 Flux가 모니터링할 Git 리포지토리 내 경로입니다.
      flux bootstrap git \
        --owner=<your-git-username> \
        --repository=<your-git-repo> \
        --branch=main \
        --path=clusters/my-cluster \
        --personal
              

      위 명령어를 실행하면 Flux CD가 필요한 컨트롤러(Controller)들을 쿠버네티스 클러스터에 설치하고, 지정된 Git 리포지토리와 연동합니다. 이제 Git 리포지토리 clusters/my-cluster 경로에 변경 사항이 생기면 Flux CD가 자동으로 감지하게 됩니다. ✅

    2. Git 리포지토리 구조 잡기

      GitOps의 핵심은 Git 리포지토리 구조를 잘 잡는 것입니다. 저는 보통 이런 식으로 구성합니다.

      
      .
      ├── clusters/
      │   └── my-cluster/ # Flux CD가 모니터링할 경로
      │       ├── flux-system/ # Flux CD가 생성한 리소스 (자동 관리)
      │       └── applications/ # 배포할 애플리케이션 HelmRelease 정의
      │           ├── nginx/
      │           │   └── nginx-helmrelease.yaml
      │           └── prometheus/
      │               └── prometheus-helmrelease.yaml
      └── helm-charts/ # 직접 만든 Helm 차트 (선택 사항, 외부 차트 사용 시 필요 없음)
          └── my-app/
              ├── Chart.yaml
              ├── values.yaml
              └── templates/
                  └── ...
              
    3. Helm 차트 정의 및 배포 (HelmRepository, HelmRelease)

      이제 애플리케이션을 배포해 볼까요? 예를 들어, 안정적인 Nginx(엔진엑스) Ingress Controller(인그레스 컨트롤러)를 배포한다고 가정해 봅시다. Flux CD에서는 HelmRepository와 HelmRelease라는 커스텀 리소스(Custom Resource)를 사용합니다.

      먼저 Helm 차트 저장소(Repository)를 정의합니다. Nginx Ingress Controller의 공식 Helm 저장소를 추가하는 HelmRepository 리소스입니다.

      
      # clusters/my-cluster/applications/nginx/nginx-helmrepository.yaml
      apiVersion: source.toolkit.fluxcd.io/v1beta2
      kind: HelmRepository
      metadata:
        name: ingress-nginx
        namespace: flux-system # Flux CD 시스템 네임스페이스
      spec:
        interval: 1h0m0s # 1시간마다 저장소 업데이트 확인
        url: https://kubernetes.github.io/ingress-nginx
              

      이 파일을 Git 리포지토리의 clusters/my-cluster/applications/nginx/ 경로에 저장하고 커밋(Commit)하면, Flux CD가 이를 감지하여 쿠버네티스 클러스터에 HelmRepository 리소스를 생성합니다. Flux CD는 이 저장소를 주기적으로 스캔하여 최신 차트 정보를 가져오게 됩니다. 💡

      Flux CD HelmRelease를 이용한 쿠버네티스 차트 배포 흐름

      Flux CD가 Git 리포토리의 HelmRelease 정의를 읽어 쿠버네티스 클러스터에 Helm 차트를 배포하는 과정을 시각화한 다이어그램입니다.

      다음으로, 실제로 Nginx Ingress Controller를 배포할 HelmRelease 리소스를 정의합니다. 여기에 어떤 차트를 어떤 버전으로, 어떤 값(values)으로 배포할지 상세하게 명시합니다.

      
      # clusters/my-cluster/applications/nginx/nginx-helmrelease.yaml
      apiVersion: helm.toolkit.fluxcd.io/v2beta1
      kind: HelmRelease
      metadata:
        name: ingress-nginx
        namespace: ingress-nginx # Nginx Ingress Controller가 배포될 네임스페이스
      spec:
        interval: 5m0s # 5분마다 상태 동기화 확인
        chart:
          spec:
            chart: ingress-nginx # HelmRepository에 정의된 차트 이름
            version: ">=4.0.0 <5.0.0" # 차트 버전 범위 지정
            sourceRef:
              kind: HelmRepository
              name: ingress-nginx # 위에서 정의한 HelmRepository 이름
              namespace: flux-system
        values: # values.yaml 내용과 동일
          controller:
            replicaCount: 2
            service:
              type: LoadBalancer
            nodeSelector:
              kubernetes.io/os: linux
          defaultBackend:
            enabled: true
              

      이 파일도 Git 리포지토리에 저장하고 커밋하면, Flux CD는 HelmRepository에서 차트를 가져와 이 HelmRelease 정의에 따라 Nginx Ingress Controller를 클러스터에 배포하게 됩니다. 와, 정말 깔끔하게 배포되는 거 보니까 속이 다 시원하더라고요! 이제 배포에 대한 모든 변경사항은 Git에서만 이뤄지게 됩니다. 🚀

    삽질 대잔치! 겪었던 문제와 해결 과정

    물론 이렇게 깔끔하게 설명했지만, 제가 이걸 처음 세팅할 때는 삽질 좀 했습니다 ㅎㅎ. 특히 몇 가지 문제로 머리를 싸맸던 기억이 나네요. 여러분은 저 같은 실수 하지 마시라고 몇 가지 팁을 공유해 드립니다. ⚠️

    • HelmRelease 동기화 실패:

      처음에는 Git에 커밋했는데도 클러스터에 아무런 변화가 없어서 당황했어요. 알고 보니 HelmRepository의 interval이나 HelmRelease의 interval 설정이 너무 길거나, Git 리포지토리 경로를 잘못 지정한 경우가 많았습니다. Flux CD의 로그를 꼼꼼히 확인하고, flux reconcile kustomization <kustomization-name> 명령어로 수동 동기화를 시도하면서 문제를 찾아냈습니다.

      
              # Flux CD Kustomization 상태 확인 (Git 리포지토리 동기화 상태)
              flux get kustomizations
      
              # Flux CD HelmRelease 상태 확인
              flux get hr -A # 모든 네임스페이스의 HelmRelease 확인
              
    • imagePullSecrets 적용 문제:

      프라이빗 레지스트리(Private Registry)에 있는 이미지를 사용해야 할 때, imagePullSecrets(이미지 풀 시크릿)을 ServiceAccount(서비스 어카운트)에 연결해야 하잖아요? 이걸 HelmRelease의 values에 직접 넣어도 되지만, 보안상 좋지 않거나 모든 ServiceAccount에 적용하고 싶을 때가 있습니다. 이럴 땐 Kustomize(커스터마이즈)를 활용하여 ServiceAccount에 imagePullSecrets를 패치(Patch)하는 방식으로 해결했습니다. Flux CD는 Kustomization 리소스도 지원해서, Helm과 Kustomize를 함께 사용하는 것도 가능합니다. (이건 다음 기회에 더 자세히 다뤄볼게요!)

    • 차트 버전 범위 지정 오류:

      HelmRelease에서 version: ">=4.0.0 <5.0.0"처럼 버전을 지정할 때, 세밀하게 지정하지 않으면 예상치 못한 마이너 버전 업데이트로 인해 문제가 생길 수 있습니다. 너무 넓은 범위보다는 안정성이 검증된 특정 버전이나, 패치 버전까지만 허용하는 것이 좋습니다.

    드디어! GitOps로 배포된 Helm 차트 확인

    이제 모든 설정이 완료되고 Git에 커밋까지 했다면, Flux CD가 자동으로 배포를 진행했을 겁니다. 배포가 제대로 되었는지 확인해 봐야겠죠? kubectl 명령어로 확인하면 됩니다.

    
    # Flux CD가 관리하는 Kustomization 리소스 상태 확인
    kubectl get kustomizations -n flux-system
    
    # Flux CD가 관리하는 HelmRelease 리소스 상태 확인
    kubectl get helmreleases -n ingress-nginx
    
    # Nginx Ingress Controller 파드(Pod) 확인
    kubectl get pods -n ingress-nginx
    

    helmreleases의 상태가 Ready이고, pods가 모두 Running 상태라면 성공입니다! 🎉 정말 깔끔하게 배포된 걸 보니까 속이 다 시원하더라고요. 이제 어떤 변경이든 Git 리포지토리에 반영하는 것만으로 배포가 자동으로 이뤄집니다. 롤백(Rollback)도 Git에서 이전 커밋으로 되돌리는 것만으로 가능하니, 얼마나 안정적이고 편리한지 몰라요.

    Kubernetes 클러스터에서 kubectl 명령어를 사용하여 Flux CD의 HelmRelease와 관련된 리소스들이 성공적으로 배포되고 실행 중인 상태를 보여주는 터미널 화면입니다.

    마무리하며: Helm GitOps, 더 나은 미래를 향해

    오늘은 13년차 인프라 엔지니어의 시선으로 Helm 차트 관리의 진화, 특히 GitOps 시대의 베스트 프랙티스를 Flux CD를 중심으로 알아봤습니다. 제가 직접 경험해 보니 GitOps는 단순히 도구를 사용하는 것을 넘어, 인프라 운영 방식 자체를 혁신하는 패러다임(Paradigm)이라는 생각이 들었습니다.

    GitOps 기반 Helm 차트 관리는 다음과 같은 장점들을 가져다줍니다.

    • 생산성 향상: 수동 작업 감소, 자동화된 배포.
    • 안정성 증대: Git을 통한 단일 진실의 원천, 쉬운 롤백.
    • 투명성 및 감사 용이성: 모든 변경 이력이 Git에 기록.
    • 협업 강화: 코드 리뷰(Code Review)를 통한 변경 사항 검증.
    전통적인 Helm 관리 방식과 GitOps 기반 Helm 관리 방식 비교표

    전통적인 Helm 관리 방식과 GitOps 기반 Helm 관리 방식을 주요 특징(자동화, 롤백, 투명성 등)별로 비교하는 인포그래픽 형태의 표입니다.

    물론 GitOps를 도입하는 것이 마냥 쉽지만은 않습니다. 초기 설정의 복잡성, Git 리포지토리 관리 전략 수립, 그리고 팀원들의 새로운 워크플로우(Workflow) 적응 등 넘어야 할 산들이 분명히 존재합니다. 하지만 그 모든 노력을 감수할 만큼의 가치가 충분하다고 저는 확신합니다. 결국 GitOps는 인프라 운영의 투명성과 안정성을 극대화하고, 개발팀과 운영팀 간의 협업을 더욱 매끄럽게 만드는 데 크게 기여할 겁니다.

    다음 글에서는 Flux CD의 고급 기능이나 다른 GitOps 툴인 Argo CD(아르고 CD)와의 비교, 또는 Kustomize를 활용한 Helm 차트 오버레이(Overlay) 방법에 대해서도 다뤄볼 예정입니다. 계속해서 “13년차의 서버실”에 많은 관심 부탁드립니다. 궁금한 점이나 여러분의 경험담이 있다면 댓글로 남겨주세요! 함께 고민하고 성장해 나가는 것이 저의 기쁨입니다. 😊

  • [k8s] AWX로 쿠버네티스 워크플로우 자동화: 실전 가이드

    [k8s] AWX로 쿠버네티스 워크플로우 자동화: 실전 가이드

    안녕하세요, 13년차 인프라 엔지니어 ’13년차의 서버실’ 주인장입니다. 오늘은 많은 분들이 고민하시는 쿠버네티스(Kubernetes) 워크플로우 자동화에 대해 이야기해보려고 해요. 특히 AWX를 활용해서 어떻게 복잡한 배포 과정을 효율적으로 관리할 수 있는지, 제가 직접 겪었던 경험과 실전 사례를 중심으로 풀어볼까 합니다. Ansible과 DevOps 문화에 관심 있는 분들이라면 이번 글이 정말 도움이 될 거예요.

    저도 처음엔 쿠버네티스 클러스터에 애플리케이션을 배포하는 과정이 꽤나 번거롭더라고요. 매번 kubectl apply -f 명령어를 입력하고, 버전 관리하고, 환경별로 설정 바꾸고… 반복적인 작업은 언제나 실수의 여지를 남기기 마련이잖아요. 그러다 보니 자연스럽게 자동화의 필요성을 느끼게 됐고, 홈랩에서 AWX(Ansible Workflow eXecutor)를 활용한 솔루션을 모색하게 됐습니다. 직접 삽질해가며 구축했던 과정, 지금부터 솔직하게 공유해볼게요.

    AWX와 쿠버네티스 연동을 통한 워크플로우 자동화 개요 아키텍처 다이어그램, AWX가 Git에서 Ansible Playbook을 가져와 쿠버네티스에 배포하는 과정을 보여줍니다.

    AWX와 쿠버네티스 연동을 통한 워크플로우 자동화 개요 아키텍처 다이어그램. AWX가 Git 저장소에서 Ansible Playbook을 가져와 쿠버네티스 API를 통해 리소스를 배포하는 과정을 보여줍니다.

    AWX와 쿠버네티스, 왜 함께 써야 할까요?

    먼저 핵심 개념부터 짚고 넘어갈게요. AWX는 Ansible Automation Platform의 업스트림 오픈소스 프로젝트로, 웹 기반 UI를 통해 Ansible Playbook을 실행하고 관리해주는 도구예요. 쉽게 말해, 터미널에서 명령어로 실행하던 Ansible 작업을 UI로 편하게 스케줄링하고, 권한을 관리하고, 실행 결과를 모니터링할 수 있다는 거죠. 제가 홈랩에서 다양한 자동화 실험을 할 때 정말 유용하게 써먹고 있는 녀석입니다.

    그리고 쿠버네티스(Kubernetes, K8s)는 컨테이너화된 워크로드와 서비스를 자동으로 배포, 스케일링 및 관리해주는 오픈소스 시스템이에요. 컨테이너 오케스트레이션(Container Orchestration)의 사실상 표준이 되었죠. 선언적(Declarative) 방식으로 원하는 상태를 정의하면, 쿠버네티스가 그 상태를 유지하도록 알아서 관리해줍니다. 저는 주로 Deployment(디플로이먼트)와 Service(서비스), Ingress(인그레스, 외부 트래픽 진입점) 같은 리소스들을 YAML 파일로 정의해서 사용하고 있어요.

    이 둘을 함께 쓰면 어떤 시너지가 생길까요? 바로 선언적 인프라(Declarative Infrastructure) 관리가 가능해진다는 거예요. Ansible Playbook으로 쿠버네티스 리소스의 최종 상태를 정의하고, AWX가 이 Playbook을 실행해서 클러스터에 배포하는 방식이죠. 이렇게 하면 수동 작업으로 인한 오류를 줄이고, 배포 과정을 표준화하며, 지속적인 통합/배포(CI/CD) 워크플로우를 구축하는 데 정말 큰 도움이 돼요. 실제 운영 환경에서 이 조합은 정말 강력하더라고요.

    실전 구현: AWX로 쿠버네티스 워크플로우 자동화하기

    자, 그럼 이제 제가 직접 구축했던 방법을 단계별로 보여드릴게요. 목표는 AWX를 통해 간단한 Nginx 웹 서버를 쿠버네티스 클러스터에 배포하고, 외부에 노출시키는 거예요.

    1단계: AWX 환경 설정

    1. 인벤토리(Inventory) 생성: AWX에서 Playbook을 실행할 대상(Host)을 정의합니다. 여기서는 쿠버네티스 클러스터의 API 서버에 접근해야 하므로, 로컬 호스트를 대상으로 하거나, 쿠버네티스 API 엔드포인트를 지정해요. 저는 주로 localhost를 대상으로 하고, kubeconfig 파일을 통해 클러스터에 접근하는 방식을 선호합니다.
    2. 자격 증명(Credential) 생성: 쿠버네티스 클러스터에 접근하기 위한 자격 증명이 필요해요. kubeconfig 파일을 AWX에 등록하는 방법이 가장 일반적입니다.
    # AWX Credential 설정 예시 (Kubeconfig Type)
    # --- Kubeconfig 내용 --- (실제 파일 내용)
    apiVersion: v1
    clusters:
    - cluster:
        certificate-authority-data: ...
        server: https://your-kubernetes-api-server:6443
      name: my-cluster
    contexts:
    - context:
        cluster: my-cluster
        user: my-user
      name: my-context
    current-context: my-context
    kind: Config
    preferences: {}
    users:
    - name: my-user
      user:
        client-certificate-data: ...
        client-key-data: ...
    

    2단계: Ansible Playbook 작성

    쿠버네티스 리소스를 배포하기 위한 Playbook을 작성해요. Ansible이 제공하는 kubernetes.core.k8s 모듈로 쿠버네티스 리소스 관리가 정말 쉬워진다니까요. 저는 Nginx Deployment와 Service를 배포하는 Playbook을 만들었어요.

    # playbook.yaml
    ---
    - name: Deploy Nginx to Kubernetes
      hosts: localhost
      connection: local
      collections:
        - kubernetes.core
    
      vars:
        namespace: default
        app_name: my-nginx
        image_version: 1.25.3
    
      tasks:
        - name: Ensure Namespace exists
          kubernetes.core.k8s:
            api_version: v1
            kind: Namespace
            name: "{{ namespace }}"
            state: present
    
        - name: Deploy Nginx Deployment
          kubernetes.core.k8s:
            state: present
            definition: |
              apiVersion: apps/v1
              kind: Deployment
              metadata:
                name: "{{ app_name }}-deployment"
                namespace: "{{ namespace }}"
                labels:
                  app: "{{ app_name }}"
              spec:
                replicas: 2
                selector:
                  matchLabels:
                    app: "{{ app_name }}"
                template:
                  metadata:
                    labels:
                      app: "{{ app_name }}"
                  spec:
                    containers:
                    - name: "{{ app_name }}"
                      image: nginx:"{{ image_version }}"
                      ports:
                      - containerPort: 80
    
        - name: Expose Nginx Service
          kubernetes.core.k8s:
            state: present
            definition: |
              apiVersion: v1
              kind: Service
              metadata:
                name: "{{ app_name }}-service"
                namespace: "{{ namespace }}"
                labels:
                  app: "{{ app_name }}"
              spec:
                selector:
                  app: "{{ app_name }}"
                ports:
                  - protocol: TCP
                    port: 80
                    targetPort: 80
                type: NodePort # 또는 LoadBalancer, ClusterIP 등 환경에 맞게
    

    이 Playbook을 Git 저장소(예: GitHub, GitLab)에 커밋해요. AWX가 이 저장소에서 Playbook을 가져와 실행할 거거든요.

    3단계: AWX 프로젝트 및 작업 템플릿(Job Template) 설정

    AWX UI에서 다음을 설정합니다.

    1. 프로젝트(Project) 생성: Git 저장소를 연결하여 Playbook을 가져와요.
    2. 작업 템플릿(Job Template) 생성: 이 템플릿에 위에서 만든 인벤토리, 자격 증명, 프로젝트, 그리고 실행할 Playbook 파일(playbook.yaml)을 연결합니다.
    AWX 작업 템플릿 설정 화면 스크린샷, Git 프로젝트, 인벤토리, 쿠버네티스 자격 증명, 실행할 Playbook 파일을 지정하는 모습

    AWX 작업 템플릿 설정 화면 스크린샷. Git 프로젝트, 인벤토리, 쿠버네티스 자격 증명, 실행할 Playbook 파일을 지정하는 모습을 보여줍니다.

    ⚠️ 삽질 경험 & 워크플로우 자동화 트러블슈팅

    제가 이 AWX와 쿠버네티스 자동화 과정을 진행하면서 겪었던 몇 가지 삽질과 그 해결책을 공유할게요. 혹시 비슷한 문제를 겪는 분들이 있다면 도움이 될 거예요.

    • 인증 오류 (Authentication Error): 가장 흔한 문제 중 하나예요. kubeconfig 파일의 권한 문제, 또는 파일 내용 자체가 잘못된 경우가 많았어요. 특히 client-certificate-data와 client-key-data가 정확한 base64 인코딩 값인지 여러 번 확인했거든요. AWX가 실행되는 컨테이너 환경에서 kubeconfig 파일에 접근 권한이 없어서 생기는 경우도 있었고요. 💡 팁: AWX 컨테이너 내부에서 kubectl get pods를 직접 실행해보며 인증 문제를 디버깅해보세요.
    • YAML 문법 오류: 쿠버네티스 리소스 정의는 YAML 파일로 하는데, 들여쓰기나 오타 하나로도 워크플로우가 실행 안 돼요. 특히 Ansible Playbook 내 definition 블록 안에 YAML을 넣을 때는 더욱 주의해야 합니다. ⚠️ 경고: definition: | 다음 줄부터는 반드시 두 칸 이상 들여쓰기 해야 합니다!
    • Ansible kubernetes.core.k8s 모듈 문제: 처음에는 이 모듈을 쓰는 게 익숙하지 않아서 헤맸어요. 특히 state: present로 리소스를 생성하고, state: absent로 삭제하는 방식에 익숙해지는 데 시간이 좀 걸렸거든요. 그리고 kubeconfig 파일 경로를 명시적으로 지정해야 하는 경우도 있었습니다 (kubeconfig: /path/to/kubeconfig).
    • 네트워크 연결 문제: AWX가 쿠버네티스 API 서버에 접근할 수 없는 네트워크 환경일 경우 당연히 실패하죠. 방화벽 규칙이나 네트워크 정책을 다시 확인해야 해요.

    ✅ 결과 검증 및 자동화의 힘!

    모든 설정이 끝나면, AWX UI에서 작업 템플릿을 실행(Launch)해요. Playbook이 성공적으로 실행되면 AWX 작업 로그에서 초록색 SUCCESS 메시지를 확인할 수 있어요. 저도 이 메시지를 처음 봤을 때, “드디어 됐다!” 하고 쾌재를 불렀던 기억이 생생해요.

    이제 쿠버네티스 클러스터에서 실제로 리소스가 배포되었는지 확인해볼 차례입니다.

    
    kubectl get deployments -n default
    # NAME                  READY   UP-TO-DATE   AVAILABLE   AGE
    # my-nginx-deployment   2/2     2            2           2m
    
    kubectl get services -n default
    # NAME              TYPE       CLUSTER-IP      EXTERNAL-IP   PORT(S)        AGE
    # my-nginx-service   NodePort   10.96.123.456   <none>        80:3xxxx/TCP   2m
    

    정상적으로 Nginx Deployment와 Service가 생성된 걸 확인할 수 있어요. 이제 NodePort로 할당된 포트를 통해 Nginx 웹 서버에 접속하면 “Welcome to Nginx!” 페이지를 볼 수 있을 거예요. 🎉 정말 편리하지 않나요? 몇 번의 클릭만으로 쿠버네티스에 애플리케이션을 배포하는 워크플로우 자동화가 완성된 거죠.

    AWX 작업 성공 로그와 kubectl get pods/deployments 명령 결과 비교 화면, AWX의 성공적인 Task 완료와 쿠버네티스 배포 리소스 확인

    AWX 작업 성공 로그와 kubectl get pods/deployments 명령 결과 비교 화면. AWX의 Job Output에서 Task가 성공적으로 완료된 것을 보여주고, 터미널에서 kubectl 명령어로 배포된 리소스들을 확인하는 모습을 나란히 보여줍니다.

    마무리하며: 자동화, 멈추지 않는 여정

    이번 AWX와 쿠버네티스 연동 사례를 통해 워크플로우 자동화가 얼마나 강력한지 다시 한번 느꼈어요. 단순한 배포를 넘어, IaC(Infrastructure as Code, 코드형 인프라)의 개념을 실현하고, DevOps 파이프라인의 핵심 구성 요소로 활용할 수 있다는 것이 핵심이죠.

    인프라 엔지니어로서 제가 얻은 가장 큰 교훈은 “반복되는 작업은 무조건 자동화하라”는 거예요. 처음엔 자동화 스크립트 작성에 시간이 들지언정, 장기적으로는 시간과 노력을 아끼고, 휴먼 에러를 줄여준다는 걸 뼈저리게 경험했거든요. 이 경험이 여러분의 인프라 관리에도 작은 영감이 되기를 바랍니다.

    다음 글에서는 이 워크플로우를 확장해서 Ingress 컨트롤러를 배포하고, 외부 도메인으로 서비스에 접근하는 방법을 다뤄볼까 해요. 기대해주세요!

    AWX, Ansible, Kubernetes, DevOps 로고들이 원형으로 배치된 인포그래픽. 각 로고들이 서로 연결되어 워크플로우 자동화를 이루는 모습을 시각적으로 보여줍니다.

  • [k8s] 쿠버네티스 스토리지: CSI 드라이버를 활용한 영구 스토리지 관리 및 최적화

    [k8s] 쿠버네티스 스토리지: CSI 드라이버를 활용한 영구 스토리지 관리 및 최적화

    안녕하세요, 13년차의 서버실입니다!

    저는 인프라 엔지니어로 일하면서 수많은 서버실을 드나들었고, 홈랩에서도 다양한 기술을 직접 실험해보고 있거든요. 특히 쿠버네티스(Kubernetes)를 운영하면서 가장 머리 아팠던 부분 중 하나가 바로 스토리지(Storage) 문제였습니다.

    컨테이너는 Stateless(무상태)여야 한다지만, 실제 애플리케이션은 데이터가 필요하잖아요? DB나 파일 서버 같은 것들 말이죠. 컨테이너가 죽거나 재시작하면 데이터가 홀라당 날아가 버리는 경험… 혹시 해보셨나요? 제가 그랬거든요, 처음엔. 😭

    그래서 오늘은 쿠버네티스 환경에서 데이터를 안전하게 보관하고 관리하는 핵심 기술인 CSI (Container Storage Interface) 드라이버를 활용한 영구 스토리지(Persistent Storage) 관리 및 최적화 방법에 대해 제 경험을 바탕으로 솔직하게 이야기해보려고 합니다. 💡

    쿠버네티스에서 스토리지가 어떻게 연결되는지 전반적인 아키텍처를 보여주는 다이어그램입니다. CSI 드라이버가 핵심 역할을 하는 것을 볼 수 있습니다.

    1. 쿠버네티스 영구 스토리지, 왜 필요하고 어떻게 작동하나요?

    쿠버네티스에서 애플리케이션이 데이터를 영구적으로 저장하려면 몇 가지 핵심 개념을 알아야 합니다. 쉽게 말해, 컨테이너는 휘발성(Ephemeral)이라서 데이터를 저장해도 컨테이너가 사라지면 데이터도 같이 사라져요. 그래서 컨테이너 외부에 데이터를 안전하게 보관할 수 있는 공간이 필요한데, 이걸 영구 스토리지(Persistent Storage)라고 부릅니다.

    PersistentVolume (PV, 영구 볼륨): 물리적인 스토리지 자원

    PV는 실제 물리적인 스토리지 공간, 예를 들면 네트워크 파일 시스템(NFS)의 특정 디렉터리나 클라우드 제공자의 디스크(AWS EBS, Google Persistent Disk 등)를 추상화한 겁니다. 클러스터 관리자가 미리 정의해두죠. 마치 서버실의 빈 하드디스크 같은 개념이랄까요? PV는 특정 스토리지 솔루션과 연결되어 실제 데이터를 저장하는 역할을 합니다.

    PersistentVolumeClaim (PVC, 영구 볼륨 요청): 애플리케이션의 스토리지 요구

    PVC는 Pod(파드)가 사용할 스토리지의 “요구 사항”을 선언하는 겁니다. “나는 10GiB(기가바이트) 용량의 ReadWriteOnce(한 번에 한 Pod만 쓰기 가능) 모드의 스토리지가 필요해!” 하고 요청하는 거죠. 사용자가 빈 하드디스크를 “내 거”라고 찜하는 것과 비슷합니다. Pod는 PV에 직접 접근하는 대신 PVC를 통해 스토리지를 요청하고 사용합니다.

    StorageClass (스토리지 클래스): 스토리지 프로비저닝 자동화

    여기서부터 좀 더 편리해집니다. StorageClass는 스토리지의 “종류”를 정의하는 템플릿이라고 보시면 돼요. 예를 들어, “빠른 SSD 스토리지”, “저렴한 HDD 스토리지”, “백업용 스토리지” 같은 거죠. StorageClass를 사용하면 PVC가 요청할 때 PV를 자동으로 생성(Dynamic Provisioning)해줍니다. 제가 처음엔 PV를 일일이 만들었었는데, StorageClass 덕분에 삽질을 훨씬 줄일 수 있었어요. 이거 진짜 편하더라고요! ✅

    StorageClass는 어떤 CSI 드라이버를 사용할지, 어떤 볼륨 타입(SSD/HDD), 회수 정책(reclaim policy) 등을 정의합니다.

    CSI (Container Storage Interface) 드라이버: 쿠버네티스와 스토리지 연결 고리

    자, 오늘의 주인공입니다! CSI 드라이버는 쿠버네티스가 다양한 외부 스토리지 시스템(NFS, Ceph, AWS EBS, OpenEBS 등)과 통신할 수 있도록 표준화된 인터페이스를 제공합니다. 스토리지 벤더들은 이 CSI 표준에 맞춰 드라이버를 개발하고, 쿠버네티스는 이 드라이버를 통해 어떤 스토리지든 일관된 방식으로 사용할 수 있게 되는 거죠. 마치 USB 포트에 어떤 장치를 꽂아도 표준 드라이버 덕분에 작동하는 것과 비슷하다고 보시면 됩니다. 덕분에 쿠버네티스가 특정 스토리지 솔루션에 종속되지 않고 유연하게 확장될 수 있더라고요. 💡

    2. CSI 드라이버를 활용한 영구 스토리지 설정하기 (NFS CSI 드라이버 예시)

    제가 홈랩에서 가장 많이 쓰는 방식 중 하나가 바로 NFS (Network File System)를 이용한 영구 스토리지입니다. 간편하고 설정하기도 쉬워서 처음 시작하는 분들께도 추천드려요. 여기서는 NFS CSI 드라이버를 예시로 들어볼게요.

    (⚠️ 사전에 NFS 서버가 구성되어 있고, 쿠버네티스 클러스터에서 접근 가능해야 합니다.)

    2.1. NFS CSI 드라이버 배포

    먼저 NFS CSI 드라이버를 쿠버네티스 클러스터에 배포해야 합니다. 보통 Helm 차트나 manifests 파일을 통해 배포하죠. 저는 안정적인 버전의 Helm 차트를 선호하는 편입니다.

    저는 보통 프로젝트 공식 저장소에서 제공하는 Helm 차트 가이드를 따라 설치합니다. Kubernetes-CSI 프로젝트의 NFS CSI 드라이버를 설치하는 방법을 보여드릴게요.

    
    helm repo add csi-driver-nfs https://kubernetes-csi.github.io/csi-driver-nfs
    helm repo update
    helm install csi-driver-nfs csi-driver-nfs/csi-driver-nfs --namespace kube-system
    

    배포가 완료되면, 다음과 같이 CSI 드라이버 관련 Pod들이 잘 올라왔는지 확인해볼 수 있습니다.

    
    kubectl get pods -n kube-system -l app.kubernetes.io/name=csi-driver-nfs
    

    2.2. StorageClass 생성

    이제 이 CSI 드라이버를 사용할 StorageClass를 정의합니다. NFS 서버의 주소와 공유할 경로를 지정해줘야 해요.

    
    # nfs-storageclass.yaml
    apiVersion: storage.k8s.io/v1
    kind: StorageClass
    metadata:
      name: nfs-csi-storage
    provisioner: nfs.csi.k8s.io # CSI 드라이버의 이름
    parameters:
      server: 192.168.1.100 # 여러분의 NFS 서버 IP 주소로 변경하세요!
      share: /mnt/nfs_share # NFS 서버의 공유 경로로 변경하세요!
    reclaimPolicy: Delete # Pod 삭제 시 PV도 함께 삭제 (Retain으로 하면 수동 삭제 필요)
    volumeBindingMode: Immediate
    mountOptions:
      - hard
      - nfsvers=4.1
    

    이 파일을 적용하면 <code>nfs-csi-storage라는 이름의 StorageClass가 생성됩니다.

    
    kubectl apply -f nfs-storageclass.yaml
    

    StorageClass를 정의하는 YAML 파일의 예시입니다. NFS CSI 드라이버를 이용해 스토리지 클래스를 생성하는 과정을 보여줍니다.

    2.3. PersistentVolumeClaim (PVC) 생성

    이제 애플리케이션이 스토리지 1GiB를 요청할 PVC를 만들어봅시다.

    
    # my-pvc.yaml
    apiVersion: v1
    kind: PersistentVolumeClaim
    metadata:
      name: my-nfs-pvc
    spec:
      accessModes:
        - ReadWriteOnce # 한 Pod만 읽기/쓰기 가능
      storageClassName: nfs-csi-storage # 위에서 생성한 StorageClass 이름 지정
      resources:
        requests:
          storage: 1Gi # 1 기가바이트 스토리지 요청
    

    적용하면 자동으로 PV가 프로비저닝됩니다. 정말 편해졌죠?

    
    kubectl apply -f my-pvc.yaml
    kubectl get pvc my-nfs-pvc
    kubectl get pv
    

    PVC가 Bound 상태가 되고, 그에 맞는 PV가 생성된 것을 확인할 수 있을 겁니다. 🎉

    2.4. Pod에서 PVC 사용

    마지막으로, 이 PVC를 사용할 Pod를 생성합니다. 간단한 Nginx Pod를 예시로 들어볼게요.

    
    # nginx-pod-with-pvc.yaml
    apiVersion: v1
    kind: Pod
    metadata:
      name: nginx-with-nfs
    spec:
      containers:
        - name: nginx
          image: nginx:latest
          ports:
            - containerPort: 80
          volumeMounts:
            - name: nfs-storage
              mountPath: /usr/share/nginx/html # Nginx의 웹 루트에 마운트
      volumes:
        - name: nfs-storage
          persistentVolumeClaim:
            claimName: my-nfs-pvc # 위에서 생성한 PVC 이름 지정
    

    이제 이 Pod를 배포하고, /usr/share/nginx/html 경로에 파일을 생성해보세요. Pod가 재시작되어도 데이터가 유지되는 것을 확인할 수 있을 겁니다!

    
    kubectl apply -f nginx-pod-with-pvc.yaml
    kubectl exec -it nginx-with-nfs -- bash
    echo "Hello from NFS CSI!" > /usr/share/nginx/html/index.html
    exit
    # Pod를 삭제했다가 다시 만들어도 데이터가 유지되는지 확인해보세요.
    kubectl delete pod nginx-with-nfs
    kubectl apply -f nginx-pod-with-pvc.yaml
    kubectl exec -it nginx-with-nfs -- cat /usr/share/nginx/html/index.html
    

    정상적으로 “Hello from NFS CSI!”라는 문구가 보인다면 성공입니다! 드디어 됐다! 🎉

    3. 삽질 경험담: CSI 드라이버 사용 시 주의사항과 트러블슈팅

    제가 이 과정을 거치면서 몇 번이고 머리를 쥐어뜯었던 경험이 있습니다. 여러분은 저 같은 삽질을 하지 마시라고 몇 가지 팁을 드릴게요.

    3.1. ⚠️ Access Modes (접근 모드) 이해하기

    PVC를 만들 때 accessModes를 지정하는데, 이게 꽤 중요합니다.

    • ReadWriteOnce (RWO): 단일 Pod만 읽기/쓰기 가능. (가장 흔함)
    • ReadOnlyMany (ROX): 여러 Pod가 읽기만 가능.
    • ReadWriteMany (RWX): 여러 Pod가 읽기/쓰기 가능. (NFS 같은 공유 파일 시스템에서 주로 사용)

    만약 RWX가 필요한데 RWO로 설정하면, 다른 Pod에서 접근이 안 돼서 문제가 생길 수 있습니다. 특히 클라우드 볼륨(EBS 같은)은 대부분 RWO만 지원하므로, RWX가 필요하면 NFS나 CephFS 같은 공유 파일 시스템 기반 CSI 드라이버를 고려해야 해요. 제가 이 부분에서 많이 헷갈렸었죠.

    3.2. ⚠️ Reclaim Policy (회수 정책) 신중하게 설정하기

    StorageClass에 reclaimPolicy를 Delete로 설정하면, PVC가 삭제될 때 연결된 PV와 실제 스토리지 볼륨도 함께 삭제됩니다. 개발 환경에서는 편하지만, 실제 운영 환경에서는 데이터가 날아갈 수 있으니 주의해야 합니다!

    저는 처음에 이걸 모르고 테스트용 DB를 날려먹을 뻔했어요… 다행히 백업이 있었지만요. 😅

    운영 환경에서는 Retain으로 설정해서 PVC 삭제 시 PV만 삭제하고, 실제 볼륨은 수동으로 관리하는 것을 고려해봐야 합니다. 아니면 백업 정책을 철저히 해야겠죠.

    3.3. 네트워크 연결 문제 (NFS 예시)

    NFS CSI 드라이버를 사용할 경우, 쿠버네티스 노드들이 NFS 서버에 접근할 수 있는지 확인해야 합니다. 방화벽 문제나 네트워크 경로 설정 문제로 연결이 안 되는 경우가 많거든요. showmount -e [NFS 서버 IP]나 mount 명령어로 직접 마운트 테스트를 해보는 것이 가장 확실합니다.

    3.4. CSI 드라이버 설치 버전 호환성

    가끔 CSI 드라이버 버전과 쿠버네티스 클러스터 버전 간의 호환성 문제로 말썽을 일으킬 때가 있습니다. CSI 드라이버의 공식 문서를 참조하여 호환되는 버전을 사용하는 것이 중요해요. 최신 버전이 무조건 좋은 건 아니더라고요.

    4. CSI 드라이버를 통한 영구 스토리지 관리의 성과

    이렇게 CSI 드라이버를 통해 영구 스토리지를 구성하고 나면, 다음과 같은 이점을 얻을 수 있습니다.

    • 데이터 영속성 (Data Persistence) 확보: Pod가 죽거나 재시작되어도 데이터는 안전하게 유지됩니다. DB나 상태를 가지는 애플리케이션 운영에 필수적이죠.
    • 스토리지 관리의 유연성 (Flexibility): 특정 스토리지 벤더에 종속되지 않고, 다양한 스토리지 솔루션을 쿠버네티스에서 일관된 방식으로 사용할 수 있습니다.
    • 운영 효율성 (Operational Efficiency) 증대: StorageClass를 통한 동적 프로비저닝(Dynamic Provisioning) 덕분에 스토리지 할당 및 관리가 자동화되어 운영 부담이 크게 줄어듭니다. 제가 직접 PV를 일일이 만들던 시절을 생각하면 정말 격세지감이죠. 😮
    • 확장성 (Scalability): 필요한 만큼 스토리지를 손쉽게 확장하거나 축소할 수 있게 됩니다.

    실제로 제가 운영하는 서비스에서도 CSI 드라이버 덕분에 안정적으로 데이터를 관리하고, 필요에 따라 스토리지를 유연하게 변경하거나 확장할 수 있게 되었어요. K8s 스토리지 최적화의 첫걸음이라고 할 수 있습니다.

    쿠버네티스 클러스터에서 PV, PVC, StorageClass 등의 스토리지 리소스 상태를 모니터링하는 대시보드의 예시입니다.

    5. 마무리하며: 쿠버네티스 스토리지, CSI 드라이버로 마스터하기

    오늘은 쿠버네티스 환경에서 영구 스토리지를 관리하고 최적화하는 데 필수적인 CSI 드라이버에 대해 제 경험을 바탕으로 이야기해보았습니다. PersistentVolume(PV), PersistentVolumeClaim(PVC), StorageClass, 그리고 CSI 드라이버라는 핵심 개념들이 처음에는 복잡하게 느껴질 수 있지만, 몇 번 직접 구성해보면 금방 익숙해지실 거예요.

    특히 StorageClass와 CSI 드라이버를 활용한 동적 프로비저닝은 쿠버네티스 운영의 편의성을 극대화시켜주는 정말 강력한 기능이라고 생각합니다. 저의 삽질 경험담이 여러분의 K8s 스토리지 여정에 작은 도움이 되었으면 좋겠네요. 🤝

    다음번에는 CephFS나 Rook-Ceph 같은 분산 스토리지 솔루션을 CSI 드라이버와 함께 사용하는 방법에 대해서도 다뤄볼 기회가 있었으면 좋겠습니다. 궁금한 점이나 공유하고 싶은 경험이 있다면 댓글로 남겨주세요! 저는 13년차의 서버실이었습니다. 감사합니다!

    다양한 쿠버네티스 영구 스토리지 솔루션(NFS, Ceph, 클라우드 볼륨 등)의 특징과 장단점을 비교하는 인포그래픽입니다.

  • [k8s] ArgoCD로 멀티 클러스터 GitOps 배포 자동화 완벽 가이드

    [k8s] ArgoCD로 멀티 클러스터 GitOps 배포 자동화 완벽 가이드

    ArgoCD로 멀티 클러스터 GitOps 배포 자동화 완벽 가이드

    안녕하세요, 13년차 서버실 지킴이입니다. 오늘도 어김없이 여러분의 인프라 여정에 도움이 될 만한 꿀팁을 들고 왔습니다. 혹시 여러 쿠버네티스 클러스터를 운영하면서 배포 때문에 머리 아팠던 경험 있으신가요? 개발, 스테이징, 운영 환경이 각각 다른 클러스터에 존재하거나, 온프레미스와 클라우드를 넘나드는 하이브리드 환경에서 일관된 배포를 유지하는 게 정말 쉽지 않거든요. 저도 처음엔 수동 배포 지옥에서 헤매던 시절이 있었죠. 클러스터마다 kubectl 명령어를 치고, YAML 파일을 수정하고, 휴먼 에러로 인해 서비스 장애를 겪었던 아찔한 순간들도 많았고요. 😱

    하지만 GitOps(깃옵스)를 만나고, 특히 ArgoCD(아르고CD)를 활용하면서 이런 배포 스트레스가 확 줄었습니다. 오늘은 저처럼 멀티 클러스터 환경에서 배포 자동화에 목마른 분들을 위해, ArgoCD로 GitOps를 구현하고 여러 클러스터에 애플리케이션을 자동으로 배포하는 멀티 클러스터 GitOps 배포 자동화 방법을 완벽하게 가이드해 드리려고 합니다. 제가 직접 삽질하며 터득한 경험들을 솔직하게 공유할 테니, 끝까지 따라오시면 분명 큰 도움이 될 겁니다! 자, 그럼 시작해 볼까요?

    ArgoCD를 활용한 멀티 클러스터 GitOps 배포 아키텍처는 위와 같이 구성될 수 있습니다. 하나의 ArgoCD 인스턴스가 여러 쿠버네티스 클러스터에 애플리케이션을 배포하고 관리하는 모습이죠. Git을 중심으로 모든 클러스터의 상태를 동기화하는 핵심 아이디어를 담고 있습니다.

    1. GitOps와 ArgoCD, 그리고 멀티 클러스터 배포, 이게 뭔가요?

    본격적인 실전에 앞서, 핵심 개념들을 짚고 넘어가는 게 중요하겠죠? 제가 늘 강조하는 부분인데, 도구를 잘 쓰는 것도 중요하지만, 그 도구가 왜 필요하고 어떤 철학을 담고 있는지 이해하는 게 진짜 실력입니다.

    • GitOps (깃옵스): 쉽게 말해, Git을 유일한 진실의 원천(Single Source of Truth)으로 삼아 인프라와 애플리케이션 배포를 자동화하는 운영 방식이에요. 모든 설정과 배포 상태를 Git 리포지토리에 코드로 관리하고, Git에 변경사항이 푸시되면 자동으로 인프라에 반영되도록 하는 거죠. 개발자들이 코드 관리하듯이 인프라를 관리한다고 생각하시면 됩니다. 일관성, 버전 관리, 감사 추적(Audit Trail)이 가능하다는 엄청난 장점이 있어요.

    • ArgoCD (아르고CD): 이 친구는 GitOps를 쿠버네티스(Kubernetes) 환경에서 구현해주는 선언적(Declarative) GitOps 지속적 배포(Continuous Delivery) 툴입니다. Git 리포지토리에 정의된 원하는 상태(Desired State)와 실제 쿠버네티스 클러스터의 현재 상태(Live State)를 끊임없이 비교하고, 만약 다르면 Git에 정의된 상태로 클러스터를 동기화(Sync)시켜 줍니다. 마치 클러스터 상태를 감시하는 파수꾼 같다고 할까요? 정말 든든한 친구더라고요.

    • 멀티 클러스터 배포 (Multi-Cluster Deployment): 여러 개의 쿠버네티스 클러스터에 동일하거나 다른 애플리케이션을 배포하고 관리하는 시나리오를 말합니다. 개발, 스테이징, 운영 환경을 분리하거나, 재해 복구(DR)를 위해 지리적으로 분산된 클러스터를 운영할 때 주로 사용하죠. ArgoCD는 하나의 중앙 인스턴스에서 여러 클러스터를 관리할 수 있어서, 멀티 클러스터 환경에서 배포를 중앙 집중화하고 자동화하는 데 아주 탁월한 솔루션입니다.

    2. 실전 구현: ArgoCD로 멀티 클러스터 GitOps 환경 구축하기

    자, 이제 이론은 충분히 봤으니, 저와 함께 직접 만들어 볼 시간입니다. 제가 홈랩에서 여러 번 시도하면서 가장 효율적이라고 생각했던 방법으로 안내해 드릴게요. 따라만 하시면 됩니다! 💡

    2.1. 사전 준비물 (Prerequisites)

    시작하기 전에 몇 가지 준비물이 필요합니다.

    • 쿠버네티스 클러스터 2개 이상: 하나는 ArgoCD를 설치할 ‘컨트롤 플레인 클러스터’로, 나머지는 애플리케이션을 배포할 ‘타겟 클러스터’로 사용할 겁니다. (저는 KIND나 K3s로 쉽게 구성했어요.)
    • kubectl: 쿠버네티스 클러스터를 제어하는 CLI 도구.
    • Helm (선택 사항): 쿠버네티스 패키지 매니저. ArgoCD 설치에 Helm을 사용하진 않지만, 애플리케이션 배포에 유용할 수 있습니다.
    • Git 리포지토리: 배포할 애플리케이션의 YAML 파일들을 저장할 공간 (GitHub, GitLab, Bitbucket 등).

    2.2. 단계 1: ArgoCD 설치 (컨트롤 플레인 클러스터)

    먼저 ArgoCD를 설치할 클러스터에 ArgoCD를 배포합니다. 이 클러스터가 모든 배포의 중앙 통제실 역할을 하게 됩니다.

    1. ArgoCD 네임스페이스 생성

      kubectl create namespace argocd
    2. ArgoCD 설치 YAML 적용

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

      이 명령은 ArgoCD의 모든 컴포넌트(API 서버, 컨트롤러, 레포 서버 등)를 설치합니다. 잠시 기다리면 파드들이 정상적으로 올라올 거예요.

    3. ArgoCD CLI 설치 (선택 사항이지만 강력 추천!)

      # macOS (Homebrew)
      brew install argocd
      
      # Linux (직접 다운로드)
      curl -sSL -o argocd-linux-amd64 https://github.com/argoproj/argo-cd/releases/latest/download/argocd-linux-amd64
      sudo install -m 555 argocd-linux-amd64 /usr/local/bin/argocd
      rm argocd-linux-amd64
    4. 초기 비밀번호 확인 및 UI 접근

      ArgoCD API 서버의 초기 비밀번호는 컨트롤 플레인 클러스터의 argocd-initial-admin-secret 시크릿에 저장되어 있습니다.

      kubectl -n argocd get secret argocd-initial-admin-secret -o jsonpath="{.data.password}" | base64 -d; echo

      UI에 접근하려면 포트 포워딩(Port Forwarding)을 해줘야 합니다.

      kubectl port-forward svc/argocd-server -n argocd 8080:443

      이제 웹 브라우저에서 https://localhost:8080으로 접속한 후, 사용자명 admin과 위에서 확인한 비밀번호로 로그인하세요. 첫 로그인 후 비밀번호를 변경하는 것을 추천합니다.

    2.3. 단계 2: Git Repository 준비

    배포할 애플리케이션의 YAML 파일들을 Git 리포지토리에 준비해야 합니다. 저는 간단한 Nginx 배포 파일을 예시로 들어볼게요.

    my-gitops-repo/apps/nginx/deployment.yaml

    apiVersion: apps/v1
    kind: Deployment
    metadata:
      name: nginx-deployment
      labels:
        app: nginx
    spec:
      replicas: 2
      selector:
        matchLabels:
          app: nginx
      template:
        metadata:
          labels:
            app: nginx
        spec:
          containers:
          - name: nginx
            image: nginx:1.14.2
            ports:
            - containerPort: 80

    my-gitops-repo/apps/nginx/service.yaml

    apiVersion: v1
    kind: Service
    metadata:
      name: nginx-service
    spec:
      selector:
        app: nginx
      ports:
        - protocol: TCP
          port: 80
          targetPort: 80
      type: LoadBalancer # 또는 ClusterIP, NodePort

    이 파일들을 Git 리포지토리에 푸시해 주세요. (예: https://github.com/your-org/my-gitops-repo.git)

    2.4. 단계 3: 타겟 클러스터 등록 (ArgoCD에 연결)

    이제 ArgoCD가 애플리케이션을 배포할 타겟 클러스터들을 ArgoCD에 등록해야 합니다. ArgoCD CLI를 사용하면 아주 쉽게 등록할 수 있어요.

    1. ArgoCD CLI 로그인

      argocd login localhost:8080

      초기 비밀번호로 로그인합니다.

    2. 타겟 클러스터 등록

      현재 kubeconfig 파일에 정의된 클러스터 컨텍스트(Context)를 사용해서 등록합니다. 등록할 클러스터의 컨텍스트로 kubectl config use-context <TARGET_CLUSTER_CONTEXT> 명령어를 실행한 후, 아래 명령어를 실행하세요.

      argocd cluster add <TARGET_CLUSTER_CONTEXT>

      예를 들어, dev-cluster와 prod-cluster라는 컨텍스트가 있다면 각각 등록해 줍니다.

      이 명령은 ArgoCD가 타겟 클러스터에 접근할 수 있도록 필요한 RBAC 설정과 시크릿을 자동으로 생성해 줍니다. ⚠️ 권한 문제로 많이들 삽질하시는데, 이 단계에서 정확한 컨텍스트를 선택했는지 꼭 확인하세요.

    3. 등록된 클러스터 확인

      argocd cluster list

      등록된 클러스터 목록이 보이면 성공입니다! ArgoCD UI에서도 ‘Clusters’ 메뉴에서 확인할 수 있습니다.

    ArgoCD UI에서 클러스터가 성공적으로 등록되고 ApplicationSet이 여러 클러스터에 배포되는 모습을 시각적으로 확인할 수 있습니다. 각 클러스터별로 애플리케이션 상태를 한눈에 파악할 수 있죠.

    2.5. 단계 4: ApplicationSet으로 멀티 클러스터 배포 자동화

    이제 이 글의 핵심인 ApplicationSet(애플리케이션셋)을 활용해서 여러 클러스터에 Nginx 애플리케이션을 배포해 볼 시간입니다. ApplicationSet은 여러 개의 ArgoCD Application 리소스를 동적으로 생성해주는 컨트롤러입니다. 특히 멀티 클러스터 환경에서 빛을 발하죠!

    ApplicationSet을 사용하면, 등록된 모든 클러스터에 동일한 애플리케이션을 배포하거나, 클러스터별로 약간 다른 설정을 적용하여 배포할 수 있습니다. 여기서는 Cluster Generator를 사용해서 ArgoCD에 등록된 모든 클러스터에 Nginx를 배포하도록 해볼게요.

    my-gitops-repo/applicationsets/nginx-applicationset.yaml

    apiVersion: argoproj.io/v1alpha1
    kind: ApplicationSet
    metadata:
      name: multi-cluster-nginx
      namespace: argocd
    spec:
      generators:
      - clusters: {}
      template:
        metadata:
          name: '{{name}}-nginx' # 클러스터 이름 기반으로 Application 이름 생성
          namespace: argocd
        spec:
          project: default
          source:
            repoURL: https://github.com/your-org/my-gitops-repo.git # 본인의 Git 리포지토리 URL로 변경
            targetRevision: HEAD
            path: apps/nginx
          destination:
            server: '{{server}}'
            namespace: default
          syncPolicy:
            automated:
              prune: true
              selfHeal: true
            syncOptions:
              - CreateNamespace=true # 대상 클러스터에 네임스페이스가 없으면 생성

    위 YAML 파일을 Git 리포지토리에 푸시한 후, ArgoCD가 설치된 컨트롤 플레인 클러스터에 적용합니다.

    kubectl apply -n argocd -f my-gitops-repo/applicationsets/nginx-applicationset.yaml

    잠시 후 ArgoCD UI의 ‘Applications’ 메뉴로 이동해 보세요. 등록된 클러스터 개수만큼 <클러스터이름>-nginx 형태의 애플리케이션이 자동으로 생성되고, 배포가 시작되는 것을 확인할 수 있을 겁니다. 정말 신기하더라고요! 🎉

    3. 주의사항 및 트러블슈팅: 저의 삽질 경험담 ⚠️

    제가 13년간 인프라 엔지니어로 일하면서 깨달은 건, 새로운 기술을 도입할 때 늘 예상치 못한 문제가 터진다는 겁니다. ArgoCD도 예외는 아니었죠. 제가 겪었던 주요 삽질 경험과 해결 팁을 공유해 드립니다.

    • RBAC (Role-Based Access Control) 문제: 타겟 클러스터 등록 시 ArgoCD가 해당 클러스터에 접근할 권한이 없어서 배포가 실패하는 경우가 많았습니다. argocd cluster add 명령이 자동으로 RBAC를 설정해주지만, 때로는 특정 리소스에 대한 추가 권한이 필요할 수 있어요. ArgoCD 서버의 서비스 어카운트(Service Account)에 필요한 ClusterRoleBinding이 제대로 되어있는지 확인하고, 필요하다면 수동으로 추가해줘야 합니다.

      # 예시: ArgoCD 서비스 어카운트에 Cluster-Admin 권한 부여 (실제 운영에서는 최소 권한 원칙 준수)
      apiVersion: rbac.authorization.k8s.io/v1
      kind: ClusterRoleBinding
      metadata:
        name: argocd-manager-role-binding
      subjects:
      - kind: ServiceAccount
        name: argocd-argocd-application-controller
        namespace: argocd
      roleRef:
        apiGroup: rbac.authorization.k8s.io
        kind: ClusterRole
        name: cluster-admin # or a more specific role
    • Kubeconfig 파일 접근 권한: ArgoCD가 타겟 클러스터에 접근하려면 컨트롤 플레인 클러스터에서 타겟 클러스터의 API 서버에 네트워크적으로 연결이 가능해야 합니다. 방화벽, VPC 설정 등을 꼼꼼히 확인하세요. 특히 온프레미스와 클라우드 하이브리드 환경에서는 네트워크 경로 설정이 복잡해질 수 있습니다.

    • Sync Policy 설정: automated: prune: true와 selfHeal: true 옵션은 배포를 매우 편리하게 해주지만, 자칫 잘못하면 예상치 못한 변경이 즉시 반영될 수 있습니다. 특히 운영 환경에서는 신중하게 접근하고, 처음에는 수동 동기화(Manual Sync)로 시작하여 동작을 충분히 이해한 후 자동화하는 것을 추천합니다.

    • ApplicationSet Generator 문제: Cluster Generator를 쓸 때, Git 리포지토리의 경로(path)나 targetRevision, 그리고 destination의 server와 namespace 설정에 오타가 없는지 여러 번 확인해야 합니다. 변수({{name}}, {{server}}) 사용법도 헷갈리기 쉽더라고요.

    4. 검증 및 결과: 드디어 됐다! ✅

    이제 ArgoCD UI에서 모든 애플리케이션들이 Synced 상태인지 확인해 보세요. 각 클러스터에 배포된 Nginx 파드들도 kubectl get pods -n default 명령으로 확인하면 정상적으로 실행되고 있을 겁니다. 드디어 모든 클러스터에 배포가 완료됐네요! 이 맛에 GitOps 하는 거 아니겠습니까? 🎉

    여기서 끝이 아닙니다! GitOps의 진정한 가치는 Git 변경 사항이 자동으로 반영되는 데 있거든요. my-gitops-repo/apps/nginx/deployment.yaml 파일의 replicas 수를 2에서 3으로 변경하고 Git에 푸시해 보세요. ArgoCD가 변경 사항을 감지하고, 몇 초 내에 모든 타겟 클러스터의 Nginx 파드 개수가 3개로 자동으로 업데이트되는 것을 볼 수 있을 겁니다. 정말 편하더라고요!

    ArgoCD 대시보드에서 여러 클러스터에 배포된 애플리케이션들의 실시간 상태를 모니터링하는 화면입니다. 모든 애플리케이션이 정상적으로 동기화(Synced)된 것을 확인할 수 있습니다.

    5. 마무리: GitOps로 한 단계 더 성장하기

    오늘은 ArgoCD를 활용하여 멀티 클러스터 GitOps 배포 자동화를 구현하는 과정을 저의 경험을 바탕으로 상세하게 설명해 드렸습니다. 어떠셨나요? 처음엔 복잡해 보이지만, 한 번 구축해 놓으면 배포의 일관성, 속도, 안정성이 비약적으로 향상되는 것을 체감하실 수 있을 겁니다.

    멀티 클러스터 환경에서 ArgoCD와 GitOps는 정말 강력한 조합입니다. 수동 작업에서 벗어나 휴먼 에러를 줄이고, Git을 통한 완벽한 버전 관리와 감사 추적이 가능해지거든요. 무엇보다 인프라 엔지니어가 더 중요하고 전략적인 업무에 집중할 수 있도록 도와주는 멋진 도구라고 생각합니다.

    물론 초기 설정에 시간과 노력이 필요하고, GitOps 문화에 적응하는 과정도 필요합니다. 하지만 그 투자 가치는 충분하다고 제가 직접 보증합니다. 제 홈랩에서도 이 방식으로 다양한 서비스를 배포하고 있거든요. 😉

    다음번에는 오늘 배운 ArgoCD와 GitOps 개념을 확장해서, Helm Chart 통합, Kustomize 활용, 그리고 Argo Rollouts(아르고 롤아웃)를 이용한 블루/그린, 카나리 배포 전략까지 자동화하는 경험담을 들려드릴게요! 이 글이 여러분의 인프라 여정에 작은 이정표가 되었기를 바랍니다. 다음에 또 만나요!

    GitOps와 기존 배포 방식, 그리고 ArgoCD의 멀티 클러스터 관리 장점을 요약한 인포그래픽입니다. 어떤 점들이 개선되었는지 한눈에 파악할 수 있습니다.

  • [k8s] 쿠버네티스 Ingress Controller 비교: Nginx, Traefik, HAProxy 장단점 분석

    [k8s] 쿠버네티스 Ingress Controller 비교: Nginx, Traefik, HAProxy 장단점 분석

    [쿠버네티스] Ingress Controller 비교: Nginx, Traefik, HAProxy 장단점 분석

    안녕하세요, 13년차 인프라 엔지니어입니다. 쿠버네티스를 운영하면서 가장 자주 마주하는 고민 중 하나가 바로 외부 트래픽을 어떻게 효율적으로 서비스에 연결할까 하는 부분일 겁니다. 저도 처음엔 NodePort나 LoadBalancer 서비스만으로 충분하다고 생각했어요. 하지만 서비스가 많아지고, TLS(Transport Layer Security) 인증서 관리나 경로 기반 라우팅 같은 복잡한 요구사항들이 생기면서 Ingress(인그레스, 외부 트래픽 진입점)의 중요성을 절실히 깨달았습니다.

    특히 어떤 Ingress Controller를 사용해야 할지 결정하는 건 늘 어려운 선택이었어요. Nginx, Traefik, HAProxy… 저마다 장단점이 명확해서 어떤 상황에 어떤 걸 써야 좋을지 항상 고민하게 되더라고요. 제가 홈랩과 실제 프로덕션 환경에서 다양한 Ingress Controller들을 직접 써보고 겪었던 삽질 경험을 바탕으로, 오늘은 이 세 가지 주요 Ingress Controller들의 특징과 장단점을 꼼꼼하게 비교해 보려고 합니다. 혹시 어떤 Ingress Controller를 선택해야 할지 막막하셨다면, 이 글이 여러분의 고민을 덜어줄 수 있기를 바랍니다!

    그림 1: 쿠버네티스 Ingress Controller를 통한 외부 트래픽 라우팅 개요

    1. 쿠버네티스 Ingress Controller, 왜 필요한가?

    쿠버네티스 클러스터 내의 애플리케이션들은 기본적으로 클러스터 내부에서만 접근 가능합니다. 외부에서 이 서비스들에 접근하게 하려면 몇 가지 방법이 있죠. 대표적으로 NodePort나 LoadBalancer 타입의 Service를 사용하는 건데요.

    • NodePort: 모든 워커 노드의 특정 포트를 열어서 서비스에 접근하게 합니다. 간단하지만 포트 관리가 어렵고, 트래픽 분산 기능을 직접 구현해야 하는 단점이 있어요.
    • LoadBalancer: 클라우드 제공업체의 로드밸런서를 프로비저닝하여 외부 IP를 통해 서비스에 접근하게 합니다. 편리하지만, 서비스 하나당 로드밸런서가 하나씩 할당되어 비용 부담이 커질 수 있고, 복잡한 라우팅 규칙을 적용하기 어렵습니다.

    여기서 Ingress가 등장합니다. Ingress는 클러스터 외부에서 내부 서비스로 들어오는 HTTP/HTTPS 트래픽을 관리하는 API 오브젝트예요. 쉽게 말해, ‘외부 트래픽의 문지기’ 역할을 한다고 보시면 됩니다. 하나의 외부 IP와 포트를 통해 여러 서비스로 트래픽을 분산하고, 도메인 기반 라우팅, 경로 기반 라우팅, TLS 종료(Termination) 등을 처리할 수 있게 해줍니다.

    그리고 이 Ingress 리소스에 정의된 규칙들을 실제로 읽고 구현하여 트래픽을 라우팅해주는 것이 바로 Ingress Controller입니다. Ingress Controller는 클러스터 내부에서 Pod 형태로 동작하며, Ingress 리소스의 변경을 감지하고, 그 규칙에 따라 실제 로드밸런싱 설정을 동적으로 업데이트합니다. 마치 웹 서버나 리버스 프록시처럼 동작하는 셈이죠. 결국 Ingress는 ‘규칙’이고, Ingress Controller는 그 ‘규칙을 실행하는 엔진’이라고 이해하시면 편할 겁니다.

    2. 주요 Ingress Controller 심층 비교 분석

    자, 이제 본론으로 들어가서 우리가 주로 사용하는 세 가지 Ingress Controller인 Nginx, Traefik, HAProxy를 하나씩 파헤쳐 봅시다. 제가 직접 써보면서 느꼈던 장단점과 팁들을 솔직하게 공유해 드릴게요.

    2.1. Nginx Ingress Controller: 국룰에는 이유가 있죠

    Nginx Ingress Controller는 아마 쿠버네티스 환경에서 가장 널리 사용되는 Ingress Controller일 겁니다. 그만큼 안정성과 기능 면에서 검증된 솔루션이라고 할 수 있죠. 저도 처음 쿠버네티스를 도입했을 때 Nginx Ingress부터 시작했습니다.

    • ✅ 장점
      • 압도적인 안정성과 성능: Nginx 자체가 고성능 웹 서버이자 리버스 프록시로 유명하죠. Ingress Controller도 그 명성에 걸맞게 안정적이고 뛰어난 성능을 보여줍니다.
      • 풍부한 기능과 설정 옵션: HTTP/HTTPS 라우팅, URL 리라이트(Rewrite), 세션 어피니티(Session Affinity), WAF(Web Application Firewall) 연동 등 다양한 기능을 지원합니다. Nginx 설정 파일에 익숙하다면 복잡한 룰도 구현하기 쉬워요.
      • 넓은 사용자층과 커뮤니티: 워낙 많은 사람이 사용하다 보니, 문제가 생겼을 때 정보를 찾거나 도움을 받기 정말 쉽습니다. Stack Overflow나 GitHub 이슈 등 자료가 많아요.
      • 익숙함: 리눅스에서 Nginx 좀 다뤄봤다 하는 분들은 설정 방식이 익숙해서 빠르게 적응할 수 있습니다.
    • ⚠️ 단점
      • 설정의 복잡성: Nginx ConfigMap이나 Annotation을 통해 Nginx 설정을 직접 제어하는 방식이라, 처음에는 복잡하게 느껴질 수 있어요. 특히 고급 설정으로 가면 Nginx 문법을 알아야 하는 경우가 많습니다.
      • 동적 설정의 제약: Nginx의 특성상 설정 변경 시 리로드가 필요한 경우가 있는데, Ingress Controller가 내부적으로 처리하긴 하지만 완전히 실시간으로 모든 설정을 변경하기는 어렵습니다.
      • CRD(Custom Resource Definition) 미활용: 다른 Ingress Controller들이 CRD를 적극 활용하여 쿠버네티스 네이티브한 설정 경험을 제공하는 반면, Nginx는 Annotation 의존도가 높은 편입니다.

    제가 실제로 Nginx Ingress Controller를 사용하면서 느꼈던 건, “역시 국룰은 다르구나” 하는 점이었어요. 대규모 환경에서도 끄떡없이 잘 돌아갔고, 웬만한 라우팅 규칙은 다 구현할 수 있었거든요. 다만, 개발팀에서 새로운 경로를 자주 추가하거나 변경할 때마다 Ingress 리소스를 수정하고 적용하는 과정이 조금 번거롭다고 느낄 때가 있었습니다.

    2.2. Traefik Ingress Controller: 개발자를 위한 자동화 끝판왕

    Traefik Ingress Controller는 클라우드 네이티브 환경에 최적화된 HTTP 리버스 프록시 및 로드 밸런서예요. 특히 동적인 환경에서 그 진가를 발휘하는데, 저도 홈랩에서 간단한 서비스들을 올릴 때 Traefik을 정말 유용하게 쓰고 있습니다.

    • ✅ 장점
      • 뛰어난 동적 설정 기능: 쿠버네티스 Ingress 리소스뿐만 아니라 Service, Deployment 등 다양한 쿠버네티스 리소스를 감지하여 자동으로 라우팅 규칙을 생성합니다. CRD를 적극 활용해서 쿠버네티스 친화적인 설정 경험을 제공해요.
      • 자동 TLS 인증서 관리 (Let’s Encrypt): Traefik의 가장 강력한 기능 중 하나입니다. Let’s Encrypt와 연동하여 도메인에 대한 TLS 인증서를 자동으로 발급받고 갱신해줍니다. 💡 이거 진짜 편하더라고요! 제가 직접 인증서 갱신하느라 삽질했던 시간이 정말 아깝게 느껴질 정도였습니다.
      • 내장 대시보드: Traefik의 설정과 현재 라우팅되고 있는 서비스들의 상태를 한눈에 볼 수 있는 웹 대시보드를 제공해요. 디버깅이나 모니터링에 정말 유용하거든요.
      • 경량화 및 빠른 시작: Nginx 대비 가볍고 빠르게 시작할 수 있어 개발 환경이나 소규모 클러스터에 특히 적합합니다.
    • ⚠️ 단점
      • Nginx 대비 상대적으로 작은 커뮤니티: 물론 Traefik도 큰 커뮤니티를 가지고 있지만, Nginx만큼은 아닙니다. 아주 특수한 설정이나 문제 발생 시 정보 탐색이 조금 어려울 수 있어요.
      • 고급 설정 시 학습 곡선: 기본적인 설정은 쉽지만, Nginx에서 제공하는 복잡하고 미세한 튜닝 옵션들을 Traefik에서 구현하려면 Traefik의 설정 방식을 익혀야 합니다.
      • 성능: 대부분의 경우 충분하지만, 극단적인 고성능 트래픽 처리나 특정 벤치마크에서는 Nginx가 우위를 보일 수 있어요.

    저는 Traefik을 처음 써봤을 때, 자동 Let’s Encrypt 기능에 정말 감탄했습니다. 홈랩에 여러 서비스 올리면서 매번 인증서 발급받고 갱신하는 게 귀찮았거든요. Traefik은 이런 번거로움을 한 방에 해결해 줘서 개발자들이 정말 좋아할 만한 툴이라고 생각해요. 동적으로 서비스가 추가되거나 스케일 아웃될 때도 설정 변경 없이 알아서 라우팅 해주는 점도 매우 편리했습니다.

    2.3. HAProxy Ingress Controller: 성능과 유연성의 끝판왕

    HAProxy Ingress Controller는 고성능과 높은 유연성이 필요한 환경에서 빛을 발합니다. HAProxy는 이미 오랜 시간 동안 다양한 프로덕션 환경에서 검증된 강력한 로드 밸런서예요. L4(전송 계층) 및 L7(애플리케이션 계층) 로드 밸런싱 기능을 모두 지원하며, 매우 정교한 트래픽 제어가 가능하죠.

    • ✅ 장점
      • 극강의 성능과 안정성: HAProxy 자체의 강력한 성능을 그대로 가져옵니다. 대규모 트래픽 처리와 높은 동시 접속 처리에 매우 강해요.
      • 고급 로드 밸런싱 기능: 다양한 로드 밸런싱 알고리즘(Round Robin, Least Connections, Source IP Hashing 등), 세션 유지, 헬스 체크, 서버 가중치 부여 등 섬세한 제어가 가능합니다.
      • L4/L7 지원: 단순히 HTTP/HTTPS뿐만 아니라 TCP 트래픽에 대한 로드 밸런싱도 지원하여 더 넓은 범위의 애플리케이션에 적용할 수 있어요.
      • 매우 유연한 설정: HAProxy의 설정 문법을 통해 매우 복잡하고 정교한 트래픽 처리 룰을 구현할 수 있습니다.
    • ⚠️ 단점
      • 상대적으로 높은 복잡성: Nginx나 Traefik에 비해 설정 파일이 복잡하고, HAProxy 자체의 문법에 대한 이해가 필요해요. 학습 곡선이 좀 가파른 편입니다.
      • 동적 설정의 제약: Nginx와 유사하게, HAProxy의 설정을 동적으로 변경하는 데는 어느 정도 제약이 있습니다. 물론 Ingress Controller가 이를 최적화하지만, Traefik처럼 완전한 자동화를 기대하기는 어렵습니다.
      • 적은 사용자층: Nginx나 Traefik에 비해 쿠버네티스 Ingress Controller로서의 사용자층은 상대적으로 적은 편이에요.

    제가 HAProxy Ingress Controller를 써봤던 경험은, “이건 진짜 성능이 중요하거나, 표준적인 Ingress로는 부족한 복잡한 요구사항이 있을 때 쓰는 거구나” 하는 느낌이었습니다. 특히 특정 TCP 포트를 외부로 노출하면서 부하 분산을 해야 할 때 아주 유용하더라고요. 하지만 일반적인 웹 서비스 라우팅에는 Nginx나 Traefik이 더 적합하다고 느꼈어요. 굳이 HAProxy의 강력한 기능을 다 쓰지 않으면서 복잡한 설정을 감당할 필요는 없으니까요.

    그림 2: 주요 Ingress Controller들의 핵심 특징 비교

    3. 어떤 Ingress Controller를 선택해야 할까요? (선택 가이드)

    세 가지 Ingress Controller의 특징을 살펴봤으니, 이제 여러분의 환경과 요구사항에 맞춰 어떤 것을 선택해야 할지 가이드라인을 제시해 드릴게요. “정답은 없다”는 말이 식상하게 들릴 수도 있지만, 인프라 엔지니어의 세계에서는 정말 맞는 말입니다. 각자의 상황에 맞는 최적의 선택이 중요하거든요. 💡

    아래 표는 각 Ingress Controller의 주요 특성을 비교하여 선택에 도움을 주기 위한 것입니다.

    기준 Nginx Ingress Controller Traefik Ingress Controller HAProxy Ingress Controller
    성능 및 안정성 매우 우수 (검증됨) 우수 (대부분의 경우 충분) 최고 (고성능, L4/L7)
    설정 복잡도 중 (Annotation, ConfigMap 이해 필요) 하 (CRD 기반, 자동화 강점) 상 (HAProxy 문법 이해 필요)
    동적 설정 중 (리로드가 필요할 수 있음) 최상 (실시간, 자동 감지) 중 (Nginx와 유사)
    TLS 관리 수동 또는 cert-manager 연동 자동 (Let’s Encrypt 내장) 수동 또는 cert-manager 연동
    커뮤니티/자료 매우 풍부 풍부 상대적으로 적음
    주요 사용 시나리오 일반적인 웹 서비스, 레거시 시스템, 익숙함 중시 클라우드 네이티브, 개발 환경, 자동화, Let’s Encrypt 활용 극단적 고성능, 복잡한 L4/L7 규칙, 특정 TCP 서비스

    그림 3: 환경과 요구사항에 따른 Ingress Controller 선택 결정 가이드

    요약하자면:

    • 가장 보편적이고 안정적인 선택을 원한다면? ➡️ Nginx Ingress Controller. 특히 Nginx에 대한 경험이 많고, 대규모 서비스에서 검증된 안정성을 추구한다면 좋은 선택입니다.
    • 설정의 간결함과 자동화를 선호한다면? ➡️ Traefik Ingress Controller. 특히 Let’s Encrypt 자동화와 동적인 서비스 환경에 강점을 보여요. 개발팀이 빠르게 서비스를 배포하고 테스트하는 환경에 안성맞춤입니다.
    • 극단적인 성능이나 L4/L7 고급 기능이 필요하다면? ➡️ HAProxy Ingress Controller. 표준 Ingress로는 해결하기 어려운 복잡한 트래픽 제어나 특정 TCP 서비스 로드 밸런싱에 적합해요. 다만 학습 곡선과 설정 복잡도를 감수해야 합니다.

    4. ⚠️ 실제 겪은 삽질 경험과 트러블슈팅 팁

    제가 이 바닥에서 13년을 구르면서 느낀 건, 아무리 좋은 툴이라도 삽질은 피할 수 없다는 겁니다. 특히 Ingress Controller는 외부와 내부를 잇는 중요한 컴포넌트라 문제가 생기면 서비스 전체가 먹통이 될 수 있죠. 제가 겪었던 몇 가지 삽질 경험과 해결 팁을 공유해 드릴게요.

    1. Ingress Controller Pod가 Pending 상태? 권한 문제!
      처음 Ingress Controller를 배포했을 때 Pod가 계속 Pending 상태거나 CrashLoopBackOff에 빠지는 경우가 있었습니다. 확인해보니 대부분 RBAC(Role-Based Access Control) 권한 문제더라고요. Ingress Controller는 Ingress, Service, Endpoint 같은 쿠버네티스 리소스들을 읽고 변경해야 하므로, 충분한 권한을 가진 ServiceAccount, ClusterRole, ClusterRoleBinding이 제대로 설정되어 있어야 합니다. 공식 문서의 배포 YAML을 꼭 참고해서 필요한 권한들을 잘 설정해주세요.
    2. TLS 인증서 적용이 안 돼요! Secret 이름 확인 필수!
      HTTPS를 적용하려고 Ingress 리소스에 tls 섹션을 추가했는데, 브라우저에서 계속 “안전하지 않은 연결” 경고가 뜨는 겁니다. 며칠을 헤맸는데, 알고 보니 Ingress 리소스의 secretName 필드에 오타가 있었어요! 🤦‍♂️ 쿠버네티스에서 Secret은 대소문자를 구분하고, 이름 하나라도 틀리면 인식이 안 됩니다. Ingress 리소스의 tls.secretName과 실제 Secret 오브젝트의 metadata.name이 정확히 일치하는지 꼼꼼히 확인해야 합니다. cert-manager를 사용하면 이런 수동적인 오류를 많이 줄일 수 있어서 강력히 추천합니다!
    3. 외부에서 접근이 안 돼요! Service 타입이 문제?
      Ingress Controller 자체는 잘 동작하는데, 외부에서 Ingress IP로 접근이 안 되는 경우가 있었습니다. 이건 대부분 Ingress Controller Service의 타입 설정 문제였어요. 클라우드 환경에서는 보통 type: LoadBalancer를 사용해서 외부 IP를 할당받는데, 온프레미스 환경이나 특정 클러스터에서는 type: NodePort나 HostPort를 사용해야 할 수도 있습니다. 클러스터의 네트워크 구성과 환경에 맞는 Service 타입을 선택하는 것이 중요해요. MetalLB 같은 온프레미스 로드밸런서 솔루션도 고려해볼 만합니다.
    4. 동일 포트 충돌! 여러 Ingress Controller 사용 시 주의!
      간혹 하나의 클러스터에 여러 종류의 Ingress Controller를 배포하려는 경우가 있습니다. 예를 들어 Nginx와 Traefik을 같이 쓰는 거죠. 이때 주의해야 할 점은 각 Ingress Controller가 사용하는 외부 포트가 겹치지 않아야 한다는 겁니다. 예를 들어 Nginx가 80/443 포트를 NodePort로 사용하고 있는데, Traefik도 동일한 포트로 NodePort를 열려고 하면 충돌이 발생합니다. 각 Ingress Controller에 고유한 외부 포트나 별도의 LoadBalancer Service를 할당해야 합니다.

    5. Ingress Controller 동작 검증 및 결과 확인

    Ingress Controller와 Ingress 리소스를 배포하고 나면, 제대로 동작하는지 확인하는 과정이 필수입니다. 제가 주로 사용하는 몇 가지 방법을 알려드릴게요.

    1. Ingress 리소스 상태 확인
      가장 먼저 kubectl get ingress 명령어로 Ingress 리소스가 잘 생성되었는지 확인합니다. ADDRESS 컬럼에 Ingress Controller의 외부 IP 주소가 할당되었는지 봐야 해요.
    2. kubectl get ingress -n my-namespace
      # 출력 예시:
      # NAME             CLASS    HOSTS              ADDRESS          PORTS     AGE
      # my-app-ingress   nginx    myapp.example.com   192.168.1.100    80, 443   5m
      

      그리고 kubectl describe ingress <ingress-name> 명령어로 Ingress 리소스의 상세 정보를 확인합니다. Rules 섹션에 정의한 라우팅 규칙들이 제대로 표시되는지, Events 섹션에 오류는 없는지 확인해야 해요.

    3. Ingress Controller Pod 로그 확인
      Ingress Controller Pod의 로그를 확인하는 것은 문제 해결의 첫걸음입니다. kubectl logs -f <ingress-controller-pod-name> -n <ingress-controller-namespace> 명령어로 실시간 로그를 보면서 트래픽이 들어올 때 어떤 동작을 하는지, 오류 메시지는 없는지 파악할 수 있습니다.
    4. 외부에서 curl 테스트
      가장 확실한 방법은 Ingress Controller의 외부 IP(또는 도메인)로 직접 curl 명령어를 날려보는 겁니다.
    5. curl -v http://myapp.example.com/path
      curl -v https://myapp.example.com/secure-path
      

      HTTP 응답 코드(200 OK 등)와 실제 서비스의 응답이 제대로 오는지 확인하세요. 특히 HTTPS의 경우 인증서 정보가 올바르게 나오는지도 함께 확인해야 합니다.

    6. Traefik 대시보드 확인 (Traefik 사용 시)
      Traefik Ingress Controller를 사용한다면, 내장된 대시보드를 통해 현재 활성화된 라우터, 서비스, 미들웨어 등의 상태를 시각적으로 확인할 수 있어요. 대시보드 접근 설정은 Traefik 배포 시 함께 구성해야 합니다. 🎉

    6. 마무리하며: 13년차 엔지니어의 선택, 그리고 다음 단계

    오늘은 쿠버네티스 Ingress Controller의 핵심 플레이어인 Nginx, Traefik, HAProxy의 장단점을 비교하고, 어떤 상황에 어떤 컨트롤러가 적합한지 제 경험을 바탕으로 이야기해 봤습니다.

    다시 한번 정리해 보면:

    • Nginx Ingress Controller: 안정성, 성능, 범용성 측면에서 가장 검증된 선택이에요. 대부분의 웹 서비스 환경에 무난하게 적용할 수 있습니다.
    • Traefik Ingress Controller: 동적인 환경, 빠른 개발 주기, 그리고 Let’s Encrypt 자동화가 중요하다면 최고의 선택입니다. 홈랩이나 개발/테스트 환경에서 빛을 발하죠.
    • HAProxy Ingress Controller: 극강의 성능과 복잡한 L4/L7 로드 밸런싱 규칙이 필요할 때 고려해볼 만합니다. 하지만 학습 곡선이 높다는 점을 인지해야 해요.

    저 같은 13년차 엔지니어에게 “그래서 뭘 추천하냐?”고 물어보신다면… 사실 정답은 없습니다. 😅 하지만 저의 개인적인 경험으로는, 일반적인 웹 서비스라면 Nginx Ingress Controller로 시작해서 안정성을 확보하고, 개발팀의 빠른 배포와 Let’s Encrypt 자동화가 절실하다면 Traefik을 고려하는 편입니다. HAProxy는 정말 특수한 경우에만 꺼내 드는 비장의 무기 같은 느낌이랄까요?

    Ingress Controller는 쿠버네티스 클러스터의 ‘얼굴’과 같은 존재입니다. 여러분의 서비스 특성과 운영 환경을 충분히 고려해서 최적의 선택을 하시길 바랍니다. 다음 글에서는 특정 Ingress Controller를 Helm 차트를 이용해 실제로 배포하고 설정하는 과정을 좀 더 자세히 다뤄보도록 하겠습니다. 그때까지 즐거운 쿠버네티스 여정 되세요! 💪

    그림 4: Nginx, Traefik, HAProxy Ingress Controller 최종 요약 비교