// 라운드 로빈 의사 코드
servers = [server1, server2, server3]
current_index = 0

function get_next_server():
    server = servers[current_index]
    current_index = (current_index + 1) % servers.length
    return server

// IP 해시 의사 코드
function get_server_by_ip(client_ip):
    hash_value = hash(client_ip)
    server_index = hash_value % servers.length
    return servers[server_index]

// 예시
client_ip = "192.168.1.100"
hash("192.168.1.100") = 12345
12345 % 3 = 0
→ servers[0] 선택

# Nginx 로드 밸런싱 기본 설정
http {
    upstream backend {
        # 라운드 로빈 (기본값)
        server backend1.example.com;
        server backend2.example.com;
        server backend3.example.com;
    }
    
    server {
        listen 80;
        
        location / {
            proxy_pass http://backend;
            proxy_set_header Host $host;
            proxy_set_header X-Real-IP $remote_addr;
        }
    }
}

upstream backend {
    server backend1.example.com weight=5;
    server backend2.example.com weight=3;
    server backend3.example.com weight=2;
}

upstream backend {
    least_conn;
    server backend1.example.com;
    server backend2.example.com;
    server backend3.example.com;
}

upstream backend {
    ip_hash;
    server backend1.example.com;
    server backend2.example.com;
    server backend3.example.com;
}

# HAProxy 기본 설정
global
    maxconn 4096
    log 127.0.0.1 local0

defaults
    mode http
    timeout connect 5000ms
    timeout client 50000ms
    timeout server 50000ms

frontend http_front
    bind *:80
    default_backend http_back

backend http_back
    balance roundrobin
    option httpchk GET /health
    server server1 192.168.1.10:8080 check
    server server2 192.168.1.11:8080 check
    server server3 192.168.1.12:8080 check

# 라운드 로빈
balance roundrobin

# 최소 연결
balance leastconn

# 소스 IP 해시
balance source

# URI 해시 (같은 URL은 같은 서버로)
balance uri

# 헤더 기반 해시
balance hdr(User-Agent)

# Nginx 세션 고정 설정
upstream backend {
    ip_hash;  # IP 기반 세션 고정
    server backend1.example.com;
    server backend2.example.com;
}

# 또는 쿠키 기반
upstream backend {
    server backend1.example.com;
    server backend2.example.com;
    sticky cookie srv_id expires=1h domain=.example.com path=/;
}

// Node.js + Express + Redis 세션 공유 예시
const session = require('express-session');
const RedisStore = require('connect-redis')(session);
const redis = require('redis');

const redisClient = redis.createClient({
    host: 'redis-server.example.com',
    port: 6379
});

app.use(session({
    store: new RedisStore({ client: redisClient }),
    secret: 'your-secret-key',
    resave: false,
    saveUninitialized: false,
    cookie: { 
        secure: true,
        maxAge: 3600000  // 1시간
    }
}));

// JWT 토큰 생성 예시 (Node.js)
const jwt = require('jsonwebtoken');

// 로그인 시 토큰 발급
function login(user) {
    const token = jwt.sign(
        { 
            userId: user.id,
            username: user.username,
            role: user.role
        },
        'your-secret-key',
        { expiresIn: '1h' }
    );
    return token;
}

// 요청 시 토큰 검증
function verifyToken(token) {
    try {
        const decoded = jwt.verify(token, 'your-secret-key');
        return decoded;
    } catch(err) {
        return null;
    }
}

// Express.js 헬스 체크 엔드포인트 예시
app.get('/health', async (req, res) => {
    try {
        // 데이터베이스 연결 확인
        await db.ping();
        
        // Redis 연결 확인
        await redis.ping();
        
        // 메모리 사용량 확인
        const memUsage = process.memoryUsage();
        const memPercent = (memUsage.heapUsed / memUsage.heapTotal) * 100;
        
        if (memPercent > 90) {
            return res.status(503).json({
                status: 'unhealthy',
                reason: 'high memory usage'
            });
        }
        
        res.status(200).json({
            status: 'healthy',
            timestamp: new Date().toISOString(),
            uptime: process.uptime()
        });
    } catch (error) {
        res.status(503).json({
            status: 'unhealthy',
            error: error.message
        });
    }
});

# Nginx 자동 복구 설정
upstream backend {
    server backend1.example.com max_fails=3 fail_timeout=30s;
    server backend2.example.com max_fails=3 fail_timeout=30s;
    server backend3.example.com max_fails=3 fail_timeout=30s;
}

# 3번 실패하면 30초 동안 제외
# 30초 후 자동으로 다시 시도

# Nginx 콘텐츠 기반 라우팅
server {
    listen 80;
    server_name example.com;
    
    # 이미지 요청은 이미지 서버로
    location ~* \.(jpg|jpeg|png|gif|ico|svg)$ {
        proxy_pass http://image_servers;
    }
    
    # API 요청은 API 서버로
    location /api/ {
        proxy_pass http://api_servers;
    }
    
    # 정적 파일은 CDN으로
    location /static/ {
        proxy_pass http://cdn_servers;
    }
    
    # 나머지는 웹 서버로
    location / {
        proxy_pass http://web_servers;
    }
}

