# /etc/nginx/nginx.conf
# Nginx ロードバランサー基本設定
 
# ワーカープロセス数: CPU コア数に合わせる
worker_processes auto;
 
# イベント処理設定
events {
    worker_connections 65536;   # 1 ワーカーあたりの最大接続数
    use epoll;                  # Linux 環境では epoll を使用
    multi_accept on;            # 複数接続の同時受付
}
 
http {
    # ログフォーマット: アップストリームの情報を含む
    log_format upstream_log '$remote_addr - $remote_user [$time_local] '
                           '"$request" $status $body_bytes_sent '
                           '"$http_referer" "$http_user_agent" '
                           'upstream: $upstream_addr '
                           'response_time: $upstream_response_time '
                           'status: $upstream_status';
 
    access_log /var/log/nginx/access.log upstream_log;
 
    # アップストリーム定義: バックエンドサーバー群
    upstream backend_servers {
        # デフォルトはラウンドロビン
        server 10.0.1.1:8080;
        server 10.0.1.2:8080;
        server 10.0.1.3:8080;
    }
 
    server {
        listen 80;
        server_name api.example.com;
 
        location / {
            proxy_pass http://backend_servers;
 
            # プロキシヘッダーの設定
            proxy_set_header Host $host;
            proxy_set_header X-Real-IP $remote_addr;
            proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
            proxy_set_header X-Forwarded-Proto $scheme;
 
            # タイムアウト設定
            proxy_connect_timeout 10s;
            proxy_send_timeout 30s;
            proxy_read_timeout 30s;
 
            # バッファリング設定
            proxy_buffering on;
            proxy_buffer_size 4k;
            proxy_buffers 8 4k;
        }
    }
}

# /etc/nginx/conf.d/load-balancer.conf
# 高度なロードバランサー設定
 
# 加重ラウンドロビン + バックアップサーバー
upstream api_servers {
    # 加重ラウンドロビン
    server 10.0.1.1:8080 weight=5 max_fails=3 fail_timeout=30s;
    server 10.0.1.2:8080 weight=3 max_fails=3 fail_timeout=30s;
    server 10.0.1.3:8080 weight=2 max_fails=3 fail_timeout=30s;
 
    # バックアップサーバー（他が全滅時のみ使用）
    server 10.0.1.99:8080 backup;
 
    # パッシブヘルスチェック設定:
    #   max_fails=3:    3 回連続失敗で除外
    #   fail_timeout=30s: 30 秒後に再度チェック
 
    # 接続キープアライブ
    keepalive 32;
    keepalive_timeout 60s;
    keepalive_requests 1000;
}
 
# 最小接続数アルゴリズム
upstream websocket_servers {
    least_conn;
    server 10.0.2.1:8080;
    server 10.0.2.2:8080;
    server 10.0.2.3:8080;
}
 
# IP ハッシュ（セッション固定）
upstream session_servers {
    ip_hash;
    server 10.0.3.1:8080;
    server 10.0.3.2:8080;
    server 10.0.3.3:8080;
 
    # サーバーを一時的に除外（ハッシュ値を維持）
    # server 10.0.3.4:8080 down;
}
 
# SSL 終端 + パスベースルーティング
server {
    listen 443 ssl http2;
    server_name api.example.com;
 
    # SSL 証明書
    ssl_certificate     /etc/ssl/certs/api.example.com.crt;
    ssl_certificate_key /etc/ssl/private/api.example.com.key;
 
    # SSL セキュリティ設定
    ssl_protocols TLSv1.2 TLSv1.3;
    ssl_ciphers ECDHE-ECDSA-AES128-GCM-SHA256:ECDHE-RSA-AES128-GCM-SHA256;
    ssl_prefer_server_ciphers on;
    ssl_session_cache shared:SSL:10m;
    ssl_session_timeout 1d;
    ssl_session_tickets off;
 
    # HSTS ヘッダー
    add_header Strict-Transport-Security "max-age=31536000; includeSubDomains" always;
 
    # パスベースルーティング
    location /api/ {
        proxy_pass http://api_servers;
        proxy_http_version 1.1;
        proxy_set_header Connection "";
        proxy_set_header Host $host;
        proxy_set_header X-Real-IP $remote_addr;
        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
        proxy_set_header X-Forwarded-Proto $scheme;
    }
 
    # WebSocket サーバー
    location /ws/ {
        proxy_pass http://websocket_servers;
        proxy_http_version 1.1;
        proxy_set_header Upgrade $http_upgrade;
        proxy_set_header Connection "upgrade";
        proxy_set_header Host $host;
        proxy_read_timeout 3600s;  # WebSocket 用に長めのタイムアウト
    }
 
    # ヘルスチェックエンドポイント（LB 自体のヘルス）
    location /health {
        access_log off;
        return 200 '{"status": "healthy"}';
        add_header Content-Type application/json;
    }
 
    # 静的ファイル（直接配信）
    location /static/ {
        alias /var/www/static/;
        expires 30d;
        add_header Cache-Control "public, immutable";
    }
}
 
