如何集群化你的Eclair节点

ACINQ_
发布于 2025-01-08 15:12
阅读 20

本文介绍了如何通过将Eclair闪电网络节点在多个服务器上进行集群化部署，以实现横向扩展。前端服务器处理路由表同步和对等连接，后端服务器专注于通道管理。文章提供了最小化演示设置、生产环境设置，以及在AWS上部署的详细指导，包括启用加密通信、配置私钥和设置环境变量等。

Eclair 允许你将一个**逻辑**闪电网络节点扩展到多台服务器上。

前端服务器负责处理与路由表相关的gossip和来自对等节点的同步请求，这需要大量的 CPU/带宽。后端服务器可以专注于核心的通道管理。因此，BOLT 1和7消息在前端处理，而BOLT 2消息则通过后端处理。

前端服务器是无状态的，可以随意停止/杀死。只要至少有一个`frontend`可用，该节点将保持运行并可达。

```
                +---+     +-----------+
                |   |     | +-------+ |
                |   |-----|-|       | |
       P   -----| L |-----|-| FRONT |-|---,
       U        | O |-----|-|       | |    \
       B     ---| A |     | +-------+ |     \
       L        | D |     |           |      \
       I        |   |     | +-------+ |       \ +------+
       C   -----| B |-----|-|       | |        `|      |
                | A |-----|-| FRONT |-|---------| BACK |<-- channels management
       N        | L |-----|-|       | |        ,|      |    relay logic
       E    ----| A |     | +-------+ |       / +------+
       T        | N |     |           |      /
       W        | C |     | +-------+ |     /
       O        | E |-----|-|       | |    /
       R   -----| R |-----|-| FRONT |-|---'
       K        |   |-----|-|       |<------- connection management
                |   |     | +-------+ |       routing table sync
                +---+     +-----------+
```

目标是将你的节点从连接和路由表管理中解放出来：
- 传入连接
- 传出连接
- gossip 查询 + pings
- 传入 gossip 聚合
- 传出 gossip 分发（重新广播）

### 先决条件

你已经有一个闪电网络节点以独立设置运行（已正确配置 Bitcoin Core 等）。

你知道你的`node id`是什么。

本文档中使用的约定：
- 我们之前称之为`eclair-node`的将被称为`backend`。它的启动、配置和备份方式与独立设置完全相同。
- `node`指的是 *akka 集群节点*，不要与闪电网络节点混淆。所有 *集群节点* 共同形成一个单一的逻辑 *闪电网络节点*。

### 最小/演示设置

如果你想在单个本地服务器上试验集群模式，请使用此设置。

在`.eclair/eclair.conf`中设置以下值：
```
akka.actor.provider = cluster
akka.extensions = ["akka.cluster.pubsub.DistributedPubSub"]

// replace this with your node id
// if you don't know what your node id is, you should probably stop right here
eclair.front.pub = 03...............
```

启动`backend`：
```shell
$ ./eclair-node.sh
```

然后运行一个`frontend`实例：
```shell
$ ./eclair-front.sh -Dakka.remote.artery.canonical.port=25521 -Declair.server.port=9736
```

注意：我们覆盖了端口，否则它们会冲突，因为在此示例中，所有内容都在同一服务器上运行。你可以在同一服务器上运行多个`frontend`，只需确保更改端口。

### 生产环境设置

在生产环境中，你应该：
- 运行多个`frontend`服务器
- 每个服务器运行一个应用程序
- 启用`tcp-tls`以使用你自己的生成证书加密集群成员之间的通信（见下文）
- 使用负载均衡器在同一 IP 地址下隐藏所有`frontend`服务器
- 设置防火墙规则以禁用`backend`服务器上的闪电网络连接（端口 9735），以便所有连接都通过`frontend`
- 启用 [监控](https://github.com/ACINQ/eclair/blob/master/docs/Monitoring.md)
- 在 AWS 上，使用 AWS Secrets Manager（参见 [AWS 部署](#aws-deployment)）

#### 为集群启用加密通信

我们使用自签名证书，这提供了一个很好的折衷方案。更多高级选项可用，请参阅 [akka 文档](https://doc.akka.io/docs/akka/current/remoting-artery.html#remote-security)。
> 为所有节点使用一组密钥和一个证书，并禁用主机名检查
> - 将这组密钥和证书分发到所有节点。该证书可以是自签名的，因为它既作为身份验证证书分发，也作为受信任的证书分发。
> - 如果密钥/证书丢失，其他人可以连接到你的集群。
> - 向集群添加节点很简单，因为密钥材料可以部署/分发到新的集群节点。

生成自签名证书（设置强密码）：
```shell
$ keytool -genkeypair -v \
          -keystore akka-cluster-tls.jks \
          -dname "O=ACME, C=FR" \
          -keypass <password> \
          -storepass <password> \
          -keyalg RSA \
          -keysize 4096 \
          -validity 9999
