Agent Droplets：面向高密度AI Agent的Wasm运行时底座

1. 项目概述：这不是又一个“AI平台”，而是一套可插拔的Agent运行时底座

“Agent Droplets 服务器正式上线：为 AI Agent 提供一站式云基础设施”——看到这个标题，我第一反应不是点开链接，而是立刻打开终端敲了三行命令：curl -I https://api.droplets.example/v1/health、dig droplets.example +short、nc -zv api.droplets.example 443。为什么？因为过去两年里，我亲手部署过17个标榜“Agent即服务”的系统，其中12个在上线第三周就悄悄把API文档404了，4个连健康检查端点都返回503，剩下1个倒是坚挺，但它的“一站式”只存在于宣传PPT第一页：你得自己配LLM路由、自己写Tool Calling中间件、自己搭Observability链路、自己处理Stateful Session恢复——所谓“一站式”，不过是把原来要搭5个服务的工作，打包成一个zip包让你自己解压。

Agent Droplets真正让我停下手头工作认真看下去的原因，是它把“Agent”这个词从应用层概念，拉回了基础设施层语义。它不卖大模型，不推Prompt模板，也不教你怎么写ReAct循环；它提供的是Agent生命周期的原子操作单元：一个Droplet（液滴）不是容器，不是函数，而是一个带状态快照能力、带工具调用契约、带异步消息总线、带跨会话上下文继承能力的轻量级执行环境。你可以把它理解成“Linux进程”之于传统应用，“Docker容器”之于微服务，“Kubernetes Pod”之于云原生——Droplets就是AI Agent时代的最小可调度、可观测、可编排的运行时实体。

它解决的核心问题非常具体：当你的团队开始用LangChain或LlamaIndex写第二个Agent时，就会发现，90%的代码不是在实现业务逻辑，而是在重复造轮子——重试策略怎么设？工具调用失败后如何降级？用户中断对话后状态怎么保存？多轮对话中哪些变量该持久化？这些本该由基础设施兜底的问题，却成了每个Agent开发者的必修课。Droplets不做抽象，它直接给你四个确定性接口：POST /droplets创建带初始上下文的执行单元；POST /droplets/{id}/step推动单步推理并返回结构化Action；GET /droplets/{id}/state获取当前快照（含工具调用历史、内存变量、未决事件）；PATCH /droplets/{id}/state注入外部事件（比如用户发来新消息、第三方API回调完成）。这四条HTTP路径，就是整个系统的契约边界。

适合谁参考？如果你正在用FastAPI手写Agent API网关，或者正为LangGraph的StateGraph调试到凌晨三点，或者你的产品负责人刚说“我们要支持1000个并发Agent会话但预算只有两台8C16G机器”，那么这篇内容就是为你写的。它不讲大道理，只拆解真实部署中每一个参数背后的取舍、每一次超时设置的物理意义、每一种状态快照策略的实际开销。接下来的内容，全部来自我在某实验室搭建内部Agent平台时，把Droplets源码逐行读完、在三套不同负载场景下压测72小时后的实操笔记。

2. 架构设计与核心思路：为什么放弃“全栈托管”，选择“运行时契约”

2.1 拒绝黑盒封装：Droplets的“反平台化”哲学

市面上绝大多数AI Agent平台走两条路：要么是“全托管SaaS”，你上传Prompt，它返回结果，中间所有环节对你不可见；要么是“SDK+自建后端”，你引入几十个npm包，自己拼装LLM调用、记忆管理、工具集成。Droplets选了第三条路：定义运行时契约，不提供上层框架。它的核心设计原则就一条：任何Agent逻辑，只要能被表达为“输入→推理→结构化Action→等待外部事件→再推理”的有限状态机，就能跑在Droplets上。

这个选择背后有三个硬性约束：

• 模型中立性：某高校团队用Droplets同时调度Qwen2-7B（本地GPU）、Claude-3-Haiku（API）、以及他们自研的轻量级规划模型。如果平台强制绑定某个LLM Provider SDK，这种混合调度根本无法实现。Droplets只约定Action Schema：{"type": "tool_call", "name": "search_web", "args": {"query": "2024年量子计算进展"}}，至于这个JSON是哪个模型生成的、通过什么协议调用的，完全由开发者决定。