# HTTP → HTTPS リダイレクト
server {
    listen 80;
    server_name api.example.com;
    return 301 https://$server_name$request_uri;
}

# /etc/haproxy/haproxy.cfg
# HAProxy 基本設定
 
#--------------------------------------------------
# グローバル設定
#--------------------------------------------------
global
    log         /dev/log local0
    log         /dev/log local1 notice
    chroot      /var/lib/haproxy
    pidfile     /var/run/haproxy.pid
    maxconn     100000              # 最大同時接続数
    user        haproxy
    group       haproxy
    daemon
 
    # SSL/TLS 設定
    ssl-default-bind-ciphers ECDHE-ECDSA-AES128-GCM-SHA256:ECDHE-RSA-AES128-GCM-SHA256
    ssl-default-bind-options no-sslv3 no-tlsv10 no-tlsv11
 
    # パフォーマンスチューニング
    tune.ssl.default-dh-param 2048
    tune.bufsize 32768
    tune.maxrewrite 1024
 
#--------------------------------------------------
# デフォルト設定
#--------------------------------------------------
defaults
    log     global
    mode    http                    # L7 モード（tcp で L4）
    option  httplog
    option  dontlognull
    option  http-server-close       # サーバー側のコネクション再利用
    option  forwardfor              # X-Forwarded-For ヘッダー追加
    option  redispatch              # サーバー障害時に別サーバーへ再送
 
    retries                 3       # 再試行回数
    timeout http-request    10s     # リクエスト受信タイムアウト
    timeout queue           1m      # キュー待ちタイムアウト
    timeout connect         10s     # バックエンド接続タイムアウト
    timeout client          1m      # クライアント側タイムアウト
    timeout server          1m      # サーバー側タイムアウト
    timeout http-keep-alive 10s     # Keep-Alive タイムアウト
    timeout check           10s     # ヘルスチェックタイムアウト
 
    # エラーページ
    errorfile 400 /etc/haproxy/errors/400.http
    errorfile 403 /etc/haproxy/errors/403.http
    errorfile 408 /etc/haproxy/errors/408.http
    errorfile 500 /etc/haproxy/errors/500.http
    errorfile 502 /etc/haproxy/errors/502.http
    errorfile 503 /etc/haproxy/errors/503.http
    errorfile 504 /etc/haproxy/errors/504.http
 
#--------------------------------------------------
# 統計ダッシュボード
#--------------------------------------------------
listen stats
    bind *:8404
    mode http
    stats enable
    stats uri /stats
    stats refresh 10s
    stats admin if LOCALHOST          # localhost からのみ管理操作可
    stats auth admin:SecureP@ss123    # 認証設定
 
#--------------------------------------------------
# フロントエンド: HTTPS 受付
#--------------------------------------------------
frontend https_front
    bind *:443 ssl crt /etc/ssl/certs/example.com.pem alpn h2,http/1.1
    bind *:80
 
    # HTTP → HTTPS リダイレクト
    http-request redirect scheme https unless { ssl_fc }
 
    # セキュリティヘッダー
    http-response set-header Strict-Transport-Security "max-age=31536000"
    http-response set-header X-Content-Type-Options nosniff
    http-response set-header X-Frame-Options DENY
 
    # ACL（アクセス制御リスト）によるルーティング
    acl is_api     path_beg /api/
    acl is_ws      path_beg /ws/
    acl is_static  path_beg /static/
    acl is_admin   hdr(host) -i admin.example.com
    acl is_health  path /health
 
    # レートリミット
    stick-table type ip size 100k expire 30s store http_req_rate(10s)
    http-request track-sc0 src
    http-request deny deny_status 429 if { sc_http_req_rate(0) gt 100 }
 
    # バックエンド振り分け
    use_backend api_backend     if is_api
    use_backend ws_backend      if is_ws
    use_backend static_backend  if is_static
    use_backend admin_backend   if is_admin
    use_backend health_backend  if is_health
    default_backend web_backend
 
