컴퓨트 최적화

# Compute Policy로 Auto Stop 강제 적용 (관리자용)
{
  "autotermination_minutes": {
    "type": "range",
    "maxValue": 30,
    "defaultValue": 10
  },
  "custom_tags.CostCenter": {
    "type": "fixed",
    "value": "engineering"
  }
}

# Spot 인스턴스 + Fallback 설정 예시
{
  "aws_attributes": {
    "first_on_demand": 1,          # 드라이버는 On-Demand
    "availability": "SPOT_WITH_FALLBACK",  # Spot 우선, 불가 시 On-Demand
    "spot_bid_price_percent": 100   # On-Demand 가격까지 입찰
  }
}

# Instance Pool 설정 예시
{
  "instance_pool_name": "data-engineering-pool",
  "node_type_id": "i3.xlarge",
  "min_idle_instances": 2,        # 항상 2대 대기 (비용 발생)
  "max_capacity": 20,              # 최대 20대까지 확장
  "idle_instance_autotermination_minutes": 15,  # 유휴 인스턴스 15분 후 반환
  "preloaded_spark_versions": ["15.4.x-scala2.12"]  # 런타임 사전 로드
}

# 배치 Job의 Spot 인스턴스 Fault Tolerance 설정
# databricks.yml 또는 Job 설정
{
  "job_clusters": [{
    "job_cluster_key": "etl_cluster",
    "new_cluster": {
      "num_workers": 8,
      "node_type_id": "i3.2xlarge",
      "aws_attributes": {
        "first_on_demand": 1,
        "availability": "SPOT_WITH_FALLBACK",
        "spot_bid_price_percent": 100,
        "zone_id": "auto"  # AZ 자동 선택으로 가용성 극대화
      },
      "autoscale": {
        "min_workers": 4,
        "max_workers": 12
      }
    }
  }],
  "tasks": [{
    "task_key": "etl_task",
    "max_retries": 3,           # Spot 회수 시 자동 재시도
    "min_retry_interval_millis": 60000,  # 1분 후 재시도
    "retry_on_timeout": true
  }]
}

# ML 학습 시 체크포인트 기반 Spot 내결함성
import mlflow
import torch

def train_with_checkpoint(model, train_loader, epochs, checkpoint_dir):
    start_epoch = 0
    
    # 기존 체크포인트가 있으면 복원
    checkpoint_path = f"{checkpoint_dir}/latest_checkpoint.pt"
    if os.path.exists(checkpoint_path):
        checkpoint = torch.load(checkpoint_path)
        model.load_state_dict(checkpoint['model_state'])
        start_epoch = checkpoint['epoch'] + 1
        print(f"체크포인트에서 복원: epoch {start_epoch}부터 재개")
    
    for epoch in range(start_epoch, epochs):
        train_one_epoch(model, train_loader)
        
        # 매 epoch마다 체크포인트 저장 (Spot 회수 대비)
        torch.save({
            'epoch': epoch,
            'model_state': model.state_dict(),
        }, checkpoint_path)
        
        mlflow.log_metric("epoch", epoch)

# Photon 활성화/비활성화를 워크로드별로 분리하는 Compute Policy
# ETL 전용 (Photon ON)
{
  "runtime_engine": {
    "type": "fixed",
    "value": "PHOTON"
  },
  "node_type_id": {
    "type": "allowlist",
    "values": ["i3.xlarge", "i3.2xlarge"]
  }
}

# ML 전용 (Photon OFF)
{
  "runtime_engine": {
    "type": "fixed",
    "value": "STANDARD"
  },
  "node_type_id": {
    "type": "allowlist",
    "values": ["g5.xlarge", "g5.2xlarge", "p3.2xlarge"]
  }
}

[시나리오 1: 일일 배치 ETL (하루 2시간 실행)]

Classic (i3.2xlarge × 4 workers):
  EC2: $0.624 × 4 × 2hr = $4.99/일
  DBU: 4 DBU × 4 × 2hr = 32 DBU/일
  연간: $4.99 × 365 + 32 × 365 × $0.22 = $4,389

Serverless:
  DBU: 32 DBU × 2hr = 64 Serverless DBU/일
  연간: 64 × 365 × $0.70 = $16,352
  
→ Classic이 73% 저렴 (예측 가능한 배치는 Classic 유리)

[시나리오 2: Ad-hoc 분석 (하루 평균 30분 실제 사용)]

Classic (m5.xlarge × 2, Auto-stop 10분):
  실제 가동: ~1시간/일 (유휴 대기 포함)
  EC2: $0.192 × 2 × 1hr = $0.38/일
  DBU: 2 × 2 × 1hr = 4 DBU/일
  연간: ($0.38 + 4 × $0.22) × 250 = $315

Serverless:
  실제 사용: 30분/일
  DBU: 4 × 0.5hr = 2 Serverless DBU/일
  연간: 2 × 250 × $0.70 = $350

→ 비슷하지만, Serverless는 즉시 시작 + 관리 부담 없음

Q1: 일일 가동률이 40% 이상인가?
  → Yes: Classic + Reserved Capacity 검토
  → No: Q2로

Q2: GPU나 커스텀 Docker가 필요한가?
  → Yes: Classic 필수
  → No: Q3로

Q3: 인프라 관리 팀이 있는가?
  → Yes: Classic이 비용 효율적
  → No: Serverless (관리 비용 절감)

# Compute Policy에서 특정 Pool 강제 지정
{
  "instance_pool_id": {
    "type": "fixed",
    "value": "pool-id-12345"
  },
  "driver_instance_pool_id": {
    "type": "fixed",
    "value": "pool-id-12345"
  }
}