eBPF와 OpenTelemetry로 진화하는 관찰가능성(Observability) 2026

2014년: Linux 3.18에 eBPF 기본 기능 도입
2017년: eBPF 기능 대폭 확장 (네트워크, 보안)
2020년: eBPF 실무 활용 시작 (관찰가능성, 보안)
2023년: eBPF 표준화 주도 (CNCF, Linux Foundation)
2026년: eBPF 기반 관찰가능성 표준 기술 (역할)

// 모든 네트워크 연결의 출발지/목적지 IP 기록
#include <uapi/linux/ptrace.h>
#include <net/sock.h>
#include <bcc/proto.h>

BPF_HASH(ipv4_connections, u32, u32);

int trace_connect_entry(struct pt_regs *ctx, struct sock *sk) {
    if (sk->__sk_common.skc_family != AF_INET)
        return 0;

    u32 sip = sk->__sk_common.skc_rcv_saddr;
    u32 dip = sk->__sk_common.skc_daddr;

    // 연결된 IP 쌍 기록
    u32 cnt = ipv4_connections.lookup_or_init(&sip, &0);
    ipv4_connections.update(&sip, &cnt + 1);

    return 0;
}

from bcc import BPF

# eBPF 프로그램 로드
b = BPF(text=ebpf_code)
b.attach_kprobe(event="tcp_v4_connect", fn_name="trace_connect_entry")

print("추적 중... (Ctrl+C로 중단)")
try:
    while True:
        time.sleep(1)
except KeyboardInterrupt:
    pass

# 결과 출력
ipv4_connections = b["ipv4_connections"]
for k, v in ipv4_connections.items():
    print(f"소스 IP: {socket.inet_ntoa(struct.pack('I', k.value))}, "
          f"연결 수: {v.value}")

1. 네트워크 정책:
  - L3/L4 기반 정책 (전통적)
  - L7 기반 정책 (HTTP, gRPC, Kafka 등)
  - 정책 적용 성능: zero-overhead

2. 관찰가능성:
  - 모든 네트워크 플로우 자동 추적
  - 계측 코드 불필요
  - 성능 오버헤드: <1%

3. 보안:
  - 마이크로세그멘테이션
  - 실시간 위협 탐지
  - DDoS 방어

4. 성능:
  - Kube-proxy 제거 시 30% 네트워크 성능 향상
  - 메모리 사용 50% 감소

# Cilium 설치
helm repo add cilium https://helm.cilium.io
helm install cilium cilium/cilium --namespace kube-system

# Cilium 상태 확인
kubectl get pods -n kube-system | grep cilium

apiVersion: cilium.io/v2
kind: CiliumNetworkPolicy
metadata:
  name: api-to-db
spec:
  description: 'API Pod만 Database에 접근 가능'
  endpointSelector:
    matchLabels:
      app: database
  ingress:
    - fromEndpoints:
        - matchLabels:
            app: api-server
      toPorts:
        - ports:
            - port: '5432'
              protocol: TCP

---
apiVersion: cilium.io/v2
kind: CiliumNetworkPolicy
metadata:
  name: http-api-policy
spec:
  description: 'HTTP API 트래픽 정책 (L7)'
  endpointSelector:
    matchLabels:
      app: api-server
  ingress:
    - fromEndpoints:
        - matchLabels:
            app: frontend
      toPorts:
        - ports:
            - port: '8080'
              protocol: TCP
          rules:
            http:
              - method: 'GET'
                path: '/api/v1/.*'
              - method: 'POST'
                path: '/api/v1/users'

애플리케이션 계층:
├─ Traces (분산 추적)
├─ Metrics (메트릭)
└─ Logs (로그)
       ↓
OpenTelemetry SDKs
       ↓
OpenTelemetry Collector
       ↓
백엔드 (Datadog, New Relic, Jaeger, Prometheus 등)

# pip install opentelemetry-api opentelemetry-sdk
# pip install opentelemetry-exporter-jaeger
# pip install opentelemetry-instrumentation-flask
# pip install opentelemetry-instrumentation-requests

