Kubernetes + KEDA GPU 스케줄링으로 AI 추론 서비스 자동 확장하기

안녕하세요, 저는 HolySheep AI에서 수백 개의 AI 서비스 인프라를 설계하고运维하는 엔지니어입니다. 이번 튜토리얼에서는 Kubernetes와 KEDA를 활용하여 AI 추론(Inference) 서비스를 자동으로 확장하는 방법을 초보자도 이해할 수 있도록 단계별로 설명드리겠습니다.

1. 기본 개념: Kubernetes, KEDA, GPU 스케줄링이란?

AI 서비스를 운영하다 보면 사용량이 늘었을 때 자동으로 서버를 추가하고, 사용량이 줄었을 때 줄여야 합니다. 이를 자동 확장(Auto Scaling)이라고 합니다. 먼저 핵심 개념들을 간단하게 정리하겠습니다.

1.1 Kubernetes란?

Kubernetes는 여러 대의 서버를 하나로 묶어서 관리하는 도구입니다. 예를 들어, 하나의 웹사이트를 3개의 컴퓨터에서 동시에 실행하고, 어떤 컴퓨터가 고장 나면 자동으로 다른 컴퓨터로 이동시키는 역할을 합니다. Docker 컨테이너를 대규모로 관리하는 업계 표준입니다.

1.2 KEDA란?

KEDA(Kubernetes Event-Driven Autoscaling)는 Kubernetes의 확장 도구입니다. 일반 Kubernetes는 CPU나 메모리 사용량만으로 확장을 결정합니다. 하지만 KEDA는 외부 이벤트에 반응할 수 있습니다. 예를 들어:

• 메시지 큐에 대기 중인 요청 수
• 특정 시간대(오후 6시에 사용량 급증)
• 커스텀 메트릭(GPU 사용률)

1.3 GPU 스케줄링이란?

AI 추론 서비스는 GPU(Graphics Processing Unit)가 필요합니다. GPU 스케줄링은 여러 AI 모델이 GPU를 효율적으로 공유하거나 전용으로 사용할 수 있도록 관리하는 기술입니다.

2. 개발 환경 준비

2.1 필요한 도구 설치

시작하기 전에 로컬 컴퓨터에 필요한 도구를 설치해야 합니다. 터미널(명령 프롬프트)을 열고 다음 명령어를 순서대로 실행하세요.

# 1. kubectl 설치 (Kubernetes 명령어 도구)
macOS의 경우
brew install kubectl

Windows의 경우 (Chocolatey 필요)
choco install kubernetes-cli

2. kind 설치 (로컬 Kubernetes 클러스터)
brew install kind

3. Helm 설치 (Kubernetes 패키지 매니저)
brew install helm

4. Docker Desktop 설치 (Kubernetes 활성화 필요)
https://www.docker.com/products/docker-desktop 에서 다운로드

# 5. kind로 Kubernetes 클러스터 생성 (GPU 노드 포함)
kind create cluster --name ai-inference --config - <6. NVIDIA GPU Operator 설치 (GPU 지원용)
helm repo add nvidia https://nvidia.github.io/gpu-operator
helm repo update
helm install gpu-operator nvidia/gpu-operator -n gpu-operator --create-namespace

2.2 HolySheep AI API 키 발급

이 튜토리얼에서는 HolySheep AI의 API를 사용하여 AI 추론 서비스를 구현합니다. HolySheep AI는 지금 가입하면 무료 크레딧을 제공하며, 해외 신용카드 없이 로컬 결제가 가능합니다.

# HolySheep AI API 키를 환경 변수로 설정
export HOLYSHEEP_API_KEY="YOUR_HOLYSHEEP_API_KEY"

API 연결 테스트
curl https://api.holysheep.ai/v1/models \
  -H "Authorization: Bearer $HOLYSHEEP_API_KEY"

3. KEDA 설치 및 기본 설정

3.1 KEDA 설치

# 3.1.1 KEDA Helm 리포지토리 추가
helm repo add kedacore https://kedacore.github.io/charts
helm repo update

3.1.2 KEDA 설치
kubectl create namespace keda
helm install keda kedacore/keda --namespace keda

3.1.3 설치 확인
kubectl get pods -n keda

# 3.1.4 KEDA 설치 완료 확인 (모든 파드가 Running 상태여야 함)
kubectl get all -n keda
출력 예시:
NAME                                                READY   STATUS
pod/keda-7f4b8c9d6-abc12                           1/1     Running
pod/keda-operator-5d8f9c7b4-xyz34                  1/1     Running
pod/keda-metrics-apiserver-9a7b6c5d8-pqr78         1/1     Running

4. AI 추론 서비스 배포

4.1 AI 추론 서비스 코드 작성

