2026年AI开发者入门必看：DeepSeek-R1系列开源模型部署全攻略

如果你刚踏入AI开发领域，面对各种开源模型不知从何下手，或者想找一个轻量、高效、容易上手的模型来练手，那么你来对地方了。今天我要带你从零开始，一步步部署DeepSeek-R1-Distill-Qwen-1.5B模型，让你在10分钟内就能跑起来自己的AI服务。

你可能听说过那些动辄几十亿、上百亿参数的大模型，它们确实强大，但对硬件要求高，部署复杂，不适合新手入门。而DeepSeek-R1-Distill-Qwen-1.5B就是为开发者量身打造的“入门神器”——它只有15亿参数，却保留了核心能力，能在普通显卡上流畅运行，是学习AI模型部署的绝佳选择。

1. 为什么选择DeepSeek-R1-Distill-Qwen-1.5B？

在开始动手之前，我们先简单了解一下这个模型的特点，这样你就能明白为什么它特别适合新手。

1.1 模型的核心优势

这个模型是DeepSeek团队基于Qwen2.5-Math-1.5B基础模型，通过知识蒸馏技术打造的轻量化版本。听起来有点技术？别担心，我用大白话给你解释一下：

知识蒸馏就像“老师教学生”——用一个大的、复杂的模型（老师）来训练一个小的、简单的模型（学生），让学生学会老师的核心能力。这样做的好处是，小模型也能有大模型的大部分本事，但运行起来快得多，需要的资源也少得多。

这个模型有几个特别适合新手的优点：

第一，对硬件要求低。它支持INT8量化部署，这是什么意思呢？简单说就是模型被“压缩”了，内存占用比原来减少了75%。这意味着你不需要昂贵的专业显卡，用NVIDIA T4这样的普通显卡，甚至一些性能不错的消费级显卡就能跑起来。

第二，保持了不错的精度。虽然模型变小了，但通过优化技术，它还能保持85%以上的原始模型精度。对于大多数应用场景来说，这个精度完全够用。

第三，在某些专业领域表现更好。在训练过程中，团队加入了法律文书、医疗问诊等专业数据，这让模型在处理这些特定任务时，效果提升了12-15个百分点。

1.2 你需要准备什么？

开始之前，确保你有以下环境：

• 一台有GPU的服务器或电脑（NVIDIA显卡，显存至少4GB）
• 安装了Python 3.8或更高版本
• 基本的命令行操作知识
• 大约5GB的可用磁盘空间

如果你没有GPU，用CPU也能运行，只是速度会慢一些。对于学习目的来说，完全没问题。

2. 快速部署：用vLLM启动模型服务

现在进入正题，我会带你一步步把模型服务跑起来。整个过程就像搭积木，一步一步来，很简单。

2.1 环境准备与安装

首先，我们需要安装必要的软件包。打开你的终端，执行以下命令：

# 创建并激活虚拟环境（推荐，避免包冲突）
python -m venv deepseek_env
source deepseek_env/bin/activate  # Linux/Mac
# 如果是Windows，用：deepseek_env\Scripts\activate

# 安装vLLM和相关依赖
pip install vllm
pip install openai  # 用于后续的API调用测试

vLLM是一个专门为大型语言模型设计的高性能推理引擎，它的最大特点就是快。相比其他框架，vLLM的推理速度能提升好几倍，而且内存使用更高效。

2.2 下载模型文件

模型文件比较大，我们需要先下载。DeepSeek的模型通常可以在Hugging Face上找到：

# 创建工作目录
mkdir -p /root/workspace
cd /root/workspace

# 使用huggingface-cli下载模型（需要先安装huggingface_hub）
pip install huggingface_hub

# 下载模型
python -c "from huggingface_hub import snapshot_download; snapshot_download(repo_id='deepseek-ai/DeepSeek-R1-Distill-Qwen-1.5B', local_dir='./DeepSeek-R1-Distill-Qwen-1.5B')"

如果下载速度慢，你也可以直接从其他镜像源下载，或者如果已经有同事下载好了，直接拷贝过来也行。

2.3 启动模型服务

这是最关键的一步。我们用vLLM来启动模型服务：

# 进入工作目录
cd /root/workspace

