8장: 비용 최적화 - 스팟 인스턴스, 모델 공유, 리소스 관리

AI 서비스 월간 비용 예시 (A100 80GB x 4, 온디맨드):
 
GPU 인스턴스 (p4d.24xlarge):
  시간당 $32.77 x 24시간 x 30일 = $23,594/월
 
스토리지 (EBS + S3):
  모델 스토리지 500GB = 약 $50/월
 
네트워크:
  데이터 전송 1TB = 약 $90/월
 
모니터링:
  CloudWatch + Prometheus = 약 $50/월
 
총 비용: 약 $23,784/월
GPU 비용 비중: 99.2%

GPU 인스턴스 비용 비교 (시간당, ap-northeast-2):
 
인스턴스 타입        온디맨드    스팟       할인율
-----------------  ---------  --------  ------
p4d.24xlarge(A100)  $32.77     $9.83     70%
g5.xlarge(A10G)     $1.01      $0.30     70%
g5.2xlarge(A10G)    $1.21      $0.36     70%
p5.48xlarge(H100)   $98.32     $29.50    70%
 
* 스팟 가격은 변동하며, 위 수치는 참고용입니다.

eksctl create nodegroup \
  --cluster ai-serving-cluster \
  --name gpu-spot-nodes \
  --node-type p4d.24xlarge \
  --nodes-min 0 \
  --nodes-max 4 \
  --spot \
  --node-labels "capacity-type=spot,accelerator=nvidia-a100" \
  --node-taints "capacity-type=spot:PreferNoSchedule"

apiVersion: apps/v1
kind: Deployment
metadata:
  name: vllm-spot
  namespace: ai-serving
spec:
  replicas: 2
  template:
    spec:
      tolerations:
        - key: nvidia.com/gpu
          operator: Equal
          value: present
          effect: NoSchedule
        - key: capacity-type
          operator: Equal
          value: spot
          effect: PreferNoSchedule
      affinity:
        nodeAffinity:
          preferredDuringSchedulingIgnoredDuringExecution:
            - weight: 90
              preference:
                matchExpressions:
                  - key: capacity-type
                    operator: In
                    values:
                      - spot
            - weight: 10
              preference:
                matchExpressions:
                  - key: capacity-type
                    operator: In
                    values:
                      - on-demand
      containers:
        - name: vllm
          # ... (기존 설정 동일)

helm repo add eks https://aws.github.io/eks-charts
helm install aws-node-termination-handler eks/aws-node-termination-handler \
  --namespace kube-system \
  --set enableSpotInterruptionDraining=true \
  --set enableScheduledEventDraining=true

혼합 전략 예시:
 
기본 용량 (온디맨드, 항상 가동):
  vllm-ondemand: replicas=2 (p4d.24xlarge, 온디맨드)
  비용: $32.77 x 2 x 24 x 30 = $47,188/월
 
추가 용량 (스팟, 트래픽 기반):
  vllm-spot: replicas=0~4 (p4d.24xlarge, 스팟)
  평균 가동: 하루 8시간, 2인스턴스
  비용: $9.83 x 2 x 8 x 30 = $4,718/월
 
총 비용: $51,906/월
순수 온디맨드 대비: $94,376/월 --> 45% 절감

Llama-3.1-70B 서빙 옵션:
 
FP16 (양자화 없음):
  필요 GPU: 4x A100 80GB
  인스턴스: p4d.24xlarge ($32.77/시간)
  월 비용: $23,594
 
INT4 (AWQ 양자화):
  필요 GPU: 1x A100 80GB 또는 1x A10G 24GB
  인스턴스: g5.xlarge ($1.01/시간)
  월 비용: $727
 
비용 절감: 96.9%
품질 손실: 약 1-3% (작업에 따라 다름)

모델 라우팅 전략:
 
간단한 질의 (70%):
  - FAQ, 정형 응답
  - Llama-3.1-8B로 처리
  - 비용: $727/월
 
복잡한 질의 (30%):
  - 분석, 추론, 창작
  - Llama-3.1-70B로 처리
  - 비용: $23,594/월 x 30% = $7,078/월
 
총 비용: $7,805/월
전부 70B 사용 대비: 67% 절감

from openai import OpenAI
 
