保姆级教程：PyTorch 2.7镜像快速上手，5分钟搞定GPU深度学习环境

保姆级教程：PyTorch 2.7镜像快速上手，5分钟搞定GPU深度学习环境

你是不是刚拿到一块新显卡，兴冲冲地想跑个深度学习模型，结果被CUDA版本、PyTorch安装、环境配置这些繁琐步骤劝退？或者你已经在不同机器上折腾过无数次环境，每次都要花半天时间解决各种依赖冲突？别担心，今天这篇教程就是为你准备的。

我最近在CSDN算力平台上发现了一个宝藏镜像——PyTorch 2.7预置环境。它最大的特点就是“开箱即用”，你不需要懂复杂的Linux命令，不需要手动安装CUDA驱动，甚至不需要知道怎么配置Python环境。只要点几下鼠标，5分钟内就能获得一个完整的、支持GPU加速的PyTorch开发环境。

这篇文章我会手把手带你走一遍完整流程，从镜像选择到环境验证，再到实际跑一个深度学习模型。整个过程就像搭积木一样简单，无论你是刚入门的新手，还是被环境问题折磨过的老手，都能轻松跟上。

1. 为什么选择PyTorch 2.7镜像？

1.1 告别环境配置的噩梦

传统搭建深度学习环境有多痛苦？让我给你数数：

1. CUDA安装：先要查显卡型号，再找对应的CUDA版本，下载安装包，配置环境变量……一步错就全盘重来。
2. PyTorch安装：官网那一长串安装命令，什么torch==2.7.1+cu128，新手根本看不懂什么意思。
3. 依赖冲突：好不容易装好了，一运行代码就报错，不是这个库版本不对，就是那个库缺失。
4. 跨平台问题：在Windows上配好的环境，到Linux上又得重新来一遍。

而PyTorch 2.7镜像把这些麻烦全打包解决了。它预装了：

• Ubuntu 22.04操作系统
• Python 3.10或3.12（稳定版本）
• PyTorch 2.7.1 + CUDA 12.8
• 常用深度学习库（torchvision、torchaudio等）
• JupyterLab和VS Code Server（开箱即用）

你什么都不用管，启动就能用。

1.2 完美支持最新硬件

如果你用的是NVIDIA RTX 40系或最新的50系显卡，这个镜像特别适合你。PyTorch 2.7原生支持这些新架构的显卡，包括：

• RTX 40系列：完整的CUDA核心支持
• RTX 50系列：Blackwell架构原生适配
• Intel Arc显卡：Windows和Linux双平台支持
• Apple Silicon：Metal后端优化加速

很多人在新显卡上装PyTorch会遇到各种奇怪问题，根本原因就是PyTorch版本太旧，不认识新显卡的计算能力。这个镜像用的PyTorch 2.7.1是最新版本，完美避开了这些坑。

1.3 三端一致的开发体验

不管你用的是什么电脑——MacBook、Windows台式机、还是Linux工作站——只要连接到这个云端环境，看到的就是完全一样的界面、一样的工具、一样的配置。

这意味着：

• 在Mac上写的代码，不用改就能在Windows上跑
• 团队协作时，不会出现“在我机器上能跑”的问题
• 调试效率大幅提升，不用花时间排查环境差异

2. 5分钟快速部署：手把手教程

2.1 第一步：找到并启动镜像

整个过程比你想的简单得多：

1. 登录CSDN算力平台：如果你还没有账号，先注册一个（过程很简单，手机号就能注册）。

2. 进入星图镜像广场：在平台首页找到“镜像广场”或“星图镜像”入口。

3. 搜索PyTorch 2.7：在搜索框输入“PyTorch 2.7”或“PyTorch 2.7.1”。

4. 选择合适镜像：你会看到类似这样的镜像：

   • pytorch-2.7.1-cuda12.8-ubuntu22.04
   • pytorch-2.7-gpu-jupyter

   我建议选择带有JupyterLab的版本，这样可以直接在浏览器里写代码，最方便。

5. 点击“一键启动”：系统会弹出一个配置页面。

2.2 第二步：配置实例参数

配置页面有几个关键选项需要你注意：

GPU型号选择：