#--------------------------------------------------
# バックエンド: API サーバー
#--------------------------------------------------
backend api_backend
    balance roundrobin
    option httpchk GET /health HTTP/1.1\r\nHost:\ api.internal
    http-check expect status 200
 
    # Connection Draining: 除外時に処理中リクエストを待つ
    default-server inter 5s fall 3 rise 2 slowstart 60s
 
    server api1 10.0.1.1:8080 check weight 5
    server api2 10.0.1.2:8080 check weight 3
    server api3 10.0.1.3:8080 check weight 2
 
#--------------------------------------------------
# バックエンド: WebSocket サーバー
#--------------------------------------------------
backend ws_backend
    balance leastconn
    option httpchk GET /health
 
    # WebSocket 用タイムアウト延長
    timeout server 3600s
    timeout tunnel 3600s
 
    server ws1 10.0.2.1:8080 check
    server ws2 10.0.2.2:8080 check
    server ws3 10.0.2.3:8080 check
 
#--------------------------------------------------
# バックエンド: 静的ファイルサーバー
#--------------------------------------------------
backend static_backend
    balance roundrobin
    option httpchk GET /health
 
    http-response set-header Cache-Control "public, max-age=2592000"
 
    server static1 10.0.3.1:80 check
    server static2 10.0.3.2:80 check
 
#--------------------------------------------------
# バックエンド: 管理画面
#--------------------------------------------------
backend admin_backend
    balance roundrobin
 
    # IP 制限
    acl allowed_ip src 10.0.0.0/8 172.16.0.0/12
    http-request deny unless allowed_ip
 
    server admin1 10.0.4.1:8080 check
    server admin2 10.0.4.2:8080 check
 
#--------------------------------------------------
# バックエンド: Web サーバー（デフォルト）
#--------------------------------------------------
backend web_backend
    balance roundrobin
    option httpchk GET /health
    cookie SERVERID insert indirect nocache
 
    server web1 10.0.5.1:8080 check cookie web1
    server web2 10.0.5.2:8080 check cookie web2
    server web3 10.0.5.3:8080 check cookie web3
 
#--------------------------------------------------
# バックエンド: ヘルスチェック
#--------------------------------------------------
backend health_backend
    mode http
    http-request return status 200 content-type application/json \
        lf-string '{"status":"healthy","timestamp":"%[date]"}'

# /etc/haproxy/haproxy-l4.cfg
# L4（TCP）モード設定例: データベースプロキシ
 
defaults
    mode tcp
    log global
    option tcplog
    timeout connect 10s
    timeout client  30m
    timeout server  30m
 
# PostgreSQL プライマリ
frontend pgsql_front
    bind *:5432
    default_backend pgsql_backend
 
backend pgsql_backend
    balance leastconn
    option pgsql-check user haproxy  # PostgreSQL 固有のヘルスチェック
 
    server pgsql1 10.0.10.1:5432 check inter 3s fall 3 rise 2
    server pgsql2 10.0.10.2:5432 check inter 3s fall 3 rise 2 backup
 
# Redis Sentinel 構成
frontend redis_front
    bind *:6379
    default_backend redis_backend
 
backend redis_backend
    balance first                    # 最初の正常なサーバーへ
    option tcp-check
    tcp-check send PING\r\n
    tcp-check expect string +PONG
 
    server redis1 10.0.11.1:6379 check inter 1s fall 3 rise 2
    server redis2 10.0.11.2:6379 check inter 1s fall 3 rise 2
    server redis3 10.0.11.3:6379 check inter 1s fall 3 rise 2

# Python (FastAPI) でのヘルスチェック実装例
from fastapi import FastAPI, Response, status
from datetime import datetime, timezone
import asyncpg
import aioredis
import time
 
app = FastAPI()
start_time = time.time()
 
# === Liveness Check（L1: プロセスは生きているか）===
@app.get("/healthz")
async def liveness():
    """
    Liveness probe: アプリケーションプロセスの生存確認。
    常に 200 を返す（デッドロック検出を除く）。
    Kubernetes の livenessProbe や LB の基本ヘルスチェックに使用。
    """
    return {"status": "alive"}
 
 
