def estimate_gpu_requirements(
    model_params_b: float,       # 模型参数量（B = 十亿）
    concurrent_requests: int,    # 目标并发数
    avg_output_tokens: int,      # 平均输出 token 数
    target_throughput_tps: float, # 目标吞吐量（tokens/s）
    target_p99_latency_s: float, # 目标 P99 延迟（秒）
) -> dict:
    """估算 GPU 需求"""
    
    # 模型权重大小（FP16）
    model_size_gb = model_params_b * 2
    
    # 每个并发请求的 KV Cache（估算）
    kv_cache_per_req_gb = model_params_b * 0.02 * 8  # 粗略估算
    
    # 单卡可用显存（A100 80GB，扣除模型权重和开销）
    gpu_memory_gb = 80
    overhead_gb = 3
    available_for_kv = gpu_memory_gb * 0.9 - model_size_gb / 1 - overhead_gb
    
    # 需要的 GPU 数（考虑模型权重）
    import math
    min_gpus_for_model = math.ceil(model_size_gb / (gpu_memory_gb * 0.9 - overhead_gb))
    
    # 需要的 GPU 数（考虑并发）
    max_concurrent_per_gpu = int(available_for_kv / kv_cache_per_req_gb) if available_for_kv > 0 else 0
    min_gpus_for_concurrent = math.ceil(concurrent_requests / max(max_concurrent_per_gpu, 1))
    
    # 需要的 GPU 数（考虑吞吐量）
    throughput_per_gpu = 500  # 粗略估算：单卡约 500-2000 tok/s
    min_gpus_for_throughput = math.ceil(target_throughput_tps / throughput_per_gpu)
    
    recommended_gpus = max(min_gpus_for_model, min_gpus_for_concurrent, min_gpus_for_throughput)
    
    return {
        "model_size_gb": model_size_gb,
        "min_gpus_for_model": min_gpus_for_model,
        "min_gpus_for_concurrent": min_gpus_for_concurrent,
        "min_gpus_for_throughput": min_gpus_for_throughput,
        "recommended_gpus": recommended_gpus,
        "max_concurrent_per_gpu": max_concurrent_per_gpu,
    }

# 示例
result = estimate_gpu_requirements(
    model_params_b=72,
    concurrent_requests=50,
    avg_output_tokens=256,
    target_throughput_tps=2000,
    target_p99_latency_s=5,
)
print(result)

# 1. 设置 API Key
vllm serve model --api-key sk-xxxxxxxxxxxx

# 2. 限制监听地址（生产环境不要用 0.0.0.0）
vllm serve model --host 127.0.0.1

# 3. 使用 Nginx 反向代理 + TLS

# nginx-ssl.conf
server {
    listen 443 ssl;
    server_name llm.example.com;
    
    ssl_certificate /etc/ssl/certs/llm.crt;
    ssl_certificate_key /etc/ssl/private/llm.key;
    
    # TLS 配置
    ssl_protocols TLSv1.2 TLSv1.3;
    ssl_ciphers HIGH:!aNULL:!MD5;
    
    # 限流
    limit_req_zone $binary_remote_addr zone=api:10m rate=10r/s;
    
    location /v1/ {
        limit_req zone=api burst=20 nodelay;
        
        # API Key 验证
        if ($http_authorization != "Bearer sk-your-secret-key") {
            return 401;
        }
        
        proxy_pass http://127.0.0.1:8000/v1/;
        proxy_buffering off;
        proxy_read_timeout 300s;
    }
}

# input_validation.py
"""API 输入验证中间件"""

from fastapi import FastAPI, HTTPException
from pydantic import BaseModel, validator

class ChatRequest(BaseModel):
    model: str
    messages: list
    max_tokens: int = 256
    temperature: float = 0.7
    
    @validator('max_tokens')
    def validate_max_tokens(cls, v):
        if v > 4096:
            raise ValueError('max_tokens 不能超过 4096')
        if v < 1:
            raise ValueError('max_tokens 必须大于 0')
        return v
    
    @validator('messages')
    def validate_messages(cls, v):
        if len(v) > 100:
            raise ValueError('消息轮次不能超过 100')
        for msg in v:
            if len(msg.get('content', '')) > 50000:
                raise ValueError('单条消息不能超过 50000 字符')
        return v

# 1. 使用防火墙限制访问
sudo ufw default deny incoming
sudo ufw allow from 10.0.0.0/8 to any port 8000
sudo ufw enable

# 2. 使用 VPN 或内网部署
# vLLM 服务只在内网可达，通过 API Gateway 暴露

# 3. 禁用不必要的端口
vllm serve model --port 8000  # 仅暴露必要端口

# 基于时间段的扩缩容（KEDA Cron）
apiVersion: keda.sh/v1alpha1
kind: ScaledObject
metadata:
  name: vllm-schedule
