로드밸런서/헬스체크: 고가용성의 심장

stateDiagram-v2
    direction LR
    
    state "Healthy (In Service)" as Healthy
    state "Unhealthy (Out of Service)" as Unhealthy
    
    [*] --> Healthy : Initial Check Pass
    
    Healthy --> Healthy : Check OK (200)
    Healthy --> Unhealthy : Check Fail x Threshold
    
    Unhealthy --> Unhealthy : Check Fail
    Unhealthy --> Healthy : Check OK x Threshold
    
    note right of Unhealthy
        Traffic blocked
        Draining active
    end note

flowchart TD
    A[로드밸런서 필요] --> B{고정 IP 필수?}
    B -->|Yes| NLB[NLB 선택]
    B -->|No| C{HTTP 경로/헤더 기반 라우팅 필요?}
    C -->|Yes| ALB[ALB 선택]
    C -->|No| D{TCP/UDP 프로토콜 직접 사용?}
    D -->|Yes| NLB
    D -->|No| E{WAF/OIDC 인증 연동?}
    E -->|Yes| ALB
    E -->|No| F{초고성능 필요? 수백만 RPS?}
    F -->|Yes| NLB
    F -->|No| ALB

Client → NLB (고정 IP) → ALB (경로 라우팅) → Target Group → EC2/ECS

// Spring Boot Actuator 기본
@RestController
public class HealthController {

    @GetMapping("/health/live")
    public ResponseEntity<String> liveness() {
        // 프로세스가 살아있으면 OK
        return ResponseEntity.ok("OK");
    }
}

@Component
public class DeepHealthIndicator implements HealthIndicator {

    private final DataSource dataSource;
    private final RedisConnectionFactory redisFactory;
    private final KafkaTemplate<String, String> kafkaTemplate;

    public DeepHealthIndicator(DataSource dataSource,
                                RedisConnectionFactory redisFactory,
                                KafkaTemplate<String, String> kafkaTemplate) {
        this.dataSource = dataSource;
        this.redisFactory = redisFactory;
        this.kafkaTemplate = kafkaTemplate;
    }

    @Override
    public Health health() {
        Health.Builder builder = Health.up();
        Map<String, Object> details = new LinkedHashMap<>();

        // 1. DB 연결 체크 (타임아웃 2초)
        try (Connection conn = dataSource.getConnection()) {
            if (!conn.isValid(2)) {
                return builder.down().withDetail("db", "connection invalid").build();
            }
            details.put("db", "OK");
        } catch (SQLException e) {
            return builder.down().withDetail("db", e.getMessage()).build();
        }

        // 2. Redis 체크
        try {
            redisFactory.getConnection().ping();
            details.put("redis", "OK");
        } catch (Exception e) {
            // Redis 장애 시 degraded (down이 아님)
            details.put("redis", "DEGRADED: " + e.getMessage());
            builder.status("DEGRADED");
        }

        // 3. Kafka 메타데이터 체크
        try {
            kafkaTemplate.getDefaultTopic(); // 메타데이터 접근 확인
            details.put("kafka", "OK");
        } catch (Exception e) {
            details.put("kafka", "DEGRADED: " + e.getMessage());
            builder.status("DEGRADED");
        }

        return builder.withDetails(details).build();
    }
}

apiVersion: v1
kind: Pod
metadata:
  name: api-server
spec:
  containers:
    - name: app
      image: api-server:latest
      ports:
        - containerPort: 8080

      # 1. Startup Probe: 앱이 완전히 올라올 때까지 기다림
      #    성공 전까지 Liveness/Readiness가 작동하지 않음
      startupProbe:
        httpGet:
          path: /health/started
          port: 8080
        initialDelaySeconds: 5
        periodSeconds: 5
        failureThreshold: 30        # 최대 5 * 30 = 150초 기다림
        successThreshold: 1

      # 2. Liveness Probe: 프로세스 데드락/좀비 탐지
      livenessProbe:
        httpGet:
          path: /health/live
          port: 8080
        periodSeconds: 10
        failureThreshold: 3          # 30초 후 재시작
        successThreshold: 1
        timeoutSeconds: 3

      # 3. Readiness Probe: 트래픽 수신 가능 여부
      readinessProbe:
        httpGet:
          path: /health/ready
          port: 8080
        periodSeconds: 5
        failureThreshold: 3          # 15초 후 LB에서 제외
        successThreshold: 2          # 10초 연속 성공 시 복귀 (보수적)
        timeoutSeconds: 3

