Kubernetes Tools/Cilium

EP15. Cilium 성능 최적화와 한계점 | 실무 팁과 리스크 관리

ygtoken 2025. 3. 23. 00:59

728x90

이 글에서는 Cilium의 성능 최적화 방법과 실제 운영 환경에서 만날 수 있는 한계점들을 살펴봅니다. 네트워크 성능 테스트 도구를 활용한 병목 현상 탐지부터 eBPF 프로그램 튜닝, 그리고 대규모 환경에서의 리소스 관리까지 실무에 바로 적용할 수 있는 최적화 기법을 다룹니다. 또한 Cilium 사용 시 주의해야 할 잠재적 리스크와 이를 완화하기 위한 전략도 함께 살펴보겠습니다.

📌 Cilium 성능 진단 및 측정

Cilium의 성능을 최적화하기 전에 먼저 현재 성능을 정확히 측정하고 진단하는 것이 중요합니다. 이를 통해 어떤 부분에 최적화가 필요한지 파악할 수 있습니다.

✅ 성능 테스트 도구 소개

# 1. 기본적인 네트워크 연결 테스트
# Pod 간 기본 연결 지연시간 측정 (간단한 ICMP 테스트)
kubectl exec -it <source-pod> -- ping <destination-pod-ip> -c 10

# 2. iperf3를 이용한 대역폭 테스트
# 서버 Pod 실행
kubectl exec -it <server-pod> -- iperf3 -s

# 클라이언트에서 테스트 실행
kubectl exec -it <client-pod> -- iperf3 -c <server-pod-ip> -t 30

좀 더 체계적인 성능 테스트를 위해 다음과 같은 도구들을 활용할 수 있습니다:

# netperf 설치를 위한 테스트 Pod 생성
# 두 개의 Pod를 생성: 하나는 클라이언트, 다른 하나는 서버 역할
cat <<EOF | kubectl apply -f -
apiVersion: v1
kind: Pod
metadata:
  name: netperf-client  # 클라이언트 Pod 이름
  labels:
    app: netperf-client # 클라이언트 Pod 레이블
spec:
  containers:
  - name: netperf       # 컨테이너 이름
    image: networkstatic/netperf  # netperf 도구가 포함된 이미지
    command: ["sleep", "infinity"]  # Pod가 계속 실행되도록 설정
---
apiVersion: v1
kind: Pod
metadata:
  name: netperf-server  # 서버 Pod 이름
  labels:
    app: netperf-server # 서버 Pod 레이블
spec:
  containers:
  - name: netperf       # 컨테이너 이름
    image: networkstatic/netperf  # netperf 도구가 포함된 이미지
    command: ["sleep", "infinity"]  # Pod가 계속 실행되도록 설정
EOF

# netperf 서버 시작
# 서버 Pod에서 netperf 서버 데몬 실행
kubectl exec -it netperf-server -- netserver

# TCP_RR 테스트 (요청-응답 지연시간)
# 클라이언트-서버 간 TCP 요청-응답 지연시간 측정 (60초 동안)
kubectl exec -it netperf-client -- netperf -H $(kubectl get pod netperf-server -o=jsonpath='{.status.podIP}') -t TCP_RR -l 60

# TCP_STREAM 테스트 (대역폭)
# 클라이언트-서버 간 TCP 스트림 대역폭 측정 (60초 동안)
kubectl exec -it netperf-client -- netperf -H $(kubectl get pod netperf-server -o=jsonpath='{.status.podIP}') -t TCP_STREAM -l 60

Cilium 자체 진단 도구를 사용한 성능 테스트:

# Cilium 연결성 테스트 도구 실행
# 이 테스트는 다양한 네트워크 시나리오에 대한 기능 및 성능을 검증합니다
# 여러 유형의 네트워크 통신을 테스트하고 결과를 보고합니다
cilium connectivity test

✅ 주요 성능 지표 수집 및 분석

# 1. Cilium 에이전트 성능 지표 수집
# cilium-agent의 Prometheus 메트릭을 로컬 포트로 포워딩
kubectl -n kube-system port-forward service/cilium-agent-prometheus-metrics 9090:9090

# 브라우저에서 http://localhost:9090/metrics 접속
# 여기서 Cilium의 다양한 성능 지표를 볼 수 있습니다

# 2. eBPF 맵 상태 확인
# 현재 eBPF 맵 목록과 각 맵의 메모리 사용량 확인
cilium bpf map list

# 특정 맵 세부 정보 확인 (예: NAT 맵)
# NAT 맵의 현재 항목 수 및 내용 확인
cilium bpf nat list

# 3. Endpoint 상태 및 정책 수 확인
# 현재 Cilium이 관리하는 모든 엔드포인트 목록 확인
cilium endpoint list

# 4. 컴포넌트별 리소스 사용량 확인
# Cilium 에이전트 Pod의 CPU/메모리 사용량 확인
kubectl top pods -n kube-system -l k8s-app=cilium
# Cilium 오퍼레이터 Pod의 CPU/메모리 사용량 확인
kubectl top pods -n kube-system -l k8s-app=cilium-operator

성능 데이터 시각화를 위한 대시보드 설정:

# 성능 모니터링 대시보드용 Grafana ConfigMap 예시
# 이 ConfigMap은 Cilium 성능 모니터링을 위한 Grafana 대시보드를 정의합니다
apiVersion: v1
kind: ConfigMap
metadata:
  name: cilium-performance-dashboard  # ConfigMap 이름
  namespace: monitoring               # 모니터링 네임스페이스에 생성
data:
  cilium-performance.json: |          # Grafana 대시보드 JSON 정의
    {
      "annotations": {
        "list": [...]
      },
      "editable": true,
      "gnetId": null,
      "graphTooltip": 0,
      "id": 1,
      "links": [],
      "panels": [
        {
          "aliasColors": {},
          "bars": false,
          "dashLength": 10,
          "dashes": false,
          "datasource": "Prometheus",
          "fieldConfig": {
            "defaults": {},
            "overrides": []
          },
          "fill": 1,
          "fillGradient": 0,
          "gridPos": {
            "h": 8,
            "w": 12,
            "x": 0,
            "y": 0
          },
          "hiddenSeries": false,
          "id": 2,
          "legend": {
            "avg": false,
            "current": false,
            "max": false,
            "min": false,
            "show": true,
            "total": false,
            "values": false
          },
          "lines": true,
          "linewidth": 1,
          "nullPointMode": "null",
          "options": {
            "alertThreshold": true
          },
          "percentage": false,
          "pluginVersion": "7.5.5",
          "pointradius": 2,
          "points": false,
          "renderer": "flot",
          "seriesOverrides": [],
          "spaceLength": 10,
          "stack": false,
          "steppedLine": false,
          "targets": [
            {
              "expr": "rate(cilium_drop_count_total[5m])",  # 5분 간격으로 패킷 드롭 비율 측정
              "interval": "",
              "legendFormat": "{{ reason }}",  # 드롭 이유별로 그래프 표시
              "refId": "A"
            }
          ],
          "thresholds": [],
          "timeRegions": [],
          "title": "Packet Drop Rate",  # 패널 제목
          "tooltip": {
            "shared": true,
            "sort": 0,
            "value_type": "individual"
          },
          "type": "graph",
          "xaxis": {
            "buckets": null,
            "mode": "time",
            "name": null,
            "show": true,
            "values": []
          },
          "yaxes": [
            {
              "format": "short",
              "label": null,
              "logBase": 1,
              "max": null,
              "min": null,
              "show": true
            },
            {
              "format": "short",
              "label": null,
              "logBase": 1,
              "max": null,
              "min": null,
              "show": true
            }
          ],
          "yaxis": {
            "align": false,
            "alignLevel": null
          }
        }
        // 추가 패널 설정...
      ],
      "refresh": "10s",  # 10초마다 대시보드 갱신
      "schemaVersion": 27,
      "style": "dark",
      "tags": [],
      "templating": {
        "list": []
      },
      "time": {
        "from": "now-6h",  # 기본적으로 지난 6시간 데이터 표시
        "to": "now"
      },
      "timepicker": {},
      "timezone": "",
      "title": "Cilium Performance",  # 대시보드 제목
      "uid": "cilium-perf",
      "version": 1
    }

✅ 성능 테스트 자동화 스크립트

다음은 주기적인 성능 테스트를 자동화하는 스크립트 예시입니다:

#!/bin/bash
# cilium-performance-test.sh
# 정기적인 성능 테스트를 실행하고 결과를 수집하는 스크립트

# 테스트 Pod가 존재하는지 확인
# netperf 테스트를 위한 Pod가 없으면 생성
if ! kubectl get pod netperf-client &>/dev/null; then
  echo "Creating test pods..."
  kubectl apply -f netperf-pods.yaml  # Pod 정의 파일 적용
  sleep 30  # Pod 생성 대기
fi

# 결과 저장 디렉토리
# 날짜와 시간 기반으로 고유한 디렉토리 생성
RESULTS_DIR="cilium-perf-results-$(date +%Y%m%d-%H%M)"
mkdir -p $RESULTS_DIR

# Cilium 버전 및 설정 정보 수집
echo "Collecting Cilium configuration..."
kubectl -n kube-system get pods -l k8s-app=cilium -o yaml > $RESULTS_DIR/cilium-pods.yaml
cilium version > $RESULTS_DIR/cilium-version.txt
cilium status --verbose > $RESULTS_DIR/cilium-status.txt
cilium config > $RESULTS_DIR/cilium-config.txt

# Pod IP 주소 가져오기
SERVER_IP=$(kubectl get pod netperf-server -o=jsonpath='{.status.podIP}')
echo "Server IP: $SERVER_IP"

# 다양한 성능 테스트 실행
echo "Running performance tests..."

# 1. TCP 요청-응답 테스트 (지연시간)
echo "TCP_RR test (latency)..."
# 60초 동안 요청-응답 테스트 실행하고 결과 저장
kubectl exec -it netperf-client -- netperf -H $SERVER_IP -t TCP_RR -l 60 -- -r 1,1 > $RESULTS_DIR/tcp_rr_results.txt

# 2. TCP 스트림 테스트 (대역폭)
echo "TCP_STREAM test (bandwidth)..."
# 60초 동안 TCP 스트림 테스트 실행하고 결과 저장
kubectl exec -it netperf-client -- netperf -H $SERVER_IP -t TCP_STREAM -l 60 > $RESULTS_DIR/tcp_stream_results.txt

