로드 밸런싱

# /etc/haproxy/haproxy.cfg - HAProxy 설정

global
    log /dev/log local0
    maxconn 4096
    user haproxy
    group haproxy
    daemon

defaults
    mode http
    log global
    option httplog
    option dontlognull
    timeout connect 5s
    timeout client 30s
    timeout server 30s
    retries 3

# 프론트엔드: 클라이언트 요청 수신
frontend http_front
    bind *:80
    bind *:443 ssl crt /etc/ssl/certs/server.pem

    # ACL 기반 라우팅
    acl is_api path_beg /api
    acl is_static path_end .css .js .png .jpg

    use_backend api_servers if is_api
    use_backend static_servers if is_static
    default_backend web_servers

# 백엔드: 실제 서버 그룹
backend web_servers
    balance roundrobin           # 알고리즘: roundrobin, leastconn, source
    option httpchk GET /health   # HTTP Health Check
    http-check expect status 200

    server web1 10.0.0.1:8080 check weight 3
    server web2 10.0.0.2:8080 check weight 2
    server web3 10.0.0.3:8080 check backup   # 백업 서버

backend api_servers
    balance leastconn
    option httpchk GET /api/health

    # Sticky Session (쿠키 기반)
    cookie SERVERID insert indirect nocache
    server api1 10.0.0.10:8080 check cookie s1
    server api2 10.0.0.11:8080 check cookie s2

# 모니터링 대시보드
listen stats
    bind *:8404
    stats enable
    stats uri /stats
    stats refresh 10s
    stats auth admin:password

# 간단한 로드 밸런서 구현 예제 (Python)
import random
import time
from collections import defaultdict
from typing import List, Optional

class Server:
    def __init__(self, host: str, port: int, weight: int = 1):
        self.host = host
        self.port = port
        self.weight = weight
        self.connections = 0
        self.healthy = True
        self.response_times = []

    @property
    def address(self) -> str:
        return f"{self.host}:{self.port}"

class LoadBalancer:
    def __init__(self, servers: List[Server], algorithm: str = "round_robin"):
        self.servers = servers
        self.algorithm = algorithm
        self.current_index = 0
        self.weighted_index = 0

    def get_healthy_servers(self) -> List[Server]:
        return [s for s in self.servers if s.healthy]

    def round_robin(self) -> Optional[Server]:
        """순차적으로 서버 선택"""
        healthy = self.get_healthy_servers()
        if not healthy:
            return None
        server = healthy[self.current_index % len(healthy)]
        self.current_index += 1
        return server

    def least_connections(self) -> Optional[Server]:
        """연결 수가 가장 적은 서버 선택"""
        healthy = self.get_healthy_servers()
        if not healthy:
            return None
        return min(healthy, key=lambda s: s.connections)

    def ip_hash(self, client_ip: str) -> Optional[Server]:
        """IP 기반 해시로 서버 선택 (Sticky Session)"""
        healthy = self.get_healthy_servers()
        if not healthy:
            return None
        index = hash(client_ip) % len(healthy)
        return healthy[index]

    def weighted_round_robin(self) -> Optional[Server]:
        """가중치 기반 라운드 로빈"""
        healthy = self.get_healthy_servers()
        if not healthy:
            return None

        # 가중치 리스트 생성
        weighted_list = []
        for server in healthy:
            weighted_list.extend([server] * server.weight)

        server = weighted_list[self.weighted_index % len(weighted_list)]
        self.weighted_index += 1
        return server

    def get_server(self, client_ip: str = None) -> Optional[Server]:
        """알고리즘에 따라 서버 반환"""
        if self.algorithm == "round_robin":
            return self.round_robin()
        elif self.algorithm == "least_conn":
            return self.least_connections()
        elif self.algorithm == "ip_hash" and client_ip:
            return self.ip_hash(client_ip)
        elif self.algorithm == "weighted":
            return self.weighted_round_robin()
        return self.round_robin()

# 사용 예제
servers = [
    Server("10.0.0.1", 8080, weight=3),
    Server("10.0.0.2", 8080, weight=2),
    Server("10.0.0.3", 8080, weight=1),
]

lb = LoadBalancer(servers, algorithm="weighted")

# 10번 요청 분산 시뮬레이션
for i in range(10):
    server = lb.get_server()
    print(f"Request {i+1} → {server.address}")