# Nginx 속도 제한 설정
http {
    # IP당 초당 10개 요청으로 제한
    limit_req_zone $binary_remote_addr zone=mylimit:10m rate=10r/s;
    
    # 대역폭 제한 (초당 1MB)
    limit_rate 1m;
    
    server {
        location /download/ {
            limit_req zone=mylimit burst=20;
            limit_rate 500k;  # 다운로드는 500KB/s로 제한
        }
        
        location /api/ {
            limit_req zone=mylimit burst=5 nodelay;
        }
    }
}

# Nginx 카나리 배포 (10% 트래픽만 신버전으로)
upstream backend_v1 {
    server backend-v1-1.example.com;
    server backend-v1-2.example.com;
}

upstream backend_v2 {
    server backend-v2-1.example.com;
}

split_clients "${remote_addr}" $backend_version {
    10%     v2;
    *       v1;
}

server {
    location / {
        proxy_pass http://backend_$backend_version;
    }
}

# Nginx GeoIP 기반 라우팅
http {
    geoip_country /usr/share/GeoIP/GeoIP.dat;
    
    map $geoip_country_code $backend {
        default     us_servers;
        KR          kr_servers;
        JP          jp_servers;
        CN          cn_servers;
        EU          eu_servers;
    }
    
    server {
        location / {
            proxy_pass http://$backend;
        }
    }
}

// Node.js 동적 가중치 조정 예시
class DynamicLoadBalancer {
    constructor() {
        this.servers = [
            { url: 'server1', weight: 5, currentLoad: 0 },
            { url: 'server2', weight: 5, currentLoad: 0 },
            { url: 'server3', weight: 5, currentLoad: 0 }
        ];
    }
    
    async updateWeights() {
        for (let server of this.servers) {
            const metrics = await this.getServerMetrics(server.url);
            
            // CPU 사용률에 따라 가중치 조정
            if (metrics.cpuUsage > 80) {
                server.weight = Math.max(1, server.weight - 1);
            } else if (metrics.cpuUsage < 50) {
                server.weight = Math.min(10, server.weight + 1);
            }
            
            server.currentLoad = metrics.cpuUsage;
        }
    }
    
    getNextServer() {
        // 가중치 기반 랜덤 선택
        const totalWeight = this.servers.reduce((sum, s) => sum + s.weight, 0);
        let random = Math.random() * totalWeight;
        
        for (let server of this.servers) {
            random -= server.weight;
            if (random <= 0) return server;
        }
    }
}

// 10초마다 가중치 업데이트
setInterval(() => balancer.updateWeights(), 10000);

// 서킷 브레이커 구현 예시
class CircuitBreaker {
    constructor(threshold = 5, timeout = 60000) {
        this.failureCount = 0;
        this.threshold = threshold;
        this.timeout = timeout;
        this.state = 'CLOSED';  // CLOSED, OPEN, HALF_OPEN
        this.nextAttempt = Date.now();
    }
    
    async call(fn) {
        if (this.state === 'OPEN') {
            if (Date.now() < this.nextAttempt) {
                throw new Error('Circuit breaker is OPEN');
            }
            this.state = 'HALF_OPEN';
        }
        
        try {
            const result = await fn();
            this.onSuccess();
            return result;
        } catch (error) {
            this.onFailure();
            throw error;
        }
    }
    
    onSuccess() {
        this.failureCount = 0;
        this.state = 'CLOSED';
    }
    
    onFailure() {
        this.failureCount++;
        if (this.failureCount >= this.threshold) {
            this.state = 'OPEN';
            this.nextAttempt = Date.now() + this.timeout;
        }
    }
}

// 사용 예시
const breaker = new CircuitBreaker(5, 60000);

async function callAPI() {
    try {
        return await breaker.call(() => fetch('http://api.example.com'));
    } catch (error) {
        // 폴백 로직
        return getCachedData();
    }
}

# Nginx 성능 최적화 설정 예시
http {
    # Keep-Alive 설정
    keepalive_timeout 65;
    keepalive_requests 100;
    
    # 압축 설정
    gzip on;
    gzip_vary on;
    gzip_min_length 1024;
    gzip_types text/plain text/css application/json application/javascript;
    
    # 버퍼 크기 설정
    client_body_buffer_size 128k;
    client_max_body_size 10m;
    
    # 프록시 설정
    proxy_buffering on;
    proxy_buffer_size 4k;
    proxy_buffers 8 4k;
    proxy_connect_timeout 60s;
    proxy_send_timeout 60s;
    proxy_read_timeout 60s;
    
    # 업스트림 Keep-Alive
    upstream backend {
        server backend1.example.com;
        server backend2.example.com;
        keepalive 32;
    }
    
    server {
        location / {
            proxy_pass http://backend;
            proxy_http_version 1.1;
            proxy_set_header Connection "";
        }
    }
}