# 3. UDP 스트림 테스트
echo "UDP_STREAM test..."
# 60초 동안 UDP 스트림 테스트 실행하고 결과 저장
kubectl exec -it netperf-client -- netperf -H $SERVER_IP -t UDP_STREAM -l 60 > $RESULTS_DIR/udp_stream_results.txt

# 4. 다양한 패킷 크기에 따른 성능 테스트
echo "Testing with various packet sizes..."
# 여러 패킷 크기(64바이트부터 16KB까지)로 테스트 실행
for size in 64 128 512 1024 8192 16384; do
  echo "Packet size: $size bytes"
  kubectl exec -it netperf-client -- netperf -H $SERVER_IP -t TCP_STREAM -l 30 -- -m $size > $RESULTS_DIR/tcp_stream_${size}bytes.txt
done

# 5. 연결 수에 따른 성능 테스트
echo "Testing with various connection counts..."
# 동시 연결 수(1부터 100까지)를 증가시키며 테스트
for conn in 1 10 50 100; do
  echo "Connections: $conn"
  kubectl exec -it netperf-client -- bash -c "for i in \$(seq 1 $conn); do netperf -H $SERVER_IP -t TCP_CRR -l 10 & done; wait" > $RESULTS_DIR/tcp_crr_${conn}conns.txt
done

# 테스트 중 리소스 사용량 측정
echo "Collecting resource usage..."
kubectl top pods -n kube-system -l k8s-app=cilium > $RESULTS_DIR/cilium_resource_usage.txt
kubectl top nodes > $RESULTS_DIR/node_resource_usage.txt

# 결과 요약
echo "Summarizing results..."
echo "Test completed at $(date)" > $RESULTS_DIR/summary.txt
echo "TCP_RR (latency):" >> $RESULTS_DIR/summary.txt
grep -A 1 "Throughput" $RESULTS_DIR/tcp_rr_results.txt >> $RESULTS_DIR/summary.txt
echo "TCP_STREAM (bandwidth):" >> $RESULTS_DIR/summary.txt
grep -A 1 "Throughput" $RESULTS_DIR/tcp_stream_results.txt >> $RESULTS_DIR/summary.txt

echo "Tests completed. Results saved to $RESULTS_DIR"

📌 eBPF 튜닝 포인트

Cilium의 핵심인 eBPF 프로그램의 성능을 최적화하는 방법을 살펴보겠습니다.

✅ 커널 파라미터 최적화

eBPF 성능에 영향을 미치는 주요 커널 파라미터와 그 설정 방법입니다:

# 노드에 적용할 sysctl 설정 (DaemonSet으로 실행)
# 이 DaemonSet은 모든 노드에서 실행되어 커널 파라미터를 최적화합니다
cat <<EOF | kubectl apply -f -
apiVersion: apps/v1
kind: DaemonSet                        # 모든 노드에서 실행되는 DaemonSet
metadata:
  name: cilium-sysctl-tuner            # DaemonSet 이름
  namespace: kube-system               # kube-system 네임스페이스에 배포
spec:
  selector:
    matchLabels:
      app: cilium-sysctl-tuner         # Pod 선택자
  template:
    metadata:
      labels:
        app: cilium-sysctl-tuner       # Pod 레이블
    spec:
      hostPID: true                    # 호스트 PID 네임스페이스 사용
      hostIPC: true                    # 호스트 IPC 네임스페이스 사용
      hostNetwork: true                # 호스트 네트워크 사용
      containers:
      - name: sysctl-tuner             # 컨테이너 이름
        image: alpine:latest           # 알파인 리눅스 베이스 이미지
        command: 
        - "/bin/sh"
        - "-c"
        - |
          # 커널 매개변수 최적화
          echo "Setting kernel parameters..."

          # 네트워크 성능 관련 매개변수
          sysctl -w net.core.somaxconn=65535                # 연결 큐 크기 증가
          sysctl -w net.ipv4.tcp_max_syn_backlog=4096       # SYN 백로그 크기 증가
          sysctl -w net.core.netdev_max_backlog=300000      # 네트워크 장치 백로그 증가
          sysctl -w net.ipv4.tcp_timestamps=1               # TCP 타임스탬프 활성화
          sysctl -w net.ipv4.tcp_sack=1                     # TCP SACK 활성화

          # 연결 추적 관련 매개변수
          sysctl -w net.netfilter.nf_conntrack_max=1000000  # 연결 추적 최대 항목 수 증가
          sysctl -w net.netfilter.nf_conntrack_tcp_timeout_established=86400  # 연결 타임아웃 증가 (24시간)

          # eBPF 관련 매개변수
          sysctl -w kernel.perf_event_paranoid=0            # 성능 이벤트 접근 제한 완화
          sysctl -w kernel.kptr_restrict=0                  # 커널 포인터 제한 완화

          # 영구 적용을 위한 sysctl 설정 파일 생성
          cat > /host/etc/sysctl.d/99-cilium-tuning.conf << INNEREOF
          net.core.somaxconn=65535
          net.ipv4.tcp_max_syn_backlog=4096
          net.core.netdev_max_backlog=300000
          net.ipv4.tcp_timestamps=1
          net.ipv4.tcp_sack=1
          net.netfilter.nf_conntrack_max=1000000
          net.netfilter.nf_conntrack_tcp_timeout_established=86400
          kernel.perf_event_paranoid=0
          kernel.kptr_restrict=0
          INNEREOF

          # 설정 적용 확인
          echo "Current kernel parameters:"
          sysctl -a | grep -E 'somaxconn|backlog|conntrack|timestamps|sack|perf_event_paranoid|kptr_restrict'

          # 무한 대기 (Pod 유지)
          echo "Configuration applied. Sleeping..."
          sleep infinity
        securityContext:
          privileged: true             # 특권 모드로 실행 (커널 파라미터 변경 필요)
        volumeMounts:
        - name: host                   # 호스트 파일시스템 마운트
          mountPath: /host
      volumes:
      - name: host                     # 호스트 볼륨 정의
        hostPath:
          path: /                      # 루트 파일시스템 접근
EOF

✅ eBPF 맵 튜닝

Cilium에서 사용하는 eBPF 맵의 크기와 설정을 조정하여 성능을 개선할 수 있습니다:

# values.yaml에 적용할 eBPF 맵 최적화 설정
bpf:
  # eBPF 맵 사전 할당 (성능 향상)
  # 맵을 미리 할당하여 동적 할당 오버헤드 제거
  preallocateMaps: true

  # 맵 값 설정
  mapValues:
    # CT 맵 크기 (연결 추적)
    # 노드당 예상 동시 연결 수에 맞게 조정
    # 기본값보다 크게 설정하면 많은 연결을 처리할 수 있지만 메모리 사용량 증가
    ct_max_entries: 524288      # 동시 연결 추적 항목 수 (TCP), 약 512K 항목
    ct_max_entries_udp: 262144  # UDP 연결 추적 항목 수, 약 256K 항목

    # NAT 맵 크기
    # 많은 외부 연결이 필요한 경우 증가
    nat_max_entries: 262144     # NAT 테이블 항목 수, 약 256K 항목

    # 소켓 맵 크기
    # 많은 소켓 연결이 있는 경우 증가
    sock_ops_entries: 65536     # 소켓 작업 추적 항목 수, 약 64K 항목

    # 정책 맵 크기
    # 복잡한 네트워크 정책이 많은 경우 증가
    policy_max_entries: 16384   # 정책 관련 맵 항목 수, 약 16K 항목

    # 프래그먼트 맵 크기
    # IPv4/IPv6 패킷 프래그먼트 처리에 사용
    fragments_max_entries: 8192 # 프래그먼트 추적 항목 수, 8K 항목

    # 이벤트 큐 크기
    # 모니터링 이벤트를 위한 버퍼
    # 높은 이벤트 발생률이 예상되는 경우 증가
    lb_entries: 65536           # 로드 밸런싱 관련 항목 수, 약 64K 항목

eBPF 맵 사용량 모니터링 스크립트:

#!/bin/bash
# ebpf-map-usage-monitor.sh
# eBPF 맵 사용량을 모니터링하는 스크립트

while true; do
  echo "=== eBPF Map Usage $(date) ==="

  # 노드별로 맵 사용량 확인
  for node in $(kubectl get nodes -o jsonpath='{.items[*].metadata.name}'); do
    echo "Node: $node"

    # 노드의 Cilium Pod 찾기
    CILIUM_POD=$(kubectl -n kube-system get pods -l k8s-app=cilium -o jsonpath='{.items[?(@.spec.nodeName=="'$node'")].metadata.name}')

    if [ -z "$CILIUM_POD" ]; then
      echo "  No Cilium pod found on node $node"
      continue
    fi

    # 주요 eBPF 맵 사용량 확인
    echo "  CT Map (TCP):"    # 연결 추적 맵 항목 수
    kubectl -n kube-system exec $CILIUM_POD -- cilium bpf ct list -o json | jq -r 'length'

    echo "  NAT Map:"         # NAT 맵 항목 수
    kubectl -n kube-system exec $CILIUM_POD -- cilium bpf nat list -o json | jq -r 'length'

    echo "  LB Map:"          # 로드 밸런싱 맵 항목 수
    kubectl -n kube-system exec $CILIUM_POD -- cilium bpf lb list -o json | jq -r 'length'

    echo "  Tunnel Map:"      # 터널 맵 항목 수
    kubectl -n kube-system exec $CILIUM_POD -- cilium bpf tunnel list -o json | jq -r 'length'

    echo "  Endpoints:"       # 관리 중인 엔드포인트 수
    kubectl -n kube-system exec $CILIUM_POD -- cilium endpoint list | grep -v reserved | wc -l

    echo ""
  done

  sleep 300  # 5분마다 실행
done

✅ 데이터 경로 최적화

데이터 경로(datapath) 설정을 최적화하여 네트워크 패킷 처리 성능을 높일 수 있습니다:

# values.yaml에 적용할 데이터 경로 최적화 설정

# 터널 모드 설정
# vxlan: 범용적이고 안정적인 터널 모드
# geneve: vxlan과 유사하지만 더 많은 메타데이터 지원
# disabled: 터널 없이 직접 라우팅 (최고 성능, 네트워크 호환성 필요)
tunnel: "disabled"     # 터널링 비활성화하여 오버헤드 제거