• 如果你只是学习或测试，选RTX 4090或RTX 5070就够了
• 如果要训练大模型，建议选A100或H100
• 预算有限的话，RTX 3090也是不错的选择

存储空间：

• 默认给的存储可能不够用，建议调到50GB以上
• 如果你要下载大模型（比如LLaMA、Stable Diffusion），最好选100GB

网络设置：

• 如果你需要从外部访问（比如部署API服务），记得开启公网IP
• 只是自己用的话，用平台提供的内网地址就行

持久化存储（重要！）：

• 一定要勾选“持久化存储”选项
• 这样即使你关机了，你的代码、数据、安装的包都不会丢失
• 下次开机直接接着用，不用重新配置

配置完成后，点击“确认启动”。系统会开始创建你的实例，这个过程大概需要2-3分钟。

2.3 第三步：连接并验证环境

实例启动成功后，你会看到几个连接方式：

方式一：JupyterLab（推荐给新手）

• 直接点击“打开JupyterLab”按钮
• 浏览器会新开一个标签页，显示JupyterLab界面
• 左边是文件管理器，右边可以新建Notebook或Python文件

方式二：VS Code Remote SSH（适合专业开发）

1. 复制页面上显示的SSH连接命令，类似：

   ssh -p 32200 root@123.45.67.89

2. 在本地VS Code安装“Remote - SSH”插件
3. 添加新的SSH连接，粘贴上面的命令
4. 连接成功后，就可以像在本地一样写代码了

方式三：直接SSH连接（适合命令行高手）

• 用终端直接执行SSH命令
• 适合快速执行命令或脚本

连接成功后，第一件事是验证环境是否正常。新建一个Python文件或Notebook，输入以下代码：

import torch print(f"PyTorch版本: {torch.__version__}") print(f"CUDA是否可用: {torch.cuda.is_available()}") if torch.cuda.is_available(): print(f"GPU型号: {torch.cuda.get_device_name(0)}") print(f"CUDA版本: {torch.version.cuda}") print(f"可用显存: {torch.cuda.get_device_properties(0).total_memory / 1e9:.2f} GB") else: print("警告: CUDA不可用，请检查驱动或配置")

运行这段代码，你应该看到类似这样的输出：

PyTorch版本: 2.7.1+cu128 CUDA是否可用: True GPU型号: NVIDIA GeForce RTX 5090 CUDA版本: 12.8 可用显存: 24.00 GB

如果看到CUDA是否可用: True，恭喜你！环境配置成功了。如果显示False，可能是驱动问题，我们后面会讲怎么解决。

3. 快速上手：运行你的第一个深度学习模型

环境搭好了，我们来实际跑个模型感受一下。我选了一个经典的例子——用预训练的ResNet50做图像分类。这个例子简单直观，能让你快速看到GPU加速的效果。

3.1 准备测试代码

新建一个Python文件，命名为first_demo.py，输入以下代码：

import torch import torchvision import time from PIL import Image import requests from io import BytesIO # 1. 检查环境 print("=" * 50) print("环境检查:") print(f"PyTorch版本: {torch.__version__}") print(f"CUDA可用: {torch.cuda.is_available()}") print(f"GPU: {torch.cuda.get_device_name(0) if torch.cuda.is_available() else 'CPU'}") print("=" * 50) # 2. 下载测试图片 print("\n下载测试图片...") url = "https://images.unsplash.com/photo-1514888286974-6d03bde4ba42" response = requests.get(url) img = Image.open(BytesIO(response.content)) # 图片预处理 transform = torchvision.transforms.Compose([ torchvision.transforms.Resize(256), torchvision.transforms.CenterCrop(224), torchvision.transforms.ToTensor(), torchvision.transforms.Normalize( mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225] ) ]) input_tensor = transform(img).unsqueeze(0) # 增加batch维度 print(f"输入图片尺寸: {input_tensor.shape}") # 3. 加载预训练模型 print("\n加载ResNet50模型...") model = torchvision.models.resnet50(pretrained=True) model.eval() # 设置为评估模式 # 移动到GPU（如果可用） device = torch.device("cuda" if torch.cuda.is_available() else "cpu") model = model.to(device) input_tensor = input_tensor.to(device) # 4. 运行推理（CPU vs GPU对比） print("\n开始推理测试...") # CPU推理 if torch.cuda.is_available(): cpu_model = torchvision.models.resnet50(pretrained=True).eval() cpu_input = input_tensor.cpu() start_time = time.time() with torch.no_grad(): cpu_output = cpu_model(cpu_input) cpu_time = time.time() - start_time print(f"CPU推理时间: {cpu_time:.4f}秒") # GPU推理 start_time = time.time() with torch.no_grad(): gpu_output = model(input_tensor) gpu_time = time.time() - start_time if torch.cuda.is_available(): print(f"GPU推理时间: {gpu_time:.4f}秒") print(f"GPU加速比: {cpu_time/gpu_time:.2f}x") else: print(f"推理时间: {gpu_time:.4f}秒 (使用CPU)") # 5. 解析结果 print("\n推理结果:") with open("imagenet_classes.txt", "r") as f: categories = [s.strip() for s in f.readlines()] probabilities = torch.nn.functional.softmax(gpu_output[0], dim=0) top5_prob, top5_catid = torch.topk(probabilities, 5) for i in range(top5_prob.size(0)): print(f"{i+1}. {categories[top5_catid[i]]}: {top5_prob[i].item()*100:.2f}%") print("\n✅ 测试完成!")

