# vLLM 生产配置 vllm_config.yaml
model: /models/DeepSeek-R1-AWQ
tensor_parallel_size: 8
gpu_memory_utilization: 0.95
max_num_seqs: 512
max_model_len: 32768
block_size: 16
enable_prefix_caching: true
swap_space: 8  # GB
enforce_eager: false
quantization: awq
kv_cache_dtype: auto

# deploy_cluster.py
import ray
from ray import serve
from vllm import LLM, SamplingParams

ray.init(address="ray://head-node:10001", namespace="llm")

@serve.deployment(
    num_replicas=4,
    ray_actor_options={"num_gpus": 2},
    max_ongoing_requests=100
)
class VLLMDeployment:
    def __init__(self, model_path):
        self.llm = LLM(
            model=model_path,
            tensor_parallel_size=2,
            trust_remote_code=True,
            max_model_len=8192,
            gpu_memory_utilization=0.45
        )
    
    async def __call__(self, request):
        prompt = request["prompt"]
        params = SamplingParams(
            temperature=0.7,
            max_tokens=1024,
            stop=["</s>"]
        )
        outputs = self.llm.generate([prompt], params)
        return {"output": outputs[0].outputs[0].text}

serve.run(VLLMDeployment.bind("/models/DeepSeek-R1-AWQ"))

# 压测命令
python3 benchmark_serving.py \
  --backend vllm \
  --model deepseek-ai/DeepSeek-R1-Distill-Qwen-32B \
  --tokenizer deepseek-ai/DeepSeek-R1-Distill-Qwen-32B \
  --dataset random \
  --num-prompts 5000 \
  --request-rate 100 \
  --max-concurrency 128 \
  --output-len 1024 \
  --port 8000

# kv_cache_optimize.py
from vllm import LLM
import torch

class KVCacheOptimizer:
    def __init__(self, model_path):
        self.llm = LLM(
            model=model_path,
            kv_cache_dtype="fp8",  # FP8 KV Cache
            enable_prefix_caching=True,
            max_model_len=65536,
            block_size=8,
            swap_space=16,
            cpu_offload_gb=32  # CPU 卸载
        )
    
    def analyze_memory(self):
        stats = self.llm.llm_engine.scheduler.block_manager.get_memory_stats()
        print(f"KV Cache 使用率: {stats['used']/stats['total']:.2%}")
        print(f"空闲块: {stats['free_blocks']}")
        print(f"交换到 CPU: {stats['swapped']} blocks")
    
    def dynamic_batch(self, requests):
        # 动态批大小调整
        for batch in self._adaptive_batching(requests):
            outputs = self.llm.generate(batch)
            yield outputs

optimizer = KVCacheOptimizer("/models/DeepSeek-R1-AWQ")
optimizer.analyze_memory()

# sglang_radix.py
from sglang.srt.managers.radix_cache import RadixCache

# 初始化 Radix 树
cache = RadixCache(max_size=100_000_000)  # 100M tokens

# 插入系统提示词
system_prompt = "You are DeepSeek-R1, an AI assistant..."
cache.insert(system_prompt, kv_tensor)

# 查询共享前缀
query = "You are DeepSeek-R1, an AI assistant. What is 2+2?"
prefix = cache.match_prefix(query)
print(f"命中前缀长度: {len(prefix)} tokens")

# 1. 安装依赖
pip install autoawq transformers torch

# 2. 量化 DeepSeek-R1-Distill-Qwen-32B
python3 -m awq.entry \
  --model_path deepseek-ai/DeepSeek-R1-Distill-Qwen-32B \
  --quant_path /models/DeepSeek-R1-AWQ \
  --quant_method awq \
  --group_size 128 \
  --zero_point \
  --bits 4 \
  --calib_data c4 \
  --calib_samples 128 \
  --auto_scale \
  --auto_clip \
  --batch_size 8

# deploy_quantized.py
from vllm import LLM, SamplingParams