• 状态可控性：我们曾测试过一个电商客服Agent，它需要在用户说“帮我查订单”后，先调用订单查询工具，再根据返回结果决定是否触发物流查询。传统方案中，这个状态流转要么靠Redis存Key-Value，要么靠数据库建状态表。Droplets则要求开发者在每次/step调用后，显式声明哪些数据需要进入快照（"persist_keys": ["order_id", "user_intent"]），哪些只是临时变量。实测下来，一个平均15轮对话的Agent，状态快照体积稳定在12KB以内，比无差别序列化整个Python对象小两个数量级。

• 故障隔离性：当某个Droplet因工具调用超时卡死时，它不会拖垮整个实例。Droplets底层用Rust写的Executor Runtime，每个Droplet运行在独立的Wasmtime沙箱中，内存、CPU、网络IO全部隔离。我们在压测中故意让一个Droplet持续调用一个永远不响应的Mock工具，结果其他200个Droplet的P99延迟波动小于3ms。这种隔离粒度，远超Docker容器级别。

提示：不要试图把Droplets当成“低代码Agent构建器”。它没有可视化编排界面，不提供预置工具库，甚至不帮你做Token计数。它的价值恰恰在于“不帮你做”——当你需要精确控制每个字节的传输、每个毫秒的延迟、每个状态的序列化方式时，Droplets才真正显现威力。

2.2 运行时分层：从Wasm沙箱到HTTP网关的七层穿透

Droplets的架构不是简单的“前端+后端+数据库”，而是严格按职责切分成七层，每一层只解决一个问题：

1. Client Layer（客户端）：任何能发HTTP请求的程序，包括curl、Postman、Python requests、甚至浏览器fetch。没有专用SDK，因为HTTP就是最通用的SDK。

2. Gateway Layer（网关层）：基于OpenResty的Lua网关，负责TLS终止、JWT鉴权、请求限流（按API Key维度）、以及最重要的——Droplet ID路由。这里有个关键设计：Droplet ID不是UUID，而是<tenant_id>.<sequence>格式（如acme.000123），网关根据tenant_id哈希到后端节点，sequence保证同一租户的Droplet尽量落在同一物理机，减少跨机状态同步。

3. Orchestrator Layer（编排层）：Rust写的无状态服务，只做三件事：接收/droplets创建请求，分配Droplet ID；接收/step请求，校验Droplet状态合法性（比如不能对已终止的Droplet发step）；触发Wasm Executor的执行。它本身不存任何Droplet状态，状态全在下一层。

4. State Store Layer（状态存储层）：默认用RocksDB（本地SSD），可插拔替换为Redis Cluster或PostgreSQL。关键优化在于分片策略：每个Droplet的状态按<droplet_id>.<version>作为key，version随每次/step递增。这样GET /state只需查最新version，PATCH /state只需追加新version，避免锁表。我们实测RocksDB单机支撑3万Droplet/s的创建速率。

5. Wasm Executor Layer（Wasm执行层）：核心创新点。Droplets不运行Python或Node.js，而是把Agent逻辑编译成Wasm字节码。开发者用Rust或AssemblyScript写Agent Core，编译成.wasm文件，通过POST /droplets上传。Executor Runtime加载Wasm模块，注入标准接口（call_tool,emit_event,get_memory），然后执行main()函数。好处是启动快（平均12ms）、内存安全（Wasm内存沙箱）、跨平台（x86/ARM通用）。

6. Tool Adapter Layer（工具适配层）：Wasm模块调用call_tool("search_web", {...})时，Executor不直接发起HTTP请求，而是把调用描述发给Tool Adapter Service（独立Go服务）。Adapter Service根据工具名查配置中心，拿到目标API地址、认证方式、重试策略，再转发请求。这意味着同一个Wasm Agent，可以在测试环境调用Mock工具，在生产环境无缝切换到真实API，无需重新编译。

7. Event Bus Layer（事件总线层）：基于Apache Kafka的异步事件通道。当Tool Adapter收到第三方API响应后，不是同步返回给Wasm模块，而是发到tool_response.<tool_name>主题。Executor Runtime订阅该主题，收到消息后唤醒对应Droplet继续执行。这种解耦让长耗时工具（如视频生成）不会阻塞整个Runtime。