# 직접 라우팅 활성화 (tunnel: disabled인 경우)
# 노드 간 직접 라우팅을 활성화하여 터널링 오버헤드 제거
autoDirectNodeRoutes: true

# 호스트 라우팅 최적화
# 호스트에서 발생하는 트래픽 처리 성능 향상
bpf:
  hostRouting: true    # eBPF 기반 호스트 라우팅 활성화

# kube-proxy 대체 모드
# "strict": kube-proxy 완전 대체 (성능 최대화)
# "probe": 기능별로 자동 탐지
# "partial": 일부만 대체
# "disabled": 대체하지 않음
kubeProxyReplacement: "strict"   # kube-proxy 완전 대체하여 성능 최대화

# 로드 밸런싱 설정
loadBalancer:
  # 알고리즘 선택
  # "random": 단순 무작위 선택 (기본값)
  # "maglev": 일관된 해싱 (연결 지속성 개선)
  algorithm: "maglev"   # 일관된 해싱 알고리즘 사용

  # DSR(Direct Server Return) 모드
  # 반환 트래픽이 로드 밸런서를 우회하여 직접 클라이언트로 전송
  # "enabled": DSR 활성화 (성능 향상)
  mode: "dsr"           # DSR 모드로 반환 트래픽 최적화

  # 가속 방식
  # "disabled": 가속 없음
  # "native": XDP 기반 가속 (지원 가능한 NIC에서 성능 대폭 향상)
  acceleration: "native"  # XDP 기반 가속 활성화

# 소켓 기반 로드 밸런싱
# 소켓 수준에서 로드 밸런싱하여 성능 향상
socketLB:
  enabled: true  # 소켓 로드 밸런싱 활성화

✅ 모니터링 오버헤드 최적화

모니터링 설정을 최적화하여 오버헤드를 줄일 수 있습니다:

# values.yaml에 적용할 모니터링 최적화 설정

# BPF 모니터링 설정
bpf:
  # 모니터링 집계 수준
  # "none": 집계 없음 (최소 오버헤드)
  # "low": 기본적인 집계
  # "medium": 중간 수준 집계
  # "maximum": 최대 집계 (높은 오버헤드)
  monitorAggregation: "medium"  # 중간 수준 집계 (균형 잡힌 설정)

  # 모니터링 간격 (초)
  # 모니터링 이벤트 수집 주기 설정
  monitorInterval: "5s"         # 5초마다 모니터링 데이터 수집

  # 모니터링 대상 패킷 유형
  # "all": 모든 패킷 (높은 오버헤드)
  # "drop": 드롭된 패킷만
  # "trace": 추적 패킷만
  # "from-network": 네트워크에서 수신된 패킷만
  # "to-network": 네트워크로 전송되는 패킷만
  # "from-proxy": 프록시에서 수신된 패킷만
  # "to-proxy": 프록시로 전송되는 패킷만
  monitorFlags: "drop"           # 드롭된 패킷만 모니터링 (오버헤드 감소)

# Hubble 모니터링 설정
hubble:
  enabled: true                  # Hubble 활성화

  # 플로우 버퍼 크기
  # 클러스터 크기/트래픽에 따라 조정
  # 크게 설정하면 더 많은 트래픽 이벤트 보관 가능 (메모리 사용량 증가)
  flowBufferSize: 65536          # 약 64K 플로우 저장 가능

  # 메트릭 수집 설정
  metrics:
    enabled:
      # 필요한 메트릭만 선택하여 오버헤드 감소
      - "drop"                   # 드롭된 패킷 메트릭만 수집
      - "tcp"                    # TCP 연결 관련 메트릭만 수집
      # - "flow"                 # 기본 플로우 메트릭 (비활성화)
      # - "http"                 # HTTP 요청 메트릭 (비활성화)
      # - "icmp"                 # ICMP 메트릭 (비활성화)
      # - "dns"                  # DNS 쿼리 메트릭 (비활성화)

📌 리소스 관리 및 스케일링

Cilium 구성 요소의 리소스 할당과 효율적인 스케일링 방법을 살펴보겠습니다.

✅ 노드 규모별 리소스 할당 전략

# 소규모 클러스터 (10 노드 이하)
# 작은 규모의 클러스터에 적합한 리소스 설정
resources:
  cilium:                     # Cilium 에이전트 리소스
    requests:
      cpu: 100m               # 최소 0.1 CPU 코어 요청
      memory: 512Mi           # 최소 512MB 메모리 요청
    limits:
      cpu: 500m               # 최대 0.5 CPU 코어 제한
      memory: 1Gi             # 최대 1GB 메모리 제한
  operator:                   # Cilium 오퍼레이터 리소스
    requests:
      cpu: 50m                # 최소 0.05 CPU 코어 요청
      memory: 128Mi           # 최소 128MB 메모리 요청
    limits:
      cpu: 200m               # 최대 0.2 CPU 코어 제한
      memory: 512Mi           # 최대 512MB 메모리 제한

# 중규모 클러스터 (10-50 노드)
# 중간 규모의 클러스터에 적합한 리소스 설정
resources:
  cilium:                     # Cilium 에이전트 리소스
    requests:
      cpu: 200m               # 최소 0.2 CPU 코어 요청
      memory: 512Mi           # 최소 512MB 메모리 요청
    limits:
      cpu: 1000m              # 최대 1 CPU 코어 제한
      memory: 2Gi             # 최대 2GB 메모리 제한
  operator:                   # Cilium 오퍼레이터 리소스
    requests:
      cpu: 100m               # 최소 0.1 CPU 코어 요청
      memory: 256Mi           # 최소 256MB 메모리 요청
    limits:
      cpu: 500m               # 최대 0.5 CPU 코어 제한
      memory: 1Gi             # 최대 1GB 메모리 제한

# 대규모 클러스터 (50 노드 이상)
# 대규모 클러스터에 적합한 리소스 설정
resources:
  cilium:                     # Cilium 에이전트 리소스
    requests:
      cpu: 500m               # 최소 0.5 CPU 코어 요청
      memory: 1Gi             # 최소 1GB 메모리 요청
    limits:
      cpu: 2000m              # 최대 2 CPU 코어 제한
      memory: 4Gi             # 최대 4GB 메모리 제한
  operator:                   # Cilium 오퍼레이터 리소스
    requests:
      cpu: 250m               # 최소 0.25 CPU 코어 요청
      memory: 512Mi           # 최소 512MB 메모리 요청
    limits:
      cpu: 1000m              # 최대 1 CPU 코어 제한
      memory: 2Gi             # 최대 2GB 메모리 제한

✅ 대규모 클러스터 확장성 팁

대규모 클러스터에서 Cilium의 확장성을 개선하기 위한 설정:

# 대규모 클러스터 확장성 설정

# Operator 레플리카 수 증가
# 여러 오퍼레이터를 실행하여 부하 분산 및 고가용성 제공
operator:
  replicas: 3                # 대규모 클러스터에서는 여러 개의 오퍼레이터 실행

# Hubble Relay 확장
# Hubble Relay 복제본 증가로 가시성 컴포넌트 부하 분산
hubble:
  relay:
    enabled: true
    replicas: 5              # 대규모 클러스터에서는 여러 개의 Relay 실행

# IPAM 설정 최적화
# IP 주소 할당 관리 설정 최적화
ipam:
  mode: "cluster-pool"       # 클러스터 풀 모드 사용
  operator:
    clusterPoolIPv4PodCIDRList:
      - "10.0.0.0/8"         # 넓은 CIDR 범위 사용
    clusterPoolIPv4MaskSize: 24  # 노드당 /24 서브넷 할당 (약 254개 IP)

# 연결 추적 최적화
# 연결 추적 테이블 크기 증가
bpf:
  ctTcpMax: 1000000          # TCP 연결 추적 최대 항목 수 증가
  ctAnyMax: 500000           # 기타 프로토콜 연결 추적 최대 항목 수 증가

# Policy 처리 최적화
# 명시적 정책이 있는 네임스페이스에만
# 정책 강제 적용하여 불필요한 처리 감소
policyEnforcementMode: "default"

# 엔드포인트 GC 최적화
# 가비지 컬렉션 간격 및 타임아웃 최적화
endpointGC:
  interval: "5m"             # 5분마다 가비지 컬렉션 실행
  timeoutSec: 86400          # 24시간 후 미사용 엔드포인트 정리

✅ Cilium 컴포넌트 스케일링 전략

# cilium-scaling-strategy.yaml

# Hubble UI 및 Relay 부하분산
hubble:
  ui:
    enabled: true
    replicas: 2              # UI 레플리카 수 증가
    service:
      type: LoadBalancer     # 클라우드 환경에서 로드밸런서 사용

  relay:
    enabled: true
    replicas: 3              # Relay 레플리카 수 증가
    # Relay에 대한 PDB(Pod Disruption Budget) 설정
    # 최소 가용성 보장
    podDisruptionBudget:
      enabled: true
      maxUnavailable: 1      # 최대 1개 Pod만 동시에 중단 가능

# 오퍼레이터 HA 구성
operator:
  replicas: 2                # 오퍼레이터 레플리카 수 증가

  # 오퍼레이터 PDB 설정
  podDisruptionBudget:
    enabled: true
    maxUnavailable: 1        # 최대 1개 Pod만 동시에 중단 가능

  # 롤링 업데이트 전략
  rollOutPods: true          # 업데이트 시 Pod 순차적 재시작

# Cilium 에이전트 업데이트 전략
updateStrategy:
  type: "RollingUpdate"      # 롤링 업데이트 방식 사용
  rollingUpdate:
    maxUnavailable: "20%"    # 한 번에 최대 20%의 노드만 업데이트

# Pod 중단 예산 설정
podDisruptionBudget:
  enabled: true
  maxUnavailable: 1          # 최대 1개 Pod만 동시에 중단 가능

✅ 리소스 사용량 모니터링 및 알림 설정

리소스 사용량 모니터링과 이상 징후 발생 시 알림을 설정하는 방법:

# prometheus-rule.yaml - Cilium 리소스 모니터링을 위한 Prometheus 알림 규칙
apiVersion: monitoring.coreos.com/v1
kind: PrometheusRule
metadata:
  name: cilium-resource-alerts   # 규칙 이름
  namespace: monitoring          # 모니터링 네임스페이스