# 启动vLLM服务
python -m vllm.entrypoints.openai.api_server \
    --model ./DeepSeek-R1-Distill-Qwen-1.5B \
    --served-model-name DeepSeek-R1-Distill-Qwen-1.5B \
    --port 8000 \
    --max-model-len 2048 \
    --gpu-memory-utilization 0.9 \
    --tensor-parallel-size 1 \
    --dtype half \
    --quantization none \
    > deepseek_qwen.log 2>&1 &

让我解释一下这些参数是什么意思：

• --model ./DeepSeek-R1-Distill-Qwen-1.5B：指定模型路径
• --port 8000：服务监听的端口号
• --max-model-len 2048：模型能处理的最大文本长度
• --gpu-memory-utilization 0.9：GPU内存使用率，0.9表示使用90%的显存
• --dtype half：使用半精度浮点数，减少内存占用
• 最后的 & 表示在后台运行

命令执行后，服务就在后台启动了。我们怎么知道它启动成功了呢？

3. 验证服务是否正常运行

服务启动需要一点时间，通常1-3分钟。我们可以通过查看日志来确认状态。

3.1 查看启动日志

# 进入工作目录
cd /root/workspace

# 查看启动日志
cat deepseek_qwen.log

如果看到类似下面的输出，就说明启动成功了：

INFO 07-15 14:30:15 llm_engine.py:72] Initializing an LLM engine with config: model='./DeepSeek-R1-Distill-Qwen-1.5B', ...
INFO 07-15 14:30:20 model_runner.py:84] Loading model weights took 4.85 GB
INFO 07-15 14:30:25 llm_engine.py:179] # GPU blocks: 456, # CPU blocks: 512
INFO 07-15 14:30:25 llm_engine.py:180] Using vLLM attention backend
INFO 07-15 14:30:30 api_server.py:217] Started server process [12345]
INFO 07-15 14:30:30 api_server.py:218] Waiting for application startup.
INFO 07-15 14:30:30 api_server.py:223] Application startup complete.
INFO 07-15 14:30:30 api_server.py:224] Serving on http://0.0.0.0:8000

关键要看最后几行，特别是“Application startup complete”和“Serving on http://0.0.0.0:8000”，这表示服务已经正常启动，在8000端口监听请求。

3.2 快速测试服务

除了看日志，我们还可以直接发送一个测试请求：

# 使用curl测试API
curl http://localhost:8000/v1/models

如果返回类似下面的JSON数据，说明API服务正常：

{
  "object": "list",
  "data": [
    {
      "id": "DeepSeek-R1-Distill-Qwen-1.5B",
      "object": "model",
      "created": 1677610602,
      "owned_by": "deepseek-ai"
    }
  ]
}

4. 编写Python客户端进行完整测试

现在服务已经跑起来了，我们来写一个完整的测试程序，看看模型的实际表现。

4.1 创建测试脚本

打开Jupyter Lab或者你喜欢的Python编辑器，创建一个新的Python文件：

from openai import OpenAI
import requests
import json


class LLMClient:
    def __init__(self, base_url="http://localhost:8000/v1"):
        """
        初始化客户端
        base_url: vLLM服务的地址，默认是本地的8000端口
        """
        self.client = OpenAI(
            base_url=base_url,
            api_key="none"  # vLLM通常不需要API密钥，随便填一个就行
        )
        self.model = "DeepSeek-R1-Distill-Qwen-1.5B"
        
    def chat_completion(self, messages, stream=False, temperature=0.7, max_tokens=2048):
        """基础的聊天完成功能"""
        try:
            response = self.client.chat.completions.create(
                model=self.model,
                messages=messages,
                temperature=temperature,
                max_tokens=max_tokens,
                stream=stream
            )
            return response
        except Exception as e:
            print(f"API调用错误: {e}")
            return None
    
    def stream_chat(self, messages):
        """流式对话示例 - 一个字一个字地显示回复"""
        print("AI: ", end="", flush=True)
        full_response = ""
        
        try:
            stream = self.chat_completion(messages, stream=True)
            if stream:
                for chunk in stream:
                    if chunk.choices[0].delta.content is not None:
                        content = chunk.choices[0].delta.content
                        print(content, end="", flush=True)
                        full_response += content
                print()  # 换行
                return full_response
        except Exception as e:
            print(f"流式对话错误: {e}")
            return ""
    
    def simple_chat(self, user_message, system_message=None):
        """简化版对话接口 - 最常用的方式"""
        messages = []
        if system_message:
            messages.append({"role": "system", "content": system_message})
        messages.append({"role": "user", "content": user_message})
        
        response = self.chat_completion(messages)
        if response and response.choices:
            return response.choices[0].message.content
        return "请求失败"
    
    def test_connection(self):
        """测试连接是否正常"""
        try:
            response = requests.get("http://localhost:8000/v1/models")
            if response.status_code == 200:
                print("✅ 连接测试成功！")
                print(f"可用模型: {response.json()}")
                return True
            else:
                print(f"❌ 连接测试失败，状态码: {response.status_code}")
                return False
        except Exception as e:
            print(f"❌ 连接异常: {e}")
            return False