另外，你还需要下载ImageNet的类别文件。在同一个目录下创建imagenet_classes.txt文件，或者直接运行这段代码下载：

import urllib.request url = "https://raw.githubusercontent.com/pytorch/hub/master/imagenet_classes.txt" urllib.request.urlretrieve(url, "imagenet_classes.txt") print("类别文件下载完成")

3.2 运行并查看结果

保存文件后，在终端运行：

python first_demo.py

你会看到类似这样的输出：

================================================== 环境检查: PyTorch版本: 2.7.1+cu128 CUDA可用: True GPU: NVIDIA GeForce RTX 5090 ================================================== 下载测试图片... 加载ResNet50模型... 开始推理测试... CPU推理时间: 0.4521秒 GPU推理时间: 0.0123秒 GPU加速比: 36.76x 推理结果: 1. tiger cat: 42.35% 2. tabby cat: 38.91% 3. Egyptian cat: 12.45% 4. Persian cat: 3.21% 5. lynx: 1.08% ✅ 测试完成!

看到那个36.76x的加速比了吗？这就是GPU的威力！在CPU上需要0.45秒的推理，在GPU上只要0.012秒，快了将近37倍。

3.3 理解代码的关键点

这个简单的例子包含了几个深度学习的关键概念：

1. 模型加载：torchvision.models.resnet50(pretrained=True)自动下载并加载预训练的ResNet50模型
2. 数据预处理：图片需要调整大小、裁剪、归一化，才能输入模型
3. 设备转移：.to(device)把模型和数据移动到GPU上
4. 推理模式：model.eval()和with torch.no_grad()确保推理时不计算梯度，节省内存
5. 结果解析：softmax把输出转换成概率，topk找到概率最高的5个类别

如果你看到GPU加速比很高，说明环境配置完全正确。如果加速比不明显，或者GPU时间比CPU还长，可能是数据太小，GPU的优势没发挥出来。

4. 进阶使用：JupyterLab实战指南

4.1 JupyterLab的基本操作

通过Web界面访问JupyterLab是最简单的方式。启动实例后，点击“打开JupyterLab”，你会看到一个功能完整的IDE：

左侧文件管理器：

• 可以上传本地文件（拖拽或点击上传按钮）
• 创建文件夹管理项目
• 支持.zip文件自动解压

新建文件：

• Python Notebook（.ipynb）：适合实验和演示
• Python文件（.py）：适合正式项目
• Markdown文件：写文档
• Terminal：命令行终端

单元格操作：

• 按Shift+Enter运行当前单元格
• 按Esc进入命令模式，按Enter进入编辑模式
• 支持代码补全（按Tab键）

4.2 一个完整的图像分类项目

让我们在Jupyter Notebook里做一个更实用的例子——训练一个简单的猫狗分类器。新建一个Notebook，按单元格依次执行：

单元格1：导入库和设置

