CRPC - 多链RPC代理服务

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40

crpc/
├── migration/            # 数据库SQL迁移文件
│   ├── init_database.sql      # 数据库初始化（表结构+索引）
│   └── insert_rpc_nodes.sql   # RPC节点配置数据
│
├── config/               # 配置文件
│   ├── config.toml      # 主配置文件
│   └── nginx.conf       # Nginx负载均衡配置
│
├── program/              # Go源码
│   ├── main.go          # 程序入口
│   ├── go.mod           # Go模块定义
│   ├── go.sum           # 依赖锁定文件
│   ├── api/             # API接口层
│   ├── cleanup/         # 日志自动清理
│   ├── config/          # 配置管理
│   ├── database/        # 数据库操作
│   ├── health/          # 健康检查
│   ├── logger/          # 日志管理
│   ├── models/          # 数据模型
│   └── proxy/           # RPC代理和故障切换
│
├── scripts/              # 脚本文件
│   ├── init_db.sh               # 数据库初始化
│   ├── start_multi_instance.sh  # 启动多实例（开发）
│   ├── deploy_to_remote.sh      # 单实例远程部署
│   ├── deploy_multi_instance.sh # 多实例远程部署
│   ├── benchmark.sh             # 性能基准测试
│   ├── monitor.sh               # 实时监控面板
│   ├── test_api.sh              # API测试
│   ├── test_batch_requests.sh   # 批量请求测试
│   └── test_rpc_realworld.sh    # 真实交易测试
│
├── bin/                  # 编译后的二进制文件
│   └── crpc            # 可执行程序
│
├── log/                  # 日志文件目录
│
├── Makefile             # 构建脚本
└── README.org           # 项目文档（本文件）

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

# 确保PostgreSQL已安装并运行
sudo systemctl start postgresql

# 创建数据库和用户
sudo -u postgres psql << EOF
CREATE DATABASE crpc;
CREATE USER crpc WITH PASSWORD 'crpc_password';
GRANT ALL PRIVILEGES ON DATABASE crpc TO crpc;
\q
EOF

1
2
3
4
5

# 进入项目目录
cd /home/smokey/Desktop/crpc

# 运行数据库迁移
make migrate

1
2

# 插入预配置的节点
make insert-nodes

1
2
3
4

1. 筛选健康节点（is_healthy = true）
2. 按 priority 排序，选择最小值的节点组
3. 在同优先级组内，根据 weight 进行加权随机选择
4. 考虑平均响应时间（avg_response_time）进行微调

1
2
3
4
5
6

[database]
host = "localhost"
port = 5432
user = "crpc"
password = "crpc_password"
dbname = "crpc"

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

# 安装Go依赖
make deps

# 编译程序
make build

# 运行（单实例）
make run

# 或者直接运行
cd program && go run main.go

1
2
3
4
5

# 检查服务健康状态
curl http://localhost:8080/health

# 预期输出：
# {"status":"ok","instance_id":"crpc-1"}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16

cd scripts

# 方式1：Unix Socket模式（推荐，性能最佳）
./start_multi_instance.sh 3 socket

# 方式2：HTTP模式（跨服务器部署）
./start_multi_instance.sh 3 http

# 方式3：双监听模式（同时支持Socket和HTTP）
./start_multi_instance.sh 3 both

# 查看日志
tail -f ../log/crpc-*.log

# 查看Socket文件（socket模式）
ls -lh /tmp/crpc-*.sock

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

# 安装Nginx
sudo apt install nginx

# 复制配置文件
sudo cp config/nginx.conf /etc/nginx/nginx.conf

# 测试配置
sudo nginx -t

# 启动Nginx
sudo systemctl start nginx
sudo systemctl enable nginx

1
2
3
4
5
6
7

# 多次请求，观察instance_id变化
for i in {1..10}; do
  curl -s http://localhost/health | jq .instance_id
  sleep 1
done

# 应该看到 crpc-1, crpc-2, crpc-3 轮流出现

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

# 获取最新区块号
curl -X POST http://localhost/ethereum \
  -H "Content-Type: application/json" \
  -d '{"jsonrpc":"2.0","method":"eth_blockNumber","params":[],"id":1}'

# 响应示例：
# {
#   "jsonrpc": "2.0",
#   "result": "0x123456",
#   "id": 1
# }