# === Readiness Check（L2: リクエストを受ける準備ができているか）===
@app.get("/ready")
async def readiness():
    """
    Readiness probe: サービスがリクエストを処理可能か確認。
    起動直後の初期化完了チェックにも使用。
    LB のヘルスチェックに推奨。
    """
    checks = {}
    is_ready = True
 
    # データベース接続チェック
    try:
        conn = await asyncpg.connect(
            host="db.internal", port=5432,
            user="app", password="secret", database="mydb",
            timeout=3
        )
        await conn.fetchval("SELECT 1")
        await conn.close()
        checks["database"] = "connected"
    except Exception as e:
        checks["database"] = f"error: {str(e)}"
        is_ready = False
 
    # Redis 接続チェック
    try:
        redis = aioredis.from_url("redis://cache.internal:6379")
        await redis.ping()
        await redis.close()
        checks["cache"] = "connected"
    except Exception as e:
        checks["cache"] = f"error: {str(e)}"
        is_ready = False
 
    uptime_seconds = int(time.time() - start_time)
 
    response_data = {
        "status": "ready" if is_ready else "not_ready",
        "checks": checks,
        "uptime_seconds": uptime_seconds,
        "timestamp": datetime.now(timezone.utc).isoformat()
    }
 
    if not is_ready:
        return Response(
            content=json.dumps(response_data),
            status_code=status.HTTP_503_SERVICE_UNAVAILABLE,
            media_type="application/json"
        )
    return response_data
 
 
# === Deep Health Check（L3: 全依存サービスの状態）===
@app.get("/health/deep")
async def deep_health():
    """
    Deep health check: 全依存サービスの詳細な状態を返す。
    監視システムや運用ダッシュボードから呼び出す。
    LB のヘルスチェックには使用しない（カスケード障害の原因になる）。
    """
    checks = {}
 
    # 各依存サービスのチェック（省略: 上記と同様）
    # ...
 
    return {
        "status": "healthy",
        "version": "2.3.1",
        "checks": checks,
        "system": {
            "uptime_seconds": int(time.time() - start_time),
            "memory_usage_mb": get_memory_usage(),
            "cpu_percent": get_cpu_usage()
        }
    }

# terraform/modules/alb/main.tf
# AWS ALB + Target Group + Listener の構成
 
# --- ALB 本体 ---
resource "aws_lb" "main" {
  name               = "app-alb"
  internal           = false
  load_balancer_type = "application"
  security_groups    = [aws_security_group.alb_sg.id]
  subnets            = var.public_subnet_ids
 
  enable_deletion_protection = true    # 誤削除防止
  enable_http2              = true     # HTTP/2 有効化
  idle_timeout              = 60       # アイドルタイムアウト（秒）
  drop_invalid_header_fields = true    # 不正ヘッダー破棄
 
  access_logs {
    bucket  = aws_s3_bucket.alb_logs.id
    prefix  = "alb"
    enabled = true
  }
 
  tags = {
    Environment = var.environment
    Service     = "web-app"
  }
}
 
# --- ALB セキュリティグループ ---
resource "aws_security_group" "alb_sg" {
  name_prefix = "alb-sg-"
  vpc_id      = var.vpc_id
 
  ingress {
    description = "HTTPS from Internet"
    from_port   = 443
    to_port     = 443
    protocol    = "tcp"
    cidr_blocks = ["0.0.0.0/0"]
  }
 
  ingress {
    description = "HTTP from Internet (redirect to HTTPS)"
    from_port   = 80
    to_port     = 80
    protocol    = "tcp"
    cidr_blocks = ["0.0.0.0/0"]
  }
 
  egress {
    from_port   = 0
    to_port     = 0
    protocol    = "-1"
    cidr_blocks = ["0.0.0.0/0"]
  }
}
 
# --- ターゲットグループ: API ---
resource "aws_lb_target_group" "api" {
  name                 = "api-tg"
  port                 = 8080
  protocol             = "HTTP"
  vpc_id               = var.vpc_id
  target_type          = "ip"          # Fargate の場合は ip
  deregistration_delay = 30            # ドレイニング待機時間
 
  health_check {
    enabled             = true
    path                = "/health"
    port                = "traffic-port"
    protocol            = "HTTP"
    healthy_threshold   = 2
    unhealthy_threshold = 3
    timeout             = 5
    interval            = 10
    matcher             = "200"
  }
 
  stickiness {
    type            = "lb_cookie"
    cookie_duration = 3600             # 1 時間
    enabled         = false
  }
 
  # スロースタート: 新規ターゲットに段階的にトラフィック増加
  slow_start = 60                      # 60 秒かけて 100% に到達
 
  tags = {
    Service = "api"
  }
}
 