spec:
  groups:
  - name: cilium-resources       # 규칙 그룹 이름
    rules:
    # Cilium 에이전트 CPU 사용량 경고
    # 5분 동안 CPU 사용량이 80% 이상일 때 경고
    - alert: CiliumAgentHighCPUUsage
      expr: sum(rate(process_cpu_seconds_total{job="cilium-agent"}[5m])) by (pod) * 100 > 80
      for: 15m                   # 15분 이상 지속되면 알림 발생
      labels:
        severity: warning        # 알림 심각도: 경고
      annotations:
        summary: "Cilium agent high CPU usage detected"
        description: "Cilium agent {{ $labels.pod }} is using more than 80% CPU for over 15 minutes."

    # Cilium 에이전트 메모리 사용량 경고
    # 메모리 사용량이 1.5GB 이상일 때 경고
    - alert: CiliumAgentHighMemoryUsage
      expr: process_resident_memory_bytes{job="cilium-agent"} / (1024 * 1024 * 1024) > 1.5
      for: 15m                   # 15분 이상 지속되면 알림 발생
      labels:
        severity: warning        # 알림 심각도: 경고
      annotations:
        summary: "Cilium agent high memory usage detected"
        description: "Cilium agent {{ $labels.pod }} is using more than 1.5GB of memory for over 15 minutes."

    # Cilium 오퍼레이터 CPU 사용량 경고
    # 5분 동안 CPU 사용량이 60% 이상일 때 경고
    - alert: CiliumOperatorHighCPUUsage
      expr: sum(rate(process_cpu_seconds_total{job="cilium-operator"}[5m])) by (pod) * 100 > 60
      for: 15m                   # 15분 이상 지속되면 알림 발생
      labels:
        severity: warning        # 알림 심각도: 경고
      annotations:
        summary: "Cilium operator high CPU usage detected"
        description: "Cilium operator {{ $labels.pod }} is using more than 60% CPU for over 15 minutes."

    # Cilium 오퍼레이터 메모리 사용량 경고
    # 메모리 사용량이 800MB 이상일 때 경고
    - alert: CiliumOperatorHighMemoryUsage
      expr: process_resident_memory_bytes{job="cilium-operator"} / (1024 * 1024) > 800
      for: 15m                   # 15분 이상 지속되면 알림 발생
      labels:
        severity: warning        # 알림 심각도: 경고
      annotations:
        summary: "Cilium operator high memory usage detected"
        description: "Cilium operator {{ $labels.pod }} is using more than 800MB of memory for over 15 minutes."

    # eBPF 맵 사용량 경고 (80% 이상)
    # 맵 사용률이 80% 이상일 때 경고
    - alert: CiliumEBPFMapNearlyFull
      expr: cilium_bpf_map_entries / cilium_bpf_map_capacity > 0.8
      for: 10m                   # 10분 이상 지속되면 알림 발생
      labels:
        severity: warning        # 알림 심각도: 경고
      annotations:
        summary: "Cilium eBPF map nearly full"
        description: "Cilium eBPF map {{ $labels.map_name }} on {{ $labels.pod }} is over 80% full."

리소스 사용량 자동 모니터링 스크립트:

#!/bin/bash
# cilium-resource-monitor.sh - Cilium 리소스 사용량 모니터링 스크립트

# 결과 저장 디렉토리
# 오늘 날짜 기준으로 디렉토리 생성
OUTPUT_DIR="cilium-metrics-$(date +%Y%m%d)"
mkdir -p $OUTPUT_DIR

# 모니터링 기간 설정
DURATION=3600  # 1시간 (초 단위)
INTERVAL=60    # 60초 간격으로 측정

# 측정 횟수 계산
ITERATIONS=$((DURATION / INTERVAL))

echo "Starting Cilium resource monitoring for $DURATION seconds..."
echo "Results will be saved to $OUTPUT_DIR"

# CSV 헤더 생성
echo "timestamp,pod,cpu_percent,memory_mb,connections,endpoints" > $OUTPUT_DIR/cilium_resources.csv

# 모니터링 반복
for ((i=1; i<=$ITERATIONS; i++)); do
  TIMESTAMP=$(date +"%Y-%m-%d %H:%M:%S")

  # 모든 Cilium Pod 순회
  for pod in $(kubectl get pods -n kube-system -l k8s-app=cilium -o jsonpath='{.items[*].metadata.name}'); do
    # CPU 사용량 (millicores)
    # kubectl top 명령을 사용하여 CPU 사용량 측정
    CPU=$(kubectl top pod -n kube-system $pod | tail -n 1 | awk '{print $2}' | sed 's/m//')

    # 메모리 사용량 (MB)
    # kubectl top 명령을 사용하여 메모리 사용량 측정
    MEMORY=$(kubectl top pod -n kube-system $pod | tail -n 1 | awk '{print $3}' | sed 's/Mi//')

    # 연결 수 (ct 맵 항목 수)
    # 연결 추적 테이블의 항목 수 측정
    CONNECTIONS=$(kubectl exec -n kube-system $pod -- cilium bpf ct list | wc -l)

    # 엔드포인트 수
    # 관리 중인 엔드포인트(Pod) 수 측정
    ENDPOINTS=$(kubectl exec -n kube-system $pod -- cilium endpoint list | grep -v reserved | wc -l)

    # CSV에 데이터 추가
    echo "$TIMESTAMP,$pod,$CPU,$MEMORY,$CONNECTIONS,$ENDPOINTS" >> $OUTPUT_DIR/cilium_resources.csv

    # 로그 출력
    echo "[$i/$ITERATIONS] $TIMESTAMP - Pod: $pod, CPU: ${CPU}m, Memory: ${MEMORY}Mi, Connections: $CONNECTIONS, Endpoints: $ENDPOINTS"
  done

  # 다음 측정까지 대기
  sleep $INTERVAL
done

echo "Monitoring completed. Data saved to $OUTPUT_DIR/cilium_resources.csv"

# 간단한 분석 수행
echo "Performing basic analysis..."
# Pod별 평균 리소스 사용량 계산
echo -e "\nAverage resource usage per pod:" >> $OUTPUT_DIR/analysis.txt
awk -F, 'NR>1 {sum_cpu[$2]+=$3; sum_mem[$2]+=$4; count[$2]++} END {for (pod in count) print pod ": CPU " sum_cpu[pod]/count[pod] "m, Memory " sum_mem[pod]/count[pod] "Mi"}' $OUTPUT_DIR/cilium_resources.csv >> $OUTPUT_DIR/analysis.txt

# Pod별 최대 리소스 사용량 계산
echo -e "\nMax resource usage per pod:" >> $OUTPUT_DIR/analysis.txt
awk -F, 'NR>1 {if ($3 > max_cpu[$2]) max_cpu[$2]=$3; if ($4 > max_mem[$2]) max_mem[$2]=$4} END {for (pod in max_cpu) print pod ": Max CPU " max_cpu[pod] "m, Max Memory " max_mem[pod] "Mi"}' $OUTPUT_DIR/cilium_resources.csv >> $OUTPUT_DIR/analysis.txt

echo "Analysis saved to $OUTPUT_DIR/analysis.txt"

📌 특정 워크로드별 최적화 전략

다양한 유형의 워크로드에 따른 Cilium 최적화 전략을 살펴보겠습니다.

✅ 마이크로서비스 트래픽 최적화

마이크로서비스 아키텍처에서 Cilium을 최적화하는 방법:

# microservices-optimized-values.yaml

# 서비스 간 통신 최적화
# ID 기반 표시를 사용하여 정책 처리를 가속화
enableIdentityMark: true

# 서비스 메시 최적화
proxy:
  enabled: true              # L7 프록시 활성화
  # Istio와 통합 시 사용할 프록시 이미지
  sidecarIstioProxyImageName: "cilium/istio_proxy"

# 로드 밸런싱 최적화 (서비스 통신용)
loadBalancer:
  algorithm: "maglev"        # 마이크로서비스에 최적화된 일관된 해싱
  mode: "snat"               # SNAT 모드 (컨테이너 네트워크에서 일반적으로 필요)

# 헤드리스 서비스 최적화
hostServices:
  enabled: true              # 호스트 서비스 지원 활성화
  protocols: "tcp"           # TCP 프로토콜만 처리 (오버헤드 감소)

# DNS 응답 캐싱 및 프록시 최적화
# 서비스 조회 성능 향상
dnsPolicy: "cluster-first-with-host-fallback"  # DNS 정책 설정
dnsProxy:
  enabled: true              # DNS 프록시 활성화
  dnsRejectResponseCode: "refused"  # 거부 응답 코드 설정
  maxDeferredConnections: 10000     # 최대 지연 연결 수

마이크로서비스 환경을 위한 네트워크 정책 템플릿:

# microservices-base-policy.yaml
apiVersion: "cilium.io/v2"
kind: CiliumNetworkPolicy
metadata:
  name: "microservices-base"           # 정책 이름
  namespace: default                   # 적용할 네임스페이스
spec:
  description: "기본 마이크로서비스 통신 정책"
  endpointSelector:
    matchLabels:
      # 모든 마이크로서비스에 적용
      io.kubernetes.pod.namespace: default  # default 네임스페이스의 모든 Pod
  ingress:
  # 같은 네임스페이스 내 통신 허용
  - fromEndpoints:
    - matchLabels:
        io.kubernetes.pod.namespace: default  # default 네임스페이스에서 오는 트래픽만 허용
    toPorts:
    - ports:
      # 마이크로서비스 일반 포트
      - port: "8080"           # 기본 서비스 포트 허용
        protocol: TCP
      # 상태 확인 포트
      - port: "8081"           # 상태 확인 포트 허용
        protocol: TCP
      # 메트릭 포트
      - port: "9090"           # 메트릭 포트 허용
        protocol: TCP
  egress:
  # 내부 DNS 쿼리 허용
  - toEndpoints:
    - matchLabels:
        k8s:io.kubernetes.pod.namespace: kube-system  # kube-system 네임스페이스로의 트래픽
        k8s-app: kube-dns                             # DNS 서비스로의 트래픽
    toPorts:
    - ports:
      - port: "53"             # DNS UDP 포트 허용
        protocol: UDP
      - port: "53"             # DNS TCP 포트 허용
        protocol: TCP
  # 외부 API 호출 허용
  - toFQDNs:
    - matchPattern: "*.api.example.com"  # 특정 도메인 패턴으로의 트래픽 허용
    toPorts:
    - ports:
      - port: "443"            # HTTPS 포트 허용
        protocol: TCP