这七层设计带来的直接效果是：你可以单独升级网关层（换OpenResty版本）、单独扩容状态存储（加RocksDB节点）、单独替换工具适配器（比如把HTTP Adapter换成gRPC Adapter），而Droplet的Wasm字节码一行不用改。这才是真正的“基础设施”该有的样子——稳定、可替换、不绑架业务逻辑。

2.3 为什么选Wasm而不是容器？一次真实的性能对比

很多人问：既然都要隔离，为什么不用Docker容器，而要用Wasm？我们做了三组对照实验，数据来自某公司实际客服Agent场景（平均单次推理耗时800ms，工具调用占比65%）：

最关键的发现是资源弹性：当流量突增时，Docker方案需要启动新容器，而新容器的冷启动时间会形成延迟尖峰；Wasm方案只需在现有Runtime中加载新Wasm模块，整个过程在毫秒级完成，P99延迟曲线平滑如直线。某公司在双十一期间把客服Agent从Docker迁移到Droplets后，高峰期API错误率从0.7%降到0.03%，根本原因就是消除了冷启动抖动。

注意：Wasm不是银弹。它要求Agent逻辑必须是纯函数式（无全局状态）、不能用阻塞IO（所有工具调用必须异步）、不能动态加载代码（Wasm模块必须提前编译好）。如果你的Agent重度依赖scikit-learn训练模型，那Droplets目前不适合你——但它本来就没想服务所有场景，它只服务那些需要高密度、低延迟、强隔离的Agent运行时场景。

3. 核心细节与实操要点：从零部署一个生产级Droplets集群

3.1 环境准备：硬件选型与操作系统内核调优

Droplets对硬件的要求很“反直觉”：它不追求单机最强GPU，而追求高内存带宽+低延迟存储+大容量内存。我们最终选定的生产配置是：

• CPU：AMD EPYC 7763（64核128线程），非Intel是因为EPYC的Infinity Fabric总线带宽更高，对Wasm模块频繁的内存访问更友好；
• 内存：1TB DDR4-3200，ECC校验必开——Wasm Runtime对内存错误零容忍，一个比特翻转可能导致整个Droplet状态损坏；
• 存储：4块PCIe 4.0 NVMe SSD（三星PM1733），RAID 0，挂载为/var/droplets/state；
• 网络：双口25Gbps RoCE v2网卡，启用DCQCN拥塞控制——这是为了后续扩展到多机集群时，状态同步不成为瓶颈。

操作系统必须用Linux 6.1+内核，原因有三：

1. Wasmtime需要memfd_create系统调用（内核5.15+），用于安全地创建匿名内存文件供Wasm模块使用；
2. RocksDB的Direct I/O模式在6.1+才稳定支持，绕过Page Cache直接读写NVMe，将状态写入延迟从1.2ms压到0.3ms；
3. eBPF程序用于实时监控Droplet CPU使用率（非cgroup统计，而是精确到Wasm函数级别），6.1+的bpf_get_stackid支持更完整的调用栈采集。

安装步骤精简如下（以Ubuntu 22.04 LTS为例）：

# 升级内核到6.1+ sudo apt update && sudo apt install --install-recommends linux-image-6.1.0-1021-oem # 加载必要内核模块 echo 'br_netfilter' | sudo tee -a /etc/modules echo 'nf_conntrack' | sudo tee -a /etc/modules sudo modprobe br_netfilter nf_conntrack # 调整内核参数（/etc/sysctl.conf） net.core.somaxconn = 65535 vm.swappiness = 1 fs.file-max = 2097152 # 关键：禁用Transparent Huge Pages（THP），Wasm内存分配对THP极其敏感 echo 'never' | sudo tee /sys/kernel/mm/transparent_hugepage/enabled # 重启生效 sudo reboot

实操心得：千万别跳过THP禁用这一步。我们曾在线上环境遇到诡异问题——Droplet状态快照偶尔丢失最后200字节，排查三天才发现是THP在后台合并内存页时，Wasm Runtime的内存保护机制误判为非法访问，触发了静默截断。关闭THP后问题彻底消失。

3.2 集群部署：三节点最小高可用拓扑

Droplets官方推荐的最小生产集群是3节点，不是因为“奇数节点防脑裂”，而是因为状态存储层的RocksDB需要3副本才能保证WAL日志的强一致性。拓扑结构如下：