from opentelemetry import trace, metrics
from opentelemetry.sdk.trace import TracerProvider
from opentelemetry.sdk.trace.export import BatchSpanProcessor
from opentelemetry.exporter.jaeger.thrift import JaegerExporter
from opentelemetry.instrumentation.flask import FlaskInstrumentor
from opentelemetry.instrumentation.requests import RequestsInstrumentor
from opentelemetry.sdk.resources import SERVICE_NAME, Resource
from flask import Flask

# Jaeger 수출기 설정
jaeger_exporter = JaegerExporter(
    agent_host_name="localhost",
    agent_port=6831,
)

# Tracer Provider 설정
trace.set_tracer_provider(
    TracerProvider(
        resource=Resource.create({SERVICE_NAME: "my-payment-service"})
    )
)
trace.get_tracer_provider().add_span_processor(
    BatchSpanProcessor(jaeger_exporter)
)

# Flask 앱 자동 계측 (코드 수정 없음!)
app = Flask(__name__)
FlaskInstrumentor().instrument_app(app)
RequestsInstrumentor().instrument()

@app.route("/api/v1/payments", methods=["POST"])
def create_payment():
    tracer = trace.get_tracer(__name__)

    with tracer.start_as_current_span("create_payment") as span:
        # 비즈니스 로직
        payment_id = process_payment()

        # span에 속성 추가
        span.set_attribute("payment.id", payment_id)
        span.set_attribute("payment.amount", 100.00)

        return {"payment_id": payment_id}

if __name__ == "__main__":
    app.run(port=5000)

{
  "traceID": "8b37a91d27d4a3f5",
  "spans": [
    {
      "spanID": "8b37a91d27d4a3f5",
      "operationName": "POST /api/v1/payments",
      "startTime": 1710700000000,
      "duration": 150000,
      "tags": {
        "span.kind": "server",
        "http.method": "POST",
        "http.url": "/api/v1/payments",
        "http.status_code": 200
      },
      "logs": [
        {
          "timestamp": 1710700000050,
          "message": "결제 처리 시작"
        }
      ]
    },
    {
      "spanID": "c2b5d8e9f1g6h2a1",
      "operationName": "query_database",
      "parentSpanID": "8b37a91d27d4a3f5",
      "duration": 45000,
      "tags": {
        "db.type": "postgresql",
        "db.operation": "SELECT"
      }
    }
  ]
}

# Tetragon 설치
helm repo add cilium https://helm.cilium.io
helm install tetragon cilium/tetragon -n kube-system

# Tetragon 트레이싱 규칙 정의
kubectl apply -f - <<'EOF'
apiVersion: cilium.io/v1alpha1
kind: TracingPolicy
metadata:
  name: "network-security"
spec:
  rules:
  # 모든 네트워크 연결 추적
  - call: "trace_tcp_connect_entry"
    syscall: "connect"
    args:
    - index: 0
      type: "sock_addr"

  # 모든 파일 접근 추적
  - call: "trace_open_entry"
    syscall: "openat"
    args:
    - index: 0
      type: "int"
    - index: 1
      type: "const_char_buf"
      sizeArg: 255

  # 모든 프로세스 실행 추적
  - call: "trace_execve"
    syscall: "execve"
    args:
    - index: 0
      type: "const_char_buf"
      sizeArg: 255
EOF

# 실시간 로그 확인
kubectl logs -f -n kube-system -l app.kubernetes.io/name=tetragon

{
  "processExec": {
    "process": {
      "execId": "NzMxOjUwODU5OjE2OTk5OTk5OTk=",
      "pid": 50859,
      "uid": 0,
      "cwd": "/",
      "binary": "/bin/bash",
      "arguments": "-c",
      "startTime": "2026-03-16T10:00:00.000000000Z"
    },
    "parent": {
      "execId": "NzMxOjUwNzk0OjE2OTk5OTk5OTk=",
      "pid": 50794
    }
  }
}

# Hubble UI 설치
helm upgrade cilium cilium/cilium --reuse-values --set hubble.ui.enabled=true