✅ 대용량 데이터 처리 워크로드 최적화

대용량 데이터 처리 워크로드(빅데이터, ML 등)를 위한 Cilium 최적화 설정:

# big-data-values.yaml

# MTU 최적화 (점보 프레임 지원)
mtu: 9000                      # 점보 프레임 지원 (네트워크 인프라 지원 필요)

# TCP 최적화
enableIPv4FragmentsTracking: true  # 프래그먼트 추적 활성화

# 직접 라우팅 사용 (터널 오버헤드 제거)
tunnel: "disabled"             # 터널링 비활성화
autoDirectNodeRoutes: true     # 직접 라우팅 활성화

# 정책 처리 최소화
# 대용량 데이터 워크로드에서 정책 처리 오버헤드 제거
policyEnforcementMode: "never"  # 정책 강제 적용 비활성화

# 소켓 수준 로드 밸런싱 활성화
socketLB:
  enabled: true                # 소켓 로드 밸런싱 활성화

# eBPF 맵 크기 최적화
bpf:
  mapValues:
    # 대용량 데이터 처리를 위한 큰 CT 테이블
    ct_max_entries: 1000000    # 100만 연결 지원
    # 대용량 패킷 처리를 위한 큰 NAT 테이블
    nat_max_entries: 1000000   # 100만 NAT 항목 지원

✅ 고성능 웹 서비스 최적화

고성능 웹 서비스 및 API 서버를 위한 Cilium 최적화:

# web-service-values.yaml

# 로드 밸런싱 최적화
loadBalancer:
  algorithm: "random"          # 웹 트래픽에 적합한 랜덤 알고리즘
  mode: "dsr"                  # DSR 모드로 응답 성능 향상
  acceleration: "native"       # XDP 가속 (지원 가능한 NIC)

# HTTP 처리 최적화
proxy:
  enabled: true                # L7 프록시 활성화
  sidecarIstioProxyImageName: "cilium/istio_proxy"  # Istio 통합 시

# DNS 캐싱 최적화
dnsProxy:
  enabled: true
  minTtl: 3600                 # DNS 캐싱 시간 증가 (1시간)

# 빠른 서비스 검색
k8sServiceHost: "kubernetes.default.svc"  # 쿠버네티스 API 서버 호스트
k8sServicePort: "443"                     # 쿠버네티스 API 서버 포트

웹 서비스를 위한 L7 정책 템플릿:

# web-service-l7-policy.yaml
apiVersion: "cilium.io/v2"
kind: CiliumNetworkPolicy
metadata:
  name: "web-service-api"      # 정책 이름
  namespace: web               # 웹 네임스페이스
spec:
  description: "Web API L7 정책"
  endpointSelector:
    matchLabels:
      app: web-api             # web-api 레이블이 있는 Pod 선택
  ingress:
  - fromEndpoints:
    - matchLabels: {}          # 모든 소스에서 허용
    toPorts:
    - ports:
      - port: "80"             # HTTP 포트
        protocol: TCP
      rules:
        http:
        # GET/POST 메서드만 허용
        - method: "GET"
          path: "/api/v1/.*"   # /api/v1/ 경로에 대한 GET 요청 허용
        - method: "POST"
          path: "/api/v1/.*"   # /api/v1/ 경로에 대한 POST 요청 허용
        # 공개 경로는 인증 없이 허용
        - method: "GET"
          path: "/public/.*"   # /public/ 경로에 대한 GET 요청 허용
        # 헬스체크 허용
        - method: "GET"
          path: "/health"      # /health 경로에 대한 GET 요청 허용
  egress:
  # 데이터베이스 접근 허용
  - toEndpoints:
    - matchLabels:
        app: database          # database 레이블이 있는 Pod로의 트래픽 허용
    toPorts:
    - ports:
      - port: "5432"           # PostgreSQL 포트 허용
        protocol: TCP

📌 Cilium의 한계점 및 주의사항

Cilium 사용 시 고려해야 할 한계점과 주의사항을 살펴보겠습니다.

✅ 알려진 한계점

커널 호환성

최신 eBPF 기능을 사용하기 위해서는 최소한의 커널 버전이 필요합니다:

# 커널 버전 확인
# 현재 호스트의 커널 버전 확인
uname -r

# 노드별 커널 버전 확인
# 클러스터 내 모든 노드의 커널 버전 확인
kubectl get nodes -o custom-columns=NAME:.metadata.name,KERNEL:.status.nodeInfo.kernelVersion

# 호환성 문제 발생 시 해결 방법
# 1. 커널 기능 감지 스크립트
cat > kernel-feature-detect.sh << 'EOF'
#!/bin/bash
# Cilium 요구사항에 따른 커널 기능 확인

# 커널 버전 확인
KERNEL_VERSION=$(uname -r)
echo "Kernel version: $KERNEL_VERSION"

# 최소 커널 요구사항 (Cilium 1.14 기준)
MIN_KERNEL_VERSION="4.19.0"

# 버전 비교 함수
function version_lt() {
  test "$(echo "$@" | tr " " "\n" | sort -V | head -n 1)" != "$1"
}

# 최소 버전 확인
if version_lt $KERNEL_VERSION $MIN_KERNEL_VERSION; then
  echo "Warning: Kernel version is less than minimum required version $MIN_KERNEL_VERSION"
fi

# BTF 지원 확인 (BPF Type Format)
if [ -f "/sys/kernel/btf/vmlinux" ]; then
  echo "BTF is supported"
else
  echo "Warning: BTF is not supported - some eBPF features may not work"
fi

# cgroup v2 지원 확인
if mount | grep -q "cgroup2"; then
  echo "cgroup v2 is mounted"
else
  echo "Warning: cgroup v2 is not mounted - some container features may not work optimally"
fi

# XDP 지원 확인
if [ -d "/sys/kernel/debug/tracing/events/xdp" ]; then
  echo "XDP is supported"
else
  echo "Warning: XDP may not be fully supported - acceleration features may not work"
fi

# BPF 프로그램 유형 확인
BPF_PROG_TYPES=$(ls -1 /sys/kernel/debug/bpf/prog_types 2>/dev/null || echo "")
if [ -n "$BPF_PROG_TYPES" ]; then
  echo "BPF program types available:"
  echo "$BPF_PROG_TYPES"

  # LWT (Lightweight Tunnel) 지원 확인
  if echo "$BPF_PROG_TYPES" | grep -q "lwt"; then
    echo "LWT is supported"
  else
    echo "Warning: LWT is not supported - direct routing mode may have limitations"
  fi
else
  echo "Warning: Cannot determine BPF program types - debug fs may not be mounted"
fi

# TCP 연결 추적 확인
if [ -d "/proc/sys/net/netfilter" ]; then
  echo "Netfilter connection tracking is available"
else
  echo "Warning: Netfilter connection tracking may not be available"
fi
EOF
chmod +x kernel-feature-detect.sh

# 모든 노드에서 실행
for node in $(kubectl get nodes -o jsonpath='{.items[*].metadata.name}'); do
  echo "Checking node: $node"
  # SSH 접속 또는 DaemonSet으로 실행
done

메모리 사용량

eBPF 맵은 상당한 메모리를 사용할 수 있으며, 대규모 클러스터에서는 메모리 사용량이 증가합니다:

# 메모리 최적화 설정 (대규모 클러스터에서도 메모리 사용량 제어)
bpf:
  # 모니터링 최소화
  monitorAggregation: "none"     # 모니터링 집계 비활성화

  # eBPF 맵 크기 최적화
  mapValues:
    # 클러스터 규모에 맞게 조정
    ct_max_entries: 131072       # 소규모 클러스터에서는 작게 시작 (약 128K 항목)
    ct_max_entries_udp: 65536    # UDP 연결 추적 항목 (약 64K 항목)

  # 최소한의 모니터링만 활성화
  monitorFlags: "drop"           # 드롭된 패킷만 모니터링

# Hubble 리소스 사용량 최소화
hubble:
  enabled: true
  metrics:
    enabled: []                   # 필요한 메트릭만 선택적으로 활성화
  relay:
    enabled: false                # 필요한 경우에만 활성화
  ui:
    enabled: false                # 필요한 경우에만 활성화

XDP 지원 제한사항

하드웨어 및 드라이버 호환성 문제로 XDP 가속이 제대로 작동하지 않을 수 있습니다:

# XDP 지원 확인
cat > xdp-check.sh << 'EOF'
#!/bin/bash
# 각 노드의 인터페이스에 대한 XDP 지원 확인

# 인터페이스 목록 가져오기
INTERFACES=$(ip -o link show | awk -F': ' '{print $2}' | grep -v "lo")

echo "Checking XDP support for interfaces:"
for iface in $INTERFACES; do
  echo -n "$iface: "

  # XDP 지원 여부 확인
  if ip link show dev $iface | grep -q "xdp"; then
    echo "XDP supported"

    # 드라이버 정보 확인
    DRIVER=$(ethtool -i $iface 2>/dev/null | grep "driver:" | awk '{print $2}')
    if [ -n "$DRIVER" ]; then
      echo "  Driver: $DRIVER"

      # 네이티브 XDP 지원 드라이버 확인
      case $DRIVER in
        i40e|ixgbe|ixgbevf|ice|nfp|thunder|mlx5_core|bnxt_en)
          echo "  Native XDP is supported"
          ;;
        *)
          echo "  Generic XDP only (slower performance)"
          ;;
      esac
    fi
  else
    echo "XDP not supported"
  fi
done
EOF
chmod +x xdp-check.sh

복잡한 네트워크 토폴로지 제한

특정 네트워크 설정에서 Cilium 사용 시 제한사항이 있을 수 있습니다:

# 네트워크 토폴로지 호환성 향상 설정
ipam:
  mode: "kubernetes"              # 호환성을 위한 IPAM 모드

# 터널 모드 활성화 (호환성 향상)
tunnel: "vxlan"                   # 대부분의 환경과 호환되는 VXLAN 모드