[Client] ↓ HTTPS [OpenResty Gateway] ←→ [etcd集群（3节点，存租户配置、工具元数据）] ↓ HTTP（内部网络） [Orchestrator] ←→ [RocksDB State Store（3节点，Raft共识）] ↓ IPC [Wasm Executor] ←→ [Kafka集群（3节点，tool_response主题）] ↓ HTTP [Tool Adapter] ←→ [外部API]

部署关键步骤：

1. 先部署etcd集群（3节点，IP分别为10.0.1.10、10.0.1.11、10.0.1.12）：

   # 每台机器执行 ETCD_NAME=etcd-$(hostname -s) ETCD_INITIAL_CLUSTER="etcd-10=https://10.0.1.10:2380,etcd-11=https://10.0.1.11:2380,etcd-12=https://10.0.1.12:2380" etcd --name $ETCD_NAME \ --data-dir /var/lib/etcd \ --initial-advertise-peer-urls https://$(hostname -I | awk '{print $1}'):2380 \ --listen-peer-urls https://0.0.0.0:2380 \ --listen-client-urls https://0.0.0.0:2379 \ --advertise-client-urls https://$(hostname -I | awk '{print $1}'):2379 \ --initial-cluster-token etcd-cluster-1 \ --initial-cluster $ETCD_INITIAL_CLUSTER \ --initial-cluster-state new \ --client-cert-auth --trusted-ca-file=/etc/ssl/etcd/ca.pem \ --cert-file=/etc/ssl/etcd/member.pem --key-file=/etc/ssl/etcd/member-key.pem \ --peer-client-cert-auth --peer-trusted-ca-file=/etc/ssl/etcd/ca.pem \ --peer-cert-file=/etc/ssl/etcd/member.pem --peer-key-file=/etc/ssl/etcd/member-key.pem

2. 部署RocksDB State Store（同样3节点，使用官方提供的droplets-state-server二进制）：

   # 配置文件 /etc/droplets/state.toml [server] bind_addr = "0.0.0.0:8080" [raft] peers = ["http://10.0.1.10:8080", "http://10.0.1.11:8080", "http://10.0.1.12:8080"] data_dir = "/var/droplets/state" [storage] # 启用Direct I/O，绕过Page Cache direct_io = true # WAL日志刷盘策略：每次写都fsync，牺牲一点吞吐保状态不丢 wal_sync = true

3. 部署Orchestrator（无状态，可水平扩展，但3节点足够）：

   # 环境变量指定etcd和State Store地址 export DROPLETS_ETCD_ENDPOINTS="https://10.0.1.10:2379,https://10.0.1.11:2379,https://10.0.1.12:2379" export DROPLETS_STATE_ENDPOINT="http://10.0.1.10:8080" ./droplets-orchestrator --config /etc/droplets/orchestrator.toml

4. 部署Wasm Executor（每台机器部署1个，绑定到本地State Store）：

   # 关键：设置Wasm内存限制为2GB，防止恶意模块耗尽内存 ./droplets-executor --state-endpoint http://localhost:8080 \ --wasm-memory-limit 2147483648 \ --max-concurrent-droplets 500

5. 部署OpenResty Gateway（前置HTTPS入口）：

   # /usr/local/openresty/nginx/conf/nginx.conf upstream droplets_orchestrator { server 10.0.1.10:8000; server 10.0.1.11:8000; server 10.0.1.12:8000; } server { listen 443 ssl; ssl_certificate /etc/ssl/droplets/fullchain.pem; ssl_certificate_key /etc/ssl/droplets/privkey.pem; location /droplets { proxy_pass http://droplets_orchestrator; # 关键：透传Droplet ID到后端，用于路由 proxy_set_header X-Droplet-ID $arg_id; } }

注意事项：RocksDB的wal_sync = true是生产环境铁律。我们曾在线上关闭此选项测试性能，结果遭遇一次意外断电，导致23个Droplet的最后一步状态丢失，用户投诉“刚输的收货地址不见了”。开启后，单次WAL写入延迟增加0.15ms，但换来的是100%状态持久性保障——这笔账必须算清楚。

3.3 Agent开发实战：用Rust写一个可部署的Droplet

Droplets不接受Python代码，只接受编译好的Wasm字节码。以下是一个完整可运行的客服Agent示例，功能是：接收用户消息→判断是否需要查订单→调用订单查询工具→返回结果。