// k6 부하 테스트 스크립트 예시
import http from 'k6/http';
import { check, sleep } from 'k6';

export let options = {
    stages: [
        { duration: '2m', target: 100 },   // 2분간 100명까지 증가
        { duration: '5m', target: 100 },   // 5분간 100명 유지
        { duration: '2m', target: 200 },   // 2분간 200명까지 증가
        { duration: '5m', target: 200 },   // 5분간 200명 유지
        { duration: '2m', target: 0 },     // 2분간 0명까지 감소
    ],
    thresholds: {
        http_req_duration: ['p(95)<500'],  // 95%의 요청이 500ms 이하
        http_req_failed: ['rate<0.01'],    // 에러율 1% 이하
    },
};

export default function() {
    let response = http.get('http://example.com/api/users');
    
    check(response, {
        'status is 200': (r) => r.status === 200,
        'response time < 500ms': (r) => r.timings.duration < 500,
    });
    
    sleep(1);
}

# Kubernetes Service 정의 (LoadBalancer 타입)
apiVersion: v1
kind: Service
metadata:
  name: my-service
spec:
  type: LoadBalancer
  selector:
    app: my-app
  ports:
    - protocol: TCP
      port: 80
      targetPort: 8080
  sessionAffinity: ClientIP  # 세션 고정
  sessionAffinityConfig:
    clientIP:
      timeoutSeconds: 3600

# Ingress 리소스 (L7 로드 밸런싱)
apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
  name: my-ingress
  annotations:
    nginx.ingress.kubernetes.io/rewrite-target: /
    nginx.ingress.kubernetes.io/ssl-redirect: "true"
spec:
  rules:
  - host: example.com
    http:
      paths:
      - path: /api
        pathType: Prefix
        backend:
          service:
            name: api-service
            port:
              number: 8080
      - path: /web
        pathType: Prefix
        backend:
          service:
            name: web-service
            port:
              number: 80

# Nginx SSL 종료 설정
server {
    listen 443 ssl http2;
    server_name example.com;
    
    # SSL 인증서 설정
    ssl_certificate /etc/nginx/ssl/example.com.crt;
    ssl_certificate_key /etc/nginx/ssl/example.com.key;
    
    # SSL 프로토콜 및 암호화 설정
    ssl_protocols TLSv1.2 TLSv1.3;
    ssl_ciphers HIGH:!aNULL:!MD5;
    ssl_prefer_server_ciphers on;
    
    # HSTS 헤더
    add_header Strict-Transport-Security "max-age=31536000" always;
    
    # 백엔드로 프록시 (HTTP)
    location / {
        proxy_pass http://backend;
        proxy_set_header X-Forwarded-Proto https;
        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
    }
}

# Nginx DDoS 방어 설정
http {
    # 연결 제한
    limit_conn_zone $binary_remote_addr zone=conn_limit:10m;
    limit_conn conn_limit 10;
    
    # 요청 속도 제한
    limit_req_zone $binary_remote_addr zone=req_limit:10m rate=10r/s;
    limit_req zone=req_limit burst=20 nodelay;
    
    # 타임아웃 설정
    client_body_timeout 10s;
    client_header_timeout 10s;
    
    server {
        # 특정 User-Agent 차단
        if ($http_user_agent ~* (bot|crawler|spider)) {
            return 403;
        }
        
        # 특정 국가 차단 (GeoIP 필요)
        if ($geoip_country_code = CN) {
            return 403;
        }
        
        location / {
            # 요청 크기 제한
            client_max_body_size 1m;
            
            proxy_pass http://backend;
        }
    }
}

# Nginx 기본 인증 설정
server {
    location /admin {
        auth_basic "Restricted Area";
        auth_basic_user_file /etc/nginx/.htpasswd;
        
        proxy_pass http://backend;
    }
    
    # JWT 토큰 검증 (lua 모듈 필요)
    location /api {
        access_by_lua_block {
            local jwt = require "resty.jwt"
            local token = ngx.var.http_authorization
            
            if not token then
                ngx.status = 401
                ngx.say("Missing token")
                return ngx.exit(401)
            end
            
            local jwt_obj = jwt:verify("your-secret", token)
            if not jwt_obj.verified then
                ngx.status = 401
                ngx.say("Invalid token")
                return ngx.exit(401)
            end
        }
        
        proxy_pass http://backend;
    }
}

# 1. 로드 밸런서 로그 확인
tail -f /var/log/nginx/access.log
tail -f /var/log/nginx/error.log

# 2. 서버별 트래픽 분포 확인
awk '{print $1}' /var/log/nginx/access.log | sort | uniq -c | sort -rn

# 3. 응답 시간 분석
awk '{print $NF}' /var/log/nginx/access.log | \
  awk '{sum+=$1; count++} END {print "Average:", sum/count}'

# 4. 에러율 확인
awk '{print $9}' /var/log/nginx/access.log | \
  grep -E "^[45]" | wc -l

# 5. 실시간 연결 수 확인
netstat -an | grep :80 | wc -l