1
2
3
4
5
6
7
8
9

# 获取账户余额
curl -X POST http://localhost/bsc \
  -H "Content-Type: application/json" \
  -d '{
    "jsonrpc":"2.0",
    "method":"eth_getBalance",
    "params":["0x742d35Cc6634C0532925a3b844Bc9e7595f0bEb", "latest"],
    "id":1
  }'

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

curl http://localhost/api/chains | jq

# 响应示例：
# {
#   "code": 0,
#   "msg": "success",
#   "data": [
#     {
#       "chain_id": "ethereum",
#       "chain_name": "Ethereum Mainnet",
#       "description": "以太坊主网"
#     }
#   ]
# }

1
2
3
4
5

# 获取以太坊的所有节点
curl http://localhost/api/nodes?chain_id=ethereum | jq

# 获取所有链的节点
curl http://localhost/api/nodes | jq

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

curl -X POST http://localhost/api/nodes \
  -H "Content-Type: application/json" \
  -d '{
    "chain_id": "ethereum",
    "node_url": "https://your-custom-rpc.com",
    "provider": "Your Provider",
    "priority": 10,
    "weight": 5,
    "is_active": true
  }'

1
2
3
4
5
6
7
8
9

# 禁用某个节点
curl -X PUT http://localhost/api/nodes/1 \
  -H "Content-Type: application/json" \
  -d '{"is_active": false}'

# 更新节点优先级
curl -X PUT http://localhost/api/nodes/1 \
  -H "Content-Type: application/json" \
  -d '{"priority": 5, "weight": 20}'

1

curl -X DELETE http://localhost/api/nodes/1

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17

curl http://localhost/api/stats/nodes | jq

# 响应示例：
# {
#   "code": 0,
#   "msg": "success",
#   "data": {
#     "ethereum": {
#       "total": 3,
#       "healthy": 2
#     },
#     "bsc": {
#       "total": 2,
#       "healthy": 2
#     }
#   }
# }

1
2
3
4
5
6
7
8
9

// 旧代码（直接连接RPC节点）
const provider = new ethers.JsonRpcProvider('https://eth.llamarpc.com');

// 新代码（使用CRPC代理，按链ID挂在根路径）
const provider = new ethers.JsonRpcProvider('http://localhost/ethereum');

// 就这么简单！无需其他修改
const blockNumber = await provider.getBlockNumber();
console.log('当前区块:', blockNumber);

1
2
3
4
5
6
7
8

from web3 import Web3

# 使用CRPC代理
w3 = Web3(Web3.HTTPProvider('http://localhost/ethereum'))

# 无需其他修改
block_number = w3.eth.block_number
print(f'当前区块: {block_number}')

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22

import { ethers } from 'ethers';

// 配置文件
const RPC_ENDPOINTS = {
  ethereum: 'http://localhost/ethereum',
  bsc: 'http://localhost/bsc',
  polygon: 'http://localhost/polygon',
};

// 创建Provider
function useProvider(chainId) {
  const [provider, setProvider] = useState(null);

  useEffect(() => {
    const endpoint = RPC_ENDPOINTS[chainId];
    if (endpoint) {
      setProvider(new ethers.JsonRpcProvider(endpoint));
    }
  }, [chainId]);

  return provider;
}

1
2
3
4
5
6
7

HTTP (TCP):
  应用 → Socket → TCP层 → IP层 → 网卡驱动 → 回环 → 网卡驱动 → IP层 → TCP层 → Socket → 应用
  ↑ 需要完整的网络协议栈处理

Unix Socket:
  应用 → VFS → Socket缓冲区 → VFS → 应用
  ↑ 直接内核通信，无需协议栈

1
2
3
4
5
6
7
8

[server]
port = 8080
instance_id = "crpc-1"
enable_http = false     # 关闭HTTP
enable_socket = true    # 启用Socket
# ⚠️ 注意：生产环境不要把socket放在/tmp下，避免Nginx的PrivateTmp=true导致不可见
# 开发环境示例：socket_path = "/tmp/crpc-1.sock"
socket_path = "/srv/crpc/crpc-1.sock"   # 生产环境推荐路径（与服务目录一致）

1
2
3
4
5
6
7
8
9