먼저 Kubernetes에 배포할 AI 추론 서비스 예제를 Python으로 작성합니다. 이 서비스는 HolySheep AI API를 사용하여 텍스트 생성을 수행합니다.

# inference-service/app.py - AI 추론 서비스 메인 코드

from flask import Flask, request, jsonify
import os
import requests
from datetime import datetime

app = Flask(__name__)

HOLYSHEEP_API_KEY = os.environ.get("HOLYSHEEP_API_KEY")
BASE_URL = "https://api.holysheep.ai/v1"

@app.route("/health")
def health():
    """헬스 체크 엔드포인트"""
    return jsonify({"status": "healthy", "timestamp": datetime.now().isoformat()})

@app.route("/generate", methods=["POST"])
def generate():
    """텍스트 생성 엔드포인트"""
    data = request.get_json()
    prompt = data.get("prompt", "")
    
    if not prompt:
        return jsonify({"error": "prompt가 필요합니다"}), 400
    
    headers = {
        "Authorization": f"Bearer {HOLYSHEEP_API_KEY}",
        "Content-Type": "application/json"
    }
    
    payload = {
        "model": "gpt-4.1",
        "messages": [{"role": "user", "content": prompt}],
        "max_tokens": 500
    }
    
    try:
        response = requests.post(
            f"{BASE_URL}/chat/completions",
            headers=headers,
            json=payload,
            timeout=30
        )
        result = response.json()
        return jsonify(result)
    except Exception as e:
        return jsonify({"error": str(e)}), 500

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

# inference-service/requirements.txt
flask==3.0.0
requests==2.31.0
gunicorn==21.2.0

# inference-service/Dockerfile
FROM python:3.11-slim

WORKDIR /app

COPY requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt

COPY app.py .

ENV PORT=5000
EXPOSE 5000

CMD ["gunicorn", "--bind", "0.0.0.0:5000", "--workers", "2", "--threads", "4", "app:app"]

4.2 Kubernetes 매니페스트 작성

# inference-deployment.yaml

apiVersion: v1
kind: Secret
metadata:
  name: holy-sheep-api-key
  namespace: inference
type: Opaque
stringData:
  api-key: "YOUR_HOLYSHEEP_API_KEY"
---
apiVersion: apps/v1
kind: Deployment
metadata:
  name: inference-service
  namespace: inference
  labels:
    app: inference-service
spec:
  replicas: 1
  selector:
    matchLabels:
      app: inference-service
  template:
    metadata:
      labels:
        app: inference-service
    spec:
      containers:
      - name: inference-service
        image: your-registry/inference-service:v1
        ports:
        - containerPort: 5000
        env:
        - name: HOLYSHEEP_API_KEY
          valueFrom:
            secretKeyRef:
              name: holy-sheep-api-key
              key: api-key
        resources:
          limits:
            nvidia.com/gpu: 1
            memory: "4Gi"
            cpu: "2"
          requests:
            nvidia.com/gpu: 1
            memory: "2Gi"
            cpu: "1"
---
apiVersion: v1
kind: Service
metadata:
  name: inference-service
  namespace: inference
spec:
  selector:
    app: inference-service
  ports:
  - protocol: TCP
    port: 80
    targetPort: 5000
  type: LoadBalancer

5. KEDA 기반 자동 확장 설정

5.1 Prometheus 메트릭 기반 스케일링

Prometheus를 설치하고 AI 서비스의 요청 수를 기반으로 자동 확장하도록 KEDA를 설정합니다.

# 5.1.1 Prometheus 설치
kubectl create namespace monitoring
helm repo add prometheus-community https://prometheus-community.github.io/helm-charts
helm repo update
helm install prometheus prometheus-community/prometheus -n monitoring

5.1.2 Prometheus가 실행 중인지 확인
kubectl get pods -n monitoring

# 5.1.3 KEDA Prometheus 스케일러를 사용한 ScaledObject 생성
scaledobject-prometheus.yaml

apiVersion: keda.sh/v1alpha1
kind: ScaledObject
metadata:
  name: inference-scaledobject
  namespace: inference
spec:
  scaleTargetRef:
    name: inference-service
  pollingInterval: 15
  cooldownPeriod: 300
  minReplicaCount: 1
  maxReplicaCount: 10
  metricsServer:
    address: keda-metrics-apiserver.keda:443
  triggers:
  - type: prometheus
    metadata:
      serverAddress: http://prometheus-server.monitoring.svc:9090
      metricName: http_requests_total
      threshold: "100"
      query: sum(rate(http_requests_total{service="inference-service"}[2m]))

# 5.1.4 ScaledObject 적용
kubectl apply -f scaledobject-prometheus.yaml

5.1.5 확장 상태 확인
kubectl get scaledobject -n inference
kubectl describe scaledobject inference-scaledobject -n inference