# AWQ 量化模型加载
llm = LLM(
    model="/models/DeepSeek-R1-AWQ",
    quantization="awq",
    dtype="float16",
    tensor_parallel_size=4,
    gpu_memory_utilization=0.95,
    max_model_len=32768
)

# 混合精度策略
sampling_params = SamplingParams(
    temperature=0.6,
    top_p=0.95,
    max_tokens=2048,
    # 关键：使用 FP16 计算，INT4 存储
    use_beam_search=False,
    best_of=1
)

# 性能验证
import time
start = time.time()
outputs = llm.generate(["Explain quantum computing in 500 words"], sampling_params)
latency = time.time() - start
print(f"生成 {len(outputs[0].outputs[0].token_ids)} tokens，延迟 {latency:.2f}s")
print(f"吞吐: {len(outputs[0].outputs[0].token_ids)/latency:.1f} tokens/s")

# tensor_parallel_config.yaml
model: /models/DeepSeek-R1-AWQ
tensor_parallel_size: 8
pipeline_parallel_size: 1
data_parallel_size: 1
# 通信优化
distributed_executor_backend: ray
# NCCL 优化
nccl:
  p2p_level: 2
  min_p2p_nbytes: 131072
  use_cuda_graph: true

# 启动 vLLM 多卡推理
python3 -m vllm.entrypoints.openai.api_server \
  --model /models/DeepSeek-R1-AWQ \
  --tensor-parallel-size 8 \
  --max-model-len 32768 \
  --gpu-memory-utilization 0.95 \
  --port 8000 \
  --trust-remote-code \
  --kv-cache-dtype fp8 \
  --quantization awq

# NCCL 环境变量优化
export NCCL_DEBUG=INFO
export NCCL_SOCKET_IFNAME=eth0
export NCCL_IB_DISABLE=0
export NCCL_IB_GID_INDEX=3
export NCCL_IB_TIMEOUT=22
export NCCL_IB_RETRY_CNT=7
export NCCL_BUFFSIZE=16777216
export NCCL_ACCEL_DMA_CPU=1

# 检查 GPU 间通信带宽
python3 -c "
import torch
import torch.distributed as dist
dist.init_process_group(backend='nccl')
tensor = torch.randn(1024, 1024, device='cuda')
dist.all_reduce(tensor)
print(f'NCCL 带宽: {tensor.numel()*4/0.001/1e9:.2f} GB/s')
"

# Dockerfile.vllm
FROM nvcr.io/nvidia/pytorch:24.01-py3