Pod 상태: Running → CrashLoopBackOff → Running → CrashLoopBackOff ...

원인: Liveness failureThreshold(3) × periodSeconds(10) = 30초
      앱 초기화 시간: 60초
      → 앱이 뜨기도 전에 계속 죽임

# application.yml
management:
  endpoint:
    health:
      probes:
        enabled: true                  # /actuator/health/liveness, /readiness 활성화
      group:
        liveness:
          include: livenessState       # 프로세스 상태만
        readiness:
          include:
            - readinessState
            - db                       # DataSource 연결
            - diskSpace                # 디스크 여유
  health:
    defaults:
      enabled: false                   # 기본 indicator 비활성화 후 명시 포함

// 커스텀 Readiness 조건 추가
@Component
public class WarmupReadinessIndicator implements HealthIndicator {

    private final AtomicBoolean warmedUp = new AtomicBoolean(false);

    @EventListener(ApplicationReadyEvent.class)
    public void onReady() {
        // 캐시 워밍업 완료 후 Ready 전환
        warmUpCaches();
        warmedUp.set(true);
    }

    @Override
    public Health health() {
        if (warmedUp.get()) {
            return Health.up().withDetail("warmup", "complete").build();
        }
        return Health.down().withDetail("warmup", "in-progress").build();
    }

    private void warmUpCaches() {
        // 핵심 캐시 사전 로딩
    }
}

Target이 Unhealthy로 전환되면:
1. 새 요청 → 다른 Target으로 전달
2. 기존 진행 중 요청 → Deregistration Delay 동안 유지
3. 딜레이 만료 → 강제 종료

기본값: 300초 (5분) — 대부분의 API는 30~60초가 적절

# application.yml
server:
  shutdown: graceful

spring:
  lifecycle:
    timeout-per-shutdown-phase: 30s    # 최대 30초간 기존 요청 완료 대기

@Component
public class GracefulShutdownHealthManager {

    private final AtomicBoolean shuttingDown = new AtomicBoolean(false);

    /**
     * SIGTERM 수신 시 Readiness를 먼저 DOWN으로 변경
     * → LB가 새 트래픽을 보내지 않음
     * → 기존 요청은 계속 처리
     */
    @PreDestroy
    public void onShutdown() {
        shuttingDown.set(true);
        
        // LB 헬스체크 주기(보통 5~10초)만큼 대기
        // → LB가 이 인스턴스를 제외할 시간을 줌
        try {
            Thread.sleep(10_000);
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        }
    }

    public boolean isShuttingDown() {
        return shuttingDown.get();
    }
}

sequenceDiagram
    participant K as Kubelet/LB
    participant A as App
    participant R as Readiness Probe

    K->>A: SIGTERM (종료 신호)
    A->>R: Readiness → DOWN
    K->>K: Health Check → Fail 감지
    K->>K: Target 제외 (새 트래픽 차단)
    
    Note over A: 기존 요청 처리 계속 (30s)
    
    A->>A: 모든 요청 완료
    A->>A: DB 커넥션 풀 정리
    A->>A: 스레드 풀 종료
    A->>K: 프로세스 종료 (exit 0)

preStop sleep (10s) + 앱 shutdown timeout (30s) < terminationGracePeriodSeconds (45s)

# Pod 설정에서의 통합
spec:
  terminationGracePeriodSeconds: 45
  containers:
    - name: app
      lifecycle:
        preStop:
          exec:
            command: ["sh", "-c", "sleep 10"]  # LB 제외 대기

# ❌ 절대 하지 마세요
livenessProbe:
  httpGet:
    path: /actuator/health    # DB, Redis, Kafka 전부 체크
    port: 8080