5.2 메시지 큐 기반 스케일링

RabbitMQ나 Kafka 같은 메시지 큐의 대기열 길이를 기반으로 확장할 수도 있습니다. 실제 프로덕션 환경에서 더 자주 사용되는 방식입니다.

# 5.2.1 RabbitMQ 설치
helm repo add bitnami https://charts.bitnami.com/bitnami
helm repo update
kubectl create namespace messaging
helm install rabbitmq bitnami/rabbitmq -n messaging

5.2.2 KEDA RabbitMQ 스케일러 설정
scaledobject-rabbitmq.yaml

apiVersion: keda.sh/v1alpha1
kind: TriggerAuthentication
metadata:
  name: rabbitmq-trigger-auth
  namespace: inference
spec:
  secretTargetRef:
  - parameter: host
    name: rabbitmq-credentials
    key: rabbitmq-host
  - parameter: username
    name: rabbitmq-credentials
    key: rabbitmq-username
  - parameter: password
    name: rabbitmq-credentials
    key: rabbitmq-password
---
apiVersion: keda.sh/v1alpha1
kind: ScaledObject
metadata:
  name: inference-queue-scaledobject
  namespace: inference
spec:
  scaleTargetRef:
    name: inference-service
  pollingInterval: 5
  cooldownPeriod: 30
  minReplicaCount: 2
  maxReplicaCount: 20
  triggers:
  - type: rabbitmq
    authenticationRef:
      name: rabbitmq-trigger-auth
    metadata:
      queueName: inference-requests
      queueLength: "50"
      host: amqp://guest:[email protected]:5672/

# 5.2.3 메시지 큐 스케일러 적용
kubectl apply -f scaledobject-rabbitmq.yaml

5.2.4 현재 레플리카 수 실시간 확인
watch kubectl get pods -n inference

5.3 GPU 사용률 기반 스케일링

AI 추론 서비스에서는 GPU 사용률이 중요한 메트릭입니다. GPU 사용률이 높으면 더 많은 파드를 추가하여 부하를 분산시킵니다.

# 5.3.1 Prometheus 노드 익스포터 설치 (GPU 메트릭 수집용)
kubectl apply -f - <

# 5.3.2 Prometheus에 GPU 메트릭 수집 설정 추가
gpu-scrape-config.yaml

apiVersion: v1
kind: ConfigMap
metadata:
  name: prometheus-server-conf
  namespace: monitoring
data:
  prometheus.yml: |
    global:
      scrape_interval: 15s
    scrape_configs:
    - job_name: 'kubernetes-nodes'
      static_configs:
      - targets: ['node-exporter.monitoring.svc:9100']
    - job_name: 'inference-service'
      kubernetes_sd_configs:
      - role: pod
      relabel_configs:
      - source_labels: [__meta_kubernetes_pod_annotation_prometheus_io_scrape]
        action: keep
        regex: true
      - source_labels: [__meta_kubernetes_pod_name]
        target_label: kubernetes_pod_name

# 6.1.1 Grafana 설치
helm install grafana bitnami/grafana -n monitoring

6.1.2 Grafana 접속 정보 확인
kubectl get secret grafana -n monitoring -o jsonpath="{.data.admin-password}" | base64 -d
kubectl port-forward svc/grafana 3000:3000 -n monitoring &

# 6.1.3 Grafana 대시보드 JSON - AI 서비스 모니터링
grafana-dashboard.json

{
  "dashboard": {
    "title": "AI Inference Service Monitoring",
    "uid": "ai-inference-001",
    "panels": [
      {
        "title": "Request Rate",
        "type": "graph",
        "targets": [
          {
            "expr": "sum(rate(http_requests_total{service=\"inference-service\"}[5m])) by (pod)",
            "legendFormat": "{{pod}}"
          }
        ]
      },
      {
        "title": "GPU Utilization",
        "type": "graph",
        "targets": [
          {
            "expr": "DCGM_FI_DEV_GPU_UTIL{container=\"inference-service\"}",
            "legendFormat": "GPU {{gpu}}"
          }
        ]
      },
      {
        "title": "Replica Count",
        "type": "stat",
        "targets": [
          {
            "expr": "kube_deployment_spec_replicas{deployment=\"inference-service\"}",
            "legendFormat": "Replicas"
          }
        ]
      }
    ]
  }
}

# 7.1 모델별 비용 비교 (2024년 기준)
HolySheep AI 공식 가격표