# --- ターゲットグループ: WebSocket ---
resource "aws_lb_target_group" "websocket" {
  name        = "ws-tg"
  port        = 8081
  protocol    = "HTTP"
  vpc_id      = var.vpc_id
  target_type = "instance"
 
  health_check {
    enabled             = true
    path                = "/ws/health"
    protocol            = "HTTP"
    healthy_threshold   = 2
    unhealthy_threshold = 2
    timeout             = 3
    interval            = 5
    matcher             = "200"
  }
 
  stickiness {
    type            = "lb_cookie"
    cookie_duration = 86400
    enabled         = true             # WebSocket はスティッキー推奨
  }
}
 
# --- HTTPS リスナー ---
resource "aws_lb_listener" "https" {
  load_balancer_arn = aws_lb.main.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
  }
}
 
# --- HTTP → HTTPS リダイレクト ---
resource "aws_lb_listener" "http_redirect" {
  load_balancer_arn = aws_lb.main.arn
  port              = 80
  protocol          = "HTTP"
 
  default_action {
    type = "redirect"
    redirect {
      port        = "443"
      protocol    = "HTTPS"
      status_code = "HTTP_301"
    }
  }
}
 
# --- リスナールール: WebSocket パス ---
resource "aws_lb_listener_rule" "websocket" {
  listener_arn = aws_lb_listener.https.arn
  priority     = 10
 
  action {
    type             = "forward"
    target_group_arn = aws_lb_target_group.websocket.arn
  }
 
  condition {
    path_pattern {
      values = ["/ws/*"]
    }
  }
}
 
# --- リスナールール: API バージョニング ---
resource "aws_lb_listener_rule" "api_v2" {
  listener_arn = aws_lb_listener.https.arn
  priority     = 20
 
  action {
    type             = "forward"
    target_group_arn = aws_lb_target_group.api_v2.arn
  }
 
  condition {
    http_header {
      http_header_name = "X-Api-Version"
      values           = ["v2"]
    }
  }
}
 
# --- WAF 連携 ---
resource "aws_wafv2_web_acl_association" "alb" {
  resource_arn = aws_lb.main.arn
  web_acl_arn  = var.waf_web_acl_arn
}

# terraform/modules/nlb/main.tf
# AWS NLB（L4）の構成
 
resource "aws_lb" "nlb" {
  name               = "app-nlb"
  internal           = false
  load_balancer_type = "network"
  subnets            = var.public_subnet_ids
 
  enable_deletion_protection       = true
  enable_cross_zone_load_balancing = true  # クロスゾーン LB
 
  # 静的 IP（Elastic IP）の割り当て
  dynamic "subnet_mapping" {
    for_each = var.public_subnet_ids
    content {
      subnet_id     = subnet_mapping.value
      allocation_id = var.eip_allocation_ids[subnet_mapping.key]
    }
  }
 
  tags = {
    Environment = var.environment
    Service     = "game-server"
  }
}
 
# --- ターゲットグループ: TCP ---
resource "aws_lb_target_group" "tcp" {
  name        = "game-tcp-tg"
  port        = 7777
  protocol    = "TCP"
  vpc_id      = var.vpc_id
  target_type = "instance"
 
  # TCP ヘルスチェック
  health_check {
    enabled             = true
    port                = "traffic-port"
    protocol            = "TCP"
    healthy_threshold   = 2
    unhealthy_threshold = 2
    interval            = 10
  }
 
  # コネクション維持設定
  connection_termination = false
  deregistration_delay   = 300
 
  # Proxy Protocol v2（クライアント IP 保持）
  proxy_protocol_v2 = true
 
  stickiness {
    enabled = true
    type    = "source_ip"
  }
}
 
# --- UDP ターゲットグループ（ゲームサーバー等）---
resource "aws_lb_target_group" "udp" {
  name        = "game-udp-tg"
  port        = 7778
  protocol    = "UDP"
  vpc_id      = var.vpc_id
  target_type = "instance"
 
  health_check {
    enabled             = true
    port                = 7777         # TCP ポートでヘルスチェック
    protocol            = "TCP"
    healthy_threshold   = 2
    unhealthy_threshold = 2
    interval            = 10
  }
}
 