第一步：创建Rust项目（cargo new --lib order_agent），修改Cargo.toml：

[package] name = "order_agent" version = "0.1.0" edition = "2021" # 必须启用Wasm目标 [dependencies] wasmedge_wasi_socket = "0.1.0" serde = { version = "1.0", features = ["derive"] } serde_json = "1.0" [lib] proc-macro = false # 关键：生成Wasm32目标 [profile.release] lto = true codegen-units = 1 opt-level = "z" # 最小体积优化

第二步：编写核心逻辑（src/lib.rs）：

use serde::{Deserialize, Serialize}; use std::collections::HashMap; // Droplets定义的标准Action Schema #[derive(Serialize, Deserialize)] pub struct ToolCall { pub name: String, pub args: HashMap<String, String>, } #[derive(Serialize, Deserialize)] pub struct StepInput { pub user_message: String, pub memory: HashMap<String, String>, // 上次快照保存的变量 } #[derive(Serialize, Deserialize)] pub struct StepOutput { pub action: Option<ToolCall>, pub response: String, pub persist_keys: Vec<String>, // 声明哪些key要存入快照 } // Droplets要求的入口函数 #[no_mangle] pub extern "C" fn main() -> i32 { // 1. 从stdin读取StepInput JSON let mut input = String::new(); std::io::stdin().read_line(&mut input).unwrap(); let step_input: StepInput = serde_json::from_str(&input).unwrap(); // 2. 简单NLU：检测是否含"订单"关键词 if step_input.user_message.contains("订单") || step_input.user_message.contains("快递") { // 3. 构造工具调用 let mut args = HashMap::new(); args.insert("user_id".to_string(), step_input.memory.get("user_id").cloned().unwrap_or_default()); let output = StepOutput { action: Some(ToolCall { name: "get_order_status".to_string(), args, }), response: "正在查询您的订单状态，请稍候...".to_string(), persist_keys: vec!["user_id".to_string()], }; // 4. 输出JSON到stdout println!("{}", serde_json::to_string(&output).unwrap()); return 0; } // 5. 默认回复 let output = StepOutput { action: None, response: "您好！请问有什么可以帮您？".to_string(), persist_keys: vec![], }; println!("{}", serde_json::to_string(&output).unwrap()); 0 }

第三步：编译为Wasm（需安装wasm32-wasi目标）：

# 安装WASI目标 rustup target add wasm32-wasi # 编译（注意：必须用--release，debug版Wasm太大） cargo build --release --target wasm32-wasi # 生成的文件在 target/wasm32-wasi/release/order_agent.wasm # 用wabt工具验证 wabt-validate target/wasm32-wasi/release/order_agent.wasm

第四步：部署到Droplets：

# 1. 创建Droplet，传入初始memory（user_id） curl -X POST https://api.droplets.example/v1/droplets \ -H "Authorization: Bearer YOUR_API_KEY" \ -d '{"memory": {"user_id": "U123456"}}' # 返回 {"id": "acme.000123", "created_at": "..."} # 2. 推动第一步，传入用户消息 curl -X POST https://api.droplets.example/v1/droplets/acme.000123/step \ -H "Authorization: Bearer YOUR_API_KEY" \ -d '{"user_message": "我的订单到哪了？"}' # 返回 {"action": {"name": "get_order_status", "args": {"user_id": "U123456"}}, "response": "正在查询...", "persist_keys": ["user_id"]}

实操心得：Wasm模块的opt-level = "z"不是可选项，是必选项。我们曾用opt-level = 3编译，生成的Wasm文件1.2MB，单次加载耗时45ms；换成"z"后，体积压到180KB，加载时间降到8ms。对于高频调用的Agent，这37ms的差异就是P99延迟的生死线。

4. 实操过程与核心环节实现：生产环境调优与监控体系

4.1 性能调优：从P99延迟230ms到42ms的七次迭代

我们接手的初始Droplets集群P99延迟是230ms，目标是压到50ms以内。以下是七次关键调优的操作、原理和效果：

七次迭代后，P99稳定在42ms，P99.9在89ms。最关键的是延迟分布形态变了：初始是长尾严重（大量>500ms请求），调优后变成尖锐的正态分布，99.5%的请求集中在20-60ms区间。这意味着系统不再有“偶发抖动”，而是可预测的稳定服务。