MODELS = {
    "gpt-4.1": {
        "input_cost": 8.0,      # $8/MTok 입력
        "output_cost": 8.0,     # $8/MTok 출력
        "use_case": "고품질 텍스트 생성, 복잡한 추론"
    },
    "claude-sonnet-4.5": {
        "input_cost": 15.0,     # $15/MTok 입력
        "output_cost": 75.0,    # $75/MTok 출력
        "use_case": "장문 분석, 컨텍스트 이해"
    },
    "gemini-2.5-flash": {
        "input_cost": 2.50,     # $2.50/MTok 입력
        "output_cost": 10.0,    # $10/MTok 출력
        "use_case": "대량 처리, 빠른 응답 필요"
    },
    "deepseek-v3.2": {
        "input_cost": 0.42,     # $0.42/MTok 입력
        "output_cost": 1.68,    # $1.68/MTok 출력
        "use_case": "비용 최적화,大批量 처리"
    }
}

def estimate_cost(model, input_tokens, output_tokens):
    """월간 비용 추정"""
    pricing = MODELS.get(model, {})
    input_cost = (input_tokens / 1_000_000) * pricing.get("input_cost", 0)
    output_cost = (output_tokens / 1_000_000) * pricing.get("output_cost", 0)
    return input_cost + output_cost

DeepSeek V3.2 사용 시 연간 95% 비용 절감 예시
print(f"GPT-4.1: ${estimate_cost('gpt-4.1', 10_000_000, 5_000_000):.2f}/월")    # $115/월
print(f"DeepSeek: ${estimate_cost('deepseek-v3.2', 10_000_000, 5_000_000):.2f}/월")  # $6.3/월

# 증상: pods가 GPU를 요청해도 nvidia.com/gpu가 0으로 표시됨

오류 메시지 예시:
Warning  FailedScheduling  2m49s default-scheduler  
0/1 nodes are available: 1 Insufficient nvidia.com/gpu.

해결 방법 1: NVIDIA Device Plugin 설치 확인
kubectl get pods -n gpu-operator
모든 파드가 Running 상태여야 함

해결 방법 2: Device Plugin이 없을 경우 설치
kubectl apply -f https://raw.githubusercontent.com/NVIDIA/k8s-device-plugin/v1.12/nvidia-device-plugin.yml

해결 방법 3: 클러스터 노드에 라벨이 없으면 추가
kubectl label nodes <node-name> nvidia.com/gpu=present

확인
kubectl get nodes -o jsonpath='{.items[*].metadata.labels}' | grep -o nvidia

# 증상: ScaledObject를 생성했지만 레플리카 수가 변경되지 않음

오류 메시지: No results found for query

해결 방법 1: Prometheus 메트릭 확인
kubectl exec -it -n monitoring prometheus-server-xxx -- /bin/sh
Prometheus 내부에서 직접 쿼리 테스트
curl "http://localhost:9090/api/v1/query?query=http_requests_total"

해결 방법 2: KEDA operator 로그 확인
kubectl logs -n keda deployment/keda-operator --tail=100

해결 방법 3: ScaledObject 상태 확인
kubectl get scaledobject inference-scaledobject -n inference -o yaml
Conditions 항목에서 상태 확인

해결 방법 4: 인증 정보 재확인
kubectl get secret rabbitmq-credentials -n inference
kubectl describe triggerauthentication rabbitmq-trigger-auth -n inference

# 증상: API 호출 시 401 Unauthorized 또는 403 Forbidden 오류

해결 방법 1: API 키 형식 확인
echo $HOLYSHEEP_API_KEY
HolySheep AI 키는 'hs_'로 시작해야 함

해결 방법 2: Secret이 올바르게 마운트되었는지 확인
kubectl exec -it <pod-name> -n inference -- env | grep HOLYSHEEP

해결 방법 3: 네트워크 정책 확인 (Istio/Calico 사용 시)
kubectl get networkpolicies -n inference
필요한 경우 egress 규칙 추가

해결 방법 4: DNS 해결 확인
kubectl exec -it <pod-name> -n inference -- nslookup api.holysheep.ai

해결 방법 5: curl로 직접 테스트
kubectl exec -it <pod-name> -n inference -- \
  curl https://api.holysheep.ai/v1/models \
  -H "Authorization: Bearer $HOLYSHEEP_API_KEY"

# 증상: OOMKilled 상태로 파드가 반복 종료됨

해결 방법 1: 현재 메모리 사용량 확인
kubectl top pods -n inference

해결 방법 2: 리소스 제한 조정
deployment-resources.yaml

apiVersion: apps/v1
kind: Deployment
metadata:
  name: inference-service
  namespace: inference
spec:
  template:
    spec:
      containers:
      - name: inference-service
        resources:
          limits:
            memory: "8Gi"        # 2배로 증가
            cpu: "2"
          requests:
            memory: "4Gi"
            cpu: "1"

해결 방법 3: Vertical Pod Autoscaler 적용
kubectl autoscale deployment inference-service \
  -n inference --cpu-percent=80 --min=1 --max=10