import torch import torch.nn as nn import torch.optim as optim from torch.utils.data import DataLoader from torchvision import datasets, transforms, models import matplotlib.pyplot as plt import numpy as np import time # 设置随机种子，保证结果可复现 torch.manual_seed(42) if torch.cuda.is_available(): torch.cuda.manual_seed(42) print("环境准备完成") print(f"使用设备: {'GPU' if torch.cuda.is_available() else 'CPU'}")

单元格2：准备数据集

# 数据预处理 transform = transforms.Compose([ transforms.Resize((224, 224)), transforms.RandomHorizontalFlip(), # 数据增强 transforms.RandomRotation(10), # 数据增强 transforms.ToTensor(), transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225]) ]) # 下载猫狗数据集（小型数据集，适合演示） train_dataset = datasets.OxfordIIITPet( root='./data', split='trainval', target_types='category', download=True, transform=transform ) test_dataset = datasets.OxfordIIITPet( root='./data', split='test', target_types='category', download=True, transform=transform ) # 创建数据加载器 batch_size = 32 train_loader = DataLoader(train_dataset, batch_size=batch_size, shuffle=True, num_workers=2) test_loader = DataLoader(test_dataset, batch_size=batch_size, shuffle=False, num_workers=2) print(f"训练集大小: {len(train_dataset)}") print(f"测试集大小: {len(test_dataset)}") print(f"类别数: {len(train_dataset.classes)}") print(f"类别: {train_dataset.classes[:10]}...") # 显示前10个类别

单元格3：查看数据样本

# 显示一些样本图片 def imshow(inp, title=None): """显示张量图片""" inp = inp.numpy().transpose((1, 2, 0)) mean = np.array([0.485, 0.456, 0.406]) std = np.array([0.229, 0.224, 0.225]) inp = std * inp + mean # 反归一化 inp = np.clip(inp, 0, 1) plt.imshow(inp) if title is not None: plt.title(title) plt.axis('off') # 获取一个batch的数据 images, labels = next(iter(train_loader)) # 显示4张图片 fig, axes = plt.subplots(1, 4, figsize=(12, 3)) for i in range(4): ax = axes[i] imshow(images[i], title=train_dataset.classes[labels[i]]) plt.tight_layout() plt.show()

单元格4：创建和训练模型

# 使用预训练的ResNet18，修改最后一层 model = models.resnet18(pretrained=True) num_features = model.fc.in_features model.fc = nn.Linear(num_features, len(train_dataset.classes)) # 修改为37个类别 # 移动到GPU device = torch.device("cuda" if torch.cuda.is_available() else "cpu") model = model.to(device) # 定义损失函数和优化器 criterion = nn.CrossEntropyLoss() optimizer = optim.Adam(model.parameters(), lr=0.001) # 训练函数 def train_model(model, train_loader, criterion, optimizer, num_epochs=5): model.train() train_losses = [] train_accs = [] for epoch in range(num_epochs): running_loss = 0.0 correct = 0 total = 0 start_time = time.time() for batch_idx, (inputs, labels) in enumerate(train_loader): inputs, labels = inputs.to(device), labels.to(device) # 前向传播 outputs = model(inputs) loss = criterion(outputs, labels) # 反向传播和优化 optimizer.zero_grad() loss.backward() optimizer.step() # 统计 running_loss += loss.item() _, predicted = outputs.max(1) total += labels.size(0) correct += predicted.eq(labels).sum().item() # 每50个batch打印一次进度 if (batch_idx + 1) % 50 == 0: print(f'Epoch [{epoch+1}/{num_epochs}], ' f'Step [{batch_idx+1}/{len(train_loader)}], ' f'Loss: {loss.item():.4f}') epoch_loss = running_loss / len(train_loader) epoch_acc = 100. * correct / total epoch_time = time.time() - start_time train_losses.append(epoch_loss) train_accs.append(epoch_acc) print(f'Epoch {epoch+1}/{num_epochs} - ' f'Loss: {epoch_loss:.4f}, Acc: {epoch_acc:.2f}%, ' f'Time: {epoch_time:.2f}s') return train_losses, train_accs print("开始训练...") train_losses, train_accs = train_model(model, train_loader, criterion, optimizer, num_epochs=5)

单元格5：测试模型