# BGP 통합 비활성화 (복잡한 네트워크 환경에서 문제 발생 가능)
externalIPs:
  enabled: false                 # 외부 IP 기능 비활성화

# 고급 라우팅 비활성화
autoDirectNodeRoutes: false      # 자동 노드 라우팅 비활성화

✅ 성능 대 기능 트레이드오프

Cilium의 다양한 기능을 활성화할 때 발생할 수 있는 성능 영향과 트레이드오프:

# 성능 우선 설정 (기능 최소화)
enableIPv4Masquerade: true       # IPv4 마스커레이딩 활성화
enableIPv6Masquerade: false      # IPv6 마스커레이딩 비활성화
enableIPv6: false                # IPv6 지원 비활성화
installIptablesRules: false      # iptables 규칙 설치 비활성화
kubeProxyReplacement: "strict"   # kube-proxy 완전 대체
tunnel: "disabled"               # 터널링 비활성화
autoDirectNodeRoutes: true       # 직접 노드 라우팅 활성화
bpf:
  hostRouting: true              # eBPF 호스트 라우팅 활성화
  monitorAggregation: "none"     # 모니터링 집계 비활성화
  preallocateMaps: true          # eBPF 맵 사전 할당
hubble:
  enabled: false                 # Hubble 비활성화
policyEnforcementMode: "never"   # 정책 강제 적용 비활성화
loadBalancer:
  acceleration: "native"         # 네이티브 가속 활성화
  mode: "dsr"                    # DSR 모드 활성화
enableCiliumEndpointSlice: false # CiliumEndpointSlice 비활성화
enableRuntimeDeviceDetection: false # 런타임 장치 감지 비활성화
enableXTSocketFallback: false    # XT 소켓 폴백 비활성화

# 기능 우선 설정 (성능 영향 있음)
enableIPv4Masquerade: true       # IPv4 마스커레이딩 활성화
enableIPv6Masquerade: true       # IPv6 마스커레이딩 활성화
enableIPv6: true                 # IPv6 지원 활성화
installIptablesRules: true       # iptables 규칙 설치 활성화
kubeProxyReplacement: "probe"    # 가능한 경우만 kube-proxy 대체
tunnel: "vxlan"                  # VXLAN 터널링 활성화
autoDirectNodeRoutes: false      # 직접 노드 라우팅 비활성화
bpf:
  hostRouting: false             # eBPF 호스트 라우팅 비활성화
  monitorAggregation: "maximum"  # 최대 모니터링 집계
  preallocateMaps: false         # eBPF 맵 동적 할당
hubble:
  enabled: true                  # Hubble 활성화
  metrics:
    enabled:                     # 모든 메트릭 활성화
      - dns
      - drop
      - tcp
      - flow
      - icmp
      - http
policyEnforcementMode: "default" # 정책 강제 적용 활성화
loadBalancer:
  acceleration: "disabled"       # 가속 비활성화
  mode: "snat"                   # SNAT 모드 사용
enableCiliumEndpointSlice: true  # CiliumEndpointSlice 활성화
enableRuntimeDeviceDetection: true # 런타임 장치 감지 활성화
enableXTSocketFallback: true     # XT 소켓 폴백 활성화

# 균형 잡힌 설정 (권장)
enableIPv4Masquerade: true       # IPv4 마스커레이딩 활성화
enableIPv6Masquerade: false      # IPv6 마스커레이딩 비활성화
enableIPv6: false                # IPv6 지원 비활성화
installIptablesRules: false      # iptables 규칙 설치 비활성화
kubeProxyReplacement: "probe"    # 가능한 경우만 kube-proxy 대체
tunnel: "vxlan"                  # VXLAN 터널링 사용
autoDirectNodeRoutes: false      # 직접 노드 라우팅 비활성화
bpf:
  hostRouting: true              # eBPF 호스트 라우팅 활성화
  monitorAggregation: "medium"   # 중간 수준 모니터링 집계
  preallocateMaps: true          # eBPF 맵 사전 할당
hubble:
  enabled: true                  # Hubble 활성화
  metrics:
    enabled:                     # 필수 메트릭만 활성화
      - drop
      - tcp
policyEnforcementMode: "default" # 정책 강제 적용 활성화
loadBalancer:
  acceleration: "disabled"       # 기본 가속 비활성화
  mode: "snat"                   # SNAT 모드 사용
enableCiliumEndpointSlice: true  # CiliumEndpointSlice 활성화
enableRuntimeDeviceDetection: false # 런타임 장치 감지 비활성화
enableXTSocketFallback: true     # XT 소켓 폴백 활성화

✅ 업그레이드 위험 및 완화 전략

Cilium 업그레이드 시 주의해야 할 위험과 그 완화 전략:

# 업그레이드 전 호환성 확인 스크립트
cat > upgrade-compatibility-check.sh << 'EOF'
#!/bin/bash
# Cilium 업그레이드 전 호환성 확인 스크립트

# 현재 버전 확인
CURRENT_VERSION=$(helm get values cilium -n kube-system -o json | jq -r .image.tag)
TARGET_VERSION="1.14.2"  # 업그레이드 대상 버전

echo "Current Cilium version: $CURRENT_VERSION"
echo "Target Cilium version: $TARGET_VERSION"

# 1. 커널 버전 호환성 확인
echo "Checking kernel versions..."
kubectl get nodes -o custom-columns=NAME:.metadata.name,KERNEL:.status.nodeInfo.kernelVersion

# 2. 현재 설정 백업
echo "Backing up current configuration..."
helm get values cilium -n kube-system > cilium-values-backup-$(date +%Y%m%d).yaml

# 3. 네트워크 정책 백업
echo "Backing up network policies..."
kubectl get ciliumnetworkpolicies --all-namespaces -o yaml > cilium-network-policies-$(date +%Y%m%d).yaml
kubectl get ciliumclusterwidenetworkpolicies -o yaml > cilium-clusterwide-policies-$(date +%Y%m%d).yaml

# 4. 연결성 사전 테스트
echo "Running pre-upgrade connectivity tests..."
if command -v cilium &> /dev/null; then
  cilium connectivity test
else
  echo "Cilium CLI not found, skipping connectivity test"
fi

# 5. 사용자 정의 리소스 호환성 확인
echo "Checking CRD compatibility..."
kubectl get customresourcedefinitions | grep cilium

# 6. 주요 기능 변경 확인 (수동 검토 필요)
echo "Please review the Cilium upgrade guide for version $TARGET_VERSION for any breaking changes or deprecations."

# 7. 결론
echo -e "\nPre-upgrade compatibility check completed."
echo "Please review any warnings above before proceeding with the upgrade."
EOF
chmod +x upgrade-compatibility-check.sh

# 안전한 업그레이드를 위한 Helm values 설정
# upgrade-safety-values.yaml

# 이전 버전과의 호환성 유지
upgradeCompatibility: "1.13"    # 이전 버전 지정

# 점진적 롤아웃 설정
rollOutCiliumPods: true         # Pod 순차적 롤아웃

# 업데이트 전략
updateStrategy:
  type: "RollingUpdate"         # 롤링 업데이트 사용
  rollingUpdate:
    maxUnavailable: 2           # 한 번에 최대 2개 노드만 업데이트

# PodDisruptionBudget 설정
podDisruptionBudget:
  enabled: true
  maxUnavailable: 1             # 최대 1개 Pod만 동시에 중단 가능

# 롤백 준비
operator:
  rollOutPods: true             # 오퍼레이터 순차적 롤아웃
  skipCRDCreation: false        # CRD 생성 확인

# 임시 호환성 모드 활성화
cni:
  chainingMode: "none"          # CNI 체이닝 없음
  exclusive: true               # 독점 모드

업그레이드 롤백 계획:

# 롤백 스크립트
cat > cilium-rollback.sh << 'EOF'
#!/bin/bash
# Cilium 긴급 롤백 스크립트

PREVIOUS_VERSION="1.13.4"          # 롤백할 이전 버전
BACKUP_VALUES="cilium-values-backup-20230601.yaml"  # 백업 파일명 조정

# 1. 현재 상태 확인
echo "Checking current Cilium status..."
cilium status
kubectl get pods -n kube-system -l k8s-app=cilium

# 2. Helm 롤백 수행
echo "Rolling back Cilium to version $PREVIOUS_VERSION..."
helm rollback cilium 1 -n kube-system

# 또는 백업된 값으로 재설치
# helm upgrade cilium cilium/cilium \
#   --version $PREVIOUS_VERSION \
#   --namespace kube-system \
#   -f $BACKUP_VALUES

# 3. 롤백 모니터링
echo "Monitoring rollback progress..."
kubectl rollout status daemonset/cilium -n kube-system

# 4. 네트워크 정책 재적용 (필요시)
echo "Reapplying network policies..."
kubectl apply -f cilium-network-policies-20230601.yaml
kubectl apply -f cilium-clusterwide-policies-20230601.yaml

# 5. 연결성 테스트
echo "Testing connectivity after rollback..."
if command -v cilium &> /dev/null; then
  cilium connectivity test
else
  echo "Cilium CLI not found, skipping connectivity test"
fi

echo "Rollback completed. Please verify cluster connectivity."
EOF
chmod +x cilium-rollback.sh

✅ 실제 운영 환경에서의 리스크 완화 전략

Cilium을 프로덕션 환경에서 안정적으로 운영하기 위한 리스크 완화 전략:

# 1. 모니터링 강화 - 핵심 지표 대시보드 설정

# Cilium 모니터링을 위한 Grafana 대시보드 구성 (기본 설정)
cat > cilium-monitoring-setup.sh << 'EOF'
#!/bin/bash
# Cilium 모니터링 설정 스크립트

# 필요한 경우 Prometheus Operator 설치
if ! kubectl get crd prometheuses.monitoring.coreos.com &>/dev/null; then
  echo "Installing Prometheus Operator..."
  helm repo add prometheus-community https://prometheus-community.github.io/helm-charts
  helm repo update
  helm install prometheus prometheus-community/kube-prometheus-stack \
    --namespace monitoring --create-namespace
fi