upstream crpc_backend {
    least_conn;
    # 生产环境推荐：与上面的socket_path保持一致
    server unix:/srv/crpc/crpc-1.sock max_fails=3 fail_timeout=30s;
    # 如需多实例，可配置 crpc-2.sock / crpc-3.sock
    # server unix:/srv/crpc/crpc-2.sock max_fails=3 fail_timeout=30s;
    # server unix:/srv/crpc/crpc-3.sock max_fails=3 fail_timeout=30s;
    keepalive 64;
}

1

./scripts/start_multi_instance.sh 3 socket

1
2
3
4
5

[server]
port = 8080
instance_id = "crpc-1"
enable_http = true      # 启用HTTP
enable_socket = false   # 关闭Socket

1
2
3
4
5
6
7

upstream crpc_backend {
    least_conn;
    server 127.0.0.1:8080 max_fails=3 fail_timeout=30s;
    server 127.0.0.1:8081 max_fails=3 fail_timeout=30s;
    server 127.0.0.1:8082 max_fails=3 fail_timeout=30s;
    keepalive 32;
}

1

./scripts/start_multi_instance.sh 3 http

1
2
3
4
5
6

[server]
port = 8080
instance_id = "crpc-1"
enable_http = true      # 同时启用HTTP
enable_socket = true    # 同时启用Socket
socket_path = "/tmp/crpc-1.sock"

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

upstream crpc_backend {
    least_conn;

    # 本地实例（Unix Socket，优先级高）
    server unix:/tmp/crpc-1.sock max_fails=3 fail_timeout=30s weight=2;
    server unix:/tmp/crpc-2.sock max_fails=3 fail_timeout=30s weight=2;

    # 远程实例（HTTP，优先级低）
    server 192.168.1.100:8080 max_fails=3 fail_timeout=30s weight=1;

    keepalive 64;
}

1

./scripts/start_multi_instance.sh 3 both

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

# 查看socket文件
ls -lh /tmp/crpc-*.sock
# 输出：srw-rw-rw- 1 user group 0 Nov 17 10:00 /tmp/crpc-1.sock

# 测试socket连接（使用curl）
curl --unix-socket /tmp/crpc-1.sock http://localhost/health
# 输出：{"status":"ok","instance_id":"crpc-1"}

# 查看进程监听
ss -xl | grep crpc
# 输出：u_str LISTEN 0 128 /tmp/crpc-1.sock

1
2
3
4
5
6
7

# 测试TCP性能
ab -n 10000 -c 100 http://localhost:8080/health

# 测试Socket性能（通过Nginx）
ab -n 10000 -c 100 http://localhost/health

# 对比QPS（Socket通常高20-30%）

1
2
3
4
5
6
7
8

# 1. 检查CRPC是否启动
ps aux | grep crpc

# 2. 检查配置
grep enable_socket config/config.toml

# 3. 查看日志
tail -f log/crpc-1.log | grep -i socket

1
2
3
4
5
6
7
8

# 检查socket权限
ls -l /tmp/crpc-*.sock
# 应该是：srw-rw-rw-

# 如果不是，手动设置
chmod 666 /tmp/crpc-*.sock

# 或者修改代码中的chmod调用

1
2
3
4
5

# 清理旧socket文件
rm -f /tmp/crpc-*.sock

# 重启服务
./scripts/start_multi_instance.sh 3 socket

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39

┌─────────────────────────────────────────────┐
│              前端应用                        │
│  只需要知道一个固定的代理域名                │
│  https://crpc.coinexus.life/{chain}        │
└─────────────────┬───────────────────────────┘
                  │
                  ↓
┌─────────────────────────────────────────────┐
│         Nginx 负载均衡器                     │
│  - 使用 least_conn 策略                     │
│  - 自动检测后端健康状态                      │
│  - 失败自动重试其他实例                      │
└──────────┬──────────────┬───────────────────┘
           │              │
    ┌──────┴──────┬───────┴──────┬
    ↓             ↓              ↓