spec:
  scaleTargetRef:
    name: vllm-server
  minReplicaCount: 1
  maxReplicaCount: 10
  triggers:
    # 工作时间扩容
    - type: cron
      metadata:
        timezone: Asia/Shanghai
        start: "0 8 * * 1-5"
        end: "0 20 * * 1-5"
        desiredReplicas: "5"
    # 非工作时间缩容
    - type: cron
      metadata:
        timezone: Asia/Shanghai
        start: "0 20 * * 1-5"
        end: "0 8 * * 1-5"
        desiredReplicas: "1"
    # 周末缩容
    - type: cron
      metadata:
        timezone: Asia/Shanghai
        start: "0 0 * * 6"
        end: "0 0 * * 1"
        desiredReplicas: "1"

# cost_calculator.py
"""LLM 推理成本计算器"""

def calculate_monthly_cost(
    gpu_type: str,
    num_gpus: int,
    gpu_hours_per_day: float,
    days_per_month: int = 30,
    spot_ratio: float = 0.0,  # Spot 实例比例
):
    """计算月度成本"""
    
    # GPU 单价（每小时，美元）
    prices = {
        "A100-80GB": 3.50,
        "H100-80GB": 8.00,
        "L40S": 2.50,
        "RTX-4090": 1.20,
        "A10G": 1.50,
    }
    
    spot_discount = 0.3  # Spot 实例通常 70% 折扣
    
    base_price = prices.get(gpu_type, 3.50)
    
    on_demand_hours = num_gpus * gpu_hours_per_day * days_per_month * (1 - spot_ratio)
    spot_hours = num_gpus * gpu_hours_per_day * days_per_month * spot_ratio
    
    on_demand_cost = on_demand_hours * base_price
    spot_cost = spot_hours * base_price * spot_discount
    
    total = on_demand_cost + spot_cost
    
    return {
        "gpu_type": gpu_type,
        "num_gpus": num_gpus,
        "monthly_cost": total,
        "cost_per_hour": total / (gpu_hours_per_day * days_per_month),
    }

# 示例
print(calculate_monthly_cost("A100-80GB", 4, 24, spot_ratio=0.5))

# Kubernetes 自愈配置
spec:
  # 健康检查
  livenessProbe:
    httpGet:
      path: /health
      port: 8000
    initialDelaySeconds: 300
    periodSeconds: 30
    failureThreshold: 3
  
  # 自动重启
  restartPolicy: Always
  
  # Pod Disruption Budget
  minAvailable: 2
  
  # 优雅关闭
  terminationGracePeriodSeconds: 120

# 1. 备份当前配置
helm get values vllm-service -n llm > values-backup.yaml

# 2. staging 环境测试
helm upgrade vllm-staging vllm/vllm-chart \
    --set image.tag=new-version \
    --namespace llm-staging

# 3. 验证
curl http://staging/health
# 运行测试用例

# 4. 灰度发布（先 1 个实例）
kubectl scale deployment vllm-server --replicas=1 -n llm
helm upgrade vllm-service vllm/vllm-chart \
    --set image.tag=new-version \
    --namespace llm

# 5. 观察 15 分钟
# 检查日志、指标、错误率

# 6. 全量发布
kubectl scale deployment vllm-server --replicas=5 -n llm

# 7. 如果有问题，回滚
helm rollback vllm-service 1 -n llm

# 每日检查脚本
#!/bin/bash
# daily_check.sh

echo "=== vLLM 每日巡检 ==="
echo "时间: $(date)"

# 1. 服务健康
echo -e "\n--- 服务健康 ---"
curl -s http://localhost:8000/health && echo "✅ 健康" || echo "❌ 异常"

# 2. GPU 状态
echo -e "\n--- GPU 状态 ---"
nvidia-smi --query-gpu=temperature.gpu,utilization.gpu,memory.used,memory.total \
    --format=csv,noheader,nounits | \
    while IFS=, read -r temp util mem_used mem_total; do
        echo "温度: ${temp}°C, 利用率: ${util}%, 显存: ${mem_used}/${mem_total} MB"
        if [ "$temp" -gt 85 ]; then echo "⚠️ GPU 温度过高"; fi
        mem_pct=$((mem_used * 100 / mem_total))
        if [ "$mem_pct" -gt 95 ]; then echo "⚠️ 显存使用率过高"; fi
    done

# 3. 请求统计
echo -e "\n--- 请求统计 ---"
curl -s http://localhost:8000/metrics | grep "vllm:num_requests"

# 4. 磁盘空间
echo -e "\n--- 磁盘空间 ---"
df -h /data/models | tail -1

# 5. 系统内存
echo -e "\n--- 系统内存 ---"
free -h | head -2

echo -e "\n=== 巡检完成 ==="