# 使用示例
if __name__ == "__main__":
    # 初始化客户端
    llm_client = LLMClient()
    
    # 先测试连接
    print("=== 连接测试 ===")
    if not llm_client.test_connection():
        print("请检查vLLM服务是否正常启动")
        exit(1)
    
    # 测试普通对话
    print("\n=== 普通对话测试 ===")
    response = llm_client.simple_chat(
        "请用中文介绍一下人工智能的发展历史",
        "你是一个有帮助的AI助手，请用通俗易懂的语言回答"
    )
    print(f"问题: 请用中文介绍一下人工智能的发展历史")
    print(f"回复: {response}")
    
    # 测试数学推理能力
    print("\n=== 数学问题测试 ===")
    math_response = llm_client.simple_chat(
        "请逐步推理，并将最终答案放在\\boxed{}内。问题：一个长方形的长是8厘米，宽是5厘米，求它的面积和周长。",
        "你是一个数学老师，请详细解释每一步"
    )
    print(f"数学问题回复: {math_response}")
    
    # 测试流式对话
    print("\n=== 流式对话测试 ===")
    messages = [
        {"role": "system", "content": "你是一个诗人，请用优美的语言创作"},
        {"role": "user", "content": "写两首关于秋天的五言绝句"}
    ]
    llm_client.stream_chat(messages)

4.2 运行测试脚本

保存上面的代码为 test_deepseek.py，然后在终端运行：

python test_deepseek.py

你应该能看到类似下面的输出：

=== 连接测试 ===
✅ 连接测试成功！
可用模型: {'object': 'list', 'data': [{'id': 'DeepSeek-R1-Distill-Qwen-1.5B', ...}]}

=== 普通对话测试 ===
问题: 请用中文介绍一下人工智能的发展历史
回复: 人工智能的发展可以分为几个阶段...（这里会是模型的实际回复）

=== 数学问题测试 ===
数学问题回复: 首先计算面积：面积 = 长 × 宽 = 8 × 5 = 40平方厘米...
最终答案：\boxed{面积40平方厘米，周长26厘米}

=== 流式对话测试 ===
AI: 秋风吹叶落，（等待一会儿）金黄满山坡...（一个字一个字显示出来）

如果一切正常，恭喜你！你已经成功部署并运行了DeepSeek-R1-Distill-Qwen-1.5B模型。

5. 使用技巧与最佳实践

模型跑起来只是第一步，要想让它发挥最好效果，还需要一些技巧。

5.1 参数设置建议

根据官方文档和实际测试，我总结了一些最佳参数设置：

# 推荐的参数配置
recommended_config = {
    "temperature": 0.6,      # 温度值，控制随机性，0.5-0.7之间效果最好
    "max_tokens": 2048,      # 最大生成长度
    "top_p": 0.9,            # 核采样参数
    "frequency_penalty": 0.1, # 频率惩罚，减少重复
    "presence_penalty": 0.1   # 存在惩罚，鼓励多样性
}

# 使用推荐配置的示例
def chat_with_recommended_settings(self, user_message):
    messages = [{"role": "user", "content": user_message}]
    
    response = self.client.chat.completions.create(
        model=self.model,
        messages=messages,
        temperature=0.6,      # 关键参数！
        max_tokens=2048,
        top_p=0.9,
        frequency_penalty=0.1,
        presence_penalty=0.1
    )
    return response.choices[0].message.content

特别提醒：温度（temperature）参数很关键！设置太低（如0.1）会让回答太死板，设置太高（如1.0）会让回答太随机。经过测试，0.6左右的效果最平衡。