# Hubble 접근
kubectl port-forward -n kube-system svc/hubble-ui 12000:80

# 브라우저에서 localhost:12000 접속

# OpenTelemetry + AI 기반 RCA 시스템
class AutomatedRootCauseAnalyzer:
    """
    메트릭, 트레이스, 로그를 분석하여
    자동으로 근본원인을 찾는 시스템
    """

    def analyze_incident(self, incident_id):
        """
        1단계: 증상 수집
        """
        # 메트릭에서 이상 탐지
        anomalies = self.detect_anomalies_in_metrics(
            metrics=['latency', 'error_rate', 'cpu_usage'],
            duration='last_5_minutes'
        )

        # 로그에서 에러 패턴 찾기
        error_patterns = self.find_error_patterns_in_logs(
            filters={'service': 'payment-service', 'severity': 'ERROR'}
        )

        # 분산 트레이스에서 느린 구간 식별
        slow_spans = self.find_slow_spans_in_traces(
            min_duration_ms=500
        )

        """
        2단계: 상관 관계 분석
        """
        correlations = self.find_correlations({
            'anomalies': anomalies,
            'error_patterns': error_patterns,
            'slow_spans': slow_spans
        })

        """
        3단계: AI 기반 근본원인 추론
        """
        # LLM을 사용한 근본원인 추론
        root_cause = self.llm_infer_root_cause({
            'correlations': correlations,
            'historical_incidents': self.get_similar_past_incidents(incident_id),
            'system_topology': self.get_system_topology()
        })

        return {
            'incident_id': incident_id,
            'root_cause': root_cause,
            'affected_services': self.get_affected_services(root_cause),
            'recommended_actions': self.get_remediation_actions(root_cause),
            'confidence_score': root_cause['confidence']
        }

    def example_analysis_result(self):
        """
        실제 분석 결과 예시:
        """
        return {
            'incident_id': 'INC-2026-03-16-001',
            'root_cause': {
                'type': 'database_connection_pool_exhaustion',
                'description': '결제 서비스의 DB 연결 풀 고갈',
                'confidence': 0.94,
                'evidence': [
                    'DB 연결 에러 증가 (100건/분)',
                    '결제 API 지연시간 500ms 증가',
                    'DB 로그에서 "too many connections" 에러',
                    '메모리 사용량 85% 이상'
                ]
            },
            'affected_services': [
                'payment-service',
                'order-service'
            ],
            'recommended_actions': [
                {
                    'action': '결제 서비스의 DB 연결 풀 크기 증가',
                    'estimated_recovery_time': '2분',
                    'priority': 'critical'
                },
                {
                    'action': '데이터베이스 연결 재설정',
                    'estimated_recovery_time': '30초',
                    'priority': 'high'
                },
                {
                    'action': '느린 쿼리 최적화 (장기 솔루션)',
                    'priority': 'medium'
                }
            ],
            'timeline': [
                {
                    'time': '2026-03-16 10:00:00',
                    'event': '오류율 증가 시작',
                    'value': '2.5%'
                },
                {
                    'time': '2026-03-16 10:05:00',
                    'event': 'API 지연시간 급증',
                    'value': '500ms → 2000ms'
                },
                {
                    'time': '2026-03-16 10:08:00',
                    'event': '결제 서비스 부분 장애',
                    'value': '에러율 25%'
                }
            ]
        }

비용 최적화 계층:

1단계: 데이터 수집 최적화
  - eBPF 기반 제로 계측 (SDK 제거)
  - 샘플링 정책 (중요한 트레이스만 100%, 나머지 10%)
  - 로그 집계 및 필터링 (클라이언트 측)
  예상 절감: 50-60%

2단계: 데이터 전송 최적화
  - 엣지 프로세싱 (수집기에서 전처리)
  - 압축 및 배치 처리
  - 로컬 버퍼링 (네트워크 오류 시)
  예상 절감: 20-30%

3단계: 저장소 최적화
  - 시계열 데이터베이스 활용 (InfluxDB, TimescaleDB)
  - 데이터 라이프사이클 관리 (시간에 따른 압축/삭제)
  - 핫/콜드 스토리지 분리
  예상 절감: 30-40%