┌────────┐   ┌────────┐    ┌────────┐
│ CRPC-1 │   │ CRPC-2 │    │ CRPC-3 │
│ 实例1  │   │ 实例2  │    │ 实例3  │
│ 8080   │   │ 8081   │    │ 8082   │
└───┬────┘   └───┬────┘    └───┬────┘
    │            │              │
    └────────────┴──────────────┘
                 │
                 ↓ (共享同一个数据库)
         ┌──────────────┐
         │ PostgreSQL   │
         │ - 节点配置    │
         │ - 健康状态    │
         │ - 统计数据    │
         └──────┬───────┘
                │
                ↓ (转发到健康节点)
    ┌───────────────────────────┐
    │     多个RPC节点池          │
    │  Ethereum: 3个节点         │
    │  BSC: 2个节点              │
    │  Polygon: 3个节点          │
    └───────────────────────────┘

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

// 每次请求都从数据库获取最新的节点列表
func (p *Proxy) ForwardRequest(ctx context.Context, chainID string, rpcReq *models.RPCRequest) (*models.RPCResponse, error) {
    // 从数据库实时获取健康节点
    nodes, err := p.db.GetHealthyNodes(chainID)
    if err != nil {
        return nil, err
    }

    // 选择节点并转发请求
    node := p.selectNode(nodes)
    return p.sendRequest(ctx, node, rpcReq)
}

1
2
3
4
5
6
7
8
9

upstream crpc_backend {
    least_conn;  # 选择连接数最少的实例

    server 127.0.0.1:8080 max_fails=3 fail_timeout=30s;
    server 127.0.0.1:8081 max_fails=3 fail_timeout=30s;
    server 127.0.0.1:8082 max_fails=3 fail_timeout=30s;

    keepalive 32;  # 保持长连接
}

1
2
3

发送交易     → 使用 /wallet
查询余额/数据 → 使用 /walletsolidity（更可靠）
兼容性调用   → 使用 /jsonrpc

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

选择流程：
1. 筛选所有健康节点（is_healthy = true）
2. 按 priority 分组（值越小优先级越高）
3. 选择最小 priority 的节点组
4. 在该组内根据 weight 进行加权随机选择
5. 如果该组所有节点都故障，降级到下一个 priority 组

示例：
- 如果 Chainstack 节点健康 → 100% 使用 Chainstack
- 如果 Chainstack 故障 → 自动切换到 Infura
- 如果 Infura 也故障 → 自动切换到公共节点

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

curl -X POST http://localhost:8080/api/nodes \
  -H "Content-Type: application/json" \
  -d '{
    "chain_id": "ethereum",
    "http_url": "https://your-node.example.com",
    "ws_url": "wss://your-node.example.com",
    "provider": "YourProvider",
    "priority": 1,
    "weight": 20,
    "node_type": "both",
    "api_key_type": "bearer",
    "api_key": "your-api-key"
  }'

1
2
3
4
5
6

curl -X PUT http://localhost:8080/api/nodes/{id} \
  -H "Content-Type: application/json" \
  -d '{
    "priority": 1,
    "weight": 25
  }'

1
2
3
4
5

curl -X PUT http://localhost:8080/api/nodes/{id} \
  -H "Content-Type: application/json" \
  -d '{
    "is_active": false
  }'

1
2
3
4
5
6
7
8

# 查看所有节点
curl http://localhost:8080/api/nodes

# 查看特定链的节点
curl http://localhost:8080/api/nodes?chain_id=ethereum

# 只看健康节点
curl http://localhost:8080/api/nodes?is_healthy=true

1
2
3
4
5

{
  "code": 0,      // 0成功，1失败
  "msg": "success",
  "data": {}      // 业务数据
}

1
2
3
4

{
  "status": "ok",
  "instance_id": "crpc-1"
}

1
2
3
4
5
6
7
8

{
  "chain_id": "ethereum",
  "node_url": "https://rpc.example.com",
  "provider": "Example",
  "priority": 10,
  "weight": 5,
  "is_active": true
}

1
2
3
4
5