5.2 提示词编写技巧

DeepSeek-R1系列模型对提示词比较敏感，这里有几个实用技巧：

第一，所有指令都放在用户消息里。不要用系统消息（system message）给指令，像这样：

# 推荐的做法 ✅
messages = [
    {"role": "user", "content": "请扮演一个数学老师，详细解答以下问题：..."}
]

# 不推荐的做法 ❌
messages = [
    {"role": "system", "content": "你是一个数学老师"},  # 模型可能忽略这个
    {"role": "user", "content": "解答以下问题：..."}
]

第二，数学问题要特殊处理。对于数学推理题，一定要在提示词中明确要求：

math_prompt = """请逐步推理，并将最终答案放在\\boxed{}内。

问题：一个水池有进水管和出水管，单独开进水管6小时可以注满，单独开出水管8小时可以放完。如果同时打开进水管和出水管，多少小时可以注满水池？

请详细写出每一步的计算过程。"""

第三，避免模型“偷懒”。有时候模型可能会输出“\n\n”这样的空行，跳过思考过程。可以在提示词开头强制要求：

# 在提示词开头加上换行符，强制模型思考
prompt = "\n请仔细思考以下问题：\n" + your_question

5.3 常见问题解决

在实际使用中，你可能会遇到一些问题，这里是一些常见问题的解决方法：

问题1：模型响应太慢

# 可以调整这些参数加速
response = client.chat.completions.create(
    model=model_name,
    messages=messages,
    temperature=0.6,
    max_tokens=512,  # 减少生成长度
    stream=False     # 关闭流式输出（一次性返回更快）
)

问题2：回答总是重复

# 增加惩罚参数
response = client.chat.completions.create(
    model=model_name,
    messages=messages,
    temperature=0.6,
    frequency_penalty=0.5,  # 增加频率惩罚
    presence_penalty=0.3    # 增加存在惩罚
)

问题3：显存不足 如果遇到CUDA out of memory错误，可以尝试：

1. 减少max_tokens参数
2. 使用更小的批次大小（如果支持）
3. 确保没有其他程序占用显存

6. 进阶应用示例

掌握了基础用法后，我们来看看这个模型能做什么有趣的事情。

6.1 构建简单的问答系统

class SimpleQASystem:
    def __init__(self):
        self.client = LLMClient()
        self.conversation_history = []
    
    def ask_question(self, question, context=None):
        """带上下文的问题回答"""
        prompt = ""
        
        if context:
            prompt += f"背景信息：{context}\n\n"
        
        prompt += f"问题：{question}\n\n请根据以上信息回答问题。"
        
        # 添加上下文历史
        if self.conversation_history:
            history_text = "\n".join([f"Q: {q}\nA: {a}" for q, a in self.conversation_history[-3:]])  # 只保留最近3轮
            prompt = f"之前的对话：\n{history_text}\n\n当前问题：{prompt}"
        
        response = self.client.simple_chat(prompt)
        
        # 保存到历史
        self.conversation_history.append((question, response))
        
        return response
    
    def clear_history(self):
        """清空对话历史"""
        self.conversation_history = []


# 使用示例
qa_system = SimpleQASystem()

# 第一次提问
answer1 = qa_system.ask_question(
    "什么是机器学习？",
    context="我们在讨论人工智能的相关概念"
)
print(f"回答1：{answer1}")

# 第二次提问（能记住上下文）
answer2 = qa_system.ask_question("那监督学习和无监督学习有什么区别？")
print(f"回答2：{answer2}")

6.2 文本摘要功能

def text_summarization(long_text, summary_length="short"):
    """文本摘要功能
    
    Args:
        long_text: 需要摘要的长文本
        summary_length: "short"（简短）或 "detailed"（详细）
    """
    length_instruction = {
        "short": "请用1-2句话简要概括主要内容",
        "detailed": "请用3-5个要点总结核心内容"
    }
    
    prompt = f"""请阅读以下文本并进行摘要：

{long_text}

{length_instruction.get(summary_length, "请概括主要内容")}。"""

    client = LLMClient()
    summary = client.simple_chat(prompt)
    
    return summary


# 使用示例
long_article = """人工智能是计算机科学的一个分支，旨在创造能够执行通常需要人类智能的任务的机器...（这里是一篇长文章）"""