4단계: 쿼리 최적화
  - 인덱싱 전략
  - 캐싱 레이어 (Redis)
  - 집계 테이블 미리 계산
  예상 절감: 20-25%

조직: 500명의 개발자, 200개의 마이크로서비스

이전 (전통적 관찰가능성):
- Datadog/New Relic: $500,000/연
- 엔지니어 시간 (계측, 디버깅): $300,000/연
- 네트워크 비용: $100,000/연
- 총 비용: $900,000/연

개선 후 (eBPF + OpenTelemetry + OSS):
- Datadog/경량 SaaS: $150,000/연
- 엔지니어 시간 (자동 계측): $80,000/연
- 네트워크 비용: $20,000/연
- 자체 호스팅 (AWS): $50,000/연
- 총 비용: $300,000/연

절감: 66% ($600,000/연)

수집 계층:
├─ eBPF 기반 (Cilium Hubble, Tetragon)
├─ OpenTelemetry Collector
└─ 경량 에이전트

처리 계층:
├─ Datadog, New Relic (SaaS)
├─ Grafana Loki (로그)
├─ Prometheus (메트릭)
└─ Jaeger (트레이스)

분석 계층:
├─ AI/ML 기반 RCA
├─ 이상 탐지
└─ 상관 관계 분석

액션 계층:
├─ 자동 수정 (AutoRemediation)
└─ 알림 및 공지

# Cilium + Hubble 설치
helm install cilium cilium/cilium \
  --namespace kube-system \
  --set hubble.relay.enabled=true \
  --set hubble.ui.enabled=true

# 네트워크 정책 자동 학습 활성화
kubectl apply -f - <<'EOF'
apiVersion: cilium.io/v2
kind: CiliumNetworkPolicy
metadata:
  name: auto-policy-learning
spec:
  description: "자동 네트워크 정책 학습"
  policies:
    - auto-generate: true
EOF

# OpenTelemetry Collector 배포
apiVersion: v1
kind: ConfigMap
metadata:
  name: otel-collector-config
data:
  config.yaml: |
    receivers:
      otlp:
        protocols:
          grpc:
            endpoint: 0.0.0.0:4317
          http:
            endpoint: 0.0.0.0:4318

    processors:
      batch:
        send_batch_size: 1024
        timeout: 10s
      memory_limiter:
        check_interval: 1s
        limit_mib: 512

    exporters:
      otlp:
        endpoint: datadog-collector:4317
      logging:
        loglevel: debug

    service:
      pipelines:
        traces:
          receivers: [otlp]
          processors: [memory_limiter, batch]
          exporters: [otlp, logging]

# LLM 기반 RCA 시스템 연동
from langchain.llms import OpenAI
from langchain.chains import RetrievalQA

class ObservabilityLLMAnalyzer:
    def __init__(self):
        self.llm = OpenAI(temperature=0.1, model="gpt-4")

    def analyze_incident_with_llm(self, incident_context):
        """
        관찰가능성 데이터를 LLM에 제공하여
        근본원인을 분석
        """
        prompt = f"""
        당신은 시스템 관리 전문가입니다.
        다음의 관찰가능성 데이터를 분석하여 근본원인을 찾으세요:

        메트릭:
        {incident_context['metrics']}

        로그:
        {incident_context['logs']}

        분산 트레이스:
        {incident_context['traces']}

        과거 유사 사건:
        {incident_context['similar_incidents']}

        1. 근본원인은 무엇인가?
        2. 영향을 받는 서비스는?
        3. 즉시 조치사항은?
        4. 장기 해결책은?
        """

        response = self.llm(prompt)
        return response

System diagram showing eBPF layer at kernel level intercepting system calls and network traffic, feeding data to OpenTelemetry Collector which aggregates metrics, traces, and logs, then flowing to multiple backends (Datadog, Prometheus, Jaeger). Show AI/ML component analyzing data for root cause analysis. Include visualization of network topology with service dependencies and health indicators. Modern tech illustration with layered architecture visualization.