small_client = OpenAI(
    base_url="http://vllm-8b-service/v1",
    api_key="not-needed"
)
 
large_client = OpenAI(
    base_url="http://vllm-70b-service/v1",
    api_key="not-needed"
)
 
def classify_complexity(message: str) -> str:
    """요청 복잡도를 분류합니다."""
    simple_keywords = ["정의", "뜻", "의미", "설명해", "알려줘"]
    if any(kw in message for kw in simple_keywords):
        return "simple"
    if len(message) > 500:
        return "complex"
    return "simple"
 
def route_request(messages: list) -> OpenAI:
    """복잡도에 따라 적절한 모델로 라우팅합니다."""
    user_message = messages[-1]["content"]
    complexity = classify_complexity(user_message)
 
    if complexity == "simple":
        return small_client
    return large_client

apiVersion: v1
kind: ConfigMap
metadata:
  name: time-slicing-config
  namespace: gpu-operator
data:
  a100-80gb: |
    version: v1
    sharing:
      timeSlicing:
        resources:
          - name: nvidia.com/gpu
            replicas: 4

프리픽스 캐싱 비용 절감 효과:
 
시스템 프롬프트 2000 토큰, 사용자 입력 평균 200 토큰:
  캐싱 미적용: 2200 토큰 프리필 필요 (100% GPU 시간)
  캐싱 적용:   200 토큰 프리필 필요 (약 9% GPU 시간)
 
동일 GPU로 처리 가능한 요청 수: 약 2-3배 증가
실질적 비용 절감: 50-66%

import json
from openai import OpenAI
 
client = OpenAI(
    base_url="http://vllm-batch-service/v1",
    api_key="not-needed"
)
 
def run_batch_inference(input_file: str, output_file: str):
    """파일 기반 배치 추론을 실행합니다."""
    with open(input_file) as f:
        items = [json.loads(line) for line in f]
 
    results = []
    # 동시에 여러 요청을 보내 GPU 활용률 극대화
    for item in items:
        response = client.chat.completions.create(
            model="meta-llama/Llama-3.1-8B-Instruct",
            messages=[
                {"role": "user", "content": item["prompt"]}
            ],
            max_tokens=512,
        )
        results.append({
            "id": item["id"],
            "response": response.choices[0].message.content
        })
 
    with open(output_file, "w") as f:
        for r in results:
            f.write(json.dumps(r, ensure_ascii=False) + "\n")

추적해야 할 비용 메트릭:
 
인프라 메트릭:
  - GPU 인스턴스 가동 시간 (온디맨드 vs 스팟)
  - GPU 활용률 (nvidia_gpu_duty_cycle)
  - GPU 메모리 사용률
 
서비스 메트릭:
  - 요청당 평균 토큰 수 (입력 + 출력)
  - 요청당 평균 처리 시간
  - 요청당 비용 = (GPU 시간당 비용 x 처리 시간) / 3600
 
비즈니스 메트릭:
  - 일간/주간/월간 총 비용
  - 서비스/모델별 비용 분배
  - 비용 추세와 예측

helm repo add kubecost https://kubecost.github.io/cost-analyzer
helm install kubecost kubecost/cost-analyzer \
  --namespace kubecost \
  --create-namespace \
  --set kubecostToken="YOUR_TOKEN"

비용 최적화 체크리스트:
 
[즉시 적용 가능]
- 양자화 적용 검토 (INT4/INT8)
- 프리픽스 캐싱 활성화
- 최대 컨텍스트 길이 필요량에 맞게 제한
- 개발/테스트 환경을 스팟 인스턴스로 전환
 
[단기 (1-2주)]
- 프로덕션 스팟 혼합 전략 구현
- 비업무 시간 스케일다운 예약
- 비실시간 작업을 배치 추론으로 전환
- 비용 모니터링 대시보드 구축
 
[중기 (1-2개월)]
- 모델 라우팅 (복잡도 기반 모델 선택)
- GPU 활용률 기반 오토스케일링 튜닝
- Reserved/Savings Plans 검토
- 작은 특화 모델 파인튜닝 검토
 
[장기]
- 자체 GPU 서버 구축 비용 분석 (코로케이션)
- 온프레미스와 클라우드 하이브리드 아키텍처