```

将生成的证书复制到后端节点和所有前端节点上的`.eclair`目录中：
```shell
$ cp akka-cluster-tls.jks ~/.eclair
```

在所有前端节点上的`eclair.conf`中添加以下内容：
```
akka.remote.artery.transport = "tls-tcp"
```

#### 在单独的服务器上运行集群节点

使用以下环境变量启动所有前端节点：
* BACKEND_IP 设置为后端节点的 IP 地址
* LOCAL_IP 设置为此前端节点的 IP 地址（这通常是一个私有 IP 地址，可以从后端节点访问）
* NODE_PUB_KEY 设置为你的节点公钥
* AKKA_TLS_PASSWORD 设置为你的 Akka 证书的密码

在你的后端节点的`eclair.conf`中添加以下内容：
```
akka.remote.artery.transport = "tls-tcp"
akka.remote.artery.canonical.hostname="ip-of-this-backend-node"
akka.cluster.seed-nodes=["akka://eclair-node@ip-of-this-backend-node:25520"]
```

使用以下环境变量启动你的后端节点：
* AKKA_TLS_PASSWORD 设置为你的 Akka 证书的密码

### AWS 部署

为方便起见，我们为`frontend`提供了一个预构建的 AWS Beanstalk 捆绑包（选择 WebServer 环境类型和 Java 平台）。

你可以按原样运行它进行测试。

#### TLS 加密

如果你打算在生产中使用它，则需要使用你自己的证书启用加密：
1. 按照上述步骤生成你的`akka-tls.jks`

2. 我们建议 fork 该项目并构建你自己的捆绑包：
```shell
$ git clone git@github.com:ACINQ/eclair.git
$ vi eclair-core/src/main/reference.conf # set akka.remote.artery.transport = "tls-tcp"
$ cp akka-cluster-tls.jks eclair-front/modules/awseb/ # copy the file you generated
$ vi eclair-front/modules/awseb.xml # uncomment the relevant parts
$ ./mvnw package -DskipTests
```
或者，你也可以编辑现有的捆绑包，并将`akka-cluster-tls.jks`文件手动添加到 zip 存档的根目录。你还需要在运行时设置`akka.remote.artery.transport=tls-tcp`。

#### 私钥

在生产环境中，我们强烈建议使用 AWS Secrets Manager 来提供节点私钥。这可以通过设置`eclair.front.priv-key-provider=aws-sm`来完成。默认的密钥名称是“node-priv-key”，但可以使用`eclair.front.aws-sm.priv-key-name`进行配置。

#### 配置

我们建议使用 Beanstalk 环境变量来设置`AKKA_TLS_PASSWORD`、`BACKEND_IP`和`NODE_PUB_KEY`。其他配置键应在`AKKA_CONF`环境变量中设置，以分号分隔。示例：
- `AKKA_CONF`：`eclair.enable-kamon=true; akka.remote.artery.transport=tls-tcp; eclair.front.priv-key-provider=aws-sm...`
- `AKKA_TLS_PASSWORD`：`xxxxxxxx`
- `BACKEND_IP`：`1.2.3.4`
- `NODE_PUB_KEY`：`03933884aaf1d6b108397e5efe5c86bcf2d8ca8d2f700eda99db9214fc2712b134`

端口`25520`需要在 Beanstalk 安全组内以及 Beanstalk 安全组和你的 `backend` 节点之间打开。

### Tor

我们建议在单独的服务器上运行你的 Tor 隐藏服务，并使用`eclair.tor.targets`将 clearnet(*) 连接重定向到你的`frontend`服务器。

(*) Clearnet 对于 Tor，但 BOLT 8 已加密。

这是最终的架构：

```
                             +---+     +-----------+
                             |   |     | +-------+ |
                             |   |-----|-|       | |
       P                -----| L |-----|-| FRONT |-|---,
       U                     | O |-----|-|       | |    \
       B                  ---| A |     | +-------+ |     \
       L                     | D |     |           |      \
       I                     |   |     | +-------+ |       \ +------+
       C              -------| B |-----|-|       | |        `|      |
                             | A |-----|-| FRONT |-|---------| BACK |<-- channels management
       N                     | L |-----|-|       | |        ,|      |    relay logic
       E                 ----| A |     | +-------+ |       / +------+
       T                     | N |     |           |      /
       W      +-------+      | C |     | +-------+ |     /
       O      |       |      | E |-----|-|       | |    /
       R   ---|  Tor  |------| R |-----|-| FRONT |-|---'
       K      |       |      |   |-----|-|       |<------- connection management
              +-------+      |   |     | +-------+ |       routing table sync
                             +---+     +-----------+
```