short_summary = text_summarization(long_article, "short")
print(f"简短摘要：{short_summary}")

detailed_summary = text_summarization(long_article, "detailed")
print(f"详细摘要：{detailed_summary}")

6.3 代码生成与解释

def generate_code(requirement, language="python"):
    """根据需求生成代码"""
    prompt = f"""请用{language}编写代码实现以下功能：

需求：{requirement}

要求：
1. 代码要有详细的注释
2. 包含必要的错误处理
3. 给出使用示例
4. 如果可能，提供测试用例"""

    client = LLMClient()
    code = client.simple_chat(prompt)
    
    return code


def explain_code(code_snippet):
    """解释代码功能"""
    prompt = f"""请解释以下代码的功能和工作原理：

```python
{code_snippet}

请用通俗易懂的语言解释：

1. 这段代码是做什么的？

2. 关键部分是如何工作的？

3. 有什么需要注意的地方？"""

   client = LLMClient() explanation = client.simple_chat(prompt)

   return explanation

使用示例

生成一个快速排序的代码

requirement = "实现快速排序算法" quick_sort_code = generate_code(requirement, "python") print("生成的快速排序代码：") print(quick_sort_code)

解释代码

explanation = explain_code(quick_sort_code) print("\n代码解释：") print(explanation)

## 7. 性能优化与监控

当你的应用正式上线后，可能需要关注性能和稳定性。

### 7.1 监控服务状态