# --- TCP リスナー ---
resource "aws_lb_listener" "tcp" {
  load_balancer_arn = aws_lb.nlb.arn
  port              = 7777
  protocol          = "TCP"
 
  default_action {
    type             = "forward"
    target_group_arn = aws_lb_target_group.tcp.arn
  }
}
 
# --- TLS リスナー（NLB での TLS 終端）---
resource "aws_lb_listener" "tls" {
  load_balancer_arn = aws_lb.nlb.arn
  port              = 443
  protocol          = "TLS"
  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.tcp.arn
  }
}

# /etc/keepalived/keepalived.conf
# Keepalived VRRP 設定（アクティブ-スタンバイ）
 
# --- グローバル設定 ---
global_defs {
    router_id LB1                    # ノード識別子
    script_user root
    enable_script_security
 
    notification_email {
        ops@example.com              # 障害通知メール
    }
    notification_email_from keepalived@example.com
    smtp_server smtp.example.com
    smtp_connect_timeout 30
}
 
# --- HAProxy の生存確認スクリプト ---
vrrp_script check_haproxy {
    script "/usr/bin/killall -0 haproxy"   # プロセス存在確認
    interval 2                              # 2 秒間隔でチェック
    weight -20                              # 失敗時に優先度を -20
    fall 3                                  # 3 回連続失敗で異常判定
    rise 2                                  # 2 回連続成功で正常復帰
}
 
# --- VRRP インスタンス ---
vrrp_instance VI_1 {
    state MASTER                             # 初期状態: MASTER
    interface eth0                           # 監視するインターフェース
    virtual_router_id 51                     # VRRP グループ ID（同一でペア）
    priority 100                             # 優先度（大きい方が MASTER）
    advert_int 1                             # VRRP 広告間隔（秒）
 
    authentication {
        auth_type PASS
        auth_pass secretpass                 # VRRP 認証パスワード
    }
 
    # 仮想 IP アドレス
    virtual_ipaddress {
        10.0.0.100/24 dev eth0               # クライアント向け VIP
    }
 
    # ヘルスチェックスクリプトの監視
    track_script {
        check_haproxy
    }
 
    # 状態遷移時の通知スクリプト
    notify_master "/etc/keepalived/notify.sh MASTER"
    notify_backup "/etc/keepalived/notify.sh BACKUP"
    notify_fault  "/etc/keepalived/notify.sh FAULT"
}

#!/bin/bash
# /etc/keepalived/notify.sh
# VRRP 状態遷移時の通知スクリプト
 
STATE=$1
TIMESTAMP=$(date '+%Y-%m-%d %H:%M:%S')
 
case $STATE in
    "MASTER")
        echo "$TIMESTAMP: Transitioned to MASTER" >> /var/log/keepalived-notify.log
        # Slack/PagerDuty 等への通知
        curl -s -X POST "https://hooks.slack.com/services/xxx" \
            -H 'Content-Type: application/json' \
            -d "{\"text\": \"$(hostname) is now MASTER at $TIMESTAMP\"}"
        ;;
    "BACKUP")
        echo "$TIMESTAMP: Transitioned to BACKUP" >> /var/log/keepalived-notify.log
        ;;
    "FAULT")
        echo "$TIMESTAMP: FAULT detected" >> /var/log/keepalived-notify.log
        curl -s -X POST "https://hooks.slack.com/services/xxx" \
            -H 'Content-Type: application/json' \
            -d "{\"text\": \"ALERT: $(hostname) entered FAULT state at $TIMESTAMP\"}"
        ;;
esac

# Nginx の例
upstream backend {
    server 10.0.1.1:8080;
    server 10.0.1.2:8080;
    server 10.0.1.3:8080;
    sticky cookie srv_id expires=1h domain=.example.com path=/;
}

backend app_backend
    balance source  # 送信元IPでハッシュ
    server app1 10.0.1.1:8080
    server app2 10.0.1.2:8080
    server app3 10.0.1.3:8080

// JWT にサーバーIDを含める（非推奨）
const token = jwt.sign({ userId: 123, serverId: 'app-2' }, secret);
 
// 推奨: JWT を使うが外部ストアでセッション管理
const token = jwt.sign({ userId: 123, sessionId: 'uuid' }, secret);
// sessionId で Redis からセッション情報を取得