>- 原文链接： [github.com/ACINQ/eclair/...](https://github.com/ACINQ/eclair/blob/master/docs/Cluster.md)
>- 登链社区 AI 助手，为大家转译优秀英文文章，如有翻译不通的地方，还请包涵～

Eclair 允许你将一个逻辑闪电网络节点扩展到多台服务器上。

前端服务器是无状态的，可以随意停止/杀死。只要至少有一个frontend可用，该节点将保持运行并可达。

                +---+     +-----------+
                |   |     | +-------+ |
                |   |-----|-|       | |
       P   -----| L |-----|-| FRONT |-|---,
       U        | O |-----|-|       | |    \
       B     ---| A |     | +-------+ |     \
       L        | D |     |           |      \
       I        |   |     | +-------+ |       \ +------+
       C   -----| B |-----|-|       | |        `|      |
                | A |-----|-| FRONT |-|---------| BACK |&lt;-- channels management
       N        | L |-----|-|       | |        ,|      |    relay logic
       E    ----| A |     | +-------+ |       / +------+
       T        | N |     |           |      /
       W        | C |     | +-------+ |     /
       O        | E |-----|-|       | |    /
       R   -----| R |-----|-| FRONT |-|---'
       K        |   |-----|-|       |&lt;------- connection management
                |   |     | +-------+ |       routing table sync
                +---+     +-----------+

目标是将你的节点从连接和路由表管理中解放出来：

传入连接
传出连接
gossip 查询 + pings
传入 gossip 聚合
传出 gossip 分发（重新广播）

先决条件

你已经有一个闪电网络节点以独立设置运行（已正确配置 Bitcoin Core 等）。

你知道你的node id是什么。

本文档中使用的约定：

我们之前称之为eclair-node的将被称为backend。它的启动、配置和备份方式与独立设置完全相同。
node指的是 akka 集群节点，不要与闪电网络节点混淆。所有 集群节点 共同形成一个单一的逻辑 闪电网络节点。

最小/演示设置

如果你想在单个本地服务器上试验集群模式，请使用此设置。

在.eclair/eclair.conf中设置以下值：

akka.actor.provider = cluster
akka.extensions = ["akka.cluster.pubsub.DistributedPubSub"]

// replace this with your node id
// if you don't know what your node id is, you should probably stop right here
eclair.front.pub = 03...............

启动backend：

$ ./eclair-node.sh

然后运行一个frontend实例：

$ ./eclair-front.sh -Dakka.remote.artery.canonical.port=25521 -Declair.server.port=9736

注意：我们覆盖了端口，否则它们会冲突，因为在此示例中，所有内容都在同一服务器上运行。你可以在同一服务器上运行多个frontend，只需确保更改端口。

生产环境设置

在生产环境中，你应该：

运行多个frontend服务器
每个服务器运行一个应用程序
启用tcp-tls以使用你自己的生成证书加密集群成员之间的通信（见下文）
使用负载均衡器在同一 IP 地址下隐藏所有frontend服务器
设置防火墙规则以禁用backend服务器上的闪电网络连接（端口 9735），以便所有连接都通过frontend
启用监控
在 AWS 上，使用 AWS Secrets Manager（参见 AWS 部署）

为集群启用加密通信

我们使用自签名证书，这提供了一个很好的折衷方案。更多高级选项可用，请参阅 akka 文档。

为所有节点使用一组密钥和一个证书，并禁用主机名检查

将这组密钥和证书分发到所有节点。该证书可以是自签名的，因为它既作为身份验证证书分发，也作为受信任的证书分发。

如果密钥/证书丢失，其他人可以连接到你的集群。

向集群添加节点很简单，因为密钥材料可以部署/分发到新的集群节点。

生成自签名证书（设置强密码）：

$ keytool -genkeypair -v \
          -keystore akka-cluster-tls.jks \
          -dname "O=ACME, C=FR" \
          -keypass &lt;password> \
          -storepass &lt;password> \
          -keyalg RSA \
          -keysize 4096 \
          -validity 9999

将生成的证书复制到后端节点和所有前端节点上的.eclair目录中：

$ cp akka-cluster-tls.jks ~/.eclair

在所有前端节点上的eclair.conf中添加以下内容：

akka.remote.artery.transport = "tls-tcp"

在单独的服务器上运行集群节点

使用以下环境变量启动所有前端节点：

BACKEND_IP 设置为后端节点的 IP 地址
LOCAL_IP 设置为此前端节点的 IP 地址（这通常是一个私有 IP 地址，可以从后端节点访问）
NODE_PUB_KEY 设置为你的节点公钥
AKKA_TLS_PASSWORD 设置为你的 Akka 证书的密码

在你的后端节点的eclair.conf中添加以下内容：

akka.remote.artery.transport = "tls-tcp"
akka.remote.artery.canonical.hostname="ip-of-this-backend-node"
akka.cluster.seed-nodes=["akka://eclair-node@ip-of-this-backend-node:25520"]

使用以下环境变量启动你的后端节点：

AKKA_TLS_PASSWORD 设置为你的 Akka 证书的密码

AWS 部署

为方便起见，我们为frontend提供了一个预构建的 AWS Beanstalk 捆绑包（选择 WebServer 环境类型和 Java 平台）。

你可以按原样运行它进行测试。

TLS 加密

如果你打算在生产中使用它，则需要使用你自己的证书启用加密：

按照上述步骤生成你的akka-tls.jks

我们建议 fork 该项目并构建你自己的捆绑包：

$ git clone git@github.com:ACINQ/eclair.git
$ vi eclair-core/src/main/reference.conf # set akka.remote.artery.transport = "tls-tcp"
$ cp akka-cluster-tls.jks eclair-front/modules/awseb/ # copy the file you generated
$ vi eclair-front/modules/awseb.xml # uncomment the relevant parts
$ ./mvnw package -DskipTests

或者，你也可以编辑现有的捆绑包，并将akka-cluster-tls.jks文件手动添加到 zip 存档的根目录。你还需要在运行时设置akka.remote.artery.transport=tls-tcp。

私钥

在生产环境中，我们强烈建议使用 AWS Secrets Manager 来提供节点私钥。这可以通过设置eclair.front.priv-key-provider=aws-sm来完成。默认的密钥名称是“node-priv-key”，但可以使用eclair.front.aws-sm.priv-key-name进行配置。

配置

我们建议使用 Beanstalk 环境变量来设置AKKA_TLS_PASSWORD、BACKEND_IP和NODE_PUB_KEY。其他配置键应在AKKA_CONF环境变量中设置，以分号分隔。示例：

AKKA_CONF：eclair.enable-kamon=true; akka.remote.artery.transport=tls-tcp; eclair.front.priv-key-provider=aws-sm...
AKKA_TLS_PASSWORD：xxxxxxxx
BACKEND_IP：1.2.3.4
NODE_PUB_KEY：03933884aaf1d6b108397e5efe5c86bcf2d8ca8d2f700eda99db9214fc2712b134

端口25520需要在 Beanstalk 安全组内以及 Beanstalk 安全组和你的 backend 节点之间打开。

Tor

我们建议在单独的服务器上运行你的 Tor 隐藏服务，并使用eclair.tor.targets将 clearnet(*) 连接重定向到你的frontend服务器。