# 测试函数 def test_model(model, test_loader): model.eval() correct = 0 total = 0 with torch.no_grad(): for inputs, labels in test_loader: inputs, labels = inputs.to(device), labels.to(device) outputs = model(inputs) _, predicted = outputs.max(1) total += labels.size(0) correct += predicted.eq(labels).sum().item() accuracy = 100. * correct / total print(f'测试准确率: {accuracy:.2f}%') return accuracy print("开始测试...") test_accuracy = test_model(model, test_loader)

单元格6：可视化训练结果

# 绘制训练曲线 fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(12, 4)) # 损失曲线 ax1.plot(train_losses, 'b-', linewidth=2) ax1.set_xlabel('Epoch') ax1.set_ylabel('Loss') ax1.set_title('Training Loss') ax1.grid(True) # 准确率曲线 ax2.plot(train_accs, 'r-', linewidth=2) ax2.set_xlabel('Epoch') ax2.set_ylabel('Accuracy (%)') ax2.set_title('Training Accuracy') ax2.grid(True) plt.tight_layout() plt.show() print(f"最终测试准确率: {test_accuracy:.2f}%")

运行完这6个单元格，你就完成了一个完整的图像分类项目！虽然准确率可能不是特别高（因为只训练了5个epoch），但整个流程是完整的。你可以尝试：

• 增加训练轮数（把num_epochs=5改成更大的数）
• 换更大的模型（比如ResNet50）
• 调整学习率
• 添加更多的数据增强

4.3 JupyterLab的实用技巧

快捷键：

• Shift+Enter: 运行当前单元格并跳到下一个
• Ctrl+Enter: 运行当前单元格
• A: 在上面插入单元格
• B: 在下面插入单元格
• DD（按两次D）：删除单元格
• M: 把单元格转为Markdown
• Y: 把单元格转为代码

魔法命令：

• %time: 测量单行代码运行时间
• %%time: 测量整个单元格运行时间
• %load_ext autoreload: 自动重载修改的模块
• %autoreload 2: 设置自动重载级别

扩展插件： JupyterLab支持很多有用的插件：

• @jupyterlab/git: Git版本控制
• @jupyterlab/toc: 自动生成目录
• @jupyter-widgets/jupyterlab-manager: 交互式控件

安装方法：在终端运行

pip install jupyterlab-git jupyter labextension install @jupyterlab/git

5. 常见问题与解决方案

5.1 CUDA不可用怎么办？

如果你运行torch.cuda.is_available()返回False，可能是以下几个原因：

原因1：驱动版本太低PyTorch 2.7需要NVIDIA驱动版本≥570。检查方法：

nvidia-smi

看顶部显示的Driver Version。如果低于570，需要升级：

# Ubuntu系统 sudo apt update sudo apt install nvidia-driver-570 sudo reboot

原因2：PyTorch版本不匹配确保安装的是CUDA 12.8版本的PyTorch：

import torch print(torch.__version__) # 应该显示 2.7.1+cu128

如果不是，重新安装：

pip install torch==2.7.1+cu128 torchvision==0.18.1+cu128 torchaudio==2.7.1+cu128 --index-url https://download.pytorch.org/whl/cu128

原因3：Docker权限问题如果你在Docker容器内，需要确保有GPU访问权限。启动容器时加上--gpus all参数。

5.2 显存不够用怎么办？

训练大模型时经常遇到OOM（Out Of Memory）错误。解决方法：

方法1：减小batch size这是最直接的方法。把batch size从32降到16或8：

# 修改DataLoader的batch_size train_loader = DataLoader(train_dataset, batch_size=16, shuffle=True) # 原来是32

方法2：使用混合精度训练PyTorch支持自动混合精度（AMP），能大幅减少显存占用：

from torch.cuda.amp import autocast, GradScaler scaler = GradScaler() for inputs, labels in train_loader: inputs, labels = inputs.cuda(), labels.cuda() optimizer.zero_grad() # 使用autocast with autocast(): outputs = model(inputs) loss = criterion(outputs, labels) # 使用scaler缩放梯度 scaler.scale(loss).backward() scaler.step(optimizer) scaler.update()

方法3：梯度累积如果batch size不能太小（影响效果），可以用梯度累积模拟大batch：