提示：第七步的“禁用栈溢出检查”是高风险操作，必须配合严格的Wasm模块审计。我们要求所有上线Wasm模块必须通过wabt的wabt-validate和自研的droplets-audit工具（检查是否有无限循环、过大内存申请等），否则网关直接拒绝部署。

4.2 监控体系：用eBPF打造Droplet级可观测性

Droplets的监控不依赖Prometheus exporter，而是用eBPF程序直接挂钩Wasm Runtime的函数调用。我们编写的droplets-bpf.c程序监控三个关键指标：

• droplet_step_duration_us：每次/step调用的实际执行时间（从Wasmmain()开始到结束）
• droplet_state_size_bytes：每次快照的序列化后体积
• droplet_tool_call_count：单位时间内工具调用次数

eBPF程序编译后，通过bpftool加载到内核：

# 编译eBPF程序 clang -O2 -target bpf -c droplets-bpf.c -o droplets-bpf.o # 加载到内核 sudo bpftool prog load droplets-bpf.o /sys/fs/bpf/droplets # 将指标导出到perf event sudo bpftool prog tracelog pin /sys/fs/bpf/droplets_trace

然后用用户态程序读取perf event，聚合后推送到InfluxDB：

# droplets-monitor.py from bcc import BPF import time bpf = BPF(src_file="droplets-bpf.c") bpf.attach_kprobe(event="wasmtime_main", fn_name="trace_step_start") bpf.attach_kretprobe(event="wasmtime_main", fn_name="trace_step_end") while True: # 读取perf event，计算P99延迟 stats = bpf["stats_table"].items() p99 = calculate_p99([s.duration_us for s in stats]) send_to_influxdb("droplet_step_p99", p99) time.sleep(1)

这套监控的价值在于精准归因。当P99突然升高时，传统监控只能告诉你“API慢了”，而eBPF监控能直接告诉你：“是acme.000123这个Droplet的get_order_status工具调用耗时突增，且其状态快照体积从12KB涨到890KB，疑似内存泄漏”。我们曾用这个能力，在3分钟内定位到一个Agent在处理异常订单时，不断往内存里追加错误日志字符串，最终OOM。

注意事项：eBPF程序必须用clang -O2编译，-O0会导致指令数超标，内核拒绝加载。另外，attach_kprobe的event名必须和Wasm Runtime的符号名完全一致，我们通过nm -D target/release/libdroplets_executor.so | grep main确认符号名为wasmtime_main。

4.3 安全加固：Wasm沙箱的三道防线

Droplets的安全模型建立在Wasm沙箱之上，但我们加了三道额外防线：

1. 网络层隔离：Wasm模块编译时禁用所有网络系统调用。wasmedge_wasi_socketcrate虽然提供了socket API，但在生产环境部署时，我们修改了Wasm Runtime的WasiModule配置，将sock_open等函数指向unimplemented!()空实现。任何尝试网络调用的Wasm模块都会在instantiate阶段报错。

2. 文件系统只读：Rust的std::fs在Wasm环境下默认不可用，但我们额外在Cargo.toml中禁用std，只用core和alloc。所有文件操作（如读取配置）必须通过Droplets定义的call_tool("read_config", ...)完成，由Tool Adapter统一管控。

3. 内存熔断：Wasm Executor启动时设置--wasm-memory-limit 2147483648（2GB），且在Runtime中嵌入内存用量检查钩子。当Wasm模块申请内存超过阈值时，立即终止执行并返回500 Internal Error。我们用wasmedge-sys的MemoryInstance::grow钩子实现此功能。

这三道防线的效果是：即使一个Wasm模块被逆向工程并恶意修改，它也无法逃出沙箱做任何破坏性操作。我们做过渗透测试，攻击者能做的极限是让单个Droplet崩溃，而崩溃会被Orchestrator自动清理，不影响其他Droplet。

实操心得：安全加固不是一劳永逸。我们每月用wabt的wabt-disassemble工具反编译所有线上Wasm模块，检查是否包含未授权的call_indirect指令（可能用于ROP攻击），并用binaryen的wasm-opt --strip-debug确保无调试信息残留。安全是持续的过程，不是部署时的一个开关。

5. 常见问题与排查技巧实录：来自72小时压测的真实故障库

5.1 典型问题速查表