```python
import time
import psutil
import GPUtil

class ServiceMonitor:
    def __init__(self, service_url="http://localhost:8000"):
        self.service_url = service_url
    
    def check_service_health(self):
        """检查服务健康状态"""
        try:
            start_time = time.time()
            response = requests.get(f"{self.service_url}/v1/models", timeout=5)
            response_time = (time.time() - start_time) * 1000  # 毫秒
            
            if response.status_code == 200:
                return {
                    "status": "healthy",
                    "response_time_ms": round(response_time, 2),
                    "model_available": True
                }
            else:
                return {
                    "status": "unhealthy",
                    "error": f"HTTP {response.status_code}"
                }
        except Exception as e:
            return {
                "status": "unreachable",
                "error": str(e)
            }
    
    def get_system_metrics(self):
        """获取系统指标"""
        metrics = {
            "timestamp": time.strftime("%Y-%m-%d %H:%M:%S"),
            "cpu_percent": psutil.cpu_percent(interval=1),
            "memory_percent": psutil.virtual_memory().percent,
        }
        
        try:
            gpus = GPUtil.getGPUs()
            if gpus:
                metrics["gpu_utilization"] = gpus[0].load * 100
                metrics["gpu_memory_percent"] = gpus[0].memoryUtil * 100
        except:
            metrics["gpu_utilization"] = "N/A"
            metrics["gpu_memory_percent"] = "N/A"
        
        return metrics
    
    def monitor_loop(self, interval_seconds=60):
        """监控循环"""
        print("开始监控服务...")
        print("时间戳 | 服务状态 | 响应时间(ms) | CPU使用率 | 内存使用率 | GPU使用率")
        print("-" * 80)
        
        while True:
            health = self.check_service_health()
            metrics = self.get_system_metrics()
            
            print(f"{metrics['timestamp']} | "
                  f"{health['status']:10} | "
                  f"{health.get('response_time_ms', 'N/A'):15} | "
                  f"{metrics['cpu_percent']:10.1f}% | "
                  f"{metrics['memory_percent']:12.1f}% | "
                  f"{metrics.get('gpu_utilization', 'N/A'):12}")
            
            time.sleep(interval_seconds)


# 使用示例
if __name__ == "__main__":
    monitor = ServiceMonitor()
    
    # 单次检查
    health_status = monitor.check_service_health()
    print(f"服务状态: {health_status}")
    
    # 系统指标
    metrics = monitor.get_system_metrics()
    print(f"系统指标: {metrics}")
    
    # 如果要持续监控，取消下面的注释
    # monitor.monitor_loop(interval_seconds=300)  # 每5分钟检查一次

7.2 批量处理优化

如果你需要处理大量请求，可以考虑批量处理：

class BatchProcessor:
    def __init__(self, batch_size=4, max_workers=2):
        self.client = LLMClient()
        self.batch_size = batch_size  # 每批处理的数量
        self.max_workers = max_workers  # 最大并发数
    
    def process_batch(self, prompts):
        """批量处理提示词"""
        results = []
        
        # 将提示词分成小批
        for i in range(0, len(prompts), self.batch_size):
            batch = prompts[i:i + self.batch_size]
            print(f"处理批次 {i//self.batch_size + 1}/{len(prompts)//self.batch_size + 1}")
            
            batch_results = self._process_single_batch(batch)
            results.extend(batch_results)
            
            # 避免请求过快
            time.sleep(0.5)
        
        return results
    
    def _process_single_batch(self, batch_prompts):
        """处理单个批次"""
        batch_results = []
        
        for prompt in batch_prompts:
            try:
                response = self.client.simple_chat(prompt)
                batch_results.append({
                    "prompt": prompt,
                    "response": response,
                    "status": "success"
                })
            except Exception as e:
                batch_results.append({
                    "prompt": prompt,
                    "response": str(e),
                    "status": "error"
                })
        
        return batch_results


# 使用示例
processor = BatchProcessor(batch_size=4)

# 准备一批问题
questions = [
    "解释什么是神经网络",
    "Python中的列表和元组有什么区别？",
    "如何快速排序一个数组？",
    "什么是HTTP协议？",
    "机器学习中的过拟合是什么意思？",
    "如何用Python读取CSV文件？",
    "解释一下区块链技术",
    "什么是RESTful API？"
]

print(f"开始批量处理 {len(questions)} 个问题...")
results = processor.process_batch(questions)

print("\n处理结果：")
for i, result in enumerate(results):
    print(f"{i+1}. 问题：{result['prompt'][:50]}...")
    print(f"   状态：{result['status']}")
    if result['status'] == 'success':
        print(f"   回答：{result['response'][:100]}...")
    print()

8. 总结

通过这篇教程，你应该已经掌握了DeepSeek-R1-Distill-Qwen-1.5B模型的完整部署流程。让我们回顾一下关键要点：

8.1 核心收获

第一，部署其实很简单。整个过程就是：准备环境 → 下载模型 → 启动服务 → 测试验证。跟着步骤一步步来，任何人都能在10分钟内跑起来。

第二，这个模型真的很友好。1.5B的参数规模，意味着它不需要强大的硬件，普通显卡就能流畅运行。对于学习、实验、小规模应用来说，完全够用。

第三，使用有技巧。记住几个关键点：温度设0.6左右效果最好、指令放在用户消息里、数学问题要加特殊格式、开头加换行符避免模型“偷懒”。

第四，能做的事情很多。从简单的问答对话，到文本摘要、代码生成、批量处理，这个模型都能胜任。你可以基于它构建各种有趣的应用。

8.2 下一步建议

如果你已经成功部署并运行了模型，我建议你：

1. 多试试不同的提示词。同样的模型，不同的提问方式，得到的结果可能天差地别。多练习怎么写好提示词。

2. 尝试不同的参数。除了温度，还可以调整top_p、frequency_penalty等参数，看看效果有什么变化。

3. 结合实际需求开发应用。可以做一个简单的聊天机器人，或者一个文档摘要工具，把学到的知识用起来。

4. 关注模型更新。开源模型发展很快，定期关注DeepSeek的官方更新，可能会有更好的版本发布。

5. 加入社区交流。遇到问题可以在相关技术社区提问，也有很多人在用同样的模型，可以互相学习。

8.3 常见问题快速参考

• 服务启动失败：检查显存是否足够，模型路径是否正确
• 响应速度慢：减少max_tokens，关闭流式输出
• 回答质量不高：调整温度参数，优化提示词
• 显存不足：确保没有其他程序占用显存，减少并发请求

记住，学习AI模型部署就像学骑自行车，开始可能会摔几次，但一旦掌握了，就能自由驰骋。DeepSeek-R1-Distill-Qwen-1.5B是一个很好的起点，它足够简单让你快速上手，又足够强大让你学到真东西。

现在，你已经有了自己的AI模型服务，接下来就是发挥创意，用它做出有趣的东西了。祝你玩得开心！

---

获取更多AI镜像

想探索更多AI镜像和应用场景？访问 CSDN星图镜像广场，提供丰富的预置镜像，覆盖大模型推理、图像生成、视频生成、模型微调等多个领域，支持一键部署。