# Cilium ServiceMonitor 생성
cat </dev/null; then
  echo "Importing Cilium dashboards to Grafana..."

  # Cilium 공식 대시보드 ID
  DASHBOARD_IDS=(
    "13537"  # Cilium Agent
    "13538"  # Cilium Operator
    "13539"  # Cilium Endpoints
    "13540"  # Cilium Network
    "13596"  # Cilium Hubble
  )

  # 각 대시보드 가져오기
  for id in "${DASHBOARD_IDS[@]}"; do
    curl -s https://grafana.com/api/dashboards/$id/revisions/latest/download > /tmp/dashboard-$id.json

    # ConfigMap으로 등록
    kubectl create configmap -n monitoring grafana-dashboard-cilium-$id \
      --from-file=cilium-$id.json=/tmp/dashboard-$id.json \
      --dry-run=client -o yaml | kubectl apply -f -

    # 레이블 추가
    kubectl label configmap -n monitoring grafana-dashboard-cilium-$id \
      grafana_dashboard="1"
  done
fi

echo "Cilium monitoring setup completed."
EOF
chmod +x cilium-monitoring-setup.sh

# 2. 장애 탐지 및 자동 복구 설정

# Cilium 에이전트 상태 모니터링 및 자동 복구 스크립트
cat > cilium-health-check.sh << 'EOF'
#!/bin/bash
# Cilium 상태 점검 및 자동 복구 스크립트

# 로그 함수
log() {
  echo "[$(date '+%Y-%m-%d %H:%M:%S')] $1"
}

# 모든 Cilium Pod 확인
CILIUM_PODS=$(kubectl get pods -n kube-system -l k8s-app=cilium -o jsonpath='{.items[*].metadata.name}')

for pod in $CILIUM_PODS; do
  log "Checking Cilium pod: $pod"

  # 노드 이름 가져오기
  NODE=$(kubectl get pod -n kube-system $pod -o jsonpath='{.spec.nodeName}')

  # Cilium 상태 확인
  STATUS=$(kubectl exec -n kube-system $pod -- cilium status --brief 2>/dev/null)
  if [ $? -ne 0 ]; then
    log "Error: Failed to get Cilium status for pod $pod on node $NODE"
    NEEDS_RESTART=true
  elif [[ $STATUS == *"KVStore:           Ok"* ]] && [[ $STATUS == *"Kubernetes:        Ok"* ]]; then
    log "Cilium status OK for pod $pod on node $NODE"
    NEEDS_RESTART=false
  else
    log "Warning: Cilium pod $pod on node $NODE has issues"
    NEEDS_RESTART=true
  fi

  # 필요한 경우 Pod 재시작
  if [ "$NEEDS_RESTART" = true ]; then
    log "Attempting to restart Cilium pod $pod on node $NODE"

    # 먼저 엔드포인트 상태 백업
    ENDPOINTS=$(kubectl exec -n kube-system $pod -- cilium endpoint list -o json 2>/dev/null)
    echo "$ENDPOINTS" > "/tmp/cilium-endpoints-$pod-$(date +%s).json"

    # Pod 재시작
    kubectl delete pod -n kube-system $pod
    log "Waiting for new Cilium pod on node $NODE..."

    # 새 Pod가 Ready 상태가 될 때까지 대기
    for i in {1..30}; do
      NEW_POD=$(kubectl get pods -n kube-system -l k8s-app=cilium -o jsonpath='{.items[?(@.spec.nodeName=="'$NODE'")].metadata.name}')
      if [ -z "$NEW_POD" ]; then
        sleep 2
        continue
      fi

      READY=$(kubectl get pod -n kube-system $NEW_POD -o jsonpath='{.status.containerStatuses[0].ready}')
      if [ "$READY" == "true" ]; then
        log "New Cilium pod $NEW_POD is ready on node $NODE"
        break
      fi

      sleep 2
    done
  fi
done

# 클러스터 연결성 확인
log "Running basic connectivity checks..."
SAMPLE_POD=$(kubectl get pods --all-namespaces -o jsonpath='{.items[0].metadata.name}' 2>/dev/null)
SAMPLE_NS=$(kubectl get pods --all-namespaces -o jsonpath='{.items[0].metadata.namespace}' 2>/dev/null)

if [ -n "$SAMPLE_POD" ] && [ -n "$SAMPLE_NS" ]; then
  log "Testing DNS resolution from pod $SAMPLE_NS/$SAMPLE_POD..."
  kubectl exec -n $SAMPLE_NS $SAMPLE_POD -- nslookup kubernetes.default 2>/dev/null
  if [ $? -eq 0 ]; then
    log "DNS resolution working properly"
  else
    log "Warning: DNS resolution failed"
  fi
else
  log "No sample pod found for connectivity testing"
fi

log "Health check completed."
EOF
chmod +x cilium-health-check.sh

# 정기 실행을 위한 CronJob 생성
cat << EOF | kubectl apply -f -
apiVersion: batch/v1
kind: CronJob
metadata:
  name: cilium-health-check
  namespace: kube-system
spec:
  schedule: "*/30 * * * *"  # 30분마다 실행
  concurrencyPolicy: Forbid
  jobTemplate:
    spec:
      template:
        spec:
          serviceAccountName: cilium-health-sa  # 적절한 권한 필요
          containers:
          - name: cilium-health-check
            image: bitnami/kubectl:latest
            command:
            - /bin/bash
            - -c
            - |
              curl -s -o /tmp/cilium-health-check.sh https://raw.githubusercontent.com/your-repo/cilium-health-check.sh
              chmod +x /tmp/cilium-health-check.sh
              /tmp/cilium-health-check.sh
          restartPolicy: OnFailure
EOF

# 3. 백업 및 복구 전략

# 중요 Cilium 구성 백업 스크립트
cat > cilium-backup.sh << 'EOF'
#!/bin/bash
# Cilium 구성 백업 스크립트

BACKUP_DIR="cilium-backup-$(date +%Y%m%d-%H%M)"
mkdir -p $BACKUP_DIR

# 1. Helm 구성 백업
echo "Backing up Helm configuration..."
helm get values cilium -n kube-system -o yaml > $BACKUP_DIR/cilium-helm-values.yaml

# 2. Cilium CRD 및 CR 백업
echo "Backing up Cilium CRDs and CRs..."

# CRD 백업
kubectl get crd -o yaml | grep -i cilium > $BACKUP_DIR/cilium-crds.yaml

# 네트워크 정책 백업
kubectl get ciliumnetworkpolicies --all-namespaces -o yaml > $BACKUP_DIR/cilium-network-policies.yaml
kubectl get ciliumclusterwidenetworkpolicies -o yaml > $BACKUP_DIR/cilium-clusterwide-policies.yaml

# 엔드포인트 백업
kubectl get ciliumendpoints --all-namespaces -o yaml > $BACKUP_DIR/cilium-endpoints.yaml

# 기타 Cilium 리소스 백업
kubectl get ciliumidentities -o yaml > $BACKUP_DIR/cilium-identities.yaml
kubectl get ciliumnodes -o yaml > $BACKUP_DIR/cilium-nodes.yaml

if kubectl get crd ciliumexternalworkloads.cilium.io &>/dev/null; then
  kubectl get ciliumexternalworkloads -o yaml > $BACKUP_DIR/cilium-external-workloads.yaml
fi

if kubectl get crd ciliumloadbalancerippools.cilium.io &>/dev/null; then
  kubectl get ciliumloadbalancerippools -o yaml > $BACKUP_DIR/cilium-lb-ip-pools.yaml
fi

if kubectl get crd ciliumbgppeeringpolicies.cilium.io &>/dev/null; then
  kubectl get ciliumbgppeeringpolicies -o yaml > $BACKUP_DIR/cilium-bgp-peering-policies.yaml
fi

# 3. Cilium 에이전트 설정 백업
echo "Backing up Cilium agent configuration..."
SAMPLE_CILIUM_POD=$(kubectl get pods -n kube-system -l k8s-app=cilium -o jsonpath='{.items[0].metadata.name}')
if [ -n "$SAMPLE_CILIUM_POD" ]; then
  kubectl exec -n kube-system $SAMPLE_CILIUM_POD -- cilium config > $BACKUP_DIR/cilium-agent-config.txt
  kubectl exec -n kube-system $SAMPLE_CILIUM_POD -- cilium status --verbose > $BACKUP_DIR/cilium-agent-status.txt
fi

# 4. 상태 스냅샷
echo "Taking status snapshot..."
kubectl get pods -n kube-system -o wide > $BACKUP_DIR/kube-system-pods.txt
kubectl get nodes -o wide > $BACKUP_DIR/nodes.txt

# 5. 백업 압축
tar -czf $BACKUP_DIR.tar.gz $BACKUP_DIR
rm -rf $BACKUP_DIR

echo "Backup completed: $BACKUP_DIR.tar.gz"
EOF
chmod +x cilium-backup.sh

프로덕션 환경에서의 실패 모드 대응 계획:

Cilium 장애 대응 매뉴얼

일반적인 장애 유형 및 대응 방법

1. Cilium 에이전트 충돌 또는 재시작 루프

**증상:**
- Cilium Pod가 계속 재시작됨
- 로그에 패닉 또는 지속적인 오류가 표시됨

**대응:**

로그 확인: `kubectl logs -n kube-system --previous`
문제 노드 식별: `kubectl get pods -n kube-system -l k8s-app=cilium -o wide`
조치:
- 특정 노드만 문제가 있는 경우: 해당 노드의 Cilium Pod만 재시작

NODE="problem-node-name" kubectl delete pod -n kube-system $(kubectl get pods -n kube-system -l k8s-app=cilium -o jsonpath='{.items\[?(@.spec.nodeName=="'$NODE'")\].metadata.name}')

전체적인 문제인 경우: Cilium 설정 확인 및 조정 후 전체 재시작

helm upgrade cilium cilium/cilium --namespace kube-system -f adjusted-values.yaml

2. IP 할당 실패 (IPAM 문제)

증상:

Pod가 ContainerCreating 상태에서 멈춤
Pod 이벤트에 "no addresses available" 오류

대응:

IPAM 상태 확인:

kubectl exec -n kube-system <cilium-pod> -- cilium status --verbose | grep -A 10 IPAM

오퍼레이터 로그 확인:

kubectl logs -n kube-system -l k8s-app=cilium-operator | grep -i ipam

조치:

IP 풀 재구성:

