1. 为什么隔离内网里的 AI Agent 工程是另一套玩法
先把场景说清楚。所谓隔离内网,就是一台或者一批机器,物理上或者策略上跟公网断开,装不了外网依赖,拉不了镜像,连 pip install 都得走内部源,甚至根本没有源,只能靠离线包往里搬。这种环境在不少行业里是常态,比如做工业控制、做数据敏感型业务、做涉密研发的团队。你在自己笔记本上跑得飞起的 AI Agent 方案,搬到这种机器上,十有八九第一步就卡死。
我前后在三个隔离环境里落地过 AI Agent 相关的工程,踩的坑足够写一本小册子。最典型的一个误区是:很多人以为"内网部署"就是把外网那套东西打个包搬进去。实际上完全不是。外网环境里你依赖的是整个生态——模型 API、包管理、容器镜像仓库、各种在线工具服务。内网里这些全都没有,你手里只有一台或者几台裸机,加上一个 U 盘或者一条单向摆渡通道。这时候你要重新回答一个根本问题: 这个 Agent 到底靠什么活着?
AI Agent 的本质是一个"感知—决策—执行"的循环。感知靠输入(用户指令、文件、数据库),决策靠模型(本地或远程),执行靠工具调用(读写文件、跑命令、调接口)。在外网,这三块都有现成服务;在内网,每一块你都得自己搭。而 MCP(Model Context Protocol)和 Skills 这两个概念,恰好是解决"决策"和"执行"两块的关键抓手,也是最近热词里反复出现的东西。
MCP 你可以理解成一套标准化的"工具插座协议"。模型本身只会输出文本,它想读文件、查数据库、调内部系统,必须通过某种约定好的接口。MCP 就是把这个约定标准化了:工具方实现一个 MCP Server,模型侧通过 MCP Client 去调用,双方不用互相改代码。Skills 则更像是"能力包"或者"操作手册",把一类任务的提示词、工具组合、执行流程打包成一个可复用的单元,Agent 遇到对应场景就加载对应 Skill。
这两个东西在内网环境里的价值被放大了。因为内网里你没法随时上网找新工具、装新插件,一切都要提前规划、离线打包、可复现部署。MCP 让工具接入标准化,Skills 让能力复用标准化,两者配合,才能让一个 Agent 在内网里真正"干活",而不是只能聊天。
这篇文章面向的是需要在隔离内网里落地 AI Agent 的工程师,不管你是做后端、做运维还是做算法,只要你要把 Agent 搬进一个没有外网的环境,这里面的思路和坑都值得看一遍。我会从环境盘点、模型选型、MCP 工具链搭建、Skills 工程化、并发与稳定性、以及离线交付这几个角度,把整套流程拆开讲。
2. 进场前的环境盘点:先搞清楚你手里有什么
2.1 内网环境的三个硬约束
进内网之前,别急着写代码,先做一次彻底的环境盘点。我一般会列一张表,把约束分成三类:算力约束、网络约束、依赖约束。
算力约束决定你能跑多大的模型。内网机器如果是纯 CPU,那基本只能跑 7B 以下的量化模型,而且推理速度感人;如果有几张消费级显卡,可以上 14B 到 32B 的量化版本;如果有专业卡或者多卡,才有资格考虑 70B 级别。这个判断必须在动手前做完,因为它直接决定后面 Agent 的"智商上限"。
网络约束决定你能不能调外部模型 API。隔离内网通常是不能的,所以模型必须本地部署。但有些"半隔离"环境是允许通过特定网关访问内部模型服务的,这种就要提前确认网关地址、鉴权方式、限流策略。
依赖约束是最容易被低估的。内网机器上 Python 版本可能是 3.8,pip 源可能是空的,系统里没有 gcc,没有 git,甚至连 curl 都没有。你要装的每一个包,都得提前在外网同架构机器上打好 wheel 包,连同它的所有依赖一起搬进去。
提示:盘点时一定要确认内网机器的 CPU 架构(x86_64 还是 ARM)和操作系统版本。我见过有人在外网 x86 上打好的包,搬到内网 ARM 服务器上全部装不上,白折腾两天。
2.2 离线依赖包的准备方法
离线包准备有一套成熟流程,我把它总结成"三同原则":同架构、同系统、同 Python 版本。具体操作是在一台跟内网机器环境完全一致的外网机器上,用 pip download 把依赖全部拉下来。
# 在外网同环境机器上执行
pip download -r requirements.txt -d ./offline_packages \
--platform manylinux2014_x86_64 \
--python-version 38 \
--only-binary=:all:
这里有几个细节要注意。第一,
--only-binary=:all:
强制只下载 wheel 包,避免下载源码包导致内网编译失败。第二,如果某个包没有对应平台的 wheel,你就得在外网先编译好,或者找替代方案。第三,requirements.txt 里的版本号一定要锁死,用
==
而不是
>=
,否则内网安装时可能拉到不兼容的版本。
搬进去之后,用
pip install --no-index --find-links=./offline_packages -r requirements.txt
安装。
--no-index
是关键,它强制 pip 不去联网,只用本地包,能提前暴露缺包问题。
2.3 模型文件的搬运与校验
模型文件动辄几个 G 到几十个 G,搬运是个体力活。我的做法是:外网下载好后,先算一遍 SHA256,把哈希值记下来;搬进内网后再算一遍,比对一致才使用。这一步不能省,我遇到过 U 盘传输过程中文件损坏,模型加载时报奇怪的错,排查了半天才发现是文件不完整。
模型格式优先选 GGUF 或者 safetensors。GGUF 适合 CPU 和低显存场景,配合 llama.cpp 系列推理框架,量化等级从 Q4 到 Q8 都有,Q4_K_M 是性价比比较高的选择。safetensors 适合有显卡、用 vLLM 或类似框架的场景,加载快、显存占用可控。
3. 模型选型:内网里没有"随便换一个"这个选项
3.1 本地模型的取舍逻辑
外网环境里模型选型很随意,这个不行换那个,API 调不通换个服务商。内网里不行,你搬进去什么模型,大概率就要用很久。所以选型要一次到位。
我的选型逻辑是这样的:先看任务复杂度,再看算力,最后看量化损失。如果 Agent 主要做的是结构化任务——比如根据指令读写文件、调用内部接口、做格式转换——那 7B 到 14B 的模型足够,重点在工具调用的准确性,不在语言能力。如果 Agent 要做复杂的推理、多步规划、长文档理解,那至少要 32B 起步,否则它会频繁"犯迷糊"。
量化等级的选择有个经验值:Q4_K_M 是通用推荐,质量损失在可接受范围;Q5_K_M 更稳一点,显存多占 15% 左右;Q8_0 基本无损,但显存占用接近翻倍。内网里如果显存紧张,宁可选小一点的模型配高量化,也不要选大模型配低量化,后者在工具调用场景下错误率会明显上升。
3.2 推理框架的部署要点
CPU 场景我一般用 llama.cpp 的 server 模式,它自带一个兼容 OpenAI 接口的 HTTP 服务,Agent 侧不用改代码就能对接。
./llama-server -m ./models/qwen2.5-14b-instruct-q4_k_m.gguf \
--host 0.0.0.0 --port 8080 \
--ctx-size 8192 --threads 8
--ctx-size
是上下文长度,内网 Agent 经常要处理长文档,建议至少 8192,显存或内存够就上 16384。
--threads
设成物理核心数,别设成超线程数,否则反而慢。
GPU 场景用 vLLM,它的吞吐比 llama.cpp 高很多,适合多用户并发。
python -m vllm.entrypoints.openai.api_server \
--model ./models/Qwen2.5-14B-Instruct \
--served-model-name local-agent \
--tensor-parallel-size 2 \
--max-model-len 16384
--tensor-parallel-size
是张量并行数,等于你的显卡数量。
--max-model-len
要跟模型支持的最大长度匹配,设太大浪费显存,设太小长文档会截断。
注意:vLLM 启动时会预分配显存,如果显存不够会直接报错退出。启动前用
nvidia-smi确认空闲显存,留出至少 2G 余量给系统。
3.3 模型服务的健康检查
内网里模型服务挂了没人通知你,所以必须自己做健康检查。我一般写一个简单的探针脚本,定时打一个最小请求,看返回是否正常。
import requests, time
def health_check(url, model):
try:
r = requests.post(f"{url}/v1/chat/completions", json={
"model": model,
"messages": [{"role": "user", "content": "ping"}],
"max_tokens": 5
}, timeout=10)
return r.status_code == 200
except Exception:
return False
while True:
ok = health_check("http://127.0.0.1:8080", "local-agent")
if not ok:
print("model service down, restarting...")
# 触发重启逻辑
time.sleep(30)
这个探针配合 systemd 或者 supervisor,就能实现模型服务的自动拉起。内网环境里这种自愈能力很重要,因为你不一定能随时进机房。
4. MCP 工具链:让 Agent 在内网里真正"动手"
4.1 MCP 到底解决了什么问题
模型只会输出文本,它说"我要读取 /data/report.csv",这句话本身没有任何执行力。要让它真的读到文件,你得有个中间层,把模型的意图翻译成实际的文件操作。MCP 就是这个中间层的标准协议。
在没有 MCP 之前,每个 Agent 框架都自己定义工具调用格式,你换个框架就得重写一遍工具。MCP 把这个格式统一了:工具方实现 MCP Server,暴露一组标准接口;Agent 侧实现 MCP Client,按标准协议调用。双方解耦,工具可以跨框架复用。
内网里这个价值特别大。因为你没法随时上网找现成工具,所有工具都要自己写。如果每个工具都跟特定框架绑定,迁移成本极高。用 MCP 标准化之后,你写一次工具,换个 Agent 框架照样能用。
4.2 内网 MCP Server 的最小实现
MCP Server 本质是一个进程,通过标准输入输出或者 HTTP 跟 Client 通信。内网里我推荐用 stdio 模式,简单、无网络依赖、好调试。
# mcp_server_file.py
import json, sys, os
def handle_request(req):
method = req.get("method")
if method == "tools/list":
return {"tools": [
{"name": "read_file", "description": "读取指定路径的文件内容",
"inputSchema": {"type": "object", "properties": {"path": {"type": "string"}}}},
{"name": "write_file", "description": "写入内容到指定文件",
"inputSchema": {"type": "object", "properties": {
"path": {"type": "string"}, "content": {"type": "string"}}}},
{"name": "list_dir", "description": "列出目录内容",
"inputSchema": {"type": "object", "properties": {"path": {"type": "string"}}}}
]}
elif method == "tools/call":
params = req.get("params", {})
name = params.get("name")
args = params.get("arguments", {})
if name == "read_file":
with open(args["path"], "r", encoding="utf-8") as f:
return {"content": [{"type": "text", "text": f.read()}]}
elif name == "write_file":
with open(args["path"], "w", encoding="utf-8") as f:
f.write(args["content"])
return {"content": [{"type": "text", "text": "written"}]}
elif name == "list_dir":
return {"content": [{"type": "text", "text": "\n".join(os.listdir(args["path"]))}]}
return {"error": "unknown method"}
def main():
for line in sys.stdin:
line = line.strip()
if not line:
continue
req = json.loads(line)
resp = handle_request(req)
sys.stdout.write(json.dumps(resp) + "\n")
sys.stdout.flush()
if __name__ == "__main__":
main()
这个最小实现暴露了三个工具:读文件、写文件、列目录。看起来简单,但已经能支撑大量内网自动化场景。比如让 Agent 读日志、分析、写报告,全靠这三个工具。
4.3 工具权限的边界控制
内网里 Agent 能操作文件系统,这是把双刃剑。它能帮你干活,也可能误删重要文件。所以工具层必须做权限控制。
我的做法是在 MCP Server 里加一个白名单目录,所有文件操作都限制在白名单内。
ALLOWED_ROOTS = ["/data/agent_workspace", "/tmp/agent"]
def is_allowed(path):
real = os.path.realpath(path)
return any(real.startswith(os.path.realpath(root)) for root in ALLOWED_ROOTS)
每次文件操作前先调
is_allowed
,不在白名单内直接拒绝。这一步能挡住绝大多数误操作。另外写文件时建议加一个备份机制,覆盖前先把原文件复制一份到
.backup
目录,出问题能回滚。
提示:内网 Agent 的工具权限要遵循最小必要原则。能只读的就别给写权限,能限定目录的就别给全盘权限。我见过一个 Agent 因为工具没做限制,把整个配置目录清空了,恢复花了半天。
4.4 把内部系统封装成 MCP 工具
内网里 Agent 真正的价值在于对接内部系统。比如查工单、调监控、读数据库、触发构建。这些系统往往有自己的接口,你要做的是把它们封装成 MCP 工具。
以查询内部数据库为例,封装一个
query_db
工具:
import sqlite3
def query_db(sql, limit=100):
conn = sqlite3.connect("/data/internal.db")
conn.row_factory = sqlite3.Row
cur = conn.cursor()
cur.execute(sql)
rows = cur.fetchall()[:limit]
conn.close()
return [dict(r) for r in rows]
这里
limit
参数很重要,防止 Agent 生成一个
SELECT *
把大表全拉出来,把内存撑爆。工具层做防护,比指望模型自觉靠谱得多。
5. Skills 工程化:把重复劳动打包成能力单元
5.1 Skills 和 MCP 的分工
很多人搞不清 Skills 和 MCP 的区别。简单说,MCP 解决"能不能调工具",Skills 解决"知道什么时候调、怎么调、调完怎么处理"。MCP 是插座,Skills 是操作手册。
举个例子。你有一个
query_db
的 MCP 工具,这是插座。但 Agent 面对"帮我统计上周订单量"这个需求时,它需要知道:先查订单表,按时间过滤,做聚合,然后格式化输出。这一整套流程,就是 Skill。
内网里 Skills 的价值在于复用和一致性。同一个任务,不同人问,Agent 应该给出同样质量的结果。如果每次都靠模型自由发挥,结果会飘。把流程固化成 Skill,就能保证稳定性。
5.2 Skill 的结构设计
一个 Skill 我一般拆成四部分:触发条件、执行步骤、工具依赖、输出格式。
触发条件描述什么情况下加载这个 Skill。执行步骤是具体的操作流程。工具依赖列出需要哪些 MCP 工具。输出格式规定结果长什么样。
name: order_statistics
description: 统计指定时间范围内的订单数据
triggers:
- "统计订单"
- "订单量"
- "订单分析"
tools:
- query_db
steps:
- 解析用户输入中的时间范围,默认最近7天
- 调用 query_db 查询订单表,按时间过滤
- 按天聚合订单数量
- 计算环比变化
output_format: |
时间范围:{start} 至 {end}
总订单量:{total}
日均订单量:{avg}
环比变化:{change}
这种 YAML 结构的好处是可读、可版本管理、可离线分发。内网里没法用在线 Skill 市场,所有 Skill 都要自己维护,结构清晰就格外重要。
5.3 Skill 的加载与路由
Agent 收到用户输入后,要先判断该加载哪个 Skill。最简单的做法是关键词匹配,但关键词匹配容易误触发。更稳的做法是用模型做一次意图分类。
def route_skill(user_input, skills):
prompt = f"""根据用户输入,从以下 Skill 中选择最合适的一个。
用户输入:{user_input}
可选 Skill:
{chr(10).join(f"- {s['name']}: {s['description']}" for s in skills)}
只输出 Skill 名称,不要其他内容。"""
# 调用本地模型
result = call_model(prompt)
return result.strip()
这个路由步骤会多消耗一次模型调用,但换来的是准确性。内网里模型调用成本可控,这点开销值得。
5.4 Skill 的测试与迭代
Skill 写完不能直接用,必须测试。我一般准备一组测试用例,覆盖正常场景、边界场景、异常场景。
| 测试类型 | 输入示例 | 预期行为 |
|---|---|---|
| 正常场景 | 统计上周订单 | 返回正确统计数据 |
| 边界场景 | 统计今天订单 | 处理单日范围 |
| 异常场景 | 统计订单(无时间) | 使用默认7天 |
| 异常场景 | 统计未来订单 | 提示无数据 |
每次改 Skill 都跑一遍测试集,确保没退化。内网里没有 CI/CD 那么方便,测试脚本要提前准备好,能一键跑。
6. 并发与稳定性:内网 Agent 扛压的实战细节
6.1 并发瓶颈到底在哪
热词里有人问"AI Agent 怎么扛并发",这个问题在内网里更尖锐,因为算力有限。并发瓶颈通常不在 Agent 框架本身,而在模型推理。一个 14B 模型在单卡上,并发请求超过 4 个,响应时间就会明显上升。
所以扛并发的核心思路是: 限制并发数 + 排队 + 快速失败 。不要指望模型能无限并发,要在架构上做削峰。
import asyncio
from asyncio import Semaphore
sem = Semaphore(4) # 最多4个并发推理
async def handle_request(user_input):
async with sem:
return await call_model_async(user_input)
用信号量限制并发,超出的请求排队等待。如果队列太长,就返回"系统繁忙,请稍后重试",而不是让请求堆积到超时。
6.2 请求队列与超时控制
内网 Agent 经常要处理长任务,比如分析一个大日志文件。这种任务不能同步等,要改成异步任务队列。
import queue, threading
task_queue = queue.Queue(maxsize=100)
def worker():
while True:
task = task_queue.get()
try:
result = process_task(task)
task["callback"](result)
except Exception as e:
task["callback"]({"error": str(e)})
finally:
task_queue.task_done()
for _ in range(4):
threading.Thread(target=worker, daemon=True).start()
队列设上限,满了就拒绝新任务。每个任务设超时,超时就中断。这样即使某个任务卡住,也不会拖垮整个系统。
6.3 模型服务的降级策略
内网里模型服务可能因为各种原因不可用:显存溢出、进程崩溃、机器重启。这时候 Agent 要有降级策略。
我的做法是准备一个"轻量模式":当主模型不可用时,切换到一个小模型或者规则引擎,至少保证基础功能可用。比如文件读写、简单查询这些不依赖复杂推理的任务,用规则就能处理。
def get_model_client():
if is_healthy(PRIMARY_MODEL):
return PrimaryClient()
elif is_healthy(FALLBACK_MODEL):
return FallbackClient()
else:
return RuleBasedClient()
这种分级降级能让系统在部分故障时仍然可用,而不是直接全挂。
6.4 日志与可观测性
内网里出问题,你没法远程调试,只能靠日志。所以日志要打得足够细。
我一般记录这几类信息:每次模型调用的输入输出、每次工具调用的参数和结果、每个请求的耗时、每个异常堆栈。日志按天切分,保留至少 30 天。
import logging, json
from datetime import datetime
logging.basicConfig(
filename=f"/var/log/agent/agent_{datetime.now():%Y%m%d}.log",
level=logging.INFO,
format="%(asctime)s %(levelname)s %(message)s"
)
def log_call(kind, payload, duration):
logging.info(json.dumps({
"kind": kind, "payload": payload, "duration": duration
}, ensure_ascii=False))
日志里不要记录敏感数据,比如密码、密钥。内网环境虽然相对封闭,但日志管理的基本规范还是要遵守。
7. 离线交付:把整套系统打包搬进内网
7.1 交付物的组织方式
内网交付不是拷几个文件那么简单,要组织成一个可复现的包。我一般按这个结构组织:
agent_delivery/
├── models/ # 模型文件
├── packages/ # 离线依赖包
├── mcp_servers/ # MCP 工具实现
├── skills/ # Skill 定义
├── configs/ # 配置文件
├── scripts/ # 启动、检查脚本
├── docs/ # 部署文档
└── checksums.txt # 所有文件的哈希
每个目录都有明确职责,部署时按文档一步步来。
checksums.txt
用于校验完整性,搬进去后先跑一遍校验,确认没损坏再部署。
7.2 一键部署脚本
内网里手动部署容易出错,我一般写一个部署脚本,把能自动化的都自动化。
#!/bin/bash
set -e
echo "校验文件完整性..."
sha256sum -c checksums.txt
echo "安装依赖..."
pip install --no-index --find-links=./packages -r requirements.txt
echo "启动模型服务..."
nohup ./scripts/start_model.sh > /var/log/agent/model.log 2>&1 &
echo "等待模型就绪..."
for i in {1..30}; do
if curl -s http://127.0.0.1:8080/health > /dev/null; then
echo "模型服务就绪"
break
fi
sleep 2
done
echo "启动 Agent 服务..."
nohup ./scripts/start_agent.sh > /var/log/agent/agent.log 2>&1 &
echo "部署完成"
set -e
让脚本遇到错误立即退出,避免错误累积。等待模型就绪的循环很重要,否则 Agent 启动时模型还没准备好,会报连接错误。
7.3 部署后的验收清单
部署完不能就算完,要有一份验收清单,逐项确认。
| 检查项 | 检查方法 | 通过标准 |
|---|---|---|
| 模型服务 | curl 健康接口 | 返回 200 |
| MCP 工具 | 调用 tools/list | 返回工具列表 |
| Skill 加载 | 触发一个 Skill | 正确执行 |
| 文件权限 | 尝试越权访问 | 被拒绝 |
| 日志输出 | 查看日志文件 | 有正常记录 |
| 并发能力 | 并发发 10 个请求 | 全部正常返回 |
这份清单每次部署都跑一遍,能挡住大部分低级问题。
7.4 版本管理与回滚
内网里升级是个麻烦事,因为没法随时回滚。所以每次交付都要保留上一个版本,出问题能切回去。
我的做法是交付包带版本号,部署时解压到带版本号的目录,用一个软链接指向当前版本。
ln -sfn /opt/agent/v1.2.0 /opt/agent/current
升级时部署新版本,改软链接指向新版本,重启服务。回滚时把软链接改回旧版本,重启即可。这样切换成本极低,风险可控。
8. 几个我踩过的坑和对应的解法
8.1 模型输出格式不稳定导致工具调用失败
内网里用的模型往往比外网 API 弱,输出格式容易飘。你要求它输出 JSON,它可能给你输出一段带解释的文字。这时候工具调用就解析失败。
解法是在提示词里强化格式要求,同时在解析层做容错。比如用正则从输出里提取 JSON 片段,而不是直接
json.loads
整个输出。
import re, json
def extract_json(text):
match = re.search(r'\{.*\}', text, re.DOTALL)
if match:
try:
return json.loads(match.group())
except json.JSONDecodeError:
return None
return None
另外可以在模型侧用 grammar 约束输出格式,llama.cpp 支持 GBNF 语法,能强制模型只输出合法 JSON。这个手段在内网里特别有用,能大幅降低解析失败率。
8.2 长上下文导致显存溢出
内网 Agent 处理长文档时,上下文会迅速膨胀。14B 模型在 16K 上下文下,显存占用可能超过 24G。如果显存不够,推理直接失败。
解法有两个:一是做上下文压缩,把长文档分段处理,只把相关片段喂给模型;二是用滑动窗口,保留最近 N 轮对话,老的截断。
def truncate_context(messages, max_tokens=8000):
total = 0
result = []
for msg in reversed(messages):
tokens = estimate_tokens(msg["content"])
if total + tokens > max_tokens:
break
result.insert(0, msg)
total += tokens
return result
estimate_tokens
可以简单按字符数除以 2 估算,中文场景下比较接近。
8.3 工具调用死循环
Agent 有时候会陷入死循环:调工具、看结果、再调同样的工具、再看结果,反复不停。内网里没人盯着,这种循环会一直消耗资源。
解法是加调用次数限制和重复检测。同一个工具用相同参数调用超过 3 次,就强制中断,返回错误。
call_history = {}
def check_loop(tool_name, args):
key = f"{tool_name}:{json.dumps(args, sort_keys=True)}"
call_history[key] = call_history.get(key, 0) + 1
if call_history[key] > 3:
raise Exception(f"检测到重复调用:{key}")
这个简单的检测能挡住绝大多数死循环。
8.4 内网时间不同步导致日志混乱
内网机器如果没配 NTP,时间可能跟实际差很多。多台机器日志时间不一致,排查问题时会很痛苦。
解法是部署前统一校时,或者至少在日志里记录相对时间戳。如果内网有内部 NTP 服务器,优先用它;没有的话,手动同步一次,然后定期检查偏差。
9. 关于内网 Agent 工程的一点个人体会
做内网 AI Agent 这几年,我最大的感受是: 外网拼的是选型,内网拼的是工程 。外网环境里,模型不行换一个,工具不够装一个,框架不爽换一个,试错成本低。内网里每一步都要提前规划,搬进去就不好改,所以工程能力比技术选型更重要。
MCP 和 Skills 这两个东西,在外网可能只是锦上添花,在内网却是雪中送炭。它们把工具接入和能力复用标准化了,让内网 Agent 从"一次性脚本"变成"可维护系统"。我建议任何要在内网落地 Agent 的团队,都先把这两个概念吃透,再动手写代码。
另外一点,内网环境里不要追求"大而全"。我见过有人想在内网复刻一整套外网的 Agent 生态,结果做了半年还没跑通。正确的做法是聚焦一个具体场景,用最小的工具集和 Skill 集把它跑通,然后再逐步扩展。先能用,再好用,最后才是强大。
最后分享一个实用技巧:内网部署前,一定要在外网搭一个"仿真内网"环境,把网络断开、依赖清空、模型本地化,完整跑一遍部署流程。这一步能提前暴露 90% 的问题,比搬进去再排查高效得多。仿真环境跑通了,真实内网部署基本就是体力活了。
1655



被折叠的 条评论
为什么被折叠?