# 系统依赖
RUN apt-get update && apt-get install -y \
    git vim curl wget htop \
    && rm -rf /var/lib/apt/lists/*

# Python 环境
RUN pip install --no-cache-dir \
    vllm==0.6.3 \
    autoawq==0.2.8 \
    ray[default]==2.31.0 \
    fastapi uvicorn

# 模型目录
RUN mkdir -p /models /app
WORKDIR /app

# 健康检查
HEALTHCHECK --interval=30s --timeout=10s --retries=3 \
  CMD curl -f http://localhost:8000/health || exit 1

# 启动脚本
COPY start.sh /app/start.sh
RUN chmod +x /app/start.sh
CMD ["/app/start.sh"]

# docker-compose.yml
version: '3.8'

services:
  vllm-worker-1:
    image: vllm:latest
    runtime: nvidia
    environment:
      - NVIDIA_VISIBLE_DEVICES=0,1,2,3
      - RAY_ADDRESS=ray://head:10001
    volumes:
      - /models:/models:ro
    deploy:
      resources:
        reservations:
          devices:
            - driver: nvidia
              count: 4
              capabilities: [gpu]
    command: ["python3", "-m", "vllm.entrypoints.openai.api_server", "--tensor-parallel-size", "4"]

  vllm-worker-2:
    image: vllm:latest
    runtime: nvidia
    environment:
      - NVIDIA_VISIBLE_DEVICES=4,5,6,7
      - RAY_ADDRESS=ray://head:10001
    volumes:
      - /models:/models:ro
    deploy:
      resources:
        reservations:
          devices:
            - driver: nvidia
              count: 4
              capabilities: [gpu]
    command: ["python3", "-m", "vllm.entrypoints.openai.api_server", "--tensor-parallel-size", "4"]

  nginx:
    image: nginx:alpine
    ports:
      - "80:80"
    volumes:
      - ./nginx.conf:/etc/nginx/nginx.conf:ro
    depends_on:
      - vllm-worker-1
      - vllm-worker-2

  prometheus:
    image: prom/prometheus
    ports:
      - "9090:9090"
    volumes:
      - ./prometheus.yml:/etc/prometheus/prometheus.yml:ro

  grafana:
    image: grafana/grafana
    ports:
      - "3000:3000"
    environment:
      - GF_SECURITY_ADMIN_PASSWORD=admin123
    volumes:
      - grafana-data:/var/lib/grafana

volumes:
  grafana-data:

# nginx.conf
upstream vllm_backend {
    least_conn;
    server worker-1:8000 max_fails=3 fail_timeout=30s;
    server worker-2:8000 max_fails=3 fail_timeout=30s;
}

server {
    listen 80;
    client_max_body_size 10M;

    location /v1/ {
        proxy_pass http://vllm_backend/v1/;
        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_read_timeout 300s;
        proxy_send_timeout 300s;
    }

    location /metrics {
        proxy_pass http://prometheus:9090;
    }
}

# prometheus.yml
global:
  scrape_interval: 15s

scrape_configs:
  - job_name: 'vllm'
    static_configs:
      - targets: ['worker-1:8000', 'worker-2:8000']
    metrics_path: '/metrics'

  - job_name: 'node'
    static_configs:
      - targets: ['node-exporter:9100']

# autoscaler.py
import ray
from ray import serve
import asyncio

class AutoScaler:
    def __init__(self, min_replicas=2, max_replicas=8):
        self.min = min_replicas
        self.max = max_replicas
        self.deployment = None
    
    async def monitor(self):
        while True:
            stats = await self.get_metrics()
            current_replicas = stats['replicas']
            
            # 基于吞吐量的扩缩容
            if stats['qps'] > 100 and current_replicas < self.max:
                self.scale_up(current_replicas + 1)
            elif stats['qps'] < 30 and current_replicas > self.min:
                self.scale_down(current_replicas - 1)
            
            await asyncio.sleep(30)
    
    def scale_up(self, n):
        serve.run(self.deployment.options(num_replicas=n).bind())
        print(f"扩容至 {n} 副本")

# 使用
scaler = AutoScaler()
asyncio.run(scaler.monitor())

# GPU 监控
nvidia-smi -l 1
nvtop

# 网络诊断
ibstatus
ibv_devinfo

# Python 性能分析
python3 -m cProfile -o profile.prof your_script.py
snakeviz profile.prof

# 内存分析
valgrind --tool=massif python3 your_script.py
massif-visualizer massif.out.*

# deploy_all.sh
#!/bin/bash

# 1. 环境准备
echo "=== 环境检查 ==="
nvidia-smi
python3 --version
docker --version

# 2. 模型下载
echo "=== 下载模型 ==="
huggingface-cli download deepseek-ai/DeepSeek-R1-Distill-Qwen-32B-AWQ \
  --local-dir /models/DeepSeek-R1-AWQ

# 3. 构建镜像
echo "=== 构建 Docker 镜像 ==="
docker build -t vllm:latest -f Dockerfile.vllm .

# 4. 启动集群
echo "=== 启动集群 ==="
docker-compose up -d

# 5. 等待服务就绪
echo "=== 等待服务启动 ==="
sleep 30
curl http://localhost:8000/health

# 6. 运行压测
echo "=== 性能压测 ==="
python3 benchmark_serving.py \
  --backend vllm \
  --model /models/DeepSeek-R1-AWQ \
  --num-prompts 1000 \
  --request-rate 50

# 7. 查看监控
echo "=== 监控面板 ==="
open http://localhost:3000