Redis 점검 (1분)
  → 100개 Pod Liveness 실패
  → kubelet이 100개 Pod 동시 재시작
  → 100개 Pod가 동시에 DB 커넥션 요청
  → DB max_connections 초과
  → 전체 서비스 장애 (복구 15분)

// ❌ 매 5초마다 full table scan
@GetMapping("/health")
public String health() {
    long count = orderRepository.count();  // SELECT COUNT(*) FROM orders
    return count > 0 ? "OK" : "FAIL";
}

readinessProbe:
  successThreshold: 1    # 한 번 성공하면 즉시 트래픽 복귀

헬스체크 Threshold: Fail 1회 → 즉시 제외
GC Pause: 전체 인스턴스에서 동시 발생 (JVM Major GC)

결과: LB에 Healthy 타겟이 0개
      → 503 Service Unavailable 폭발

제외 판단 시간 = failureThreshold × periodSeconds
복귀 판단 시간 = successThreshold × periodSeconds

권장값:
  제외: 3 × 10s = 30초 (빠르게 차단)
  복귀: 3 × 10s = 30초 (보수적으로 투입)

"제외는 빠를수록 좋고(사용자 에러 방지),
 복귀는 보수적일수록 좋다(확실히 나았을 때 투입)."

# Prometheus 메트릭 예시

# 1. 헬스체크 성공/실패 카운터
health_check_total{status="success", target="api-01"} 14400
health_check_total{status="failure", target="api-01"} 3

# 2. 헬스체크 응답 시간
health_check_duration_seconds{quantile="0.99"} 0.045

# 3. Target 상태 변경 이벤트
target_state_transitions_total{from="healthy", to="unhealthy"} 2

# 4. Healthy 인스턴스 비율
healthy_targets_ratio = healthy_count / total_count

Row 1: [Healthy Target Count] [Unhealthy Count] [Draining Count]
Row 2: [HC Response Time Heatmap] [State Transitions Timeline]
Row 3: [Per-Target Status Matrix] [Deregistration Duration P95]

Primary (ap-northeast-2):
  ALB → EC2 (정상 운영)
  Route 53 Health Check → ALB 엔드포인트 체크

Secondary (us-east-1):
  ALB → EC2 (대기)
  
Failover 조건: Primary HC 3회 연속 실패 → DNS TTL 만료 후 Secondary로 전환

# ALB + Target Group + Health Check 전체 구성

resource "aws_lb" "api" {
  name               = "api-alb"
  internal           = false
  load_balancer_type = "application"
  security_groups    = [aws_security_group.alb.id]
  subnets            = var.public_subnet_ids

  enable_deletion_protection = true

  tags = {
    Environment = "production"
  }
}

resource "aws_lb_target_group" "api" {
  name     = "api-tg"
  port     = 8080
  protocol = "HTTP"
  vpc_id   = var.vpc_id

  # Deregistration Delay: 배포 시 기존 요청 완료 대기
  deregistration_delay = 30

  health_check {
    enabled             = true
    path                = "/actuator/health/readiness"
    port                = "traffic-port"
    protocol            = "HTTP"
    healthy_threshold   = 3       # 3회 연속 성공 → Healthy
    unhealthy_threshold = 2       # 2회 연속 실패 → Unhealthy (빠른 제외)
    timeout             = 5
    interval            = 10
    matcher             = "200"
  }

  # Slow Start: 새 인스턴스에 점진적 트래픽 증가
  slow_start = 60

  stickiness {
    type            = "lb_cookie"
    cookie_duration = 86400
    enabled         = false       # API는 sticky 비권장
  }
}

resource "aws_lb_listener" "https" {
  load_balancer_arn = aws_lb.api.arn
  port              = 443
  protocol          = "HTTPS"
  ssl_policy        = "ELBSecurityPolicy-TLS13-1-2-2021-06"
  certificate_arn   = var.acm_certificate_arn

  default_action {
    type             = "forward"
    target_group_arn = aws_lb_target_group.api.arn
  }
}