accumulation_steps = 4 # 累积4步 for i, (inputs, labels) in enumerate(train_loader): inputs, labels = inputs.cuda(), labels.cuda() outputs = model(inputs) loss = criterion(outputs, labels) loss = loss / accumulation_steps # 损失除以累积步数 loss.backward() if (i + 1) % accumulation_steps == 0: optimizer.step() optimizer.zero_grad()

方法4：检查内存泄漏有时候是代码问题导致内存不断增长：

import torch torch.cuda.empty_cache() # 清空缓存 # 监控显存使用 print(torch.cuda.memory_allocated() / 1e9, "GB") # 当前已分配 print(torch.cuda.memory_reserved() / 1e9, "GB") # 当前保留 print(torch.cuda.max_memory_allocated() / 1e9, "GB") # 历史最大

5.3 如何安装额外的包？

镜像已经预装了很多常用包，但你可能还需要其他库。安装方法：

方法1：使用pip

# 安装单个包 pip install pandas matplotlib seaborn # 安装指定版本 pip install transformers==4.38.0 # 从requirements.txt安装 pip install -r requirements.txt

方法2：使用conda（如果镜像包含）

conda install numpy scipy

方法3：安装开发版本

# 从GitHub安装 pip install git+https://github.com/用户名/仓库名.git # 安装本地包 pip install -e .

重要提示：如果你希望安装的包在重启后仍然存在，确保你的实例开启了“持久化存储”。否则，安装的包会在关机后丢失。

5.4 如何上传和下载文件？

上传文件到实例：

1. 在JupyterLab界面，直接拖拽文件到文件管理器
2. 或者点击上传按钮选择文件
3. 最大支持单个文件2GB

从实例下载文件：

1. 在JupyterLab中右键点击文件，选择“Download”
2. 或者用scp命令从本地下载：

   # 从本地终端执行 scp -P 32200 root@服务器IP:/path/to/file ./local/path

使用云存储： 对于大文件，建议使用云存储服务：

# 从URL下载 import urllib.request urllib.request.urlretrieve("https://example.com/model.pth", "model.pth") # 使用云存储SDK（如阿里云OSS、AWS S3） import boto3 s3 = boto3.client('s3') s3.download_file('bucket-name', 'object-key', 'local-file')

5.5 如何节省费用？

GPU实例是按使用时间计费的，这里有几个省钱技巧：

技巧1：不用时及时关机

• 训练完成后，立即在控制台关机
• 注意：关机后公网IP可能会变，但内网IP不变
• 持久化存储的数据不会丢失

技巧2：使用竞价实例

• 有些平台提供竞价实例，价格便宜30-70%
• 缺点是可能被回收，适合短时间训练

技巧3：监控使用情况

# 查看GPU使用率 nvidia-smi # 查看进程占用 nvidia-smi --query-compute-apps=pid,process_name,used_memory --format=csv # 杀死占用GPU的进程 kill -9 PID

技巧4：使用低配置调试

• 写代码和调试时用CPU或低配GPU实例
• 正式训练时再切换到高配GPU
• 很多平台支持快速切换实例类型

6. 总结

通过这篇教程，你应该已经掌握了：

1. 快速部署：5分钟内就能启动一个完整的PyTorch 2.7 GPU环境，不用自己折腾CUDA、驱动、依赖
2. 环境验证：用简单的代码检查CUDA是否可用，GPU是否识别
3. 基础使用：运行了第一个深度学习模型，看到了GPU带来的几十倍加速
4. 项目实战：在JupyterLab中完成了一个完整的图像分类项目
5. 问题解决：知道遇到常见问题（CUDA不可用、显存不足等）该怎么处理

PyTorch 2.7镜像最大的价值在于“开箱即用”和“环境一致”。无论你是个人学习、团队协作，还是项目部署，都能节省大量配置环境的时间。特别是对于新手，不用再被复杂的安装过程劝退，可以专注于学习深度学习的核心内容。

现在你已经有了一个强大的GPU开发环境，接下来可以：

• 尝试更复杂的模型（如Transformer、Diffusion模型）
• 跑一些开源项目（如Stable Diffusion、LLaMA）
• 学习模型训练和调参技巧
• 部署自己的AI服务

深度学习的世界很大，但入门可以很简单。从今天开始，用这个镜像开启你的AI之旅吧。

获取更多AI镜像

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