{
  "priority": 5,
  "weight": 10,
  "is_active": false
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

{
  "code": 0,
  "msg": "success",
  "data": {
    "ethereum": {
      "total": 3,
      "healthy": 2
    },
    "bsc": {
      "total": 2,
      "healthy": 2
    }
  }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17

[server]
port = 8080              # HTTP服务端口
mode = "release"         # 运行模式: debug, release
read_timeout = 30        # 读取超时（秒）
write_timeout = 30       # 写入超时（秒）
instance_id = "crpc-1"   # 实例ID，多实例需不同

# 监听模式配置（新增）
enable_http = true       # 是否启用HTTP监听（TCP）
enable_socket = false    # 是否启用Unix Socket监听
# ⚠️ 开发环境示例：可以使用/tmp，便于本机调试
#    socket_path = "/tmp/crpc.sock"  # 开发环境示例
# 生产环境请避免使用/tmp（Nginx通常启用PrivateTmp=true，看不到/tmp里的socket）
# 推荐放在服务目录或/run下，例如：
#    socket_path = "/srv/crpc/crpc.sock"
#    socket_path = "/run/crpc.sock"
socket_path = "/tmp/crpc.sock"  # 默认值（开发环境友好），生产环境请按上面说明修改

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

[database]
host = "localhost"
port = 5432
user = "crpc"
password = "crpc_password"
dbname = "crpc"
sslmode = "disable"
max_open_conns = 25      # 最大打开连接数
max_idle_conns = 5       # 最大空闲连接数
conn_max_lifetime = 300  # 连接最大生命周期（秒）

1
2
3
4
5
6

[health_check]
enabled = true           # 是否启用健康检查
interval = 10            # 检查间隔（秒）
timeout = 5              # RPC请求超时（秒）
max_failures = 3         # 连续失败次数阈值
recovery_interval = 30   # 不健康节点重新检查间隔（秒）

1
2
3
4
5
6

[proxy]
retry_count = 2          # 失败重试次数
request_timeout = 30     # 请求超时（秒）
enable_cache = false     # 是否启用缓存（未实现）
cache_ttl = 60           # 缓存TTL（秒）
max_batch_size = 100     # 批量请求最大数量（防止恶意超大批量请求）

1
2
3
4

[log]
level = "info"           # 日志级别: debug, info, warn, error
output = "stdout"        # 输出位置: stdout, file
file_path = "../log/crpc.log"  # 日志文件路径

1
2
3
4

[log_cleanup]
enabled = true          # 是否启用自动清理
interval = 24           # 清理间隔（小时），默认每24小时
retention_days = 7      # 日志保留天数，删除N天前的日志

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

# 创建部署目录
sudo mkdir -p /opt/crpc
sudo chown $USER:$USER /opt/crpc

# 复制项目文件
cp -r /home/smokey/Desktop/crpc/* /opt/crpc/

# 编译程序
cd /opt/crpc
make build

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15

[Unit]
Description=CRPC Instance %i
After=network.target postgresql.service

[Service]
Type=simple
User=crpc
WorkingDirectory=/opt/crpc/program
Environment="CRPC_INSTANCE_ID=crpc-%i"
ExecStart=/opt/crpc/program/crpc
Restart=always
RestartSec=10

[Install]
WantedBy=multi-user.target

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

# 实例1（端口8080）
cp /opt/crpc/config/config.toml /opt/crpc/config/config.instance1.toml

# 实例2（端口8081）
cp /opt/crpc/config/config.toml /opt/crpc/config/config.instance2.toml
sed -i 's/port = 8080/port = 8081/' /opt/crpc/config/config.instance2.toml
sed -i 's/instance_id = "crpc-1"/instance_id = "crpc-2"/' /opt/crpc/config/config.instance2.toml

# 实例3（端口8082）
cp /opt/crpc/config/config.toml /opt/crpc/config/config.instance3.toml
sed -i 's/port = 8080/port = 8082/' /opt/crpc/config/config.instance3.toml
sed -i 's/instance_id = "crpc-1"/instance_id = "crpc-3"/' /opt/crpc/config/config.instance3.toml

1
2
3
4
5
6
7
8
9

# 启动实例
sudo systemctl enable crpc@1 crpc@2 crpc@3
sudo systemctl start crpc@1 crpc@2 crpc@3

# 查看状态
sudo systemctl status crpc@*

# 查看日志
sudo journalctl -u crpc@1 -f

1
2
3
4
5
6
7
8
9

# 复制Nginx配置
sudo cp /opt/crpc/config/nginx.conf /etc/nginx/nginx.conf

# 测试配置
sudo nginx -t

# 重启Nginx
sudo systemctl restart nginx
sudo systemctl enable nginx

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

-- 连接数据库
psql -h localhost -U crpc -d crpc

-- 添加新链
INSERT INTO chains (chain_id, chain_name, description)
VALUES ('arbitrum', 'Arbitrum One', 'Arbitrum Layer 2网络');

-- 添加节点
INSERT INTO rpc_nodes (chain_id, node_url, provider, priority, weight)
VALUES
('arbitrum', 'https://arb1.arbitrum.io/rpc', 'Official', 1, 10),
('arbitrum', 'https://rpc.ankr.com/arbitrum', 'Ankr', 2, 10),
('arbitrum', 'https://arbitrum.llamarpc.com', 'LlamaNodes', 3, 5);

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

# 先手动添加链到数据库，然后通过API添加节点
curl -X POST http://localhost/api/nodes \
  -H "Content-Type: application/json" \
  -d '{
    "chain_id": "arbitrum",
    "node_url": "https://arb1.arbitrum.io/rpc",
    "provider": "Official",
    "priority": 1,
    "weight": 10,
    "is_active": true
  }'

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

cd scripts

# 部署到默认服务器（d1.smokey）
./deploy_to_remote.sh

# 脚本会自动：
# 1. 本地编译应用
# 2. 上传二进制文件到远程服务器
# 3. 询问是否更新配置文件
# 4. 重启远程服务
# 5. 验证服务健康状态

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15

cd scripts

# 部署3个实例到 d1.smokey（默认）
./deploy_multi_instance.sh

# 部署5个实例到指定服务器
./deploy_multi_instance.sh your-server 5

# 脚本会自动：
# 1. 编译应用程序
# 2. 上传二进制文件
# 3. 为每个实例生成独立配置（端口 8080-808N）
# 4. 创建 systemd 服务单元 (crpc@1, crpc@2, ...)
# 5. 更新 Nginx 负载均衡配置
# 6. 启动所有实例并验证

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

# 查看所有实例状态
ssh d1.smokey systemctl status 'crpc@*'

# 重启所有实例
ssh d1.smokey systemctl restart 'crpc@*'

# 停止单个实例
ssh d1.smokey systemctl stop crpc@2

# 查看实例日志
ssh d1.smokey journalctl -u crpc@1 -f

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15

cd scripts

# 测试默认服务器（192.168.1.21）
./benchmark.sh

# 测试指定地址，10并发，100请求
./benchmark.sh http://your-server 10 100

# 测试内容包括：
# 1. 健康检查端点延迟测试
# 2. RPC代理响应时间测试（eth_blockNumber）
# 3. API管理接口功能测试
# 4. 负载均衡验证（实例分配统计）
# 5. 并发压力测试（需要 ab 工具）
# 6. 节点和日志统计信息

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

============================================
📊 CRPC 性能测试
============================================
目标地址: http://192.168.1.21
并发数: 10
请求数: 100
============================================

测试1: 健康检查端点
GET http://192.168.1.21/health
  请求 1: {"instance_id":"crpc-1","status":"ok"} (耗时: 0.001ms)
  ...

测试2: RPC代理 - eth_blockNumber
  ✅ 请求 1: 成功 - 区块高度 0x16b77f2 (耗时: 0.5s)
  ...
  统计结果:
    成功: 20
    失败: 0
    平均响应时间: 0.45s

测试4: 负载均衡测试
  实例分配统计:
    crpc-1: 4 次请求
    crpc-2: 3 次请求
    crpc-3: 3 次请求

1
2
3
4
5
6
7
8
9

cd scripts

# 监控默认服务器，每5秒刷新
./monitor.sh

# 监控指定服务器，每3秒刷新
./monitor.sh your-server 3

# 按 Ctrl+C 退出监控

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

============================================
📊 CRPC 服务监控面板
============================================
主机: d1.smokey
刷新间隔: 5s
时间: 2025-11-17 19:30:45
============================================

🔧 服务状态
----------------------------------------
crpc@1.service: ✅ 运行中
crpc@2.service: ✅ 运行中
crpc@3.service: ✅ 运行中

🏥 健康检查
----------------------------------------
Nginx 代理: ✅ 正常
响应: {"instance_id":"crpc-2","status":"ok"}

🌐 RPC 节点统计
----------------------------------------
  总节点数: 15
  健康节点: 13
  异常节点: 2

💻 系统资源
----------------------------------------
  CPU 使用率: 8.5%
  内存: 已用: 1850MB / 总计: 3950MB (46.8%)
  磁盘: 已用: 12.5G / 总计: 50G (26%)

1
2
3
4
5
6
7
8
9

# 步骤1：部署多实例
cd scripts
./deploy_multi_instance.sh your-server 3

# 步骤2：运行性能测试
./benchmark.sh http://your-server

# 步骤3：启动实时监控（另开终端）
./monitor.sh your-server 5

1
2
3

# 快速重新部署（已配置好systemd和Nginx）
cd scripts
./deploy_to_remote.sh

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

# 检查Nginx状态
curl http://localhost/health

# 检查特定实例（直连）
curl http://localhost:8080/health
curl http://localhost:8081/health
curl http://localhost:8082/health

# 检查所有实例
for i in 8080 8081 8082; do
  echo "实例端口$i:"
  curl -s http://localhost:$i/health | jq
done

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

# 本地运行
tail -f log/crpc.log

# Systemd管理的服务
sudo journalctl -u crpc@1 -f
sudo journalctl -u crpc@2 -f
sudo journalctl -u crpc@3 -f

# 查看所有实例日志
sudo journalctl -u 'crpc@*' -f

1
2
3
4
5
6
7
8

SELECT
    chain_id,
    COUNT(*) as total,
    SUM(CASE WHEN is_healthy THEN 1 ELSE 0 END) as healthy,
    SUM(CASE WHEN is_healthy THEN 0 ELSE 1 END) as unhealthy
FROM rpc_nodes
WHERE is_active = true
GROUP BY chain_id;

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

SELECT
    n.chain_id,
    n.node_url,
    h.is_healthy,
    h.response_time,
    h.checked_by,
    h.checked_at
FROM health_check_logs h
JOIN rpc_nodes n ON h.node_id = n.id
ORDER BY h.checked_at DESC
LIMIT 20;

1
2
3
4
5
6
7
8

SELECT
    chain_id,
    COUNT(*) as total_requests,
    SUM(CASE WHEN success THEN 1 ELSE 0 END) as success_count,
    AVG(response_time) as avg_response_time
FROM request_logs
WHERE created_at > NOW() - INTERVAL '1 hour'
GROUP BY chain_id;

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18

-- 查看表大小和行数
SELECT
    schemaname,
    tablename,
    pg_size_pretty(pg_total_relation_size(schemaname||'.'||tablename)) AS size,
    n_live_tup AS row_count
FROM pg_stat_user_tables
WHERE tablename IN ('request_logs', 'health_check_logs')
ORDER BY pg_total_relation_size(schemaname||'.'||tablename) DESC;

-- 查看每天的日志增长
SELECT
    DATE(created_at) as date,
    COUNT(*) as request_count
FROM request_logs
WHERE created_at > NOW() - INTERVAL '30 days'
GROUP BY DATE(created_at)
ORDER BY date DESC;

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15

-- 定期清理旧日志（保留7天）
DELETE FROM health_check_logs WHERE checked_at < NOW() - INTERVAL '7 days';
DELETE FROM request_logs WHERE created_at < NOW() - INTERVAL '7 days';

-- 创建定时任务
CREATE EXTENSION IF NOT EXISTS pg_cron;

SELECT cron.schedule(
    'cleanup-old-logs',
    '0 2 * * *',  -- 每天凌晨2点
    $$
    DELETE FROM health_check_logs WHERE checked_at < NOW() - INTERVAL '7 days';
    DELETE FROM request_logs WHERE created_at < NOW() - INTERVAL '7 days';
    $$
);

1
2

# 编辑 program/proxy/proxy.go
# 注释掉 CreateRequestLog 相关调用

1
2
3
4
5
6
7
8

# 增加worker进程
worker_processes auto;

# 增加keepalive连接
keepalive 64;

# 增加连接超时
keepalive_timeout 65;

1
2
3

cd program
./crpc
# 查看错误信息

1

psql -h localhost -U crpc -d crpc -c "SELECT 1;"

1
2
3
4

# 检查端口是否被占用
netstat -tunlp | grep 8080
netstat -tunlp | grep 8081
netstat -tunlp | grep 8082

1

SELECT * FROM rpc_nodes WHERE id = 1;

1
2
3
4

SELECT * FROM health_check_logs
WHERE node_id = 1
ORDER BY checked_at DESC
LIMIT 10;

1
2
3

curl -X POST https://eth.llamarpc.com \
  -H "Content-Type: application/json" \
  -d '{"jsonrpc":"2.0","method":"eth_blockNumber","params":[],"id":1}'

1
2
3

UPDATE rpc_nodes
SET is_healthy = true, failure_count = 0
WHERE id = 1;

1
2

sudo nginx -t
curl http://localhost/nginx_status

1
2
3
4
5

# Systemd
sudo systemctl status crpc@1 crpc@2 crpc@3

# 直接检查进程
ps aux | grep crpc

1
2
3
4
5
6

SELECT
    instance_id,
    COUNT(*) as request_count
FROM request_logs
WHERE created_at > NOW() - INTERVAL '1 hour'
GROUP BY instance_id;

1
2
3
4

# 编辑 config/config.toml
[database]
max_open_conns = 50  # 增加最大连接数
max_idle_conns = 10  # 增加空闲连接数

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15

# 1. 更新实例1
sudo systemctl stop crpc@1
cd /opt/crpc/program
go build -o crpc .
sudo systemctl start crpc@1
sleep 10  # 等待健康检查通过

# 2. 更新实例2
sudo systemctl stop crpc@2
sudo systemctl start crpc@2
sleep 10

# 3. 更新实例3
sudo systemctl stop crpc@3
sudo systemctl start crpc@3

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19

// program/api/handler.go
func AuthMiddleware() gin.HandlerFunc {
    return func(c *gin.Context) {
        token := c.GetHeader("X-API-Key")
        if token == "" || !validateToken(token) {
            c.JSON(401, gin.H{"error": "Unauthorized"})
            c.Abort()
            return
        }
        c.Next()
    }
}

// 在SetupRoutes中使用
api := r.Group("/api")
api.Use(AuthMiddleware())
{
    // ... 路由定义
}

1
2
3

#!/bin/bash
# 每5秒刷新一次节点状态
watch -n 5 "curl -s http://localhost/api/stats/nodes | jq"

1
2
3

curl -X PUT http://localhost/api/nodes/{id} \
  -H "Content-Type: application/json" \
  -d '{"priority": 99, "weight": 1}'

1
2
3

curl -X PUT http://localhost/api/nodes/{id} \
  -H "Content-Type: application/json" \
  -d '{"is_active": false}'

1
2
3

upstream crpc_backend {
    keepalive 64;  # 保持64个长连接到后端
}

1
2
3

gzip on;
gzip_comp_level 6;
gzip_types application/json;

1
2
3

proxy_buffering on;
proxy_buffer_size 8k;
proxy_buffers 8 8k;

1
2
3
4

upstream crpc_backend {
    least_conn;  # 最少连接算法
    server localhost:8080 max_fails=3 fail_timeout=30s;
}

1
2
3
4

[database]
max_open_conns = 50   # 最大连接数
max_idle_conns = 10   # 空闲连接池
conn_max_lifetime = 3600  # 连接复用时长（秒）

1
2

proxy_http_version 1.1;
proxy_set_header Connection "";

1
2
3
4
5
6
7
8
9

-- 链ID索引（常用查询）
CREATE INDEX idx_nodes_chain ON rpc_nodes(chain_id);

-- 健康节点查询索引（组合索引）
CREATE INDEX idx_nodes_healthy ON rpc_nodes(chain_id, is_healthy, is_active);

-- 日志时间索引（清理操作）
CREATE INDEX idx_request_logs_time ON request_logs(created_at);
CREATE INDEX idx_health_logs_time ON health_check_logs(checked_at);

1
2
3
4

[计划中] 添加 Redis 缓存
- 缓存 eth_blockNumber 等轻量查询（5秒TTL）
- 缓存节点列表（减少数据库查询）
- 预期提升：50-100% 吞吐量

1
2
3
4

[计划中] 上游RPC节点连接池
- 预建立和复用HTTP/WebSocket连接
- 减少TLS握手延迟
- 预期提升：20-50ms 延迟降低

1
2
3
4

[计划中] 集成 OpenTelemetry
- 端到端请求追踪
- 性能瓶颈分析
- 更精准的监控告警