helm upgrade cilium cilium/cilium --namespace kube-system --reuse-values  
\--set ipam.operator.clusterPoolIPv4PodCIDRList={"10.0.0.0/8"}  
\--set ipam.operator.clusterPoolIPv4MaskSize=24

3. DNS 해결 실패

증상:

Pod가 DNS 쿼리 실패 보고
서비스 이름으로 연결 불가

대응:

DNS 프록시 상태 확인:

kubectl exec -n kube-system <cilium-pod> -- cilium status | grep DNS

DNS 트래픽 모니터링:

kubectl exec -n kube-system <cilium-pod> -- hubble observe --protocol dns

조치:

DNS 프록시 재구성:

helm upgrade cilium cilium/cilium --namespace kube-system --reuse-values  
\--set dnsProxy.enabled=true  
\--set dnsProxy.dnsRejectResponseCode=refused

CoreDNS 재시작:

kubectl delete pod -n kube-system -l k8s-app=kube-dns

4. 정책 강제 적용 문제

증상:

네트워크 정책이 적용되지 않음
예상치 않게 트래픽이 차단되거나 허용됨

대응:

정책 상태 확인:

kubectl exec -n kube-system <cilium-pod> -- cilium policy get

엔드포인트 상태 확인:

kubectl exec -n kube-system <cilium-pod> -- cilium endpoint list

문제 식별을 위한 트래픽 관찰:

hubble observe --verdict DROPPED --pod-to <destination-pod>

조치:

강제 정책 재생성:

kubectl exec -n kube-system <cilium-pod> -- cilium policy import -r /var/lib/cilium/policy.json

정책 모드 재설정:

helm upgrade cilium cilium/cilium --namespace kube-system --reuse-values  
\--set policyEnforcementMode=default

5. 심각한 장애 상황에서의 긴급 복구

상황: Cilium이 완전히 작동 불능 상태가 됨

긴급 대응:

Cilium을 kube-proxy 모드로 전환:

helm upgrade cilium cilium/cilium --namespace kube-system --reuse-values  
\--set kubeProxyReplacement=disabled  
\--set tunnel=vxlan  
\--set installIptablesRules=true  
\--set policyEnforcementMode=never

그래도 해결되지 않는 경우, 임시로 Cilium 비활성화:

# 노드에서 실행 (DaemonSet으로 실행해야 함)

mv /etc/cni/net.d/05-cilium.conf /etc/cni/net.d/05-cilium.conf.bak systemctl restart kubelet

최후의 수단: 임시 대체 CNI 설치:

 kubectl delete -f [https://raw.githubusercontent.com/cilium/cilium/v1.14.2/install/kubernetes/quick-install.yaml](https://raw.githubusercontent.com/cilium/cilium/v1.14.2/install/kubernetes/quick-install.yaml) kubectl apply -f [https://raw.githubusercontent.com/flannel-io/flannel/master/Documentation/kube-flannel.yml](https://raw.githubusercontent.com/flannel-io/flannel/master/Documentation/kube-flannel.yml)

모니터링 및 예방 조치

1. 주요 모니터링 지표

리소스 사용량:
cilium_process_resident_memory_bytes: 메모리 사용량
cilium_process_cpu_seconds_total: CPU 사용량
eBPF 맵 상태:
cilium_bpf_map_ops_total: eBPF 맵 작업 수
cilium_bpf_map_pressure: eBPF 맵 압력
엔드포인트 상태:
cilium_endpoint_count: 엔드포인트 수
cilium_endpoint_regeneration_time_stats_seconds: 엔드포인트 재생성 시간
정책 상태:
cilium_policy_count: 정책 수
cilium_policy_regeneration_time_stats_seconds: 정책 재생성 시간

2. 주요 알림 설정

높은 메모리 사용량:

process\_resident\_memory\_bytes{job="cilium-agent"} / (1024 \* 1024 \* 1024) > 2

비정상적인 패킷 드롭:

rate(cilium\_drop\_count\_total\[5m\]) > 100

엔드포인트 재생성 실패:

rate(cilium\_endpoint\_regeneration\_total{outcome="failure"}\[5m\]) > 5

eBPF 맵 압력:

cilium\_bpf\_map\_pressure > 0.8

3. 주기적 점검 사항

주간: eBPF 맵 사용량 검토
격주: 정책 및 엔드포인트 상태 검토
월간: 전체 Cilium 구성 검토 및 최적화
분기: 대규모 로드 테스트 및 성능 벤치마크

통신 및 에스컬레이션 절차

이슈 감지 및 초기 대응 (L1)
내부 에스컬레이션 (L2)
벤더/커뮤니티 지원 요청 (L3)
포스트모템 분석 및 재발 방지 대책 수립

📌 Summary

이 글에서는 Cilium의 성능 최적화 방법과 운영 환경에서의 한계점 및 주의사항에 대해 살펴보았습니다. 주요 내용을 요약하면 다음과 같습니다:

성능 진단 및 측정: 다양한 네트워크 성능 테스트 도구를 활용해 Cilium의 현재 성능을 정확히 측정하고 병목 현상을 식별하는 방법을 살펴보았습니다. iperf3, netperf 등의 도구와 Cilium 자체 진단 명령어를 통해 포괄적인 성능 프로파일을 만들 수 있습니다.
eBPF 튜닝 포인트: Cilium의 핵심인 eBPF 프로그램의 성능을 최적화하기 위한 다양한 설정을 살펴보았습니다. 커널 파라미터 최적화, eBPF 맵 튜닝, 데이터 경로 최적화, 모니터링 오버헤드 감소 등 다양한 측면에서 성능을 향상시킬 수 있는 방법을 제시했습니다.
리소스 관리 및 스케일링: 클러스터 규모에 따른 리소스 할당 전략, 대규모 클러스터에서의 확장성 팁, 컴포넌트별 스케일링 방법, 그리고 리소스 사용량 모니터링 및 알림 설정 방법을 살펴보았습니다.
워크로드별 최적화 전략: 마이크로서비스, 대용량 데이터 처리, 고성능 웹 서비스 등 다양한 워크로드 유형에 따른 Cilium 최적화 전략을 제시했습니다. 각 워크로드의 특성에 맞게 Cilium 설정을 조정하여 최적의 성능을 얻을 수 있습니다.
Cilium의 한계점 및 주의사항: 커널 호환성, 메모리 사용량, XDP 지원 제한, 복잡한 네트워크 토폴로지에서의 제한사항 등 Cilium의 알려진 한계점을 살펴보았습니다. 또한 성능과 기능 간의 트레이드오프, 업그레이드 위험 및 완화 전략, 그리고 실제 운영 환경에서의 리스크 완화 방법에 대해 논의했습니다.

Cilium은 뛰어난 성능과 다양한 기능을 제공하지만, 최적의 성능과 안정성을 확보하려면 세심한 튜닝과 운영 전략이 필요합니다. 이 글에서 제시한 다양한 최적화 기법과 운영 팁을 활용하여 Cilium의 잠재력을 최대한 발휘하면서도 안정적으로 운영할 수 있기를 바랍니다.

728x90

저작자표시 비영리 변경금지

'Kubernetes Tools > Cilium' 카테고리의 다른 글

EP14. Cilium 운영 환경 구성 전략 \| 롤아웃, 업데이트, 장애 복구 (0)	2025.03.23
EP13. Hubble CLI & UI 고급 사용법 \| 네트워크 분석 실무 활용 (0)	2025.03.23
EP12. ID 기반 정책과 보안 강화 \| Identity 기반 접근 제어 이해 (0)	2025.03.23
EP11. CiliumClusterwideNetworkPolicy 실습 \| 클러스터 전체 범위 제어 (0)	2025.03.23
EP10. CIDR, Entity 기반 정책 구성 \| 외부 접근 정밀 제어 (0)	2025.03.22

현재글EP15. Cilium 성능 최적화와 한계점 | 실무 팁과 리스크 관리

YG Tech Blog

A blog about IT, covering topics from cloud computing and DevOps to Kubernetes and system architecture. Sharing insights, solutions, and best practices for modern IT professionals

k8s, langchain, Security, DevOps, Cilium, Minio, Istio, DaemonSet, 서비스메시, kubernetes, statefulset, 쿠버네티스, gitops, CI/CD, YAML, RAG, 서비스_운영, Python, 파이썬, argocd,

Today :
Yesterday :

« 2025/05 »
일	월	화	수	목	금	토
				1	2	3
4	5	6	7	8	9	10
11	12	13	14	15	16	17
18	19	20	21	22	23	24
25	26	27	28	29	30	31

EP15. Cilium 성능 최적화와 한계점 | 실무 팁과 리스크 관리

📌 Cilium 성능 진단 및 측정

✅ 성능 테스트 도구 소개

✅ 주요 성능 지표 수집 및 분석

✅ 성능 테스트 자동화 스크립트

📌 eBPF 튜닝 포인트

✅ 커널 파라미터 최적화

✅ eBPF 맵 튜닝

✅ 데이터 경로 최적화

✅ 모니터링 오버헤드 최적화

📌 리소스 관리 및 스케일링

✅ 노드 규모별 리소스 할당 전략

✅ 대규모 클러스터 확장성 팁

✅ Cilium 컴포넌트 스케일링 전략

✅ 리소스 사용량 모니터링 및 알림 설정

📌 특정 워크로드별 최적화 전략

✅ 마이크로서비스 트래픽 최적화

✅ 대용량 데이터 처리 워크로드 최적화

✅ 고성능 웹 서비스 최적화

📌 Cilium의 한계점 및 주의사항

✅ 알려진 한계점

✅ 성능 대 기능 트레이드오프

✅ 업그레이드 위험 및 완화 전략

✅ 실제 운영 환경에서의 리스크 완화 전략

Cilium 장애 대응 매뉴얼

일반적인 장애 유형 및 대응 방법

1. Cilium 에이전트 충돌 또는 재시작 루프

2. IP 할당 실패 (IPAM 문제)

3. DNS 해결 실패

4. 정책 강제 적용 문제

5. 심각한 장애 상황에서의 긴급 복구

모니터링 및 예방 조치

1. 주요 모니터링 지표

2. 주요 알림 설정

3. 주기적 점검 사항

통신 및 에스컬레이션 절차

📌 Summary

'Kubernetes Tools > Cilium' 카테고리의 다른 글

'Kubernetes Tools/Cilium'의 다른글

관련글

티스토리툴바