15.3.5 节点客户端、RPC 与索引
所属:全栈开发面试题库 / 15 Web3 与区块链 / 15.3 以太坊与 EVM
本节要解决的问题
面试里问"怎么连以太坊",多数人答"用 Infura"。这是入门。真正的分水岭是:能不能说清 full 节点与 archive 节点的区别、Geth 与 reth 的架构差异、JSON-RPC 的常用方法与限流、以及为什么 The Graph 之类的索引服务是 DApp 必备。本节解决四个具体问题:一是分清节点同步模式(full/snap/fast)与它们的取舍;二是讲清 eth_call 的状态模拟原理(它不发交易,只是在 EVM 里跑一遍);三是把 eth_getLogs 的限流与容量限制讲明白(为什么 Infura 不让你查 100 万块的日志);四是说明 The Graph subgraph 的索引原理——它不是实时查 RPC,而是把事件日志索引成数据库。
学习目标
学完本节,你应当能够:
- 区分 full 节点、archive 节点、轻节点的用途与成本。
- 列出常用 JSON-RPC 方法(eth_call、eth_getBalance、eth_sendRawTransaction、eth_getLogs)的用途与限制。
- 解释 eth_call 的状态模拟原理,以及它与真实交易的区别。
- 说明 The Graph subgraph 的索引原理,以及为什么 DApp 需要它。
先修与前置
- 建议先读 15.3.4 状态树、收据与事件日志,理解收据与事件日志的结构。
- 本节是 15.6 DApp 全栈与钱包 的前置,先懂节点与 RPC 再看 DApp 架构。
知识地图
节点类型:
full 节点:只保留最新状态,几百 GB
archive 节点:保留所有历史状态,TB 级
轻节点:只下载区块头,不下载完整数据
节点同步模式:
full sync:逐区块执行,慢但完整
snap sync:从快照同步状态,快
fast sync:快速同步到最新,再切换 full
JSON-RPC 常用方法:
eth_call:模拟交易,不发链
eth_getBalance:查余额
eth_sendRawTransaction:发交易
eth_getLogs:查事件日志
索引服务:
The Graph subgraph:把事件日志索引成数据库
原理:监听事件日志 → 写入数据库 → DApp 查数据库
核心术语
- full 节点:只保留最新状态的节点,磁盘占用几百 GB。
- archive 节点:保留所有历史状态的节点,磁盘占用 TB 级。
- Geth:Go 语言写的以太坊客户端,最主流。
- reth:Rust 语言写的以太坊客户端,新一代,性能更高。
- JSON-RPC:节点对外暴露的 RPC 接口,基于 HTTP/WebSocket。
- eth_call:模拟交易,不发链,只返回结果。
- eth_getLogs:查事件日志,有区块范围限制。
- The Graph:去中心化索引协议,把事件日志索引成数据库。
- subgraph:The Graph 的索引服务,定义要索引哪些事件。
覆盖范围
- 节点类型:full、archive、轻节点
- 节点客户端:Geth、reth、Erigon、Nethermind
- 同步模式:full sync、snap sync、fast sync
- JSON-RPC 常用方法与限流
- eth_call 的状态模拟原理
- 交易池(mempool)与交易广播
- The Graph subgraph 索引原理
- 自建 RPC 节点 vs 托管 RPC 的选型
高频题速览
| 编号 | 题目 | 难度 | 频率 |
|---|---|---|---|
| 15.3.5-001 | full 节点和 archive 节点有什么区别? | 基础 | ★★★★★ |
| 15.3.5-002 | Geth 和 reth 有什么区别? | 基础 | ★★★★ |
| 15.3.5-003 | JSON-RPC 常用方法有哪些? | 基础 | ★★★★★ |
| 15.3.5-004 | eth_call 是怎么模拟交易的? | 进阶 | ★★★★ |
| 15.3.5-005 | eth_getLogs 为什么有区块范围限制? | 进阶 | ★★★★ |
| 15.3.5-006 | 交易池(mempool)是什么? | 进阶 | ★★★ |
| 15.3.5-007 | 节点同步模式有哪些? | 进阶 | ★★★ |
| 15.3.5-008 | The Graph subgraph 是怎么索引的? | 高级 | ★★★★ |
| 15.3.5-009 | 自建 RPC 节点 vs 托管 RPC 怎么选? | 高级 | ★★★ |
| 15.3.5-010 | 节点的状态缓存层有什么用? | 高级 | ★★★ |
15.3.5-001 full 节点和 archive 节点有什么区别?
一句话结论
full 节点只保留最新状态(当前 stateRoot),磁盘占用几百 GB;archive 节点保留所有历史状态(每个区块的 stateRoot),磁盘占用 TB 级。full 节点只能查当前状态,archive 节点能查任何历史区块的状态。
概念解释
- full 节点:只保留最新 stateRoot,旧 stateRoot 对应的 MPT 被修剪。
- archive 节点:保留所有历史 stateRoot 对应的 MPT。
- 用途:区块浏览器、数据分析、重放交易需要 archive 节点。
- 成本:archive 节点磁盘占用 TB 级,同步时间长(几周)。
原理流程
- full 节点同步到最新区块后,只保留最新 stateRoot,旧 MPT 节点被修剪。
- archive 节点同步时保留所有历史 stateRoot 对应的 MPT。
- 查"当前余额":full 节点与 archive 节点都能查。
- 查"某区块的余额":只有 archive 节点能查。
- 普通 DApp 用 full 节点或托管 RPC 即可,不需要 archive 节点。
代码或图示
full 节点 vs archive 节点:
full 节点:
磁盘占用:几百 GB
能查:当前状态
同步时间:几天
用途:普通 DApp、验证交易
archive 节点:
磁盘占用:TB 级
能查:任何历史区块的状态
同步时间:几周
用途:区块浏览器、数据分析、重放交易
例:
查"Alice 当前余额":full 节点 OK
查"Alice 在区块 100 万时的余额":只有 archive 节点 OK
常见误区
- 误区:所有节点都是 archive 节点;正解:只有专门的 archive 节点才保留历史状态。
- 误区:full 节点性能更好;正解:full 节点与 archive 节点性能一样,只是磁盘占用不同。
- 误区:archive 节点是必须的;正解:普通用户用 full 节点或托管 RPC 即可。
追问
- 为什么 full 节点要修剪历史?答:因为完整历史状态的磁盘占用太大(TB 级),普通节点承担不起;修剪后只保留最新状态,磁盘占用几百 GB。机制上 MPT 是持久化数据结构,旧根对应的节点可以被修剪。边界在于:这也意味着 full 节点不能查历史状态。延伸:这是 15.3.4-008 的主题。
- 什么时候需要 archive 节点?答:区块浏览器、数据分析、重放交易、合约调试需要历史状态。机制上这些应用要查"某地址在某区块的状态"。边界在于:普通 DApp 只用最新状态,不需要 archive 节点。延伸:这也是为什么托管 RPC(如 Infura、Alchemy)提供 archive 节点服务。
- 运行 archive 节点的成本?答:磁盘 TB 级、同步时间几周、需要大量带宽;自建 archive 节点成本很高。机制上 archive 节点要同步所有历史状态。边界在于:这也是大多数团队用托管 archive 节点的原因。延伸:这是节点运维的成本权衡。
15.3.5-002 Geth 和 reth 有什么区别?
一句话结论
Geth 是 Go 语言写的以太坊客户端,最主流、最成熟;reth 是 Rust 语言写的新一代客户端,性能更高、内存占用更少。两者都实现了以太坊协议,但架构与性能特点不同。
概念解释
- Geth:Go 语言写,最主流,社区大,文档全。
- reth:Rust 语言写,新一代,性能更高,内存占用更少。
- Erigon:Go 语言写,另一个客户端,staged sync 架构,磁盘占用小。
- Nethermind:C# 语言写,企业级客户端。
原理流程
- Geth:最早的以太坊客户端之一,Go 语言实现,社区最大。
- reth:新一代 Rust 客户端,优化了状态访问与内存占用。
- Erigon:staged sync 架构,把同步分成多个阶段,磁盘占用小。
- 它们都实现了以太坊协议,可以互相通信(共识一致)。
- 选择取决于团队技术栈与性能需求。
代码或图示
主流以太坊客户端:
Geth:
语言:Go
特点:最主流、最成熟、社区大
用途:大多数节点运营者
reth:
语言:Rust
特点:性能更高、内存占用更少
用途:新一代高性能节点
Erigon:
语言:Go
特点:staged sync、磁盘占用小
用途:archive 节点
Nethermind:
语言:C#
特点:企业级、.NET 生态
用途:企业用户
常见误区
- 误区:所有客户端都一样;正解:不同客户端架构不同,性能特点不同。
- 误区:Geth 是官方唯一客户端;正解:以太坊有多个客户端,都实现了协议。
- 误区:reth 还不成熟;正解:reth 已经主网运行,性能优秀。
追问
- 为什么要有多个客户端?答:为了抗中心化——如果只有一个客户端,一个 bug 就会导致全网停机;多个客户端实现协议,增加容错。机制上以太坊协议是规范,多个客户端独立实现。边界在于:这也是以太坊客户端多样性的重要性。延伸:这是以太坊去中心化的一部分。
- reth 比 Geth 好在哪里?答:reth 用 Rust 实现,优化了状态访问与内存占用,性能更高。机制上 Rust 的内存安全与零成本抽象让节点更高效。边界在于:Geth 社区更大、文档更全。延伸:这是新一代客户端的优势。
- 怎么选客户端?答:取决于团队技术栈、性能需求、运维经验;Geth 是稳妥选择,reth 是高性能选择。机制上两者都实现了协议,共识一致。边界在于:企业用户可能选 Nethermind(.NET 生态)。延伸:这是节点运维的技术选型。
15.3.5-003 JSON-RPC 常用方法有哪些?
一句话结论
常用 JSON-RPC 方法包括:eth_call(模拟交易)、eth_getBalance(查余额)、eth_sendRawTransaction(发交易)、eth_getLogs(查事件日志)、eth_blockNumber(查最新区块号)、eth_getBlockByNumber(查区块)。
概念解释
- eth_call:模拟交易,不发链,只返回结果。
- eth_getBalance:查地址余额。
- eth_sendRawTransaction:发签名后的交易。
- eth_getLogs:查事件日志。
- eth_blockNumber:查最新区块号。
原理流程
- DApp 前端通过 HTTP/WebSocket 调用节点的 JSON-RPC。
- 常用方法:
- eth_call:模拟合约调用,查状态。
- eth_getBalance:查地址余额。
- eth_sendRawTransaction:发签名后的交易。
- eth_getLogs:查事件日志。
- 节点执行请求,返回结果。
- 托管 RPC(如 Infura、Alchemy)提供这些方法的限流版本。
代码或图示
常用 JSON-RPC 方法:
// 查最新区块号
{"jsonrpc":"2.0","method":"eth_blockNumber","params":[],"id":1}
// 查余额
{"jsonrpc":"2.0","method":"eth_getBalance","params":["0x1111...","latest"],"id":1}
// 模拟调用(查 balanceOf)
{"jsonrpc":"2.0","method":"eth_call","params":[{
"to": "0xToken...",
"data": "0x70a082310000000000000000000000001111..."
},"latest"],"id":1}
// 发交易
{"jsonrpc":"2.0","method":"eth_sendRawTransaction","params":["0xSignedTx..."],"id":1}
// 查事件日志
{"jsonrpc":"2.0","method":"eth_getLogs","params":[{
"address": "0xToken...",
"fromBlock": "0x1000000",
"toBlock": "0x1001000",
"topics": ["0xddf252ad..."]
}],"id":1}
常见误区
- 误区:eth_call 会发交易;正解:eth_call 只是模拟,不发链。
- 误区:eth_getLogs 可以查任意范围;正解:托管 RPC 有区块范围限制。
- 误区:JSON-RPC 是 WebSocket;正解:JSON-RPC 可以用 HTTP 或 WebSocket。
追问
- 为什么有 HTTP 与 WebSocket 两种?答:HTTP 用于请求-响应(如查余额),WebSocket 用于订阅事件(如新区块、新日志)。机制上 HTTP 无状态,WebSocket 长连接。边界在于:订阅事件要用 WebSocket。延伸:这是 DApp 实时更新的基础。
- 托管 RPC 为什么要限流?答:因为节点资源有限,要防止单个用户滥用;限流方式包括 QPS 限制、区块范围限制、并发限制。机制上托管 RPC 是共享服务,要保护节点。边界在于:免费 tier 限流很严,付费 tier 更宽松。延伸:这是 RPC 服务的商业模式。
- 怎么批量调用?答:JSON-RPC 支持批量请求(一个数组里多个请求),减少 HTTP 开销。机制上批量请求在一个 HTTP 连接里发多个调用。边界在于:托管 RPC 可能限制批量大小。延伸:这是 DApp 性能优化的一部分。
15.3.5-004 eth_call 是怎么模拟交易的?
一句话结论
eth_call 在 EVM 里跑一遍合约代码,但不真正发交易(不修改状态、不消耗 Gas、不进区块);它把状态回滚到调用前,返回执行结果。用于 DApp 查状态(如 balanceOf、getPrice)。
概念解释
- eth_call:在 EVM 里执行合约代码,但不修改状态、不消耗 Gas。
- 原理:创建一个临时执行上下文,跑完后回滚状态。
- 用途:DApp 查状态(如 balanceOf、getPrice)。
- 与真实交易的区别:不发链、不消耗 Gas、不进区块。
原理流程
- DApp 发 eth_call 请求:to = 合约地址,data = 编码的函数调用。
- 节点在 EVM 里创建临时执行上下文(当前状态)。
- 执行合约代码(可以 SLOAD、可以读存储)。
- 执行结束后,回滚状态(所有 SSTORE 都撤销)。
- 返回执行结果(返回值),不消耗 Gas。
代码或图示
eth_call 原理:
真实交易:
1. 签名交易 → 发交易池
2. 验证者打包 → 进区块
3. EVM 执行 → 修改状态
4. 消耗 Gas
eth_call:
1. DApp 发请求(to, data)
2. 节点在 EVM 里执行(临时上下文)
3. 执行结束 → 回滚状态
4. 返回结果(不消耗 Gas)
用途:
DApp 查 balanceOf、getPrice、查询合约状态
常见误区
- 误区:eth_call 会修改状态;正解:eth_call 执行后回滚状态,不修改。
- 误区:eth_call 消耗 Gas;正解:eth_call 不消耗 Gas(节点免费提供)。
- 误区:eth_call 与真实交易一样;正解:eth_call 只是模拟,不进区块。
追问
- eth_call 能调用写函数吗?答:技术上能,但执行后回滚状态,没有实际效果;通常 eth_call 只调用 view/pure 函数。机制上节点允许任何调用,但状态回滚。边界在于:有些节点可能限制写函数调用。延伸:这是 DApp 查状态的方式。
- eth_call 的状态是哪个?答:默认是最新状态("latest"),也可以指定区块号(如"0x1000000");指定历史区块号需要 archive 节点。机制上 eth_call 在指定区块的状态上执行。边界在于:历史状态查询需要 archive 节点。延伸:这是 15.3.5-001 的主题。
- eth_call 与真实交易的 Gas 估算有什么关系?答:eth_call 可以用来估算真实交易的 Gas(eth_estimateGas);节点在 EVM 里跑一遍,返回消耗的 Gas。机制上 eth_estimateGas 就是带 Gas 计算的 eth_call。边界在于:估算值可能与实际有偏差(因为状态变化)。延伸:这是钱包估算 Gas 的方式。
15.3.5-005 eth_getLogs 为什么有区块范围限制?
一句话结论
eth_getLogs 查事件日志时,托管 RPC 限制区块范围(如一次最多 1000 块),因为扫描大量区块的日志很耗资源;如果不限制,恶意用户可以让节点扫几万块,耗尽节点资源。
概念解释
- eth_getLogs:查事件日志,按区块范围与 topic 过滤。
- 区块范围限制:托管 RPC 限制一次最多查多少块(如 1000 块)。
- 为什么:扫描大量区块日志很耗资源,不限制会被 DoS。
- 替代:用 The Graph 之类的索引服务查历史日志。
原理流程
- DApp 发 eth_getLogs 请求:fromBlock、toBlock、topics。
- 节点扫描 fromBlock 到 toBlock 的所有收据,过滤匹配的日志。
- 如果范围太大(如 10 万块),扫描很耗资源。
- 托管 RPC 限制范围(如最多 1000 块),防止 DoS。
- DApp 要查历史日志,用 The Graph 之类的索引服务。
代码或图示
eth_getLogs 限制:
托管 RPC(如 Infura):
一次最多查 1000 块
否则报错:"query exceeds max block range"
例:
查从区块 100 万到 101 万的日志:
范围 = 1 万块 → 超限,报错
正确做法:
分批查:100 万-101 万分成 10 批,每批 1000 块
或用 The Graph subgraph
自建节点:
可以配置更大范围(但要注意节点资源)
常见误区
- 误区:eth_getLogs 可以查任意范围;正解:托管 RPC 有区块范围限制。
- 误区:eth_getLogs 很快;正解:扫描大量区块日志很耗资源。
- 误区:The Graph 是必须的;正解:小范围查询 eth_getLogs 即可,大范围查询用 The Graph。
追问
- 为什么扫描日志很耗资源?答:因为日志在每个区块的收据里,要扫描所有区块的收据,过滤匹配的日志。机制上节点要遍历每个区块的 receipts MPT。边界在于:区块越多,扫描越慢。延伸:这就是 The Graph 存在的原因。
- 怎么查大量历史日志?答:用 The Graph subgraph——它把事件日志索引成数据库,DApp 直接查数据库,不用扫描区块。机制上 The Graph 节点持续监听事件日志,写入数据库。边界在于:The Graph 有索引延迟(几分钟到几小时)。延伸:这是 15.3.5-008 的主题。
- 自建节点可以放宽限制吗?答:可以,自建节点可以配置更大范围;但要注意节点资源(CPU、磁盘)。机制上自建节点没有托管限制。边界在于:这也是为什么大型团队自建节点。延伸:这是节点运维的权衡。
15.3.5-006 交易池(mempool)是什么?
一句话结论
交易池(mempool)是节点收到的、尚未被打包进区块的交易临时存储;节点从 P2P 网络收到交易后先放进 mempool,等待验证者打包。
概念解释
- mempool:交易池,临时存储未打包的交易。
- 交易广播:节点收到交易后,广播给其他节点(P2P 网络)。
- 交易顺序:mempool 里的交易按 Gas 价格排序,高 Gas 优先打包。
- 交易过期:mempool 里的交易如果太久没被打包,会被丢弃。
原理流程
- 用户签名交易,发 RPC 节点(或 P2P 网络)。
- 节点验证交易(签名、nonce、余额),通过后放进 mempool。
- 节点广播交易给其他节点(P2P 网络)。
- 验证者打包区块时,从 mempool 选交易(按 Gas 价格排序)。
- 交易被打包后,从 mempool 移除。
代码或图示
交易池流程:
用户签名交易
↓
发 RPC 节点(或 P2P)
↓
节点验证(签名、nonce、余额)
↓
放进 mempool(临时存储)
↓
节点广播给其他节点(P2P)
↓
验证者打包区块时,从 mempool 选交易(按 Gas 排序)
↓
交易被打包 → 从 mempool 移除
例:
高 Gas 交易优先打包
低 Gas 交易可能等很久
常见误区
- 误区:交易发 RPC 节点就直接进区块;正解:交易先进 mempool,等待验证者打包。
- 误区:mempool 是全局的;正解:每个节点有自己的 mempool,不是全局共享。
- 误区:mempool 里的交易一定会被打包;正解:交易可能因为 Gas 太低、nonce 过期、或被替换而不打包。
追问
- 怎么监听 mempool?答:用 WebSocket 订阅 newPendingTransactions,节点会推送新交易。机制上节点收到新交易时通知订阅者。边界在于:托管 RPC 可能不支持订阅 mempool。延伸:这是 MEV 搜索者的工作方式。
- 交易被替换(replacement)是什么?答:用户发了一笔交易后,又发了一笔同 nonce 但更高 Gas 的交易,节点用新交易替换 mempool 里的旧交易。机制上 nonce 相同的交易会替换。边界在于:这也是"加速交易"的方式。延伸:这是 DApp 交易体验的一部分。
- mempool 为什么会被清空?答:节点重启、或交易过期(太久没被打包),mempool 会清空。机制上 mempool 是易失的,不持久化。边界在于:这也是为什么用户要保存交易哈希(如果交易没进区块,要重发)。延伸:这是 DApp 交易可靠性的重点。
15.3.5-007 节点同步模式有哪些?
一句话结论
节点同步模式包括:full sync(逐区块执行,慢但完整)、snap sync(从快照同步状态,快)、fast sync(快速同步到最新,再切换 full)。选择取决于时间与磁盘需求。
概念解释
- full sync:逐区块执行所有交易,慢但完整,可以验证所有历史。
- snap sync:从可信快照同步最新状态,快,但不验证历史。
- fast sync:快速同步到最新区块头,再切换 full sync。
- 选择:full sync 慢但可信,snap sync 快但不验证历史。
原理流程
- full sync:从创世块开始,逐区块执行所有交易,构建状态树。
- snap sync:从其他节点下载最新状态快照,跳过历史执行。
- fast sync:快速同步到最新区块头,再切换 full sync 执行后续区块。
- 选择:full sync 慢(几周)但完整,snap sync 快(几小时)但不验证历史。
- 大多数节点用 snap sync 快速启动。
代码或图示
同步模式:
full sync:
从创世块开始,逐区块执行所有交易
时间:几周
优点:完整验证历史
缺点:慢
snap sync:
从可信快照下载最新状态
时间:几小时
优点:快
缺点:不验证历史
fast sync:
快速同步到最新区块头,再切换 full sync
时间:几天
优点:折中
选择:
大多数节点用 snap sync 快速启动
归档节点用 full sync 保留历史
常见误区
- 误区:所有节点都用 full sync;正解:大多数节点用 snap sync 快速启动。
- 误区:snap sync 不安全;正解:snap sync 从可信快照同步,信任快照来源。
- 误区:同步模式影响共识;正解:同步模式只影响节点启动速度,共识一致。
追问
- 为什么要有 snap sync?答:因为 full sync 太慢(几周),普通用户等不起;snap sync 从快照同步,几小时就能启动。机制上 snap sync 跳过历史执行,直接下载最新状态。边界在于:snap sync 不验证历史,信任快照来源。延伸:这是节点可用性的优化。
- snap sync 信任什么?答:信任快照来源(其他节点、官方快照);如果快照是恶意的,节点会同步错误状态。机制上 snap sync 不验证历史,依赖快照来源可信。边界在于:这也是为什么大多数节点从官方或可信来源下载快照。延伸:这是去中心化的权衡。
- 归档节点用什么同步?答:归档节点通常用 full sync(或 Erigon 的 staged sync),保留所有历史状态。机制上归档节点要完整执行历史,构建状态树。边界在于:归档节点同步时间长(几周)。延伸:这是 15.3.5-001 的主题。
15.3.5-008 The Graph subgraph 是怎么索引的?
一句话结论
The Graph subgraph 是一个索引服务:它持续监听事件日志,把事件数据索引成数据库;DApp 直接查数据库,不用扫描区块。原理是:定义要索引哪些事件(subgraph manifest),The Graph 节点持续同步事件日志,写入数据库,DApp 用 GraphQL 查询。
概念解释
- subgraph:The Graph 的索引定义,指定要索引哪些合约、哪些事件。
- The Graph 节点:持续监听事件日志,写入数据库。
- GraphQL:DApp 查询语言,直接查数据库。
- 索引延迟:The Graph 同步事件有延迟(几分钟到几小时)。
原理流程
- 定义 subgraph manifest:指定合约地址、事件、要提取的字段。
- The Graph 节点持续同步区块,监听指定事件。
- 事件触发时,节点把数据写入数据库。
- DApp 用 GraphQL 查询数据库,不用扫描区块。
- 索引延迟:几分钟到几小时(取决于 The Graph 网络)。
代码或图示
The Graph subgraph 原理:
定义 subgraph:
合约地址:0xToken...
事件:Transfer(address,address,uint256)
字段:from, to, value
The Graph 节点:
持续同步区块
监听 Transfer 事件
事件触发时 → 写入数据库
DApp 查询:
GraphQL 查询:
{
transfers(where: {to: "0xBob..."}) {
from
to
value
}
}
优点:
不用扫描区块,直接查数据库
支持复杂查询(过滤、排序、分页)
缺点:
索引延迟(几分钟到几小时)
常见误区
- 误区:The Graph 是实时的;正解:The Graph 有索引延迟(几分钟到几小时)。
- 误区:The Graph 是必须的;正解:小范围查询 eth_getLogs 即可,大范围用 The Graph。
- 误区:The Graph 是中心化的;正解:The Graph 是去中心化网络(节点激励),也有托管服务。
追问
- The Graph 为什么有索引延迟?答:因为 The Graph 节点要持续同步区块,监听事件,写入数据库;这个过程需要时间。机制上节点不是实时同步,而是按区块批量处理。边界在于:实时性要求高的 DApp 直接用 WebSocket 订阅事件。延伸:这是索引服务的权衡。
- The Graph 与自建索引有什么区别?答:自建索引(自己跑节点、写数据库)实时性更高,但运维成本高;The Graph 是托管服务,成本低但有延迟。机制上两者原理相同,都是索引事件日志。边界在于:大型团队自建索引,小团队用 The Graph。延伸:这是 DApp 架构的选择。
- The Graph 的去中心化是什么?答:The Graph 网络由索引节点组成,节点质押 GRT 代币提供索引服务;查询者付费用 GRT。机制上节点激励去中心化索引。边界在于:也有托管服务(The Graph 官方托管),更简单。延伸:这是 Web3 基础设施的趋势。
15.3.5-009 自建 RPC 节点 vs 托管 RPC 怎么选?
一句话结论
自建 RPC 节点成本高(硬件、运维、带宽),但可控、无限流;托管 RPC(如 Infura、Alchemy)成本低、上手快,但有限流。选择取决于团队规模、性能需求、预算。
概念解释
- 自建节点:自己跑 Geth/reth,自己运维。
- 托管 RPC:用 Infura、Alchemy、QuickNode 等服务。
- 自建优点:可控、无限流、数据私有。
- 托管优点:成本低、上手快、不用运维。
原理流程
- 自建节点:买服务器、跑节点、运维、监控。
- 托管 RPC:注册账号、拿 API Key、直接用。
- 自建成本:硬件(几千到几万/月)、带宽、运维人力。
- 托管成本:按 tier 付费(免费 tier 有限流,付费 tier 更宽松)。
- 选择:小团队用托管,大团队自建。
代码或图示
自建 vs 托管 RPC:
自建节点:
优点:可控、无限流、数据私有
缺点:成本高、运维复杂
适合:大团队、高流量 DApp
托管 RPC:
优点:成本低、上手快、不用运维
缺点:有限流、数据共享
适合:小团队、早期 DApp
成本对比:
自建:服务器 $500-2000/月 + 带宽 + 运维人力
托管:免费 tier 或 $100-1000/月(付费 tier)
常见误区
- 误区:所有 DApp 都要自建节点;正解:小团队用托管即可。
- 误区:托管 RPC 不安全;正解:托管 RPC 只是查节点,不存私钥(私钥在用户钱包里)。
- 误区:自建节点性能更好;正解:自建与托管性能取决于节点配置。
追问
- 什么时候要自建节点?答:当流量大、需要无限流、需要私有数据、或需要 archive 节点时。机制上托管 RPC 有流量限制,大流量 DApp 成本高。边界在于:自建节点运维成本高。延伸:这是团队规模与成本的权衡。
- 托管 RPC 有什么风险?答:托管 RPC 可能宕机、限流、或被攻击;DApp 要设计降级方案(如备用 RPC)。机制上托管 RPC 是共享服务,要容错。边界在于:DApp 前端应该支持多 RPC 切换。延伸:这是 DApp 可靠性的重点。
- 怎么提高 RPC 可靠性?答:用多 RPC(主 RPC + 备用 RPC)、缓存常用查询、批量请求。机制上多 RPC 容错,缓存减少请求。边界在于:这增加了前端复杂度。延伸:这是 DApp 性能优化的一部分。
15.3.5-010 节点的状态缓存层有什么用?
一句话结论
节点的状态缓存层(如 Geth 的 state cache、reth 的缓存)缓存最近访问的 MPT 节点,避免每次 SLOAD 都从磁盘读;大幅提高 RPC 请求的响应速度。
概念解释
- 状态缓存:缓存最近访问的 MPT 节点(账户、存储槽)。
- 为什么:MPT 节点存在磁盘上,每次 SLOAD 都从磁盘读很慢;缓存避免磁盘 IO。
- 缓存大小:几百 MB 到几 GB,取决于节点配置。
- 效果:RPC 请求响应速度提升数倍。
原理流程
- 节点收到 RPC 请求(如 eth_call)。
- 执行时要 SLOAD 某槽位。
- 先查缓存:如果缓存里有,直接用;否则从磁盘读 MPT 节点。
- 读完后放进缓存(LRU 淘汰)。
- 热数据(常用账户、槽位)一直在缓存里,RPC 请求快。
代码或图示
状态缓存原理:
无缓存:
SLOAD → 从磁盘读 MPT 节点 → 慢(几 ms 到几十 ms)
有缓存:
SLOAD → 查缓存 → 命中 → 快(几 μs)
→ 未命中 → 从磁盘读 → 放进缓存
缓存大小:
Geth:默认几百 MB(可配置)
reth:优化的缓存,内存占用更少
效果:
热数据(常用账户、槽位)在缓存里
RPC 请求响应速度提升数倍
常见误区
- 误区:节点不需要缓存;正解:缓存大幅提升 RPC 性能。
- 误区:缓存是磁盘缓存;正解:缓存是内存缓存(RAM)。
- 误区:缓存越大越好;正解:缓存太大占用内存,影响其他进程。
追问
- 缓存是怎么淘汰的?答:用 LRU(Least Recently Used)算法——最近最少使用的节点被淘汰。机制上缓存满时,淘汰最久没访问的节点。边界在于:热点数据一直在缓存里,冷数据被淘汰。延伸:这是经典缓存设计。
- 缓存与一致性有什么关系?答:缓存是只读的,修改状态时(SSTORE)同时更新缓存;区块切换时,缓存回滚到旧状态。机制上缓存是状态的快照,与区块一致。边界在于:重org 时缓存要重建。延伸:这是节点一致性的保证。
- 怎么调优缓存?答:根据节点配置(CPU、内存)调整缓存大小;大内存节点可以配更大缓存。机制上缓存越大,热数据命中率越高。边界在于:缓存太大占用内存,影响其他进程。延伸:这是节点运维的调优。
动手练习
练习 1:用 JSON-RPC 查一笔交易
- 任务:用 curl 或 Postman 调用托管 RPC(如 Infura),查最新区块号、查某地址余额、模拟调用合约函数。
- 验收标准:
- 能写出 eth_blockNumber、eth_getBalance、eth_call 的请求。
- 能解释 eth_call 与真实交易的区别。
- 能说出托管 RPC 的限流限制。
练习 2:写一个简单的 subgraph
- 任务:用 The Graph 托管服务,写一个 subgraph 索引 ERC20 的 Transfer 事件;用 GraphQL 查询。
- 验收标准:
- 能写出 subgraph manifest(合约地址、事件)。
- 能解释索引延迟的原因。
- 能写出 GraphQL 查询语句。
自检清单
- [ ] 能区分 full 节点与 archive 节点的用途与成本?
- [ ] 能说出 Geth 与 reth 的区别?
- [ ] 能列出常用 JSON-RPC 方法?
- [ ] 能解释 eth_call 的模拟原理?
- [ ] 能说明 eth_getLogs 的区块范围限制?
- [ ] 能解释 mempool 的工作流程?
- [ ] 能区分 full sync、snap sync、fast sync?
- [ ] 能解释 The Graph subgraph 的索引原理?
- [ ] 能对比自建 RPC 与托管 RPC 的选择?
- [ ] 能说明状态缓存层的作用?
延伸阅读
- Geth 官方文档:JSON-RPC API、同步模式。
- reth 官方文档:Rust 以太坊客户端。
- The Graph 官方文档:subgraph 开发。
- Ethereum 文档:Nodes and Clients。
- 《Mastering Ethereum》:客户端与 RPC 章节。
待整理清单
- [ ] 补充主流托管 RPC(Infura、Alchemy、QuickNode)的限流参数对比
- [ ] 补充自建节点的硬件配置与带宽预算
- [ ] 补充 The Graph 去中心化网络的当前状态(待确认)