Data Grid 服务器指南
Red Hat Data Grid
Data Grid 是一个高性能分布式内存数据存储。
- 无架构数据结构
- 将不同对象存储为键值对的灵活性。
- 基于网格的数据存储
- 旨在在集群中分发和复制数据。
- 弹性扩展
- 动态调整节点数量,以便在不中断服务的情况下满足需求。
- 数据互操作性
- 从不同端点在网格中存储、检索和查询数据。
Data Grid 文档
红帽客户门户网站中提供了 Data Grid 的文档。
Data Grid 下载
访问红帽客户门户上的 Data Grid 软件下载。
您必须有一个红帽帐户才能访问和下载数据中心软件。
使开源包含更多
红帽致力于替换我们的代码、文档和 Web 属性中存在问题的语言。我们从这四个术语开始:master、slave、黑名单和白名单。由于此项工作十分艰巨,这些更改将在即将推出的几个发行版本中逐步实施。详情请查看 CTO Chris Wright 的信息。
第 1 章 Data Grid 服务器入门
安装服务器分发、创建用户并启动您的第一个 Data Grid 集群。
Ansible 集合
使用 Ansible 集合(包括 Keycloak 缓存和跨站点复制配置)自动安装 Data Grid 集群。Ansible 集合还可让您在安装过程中将 Data Grid 缓存注入每个服务器实例的静态配置。
Red Hat Automation Hub 提供了 Data Grid 的 Ansible 集合。
1.1. Data Grid 服务器要求
Data Grid 服务器需要 Java 虚拟机。有关支持版本的详情,请查看 Data Grid 支持的配置。
1.2. 下载 Data Grid 服务器发布
Data Grid 服务器分发是 Java 库(JAR
文件)和配置文件的存档。
流程
- 访问红帽客户门户。
- 从 软件下载部分 下载 Red Hat Data Grid 8.5 Server。
运行
md5sum
或sha256sum
命令,并将服务器下载归档作为参数,例如:sha256sum jboss-datagrid-${version}-server.zip
-
与 Data Grid Software Details 页面中的
MD5
或SHA-256
checksum 值进行比较。
参考
- Data Grid Server README 描述了服务器分发的内容。
1.3. 安装 Data Grid 服务器
在主机系统上安装 Data Grid 服务器分发。
先决条件
- 下载 Data Grid 服务器分发存档。
流程
- 使用任何适当的工具将 Data Grid 服务器存档提取到主机文件系统。
unzip redhat-datagrid-8.5.2-server.zip
生成的目录是您的 $RHDG_HOME
。
1.4. Data Grid 的 JVM 设置
您可以通过编辑 server.conf
配置文件或设置 JAVA_OPTS
环境变量来为 Data Grid 定义 Java 虚拟机(JVM)设置。
如果您在容器中运行 Data Grid,则不会设置 Xmx
或 Xms
,因为这些值是从容器设置自动计算为容器大小的 50%。
编辑配置文件
您可以编辑 server.conf
配置文件中所需的值。例如,要将选项设置为传递给 JVM,请编辑以下行:
JAVA_OPTS="-Xms64m -Xmx512m -XX:MetaspaceSize=64M -Djava.net.preferIPv4Stack=true" JAVA_OPTS="$JAVA_OPTS -Djava.awt.headless=true"
您也可以取消对现有示例设置的注释。例如,要为远程套接字调试配置 Java Platform Debugger Architecture (JPDA)设置,请按如下所示更新该文件:
# Sample JPDA settings for remote socket debugging JAVA_OPTS="$JAVA_OPTS -agentlib:jdwp=transport=dt_socket,address=8787,server=y,suspend=n"
另外,您可以在 JAVA_OPTS
中添加更多设置,如下所示:
JAVA_OPTS="$JAVA_OPTS <key_1>=<value_1>, ..., <key_N>=<value_N> "
设置环境变量
您可以通过设置 JAVA_OPTS
环境变量来覆盖 server.conf
配置文件中的设置。例如:
Linux
export JAVA_OPTS="-Xmx1024M"
Microsoft Windows
set JAVA_OPTS="-Xmx1024M"
1.5. 启动 Data Grid 服务器
在任何受支持的主机上的 Java 虚拟机(JVM)中运行 Data Grid 服务器实例。
先决条件
- 下载并安装服务器分发。
流程
-
在
$RHDG_HOME
中打开一个终端。 使用
服务器
脚本启动 Data Grid 服务器实例。- Linux
bin/server.sh
- Microsoft Windows
bin\server.bat
Data Grid 服务器在记录以下信息时成功运行:
ISPN080004: Protocol SINGLE_PORT listening on 127.0.0.1:11222 ISPN080034: Server '...' listening on http://127.0.0.1:11222 ISPN080001: Data Grid Server <version> started in <mm>ms
验证
-
在任意浏览器中打开
127.0.0.1:11222/console/
。 - 在提示符处输入您的凭证,并继续到 Data Grid Console。
1.6. 在启动时传递数据网格服务器配置
在启动 Data Grid 服务器时指定自定义配置。
Data Grid 服务器可以解析您在启动时使用 --server-config
参数覆盖的多个配置文件。您可以根据需要按任何顺序使用任意数量的配置覆盖文件。配置覆盖文件:
-
必须是有效的 Data Grid 配置,并且包含根服务器
元素
或字段。 - 只要您的覆盖文件组合形成完整的配置,就不需要完全配置。
Data Grid 服务器不会检测覆盖文件之间的冲突配置。每个覆盖文件覆盖上述配置中的任何冲突配置。
如果您在启动时将缓存配置传递给 Data Grid 服务器,则不会在集群中动态创建这些缓存。您必须手动将缓存传播到每个节点。
此外,您在启动时传递给 Data Grid 服务器的缓存配置必须包含 infinispan
和 cache-container
元素。
先决条件
- 下载并安装服务器分发。
-
将自定义服务器配置添加到 Data Grid Server 安装的
server/conf
目录中。
流程
-
在
$RHDG_HOME
中打开一个终端。 使用
--server-config= or
参数指定一个或多个配置文件,例如:-
cbin/server.sh -c infinispan.xml -c datasources.yaml -c security-realms.json
1.7. 创建 Data Grid 用户
添加凭据,以通过 Hot Rod 和 REST 端点与数据网格服务器部署进行身份验证。在访问 Data Grid 控制台或执行缓存操作前,您必须至少创建一个使用 Data Grid 命令行界面(CLI)的用户。
Data Grid 通过基于角色的访问控制(RBAC)强制实施安全授权。第一次添加凭证以为您的 Data Grid 部署获得完整的 ADMIN
权限时,创建一个 admin
用户。
先决条件
- 下载并安装 Data Grid Server。
流程
-
在
$RHDG_HOME
中打开一个终端。 使用
user create
命令创建admin
用户。bin/cli.sh user create admin -p changeme
提示从 CLI 会话运行
help user
以获取完整的命令详情。
验证
打开 user.properties
并确认用户存在。
cat server/conf/users.properties admin=scram-sha-1\:BYGcIAwvf6b...
使用 CLI 向属性域添加凭证只会在您连接的服务器实例上创建用户。您必须在属性域中手动将凭证同步到集群中的每个节点。
1.7.1. 授予用户角色
为用户分配角色,并授予他们执行缓存操作并与 Data Grid 资源交互的权限。
如果要为多个用户分配同一角色并集中维护其权限,请将角色授予组而不是用户。
先决条件
-
具有 Data Grid 的
ADMIN
权限。 - 创建 Data Grid 用户。
流程
- 创建与 Data Grid 的 CLI 连接。
使用
用户角色 grant 命令为用户分配角色
,例如:user roles grant --roles=deployer katie
验证
使用用户角色 ls 命令,列出您向用户授予的角色
。
user roles ls katie ["deployer"]
1.7.2. 将用户添加到组中
组可让您更改多个用户的权限。您可以为组分配角色,然后将用户添加到该组。用户从组角色继承权限。
您可以使用 groups 作为 Data Grid Server 配置中的属性域的一部分。每个组都是特殊的用户,它还需要用户名和密码。
先决条件
-
具有 Data Grid 的
ADMIN
权限。 - 创建 Data Grid 用户。
流程
- 创建与 Data Grid 的 CLI 连接。
使用
user create
命令创建组。-
使用
--groups
参数指定组名称。 为组设置用户名和密码。
user create --groups=developers developers -p changeme
-
使用
列出组。
user ls --groups
为组授予角色。
user roles grant --roles=application developers
列出组的角色。
user roles ls developers
一次将用户添加到组中。
user groups john --groups=developers
验证
打开 groups.properties
并确认组存在。
cat server/conf/groups.properties
1.7.3. Data Grid 用户角色和权限
Data Grid 包括多个角色,为用户提供访问缓存和数据网格资源的权限。
角色 | 权限 | 描述 |
---|---|---|
| ALL | 具有所有权限的超级用户,包括控制缓存管理器生命周期。 |
| ALL_READ、ALL_WRITE、LISTEN、EXEC、MONITOR、CREATE |
除了 |
| ALL_READ, ALL_WRITE, LISTEN, EXEC, MONITOR |
除 |
| ALL_READ, MONITOR |
除了监控权限外,还具有对 Data Grid |
| MONITOR |
可以通过 JMX 和 |
1.8. 验证集群视图
同一网络上的数据网格服务器实例会自动发现彼此并组成集群。
完成此流程,使用本地运行 Data Grid 服务器实例的默认 TCP
堆栈中的 MPING
协议观察集群发现。如果要针对自定义网络要求调整集群传输,请参阅设置 Data Grid 集群的文档。
此流程旨在演示集群发现的原则,它不适用于生产环境。在命令行中指定端口偏移等操作不是为生产环境配置集群传输的可靠方法。
先决条件
运行一个 Data Grid 服务器的一个实例。
流程
-
在
$RHDG_HOME
中打开一个终端。 将根目录复制到
server2
。cp -r server server2
指定端口偏移和
server2
目录。bin/server.sh -o 100 -s server2
验证
您可以在控制台的 127.0.0.1:11222/console/cluster-membership
中查看集群成员资格。
在节点加入集群时,Data Grid 还记录以下信息:
INFO [org.infinispan.CLUSTER] (jgroups-11,<server_hostname>) ISPN000094: Received new cluster view for channel cluster: [<server_hostname>|3] (2) [<server_hostname>, <server2_hostname>] INFO [org.infinispan.CLUSTER] (jgroups-11,<server_hostname>) ISPN100000: Node <server2_hostname> joined the cluster
1.9. 关闭 Data Grid 服务器
停止单独运行的服务器,或者安全地关闭集群。
流程
- 创建与 Data Grid 的 CLI 连接。
使用以下方法之一关闭 Data Grid 服务器:
使用
shutdown cluster
命令停止集群中的所有节点,例如:shutdown cluster
此命令将集群状态保存到集群中每个节点的
data
文件夹。如果使用缓存存储,shutdown cluster
命令也会保留缓存中的所有数据。使用
shutdown server
命令和服务器主机名停止单个服务器实例,例如:shutdown server <my_server01>
shutdown server
命令不会等待重新平衡操作完成,如果同时指定了多个主机名,这可能会导致数据丢失。
有关使用 命令的更多详细信息,运行 help shutdown
。
验证
在关闭服务器时,Data Grid 会记录以下信息:
ISPN080002: Data Grid Server stopping ISPN000080: Disconnecting JGroups channel cluster ISPN000390: Persisted state, version=<$version> timestamp=YYYY-MM-DDTHH:MM:SS ISPN080003: Data Grid Server stopped
1.9.1. 关闭并重启 Data Grid 集群
通过正确关闭和重启节点,防止数据丢失并确保集群的一致性。
集群关闭
Data Grid 建议使用 shutdown cluster
命令停止集群中的所有节点,同时保存集群状态并保留缓存中的所有数据。您还可以将 shutdown cluster
命令用于具有单一节点的集群。
当您将 Data Grid 集群恢复在线时,集群中的所有节点和缓存都将不可用,直到所有节点都重新加入为止。为了防止不一致或数据丢失,Data Grid 限制对集群中存储的数据的访问和修改,并修改集群状态,直到集群再次正常工作。另外,Data Grid 禁用集群重新平衡,并防止本地缓存在启动时存储清除。
在集群恢复过程中,协调节点会记录每个新节点加入的消息,指示哪些节点可用,哪些仍然缺失。Data Grid 集群中的其他节点有他们加入的时间视图。您可以使用 Data Grid Console 或 REST API 监控缓存的可用性。
但是,如果不需要等待所有节点,则可使用当前拓扑设置可用的缓存。此方法可以通过 CLI、如下所示或 REST API 实现。
手动安装拓扑可能会导致数据丢失,只有在无法重新创建初始拓扑时才执行此操作。
服务器关闭
在使用 shutdown server
命令关闭节点后,第一个节点将立即上线,而无需等待其他成员。其余的节点立即加入集群,触发状态传输,但首先载入本地持久性,这可能会导致过时的条目。配置为在启动时清除的本地缓存存储将在服务器启动时清除。在服务器重启后,标记为 purge=false
的本地缓存存储将可用,但可能包含过时的条目。
如果您使用 shutdown server
命令关闭集群节点,您必须以相反的顺序重启每台服务器,以避免与缓存中数据丢失和过时的条目相关的潜在问题。
例如,如果您关闭 server1
,然后关闭 server2
,您应该首先启动 server2
,然后启动 server1
。但是,以相反顺序重启集群节点不会完全阻止数据丢失和过时的条目。
1.10. Data Grid Server 安装目录结构
Data Grid 服务器在主机文件系统上使用 $RHDG_HOME
下的以下文件夹:
├── bin ├── boot ├── docs ├── lib ├── server └── static
有关 $RHDG_HOME
目录中每个文件夹的描述以及您可以使用的系统属性来自定义文件系统,请参阅 Data Grid Server README。
1.10.1. 服务器根目录
除了 bin
和 docs
文件夹中的资源外,您应当与之交互的 $RHDG_HOME
下的唯一文件夹是服务器根目录,默认是
服务器的根目录。
您可以在同一 $RHDG_HOME
目录或不同的目录中创建多个节点,但每个 Data Grid 服务器实例必须具有自己的服务器根目录。例如,5 个节点的集群可以在文件系统上有以下服务器根目录:
├── server ├── server1 ├── server2 ├── server3 └── server4
每个服务器根目录都应该包含以下文件夹:
├── server │ ├── conf │ ├── data │ ├── lib │ └── log
server/conf
包含 Data Grid 服务器实例的 infinispan.xml
配置文件。
Data Grid 将配置分成两个层:
- dynamic
-
为数据可扩展性创建可变缓存配置。
Data Grid 服务器会永久保存您在运行时创建的缓存,以及跨节点分布的集群状态。每个加入节点都会获得一个完整的集群状态,当发生更改时,Data Grid 服务器会在所有节点间同步。 - Static
-
为
infinispan.xml
添加配置,以用于集群传输、安全性和共享数据源等底层服务器机制。
server/data
提供 Data Grid 服务器用来维护集群状态的内部存储。
切勿直接删除或修改 server/data
中的内容。
在服务器运行时 修改 cache.xml
等文件可能会导致崩溃。删除内容可能会导致状态不正确,这意味着集群无法在关闭后重启。
server/lib
包含适用于自定义过滤器、自定义事件监听程序、JDBC 驱动程序、自定义 ServerTask
实现等的扩展 JAR
文件。
server/log
包含 Data Grid 服务器日志文件。
第 2 章 网络接口和套接字绑定
通过网络接口公开 Data Grid 服务器,方法是将其绑定到 IP 地址。然后,您可以将端点配置为使用接口,以便 Data Grid 服务器可以处理来自远程客户端应用程序的请求。
2.1. 网络接口
Data Grid 服务器对单个 TCP/IP 端口进行多路复用端点,并自动检测入站客户端请求的协议。您可以配置 Data Grid 服务器如何绑定到网络接口,以侦听客户端请求。
互联网协议(IP)地址
XML
<server xmlns="urn:infinispan:server:15.0"> <!-- Selects a specific IPv4 address, which can be public, private, or loopback. This is the default network interface for Data Grid Server. --> <interfaces> <interface name="public"> <inet-address value="${infinispan.bind.address:127.0.0.1}"/> </interface> </interfaces> </server>
JSON
{ "server": { "interfaces": [{ "name": "public", "inet-address": { "value": "127.0.0.1" } }] } }
YAML
server: interfaces: - name: "public" inetAddress: value: "127.0.0.1"
环回地址
XML
<server xmlns="urn:infinispan:server:15.0"> <!-- Selects an IP address in an IPv4 or IPv6 loopback address block. --> <interfaces> <interface name="public"> <loopback/> </interface> </interfaces> </server>
JSON
{ "server": { "interfaces": [{ "name": "public", "loopback": null }] } }
YAML
server: interfaces: - name: "public" loopback: ~
非循环地址
XML
<server xmlns="urn:infinispan:server:15.0"> <!-- Selects an IP address in an IPv4 or IPv6 non-loopback address block. --> <interfaces> <interface name="public"> <non-loopback/> </interface> </interfaces> </server>
JSON
{ "server": { "interfaces": [{ "name": "public", "non_loopback": null }] } }
YAML
server: interfaces: - name: "public" nonLoopback: ~
任何地址
XML
<server xmlns="urn:infinispan:server:15.0"> <!-- Uses the `INADDR_ANY` wildcard address which means Data Grid Server listens for inbound client requests on all interfaces. --> <interfaces> <interface name="public"> <any-address/> </interface> </interfaces> </server>
JSON
{ "server": { "interfaces": [{ "name": "public", "any_address": null }] } }
YAML
server: interfaces: - name: "public" anyAddress: ~
链接本地
XML
<server xmlns="urn:infinispan:server:15.0"> <!-- Selects a link-local IP address in an IPv4 or IPv6 address block. --> <interfaces> <interface name="public"> <link-local/> </interface> </interfaces> </server>
JSON
{ "server": { "interfaces": [{ "name": "public", "link_local": null }] } }
YAML
server: interfaces: - name: "public" linkLocal: ~
站点本地
XML
<server xmlns="urn:infinispan:server:15.0"> <!-- Selects a site-local (private) IP address in an IPv4 or IPv6 address block. --> <interfaces> <interface name="public"> <site-local/> </interface> </interfaces> </server>
JSON
{ "server": { "interfaces": [{ "name": "public", "site_local": null }] } }
YAML
server: interfaces: - name: "public" siteLocal: ~
2.1.1. 匹配和回退策略
Data Grid 服务器可以枚举主机系统上的所有网络接口,并绑定到与值匹配的接口、主机或 IP 地址,其中包括正则表达式以获得更大的灵活性。
匹配主机
XML
<server xmlns="urn:infinispan:server:15.0"> <!-- Selects an IP address that is assigned to a matching host name. --> <interfaces> <interface name="public"> <match-host value="my_host_name"/> </interface> </interfaces> </server>
JSON
{ "server": { "interfaces": [{ "name": "public", "match-host": { "value": "my_host_name" } }] } }
YAML
server: interfaces: - name: "public" matchHost: value: "my_host_name"
匹配接口
XML
<server xmlns="urn:infinispan:server:15.0"> <!--Selects an IP address assigned to a matching network interface. --> <interfaces> <interface name="public"> <match-interface value="eth0"/> </interface> </interfaces> </server>
JSON
{ "server": { "interfaces": [{ "name": "public", "match-interface": { "value": "eth0" } }] } }
YAML
server: interfaces: - name: "public" matchInterface: value: "eth0"
匹配地址
XML
<server xmlns="urn:infinispan:server:15.0"> <!-- Selects an IP address that matches a regular expression. --> <interfaces> <interface name="public"> <match-address value="132\..*"/> </interface> </interfaces> </server>
JSON
{ "server": { "interfaces": [{ "name": "public", "match-address": { "value": "132\\..*" } }] } }
YAML
server: interfaces: - name: "public" matchAddress: value: "127\\..*"
fallback
XML
<server xmlns="urn:infinispan:server:15.0"> <!-- Includes multiple strategies that Data Grid Server tries in the declared order until it finds a match. --> <interfaces> <interface name="public"> <match-host value="my_host_name"/> <match-address value="132\..*"/> <any-address/> </interface> </interfaces> </server>
JSON
{ "server": { "interfaces": [{ "name": "public", "match-host": { "value": "my_host_name" }, "match-address": { "value": "132\\..*" }, "any_address": null }] } }
YAML
server: interfaces: - name: "public" matchHost: value: "my_host_name" matchAddress: value: "132\\..*" anyAddress: ~
2.2. 套接字绑定
套接字绑定将端点连接器映射到网络接口和端口。默认情况下,Data Grid 服务器包含一个套接字绑定配置,它监听 localhost 接口 127.0.0.1
,在 REST 和 Hot Rod 端点的端口 11222
上侦听。如果启用 Memcached 端点,则默认套接字绑定将 Data Grid Server 配置为绑定到端口 11221
。
默认的套接字绑定
<server xmlns="urn:infinispan:server:15.0"> <socket-bindings default-interface="public" port-offset="${infinispan.socket.binding.port-offset:0}"> <socket-binding name="default" port="${infinispan.bind.port:11222}"/> <socket-binding name="memcached" port="11221"/> </socket-bindings> </server>
配置元素或属性 | 描述 |
---|---|
| 包含所有网络接口和端口的 root 元素,Data Grid 服务器端点可以绑定和侦听客户端连接。 |
| 声明 Data Grid 服务器默认侦听的网络接口。 |
| 指定 Data Grid 服务器应用到套接字绑定的端口声明的偏移。 |
| 将 Data Grid 服务器配置为绑定到网络接口上的端口。 |
自定义套接字绑定声明
以下示例配置添加了名为"private" 的接口
声明和一个 socket-binding
声明,该声明将 Data Grid 服务器绑定到私有 IP 地址:
XML
<server xmlns="urn:infinispan:server:15.0"> <interfaces> <interface name="public"> <inet-address value="${infinispan.bind.address:127.0.0.1}"/> </interface> <interface name="private"> <inet-address value="10.1.2.3"/> </interface> </interfaces> <socket-bindings default-interface="public" port-offset="${infinispan.socket.binding.port-offset:0}"> <socket-binding name="private_binding" interface="private" port="49152"/> </socket-bindings> <endpoints socket-binding="private_binding" security-realm="default"/> </server>
JSON
{ "server": { "interfaces": [{ "name": "private", "inet-address": { "value": "10.1.2.3" } }, { "name": "public", "inet-address": { "value": "127.0.0.1" } }], "socket-bindings": { "port-offset": "0", "default-interface": "public", "socket-binding": [{ "name": "private_binding", "port": "1234", "interface": "private" }] }, "endpoints": { "endpoint": { "socket-binding": "private_binding", "security-realm": "default" } } } }
YAML
server: interfaces: - name: "private" inetAddress: value: "10.1.2.3" - name: "public" inetAddress: value: "127.0.0.1" socketBindings: portOffset: "0" defaultInterface: "public" socketBinding: - name: "private_binding" port: "49152" interface: "private" endpoints: endpoint: socketBinding: "private_binding" securityRealm: "default"
2.3. 更改 Data Grid 服务器的绑定地址
Data Grid 服务器绑定到网络 IP 地址,以侦听 Hot Rod 和 REST 端点上的入站客户端连接。您可以在 Data Grid 服务器配置或启动服务器实例时指定该 IP 地址。
先决条件
- 至少有一个 Data Grid 服务器安装。
流程
使用以下方法之一指定 Data Grid 服务器绑定的 IP 地址:
打开 Data Grid Server 配置并设置
inet-address
元素的值,例如:<server xmlns="urn:infinispan:server:15.0"> <interfaces> <interface name="custom"> <inet-address value="${infinispan.bind.address:192.0.2.0}"/> </interface> </interfaces> </server>
使用
-b
选项或infinispan.bind.address
系统属性。Linux
bin/server.sh -b 192.0.2.0
Windows
bin\server.bat -b 192.0.2.0
2.3.1. 侦听所有地址
如果您将 0.0.0.0
元地址或 INADDR_ANY
指定,作为 Data Grid Server 配置中的绑定地址,它会在所有可用网络接口上侦听传入的客户端连接。
客户端智能
将 Data Grid 配置为侦听所有地址会影响它如何通过集群拓扑提供 Hot Rod 客户端。如果 Data Grid 服务器绑定有多个接口,它会为每个接口发送 IP 地址列表。
例如,每个服务器节点绑定到的集群:
-
10.0.0.0/8
子网 -
192.168.0.0/16
子网 -
127.0.0.1
loopback
热 Rod 客户端接收属于客户端连接接口的服务器节点的 IP 地址。例如,如果客户端连接到 192.168.0.0
,则不会接收任何侦听 10.0.0.0
的节点的集群拓扑详细信息。
子网掩码覆盖
Kubernetes 和一些环境,将 IP 地址空间划分为子网,并将这些不同的子网用作单个网络。例如,10.129.2.100/23
和 10.129.4.100/23
位于不同的子网中,但属于 10.0.0.0/8
网络。
因此,Data Grid 服务器会覆盖主机系统提供的子网掩码,该子网掩码为私有和保留网络遵循 IANA 约定:
-
IPv4:
10.0.0.0/8
,100.64.0.0/10
, 192.168.0.0/16',172.16.0.0/12
,169.254.0.0/16
和240.0.0.0/4
-
IPv6:
fc00::/7
和fe80::/10
请参阅 RFC 1112
,RFC 1918
,RFC 3927
,RFC 6598
for IPv4 或 RFC 4193
,RFC 3513
for IPv6。
您可以选择将 Hot Rod 连接器配置为使用主机系统为带有 network-prefix-override
属性的接口提供的子网掩码。
2.4. Data Grid 服务器端口和协议
Data Grid 服务器提供网络端点,允许客户端访问不同的协议。
端口 | 协议 | 描述 |
---|---|---|
| TCP | 热 Rod 和 REST |
| TCP | Memcached (默认禁用) |
单个端口
Data Grid 服务器通过单个 TCP 端口 11222
公开多个协议。使用单一端口处理多个协议可简化配置并降低部署 Data Grid 集群时的管理复杂性。使用单个端口还通过最大程度减少网络上的攻击面来增强安全性。
Data Grid 服务器以不同的方式通过单一端口处理来自客户端的 HTTP/1.1、HTTP/2 和 Hot Rod 协议请求。
HTTP/1.1 升级标头
客户端请求可以包含 HTTP/1.1 升级
标头字段,用来与 Data Grid Server 启动 HTTP/1.1 连接。然后,客户端应用程序可以发送 Upgrade: protocol
标头字段,其中 protocol
是服务器端点。
应用程序层协议协商(ALPN)/传输层安全(TLS)
客户端请求包括 Data Grid Server 端点的 Server Name Indication (SNI)映射,以便通过 TLS 连接协商协议。
自动 Hot Rod 检测
包括 Hot Rod 标头的客户端请求会自动路由到 Hot Rod 端点。
2.4.1. 为 Data Grid 流量配置网络防火墙
调整防火墙规则,以允许 Data Grid 服务器和客户端应用程序之间的流量。
流程
例如,在 Red Hat Enterprise Linux (RHEL)工作站中,您可以使用 firewalld 来允许到端口 11222
的流量,如下所示:
# firewall-cmd --add-port=11222/tcp --permanent success # firewall-cmd --list-ports | grep 11222 11222/tcp
要配置在网络上应用的防火墙规则,您可以使用 nftables 工具。
2.5. 指定端口偏移
在同一主机上为多个 Data Grid 服务器实例配置端口偏移。默认端口偏移是 0。
流程
将 -o
交换机与 Data Grid CLI 或 infinispan.socket.binding.port-offset
系统属性一起使用,以设置端口偏移。
例如,启动一个服务器实例,其偏移为 100
,如下所示:使用默认配置,这会导致在侦听端口 11322
的 Data Grid 服务器。
- Linux
bin/server.sh -o 100
- Windows
bin\server.bat -o 100
第 3 章 Data Grid 服务器端点
Data Grid 服务器端点提供对 Hot Rod 和 REST 协议的缓存管理器的客户端访问。
3.1. Data Grid 服务器端点
3.1.1. 热 Rod
热 Rod 是一种二进制 TCP 客户端-服务器协议,旨在提供更快的数据访问,并比基于文本的协议提高性能。
Data Grid 提供 Java、C++、C#、Node.js 和其他编程语言的 Hot Rod 客户端库。
拓扑缓存
Data Grid 使用拓扑缓存为客户端提供集群视图。拓扑缓存包含将内部 JGroups 传输地址映射到公开 Hot Rod 端点的条目。
当客户端发送请求时,Data Grid 服务器将请求标头中的拓扑 ID 与缓存中的拓扑 ID 进行比较。如果客户端有旧的拓扑 ID,Data Grid 服务器会发送新的拓扑视图。
集群拓扑视图允许 Hot Rod 客户端立即检测节点加入和离开的时间,从而启用动态负载平衡和故障转移。
在分布式缓存模式中,一致的哈希算法也使 Hot Rod 客户端请求直接路由到主要所有者。
3.1.2. REST
Data Grid 会公开一个 RESTful 接口,允许 HTTP 客户端访问数据、监控和维护集群,以及执行管理操作。
您可以使用标准 HTTP 负载均衡器为客户端提供负载均衡和故障转移功能。但是,HTTP 负载均衡器会维护静态集群视图,并在集群拓扑更改时需要手动更新。
3.1.3. RESP
Data Grid 提供 RESP3 协议的实施。
RESP 连接器支持 Redis 命令的子集。
3.1.4. Memcached
Data Grid 为远程客户端访问提供 Memcached 文本和二进制协议的实现。
Data Grid Memcached 端点支持使用复制和分布式缓存模式的集群。
有些 Memcached 客户端实现(如 Cache::Memcached Perl 客户端)可以使用集群拓扑更改时需要手动的 Data Grid 服务器地址列表提供负载均衡和故障转移检测功能。
3.1.5. 端点协议的比较
热 Rod | HTTP / REST | Memcached | RESP | |
---|---|---|---|---|
topology-aware | Y | N | N | N |
hash-aware | Y | N | N | N |
Encryption | Y | Y | Y | Y |
身份验证 | Y | Y | Y | Y |
条件 ops | Y | Y | Y | N |
批量操作 | Y | N | Y | Y |
Transactions | Y | N | N | N |
监听器 | Y | N | N | Y |
查询 | Y | Y | N | N |
执行 | Y | N | N | N |
跨站点故障切换 | Y | N | N | N |
3.1.6. 热 Rod 客户端与 Data Grid 服务器的兼容性
借助数据网格服务器,您可以将 Hot Rod 客户端与不同的版本连接。例如,在迁移或升级到 Data Grid 集群期间,Hot Rod 客户端版本可能是比 Data Grid Server 低的 Data Grid 版本。
Data Grid 建议使用最新的 Hot Rod 客户端版本从最新的功能和安全增强中受益。
Data Grid 8 及更新的版本
热 Rod 协议版本 3.x 会自动协商使用 Data Grid Server 的客户端可能的最高版本。
Data Grid 7.3 及更早版本
使用比 Data Grid 服务器版本高的 Hot Rod 协议版本的客户端必须设置 infinispan.client.hotrod.protocol_version
属性。
其他资源
- 热 Rod 协议参考
- 将 Hot Rod 客户端连接到具有不同版本的服务器 (红帽知识库)
3.2. 配置 Data Grid 服务器端点
控制不同的协议端点如何绑定到套接字,并使用安全域配置。您还可以配置多个端点并禁用管理功能。
每个唯一的端点配置必须包含 Hot Rod 连接器和 REST 连接器。Data Grid 服务器在 端点
配置中隐式包括 hotrod-connector
和 rest-connector
元素或字段。您应该只将这些元素添加到自定义配置中,以指定端点的身份验证机制。
先决条件
- 在您的 Data Grid 服务器配置中添加套接字绑定和安全域。
流程
- 打开 Data Grid Server 配置以进行编辑。
-
使用
endpoint
元素嵌套多个端点配置
。 -
指定端点用于
socket-binding
属性的套接字绑定。 -
指定端点用于
security-realm
属性的安全域。 如果需要,禁用具有
admin="false"
属性的管理员访问权限。使用这个配置,用户无法从端点访问 Data Grid 控制台或命令行界面(CLI)。
- 保存对配置的更改。
多个端点配置
以下 Data Grid 服务器配置使用专用安全域在单独的套接字绑定中创建端点:
XML
<server xmlns="urn:infinispan:server:15.0"> <endpoints> <endpoint socket-binding="public" security-realm="application-realm" admin="false"> </endpoint> <endpoint socket-binding="private" security-realm="management-realm"> </endpoint> </endpoints> </server>
JSON
{ "server": { "endpoints": [{ "socket-binding": "private", "security-realm": "private-realm" }, { "socket-binding": "public", "security-realm": "default", "admin": "false" }] } }
YAML
server: endpoints: - socketBinding: public securityRealm: application-realm admin: false - socketBinding: private securityRealm: management-realm
其他资源
3.3. 端点连接器
连接器配置 Hot Rod 和 REST 端点,以使用套接字绑定和安全域。
默认端点配置
<endpoints socket-binding="default" security-realm="default"/>
配置元素或属性 | 描述 |
---|---|
| 嵌套端点连接器配置。 |
| 声明一个 Data Grid 服务器端点,该端点将 Hot Rod 和 REST 连接器配置为使用套接字绑定和安全域。 |
|
在端点配置中包含 Hot Rod |
|
在端点配置中包含 REST |
|
在端点配置中包含 RESP |
|
在端点配置中包含 Memcached |
其他资源
3.4. 端点 IP 地址过滤规则
Data Grid 服务器端点可以使用过滤规则来控制客户端是否可以根据其 IP 地址进行连接。Data Grid 服务器按顺序应用过滤规则,直到找到客户端 IP 地址匹配为止。
CIDR 块是 IP 地址及其关联的网络掩码的紧凑表示。CIDR 表示法指定 IP 地址、斜杠('/')字符和十进制数字。十进制数是网络掩码中前 1 位的计数。编号也可以被视为网络前缀的宽度(以位表示)。CIDR 标记中的 IP 地址始终根据 IPv4 或 IPv6 的标准来表示。
该地址可以表示特定的接口地址,包括主机标识符,如 10.0.0.1/8
,也可以是整个网络接口范围的开头地址,使用主机标识符 0,如 10.0.0.0/8
或 10/8
。
例如:
-
192.168.100.14/24
代表 IPv4 地址192.168.100.14
及其关联的网络前缀192.168.100.0
,或者等同,子网掩码为255.255.255.0
,它有 24 个前 1 位。 -
IPv4 块
192.168.100.0/22
代表从192.168.100.0
到192.168.103.255
的 1024 个 IPv4 地址。 -
IPv6 块
2001:db8::/48
代表2001:db8:0:0:0:0:0:0
到2001:db8:0:ffff:ffff:ffff:ffff:ffff
。 -
::1/128
代表 IPv6 环回地址。其前缀长度为 128,地址为位数。
IP 地址过滤器配置
在以下配置中,Data Grid 服务器仅接受来自 192.168.0.0/16
和 10.0.0.0/8
CIDR 块中的地址的连接。Data Grid 服务器拒绝所有其他连接。
XML
<server xmlns="urn:infinispan:server:15.0"> <endpoints> <endpoint socket-binding="default" security-realm="default"> <ip-filter> <accept from="192.168.0.0/16"/> <accept from="10.0.0.0/8"/> <reject from="/0"/> </ip-filter> </endpoint> </endpoints> </server>
JSON
{ "server": { "endpoints": { "endpoint": { "socket-binding": "default", "security-realm": "default", "ip-filter": { "accept-from": ["192.168.0.0/16", "10.0.0.0/8"], "reject-from": "/0" } } } } }
YAML
server: endpoints: endpoint: socketBinding: "default" securityRealm: "default" ipFilter: acceptFrom: ["192.168.0.0/16","10.0.0.0/8"] rejectFrom: "/0"
3.5. 检查和修改用于过滤 IP 地址的规则
在 Data Grid 服务器端点上配置 IP 地址过滤规则,以根据客户端地址接受或拒绝连接。
先决条件
- 安装 Data Grid 命令行界面(CLI)。
流程
- 创建与 Data Grid 服务器的 CLI 连接。
根据需要,检查并修改 IP 过滤器规则
服务器连接器 ipfilter
命令。列出集群中连接器上活跃的所有 IP 过滤规则:
server connector ipfilter ls endpoint-default
在集群中设置 IP 过滤规则。
注意此命令替换任何现有规则。
server connector ipfilter set endpoint-default --rules=ACCEPT/192.168.0.0/16,REJECT/10.0.0.0/8`
删除所有集群中的连接器上的 IP 过滤规则。
server connector ipfilter clear endpoint-default
第 4 章 端点身份验证机制
Data Grid 服务器可以为 Hot Rod 和 REST 端点使用自定义 SASL 和 HTTP 身份验证机制。
4.1. Data Grid 服务器身份验证
身份验证限制用户访问端点,以及 Data Grid 控制台和命令行界面(CLI)。
Data Grid 服务器包括一个"默认"安全域,用于强制实施用户身份验证。默认身份验证使用属性 realm,其用户凭证存储在 server/conf/users.properties
文件中。Data Grid 服务器还默认启用安全授权,因此您必须为用户授予存储在 server/conf/groups.properties
文件中的权限。
通过命令行接口(CLI)使用 user create
命令来添加用户并分配权限。运行 user create --help
获取示例和更多信息。
4.2. 配置 Data Grid 服务器身份验证机制
您可以明确配置 Hot Rod 和 REST 端点,以使用特定的身份验证机制。只有在需要显式覆盖安全域的默认机制时,才需要配置验证机制。
配置中的每个 endpoint
部分都必须包含 hotrod-connector
和 rest-connector
元素或字段。例如,如果您明确声明了 hotrod-connector
,还必须声明 rest-connector
,即使它没有配置身份验证机制。
先决条件
- 根据需要,将安全域添加到您的 Data Grid 服务器配置。
流程
- 打开 Data Grid Server 配置以进行编辑。
-
添加
endpoint
元素或字段,并指定它与security-realm
属性一起使用的安全域。 添加
hotrod-connector
元素或字段来配置 Hot Rod 端点。-
添加
authentication
元素或字段。 -
为 Hot Rod 端点指定 SASL 身份验证机制,以用于
sasl 机制
属性。 -
如果适用,使用
qop
属性指定保护设置的 SASL 质量。 -
如有必要,使用
server-name
属性指定 Data Grid 服务器身份。
-
添加
添加
rest-connector
元素或字段来配置 REST 端点。-
添加
authentication
元素或字段。 -
为 REST 端点指定用于 mechanism 属性的 HTTP
身份验证机制
。
-
添加
- 保存对配置的更改。
身份验证机制配置
以下配置指定了用于身份验证的 Hot Rod 端点的 SASL 机制:
XML
<server xmlns="urn:infinispan:server:15.0"> <endpoints> <endpoint socket-binding="default" security-realm="my-realm"> <hotrod-connector> <authentication> <sasl mechanisms="SCRAM-SHA-512 SCRAM-SHA-384 SCRAM-SHA-256 SCRAM-SHA-1 DIGEST-SHA-512 DIGEST-SHA-384 DIGEST-SHA-256 DIGEST-SHA DIGEST-MD5 PLAIN" server-name="infinispan" qop="auth"/> </authentication> </hotrod-connector> <rest-connector> <authentication mechanisms="DIGEST BASIC"/> </rest-connector> </endpoint> </endpoints> </server>
JSON
{ "server": { "endpoints": { "endpoint": { "socket-binding": "default", "security-realm": "my-realm", "hotrod-connector": { "authentication": { "security-realm": "default", "sasl": { "server-name": "infinispan", "mechanisms": ["SCRAM-SHA-512", "SCRAM-SHA-384", "SCRAM-SHA-256", "SCRAM-SHA-1", "DIGEST-SHA-512", "DIGEST-SHA-384", "DIGEST-SHA-256", "DIGEST-SHA", "DIGEST-MD5", "PLAIN"], "qop": ["auth"] } } }, "rest-connector": { "authentication": { "mechanisms": ["DIGEST", "BASIC"], "security-realm": "default" } } } } } }
YAML
server: endpoints: endpoint: socketBinding: "default" securityRealm: "my-realm" hotrodConnector: authentication: securityRealm: "default" sasl: serverName: "infinispan" mechanisms: - "SCRAM-SHA-512" - "SCRAM-SHA-384" - "SCRAM-SHA-256" - "SCRAM-SHA-1" - "DIGEST-SHA-512" - "DIGEST-SHA-384" - "DIGEST-SHA-256" - "DIGEST-SHA" - "DIGEST-MD5" - "PLAIN" qop: - "auth" restConnector: authentication: mechanisms: - "DIGEST" - "BASIC" securityRealm: "default"
4.2.1. 禁用身份验证
在本地开发环境或隔离网络中,您可以将 Data Grid 配置为允许未经身份验证的客户端请求。当您禁用用户身份验证时,您还应在 Data Grid 安全配置中禁用授权。
流程
- 打开 Data Grid Server 配置以进行编辑。
-
从 endpoint 元素或字段中删除
security-realm
属性。 -
从
cache-container
的安全配置和每个缓存配置中删除任何授权
元素。 - 保存对配置的更改。
XML
<server xmlns="urn:infinispan:server:15.0"> <endpoints socket-binding="default"/> </server>
JSON
{ "server": { "endpoints": { "endpoint": { "socket-binding": "default" } } } }
YAML
server: endpoints: endpoint: socketBinding: "default"
4.3. Data Grid 服务器身份验证机制
Data Grid 服务器使用与您的安全域配置匹配的验证机制自动配置端点。例如,如果您添加 Kerberos 安全域,则 Data Grid 服务器为 Hot Rod 端点启用 GSSAPI
和 GS2-KRB5
身份验证机制。
目前,您不能将轻量级目录访问协议(LDAP)协议与 DIGEST
或 SCRAM
身份验证机制一起使用,因为这些机制需要访问特定的散列密码。
热 Rod 端点
当您的配置包含对应的安全域时,Data Grid 服务器为 Hot Rod 端点启用以下 SASL 身份验证机制:
安全域 | SASL 身份验证机制 |
---|---|
属性域和 LDAP 域 |
|
令牌域 |
|
信任域 |
|
Kerberos 身份 |
|
SSL/TLS 身份 |
|
REST 端点
当您的配置包含对应的安全域时,Data Grid 服务器为 REST 端点启用以下 HTTP 身份验证机制:
安全域 | HTTP 身份验证机制 |
---|---|
属性域和 LDAP 域 |
|
令牌域 |
|
信任域 |
|
Kerberos 身份 |
|
SSL/TLS 身份 |
|
memcached 端点
当您的配置包含对应的安全域时,Data Grid 服务器为 Memcached 二进制协议端点启用以下 SASL 身份验证机制:
安全域 | SASL 身份验证机制 |
---|---|
属性域和 LDAP 域 |
|
令牌域 |
|
信任域 |
|
Kerberos 身份 |
|
SSL/TLS 身份 |
|
Data Grid 服务器仅在 Memcached 文本协议端点上启用身份验证,只有支持基于密码的身份验证的安全域:
安全域 | Memcached 文本身份验证 |
---|---|
属性域和 LDAP 域 | 是 |
令牌域 | 否 |
信任域 | 否 |
Kerberos 身份 | 否 |
SSL/TLS 身份 | 否 |
RESP 端点
Data Grid 服务器仅在支持基于密码的身份验证的安全域中启用 RESP 端点身份验证:
安全域 | RESP 身份验证 |
---|---|
属性域和 LDAP 域 | 是 |
令牌域 | 否 |
信任域 | 否 |
Kerberos 身份 | 否 |
SSL/TLS 身份 | 否 |
4.3.1. SASL 身份验证机制
Data Grid 服务器支持使用 Hot Rod 和 Memcached 二进制协议端点的以下 SASL 验证机制:
身份验证机制 | 描述 | 安全域类型 | 相关详情 |
---|---|---|---|
|
以纯文本格式使用凭据。您应该只在加密连接中使用 | 属性域和 LDAP 域 |
与 |
|
使用哈希算法和非ce 值。热 Rod 连接器支持 | 属性域和 LDAP 域 |
与 |
|
除了哈希算法和非ce 值外,还使用 salt 值。热 Rod 连接器支持 | 属性域和 LDAP 域 |
与 |
|
使用 Kerberos 票据并需要一个 Kerberos 域控制器。您必须在 realm 配置中添加对应的 | Kerberos realm |
与 |
|
使用 Kerberos 票据并需要一个 Kerberos 域控制器。您必须在 realm 配置中添加对应的 | Kerberos realm |
与 |
| 使用客户端证书。 | 信任存储域 |
与 |
|
使用 OAuth 令牌并需要一个 | 令牌域 |
与EARER |
4.3.2. SASL 质量保护(QoP)
如果 SASL 机制支持完整性和隐私保护(QoP)设置,您可以使用 qop
属性将它们添加到 Hot Rod 和 Memcached 端点配置中。
QoP 设置 | 描述 |
---|---|
| 仅进行身份验证。 |
| 使用完整性保护进行身份验证。 |
| 通过完整性和隐私保护进行身份验证。 |
4.3.3. SASL 策略
SASL 策略提供对 Hot Rod 和 Memcached 身份验证机制的精细控制。
Data Grid 缓存授权根据角色和权限限制对缓存的访问。配置缓存授权,然后设置 < ;no-anonymous value=false /&
gt; 以允许匿名登录,并将访问逻辑委派给缓存授权。
policy | 描述 | 默认值 |
---|---|---|
| 仅使用支持会话间转发保密的 SASL 机制。这意味着,破坏一个会话不会自动提供破坏未来会话的信息。 | false |
| 仅使用需要客户端凭证的 SASL 机制。 | false |
| 不要使用容易受到简单普通被动攻击的 SASL 机制。 | false |
| 不要使用容易被活跃、非字典攻击的 SASL 机制。 | false |
| 不要使用容易受到被动字典攻击的 SASL 机制。 | false |
| 不要使用接受匿名登录的 SASL 机制。 | true |
SASL 策略配置
在以下配置中,Hot Rod 端点使用 GSSAPI
机制进行身份验证,因为它是唯一符合所有 SASL 策略的机制:
XML
<server xmlns="urn:infinispan:server:15.0"> <endpoints> <endpoint socket-binding="default" security-realm="default"> <hotrod-connector> <authentication> <sasl mechanisms="PLAIN DIGEST-MD5 GSSAPI EXTERNAL" server-name="infinispan" qop="auth" policy="no-active no-plain-text"/> </authentication> </hotrod-connector> <rest-connector/> </endpoint> </endpoints> </server>
JSON
{ "server": { "endpoints" : { "endpoint" : { "socket-binding" : "default", "security-realm" : "default", "hotrod-connector" : { "authentication" : { "sasl" : { "server-name" : "infinispan", "mechanisms" : [ "PLAIN","DIGEST-MD5","GSSAPI","EXTERNAL" ], "qop" : [ "auth" ], "policy" : [ "no-active","no-plain-text" ] } } }, "rest-connector" : "" } } } }
YAML
server: endpoints: endpoint: socketBinding: "default" securityRealm: "default" hotrodConnector: authentication: sasl: serverName: "infinispan" mechanisms: - "PLAIN" - "DIGEST-MD5" - "GSSAPI" - "EXTERNAL" qop: - "auth" policy: - "no-active" - "no-plain-text" restConnector: ~
4.3.4. HTTP 身份验证机制
Data Grid 服务器支持带有 REST 端点的以下 HTTP 身份验证机制:
身份验证机制 | 描述 | 安全域类型 | 相关详情 |
---|---|---|---|
|
以纯文本格式使用凭据。您应该只使用带有加密连接的 | 属性域和 LDAP 域 |
对应于 |
|
使用哈希算法和非ce 值。REST 连接器支持 | 属性域和 LDAP 域 |
对应于 |
|
使用 Kerberos 票据并需要一个 Kerberos 域控制器。您必须在 realm 配置中添加对应的 | Kerberos realm |
对应于 |
|
使用 OAuth 令牌并需要一个 | 令牌域 |
对应于 |
| 使用客户端证书。 | 信任存储域 |
与 |
第 5 章 安全域
安全域将 Data Grid 服务器部署与您的环境中的网络协议和基础架构集成,以控制用户身份并验证用户身份。
5.1. 创建安全域
向 Data Grid 服务器配置添加安全域,以控制对部署的访问。您可以在配置中添加一个或多个安全域。
当您向配置添加安全域时,Data Grid 服务器会自动为 Hot Rod 和 REST 端点启用匹配的身份验证机制。
先决条件
- 根据需要,为您的 Data Grid 服务器配置添加套接字绑定。
创建密钥存储或具有 PEM 文件,以使用 TLS/SSL 加密配置安全域。
网格服务器也可以在启动时生成密钥存储。
-
置备安全域配置依赖的资源或服务。
例如,如果您添加令牌域,则需要置备 OAuth 服务。
此流程演示了如何配置多个属性域。开始之前,您需要创建属性文件,以使用命令行界面(CLI)添加用户并分配权限。使用 user create
命令,如下所示:
user create <username> -p <changeme> -g <role> \ --users-file=application-users.properties \ --groups-file=application-groups.properties user create <username> -p <changeme> -g <role> \ --users-file=management-users.properties \ --groups-file=management-groups.properties
运行 user create --help
获取示例和更多信息。
使用 CLI 向属性域添加凭证只会在您连接的服务器实例上创建用户。您必须在属性域中手动将凭证同步到集群中的每个节点。
流程
- 打开 Data Grid Server 配置以进行编辑。
-
使用安全配置中的
security
-realms 添加一个带有
security-realm
元素的安全域,并为它赋予name
属性的唯一名称。要遵循示例,请创建一个名为
application-realm
的安全域,另一个名为management-realm
。-
为 Data Grid 服务器提供 TLS/SSL 识别,并提供
server-identities
元素,并根据需要配置密钥存储。 通过添加以下元素或字段来指定安全域的类型:
-
properties-realm
-
ldap-realm
-
token-realm
-
truststore-realm
-
指定您根据需要配置的安全域类型的属性。
要遵循示例,请使用
user-
和properties
group-properties
元素或字段上的path
属性指定您使用 CLI 创建的 dcproperties 文件。-
如果您在配置中添加多种不同类型的安全域,请包含
distributed-realm
元素或字段,以便 Data Grid 服务器使用域并相互组合。 -
配置 Data Grid 服务器端点,以使用带有
security-realm
属性的安全域。 - 保存对配置的更改。
多个属性域
XML
<server xmlns="urn:infinispan:server:15.0"> <security> <security-realms> <security-realm name="application-realm"> <properties-realm groups-attribute="Roles"> <user-properties path="application-users.properties"/> <group-properties path="application-groups.properties"/> </properties-realm> </security-realm> <security-realm name="management-realm"> <properties-realm groups-attribute="Roles"> <user-properties path="management-users.properties"/> <group-properties path="management-groups.properties"/> </properties-realm> </security-realm> </security-realms> </security> </server>
JSON
{ "server": { "security": { "security-realms": [{ "name": "management-realm", "properties-realm": { "groups-attribute": "Roles", "user-properties": { "digest-realm-name": "management-realm", "path": "management-users.properties" }, "group-properties": { "path": "management-groups.properties" } } }, { "name": "application-realm", "properties-realm": { "groups-attribute": "Roles", "user-properties": { "digest-realm-name": "application-realm", "path": "application-users.properties" }, "group-properties": { "path": "application-groups.properties" } } }] } } }
YAML
server: security: securityRealms: - name: "management-realm" propertiesRealm: groupsAttribute: "Roles" userProperties: digestRealmName: "management-realm" path: "management-users.properties" groupProperties: path: "management-groups.properties" - name: "application-realm" propertiesRealm: groupsAttribute: "Roles" userProperties: digestRealmName: "application-realm" path: "application-users.properties" groupProperties: path: "application-groups.properties"
5.2. 设置 Kerberos 身份
在 Data Grid Server 配置中为安全域添加 Kerberos 身份,以使用包含服务主体名称和加密密钥的 keytab 文件,从 Kerberos 密码衍生。
先决条件
- 有 Kerberos 服务帐户主体。
keytab 文件可以包含用户和服务帐户主体。但是,Data Grid 服务器只使用服务帐户主体,这意味着它可以向客户端提供身份,并允许客户端与 Kerberos 服务器进行身份验证。
在大多数情况下,您可以为 Hot Rod 和 REST 端点创建唯一的主体。例如,如果您在 "INFINISPAN.ORG" 域中有一个"datagrid"服务器,您应该创建以下服务主体:
-
HotRod/datagrid@INFINISPAN.ORG
标识 Hot Rod 服务。 -
http/datagrid@INFINISPAN.ORG
标识 REST 服务。
流程
为 Hot Rod 和 REST 服务创建 keytab 文件。
- Linux
ktutil ktutil: addent -password -p datagrid@INFINISPAN.ORG -k 1 -e aes256-cts Password for datagrid@INFINISPAN.ORG: [enter your password] ktutil: wkt http.keytab ktutil: quit
- Microsoft Windows
ktpass -princ HTTP/datagrid@INFINISPAN.ORG -pass * -mapuser INFINISPAN\USER_NAME ktab -k http.keytab -a HTTP/datagrid@INFINISPAN.ORG
-
将 keytab 文件复制到 Data Grid Server 安装的
server/conf
目录中。 - 打开 Data Grid Server 配置以进行编辑。
-
在 Data Grid 服务器安全域中添加
server-identities
定义。 - 指定为 Hot Rod 和 REST 连接器提供服务主体的 keytab 文件的位置。
- 将 Kerberos 服务主体命名为。
- 保存对配置的更改。
Kerberos 身份配置
XML
<server xmlns="urn:infinispan:server:15.0"> <security> <security-realms> <security-realm name="kerberos-realm"> <server-identities> <!-- Specifies a keytab file that provides a Kerberos identity. --> <!-- Names the Kerberos service principal for the Hot Rod endpoint. --> <!-- The required="true" attribute specifies that the keytab file must be present when the server starts. --> <kerberos keytab-path="hotrod.keytab" principal="hotrod/datagrid@INFINISPAN.ORG" required="true"/> <!-- Specifies a keytab file and names the Kerberos service principal for the REST endpoint. --> <kerberos keytab-path="http.keytab" principal="HTTP/localhost@INFINISPAN.ORG" required="true"/> </server-identities> </security-realm> </security-realms> </security> <endpoints> <endpoint socket-binding="default" security-realm="kerberos-realm"> <hotrod-connector> <authentication> <sasl server-name="datagrid" server-principal="hotrod/datagrid@INFINISPAN.ORG"/> </authentication> </hotrod-connector> <rest-connector> <authentication server-principal="HTTP/localhost@INFINISPAN.ORG"/> </rest-connector> </endpoint> </endpoints> </server>
JSON
{ "server": { "security": { "security-realms": [{ "name": "kerberos-realm", "server-identities": [{ "kerberos": { "principal": "hotrod/datagrid@INFINISPAN.ORG", "keytab-path": "hotrod.keytab", "required": true }, "kerberos": { "principal": "HTTP/localhost@INFINISPAN.ORG", "keytab-path": "http.keytab", "required": true } }] }] }, "endpoints": { "endpoint": { "socket-binding": "default", "security-realm": "kerberos-realm", "hotrod-connector": { "authentication": { "security-realm": "kerberos-realm", "sasl": { "server-name": "datagrid", "server-principal": "hotrod/datagrid@INFINISPAN.ORG" } } }, "rest-connector": { "authentication": { "server-principal": "HTTP/localhost@INFINISPAN.ORG" } } } } } }
YAML
server: security: securityRealms: - name: "kerberos-realm" serverIdentities: - kerberos: principal: "hotrod/datagrid@INFINISPAN.ORG" keytabPath: "hotrod.keytab" required: "true" - kerberos: principal: "HTTP/localhost@INFINISPAN.ORG" keytabPath: "http.keytab" required: "true" endpoints: endpoint: socketBinding: "default" securityRealm: "kerberos-realm" hotrodConnector: authentication: sasl: serverName: "datagrid" serverPrincipal: "hotrod/datagrid@INFINISPAN.ORG" restConnector: authentication: securityRealm: "kerberos-realm" serverPrincipal" : "HTTP/localhost@INFINISPAN.ORG"
5.3. 属性域
属性域使用属性文件来定义用户和组。
-
users.properties
包含 Data Grid 用户凭证。可以使用DIGEST-MD5
和DIGEST
身份验证机制预先摘要密码。 -
groups.properties
将用户与角色和权限相关联。
users.properties
myuser=a_password user2=another_password
groups.properties
myuser=supervisor,reader,writer user2=supervisor
属性域配置
XML
<server xmlns="urn:infinispan:server:15.0"> <security> <security-realms> <security-realm name="default"> <!-- groups-attribute configures the "groups.properties" file to contain security authorization roles. --> <properties-realm groups-attribute="Roles"> <user-properties path="users.properties" relative-to="infinispan.server.config.path" plain-text="true"/> <group-properties path="groups.properties" relative-to="infinispan.server.config.path"/> </properties-realm> </security-realm> </security-realms> </security> </server>
JSON
{ "server": { "security": { "security-realms": [{ "name": "default", "properties-realm": { "groups-attribute": "Roles", "user-properties": { "digest-realm-name": "default", "path": "users.properties", "relative-to": "infinispan.server.config.path", "plain-text": true }, "group-properties": { "path": "groups.properties", "relative-to": "infinispan.server.config.path" } } }] } } }
YAML
server: security: securityRealms: - name: "default" propertiesRealm: # groupsAttribute configures the "groups.properties" file # to contain security authorization roles. groupsAttribute: "Roles" userProperties: digestRealmName: "default" path: "users.properties" relative-to: 'infinispan.server.config.path' plainText: "true" groupProperties: path: "groups.properties" relative-to: 'infinispan.server.config.path'
5.3.1. 属性 realm 文件结构
用户属性文件的结构如下:
users.properties 结构
#$REALM_NAME=default$ #$ALGORITHM=encrypted$ #Wed Jul 31 08:32:08 CEST 2024 admin=algorithm-1\:hash-1;algorithm-2\:hash-2;...
前三行是特殊的注释,用于定义域的名称($REALM_NAME
)、密码是否 以明文
格式存储($ALGORITHM
),以及最近更新的时间戳。
用户凭据以传统键/值格式存储:键对应于用户名,值则对应于密码。加密的密码以分号分隔的算法/哈希对形式表示,使用以 Base64 编码的哈希来表示。
凭据使用域名加密。更改 realm 的名称需要重新加密所有密码。使用 Data Grid CLI 为文件输入正确的安全域名称。
5.4. LDAP 域
LDAP 域连接到 LDAP 服务器,如 OpenLDAP、红帽目录服务器、Apache 目录服务器或 Microsoft Active Directory,以验证用户并获取成员资格信息。
根据服务器和部署的类型,LDAP 服务器可以有不同的条目布局。本文档超出了本文档的范围,为所有可能的配置提供示例。
5.4.1. LDAP 连接属性
指定 LDAP 域配置中的 LDAP 连接属性。
需要以下属性:
url |
指定 LDAP 服务器的 URL。URL 的格式应为 |
主体 | 在 LDAp 服务器中指定有效用户的可分辨名称(DN)。DN 在 LDAP 目录结构中唯一标识用户。 |
credential | 对应于与上述主体关联的密码。 |
LDAP 连接的主体必须具有必要的特权,才能执行 LDAP 查询和访问特定属性。
启用 连接池可显著提高
LDAP 服务器身份验证的性能。连接池机制由 JDK 提供。如需更多信息,请参阅 连接池配置和 Java Tutorials:池。
5.4.2. LDAP 域用户验证方法
在 LDAP 域中配置用户验证方法。
LDAP 域可以通过两种方式验证用户:
散列化密码比较 |
通过比较存储在用户密码属性中的散列密码(通常为 |
直接验证 | 使用提供的凭证对 LDAP 服务器进行身份验证
直接验证是与 Active Directory 搭配使用的唯一方法,因为禁止访问 |
您不能使用通过 direct-verification
属性执行哈希的端点身份验证机制,因为此方法需要以明文形式提供密码。因此,您必须将 BASIC
身份验证机制与 REST 端点一起使用,并将 PLAIN
与 Hot Rod 端点一起使用,才能与 Active Directory Server 集成。更安全的替代方案是使用 Kerberos,它允许 SPNEGO
、GSSAPI
和 GS2-KRB5
身份验证机制。
LDAP 域搜索目录以查找与经过身份验证的用户对应的条目。rdn-identifier
属性指定一个 LDAP 属性,它根据提供的标识符查找用户条目,通常是用户名;例如,uid
或 sAMAccountName
属性。向配置中添加 search-recursive="true"
以递归搜索目录。默认情况下,搜索用户条目使用 (rdn_identifier={0})
过滤器。您可以使用 filter-name
属性指定不同的过滤器。
5.4.3. 将用户条目映射到其关联的组
在 LDAP 域配置中,指定 attribute-mapping
元素以检索和关联用户所属的所有组。
成员资格信息通常以两种方式存储:
-
在组条目下,通常具有
member
属性中的 classgroupOfNames
或groupOfUniqueNames
。这是除 Active Directory 以外的大多数 LDAP 安装中的默认行为。在这种情况下,您可以使用属性过滤器。此过滤器搜索与提供的过滤器匹配的条目,该条目会找到与用户 DN 相等的member
属性的组。然后,过滤器提取
由 指定的组条目的 CN,并将其添加到用户的Role
中。 在
memberOf
属性的用户条目中。这通常是 Active Directory 的情况。在这种情况下,您应该使用如下属性引用:<attribute-reference reference="memberOf" from="cn" to="Roles" />
此引用从用户条目获取所有
memberOf
属性,按照从 指定的方式
提取 CN,并将它们添加到用户的组中(角色是
用于映射组的内部名称)。
5.4.4. LDAP 域配置参考
XML
<server xmlns="urn:infinispan:server:15.0"> <security> <security-realms> <security-realm name="ldap-realm"> <!-- Specifies connection properties. --> <ldap-realm url="ldap://my-ldap-server:10389" principal="uid=admin,ou=People,dc=infinispan,dc=org" credential="strongPassword" connection-timeout="3000" read-timeout="30000" connection-pooling="true" referral-mode="ignore" page-size="30" direct-verification="true"> <!-- Defines how principals are mapped to LDAP entries. --> <identity-mapping rdn-identifier="uid" search-dn="ou=People,dc=infinispan,dc=org" search-recursive="false"> <!-- Retrieves all the groups of which the user is a member. --> <attribute-mapping> <attribute from="cn" to="Roles" filter="(&(objectClass=groupOfNames)(member={1}))" filter-dn="ou=Roles,dc=infinispan,dc=org"/> </attribute-mapping> </identity-mapping> </ldap-realm> </security-realm> </security-realms> </security> </server>
JSON
{ "server": { "security": { "security-realms": [{ "name": "ldap-realm", "ldap-realm": { "url": "ldap://my-ldap-server:10389", "principal": "uid=admin,ou=People,dc=infinispan,dc=org", "credential": "strongPassword", "connection-timeout": "3000", "read-timeout": "30000", "connection-pooling": "true", "referral-mode": "ignore", "page-size": "30", "direct-verification": "true", "identity-mapping": { "rdn-identifier": "uid", "search-dn": "ou=People,dc=infinispan,dc=org", "search-recursive": "false", "attribute-mapping": [{ "from": "cn", "to": "Roles", "filter": "(&(objectClass=groupOfNames)(member={1}))", "filter-dn": "ou=Roles,dc=infinispan,dc=org" }] } } }] } } }
YAML
server: security: securityRealms: - name: ldap-realm ldapRealm: url: 'ldap://my-ldap-server:10389' principal: 'uid=admin,ou=People,dc=infinispan,dc=org' credential: strongPassword connectionTimeout: '3000' readTimeout: '30000' connectionPooling: true referralMode: ignore pageSize: '30' directVerification: true identityMapping: rdnIdentifier: uid searchDn: 'ou=People,dc=infinispan,dc=org' searchRecursive: false attributeMapping: - filter: '(&(objectClass=groupOfNames)(member={1}))' filterDn: 'ou=Roles,dc=infinispan,dc=org' from: cn to: Roles
5.4.4.1. LDAP 域主体重写
SASL 身份验证机制获取的主体,如 GSSAPI
、GS2-KRB5
和 Negotiate
通常包括域名,例如 myuser@INFINISPAN.ORG
。在 LDAP 查询中使用这些主体前,需要转换它们以确保其兼容性。这个过程被称为重写。
网格包括以下转换器:
case-principal-transformer |
将主体重写为所有大写或所有小写。例如, |
common-name-principal-transformer |
以 LDAP Distinguished Name 格式重写主体(由 RFC 4514定义)。它提取 |
regex-principal-transformer | 使用带有捕获组的正则表达式重写主体,例如,用于提取任何子字符串。 |
5.4.4.2. LDAP 主体重写配置参考
问题单主体转换器
XML
<server xmlns="urn:infinispan:server:15.0"> <security> <security-realms> <security-realm name="ldap-realm"> <ldap-realm url="ldap://${org.infinispan.test.host.address}:10389" principal="uid=admin,ou=People,dc=infinispan,dc=org" credential="strongPassword"> <name-rewriter> <!-- Defines a rewriter that transforms usernames to lowercase --> <case-principal-transformer uppercase="false"/> </name-rewriter> <!-- further configuration omitted --> </ldap-realm> </security-realm> </security-realms> </security> </server>
JSON
{ "server": { "security": { "security-realms": [{ "name": "ldap-realm", "ldap-realm": { "principal": "uid=admin,ou=People,dc=infinispan,dc=org", "url": "ldap://${org.infinispan.test.host.address}:10389", "credential": "strongPassword", "name-rewriter": { "case-principal-transformer": { "uppercase": false } } } }] } } }
YAML
server: security: securityRealms: - name: "ldap-realm" ldapRealm: principal: "uid=admin,ou=People,dc=infinispan,dc=org" url: "ldap://${org.infinispan.test.host.address}:10389" credential: "strongPassword" nameRewriter: casePrincipalTransformer: uppercase: false # further configuration omitted
通用名称主体转换器
XML
<server xmlns="urn:infinispan:server:15.0"> <security> <security-realms> <security-realm name="ldap-realm"> <ldap-realm url="ldap://${org.infinispan.test.host.address}:10389" principal="uid=admin,ou=People,dc=infinispan,dc=org" credential="strongPassword"> <name-rewriter> <!-- Defines a rewriter that obtains the first CN from a DN --> <common-name-principal-transformer /> </name-rewriter> <!-- further configuration omitted --> </ldap-realm> </security-realm> </security-realms> </security> </server>
JSON
{ "server": { "security": { "security-realms": [{ "name": "ldap-realm", "ldap-realm": { "principal": "uid=admin,ou=People,dc=infinispan,dc=org", "url": "ldap://${org.infinispan.test.host.address}:10389", "credential": "strongPassword", "name-rewriter": { "common-name-principal-transformer": {} } } }] } } }
YAML
server: security: securityRealms: - name: "ldap-realm" ldapRealm: principal: "uid=admin,ou=People,dc=infinispan,dc=org" url: "ldap://${org.infinispan.test.host.address}:10389" credential: "strongPassword" nameRewriter: commonNamePrincipalTransformer: ~ # further configuration omitted
正则表达式主体转换器
XML
<server xmlns="urn:infinispan:server:15.0"> <security> <security-realms> <security-realm name="ldap-realm"> <ldap-realm url="ldap://${org.infinispan.test.host.address}:10389" principal="uid=admin,ou=People,dc=infinispan,dc=org" credential="strongPassword"> <name-rewriter> <!-- Defines a rewriter that extracts the username from the principal using a regular expression. --> <regex-principal-transformer pattern="(.*)@INFINISPAN\.ORG" replacement="$1"/> </name-rewriter> <!-- further configuration omitted --> </ldap-realm> </security-realm> </security-realms> </security> </server>
JSON
{ "server": { "security": { "security-realms": [{ "name": "ldap-realm", "ldap-realm": { "principal": "uid=admin,ou=People,dc=infinispan,dc=org", "url": "ldap://${org.infinispan.test.host.address}:10389", "credential": "strongPassword", "name-rewriter": { "regex-principal-transformer": { "pattern": "(.*)@INFINISPAN\\.ORG", "replacement": "$1" } } } }] } } }
YAML
server: security: securityRealms: - name: "ldap-realm" ldapRealm: principal: "uid=admin,ou=People,dc=infinispan,dc=org" url: "ldap://${org.infinispan.test.host.address}:10389" credential: "strongPassword" nameRewriter: regexPrincipalTransformer: pattern: (.*)@INFINISPAN\.ORG replacement: "$1" # further configuration omitted
5.4.4.3. 使用 Data Grid 的 LDAP 用户和组映射过程
本例演示了加载和内部将 LDAP 用户和组映射到 Data Grid 主题的过程。以下是 LDIF (LDAP 数据交换格式)文件,它描述了多个 LDAP 条目:
LDIF
# Users dn: uid=root,ou=People,dc=infinispan,dc=org objectclass: top objectclass: uidObject objectclass: person uid: root cn: root sn: root userPassword: strongPassword # Groups dn: cn=admin,ou=Roles,dc=infinispan,dc=org objectClass: top objectClass: groupOfNames cn: admin description: the Infinispan admin group member: uid=root,ou=People,dc=infinispan,dc=org dn: cn=monitor,ou=Roles,dc=infinispan,dc=org objectClass: top objectClass: groupOfNames cn: monitor description: the Infinispan monitor group member: uid=root,ou=People,dc=infinispan,dc=org
root
用户是 admin
和 monitor
组的成员。
当使用密码 strongPassword
验证用户 root
的请求时,会在其中一个端点上执行以下操作:
- 使用所选主体转换器(可选)重写用户名。
-
realm 在
ou=People,dc=infinispan,dc=org
树中搜索,其uid
属性等于root
,并查找 DNuid=root,ou=People,dc=infinispan,dc=org
的条目,这将成为用户主体。 -
realm 在
u=Roles,dc=infinispan,dc=org
树中搜索包含member
属性中的uid=root,ou=People,dc=infinispan,dc=org
的条目。在这种情况下,它找到两个条目:
cn=admin,ou=Roles,dc=infinispan,dc=org
和cn=monitor,ou=Roles,dc=infinispan,dc=org
。从这些条目中,它会提取作为组主体的cn
属性。
因此,生成的主题将类似如下:
-
NamePrincipal:
uid=root,ou=People,dc=infinispan,dc=org
-
RolePrincipal:
admin
-
RolePrincipal:
monitor
此时,全局授权映射程序应用于上述主题,将主体转换为角色。然后,角色会扩展到一组权限,这些权限会根据请求的缓存和操作进行验证。
5.5. 令牌域
令牌域使用外部服务来验证令牌,并且需要与 RFC-7662 (OAuth2 Token Introspection)兼容的提供程序,如 Red Hat SSO。
令牌域配置
XML
<server xmlns="urn:infinispan:server:15.0"> <security> <security-realms> <security-realm name="token-realm"> <!-- Specifies the URL of the authentication server. --> <token-realm name="token" auth-server-url="https://oauth-server/auth/"> <!-- Specifies the URL of the token introspection endpoint. --> <oauth2-introspection introspection-url="https://oauth-server/auth/realms/infinispan/protocol/openid-connect/token/introspect" client-id="infinispan-server" client-secret="1fdca4ec-c416-47e0-867a-3d471af7050f"/> </token-realm> </security-realm> </security-realms> </security> </server>
JSON
{ "server": { "security": { "security-realms": [{ "name": "token-realm", "token-realm": { "auth-server-url": "https://oauth-server/auth/", "oauth2-introspection": { "client-id": "infinispan-server", "client-secret": "1fdca4ec-c416-47e0-867a-3d471af7050f", "introspection-url": "https://oauth-server/auth/realms/infinispan/protocol/openid-connect/token/introspect" } } }] } } }
YAML
server: security: securityRealms: - name: token-realm tokenRealm: authServerUrl: 'https://oauth-server/auth/' oauth2Introspection: clientId: infinispan-server clientSecret: '1fdca4ec-c416-47e0-867a-3d471af7050f' introspectionUrl: 'https://oauth-server/auth/realms/infinispan/protocol/openid-connect/token/introspect'
5.6. 信任存储域
信任存储域使用证书或证书链,在 Data Grid 服务器和客户端身份协商连接时验证 Data Grid 服务器和客户端身份。
- keystores
- 包含为客户端提供 Data Grid 服务器身份的服务器证书。如果您使用服务器证书配置密钥存储,Data Grid 服务器使用行业标准 SSL/TLS 协议加密流量。
- 信任存储
- 包含客户端到 Data Grid 服务器的证书或证书链。客户端信任存储是可选的,并允许 Data Grid 服务器执行客户端证书身份验证。
客户端证书身份验证
如果您希望 Data Grid 服务器验证或验证客户端证书,您必须将 require-ssl-client-auth="true"
属性添加到端点配置。
信任存储域配置
XML
<server xmlns="urn:infinispan:server:15.0"> <security> <security-realms> <security-realm name="trust-store-realm"> <server-identities> <ssl> <!-- Provides an SSL/TLS identity with a keystore that contains server certificates. --> <keystore path="server.p12" relative-to="infinispan.server.config.path" keystore-password="secret" alias="server"/> <!-- Configures a trust store that contains client certificates or part of a certificate chain. --> <truststore path="trust.p12" relative-to="infinispan.server.config.path" password="secret"/> </ssl> </server-identities> <!-- Authenticates client certificates against the trust store. If you configure this, the trust store must contain the public certificates for all clients. --> <truststore-realm/> </security-realm> </security-realms> </security> </server>
JSON
{ "server": { "security": { "security-realms": [{ "name": "trust-store-realm", "server-identities": { "ssl": { "keystore": { "path": "server.p12", "relative-to": "infinispan.server.config.path", "keystore-password": "secret", "alias": "server" }, "truststore": { "path": "trust.p12", "relative-to": "infinispan.server.config.path", "password": "secret" } } }, "truststore-realm": {} }] } } }
YAML
server: security: securityRealms: - name: "trust-store-realm" serverIdentities: ssl: keystore: path: "server.p12" relative-to: "infinispan.server.config.path" keystore-password: "secret" alias: "server" truststore: path: "trust.p12" relative-to: "infinispan.server.config.path" password: "secret" truststoreRealm: ~
5.7. 分布式安全域
分布式域组合多种不同类型的安全域。当用户尝试访问 Hot Rod 或 REST 端点时,Data Grid 服务器依次使用每个安全域,直到找到可以执行身份验证的用户为止。
分布式域配置
XML
<server xmlns="urn:infinispan:server:15.0"> <security> <security-realms> <security-realm name="distributed-realm"> <ldap-realm url="ldap://my-ldap-server:10389" principal="uid=admin,ou=People,dc=infinispan,dc=org" credential="strongPassword"> <identity-mapping rdn-identifier="uid" search-dn="ou=People,dc=infinispan,dc=org" search-recursive="false"> <attribute-mapping> <attribute from="cn" to="Roles" filter="(&(objectClass=groupOfNames)(member={1}))" filter-dn="ou=Roles,dc=infinispan,dc=org"/> </attribute-mapping> </identity-mapping> </ldap-realm> <properties-realm groups-attribute="Roles"> <user-properties path="users.properties" relative-to="infinispan.server.config.path"/> <group-properties path="groups.properties" relative-to="infinispan.server.config.path"/> </properties-realm> <distributed-realm/> </security-realm> </security-realms> </security> </server>
JSON
{ "server": { "security": { "security-realms": [{ "name": "distributed-realm", "ldap-realm": { "principal": "uid=admin,ou=People,dc=infinispan,dc=org", "url": "ldap://my-ldap-server:10389", "credential": "strongPassword", "identity-mapping": { "rdn-identifier": "uid", "search-dn": "ou=People,dc=infinispan,dc=org", "search-recursive": false, "attribute-mapping": { "attribute": { "filter": "(&(objectClass=groupOfNames)(member={1}))", "filter-dn": "ou=Roles,dc=infinispan,dc=org", "from": "cn", "to": "Roles" } } } }, "properties-realm": { "groups-attribute": "Roles", "user-properties": { "digest-realm-name": "distributed-realm", "path": "users.properties" }, "group-properties": { "path": "groups.properties" } }, "distributed-realm": {} }] } } }
YAML
server: security: securityRealms: - name: "distributed-realm" ldapRealm: principal: "uid=admin,ou=People,dc=infinispan,dc=org" url: "ldap://my-ldap-server:10389" credential: "strongPassword" identityMapping: rdnIdentifier: "uid" searchDn: "ou=People,dc=infinispan,dc=org" searchRecursive: "false" attributeMapping: attribute: filter: "(&(objectClass=groupOfNames)(member={1}))" filterDn: "ou=Roles,dc=infinispan,dc=org" from: "cn" to: "Roles" propertiesRealm: groupsAttribute: "Roles" userProperties: digestRealmName: "distributed-realm" path: "users.properties" groupProperties: path: "groups.properties" distributedRealm: ~
5.8. 聚合安全域
聚合域组合多个域:用于身份验证步骤的第一个域,另一个用于加载授权步骤的身份。例如,这可用于通过客户端证书验证用户身份,并从属性或 LDAP 域检索身份。
聚合域配置
XML
<server xmlns="urn:infinispan:server:15.0"> <security> <security-realms> <security-realm name="default" default-realm="aggregate"> <server-identities> <ssl> <keystore path="server.pfx" password="secret" alias="server"/> <truststore path="trust.pfx" password="secret"/> </ssl> </server-identities> <properties-realm name="properties" groups-attribute="Roles"> <user-properties path="users.properties" relative-to="infinispan.server.config.path"/> <group-properties path="groups.properties" relative-to="infinispan.server.config.path"/> </properties-realm> <truststore-realm name="trust"/> <aggregate-realm authentication-realm="trust" authorization-realms="properties"> <name-rewriter> <common-name-principal-transformer/> </name-rewriter> </aggregate-realm> </security-realm> </security-realms> </security> </server>
JSON
{ "server": { "security": { "security-realms": [ { "name": "aggregate-realm", "default-realm": "aggregate", "server-identities": { "ssl": { "keystore": { "path": "server.p12", "relative-to": "infinispan.server.config.path", "keystore-password": "secret", "alias": "server" }, "truststore": { "path": "trust.p12", "relative-to": "infinispan.server.config.path", "password": "secret" } } }, "properties-realm": { "name": "properties", "groups-attribute": "Roles", "user-properties": { "digest-realm-name": "distributed-realm", "path": "users.properties" }, "group-properties": { "path": "groups.properties" } }, "truststore-realm": { "name": "trust" }, "aggregate-realm": { "authentication-realm": "trust", "authorization-realms": ["properties"], "name-rewriter": { "common-name-principal-transformer": {} } } } ] } } }
YAML
server: security: securityRealms: - name: "aggregate-realm" defaultRealm: "aggregate" serverIdentities: ssl: keystore: path: "server.p12" relative-to: "infinispan.server.config.path" keystore-password: "secret" alias: "server" truststore: path: "trust.p12" relative-to: "infinispan.server.config.path" password: "secret" truststoreRealm: name: "trust" propertiesRealm: name: "properties" groupsAttribute: "Roles" userProperties: digestRealmName: "distributed-realm" path: "users.properties" groupProperties: path: "groups.properties" aggregateRealm: authenticationRealm: "trust" authorizationRealms: - "properties" nameRewriter: common-name-principal-transformer: ~
5.8.1. name rewriters
主体名称可能具有不同的表单,具体取决于安全域类型:
- 属性和令牌域可能会返回简单字符串
- 信任和 LDAP 域可能会返回 X.500 风格的可分辨名称
-
Kerberos 域可以返回
user@domain
风格名称
在使用聚合域时使用以下转换器之一时,名称必须规范化为通用形式。
5.8.1.1. case Principal Transformer
case-principal-transformer
将名称转换为所有大写字母或所有小写字母。
XML
<aggregate-realm authentication-realm="trust" authorization-realms="properties"> <name-rewriter> <case-principal-transformer uppercase="false"/> </name-rewriter> </aggregate-realm>
JSON
{ "aggregate-realm": { "authentication-realm": "trust", "authorization-realms": [ "properties" ], "name-rewriter": { "case-principal-transformer": { "uppercase": "false" } } } }
YAML
aggregateRealm: authenticationRealm: "trust" authorizationRealms: - "properties" nameRewriter: casePrincipalTransformer: uppercase: false
5.8.1.2. 通用名称 Principal Transformer
common-name-principal-transformer
从 LDAP 或证书使用的 DN
中提取第一个 CN
元素。例如,假设一个主体,格式为 CN=app1,CN=serviceA,OU=applications,DC=infinispan,DC=org
,以下配置将提取 app1
作为主体。
XML
<aggregate-realm authentication-realm="trust" authorization-realms="properties"> <name-rewriter> <common-name-principal-transformer/> </name-rewriter> </aggregate-realm>
JSON
{ "aggregate-realm": { "authentication-realm": "trust", "authorization-realms": [ "properties" ], "name-rewriter": { "common-name-principal-transformer": {} } } }
YAML
aggregateRealm: authenticationRealm: "trust" authorizationRealms: - "properties" nameRewriter: commonNamePrincipalTransformer: ~
5.8.1.3. regex Principal Transformer
regex-principal-transformer
可以使用正则表达式执行 find 和 replace。这个示例演示了如何从 user@domain.com
标识符中提取本地部分。
XML
<aggregate-realm authentication-realm="trust" authorization-realms="properties"> <name-rewriter> <regex-principal-transformer pattern="([^@]+)@.*" replacement="$1" replace-all="false"/> </name-rewriter> </aggregate-realm>
JSON
{ "aggregate-realm": { "authentication-realm": "trust", "authorization-realms": [ "properties" ], "name-rewriter": { "regex-principal-transformer": { "pattern" : "([^@]+)@.*", "replacement": "$1", "replace-all": false } } } }
YAML
aggregateRealm: authenticationRealm: "trust" authorizationRealms: - "properties" nameRewriter: regexPrincipalTransformer: pattern: "([^@]+)@.*" replacement: "$1" replaceAll: false
5.9. 安全域缓存
安全域实施缓存,以避免重复检索通常更改的数据。默认
realm 缓存域配置
XML
<server xmlns="urn:infinispan:server:15.0"> <security> <security-realms> <security-realm name="default" cache-max-size="1024" cache-lifespan="120000"> </security-realm> </security-realms> </security> </server>
JSON
{ "server": { "security": { "security-realms": [{ "name": "default", "cache-max-size": 1024, "cache-lifespan": 120000 }] } } }
YAML
server: security: securityRealms: - name: "default" cache-max-size: 1024 cache-lifespan: 120000
5.9.1. 清空域缓存
使用 CLI 刷新整个集群中的安全域缓存。
[node-1@mycluster//containers/default]> server aclcache flush
第 6 章 配置 TLS/SSL 加密
您可以通过配置包含 Data Grid 公钥的密钥存储来保护使用 SSL/TLS 加密的数据网格服务器连接。如果需要 mutual TLS,您还可以配置客户端证书身份验证。
6.1. 配置 Data Grid 服务器密钥存储
将密钥存储添加到 Data Grid 服务器,并将它配置为提供验证客户端身份的 SSL/TLS 证书。如果安全域包含 TLS/SSL 身份,它会加密到使用该安全域的 Data Grid 服务器端点的任何连接。
先决条件
- 为 Data Grid 服务器创建一个包含证书或证书链的密钥存储。
Data Grid 服务器支持以下密钥存储格式:JKS、JCEKS、PKCS12/PFX 和 PEM。如果存在 Bouncy Castle 库,则也支持 BKS、BCFKS 和 UBER。
证书应包含类型为 dNSName
和/或 iPAddress
的 subjectAltName
扩展,以便客户端可以根据 RFC 2818 规格定义的规则正确执行主机名验证。如果使用不包括此类扩展的证书启动,服务器将发出警告。
在生产环境中,服务器证书应由受信任的证书颁发机构( Root 或 Intermediate CA)签名。
如果以下两者都包含,您可以使用 PEM 文件作为密钥存储:
- PKCS1/ 或 PKCS""8 格式的私钥。
- 一个或多个证书。
您还应该使用空密码配置 PEM 文件密钥存储(password=""
)。
流程
- 打开 Data Grid Server 配置以进行编辑。
-
将包含 Data Grid 服务器的 SSL/TLS 身份的密钥存储添加到
$RHDG_HOME/server/conf
目录中。 -
在 Data Grid Server 安全域中添加
server-identities
定义。 -
使用
path
属性指定密钥存储文件名。 -
使用
keystore-password
和alias
属性提供密钥存储密码和证书别名。 - 保存对配置的更改。
后续步骤
使用信任存储配置客户端,以便它们能够验证 Data Grid 服务器的 SSL/TLS 身份。
密钥存储配置
XML
<server xmlns="urn:infinispan:server:15.0"> <security> <security-realms> <security-realm name="default"> <server-identities> <ssl> <!-- Adds a keystore that contains server certificates that provide SSL/TLS identities to clients. --> <keystore path="server.p12" relative-to="infinispan.server.config.path" password="secret" alias="my-server"/> </ssl> </server-identities> </security-realm> </security-realms> </security> </server>
JSON
{ "server": { "security": { "security-realms": [{ "name": "default", "server-identities": { "ssl": { "keystore": { "alias": "my-server", "path": "server.p12", "password": "secret" } } } }] } } }
YAML
server: security: securityRealms: - name: "default" serverIdentities: ssl: keystore: alias: "my-server" path: "server.p12" password: "secret"
6.1.1. SSL/TLS 证书轮转
SSL/TLS 证书具有过期日期,之后它们已不再有效。续订证书的过程也称为"轮转"。网格监控密钥存储文件是否有变化,并在不需要服务器或客户端重启的情况下自动重新载入它们。
要在证书轮转过程中确保无缝操作,请使用由证书颁发机构(CA)签名的证书,并使用 CA 证书配置服务器和客户端信任存储。使用自签名证书将导致临时握手失败,直到所有客户端和服务器都已更新。
其他资源
6.1.2. 生成 Data Grid 服务器密钥存储
配置 Data Grid 服务器,以在启动时自动生成密钥存储。
自动生成的密钥存储:
- 不应该在生产环境中使用。
- 在需要时会生成 ;例如,从客户端获取第一个连接时。
- 包含您可以在 Hot Rod 客户端中直接使用的证书。
流程
- 打开 Data Grid Server 配置以进行编辑。
-
在服务器配置中包含
keystore
元素的generate-self-signed-certificate-host
属性。 - 指定服务器证书的主机名作为值。
- 保存对配置的更改。
生成的密钥存储配置
XML
<server xmlns="urn:infinispan:server:15.0"> <security> <security-realms> <security-realm name="generated-keystore"> <server-identities> <ssl> <!-- Generates a keystore that includes a self-signed certificate with the specified hostname. --> <keystore path="server.p12" relative-to="infinispan.server.config.path" password="secret" alias="server" generate-self-signed-certificate-host="localhost"/> </ssl> </server-identities> </security-realm> </security-realms> </security> </server>
JSON
{ "server": { "security": { "security-realms": [{ "name": "generated-keystore", "server-identities": { "ssl": { "keystore": { "alias": "server", "generate-self-signed-certificate-host": "localhost", "path": "server.p12", "password": "secret" } } } }] } } }
YAML
server: security: securityRealms: - name: "generated-keystore" serverIdentities: ssl: keystore: alias: "server" generateSelfSignedCertificateHost: "localhost" path: "server.p12" password: "secret"
6.1.3. 配置 TLS 版本和密码套件
当使用 SSL/TLS 加密来保护部署时,您可以将 Data Grid 服务器配置为使用 TLS 协议的特定版本以及协议中的特定加密套件。
流程
- 打开 Data Grid Server 配置以进行编辑。
-
将
engine
元素添加到 Data Grid 服务器的 SSL 配置中。 将 Data Grid 配置为使用带有
enabled-protocols
属性的一个或多个 TLS 版本。默认情况下,Data Grid 服务器支持 TLS 版本 1.2 和 1.3。如果适当,您可以设置
TLSv1.3
仅来限制客户端连接的安全协议。网格不推荐启用TLSv1.1
,因为它是支持有限且提供弱安全性的旧协议。您不应该启用任何早于 1.1 的 TLS 版本。警告如果您修改了 Data Grid 服务器的 SSL
引擎
配置,则必须使用enabled-protocols
属性显式配置 TLS 版本。省略enabled-protocols
属性允许任何 TLS 版本。<engine enabled-protocols="TLSv1.3 TLSv1.2" />
将 Data Grid 配置为使用带有
enabled-ciphersuites
属性(TLSv1.2 和 below)和enabled-ciphersuites-tls13
属性(用于 TLSv1.3)的一个或多个密码套件。您必须确保设置了支持您计划使用的任何协议功能的密码套件;例如
HTTP/2 ALPN
。- 保存对配置的更改。
SSL 引擎配置
XML
<server xmlns="urn:infinispan:server:15.0"> <security> <security-realms> <security-realm name="default"> <server-identities> <ssl> <keystore path="server.p12" relative-to="infinispan.server.config.path" password="secret" alias="server"/> <!-- Configures Data Grid Server to use specific TLS versions and cipher suites. --> <engine enabled-protocols="TLSv1.3 TLSv1.2" enabled-ciphersuites="TLS_DHE_RSA_WITH_AES_128_CBC_SHA,TLS_DHE_RSA_WITH_AES_128_CBC_SHA256" enabled-ciphersuites-tls13="TLS_AES_256_GCM_SHA384:TLS_CHACHA20_POLY1305_SHA256:TLS_AES_128_GCM_SHA256"/> </ssl> </server-identities> </security-realm> </security-realms> </security> </server>
JSON
{ "server": { "security": { "security-realms": [{ "name": "default", "server-identities": { "ssl": { "keystore": { "alias": "server", "path": "server.p12", "password": "secret" }, "engine": { "enabled-protocols": ["TLSv1.3"], "enabled-ciphersuites": "TLS_DHE_RSA_WITH_AES_128_CBC_SHA,TLS_DHE_RSA_WITH_AES_128_CBC_SHA256", "enabled-ciphersuites-tls13": "TLS_AES_256_GCM_SHA384:TLS_CHACHA20_POLY1305_SHA256:TLS_AES_128_GCM_SHA256" } } } }] } } }
YAML
server: security: securityRealms: - name: "default" serverIdentities: ssl: keystore: alias: "server" path: "server.p12" password: "secret" engine: enabledProtocols: - "TLSv1.3" enabledCiphersuites: "TLS_AES_256_GCM_SHA384,TLS_AES_128_GCM_SHA256" enabledCiphersuitesTls13: "TLS_AES_256_GCM_SHA384"
6.2. 在具有 FIPS 140-2 兼容加密的系统中配置 Data Grid 服务器
FIPS (Federal Information Processing Standards)是美国联邦计算机系统的标准和准则。虽然 FIPS 由美国联邦政府开发,但许多在私有部门的自愿使用这些标准。
FIPS 140-2 定义加密模块的安全要求。您可以使用替代 JDK 安全供应商,将 Data Grid 服务器配置为使用遵循 FIPS 140-2 规格的加密密码。
6.2.1. 配置 PKCS11 加密供应商
您可以使用 SunPKCS11-NSS-FIPS
供应商指定 PKCS11 密钥存储来配置 PKCS11 加密供应商。
先决条件
-
为 FIPS 模式配置您的系统。您可以通过在 Data Grid 命令行界面(CLI)中发出
fips-mode-setup --check
命令检查您的系统是否启用了 FIPS 模式。 -
使用
certutil
工具初始化系统范围 NSS 数据库。 -
使用配置为启用
SunPKCS11
提供程序的java.security
文件安装 JDK。这个供应商指向 NSS 数据库和 SSL 供应商。 - 在 NSS 数据库中安装证书。
流程
- 打开 Data Grid Server 配置以进行编辑。
-
在 Data Grid Server 安全域中添加
server-identities
定义。 -
使用
SunPKCS11-NSS-FIPS
供应商指定 PKCS11 密钥存储。 - 保存对配置的更改。
密钥存储配置
XML
<server xmlns="urn:infinispan:server:15.0"> <security> <security-realms> <security-realm name="default"> <server-identities> <ssl> <!-- Adds a keystore that reads certificates from the NSS database. --> <keystore provider="SunPKCS11-NSS-FIPS" type="PKCS11"/> </ssl> </server-identities> </security-realm> </security-realms> </security> </server>
JSON
{ "server": { "security": { "security-realms": [{ "name": "default", "server-identities": { "ssl": { "keystore": { "provider": "SunPKCS11-NSS-FIPS", "type": "PKCS11" } } } }] } } }
YAML
server: security: securityRealms: - name: "default" serverIdentities: ssl: keystore: provider: "SunPKCS11-NSS-FIPS" type: "PKCS11"
6.2.2. 配置 Bouncy Castle FIPS 加密供应商
您可以在 Data Grid 服务器的配置中配置 Bouncy Castle FIPS (Federal Information Processing Standards)加密供应商。
先决条件
-
为 FIPS 模式配置您的系统。您可以通过在 Data Grid 命令行界面(CLI)中发出
fips-mode-setup --check
命令检查您的系统是否启用了 FIPS 模式。 - 以 BCFKS 格式创建包含证书的密钥存储。
流程
-
下载 Bouncy Castle FIPS JAR 文件,并将该文件添加到 Data Grid Server 安装的
server/lib
目录中。 要安装 Bouncy Castle,请发出
install
命令:[disconnected]> install org.bouncycastle:bc-fips:1.0.2.3
- 打开 Data Grid Server 配置以进行编辑。
-
在 Data Grid Server 安全域中添加
server-identities
定义。 -
使用
BCFIPS
提供程序指定 BCFKS 密钥存储。 - 保存对配置的更改。
密钥存储配置
XML
<server xmlns="urn:infinispan:server:15.0"> <security> <security-realms> <security-realm name="default"> <server-identities> <ssl> <!-- Adds a keystore that reads certificates from the BCFKS keystore. --> <keystore path="server.bcfks" password="secret" alias="server" provider="BCFIPS" type="BCFKS"/> </ssl> </server-identities> </security-realm> </security-realms> </security> </server>
JSON
{ "server": { "security": { "security-realms": [{ "name": "default", "server-identities": { "ssl": { "keystore": { "path": "server.bcfks", "password": "secret", "alias": "server", "provider": "BCFIPS", "type": "BCFKS" } } } }] } } }
YAML
server: security: securityRealms: - name: "default" serverIdentities: ssl: keystore: path: "server.bcfks" password: "secret" alias: "server" provider: "BCFIPS" type: "BCFKS"
6.3. 配置客户端证书身份验证
将 Data Grid 服务器配置为使用 mutual TLS 来保护客户端连接。
您可以通过两种方式将 Data Grid 配置为以两种方式从信任存储中验证证书的客户端身份:
- 需要仅包含签名证书的信任存储,通常是证书颁发机构(CA)。任何提供 CA 签名的证书的客户端都可以连接到 Data Grid。
- 除了签名证书外,还需要包含所有客户端证书的信任存储。只有提供信任存储中存在的签名证书的客户端才能连接到 Data Grid。
另外,您还可以提供信任存储,您可以使用共享系统证书。
先决条件
- 创建包含 CA 证书或所有公共证书的客户端信任存储。
- 为 Data Grid 服务器创建一个密钥存储,并配置 SSL/TLS 身份。
PEM 文件可以用作信任存储,只要它们包含一个或多个证书。这些信任存储应该配置空密码: password=""
。
流程
- 打开 Data Grid Server 配置以进行编辑。
-
将
require-ssl-client-auth="true"
参数添加到您的端点
配置中。 -
将客户端信任存储添加到
$RHDG_HOME/server/conf
目录中。 -
在 Data Grid Server 安全域配置中,指定
truststore
元素的路径
和密码
属性。 -
如果您希望 Data Grid 服务器验证每个客户端证书,请将 <
truststore-realm
/> 元素添加到安全域中。 - 保存对配置的更改。
后续步骤
- 如果使用安全角色和权限控制访问权限,请在 Data Grid 服务器配置中设置授权。
- 将客户端配置为与 Data Grid 服务器协商 SSL/TLS 连接。
客户端证书身份验证配置
XML
<server xmlns="urn:infinispan:server:15.0"> <security> <security-realms> <security-realm name="trust-store-realm"> <server-identities> <ssl> <!-- Provides an SSL/TLS identity with a keystore that contains server certificates. --> <keystore path="server.p12" relative-to="infinispan.server.config.path" keystore-password="secret" alias="server"/> <!-- Configures a trust store that contains client certificates or part of a certificate chain. --> <truststore path="trust.p12" relative-to="infinispan.server.config.path" password="secret"/> </ssl> </server-identities> <!-- Authenticates client certificates against the trust store. If you configure this, the trust store must contain the public certificates for all clients. --> <truststore-realm/> </security-realm> </security-realms> </security> <endpoints> <endpoint socket-binding="default" security-realm="trust-store-realm" require-ssl-client-auth="true"> <hotrod-connector> <authentication> <sasl mechanisms="EXTERNAL" server-name="infinispan" qop="auth"/> </authentication> </hotrod-connector> <rest-connector> <authentication mechanisms="CLIENT_CERT"/> </rest-connector> </endpoint> </endpoints> </server>
JSON
{ "server": { "security": { "security-realms": [{ "name": "trust-store-realm", "server-identities": { "ssl": { "keystore": { "path": "server.p12", "relative-to": "infinispan.server.config.path", "keystore-password": "secret", "alias": "server" }, "truststore": { "path": "trust.p12", "relative-to": "infinispan.server.config.path", "password": "secret" } } }, "truststore-realm": {} }] }, "endpoints": [{ "socket-binding": "default", "security-realm": "trust-store-realm", "require-ssl-client-auth": "true", "connectors": { "hotrod": { "hotrod-connector": { "authentication": { "sasl": { "mechanisms": "EXTERNAL", "server-name": "infinispan", "qop": "auth" } } }, "rest": { "rest-connector": { "authentication": { "mechanisms": "CLIENT_CERT" } } } } } }] } }
YAML
server: security: securityRealms: - name: "trust-store-realm" serverIdentities: ssl: keystore: path: "server.p12" relative-to: "infinispan.server.config.path" keystore-password: "secret" alias: "server" truststore: path: "trust.p12" relative-to: "infinispan.server.config.path" password: "secret" truststoreRealm: ~ endpoints: socketBinding: "default" securityRealm: "trust-store-realm" requireSslClientAuth: "true" connectors: - hotrod: hotrodConnector: authentication: sasl: mechanisms: "EXTERNAL" serverName: "infinispan" qop: "auth" - rest: restConnector: authentication: mechanisms: "CLIENT_CERT"
其他资源
- 配置 Hot Rod 客户端加密
- 使用共享系统证书 (Red Hat Enterprise Linux 7 安全指南)
6.4. 使用客户端证书配置授权
启用客户端证书身份验证意味着您不需要在客户端配置中指定 Data Grid 用户凭证,这意味着您必须将角色与客户端证书中的通用名称(CN)字段关联。
先决条件
- 为客户端提供包含其公共证书的 Java 密钥存储或证书链的一部分,通常是公共 CA 证书。
- 配置 Data Grid 服务器,以执行客户端证书身份验证。
流程
- 打开 Data Grid Server 配置以进行编辑。
-
在安全授权配置中启用
common-name-role-mapper
。 -
从客户端证书分配具有适当权限的角色的通用名称(
CN
)。 - 保存对配置的更改。
Data Grid 通过提取证书主体来创建客户端的身份。当前会忽略证书中存在的任何其他主题备用名称(SAN)。因此,以下 authorization.group-only-mapping
属性必须设置为 false
。
客户端证书授权配置
XML
<infinispan> <cache-container name="certificate-authentication" statistics="true"> <security> <authorization group-only-mapping="false"> <!-- Declare a role mapper that associates the common name (CN) field in client certificate trust stores with authorization roles. --> <common-name-role-mapper/> <!-- In this example, if a client certificate contains `CN=Client1` then clients with matching certificates get ALL permissions. --> <role name="Client1" permissions="ALL"/> </authorization> </security> </cache-container> </infinispan>
JSON
{ "infinispan": { "cache-container": { "name": "certificate-authentication", "security": { "authorization": { "group-only-mapping": false, "common-name-role-mapper": null, "roles": { "Client1": { "role": { "permissions": "ALL" } } } } } } } }
YAML
infinispan: cacheContainer: name: "certificate-authentication" security: authorization: groupOnlyMapping: false commonNameRoleMapper: ~ roles: Client1: role: permissions: - "ALL"
第 7 章 在密钥存储中存储 Data Grid 服务器凭证
外部服务需要凭证才能使用 Data Grid 服务器进行身份验证。为了保护敏感文本字符串,如密码,请将它们添加到凭据密钥存储中,而不是直接在 Data Grid 服务器配置文件中。
然后,您可以将 Data Grid 服务器配置为解密密码,以与数据库或 LDAP 目录等服务建立连接。
$RHDG_HOME/server/conf
中的纯文本密码是未加密的。任何对主机文件系统具有读取访问权限的用户帐户都可以查看纯文本密码。
虽然凭据密钥存储是受密码保护的存储密码,但对主机文件系统具有写入访问权限的任何用户帐户都可以被密钥存储本身篡改。
要完全保护 Data Grid 服务器凭证,您应该只向可以配置和运行 Data Grid Server 的用户帐户授予读写访问权限。
7.1. 设置凭据密钥存储
创建密钥存储来加密 Data Grid 服务器访问的凭据。
凭据密钥存储至少包含一个与加密密码关联的别名。创建密钥存储后,您可以在连接配置中指定别名,如数据库连接池。然后,当服务尝试身份验证时,Data Grid 服务器从密钥存储中解密该别名的密码。
您可以根据需要创建任意数量的凭证存储,其别名数量相同。
作为安全最佳实践,密钥存储应只由运行 Data Grid Server 进程的用户读取。
流程
-
在
$RHDG_HOME
中打开一个终端。 创建密钥存储,并使用
credentials
命令向其添加凭据。提示默认情况下,密钥存储是 PKCS12 类型的。运行
帮助凭据
以获取有关更改密钥存储默认值的详细信息。以下示例演示了如何创建密钥存储,其中包含密码"changeme"的别名"dbpassword"。在创建密钥存储时,您也指定使用
-p
参数访问密钥存储的密码。- Linux
bin/cli.sh credentials add dbpassword -c changeme -p "secret1234!"
- Microsoft Windows
bin\cli.bat credentials add dbpassword -c changeme -p "secret1234!"
检查别名是否已添加到密钥存储。
bin/cli.sh credentials ls -p "secret1234!" dbpassword
- 打开 Data Grid Server 配置以进行编辑。
配置 Data Grid,以使用凭据密钥存储。
-
在安全
配置中添加credential-stores
部分。 - 指定凭据密钥存储的名称和位置。
指定使用
明文-text-credential
配置访问凭据密钥存储的密码。注意除了将凭据密钥存储的明文密码添加到 Data Grid Server 配置中,而是使用外部命令或屏蔽的密码来获得额外的安全性。
您还可以在一个凭证存储中使用密码作为另一个凭证存储的 master 密码。
-
在 Data Grid 服务器用来与外部系统(如数据源或 LDAP 服务器)连接的配置中引用凭据密钥存储。
-
添加
credentials-reference
部分。 -
使用
store
属性指定凭据密钥存储的名称。 使用
alias
属性指定密码别名。提示credential-reference
配置中的属性是可选的。-
只有在您有多个密钥存储时才需要
存储
。 -
只有密钥存储包含多个密码别名时才需要
alias
。
-
只有在您有多个密钥存储时才需要
-
添加
- 保存对配置的更改。
7.2. 保护凭据密钥存储的密码
Data Grid 服务器需要密码才能访问凭据密钥存储。您可以以明文形式将该密码添加到 Data Grid Server 配置中,或者作为添加的安全层,您可以使用外部命令作为密码,或者您可以屏蔽密码。
先决条件
- 为 Data Grid 服务器设置凭据密钥存储。
流程
执行以下操作之一:
使用
credentials mask
命令模糊密码,例如:bin/cli.sh credentials mask -i 100 -s pepper99 "secret1234!"
屏蔽的密码使用 Based Encryption (PBE),且必须在 Data Grid Server 配置中采用以下格式: <MASKED_VALUE;SALT;ITERATION>。
使用提供密码作为标准输出的外部命令。
外部命令可以是任何使用 java.lang.
Runtime"exec (java.lang.String)
的可执行文件,如 shell 脚本或二进制。
如果命令需要参数,以空格分隔的字符串列表形式提供。
7.3. 凭证密钥存储配置
您可以将凭据密钥存储添加到 Data Grid Server 配置中,并使用明文密码、屏蔽密码或提供密码的外部命令。
带有明文密码的凭证密钥存储
XML
<server xmlns="urn:infinispan:server:15.0"> <security> <credential-stores> <credential-store name="credentials" path="credentials.pfx"> <clear-text-credential clear-text="secret1234!"/> </credential-store> </credential-stores> </security> </server>
JSON
{ "server": { "security": { "credential-stores": [{ "name": "credentials", "path": "credentials.pfx", "clear-text-credential": { "clear-text": "secret1234!" } }] } } }
YAML
server: security: credentialStores: - name: credentials path: credentials.pfx clearTextCredential: clearText: "secret1234!"
带有屏蔽密码的凭证密钥存储
XML
<server xmlns="urn:infinispan:server:15.0"> <security> <credential-stores> <credential-store name="credentials" path="credentials.pfx"> <masked-credential masked="1oTMDZ5JQj6DVepJviXMnX;pepper99;100"/> </credential-store> </credential-stores> </security> </server>
JSON
{ "server": { "security": { "credential-stores": [{ "name": "credentials", "path": "credentials.pfx", "masked-credential": { "masked": "1oTMDZ5JQj6DVepJviXMnX;pepper99;100" } }] } } }
YAML
server: security: credentialStores: - name: credentials path: credentials.pfx maskedCredential: masked: "1oTMDZ5JQj6DVepJviXMnX;pepper99;100"
外部命令密码
XML
<server xmlns="urn:infinispan:server:15.0"> <security> <credential-stores> <credential-store name="credentials" path="credentials.pfx"> <command-credential command="/path/to/executable.sh arg1 arg2"/> </credential-store> </credential-stores> </security> </server>
JSON
{ "server": { "security": { "credential-stores": [{ "name": "credentials", "path": "credentials.pfx", "command-credential": { "command": "/path/to/executable.sh arg1 arg2" } }] } } }
YAML
server: security: credentialStores: - name: credentials path: credentials.pfx commandCredential: command: "/path/to/executable.sh arg1 arg2"
7.4. 凭证密钥存储引用
将凭据密钥存储添加到 Data Grid 服务器后,您可以在连接配置中引用它们。
数据源连接
XML
<server xmlns="urn:infinispan:server:15.0"> <security> <credential-stores> <credential-store name="credentials" path="credentials.pfx"> <clear-text-credential clear-text="secret1234!"/> </credential-store> </credential-stores> </security> <data-sources> <data-source name="postgres" jndi-name="jdbc/postgres"> <!-- Specifies the database username in the connection factory. --> <connection-factory driver="org.postgresql.Driver" username="dbuser" url="${org.infinispan.server.test.postgres.jdbcUrl}"> <!-- Specifies the credential keystore that contains an encrypted password and the alias for it. --> <credential-reference store="credentials" alias="dbpassword"/> </connection-factory> <connection-pool max-size="10" min-size="1" background-validation="1000" idle-removal="1" initial-size="1" leak-detection="10000"/> </data-source> </data-sources> </server>
JSON
{ "server": { "security": { "credential-stores": [{ "name": "credentials", "path": "credentials.pfx", "clear-text-credential": { "clear-text": "secret1234!" } }], "data-sources": [{ "name": "postgres", "jndi-name": "jdbc/postgres", "connection-factory": { "driver": "org.postgresql.Driver", "username": "dbuser", "url": "${org.infinispan.server.test.postgres.jdbcUrl}", "credential-reference": { "store": "credentials", "alias": "dbpassword" } } }] } } }
YAML
server: security: credentialStores: - name: credentials path: credentials.pfx clearTextCredential: clearText: "secret1234!" dataSources: - name: postgres jndiName: jdbc/postgres connectionFactory: driver: org.postgresql.Driver username: dbuser url: '${org.infinispan.server.test.postgres.jdbcUrl}' credentialReference: store: credentials alias: dbpassword
LDAP 连接
XML
<server xmlns="urn:infinispan:server:15.0"> <security> <credential-stores> <credential-store name="credentials" path="credentials.pfx"> <clear-text-credential clear-text="secret1234!"/> </credential-store> </credential-stores> <security-realms> <security-realm name="default"> <!-- Specifies the LDAP principal in the connection factory. --> <ldap-realm name="ldap" url="ldap://my-ldap-server:10389" principal="uid=admin,ou=People,dc=infinispan,dc=org"> <!-- Specifies the credential keystore that contains an encrypted password and the alias for it. --> <credential-reference store="credentials" alias="ldappassword"/> </ldap-realm> </security-realm> </security-realms> </security> </server>
JSON
{ "server": { "security": { "credential-stores": [{ "name": "credentials", "path": "credentials.pfx", "clear-text-credential": { "clear-text": "secret1234!" } }], "security-realms": [{ "name": "default", "ldap-realm": { "name": "ldap", "url": "ldap://my-ldap-server:10389", "principal": "uid=admin,ou=People,dc=infinispan,dc=org", "credential-reference": { "store": "credentials", "alias": "ldappassword" } } }] } } }
YAML
server: security: credentialStores: - name: credentials path: credentials.pfx clearTextCredential: clearText: "secret1234!" securityRealms: - name: "default" ldapRealm: name: ldap url: 'ldap://my-ldap-server:10389' principal: 'uid=admin,ou=People,dc=infinispan,dc=org' credentialReference: store: credentials alias: ldappassword
第 8 章 使用基于角色的访问控制进行安全授权
基于角色的访问控制(RBAC)功能使用不同的权限级别来限制用户与网格交互。
有关创建用户并配置特定于远程或嵌入式缓存的授权的详情,请参考:
8.1. Data Grid 用户角色和权限
Data Grid 包括多个角色,为用户提供访问缓存和数据网格资源的权限。
角色 | 权限 | 描述 |
---|---|---|
| ALL | 具有所有权限的超级用户,包括控制缓存管理器生命周期。 |
| ALL_READ、ALL_WRITE、LISTEN、EXEC、MONITOR、CREATE |
除了 |
| ALL_READ, ALL_WRITE, LISTEN, EXEC, MONITOR |
除 |
| ALL_READ, MONITOR |
除了监控权限外,还具有对 Data Grid |
| MONITOR |
可以通过 JMX 和 |
8.1.1. 权限
用户角色是具有不同访问级别的权限集。
权限 | 功能 | 描述 |
配置 |
| 定义新的缓存配置。 |
LISTEN |
| 针对缓存管理器注册监听程序。 |
生命周期 |
| 停止缓存管理器。 |
CREATE |
| 创建和删除容器资源,如缓存、计数器、模式和脚本。 |
MONITOR |
|
允许访问 JMX 统计信息和 |
ALL | - | 包括所有缓存管理器权限。 |
权限 | 功能 | 描述 |
READ |
| 从缓存检索条目。 |
写 |
放置 , | 写入、替换、删除、驱除缓存中的数据。 |
EXEC |
| 允许针对缓存执行代码。 |
LISTEN |
| 针对缓存注册监听程序。 |
BULK_READ |
| 执行批量检索操作。 |
BULK_WRITE |
| 执行批量写入操作。 |
生命周期 |
| 启动和停止缓存。 |
ADMIN |
| 允许访问底层组件和内部结构。 |
MONITOR |
|
允许访问 JMX 统计信息和 |
ALL | - | 包括所有缓存权限。 |
ALL_READ | - | 组合了 READ 和 BULK_READ 权限。 |
ALL_WRITE | - | 组合 WRITE 和 BULK_WRITE 权限。 |
8.1.2. 角色和权限映射器
Data Grid 将用户实施为主体的集合。主体代表单独的用户身份,如用户名或用户所属的组。在内部,它们使用 javax.security.auth.Subject
类实现。
要启用授权,主体必须映射到角色名称,然后扩展到一组权限。
Data Grid 包括 PrincipalRoleMapper
API,用于将安全主体与角色关联,以及用于将角色与特定权限关联的 RolePermissionMapper
API。
Data Grid 提供以下角色和权限映射程序实现:
- 集群角色映射器
- 在集群 registry 中存储角色映射的主体。
- 集群权限映射器
- 在集群 registry 中存储权限映射的角色。允许您动态修改用户角色和权限。
- 身份角色映射器
- 使用主体名称作为角色名称。主体名称的类型或格式取决于源。例如,在 LDAP 目录中,主体名称可以是可辨识名称(DN)。
- 通用名称角色映射器
-
使用 Common Name (CN)作为角色名称。您可以将此角色映射程序与 LDAP 目录或包含可辨识名称(DN)的客户端证书一起使用;例如
cn=managers,ou=people,dc=example,dc=com
映射到managers
角色。
默认情况下,principal-to-role 映射仅应用于代表组的主体。通过将 authorization.group-only-mapping
配置属性设置为 false
,可以将 Data Grid 配置为也为用户主体执行映射。
8.1.2.1. 在 Data Grid 中将用户映射到角色和权限
考虑从 LDAP 服务器检索的以下用户,作为 DN 的集合:
CN=myapplication,OU=applications,DC=mycompany CN=dataprocessors,OU=groups,DC=mycompany CN=finance,OU=groups,DC=mycompany
使用 通用名称角色映射器 时,用户将映射到以下角色:
dataprocessors finance
Data Grid 具有以下角色定义:
dataprocessors: ALL_WRITE ALL_READ finance: LISTEN
用户应具有以下权限:
ALL_WRITE ALL_READ LISTEN
8.1.3. 配置角色映射器
默认情况下,Data Grid 启用集群角色映射程序和集群权限映射程序。要将不同的实现用于角色映射,您必须配置角色映射程序。
流程
- 打开 Data Grid 配置以进行编辑。
- 在 Cache Manager 配置中,将角色映射器声明为安全授权的一部分。
- 保存对配置的更改。
角色映射器配置
XML
<cache-container> <security> <authorization> <common-name-role-mapper /> </authorization> </security> </cache-container>
JSON
{ "infinispan" : { "cache-container" : { "security" : { "authorization" : { "common-name-role-mapper": {} } } } } }
YAML
infinispan: cacheContainer: security: authorization: commonNameRoleMapper: ~
其他资源
8.1.4. 配置集群角色和权限映射程序
集群角色映射程序在主体和角色之间维护动态映射。集群权限映射程序维护一组动态的角色定义。在这两种情况下,映射都存储在集群注册表中,可以使用 CLI 或 REST API 在运行时操作。
先决条件
-
具有 Data Grid 的
ADMIN
权限。 - 启动 Data Grid CLI。
- 连接到正在运行的 Data Grid 集群。
8.1.4.1. 创建新角色
创建新角色并设置权限。
流程
使用用户角色
create 命令创建角色
,例如:user roles create --permissions=ALL_READ,ALL_WRITE simple
验证
使用用户角色 ls 命令,列出您向用户授予的角色
。
user roles ls ["observer","application","admin","monitor","simple","deployer"]
描述 使用用户角色的角色 describe
命令。
user roles describe simple { "name" : "simple", "permissions" : [ "ALL_READ","ALL_WRITE" ] }
8.1.4.2. 授予用户角色
为用户分配角色,并授予他们执行缓存操作并与 Data Grid 资源交互的权限。
如果要为多个用户分配同一角色并集中维护其权限,请将角色授予组而不是用户。
先决条件
-
具有 Data Grid 的
ADMIN
权限。 - 创建 Data Grid 用户。
流程
- 创建与 Data Grid 的 CLI 连接。
使用
用户角色 grant 命令为用户分配角色
,例如:user roles grant --roles=deployer katie
验证
使用用户角色 ls 命令,列出您向用户授予的角色
。
user roles ls katie ["deployer"]
8.1.4.3. 集群角色映射程序名称重写器
默认情况下,映射是使用主体名称和角色之间的严格字符串等效性来执行。在执行查找前,可以将集群角色映射器配置为应用到主体名称的转换。
流程
- 打开 Data Grid 配置以进行编辑。
- 为集群角色映射器指定一个名称 rewriter,作为 Cache Manager 配置中的安全授权的一部分。
- 保存对配置的更改。
主体名称可能具有不同的表单,具体取决于安全域类型:
- 属性和令牌域可能会返回简单字符串
- 信任和 LDAP 域可能会返回 X.500 风格的可分辨名称
-
Kerberos 域可以返回
user@domain
风格名称
使用以下转换器之一,名称可以规范化为通用形式:
8.1.4.3.1. case Principal Transformer
XML
<cache-container> <security> <authorization> <cluster-role-mapper> <name-rewriter> <case-principal-transformer uppercase="false"/> </name-rewriter> </cluster-role-mapper> </authorization> </security> </cache-container>
JSON
{ "cache-container": { "security": { "authorization": { "cluster-role-mapper": { "name-rewriter": { "case-principal-transformer": {} } } } } } }
YAML
cacheContainer: security: authorization: clusterRoleMapper: nameRewriter: casePrincipalTransformer: uppercase: false
8.1.4.3.2. regex Principal Transformer
XML
<cache-container> <security> <authorization> <cluster-role-mapper> <name-rewriter> <regex-principal-transformer pattern="cn=([^,]+),.*" replacement="$1"/> </name-rewriter> </cluster-role-mapper> </authorization> </security> </cache-container>
JSON
{ "cache-container": { "security": { "authorization": { "cluster-role-mapper": { "name-rewriter": { "regex-principal-transformer": { "pattern": "cn=([^,]+),.*", "replacement": "$1" } } } } } } }
YAML
cacheContainer: security: authorization: clusterRoleMapper: nameRewriter: regexPrincipalTransformer: pattern: "cn=([^,]+),.*" replacement: "$1"
其他资源
8.2. 使用安全授权配置缓存
为缓存添加安全授权来强制实施基于角色的访问控制(RBAC)。这要求 Data Grid 用户拥有足够级别权限来执行缓存操作的角色。
先决条件
- 创建 Data Grid 用户,并使用角色授予他们,或者将它们分配到组。
流程
- 打开 Data Grid 配置以进行编辑。
-
在配置中添加
security
部分。 指定用户必须使用
authorization
元素执行缓存操作的角色。您可以隐式添加缓存管理器中定义的所有角色,或者明确定义角色的子集。
- 保存对配置的更改。
隐式角色配置
以下配置会隐式添加缓存管理器中定义的每个角色:
XML
<distributed-cache> <security> <authorization/> </security> </distributed-cache>
JSON
{ "distributed-cache": { "security": { "authorization": { "enabled": true } } } }
YAML
distributedCache: security: authorization: enabled: true
显式角色配置
以下配置明确添加缓存管理器中定义的角色子集。在这种情况下,Data Grid 拒绝任何没有配置角色的用户的缓存操作。
XML
<distributed-cache> <security> <authorization roles="admin supervisor"/> </security> </distributed-cache>
JSON
{ "distributed-cache": { "security": { "authorization": { "enabled": true, "roles": ["admin","supervisor"] } } } }
YAML
distributedCache: security: authorization: enabled: true roles: ["admin","supervisor"]
第 9 章 启用并配置 Data Grid 统计和 JMX 监控
网格可以提供缓存管理器和缓存统计信息,以及导出 JMX MBeans。
9.1. 在远程缓存中启用统计信息
Data Grid 服务器自动启用默认缓存管理器的统计信息。但是,您必须明确为您的缓存启用统计信息。
流程
- 打开 Data Grid 配置以进行编辑。
-
添加
statistics
属性或字段,并将true
指定为值。 - 保存并关闭您的 Data Grid 配置。
远程缓存统计信息
XML
<distributed-cache statistics="true" />
JSON
{ "distributed-cache": { "statistics": "true" } }
YAML
distributedCache: statistics: true
9.2. 启用 Hot Rod 客户端统计信息
热 Rod Java 客户端可以提供包括远程缓存和近缓存命中和未命中的统计数据,以及连接池使用情况。
流程
- 打开 Hot Rod Java 客户端配置以进行编辑。
-
将
true
设置为统计
属性的值或调用statistics ().enable ()
方法。 -
使用
jmx
和jmx_domain
属性为您的 Hot Rod 客户端导出 JMX MBeans,或者调用jmxEnable ()
和jmxDomain ()
方法。 - 保存并关闭您的客户端配置。
热 Rod Java 客户端统计信息
ConfigurationBuilder
ConfigurationBuilder builder = new ConfigurationBuilder(); builder.statistics().enable() .jmxEnable() .jmxDomain("my.domain.org") .addServer() .host("127.0.0.1") .port(11222); RemoteCacheManager remoteCacheManager = new RemoteCacheManager(builder.build());
hotrod-client.properties
infinispan.client.hotrod.statistics = true infinispan.client.hotrod.jmx = true infinispan.client.hotrod.jmx_domain = my.domain.org
9.3. 配置 Data Grid 指标
Data Grid 生成与任何监控系统兼容的指标。
- 量表提供值,如写操作或 JVM 正常运行时间的平均纳秒数。
- histograms 提供有关操作执行时间的详细信息,如读取、写入和删除时间。
默认情况下,当启用统计数据时,Data Grid 会生成量表,但您也可以将其配置为生成直方图。
Data Grid 指标在 供应商
范围内提供。与 JVM 相关的指标 在基本
范围内提供。
流程
- 打开 Data Grid 配置以进行编辑。
-
将
metrics
元素或对象添加到缓存容器。 -
使用量表属性或字段启用或禁用
量表
。 -
使用
histograms
属性或字段启用或禁用直方图。 - 保存并关闭您的客户端配置。
指标配置
XML
<infinispan> <cache-container statistics="true"> <metrics gauges="true" histograms="true" /> </cache-container> </infinispan>
JSON
{ "infinispan" : { "cache-container" : { "statistics" : "true", "metrics" : { "gauges" : "true", "histograms" : "true" } } } }
YAML
infinispan: cacheContainer: statistics: "true" metrics: gauges: "true" histograms: "true"
验证
Data Grid 服务器通过指标端点公开统计信息,您可以使用 Prometheus 等监控工具来收集这些端点。要验证统计是否已导出到
指标端点
,您可以执行以下操作:
Prometheus 格式
curl -v http://localhost:11222/metrics \ --digest -u username:password
OpenMetrics 格式
curl -v http://localhost:11222/metrics \ --digest -u username:password \ -H "Accept: application/openmetrics-text"
Data Grid 不再以 MicroProfile JSON 格式提供指标。
9.4. 注册 JMX MBeans
Data Grid 可以注册可以用来收集统计信息并执行管理操作的 JMX MBeans。您还必须启用统计信息,否则 Data Grid 为 JMX MBeans 中的所有统计属性提供 0
值。
只有在 Data Grid 嵌入于应用程序中而不是远程 Data Grid 服务器时,使用 JMX Mbeans 来收集统计信息。
当您使用 JMX Mbeans 从远程 Data Grid 服务器收集统计信息时,从 JMX Mbeans 接收的数据可能与 REST 等其他 API 接收的数据不同。在这种情况下,从其他 API 接收的数据更为准确。
流程
- 打开 Data Grid 配置以进行编辑。
-
将
jmx
元素或对象添加到缓存容器,并将true
指定为enabled
属性或字段的值。 -
添加
domain
属性或字段,并指定公开 JMX MBeans 的域(如果需要)。 - 保存并关闭您的客户端配置。
JMX 配置
XML
<infinispan> <cache-container statistics="true"> <jmx enabled="true" domain="example.com"/> </cache-container> </infinispan>
JSON
{ "infinispan" : { "cache-container" : { "statistics" : "true", "jmx" : { "enabled" : "true", "domain" : "example.com" } } } }
YAML
infinispan: cacheContainer: statistics: "true" jmx: enabled: "true" domain: "example.com"
9.4.1. 启用 JMX 远程端口
提供唯一的远程 JMX 端口,以通过 JMXServiceURL 格式的连接公开数据网格 MBean。
Data Grid 服务器不会通过单一端口端点远程公开 JMX。如果要通过 JMX 远程访问 Data Grid 服务器,您必须启用远程端口。
您可以使用以下方法之一启用远程 JMX 端口:
- 启用需要向其中一个 Data Grid 服务器安全域进行身份验证的远程 JMX 端口。
- 使用标准 Java 管理配置选项手动启用远程 JMX 端口。
先决条件
-
对于带有身份验证的远程 JMX,请使用默认安全域定义 JMX 特定的用户角色。用户必须具有具有读/写访问权限的
controlRole
,或者具有只读访问权限的monitorRole
才能访问任何 JMX 资源。Data Grid 会自动将全局ADMIN
和MONITOR
权限映射到 JMXcontrolRole
和monitorRole
角色。
流程
使用以下方法之一启动启用了远程 JMX 端口的 Data Grid 服务器:
通过端口
9999
启用远程 JMX。bin/server.sh --jmx 9999
警告在生产环境中不适用于禁用 SSL 的远程 JMX。
在启动时将以下系统属性传递给 Data Grid 服务器。
bin/server.sh -Dcom.sun.management.jmxremote.port=9999 -Dcom.sun.management.jmxremote.authenticate=false -Dcom.sun.management.jmxremote.ssl=false
警告启用没有身份验证或 SSL 的远程 JMX 不安全,在任何环境中都不推荐使用。禁用身份验证和 SSL 允许未授权用户连接到服务器并访问托管的数据。
其他资源
9.4.2. Data Grid MBeans
Data Grid 公开了代表可管理资源的 JMX MBeans。
org.infinispan:type=Cache
- 可用于缓存实例的属性和操作。
org.infinispan:type=CacheManager
- 可用于缓存管理器的属性和操作,包括数据网格缓存和集群健康统计信息。
有关可用 JMX MBeans 的完整列表以及描述和可用的操作和属性,请参阅 Data Grid JMX 组件 文档。
其他资源
9.4.3. 在自定义 MBean 服务器中注册 MBeans
Data Grid 包含一个 MBeanServerLookup
接口,可用于在自定义 MBeanServer 实例中注册 MBeans。
先决条件
-
创建
MBeanServerLookup
的实现,以便getMBeanServer ()
方法返回自定义 MBeanServer 实例。 - 配置数据网格以注册 JMX MBeans。
流程
- 打开 Data Grid 配置以进行编辑。
-
将
mbean-server-lookup
属性或字段添加到 Cache Manager 的 JMX 配置。 -
指定
MBeanServerLookup
实施的完全限定名称(FQN)。 - 保存并关闭您的客户端配置。
JMX MBean 服务器查找配置
XML
<infinispan> <cache-container statistics="true"> <jmx enabled="true" domain="example.com" mbean-server-lookup="com.example.MyMBeanServerLookup"/> </cache-container> </infinispan>
JSON
{ "infinispan" : { "cache-container" : { "statistics" : "true", "jmx" : { "enabled" : "true", "domain" : "example.com", "mbean-server-lookup" : "com.example.MyMBeanServerLookup" } } } }
YAML
infinispan: cacheContainer: statistics: "true" jmx: enabled: "true" domain: "example.com" mbeanServerLookup: "com.example.MyMBeanServerLookup"
9.5. 在状态传输操作过程中导出指标
您可以为跨节点分布集群缓存导出时间指标。
当集群缓存拓扑更改时,状态传输操作发生,如加入或离开集群的节点。在状态传输操作期间,Data Grid 会导出每个缓存中的指标,以便您可以确定缓存的状态。状态传输将属性作为属性公开,以便 Data Grid 可以从每个缓存中导出指标。
您不能在无效模式下执行状态传输操作。
Data Grid 生成与 REST API 和 JMX API 兼容的时间指标。
先决条件
- 配置数据网格指标。
- 为您的缓存类型启用指标,如嵌入式缓存或远程缓存。
- 通过更改集群缓存拓扑来启动状态传输操作。
流程
选择以下任一方法:
- 配置 Data Grid 以使用 REST API 来收集指标。
- 配置 Data Grid 以使用 JMX API 来收集指标。
9.6. 监控跨站点复制的状态
监控备份位置的站点状态,以检测站点之间的通信中断。当远程站点状态变为 离线时
,Data Grid 会停止将数据复制到备份位置。您的数据不同步,您必须在使集群重新上线前修复不一致的问题。
对于早期问题检测,需要监控跨站点事件。使用以下监控策略之一:
使用 REST API 监控跨站点复制
使用 REST 端点监控所有缓存的跨站点复制状态。您可以实施自定义脚本来轮询 REST 端点,或者使用以下示例。
先决条件
- 启用跨站点复制。
流程
实施脚本以轮询 REST 端点。
以下示例演示了如何使用 Python 脚本每 5 秒轮询站点状态。
#!/usr/bin/python3 import time import requests from requests.auth import HTTPDigestAuth class InfinispanConnection: def __init__(self, server: str = 'http://localhost:11222', cache_manager: str = 'default', auth: tuple = ('admin', 'change_me')) -> None: super().__init__() self.__url = f'{server}/rest/v2/container/x-site/backups/' self.__auth = auth self.__headers = { 'accept': 'application/json' } def get_sites_status(self): try: rsp = requests.get(self.__url, headers=self.__headers, auth=HTTPDigestAuth(self.__auth[0], self.__auth[1])) if rsp.status_code != 200: return None return rsp.json() except: return None # Specify credentials for Data Grid user with permission to access the REST endpoint USERNAME = 'admin' PASSWORD = 'change_me' # Set an interval between cross-site status checks POLL_INTERVAL_SEC = 5 # Provide a list of servers SERVERS = [ InfinispanConnection('http://127.0.0.1:11222', auth=(USERNAME, PASSWORD)), InfinispanConnection('http://127.0.0.1:12222', auth=(USERNAME, PASSWORD)) ] #Specify the names of remote sites REMOTE_SITES = [ 'nyc' ] #Provide a list of caches to monitor CACHES = [ 'work', 'sessions' ] def on_event(site: str, cache: str, old_status: str, new_status: str): # TODO implement your handling code here print(f'site={site} cache={cache} Status changed {old_status} -> {new_status}') def __handle_mixed_state(state: dict, site: str, site_status: dict): if site not in state: state[site] = {c: 'online' if c in site_status['online'] else 'offline' for c in CACHES} return for cache in CACHES: __update_cache_state(state, site, cache, 'online' if cache in site_status['online'] else 'offline') def __handle_online_or_offline_state(state: dict, site: str, new_status: str): if site not in state: state[site] = {c: new_status for c in CACHES} return for cache in CACHES: __update_cache_state(state, site, cache, new_status) def __update_cache_state(state: dict, site: str, cache: str, new_status: str): old_status = state[site].get(cache) if old_status != new_status: on_event(site, cache, old_status, new_status) state[site][cache] = new_status def update_state(state: dict): rsp = None for conn in SERVERS: rsp = conn.get_sites_status() if rsp: break if rsp is None: print('Unable to fetch site status from any server') return for site in REMOTE_SITES: site_status = rsp.get(site, {}) new_status = site_status.get('status') if new_status == 'mixed': __handle_mixed_state(state, site, site_status) else: __handle_online_or_offline_state(state, site, new_status) if __name__ == '__main__': _state = {} while True: update_state(_state) time.sleep(POLL_INTERVAL_SEC)
当站点状态从 Online 变为 offline
或 vice-versa 时,调用 on_event
的功能。
如果要使用这个脚本,您必须指定以下变量:
-
USERNAME
和PASSWORD
:Data Grid 用户的用户名和密码,有权访问 REST 端点。 -
POLL_INTERVAL_SEC
:轮询之间的秒数。 -
SERVERS
:此站点的数据网格服务器列表。该脚本只需要一个有效的响应,但提供了列表以允许故障切换。 -
REMOTE_SITES
: 要监控这些服务器上的远程站点列表。 -
CACHES
:要监控的缓存名称列表。
其他资源
使用 Prometheus 指标监控跨站点复制
Prometheus 和其他监控系统可让您配置警报来检测站点状态何时更改为 离线
。
监控跨站点延迟指标可帮助您发现潜在的问题。
先决条件
- 启用跨站点复制。
流程
- 配置数据网格指标。
使用 Prometheus 指标格式配置警报规则。
-
对于站点状态,
在线
使用1
,0
代表离线
。 对于
expr
filed,请使用以下格式:vendor_cache_manager_default_cache_<cache name>_x_site_admin_<site name>_status
。在以下示例中,当 NYC 站点为名为
work
或 session 的缓存离线时
,Prometheus会发出警告
。groups: - name: Cross Site Rules rules: - alert: Cache Work and Site NYC expr: vendor_cache_manager_default_cache_work_x_site_admin_nyc_status == 0 - alert: Cache Sessions and Site NYC expr: vendor_cache_manager_default_cache_sessions_x_site_admin_nyc_status == 0
下图显示了 NYC 站点
离线
进行缓存工作
的警报。图 9.1. Prometheus Alert
-
对于站点状态,
第 10 章 启用并配置 Data Grid OpenTelemetry 追踪
Data Grid 生成与 OpenTelemetry 标准兼容的追踪,允许您导出、视觉化和分析与最重要的缓存操作相关的追踪数据。
10.1. 配置数据网格追踪
配置 OpenTelemetry 追踪,以启用缓存操作的监控和追踪。
流程
- 打开 Data Grid 配置以进行编辑。
-
将
tracing
元素或对象添加到缓存容器。 -
使用
collector_endpoint
属性或字段定义 OpenTelemetry 收集器的端点 URL。启用追踪是必需的。4318
通常是http/protobuf
OTLP 标准端口。 -
使用
enable
属性或字段全局启用或禁用追踪。 -
使用
security
属性或字段启用或禁用安全事件追踪。 -
(可选)更改追踪导出器协议更改
exporter_protocol
属性或字段。默认情况下,它是otlp
(OpenTelemetry 协议)。 -
(可选)更改与生成的追踪范围关联的追踪服务名称,更改
service_name
属性或字段。默认情况下,它是infinispan-server
。 - 保存并关闭您的客户端配置。
后续步骤
要应用任何全局追踪配置更改,请停止服务器并重复这个过程。
追踪配置
Data Grid 在全局范围内对所有缓存应用追踪配置。
XML
<infinispan> <cache-container statistics="true"> <tracing collector-endpoint="http://localhost:4318" enabled="true" exporter-protocol="OTLP" service-name="infinispan-server" security="false" /> </cache-container> </infinispan>
JSON
{ "infinispan" : { "cache-container" : { "statistics" : true, "tracing" : { "collector-endpoint" : "http://localhost:4318", "enabled" : true, "exporter-protocol" : "OTLP", "service-name" : "infinispan-server", "security" : false } } } }
YAML
infinispan: cacheContainer: statistics: true tracing: collector-endpoint: "http://localhost:4318" enabled: true exporter-protocol: "OTLP" service-name: "infinispan-server" security: false
10.1.1. 进一步跟踪选项
要配置进一步追踪选项,可以在启动时将系统属性或设置环境变量传递给 Data Grid 服务器,以直接配置 OpenTelemetry SDK Autoconfigure,供 Data Grid 服务器用来配置 OpenTelemetry 追踪。
流程
在启动时将系统属性传递给 Data Grid 服务器。
use
-D<property-name>=<property-value
> 参数,如下例所示:bin/server.sh -Dotel.exporter.otlp.timeout=10000
追踪数据格式
默认情况下,Data Grid 服务器使用 OTLP http/protobuf
协议导出追踪数据。
tracing.properties
otel.exporter.otlp.protocol = http/protobuf
要使用不同的协议,您必须将 JAR 文件或依赖项复制到 Data Grid Server 安装的 $ISPN_HOME/server/lib
目录中。
10.2. 在缓存级别配置追踪
在服务器级别 配置了 追踪后,它将在所有缓存中自动启用。缓存配置级别的追踪允许另一手在缓存级别和运行时启用或禁用它。
追踪类别
可能会跟踪几个类别:
- 容器。这是所有主要缓存操作,如 replace, put, clear, getForReplace, remove operations and size。除 get 操作外。
- 集群.复制到同一集群中的另一节点的操作。
- X-Site。复制到另一个外部站点的操作。
- 持久性.涉及通过缓存存储和/或缓存加载程序持久性的所有操作。
每个类别都可以在启动时启用/禁用,或者在 categories
list 属性中列出它们。默认情况下,仅启用容器类别。
Security
类别也要跟踪安全审计事件。此类别在全局范围内配置,不仅在缓存级别上配置,因为它们的事件可以具有不同的范围(缓存、容器或服务器),而不仅仅是缓存范围。
为给定缓存启用/禁用追踪
XML
<replicated-cache> <tracing enabled="true" categories="container cluster x-site persistence" /> </replicated-cache>
JSON
{ "distributed-cache": { "tracing": { "enabled" : true, "categories": [ "container", "cluster", "x-site", "persistence" ] } } }
YAML
distributedCache: tracing: enabled: true categories: - "container" - "cluster" - "x-site" - "persistence"
在运行时启用/禁用追踪
cache-level tracing 属性 enable
是一个 mutable 属性,这意味着可以在运行时更改它,而无需重启 Infinispan 集群。
要更改 mutable 属性,可以使用 HotRod 和 REST API。
HotRod
remoteCacheManager.administration() .updateConfigurationAttribute(CACHE_A, "tracing.enabled", "false");
REST
restClient.cache(CACHE_A) .updateConfigurationAttribute("tracing.enabled", "false");
其他资源
第 11 章 在 Data Grid 服务器中添加受管数据源
通过在 Data Grid 服务器配置中添加受管数据源,为 JDBC 数据库连接优化连接池和性能。
11.1. 配置受管数据源
作为 Data Grid 服务器配置的一部分创建受管数据源,以优化 JDBC 数据库连接的连接池和性能。然后,您可以在缓存中指定受管数据源的 JDNI 名称,它将为您的部署集中 JDBC 连接配置。
先决条件
将数据库驱动程序复制到 Data Grid Server 安装中的
server/lib
目录中。提示使用带有 Data Grid 命令行界面(CLI)的
install
命令,将所需的驱动程序下载到server/lib
目录中,例如:install org.postgresql:postgresql:42.4.3
流程
- 打开 Data Grid Server 配置以进行编辑。
-
在
data-sources
部分添加新的数据源 -
使用
name
属性或字段唯一标识数据源。 使用
jndi-name
属性或字段为数据源指定 JNDI 名称。提示您可以使用 JNDI 名称在 JDBC 缓存存储配置中指定数据源。
-
将
true
设置为statistics
属性或字段的值,以通过/metrics
端点启用数据源的统计信息。 提供 JDBC 驱动程序详细信息,用于定义如何在
connection-factory
部分中连接到数据源。-
使用
driver
属性或字段指定数据库驱动程序的名称。 -
使用 url 属性或字段指定 JDBC 连接
url
。 -
使用
用户名和密码
属性或字段指定 - 根据需要提供任何其他配置。
-
使用
-
定义 Data Grid Server 节点如何池,并在
connection-pool
部分中定义连接池调优属性的连接。 - 保存对配置的更改。
验证
使用 Data Grid 命令行界面(CLI)测试数据源连接,如下所示:
启动 CLI 会话。
bin/cli.sh
列出所有数据源,并确认您创建的数据源可用。
server datasource ls
测试数据源连接。
server datasource test my-datasource
受管数据源配置
XML
<server xmlns="urn:infinispan:server:15.0"> <data-sources> <!-- Defines a unique name for the datasource and JNDI name that you reference in JDBC cache store configuration. Enables statistics for the datasource, if required. --> <data-source name="ds" jndi-name="jdbc/postgres" statistics="true"> <!-- Specifies the JDBC driver that creates connections. --> <connection-factory driver="org.postgresql.Driver" url="jdbc:postgresql://localhost:5432/postgres" username="postgres" password="changeme"> <!-- Sets optional JDBC driver-specific connection properties. --> <connection-property name="name">value</connection-property> </connection-factory> <!-- Defines connection pool tuning properties. --> <connection-pool initial-size="1" max-size="10" min-size="3" background-validation="1000" idle-removal="1" blocking-timeout="1000" leak-detection="10000"/> </data-source> </data-sources> </server>
JSON
{ "server": { "data-sources": [{ "name": "ds", "jndi-name": "jdbc/postgres", "statistics": true, "connection-factory": { "driver": "org.postgresql.Driver", "url": "jdbc:postgresql://localhost:5432/postgres", "username": "postgres", "password": "changeme", "connection-properties": { "name": "value" } }, "connection-pool": { "initial-size": 1, "max-size": 10, "min-size": 3, "background-validation": 1000, "idle-removal": 1, "blocking-timeout": 1000, "leak-detection": 10000 } }] } }
YAML
server: dataSources: - name: ds jndiName: 'jdbc/postgres' statistics: true connectionFactory: driver: "org.postgresql.Driver" url: "jdbc:postgresql://localhost:5432/postgres" username: "postgres" password: "changeme" connectionProperties: name: value connectionPool: initialSize: 1 maxSize: 10 minSize: 3 backgroundValidation: 1000 idleRemoval: 1 blockingTimeout: 1000 leakDetection: 10000
11.2. 使用 JNDI 名称配置缓存
将受管数据源添加到 Data Grid 服务器时,您可以将 JNDI 名称添加到基于 JDBC 的缓存存储配置中。
先决条件
- 使用托管数据源配置 Data Grid 服务器。
流程
- 打开缓存配置进行编辑。
-
将
data-source
元素或字段添加到基于 JDBC 的缓存存储配置中。 -
将受管数据源的 JNDI 名称指定为
jndi-url
属性的值。 - 根据情况配置基于 JDBC 的缓存存储。
- 保存对配置的更改。
缓存配置中的 JNDI 名称
XML
<distributed-cache> <persistence> <jdbc:string-keyed-jdbc-store> <!-- Specifies the JNDI name of a managed datasource on Data Grid Server. --> <jdbc:data-source jndi-url="jdbc/postgres"/> <jdbc:string-keyed-table drop-on-exit="true" create-on-start="true" prefix="TBL"> <jdbc:id-column name="ID" type="VARCHAR(255)"/> <jdbc:data-column name="DATA" type="BYTEA"/> <jdbc:timestamp-column name="TS" type="BIGINT"/> <jdbc:segment-column name="S" type="INT"/> </jdbc:string-keyed-table> </jdbc:string-keyed-jdbc-store> </persistence> </distributed-cache>
JSON
{ "distributed-cache": { "persistence": { "string-keyed-jdbc-store": { "data-source": { "jndi-url": "jdbc/postgres" }, "string-keyed-table": { "prefix": "TBL", "drop-on-exit": true, "create-on-start": true, "id-column": { "name": "ID", "type": "VARCHAR(255)" }, "data-column": { "name": "DATA", "type": "BYTEA" }, "timestamp-column": { "name": "TS", "type": "BIGINT" }, "segment-column": { "name": "S", "type": "INT" } } } } } }
YAML
distributedCache: persistence: stringKeyedJdbcStore: dataSource: jndi-url: "jdbc/postgres" stringKeyedTable: prefix: "TBL" dropOnExit: true createOnStart: true idColumn: name: "ID" type: "VARCHAR(255)" dataColumn: name: "DATA" type: "BYTEA" timestampColumn: name: "TS" type: "BIGINT" segmentColumn: name: "S" type: "INT"
11.3. 连接池调优属性
您可以在 Data Grid Server 配置中针对受管数据源调整 JDBC 连接池。
属性 | 描述 |
---|---|
| 池应保留的初始连接数。 |
| 池中的最大连接数。 |
| 池应保留的最小连接数。 |
|
在抛出异常前等待连接时的最大时间(毫秒)。如果创建新连接需要很长时间,则这永远不会抛出异常。默认值为 |
|
后台验证运行之间的时间(毫秒)。持续时间为 |
|
闲置的时间比这个时间更长的时间(以毫秒为单位指定)会在获取前验证(foreground 验证)。持续时间为 |
| 在几分钟内,连接必须处于闲置状态才能被删除。 |
| 在泄漏警告前,必须保留连接的时间(毫秒)。 |
第 12 章 设置 Data Grid 集群传输
Data Grid 需要传输层,以便节点可以自动加入和离开集群。传输层还可让数据在网络间复制或分发数据,并执行操作,如重新平衡和状态传输。
12.1. 默认 JGroups 堆栈
Data Grid 在 infinispan-core-14.0.21.Final
。
-redhat-00001.jar
文件的 default-configs
目录中提供默认的 JGroups 堆栈文件 default-jgroups114.xml
您可以在 $RHDG_HOME/lib
目录中找到此 JAR 文件。
文件名 | 堆栈名称 | 描述 |
---|---|---|
|
| 使用 UDP 进行传输和 UDP 多播进行发现。适用于较大的集群(超过 100 个节点),或者使用复制缓存或无效模式。最小化打开的插槽数量。 |
|
|
使用 TCP 传输和 |
|
|
使用 TCP 进行传输, |
|
|
使用 TCP 进行传输和 |
|
|
使用 TCP 进行传输, |
|
|
使用 TCP 进行传输, |
|
|
使用 |
其他资源
12.2. 集群发现协议
Data Grid 支持不同的协议,允许节点在网络上自动找到并形成集群。
Data Grid 可以使用两种发现机制:
- 在大多数网络上工作且不依赖于外部服务的通用发现协议。
-
依赖于外部服务的发现协议来存储和检索 Data Grid 集群的拓扑信息。
例如,DNS_PING 协议通过 DNS 服务器记录执行发现。
在托管平台上运行 Data Grid 需要使用针对各个云提供商实施的网络限制的发现机制。
其他资源
12.2.1. PING
PING 或 UDPPING 是一种通用 JGroups 发现机制,它使用 UDP 协议的动态多播。
加入后,节点将 PING 请求发送到 IP 多播地址,以发现已在 Data Grid 集群中的其他节点。每个节点通过包含协调器节点地址的数据包以及自己的地址来响应 PING 请求。C=coordinator 的地址和 A=own 地址。如果没有节点响应 PING 请求,则加入节点会成为新集群中的协调节点。
PING 配置示例
<PING num_discovery_runs="3"/>
其他资源
12.2.2. TCPPING
TCPPING 是一种通用 JGroups 发现机制,它对群集成员使用静态地址列表。
使用 TCPPING 时,您可以手动将 Data Grid 集群中每个节点的 IP 地址或主机名指定为 JGroups 堆栈的一部分,而不是让节点动态发现其他节点。
TCPPING 配置示例
<TCP bind_port="7800" /> <TCPPING timeout="3000" initial_hosts="${jgroups.tcpping.initial_hosts:hostname1[port1],hostname2[port2]}" port_range="0" num_initial_members="3"/>
其他资源
12.2.3. MPING
MPING 使用 IP 多播来发现 Data Grid 集群的初始成员资格。
您可以使用 MPING 将 TCPPING 发现替换为 TCP 堆栈,并使用 multicasing 进行发现,而不使用初始主机的静态列表。但是,您还可以将 MPING 与 UDP 堆栈一起使用。
MPING 配置示例
<MPING mcast_addr="${jgroups.mcast_addr:239.6.7.8}" mcast_port="${jgroups.mcast_port:46655}" num_discovery_runs="3" ip_ttl="${jgroups.udp.ip_ttl:2}"/>
其他资源
12.2.4. TCPGOSSIP
gossip 路由器在网络上提供一个中央位置,用于您的数据网格集群可以检索其他节点的地址。
您可以将 Gossip 路由器的地址(IP:PORT
)注入 Data Grid 节点,如下所示:
-
将 address 作为系统属性传递给 JVM;例如,
-DGossipRouterAddress="10.10.2.4[12001]"
。 - 在 JGroups 配置文件中引用该系统属性。
gossip 路由器配置示例
<TCP bind_port="7800" /> <TCPGOSSIP timeout="3000" initial_hosts="${GossipRouterAddress}" num_initial_members="3" />
12.2.5. JDBC_PING2
JDBC_PING2 使用共享数据库存储关于 Data Grid 集群的信息。此协议支持任何可以使用 JDBC 连接的数据库。
节点将其 IP 地址写入共享数据库,以便加入节点可以在网络上找到 Data Grid 集群。当节点离开 Data Grid 集群时,它们会从共享数据库中删除其 IP 地址。
JDBC_PING2 配置示例
<JDBC_PING connection_url="jdbc:mysql://localhost:3306/database_name" connection_username="user" connection_password="password" connection_driver="com.mysql.jdbc.Driver"/>
将适当的 JDBC 驱动程序添加到 classpath 中,以便 Data Grid 可以使用 JDBC_PING2。
12.2.5.1. 将服务器数据源用于 JDBC_PING2 发现
将受管数据源添加到 Data Grid 服务器,并使用它来为集群传输 JDBC_PING2 发现协议提供数据库连接。
先决条件
- 安装 Data Grid Server 集群。
流程
-
将 JDBC 驱动程序 JAR 部署到 Data Grid Server
server/lib
目录中 为您的数据库创建数据源。
<server xmlns="urn:infinispan:server:15.0"> <data-sources> <!-- Defines a unique name for the datasource and JNDI name that you reference in JDBC cache store configuration. Enables statistics for the datasource, if required. --> <data-source name="ds" jndi-name="jdbc/postgres" statistics="true"> <!-- Specifies the JDBC driver that creates connections. --> <connection-factory driver="org.postgresql.Driver" url="jdbc:postgresql://localhost:5432/postgres" username="postgres" password="changeme"> <!-- Sets optional JDBC driver-specific connection properties. --> <connection-property name="name">value</connection-property> </connection-factory> <!-- Defines connection pool tuning properties. --> <connection-pool initial-size="1" max-size="10" min-size="3" background-validation="1000" idle-removal="1" blocking-timeout="1000" leak-detection="10000"/> </data-source> </data-sources> </server>
-
创建 JGroups 堆栈,它将使用
JDBC_PING2
协议进行发现。 通过使用
server:data-source
属性指定数据源的名称,将集群传输配置为使用数据源。<infinispan> <jgroups> <stack name="jdbc" extends="tcp"> <JDBC_PING stack.combine="REPLACE" stack.position="MPING" /> </stack> </jgroups> <cache-container> <transport stack="jdbc" server:data-source="ds" /> </cache-container> </infinispan>
其他资源
12.2.6. DNS_PING
JGroups DNS_PING 查询 DNS 服务器,以便在 Kubernetes 环境中发现数据网格群集成员,如 OKD 和 Red Hat OpenShift。
DNS_PING 配置示例
<dns.DNS_PING dns_query="myservice.myproject.svc.cluster.local" />
其他资源
- JGroups DNS_PING
- 服务和 Pod 的 DNS (Kubernetes 文档来添加 DNS 条目)
12.2.7. 云发现协议
Data Grid 包括默认的 JGroups 堆栈,它使用特定于云提供商的发现协议实现。
发现协议 | 默认堆栈文件 | 工件 | Version |
---|---|---|---|
|
|
|
|
|
|
|
|
|
|
|
|
为云发现协议提供依赖项
要使用 aws.S3_PING
、GOOGLE_PING2
或 azure.AZURE_PING
云发现协议,您需要向 Data Grid 提供依赖的库。
流程
- 下载工件 JAR 文件和所有依赖项。
将工件 JAR 文件和所有依赖项添加到 Data Grid Server 安装的
$RHDG_HOME/server/lib
目录中。如需了解更多详细信息,请参阅 用于 Data Grid Server 的 JGroups 云发现协议下载工件 (红帽知识库文章)
然后,您可以将云发现协议配置为 JGroups 堆栈文件或系统属性的一部分。
12.3. 使用默认 JGroups 堆栈
Data Grid 使用 JGroups 协议堆栈,以便节点可以在专用集群通道上发送其他消息。
Data Grid 为 UDP
和 TCP
协议提供预配置的 JGroups 堆栈。您可以使用这些默认堆栈作为构建自定义集群传输配置的起点,该配置根据您的网络要求进行了优化。
流程
执行以下操作之一使用默认 JGroups 堆栈之一:
使用
infinispan.xml
文件中的stack
属性。<infinispan> <cache-container default-cache="replicatedCache"> <!-- Use the default UDP stack for cluster transport. --> <transport cluster="${infinispan.cluster.name}" stack="udp" node-name="${infinispan.node.name:}"/> </cache-container> </infinispan>
在 Data Grid 服务器启动时,使用
cluster-stack
参数设置 JGroups 堆栈文件:bin/server.sh --cluster-stack=udp
验证
Data Grid 记录以下信息以指示它使用的堆栈:
[org.infinispan.CLUSTER] ISPN000078: Starting JGroups channel cluster with stack udp
其他资源
- Data Grid 8.x 的 JGroups 集群传输配置 (红帽知识库文章)
12.4. 自定义 JGroups 堆栈
调整和调优属性,以创建适合您的网络要求的集群传输配置。
Data Grid 提供可让您扩展默认 JGroups 堆栈以方便配置的属性。您可以在合并、删除和替换其他属性时从默认堆栈继承属性。
流程
-
在
infinispan.xml
文件中创建一个新的 JGroups 堆栈声明。 -
添加
extends
属性,并指定 JGroups 堆栈来继承属性。 -
使用
stack.combine
属性修改继承堆栈中配置的协议的属性。 -
使用
stack.position
属性定义自定义堆栈的位置。 指定堆栈名称,作为
传输
配置中stack
属性的值。例如,您可以使用 Gossip 路由器和使用默认 TCP 堆栈的对称加密来评估,如下所示:
<infinispan> <jgroups> <!-- Creates a custom JGroups stack named "my-stack". --> <!-- Inherits properties from the default TCP stack. --> <stack name="my-stack" extends="tcp"> <!-- Uses TCPGOSSIP as the discovery mechanism instead of MPING --> <TCPGOSSIP initial_hosts="${jgroups.tunnel.gossip_router_hosts:localhost[12001]}" stack.combine="REPLACE" stack.position="MPING" /> <!-- Removes the FD_SOCK2 protocol from the stack. --> <FD_SOCK2 stack.combine="REMOVE"/> <!-- Modifies the timeout value for the VERIFY_SUSPECT2 protocol. --> <VERIFY_SUSPECT2 timeout="2000"/> <!-- Adds SYM_ENCRYPT to the stack after VERIFY_SUSPECT2. --> <SYM_ENCRYPT sym_algorithm="AES" keystore_name="mykeystore.p12" keystore_type="PKCS12" store_password="changeit" key_password="changeit" alias="myKey" stack.combine="INSERT_AFTER" stack.position="VERIFY_SUSPECT2" /> </stack> </jgroups> <cache-container name="default" statistics="true"> <!-- Uses "my-stack" for cluster transport. --> <transport cluster="${infinispan.cluster.name}" stack="my-stack" node-name="${infinispan.node.name:}"/> </cache-container> </infinispan>
检查 Data Grid 日志,以确保它使用堆栈。
[org.infinispan.CLUSTER] ISPN000078: Starting JGroups channel cluster with stack my-stack
参考
- Data Grid 8.x 的 JGroups 集群传输配置 (红帽知识库文章)
12.4.1. 继承属性
当您扩展 JGroups 堆栈时,继承属性允许您调整您要扩展的堆栈中的协议和属性。
-
stack.position
指定要修改的协议。 stack.combine
使用以下值来扩展 JGroups 堆栈:value 描述 组合
覆盖协议属性。
REPLACE
替换协议。
INSERT_AFTER
在另一个协议后将协议添加到堆栈中。不会影响指定为插入点的协议。
JGroups 堆栈中的协议会根据堆栈中的位置相互影响。例如,您应该在
SYM_ENCRYPT
或ASYM_ENCRYPT
协议后放置NAKACK2
等协议,以便保护NAKACK2
。INSERT_BEFORE
在另一个协议前,将协议插入到堆栈中。影响您指定为插入点的协议。
删除
从堆栈中删除协议。
12.5. 使用 JGroups 系统属性
在启动时将系统属性传递给 Data Grid,以调优群集传输。
流程
-
根据需要,使用
-D<property-name>=<property-value
> 参数设置 JGroups 系统属性。
例如,设置自定义绑定端口和 IP 地址,如下所示:
bin/server.sh -Djgroups.bind.port=1234 -Djgroups.bind.address=192.0.2.0
12.5.1. 集群传输属性
使用以下属性自定义 JGroups 集群传输。
系统属性 | 描述 | 默认值 | 必填/选填 |
---|---|---|---|
| 集群传输的绑定地址。 |
| 选填 |
| 套接字的绑定端口。 |
| 选填 |
| 用于多播的 IP 地址,包括发现和集群间通信。IP 地址必须是适合 IP 多播的有效"类 D"地址。 |
| 选填 |
| 多播套接字的端口。 |
| 选填 |
| IP 多播数据包的时间到时间(TTL)。该值定义数据包在丢弃前可以进行的网络跃点数。 | 2 | 选填 |
| 线程池的最小线程数量。 | 0 | 选填 |
| 线程池的最大线程数。 | 200 | 选填 |
| 等待加入请求成功的最大毫秒数。 | 2000 | 选填 |
| 在记录线程转储前,线程池需要满的次数。 | 10000 | 选填 |
|
来自 FD (检测协议)套接字的 |
| 选填 |
| 消息中的最大字节数。大于碎片的消息。 | 60000 | 选填 |
| 启用 JGroups 诊断探测。 | false | 选填 |
其他资源
12.5.2. 云发现协议的系统属性
使用以下属性为托管平台配置 JGroups 发现协议:
12.5.2.1. Amazon EC2
用于配置 aws.S3_PING
的系统属性。
系统属性 | 描述 | 默认值 | 必填/选填 |
---|---|---|---|
| Amazon S3 区域的名称。 | 没有默认值。 | 选填 |
| Amazon S3 存储桶的名称。名称必须存在,并且必须是唯一的。 | 没有默认值。 | 选填 |
12.5.2.2. Google Cloud Platform
用于配置 GOOGLE_PING2
的系统属性。
系统属性 | 描述 | 默认值 | 必填/选填 |
---|---|---|---|
| Google Compute Engine 存储桶的名称。名称必须存在,并且必须是唯一的。 | 没有默认值。 | 必填 |
12.5.2.3. Azure
azure.AZURE_PING' 的系统属性。
系统属性 | 描述 | 默认值 | 必填/选填 |
---|---|---|---|
| Azure 存储帐户的名称。名称必须存在,并且必须是唯一的。 | 没有默认值。 | 必填 |
| Azure 存储访问密钥的名称。 | 没有默认值。 | 必填 |
| 存储 ping 信息的容器的有效 DNS 名称。 | 没有默认值。 | 必填 |
12.5.2.4. OpenShift
DNS_PING
的系统属性。
系统属性 | 描述 | 默认值 | 必填/选填 |
---|---|---|---|
| 设置返回群集成员的 DNS 记录。 | 没有默认值。 | 必填 |
| 设置 DNS 记录类型。 | A | 选填 |
12.6. 使用 inline JGroups 堆栈
您可以将完整的 JGroups 堆栈定义插入到 infinispan.xml
文件中。
流程
在
infinispan.xml
文件中嵌入自定义 JGroups 堆栈声明。<infinispan> <!-- Contains one or more JGroups stack definitions. --> <jgroups> <!-- Defines a custom JGroups stack named "prod". --> <stack name="prod"> <TCP bind_port="7800" port_range="30" recv_buf_size="20000000" send_buf_size="640000"/> <RED/> <MPING break_on_coord_rsp="true" mcast_addr="${jgroups.mping.mcast_addr:239.2.4.6}" mcast_port="${jgroups.mping.mcast_port:43366}" num_discovery_runs="3" ip_ttl="${jgroups.udp.ip_ttl:2}"/> <MERGE3 /> <FD_SOCK2 /> <FD_ALL3 timeout="3000" interval="1000" timeout_check_interval="1000" /> <VERIFY_SUSPECT2 timeout="1000" /> <pbcast.NAKACK2 use_mcast_xmit="false" xmit_interval="200" xmit_table_num_rows="50" xmit_table_msgs_per_row="1024" xmit_table_max_compaction_time="30000" /> <UNICAST3 conn_close_timeout="5000" xmit_interval="200" xmit_table_num_rows="50" xmit_table_msgs_per_row="1024" xmit_table_max_compaction_time="30000" /> <pbcast.STABLE desired_avg_gossip="2000" max_bytes="1M" /> <pbcast.GMS print_local_addr="false" join_timeout="${jgroups.join_timeout:2000}" /> <UFC max_credits="4m" min_threshold="0.40" /> <MFC max_credits="4m" min_threshold="0.40" /> <FRAG4 /> </stack> </jgroups> <cache-container default-cache="replicatedCache"> <!-- Uses "prod" for cluster transport. --> <transport cluster="${infinispan.cluster.name}" stack="prod" node-name="${infinispan.node.name:}"/> </cache-container> </infinispan>
12.7. 使用外部 JGroups 堆栈
引用在 infinispan.xml
文件中定义自定义 JGroups 堆栈的外部文件。
流程
将自定义 JGroups 堆栈文件添加到
$RHDG_HOME/server/conf
目录中。或者,您可以在声明外部堆栈文件时指定绝对路径。
使用
stack-file
元素引用外部堆栈文件。<infinispan> <jgroups> <!-- Creates a "prod-tcp" stack that references an external file. --> <stack-file name="prod-tcp" path="prod-jgroups-tcp.xml"/> </jgroups> <cache-container default-cache="replicatedCache"> <!-- Use the "prod-tcp" stack for cluster transport. --> <transport stack="prod-tcp" /> <replicated-cache name="replicatedCache"/> </cache-container> <!-- Cache configuration goes here. --> </infinispan>
12.8. 加密集群传输
保护集群传输,以便节点与加密消息通信。您还可以配置 Data Grid 集群来执行证书身份验证,以便只有具有有效身份的节点才能加入。
12.8.1. 使用 TLS 身份保护集群传输
为 Data Grid 服务器安全域添加 SSL/TLS 身份,并使用它们来保护集群传输。Data Grid Server 集群中的节点随后交换 SSL/TLS 证书以加密 JGroups 消息,包括 RELAY 消息(如果您配置跨站点复制)。
先决条件
- 安装 Data Grid Server 集群。
流程
创建一个 TLS 密钥存储,其中包含单个证书来标识 Data Grid 服务器。
如果 PEM 文件包含 PKCS"" 或 PKCS""8 格式的私钥,则可使用证书,并且具有空密码:
password=""
。注意如果密钥存储中的证书没有由公共证书颁发机构(CA)签名,那么您还必须创建一个包含签名证书或公钥的信任存储。
-
将密钥存储添加到
$RHDG_HOME/server/conf
目录中。 将密钥存储添加到 Data Grid Server 配置中的新安全域。
重要您应该创建专用的密钥存储和安全域,以便 Data Grid 服务器端点不使用与集群传输相同的安全域。
<server xmlns="urn:infinispan:server:15.0"> <security> <security-realms> <security-realm name="cluster-transport"> <server-identities> <ssl> <!-- Adds a keystore that contains a certificate that provides SSL/TLS identity to encrypt cluster transport. --> <keystore path="server.pfx" relative-to="infinispan.server.config.path" password="secret" alias="server"/> </ssl> </server-identities> </security-realm> </security-realms> </security> </server>
使用
server:security-realm
属性指定安全域的名称,将集群传输配置为使用安全域。<infinispan> <cache-container> <transport server:security-realm="cluster-transport"/> </cache-container> </infinispan>
验证
当您启动 Data Grid Server 时,以下日志消息表示集群使用安全域进行集群传输:
[org.infinispan.SERVER] ISPN080060: SSL Transport using realm <security_realm_name>
12.8.2. JGroups 加密协议
要保护集群流量,您可以配置 Data Grid 节点,以使用 secret 密钥加密 JGroups 消息有效负载。
Data Grid 节点可以从以下方法获取 secret 密钥:
- 协调器节点(symmetric 加密)。
- 共享密钥存储(symmetric encryption)。
从协调器节点检索 secret 密钥
您可以通过在 Data Grid 配置中的 JGroups 堆栈中添加 ASYM_ENCRYPT
协议来配置非对称加密。这允许 Data Grid 集群生成和分发 secret 密钥。
在使用非对称加密时,您还应提供密钥存储,以便节点能够执行证书身份验证并安全地交换机密密钥。这可保护集群不受中间人(MitM)攻击的影响。
非对称加密保护集群流量,如下所示:
- Data Grid 集群中的第一个节点(coordinator 节点)会生成一个 secret 密钥。
- 加入节点使用协调器执行证书身份验证,以互相验证身份。
- 加入的节点从 coordinator 节点请求 secret 密钥。该请求包含加入节点的公钥。
- 协调器节点使用公钥加密 secret 密钥,并将其返回到加入节点。
- 加入节点解密并安装 secret 密钥。
- 节点加入集群,使用 secret 密钥加密并解密信息。
从共享密钥存储检索 secret 密钥
您可以通过在 Data Grid 配置中的 JGroups 堆栈中添加 SYM_ENCRYPT
协议来配置对称加密。这允许 Data Grid 集群从您提供的密钥存储获取 secret 密钥。
- 节点在启动时从 Data Grid 类路径上的密钥存储安装 secret 密钥。
- 节点加入集群,使用 secret 密钥加密和解密消息。
非对称和对称加密的比较
带有证书身份验证的 ASYM_ENCRYPT
提供了额外的加密层,与 SYM_ENCRYPT
相比。您提供密钥存储来为 secret 密钥加密对协调节点的请求。Data Grid 会自动生成该 secret 密钥并处理集群流量,同时允许您指定何时生成 secret 密钥。例如,您可以配置集群以在节点离开时生成新的 secret 密钥。这样可确保节点无法绕过证书身份验证,并使用旧密钥加入。
另一方面,SYM_ENCRYPT
比 ASYM_ENCRYPT
快,因为节点不需要与集群协调器交换密钥。SYM_ENCRYPT
是没有配置在集群成员资格更改时自动生成新 secret 密钥的潜在缺陷。用户负责生成和分发节点用于加密集群流量的 secret 密钥。
12.8.3. 使用非对称加密保护集群传输
配置 Data Grid 集群,以生成和分发加密 JGroups 消息的 secret 密钥。
流程
- 使用证书链创建密钥存储,使 Data Grid 能够验证节点身份。
将密钥存储放在集群中每个节点的 classpath 上。
对于 Data Grid Server,您要将密钥存储放在 $RHDG_HOME 目录中。
将
SSL_KEY_EXCHANGE
和ASYM_ENCRYPT
协议添加到 Data Grid 配置中的 JGroups 堆栈,如下例所示:<infinispan> <jgroups> <!-- Creates a secure JGroups stack named "encrypt-tcp" that extends the default TCP stack. --> <stack name="encrypt-tcp" extends="tcp"> <!-- Adds a keystore that nodes use to perform certificate authentication. --> <!-- Uses the stack.combine and stack.position attributes to insert SSL_KEY_EXCHANGE into the default TCP stack after VERIFY_SUSPECT2. --> <SSL_KEY_EXCHANGE keystore_name="mykeystore.jks" keystore_password="changeit" stack.combine="INSERT_AFTER" stack.position="VERIFY_SUSPECT2"/> <!-- Configures ASYM_ENCRYPT --> <!-- Uses the stack.combine and stack.position attributes to insert ASYM_ENCRYPT into the default TCP stack before pbcast.NAKACK2. --> <!-- The use_external_key_exchange = "true" attribute configures nodes to use the `SSL_KEY_EXCHANGE` protocol for certificate authentication. --> <ASYM_ENCRYPT asym_keylength="2048" asym_algorithm="RSA" change_key_on_coord_leave = "false" change_key_on_leave = "false" use_external_key_exchange = "true" stack.combine="INSERT_BEFORE" stack.position="pbcast.NAKACK2"/> </stack> </jgroups> <cache-container name="default" statistics="true"> <!-- Configures the cluster to use the JGroups stack. --> <transport cluster="${infinispan.cluster.name}" stack="encrypt-tcp" node-name="${infinispan.node.name:}"/> </cache-container> </infinispan>
验证
当您启动 Data Grid 集群时,以下日志消息表示集群使用 secure JGroups 堆栈:
[org.infinispan.CLUSTER] ISPN000078: Starting JGroups channel cluster with stack <encrypted_stack_name>
只有在它们使用 ASYM_ENCRYPT
且可以从协调器节点获取 secret 密钥时,数据网格节点才能加入集群。否则,以下信息会写入 Data Grid 日志:
[org.jgroups.protocols.ASYM_ENCRYPT] <hostname>: received message without encrypt header from <hostname>; dropping it
12.8.4. 使用对称加密保护集群传输
配置 Data Grid 集群,以使用您提供的密钥存储中的 secret 密钥加密 JGroups 消息。
流程
- 创建包含 secret 密钥的密钥存储。
将密钥存储放在集群中每个节点的 classpath 上。
对于 Data Grid Server,您要将密钥存储放在 $RHDG_HOME 目录中。
-
将
SYM_ENCRYPT
协议添加到 Data Grid 配置中的 JGroups 堆栈。
<infinispan> <jgroups> <!-- Creates a secure JGroups stack named "encrypt-tcp" that extends the default TCP stack. --> <stack name="encrypt-tcp" extends="tcp"> <!-- Adds a keystore from which nodes obtain secret keys. --> <!-- Uses the stack.combine and stack.position attributes to insert SYM_ENCRYPT into the default TCP stack after VERIFY_SUSPECT2. --> <SYM_ENCRYPT keystore_name="myKeystore.p12" keystore_type="PKCS12" store_password="changeit" key_password="changeit" alias="myKey" stack.combine="INSERT_AFTER" stack.position="VERIFY_SUSPECT2"/> </stack> </jgroups> <cache-container name="default" statistics="true"> <!-- Configures the cluster to use the JGroups stack. --> <transport cluster="${infinispan.cluster.name}" stack="encrypt-tcp" node-name="${infinispan.node.name:}"/> </cache-container> </infinispan>
验证
当您启动 Data Grid 集群时,以下日志消息表示集群使用 secure JGroups 堆栈:
[org.infinispan.CLUSTER] ISPN000078: Starting JGroups channel cluster with stack <encrypted_stack_name>
只有在使用 SYM_ENCRYPT
且可以从共享密钥存储获取 secret 密钥时,数据网格节点才能加入集群。否则,以下信息会写入 Data Grid 日志:
[org.jgroups.protocols.SYM_ENCRYPT] <hostname>: received message without encrypt header from <hostname>; dropping it
12.9. 集群流量的 TCP 和 UDP 端口
Data Grid 对集群传输信息使用以下端口:
默认端口 | 协议 | 描述 |
---|---|---|
| TCP/UDP | JGroups 集群绑定端口 |
| UDP | JGroups 多播 |
跨站点复制
Data Grid 为 JGroups RELAY2 协议使用以下端口:
7900
- 对于在 OpenShift 上运行的 Data Grid 集群。
7800
- 如果将 UDP 用于节点间的流量,使用 TCP 作为集群之间的流量。
7801
- 如果将 TCP 用于节点和 TCP 间的流量,用于集群之间的流量。
第 13 章 创建远程缓存
当您在运行时创建远程缓存时,Data Grid 服务器会在集群中同步您的配置,以便所有节点都有副本。因此,您应该始终使用以下机制动态创建远程缓存:
- Data Grid 控制台
- Data Grid 命令行界面(CLI)
- 热 Rod 或 HTTP 客户端
13.1. 默认缓存管理器
Data Grid Server 提供了一个默认的缓存管理器,用于控制远程缓存的生命周期。启动 Data Grid 服务器会自动实例化缓存管理器,以便您可以创建和删除远程缓存和其他资源,如 Protobuf 模式。
启动 Data Grid 服务器并添加用户凭证后,您可以查看缓存管理器的详情,并从 Data Grid 控制台获取集群信息。
-
在任何浏览器中打开
127.0.0.1:11222
。
您还可以通过命令行界面(CLI)或 REST API 获取有关缓存管理器的信息:
- CLI
在 default 容器中运行
describe
命令。[//containers/default]> describe
- REST
-
在任何浏览器中打开
127.0.0.1:11222/rest/v2/container/
。
默认缓存管理器配置
XML
<infinispan> <!-- Creates a Cache Manager named "default" and enables metrics. --> <cache-container name="default" statistics="true"> <!-- Adds cluster transport that uses the default JGroups TCP stack. --> <transport cluster="${infinispan.cluster.name:cluster}" stack="${infinispan.cluster.stack:tcp}" node-name="${infinispan.node.name:}"/> <!-- Requires user permission to access caches and perform operations. --> <security> <authorization/> </security> </cache-container> </infinispan>
JSON
{ "infinispan" : { "jgroups" : { "transport" : "org.infinispan.remoting.transport.jgroups.JGroupsTransport" }, "cache-container" : { "name" : "default", "statistics" : "true", "transport" : { "cluster" : "cluster", "node-name" : "", "stack" : "tcp" }, "security" : { "authorization" : {} } } } }
YAML
infinispan: jgroups: transport: "org.infinispan.remoting.transport.jgroups.JGroupsTransport" cacheContainer: name: "default" statistics: "true" transport: cluster: "cluster" nodeName: "" stack: "tcp" security: authorization: ~
13.2. 使用 Data Grid 控制台创建缓存
使用 Data Grid 控制台从任何 Web 浏览器使用直观的可视化界面创建远程缓存。
先决条件
-
创建具有
admin
权限的 Data Grid 用户。 - 至少启动一个 Data Grid 服务器实例。
- 具有 Data Grid 缓存配置。
流程
-
在任意浏览器中打开
127.0.0.1:11222/console/
。 - 选择 Create Cache 并按照步骤操作,作为 Data Grid Console 指南。
13.3. 使用 Data Grid CLI 创建远程缓存
使用 Data Grid 命令行界面(CLI)在 Data Grid Server 中添加远程缓存。
先决条件
-
创建具有
admin
权限的 Data Grid 用户。 - 至少启动一个 Data Grid 服务器实例。
- 具有 Data Grid 缓存配置。
流程
启动 CLI。
bin/cli.sh
-
运行
connect
命令,并在提示时输入您的用户名和密码。 使用
create cache
命令创建远程缓存。例如,从名为
mycache.xml
的文件创建一个名为 "mycache" 的缓存,如下所示:create cache --file=mycache.xml mycache
验证
使用
ls
命令列出所有远程缓存。ls caches mycache
使用
describe
命令查看缓存配置。describe caches/mycache
13.4. 从 Hot Rod 客户端创建远程缓存
使用 Data Grid Hot Rod API 从 Java、C++、.NET/C#、JS 客户端等在 Data Grid Server 上创建远程缓存。
此流程演示了如何使用 Hot Rod Java 客户端在首次访问时创建远程缓存。您可以在 Data Grid Tutorials 中找到其他 Hot Rod 客户端的代码示例。
先决条件
-
创建具有
admin
权限的 Data Grid 用户。 - 至少启动一个 Data Grid 服务器实例。
- 具有 Data Grid 缓存配置。
流程
-
调用
remoteCache ()
方法,作为ConfigurationBuilder
的一部分。 -
在 classpath 上的
hotrod-client.properties
文件中设置configuration
或configuration_uri
属性。
ConfigurationBuilder
File file = new File("path/to/infinispan.xml") ConfigurationBuilder builder = new ConfigurationBuilder(); builder.remoteCache("another-cache") .configuration("<distributed-cache name=\"another-cache\"/>"); builder.remoteCache("my.other.cache") .configurationURI(file.toURI());
hotrod-client.properties
infinispan.client.hotrod.cache.another-cache.configuration=<distributed-cache name=\"another-cache\"/> infinispan.client.hotrod.cache.[my.other.cache].configuration_uri=file:///path/to/infinispan.xml
如果远程缓存的名称包含 .
字符,则必须在使用 hotrod-client.properties
文件时将其放在方括号中。
13.5. 使用 REST API 创建远程缓存
使用 Data Grid REST API 从任何合适的 HTTP 客户端在 Data Grid Server 上创建远程缓存。
先决条件
-
创建具有
admin
权限的 Data Grid 用户。 - 至少启动一个 Data Grid 服务器实例。
- 具有 Data Grid 缓存配置。
流程
-
使用有效负载中的缓存配置调用
POST
请求到/rest/v2/caches/<cache_name
>。
其他资源
第 14 章 在 Data Grid Server 上运行脚本和任务
向 Data Grid 服务器部署中添加任务和脚本,以便从命令行界面(CLI)和 Hot Rod 或 REST 客户端进行远程执行。您可以将任务作为自定义 Java 类实施,或者以 JavaScript 等语言定义脚本。
14.1. 在 Data Grid 服务器部署中添加任务
将自定义服务器任务类添加到 Data Grid Server。
先决条件
如果 Data Grid Server 正在运行,则停止它。
Data Grid 服务器不支持自定义类的运行时部署。
流程
添加
META-INF/services/org.infinispan.tasks.ServerTask
文件,其中包含服务器任务的完全限定域名,例如:example.HelloTask
- 将服务器任务实施打包到 JAR 文件中。
-
将 JAR 文件复制到 Data Grid Server 安装的
$RHDG_HOME/server/lib
目录中。 - 将您的类添加到 Data Grid 配置中的反序列化允许列表中。或者,使用系统属性设置 allow 列表。
14.1.1. Data Grid Server 任务
Data Grid Server 任务是扩展 org.infinispan.tasks.ServerTask
接口的类,通常包括以下方法调用:
setTaskContext()
-
允许访问执行上下文信息,包括任务参数、执行哪些任务的缓存引用等。在大多数情况下,实施会将此信息存储在本地,并在实际执行任务时使用这些信息。使用
SHARED
实例化模式时,任务应使用ThreadLocal
存储TaskContext
进行并发调用。 getName()
- 返回任务的唯一名称。客户端使用这些名称调用任务。
getExecutionMode()
返回任务的执行模式。
-
TaskExecutionMode.ONE_NODE
仅处理请求的节点执行脚本。虽然脚本仍然可以调用集群操作。这是默认值。 -
TaskExecutionMode.ALL_NODES
Data Grid 使用集群执行器在节点间运行脚本。例如,调用流处理的服务器任务需要在单一节点上执行,因为流处理被分发到所有节点。
-
getInstantiationMode()
返回用于任务的实例化模式。
-
TaskInstantiationMode.SHARED
创建一个单个实例,用于同一服务器上的每个任务执行。这是默认值。 -
TaskInstantiationMode.ISOLATED
为每个调用创建一个新实例。
-
call ()
-
计算结果。此方法在
java.util.concurrent.Callable
接口中定义,并通过服务器任务调用。
服务器任务实施必须遵循服务加载程序模式要求。例如,实现必须具有零参数构造器。
以下 HelloTask
类实施提供了具有一个参数的示例任务。它还演示了使用 ThreadLocal
存储 TaskContext
以进行并发调用。
package example; import org.infinispan.tasks.ServerTask; import org.infinispan.tasks.TaskContext; public class HelloTask implements ServerTask<String> { private static final ThreadLocal<TaskContext> taskContext = new ThreadLocal<>(); @Override public void setTaskContext(TaskContext ctx) { taskContext.set(ctx); } @Override public String call() throws Exception { TaskContext ctx = taskContext.get(); String name = (String) ctx.getParameters().get().get("name"); return "Hello " + name; } @Override public String getName() { return "hello-task"; } }
14.2. 在 Data Grid 服务器部署中添加脚本
使用命令行界面在 Data Grid 服务器中添加脚本。
先决条件
Data Grid 服务器将脚本存储在 ___script_cache
缓存中。如果启用缓存授权,用户必须具有 CREATE
权限才能添加到 ___script_cache
中。
如果您使用默认授权设置,请至少为用户分配 deployer
角色。
流程
根据需要定义脚本。
例如,创建一个名为
multiplication.js
的文件,它在单一 Data Grid 服务器上运行,它有两个参数,并使用 JavaScript 乘以给定值:// mode=local,language=javascript multiplicand * multiplier
- 创建与 Data Grid 的 CLI 连接。
使用
task
命令上传脚本,如下例所示:task upload --file=multiplication.js multiplication
验证您的脚本是否可用。
ls tasks multiplication
14.2.1. Data Grid 服务器脚本
Data Grid 服务器脚本基于 javax.script
API,并与任何基于 JVM 的 ScriptEngine 实施兼容。
您好世界
以下是在单个 Data Grid 服务器上运行的简单示例,具有一个参数,并使用 JavaScript:
// mode=local,language=javascript,parameters=[greetee] "Hello " + greetee
运行前面的脚本时,您将传递 greetee
参数的值,Data Grid 返回 "Hello ${value}"
。
14.2.1.1. 脚本元数据
元数据提供有关在运行脚本时 Data Grid 服务器使用的脚本的附加信息。
脚本元数据是您添加到脚本第一行中的 property=value
对,如下例所示:
// name=test, language=javascript // mode=local, parameters=[a,b,c]
-
使用与脚本语言匹配的注释样式(
//
、;;
,#
)。 -
使用逗号分隔
property=value
对。 - 使用单个(')或双引号(")分隔值。
属性 | 描述 |
---|---|
| 定义执行模式,并具有以下值:
|
| 指定执行脚本的 ScriptEngine。 |
| 指定文件扩展作为设置 ScriptEngine 的替代方法。 |
| 指定用户必须执行脚本的角色。 |
| 指定此脚本的有效参数名称数组。调用指定此列表中未包含的参数会导致异常。 |
| (可选)设置 MediaType (MIME type)来存储数据以及参数和返回值。此属性对仅支持特定数据格式的远程客户端很有用。
目前,您只能设置 |
14.2.1.2. 脚本绑定
Data Grid 将内部对象公开为脚本执行的绑定。
绑定 | 描述 |
---|---|
| 指定运行脚本的缓存。 |
| 指定用于将数据序列化到缓存的 marshaller。 |
|
指定缓存的 |
| 指定运行脚本的脚本管理器的实例。您可以使用此绑定从脚本运行其他脚本。 |
14.2.1.3. 脚本参数
Data Grid 可让您将命名参数传递为运行脚本的绑定。
参数是 name,value
对,其中 name
是一个字符串,value
是 marshaller 可以解释的任何值。
以下示例脚本有两个参数,即 multiplicand
和 multiplier
。脚本采用 multiplicand
的值,并乘以它的值乘以 倍数
。
// mode=local,language=javascript multiplicand * multiplier
当您运行前面的脚本时,Data Grid 会响应表达式评估的结果。
14.2.2. 编程创建脚本
使用 Hot Rod RemoteCache
接口添加脚本,如下例所示:
RemoteCache<String, String> scriptCache = cacheManager.getCache("___script_cache"); scriptCache.put("multiplication.js", "// mode=local,language=javascript\n" + "multiplicand * multiplier\n");
14.3. 运行脚本和任务
使用命令行界面在 Data Grid 服务器部署上运行任务和脚本。或者,您也可以从 Hot Rod 客户端执行脚本和任务。
先决条件
- 为 Data Grid 服务器添加脚本或任务。
流程
- 创建与 Data Grid 的 CLI 连接。
使用
task
命令运行任务和脚本,如下例所示:执行名为
multiplier.js
的脚本并指定两个参数:task exec multiplier.js -Pmultiplicand=10 -Pmultiplier=20 200.0
执行名为
@@cache@names
的任务,以检索所有可用缓存的列表:task exec @@cache@names ["___protobuf_metadata","mycache","___script_cache"]
Programmatic execution
-
调用
execute ()
方法以使用 Hot RodRemoteCache
接口运行脚本,如下例所示:
脚本执行
RemoteCache<String, Integer> cache = cacheManager.getCache(); // Create parameters for script execution. Map<String, Object> params = new HashMap<>(); params.put("multiplicand", 10); params.put("multiplier", 20); // Run the script with the parameters. Object result = cache.execute("multiplication.js", params);
任务执行
// Add configuration for a locally running server. ConfigurationBuilder builder = new ConfigurationBuilder(); builder.addServer().host("127.0.0.1").port(11222); // Connect to the server. RemoteCacheManager cacheManager = new RemoteCacheManager(builder.build()); // Retrieve the remote cache. RemoteCache<String, String> cache = cacheManager.getCache(); // Create task parameters. Map<String, String> parameters = new HashMap<>(); parameters.put("name", "developer"); // Run the server task. String greet = cache.execute("hello-task", parameters); System.out.println(greet);
第 15 章 配置 Data Grid 服务器日志记录
Data Grid 服务器使用 Apache Log4j 2 提供可配置的日志记录机制,用于捕获环境和记录缓存操作以进行故障排除和根本原因分析。
15.1. Data Grid 服务器日志文件
Data Grid 将服务器日志写入 $RHDG_HOME/server/log
目录中的以下文件中:
server.log
-
以人类可读的格式消息,包括与服务器启动相关的引导日志。
当您启动服务器时,Data Grid 会创建此文件。 server.log.json
-
用于解析和分析 Data Grid 日志的 JSON 格式的消息。
当您启用JSON-FILE
附加程序时,Data Grid 会创建此文件。
15.1.1. 配置 Data Grid 服务器日志
Data Grid 使用 Apache Log4j 技术编写服务器日志消息。您可以在 log4j2.xml
文件中配置服务器日志。
流程
-
使用任何文本编辑器打开
$RHDG_HOME/server/conf/log4j2.xml
。 - 根据需要更改服务器日志记录。
-
保存并关闭
log4j2.xml
。
其他资源
15.1.2. 日志级别
日志级别表示消息的性质和严重性。
日志级别 | 描述 |
---|---|
| 细粒度调试消息,通过应用程序捕获单个请求的流。 |
| 用于常规调试的消息,与单个请求无关。 |
| 有关应用程序整体进度的消息,包括生命周期事件。 |
| 可能导致错误或降低性能的事件。 |
| 错误条件可能会阻止操作或活动成功,但不会阻止应用程序运行。 |
| 可能导致关键服务失败和应用程序关闭的事件。 |
除了上面提供的单个消息级别外,配置还允许两个值: ALL
包括所有消息,OFF
排除所有消息。
15.1.3. Data Grid 日志记录类别
Data Grid 为 INFO
,WARN
,ERROR
,FATAL
级别消息提供类别,这些消息按功能区域组织日志。
org.infinispan.CLUSTER
- 特定于 Data Grid 集群的消息,其中包括状态传输操作、重新平衡事件、分区等。
org.infinispan.CONFIG
- 特定于 Data Grid 配置的消息。
org.infinispan.CONTAINER
- 特定于数据容器的消息,包括过期和驱除操作、缓存侦听器通知、事务等。
org.infinispan.PERSISTENCE
- 特定于缓存加载程序和存储的消息。
org.infinispan.SECURITY
- 特定于 Data Grid 安全的消息。
org.infinispan.SERVER
- 特定于 Data Grid 服务器的消息。
org.infinispan.XSITE
- 特定于跨站点复制操作的消息。
15.1.4. 日志附加器
日志附加器定义 Data Grid Server 如何记录日志消息。
- 控制台(CONSOLE)
-
将日志消息写入主机标准输出(
stdout
)或标准错误(stderr
)流。
默认使用org.apache.logging.log4j.core.appender.ConsoleAppender
类。 - FILE
-
将日志消息写入到文件。
默认使用org.apache.logging.log4j.core.appender.RollingFileAppender
类。 - JSON-FILE
-
以 JSON 格式将日志消息写入文件。
默认使用org.apache.logging.log4j.core.appender.RollingFileAppender
类。
15.1.5. 日志模式格式器
CONSOLE
和 FILE
附加器使用 PatternLayout
来根据 模式 格式化日志消息。
示例是 FILE appender 中的默认模式:%d{yyyy-MM-dd HH:mm:ss,SSS} %-5p (%t)[%c pcscd] %m%throwable%n
-
%d{yyyy-MM-dd HH:mm:ss,SSS}
添加了当前的时间和日期。 -
%-5p
指定日志级别,与右侧一致。 -
%
T 添加当前线程的名称。 -
%c device
添加日志记录类别的短名称。 -
%
M 添加日志消息。 -
%throwable
添加异常堆栈追踪。 -
%n
添加新行。
PatternLayout
文档中 完全描述了模式。
15.1.6. 启用 JSON 日志处理程序
Data Grid Server 提供了一个日志处理程序,用于以 JSON 格式编写消息。
先决条件
-
如果 Data Grid Server 正在运行,则停止它。
您无法动态启用日志处理程序。
流程
-
使用任何文本编辑器打开
$RHDG_HOME/server/conf/log4j2.xml
。 取消注释
JSON-FILE
附加器并注释掉FILE
附加器:<!--<AppenderRef ref="FILE"/>--> <AppenderRef ref="JSON-FILE"/>
- (可选)根据需要配置 JSON 附加程序和 JSON 布局。
-
保存并关闭
log4j2.xml
。
当您启动 Data Grid 时,它会在以下文件中将每个日志消息写为 JSON 映射:$RHDG_HOME/server/log/server.log.json
15.2. 访问日志
访问日志将 Hot Rod 和 REST 端点的所有入站客户端请求记录到 $RHDG_HOME/server/log
目录中的文件。
org.infinispan.HOTROD_ACCESS_LOG
-
将 Hot Rod 访问消息写入
hotrod-access.log
文件的日志记录类别。 org.infinispan.REST_ACCESS_LOG
-
将 REST 访问消息写入
rest-access.log
文件的日志记录类别。
15.2.1. 启用访问日志
要记录 Hot Rod、REST 和 Memcached 端点访问信息,您需要在 log4j2.xml
中启用日志类别。
流程
-
使用任何文本编辑器打开
$RHDG_HOME/server/conf/log4j2.xml
。 -
将
org.infinispan.HOTROD_ACCESS_LOG
、org.infinispan.REST_ACCESS_LOG
和org.infinispan.MEMCACHED_ACCESS_LOG
日志记录类别的级别更改为TRACE
。 -
保存并关闭
log4j2.xml
。
<Logger name="org.infinispan.HOTROD_ACCESS_LOG" additivity="false" level="TRACE"> <AppenderRef ref="HR-ACCESS-FILE"/> </Logger>
15.2.2. 访问日志属性
访问日志的默认格式如下:
%X{address} %X{user} [%d{dd/MMM/yyyy:HH:mm:ss Z}] "%X{method} %m %X{protocol}" %X{status} %X{requestSize} %X{responseSize} %X{duration}%n
上述格式会创建日志条目,如下所示:
127.0.0.1 - [DD/MM/YYYY:HH:MM:SS +0000] "PUT /rest/v2/caches/default/key HTTP/1.1" 404 5 77 10
日志记录属性使用 %X{name}
表示法,并允许您修改访问日志的格式。以下是默认日志属性:
属性 | 描述 |
---|---|
|
|
| 主体名称,如果使用身份验证。 |
|
使用协议的具体方法。 |
|
使用的协议。 |
|
REST 端点的 HTTP 状态代码。 |
| 请求的大小(以字节为单位)。 |
| 响应的大小(以字节为单位)。 |
| 服务器处理请求所花费的毫秒数。 |
使用前缀 h:
的标头名称来记录请求中包含的标头,例如 %X{h:User-Agent}
。
15.3. 审计日志
审计日志可让您跟踪对 Data Grid 服务器部署的更改,以便了解何时发生更改以及哪些用户进行更改。启用并配置审计日志记录,以记录服务器配置事件和管理操作。
org.infinispan.AUDIT
-
将安全审计消息写入
$RHDG_HOME/server/log
目录中的audit.log
文件的日志记录类别。
15.3.1. 启用审计日志记录
要记录安全审核消息,您需要在 log4j2.xml
中启用日志记录类别。
流程
-
使用任何文本编辑器打开
$RHDG_HOME/server/conf/log4j2.xml
。 -
将
org.infinispan.AUDIT
日志记录类别的级别更改为INFO
。 -
保存并关闭
log4j2.xml
。
<!-- Set to INFO to enable audit logging --> <Logger name="org.infinispan.AUDIT" additivity="false" level="INFO"> <AppenderRef ref="AUDIT-FILE"/> </Logger>
15.3.2. 配置审计日志记录附加器
Apache Log4j 提供不同的附加程序,可用于将审计消息发送到默认日志文件以外的目标。例如,如果要将审计日志发送到 syslog 守护进程、JDBC 数据库或 Apache Kafka 服务器,您可以在 log4j2.xml
中配置附加程序。
流程
-
使用任何文本编辑器打开
$RHDG_HOME/server/conf/log4j2.xml
。 注释或删除默认的
AUDIT-FILE
滚动文件附加器。<!--RollingFile name="AUDIT-FILE" ... </RollingFile-->
为审计消息添加所需的日志记录附加程序。
例如,您可以为 Kafka 服务器添加日志记录附加程序,如下所示:
<Kafka name="AUDIT-KAFKA" topic="audit"> <PatternLayout pattern="%date %message"/> <Property name="bootstrap.servers">localhost:9092</Property> </Kafka>
-
保存并关闭
log4j2.xml
。
其他资源
15.3.3. 使用自定义审计日志记录实现
如果配置 Log4j attachers 不满足您的需要,您可以创建 org.infinispan.security.AuditLogger
API 的自定义实现。
先决条件
-
根据需要实施
org.infinispan.security.AuditLogger
,并将它打包在 JAR 文件中。
流程
-
将您的 JAR 添加到 Data Grid Server 安装中的
server/lib
目录中。 指定自定义审计日志记录器的完全限定类名称,作为缓存容器安全配置中
authorization
元素上的audit-logger
属性的值。例如,以下配置定义了
my.package.CustomAuditLogger
作为日志记录审计消息的类:<infinispan> <cache-container> <security> <authorization audit-logger="my.package.CustomAuditLogger"/> </security> </cache-container> </infinispan>
第 16 章 为 Data Grid Server 集群执行滚动升级
执行数据网格集群的滚动升级,在不停机或数据丢失的版本之间更改,并通过 Hot Rod 协议迁移数据。
16.1. 设置目标 Data Grid 集群
创建一个使用您计划升级到的 Data Grid 版本的集群,然后使用远程缓存存储将源集群连接到目标集群。
先决条件
- 使用目标集群所需的版本安装 Data Grid Server 节点。
确保目标集群的网络属性不会与源集群的网络属性重叠。您应该在 JGroups 传输配置中为目标和源集群指定唯一名称。根据您的环境,您还可以使用不同的网络接口和端口偏移来分隔目标和源集群。
流程
以 JSON 格式创建远程缓存存储配置,允许目标集群连接到源集群。
远程缓存存储在目标集群上,使用 Hot Rod 协议从源集群检索数据。
{ "remote-store": { "cache": "myCache", "shared": true, "raw-values": true, "security": { "authentication": { "digest": { "username": "username", "password": "changeme", "realm": "default" } } }, "remote-server": [ { "host": "127.0.0.1", "port": 12222 } ] } }
使用 Data Grid 命令行界面(CLI)或 REST API 将远程缓存存储配置添加到目标集群,以便它可以连接到源集群。
CLI:在目标集群中使用
migrate cluster connect
命令。[//containers/default]> migrate cluster connect -c myCache --file=remote-store.json
REST API:使用一个 POST 请求,该请求在有效负载中包含远程存储配置,并带有
rolling-upgrade/source-connection
方法。POST /rest/v2/caches/myCache/rolling-upgrade/source-connection
- 对您要迁移的每个缓存重复前面的步骤。
将客户端切换到目标集群,以便它开始处理所有请求。
- 使用目标集群的位置更新客户端配置。
- 重新启动客户端。
如果您需要迁移索引缓存,您必须首先迁移内部 ___protobuf_metadata
缓存,以便源集群中定义的 .proto 模式也会存在于目标集群上。
其他资源
16.2. 将数据同步到目标集群
当您设置目标 Data Grid 集群并将其连接到源集群时,目标集群可以使用远程缓存存储和按需加载数据的客户端请求。要将数据完全迁移到目标集群,以便您可以停用源集群,您可以同步数据。此操作从源集群读取数据并将其写入目标集群。数据会并行迁移到目标集群中的所有节点,每个节点都接收数据的子集。您必须对要迁移到目标集群的每个缓存执行同步。
先决条件
- 使用适当的 Data Grid 版本设置目标集群。
流程
使用 Data Grid 命令行界面(CLI)或 REST API 开始同步您要迁移到目标集群的每个缓存。
CLI:使用
migrate cluster synchronize
命令。migrate cluster synchronize -c myCache
REST API:将
?action=sync-data
参数与 POST 请求一起使用。POST /rest/v2/caches/myCache?action=sync-data
当操作完成后,Data Grid 使用复制到目标集群的条目总数进行响应。
断开目标集群中的每个节点与源集群的连接。
CLI:使用
migrate cluster disconnect
命令。migrate cluster disconnect -c myCache
REST API:指示 DELETE 请求。
DELETE /rest/v2/caches/myCache/rolling-upgrade/source-connection
后续步骤
同步源集群中的所有数据后,滚动升级过程已完成。现在,您可以停用源集群。
第 17 章 Data Grid 服务器部署故障排除
收集与 Data Grid 服务器部署的诊断信息,并执行故障排除步骤来解决问题。
17.1. 从 Data Grid 服务器获取诊断报告
Data Grid 服务器在 tar.gz
存档中提供聚合报告,其中包含关于服务器实例和主机系统的诊断信息。除了配置和日志文件外,报告还提供有关 CPU、内存、打开文件、网络套接字和路由、线程的详细信息。
流程
- 创建与 Data Grid 服务器的 CLI 连接。
使用
server report
命令下载tar.gz
归档:server report Downloaded report 'infinispan-<hostname>-<timestamp>-report.tar.gz'
命令使用报告名称进行响应,如下例所示:
Downloaded report 'infinispan-<hostname>-<timestamp>-report.tar.gz'
-
将
tar.gz
文件移动到您文件系统的适当位置。 -
使用任何归档工具提取
tar.gz
文件。
17.2. 在运行时更改 Data Grid 服务器日志配置
在运行时修改 Data Grid 服务器的日志记录配置,以临时调整日志记录以排除问题并执行根本原因分析。
通过 CLI 修改日志记录配置是一个仅运行时的操作,这意味着更改:
-
不会保存到
log4j2.xml
文件中。重启服务器节点或整个集群会将日志记录配置重置为log4j2.xml
文件中的默认属性。 - 仅在调用 CLI 时应用到集群中的节点。更改日志记录配置后加入集群的节点使用默认属性。
流程
- 创建与 Data Grid 服务器的 CLI 连接。
使用
日志记录
进行必要的调整。列出服务器上定义的所有附加器:
logging list-appenders
命令提供如下 JSON 响应:
{ "STDOUT" : { "name" : "STDOUT" }, "JSON-FILE" : { "name" : "JSON-FILE" }, "HR-ACCESS-FILE" : { "name" : "HR-ACCESS-FILE" }, "FILE" : { "name" : "FILE" }, "REST-ACCESS-FILE" : { "name" : "REST-ACCESS-FILE" } }
列出服务器上定义的所有日志记录器配置:
logging list-loggers
命令提供如下 JSON 响应:
[ { "name" : "", "level" : "INFO", "appenders" : [ "STDOUT", "FILE" ] }, { "name" : "org.infinispan.HOTROD_ACCESS_LOG", "level" : "INFO", "appenders" : [ "HR-ACCESS-FILE" ] }, { "name" : "com.arjuna", "level" : "WARN", "appenders" : [ ] }, { "name" : "org.infinispan.REST_ACCESS_LOG", "level" : "INFO", "appenders" : [ "REST-ACCESS-FILE" ] } ]
使用
set
子命令添加和修改日志记录器配置例如,以下命令将
org.infinispan
软件包的日志级别设置为DEBUG
:logging set --level=DEBUG org.infinispan
使用
remove
子命令移除现有的日志记录器配置。例如,以下命令删除了
org.infinispan
logger 配置,这意味着改为使用 root 配置:logging remove org.infinispan
17.3. 通过 CLI 收集资源统计信息
您可以使用 stats
命令检查某些 Data Grid Server 资源的 server-collected 统计信息。
从提供统计信息(容器、缓存)或此类资源的路径的资源上下文中使用 stats
命令:
stats
{ "statistics_enabled" : true, "number_of_entries" : 0, "hit_ratio" : 0.0, "read_write_ratio" : 0.0, "time_since_start" : 0, "time_since_reset" : 49, "current_number_of_entries" : 0, "current_number_of_entries_in_memory" : 0, "off_heap_memory_used" : 0, "data_memory_used" : 0, "stores" : 0, "retrievals" : 0, "hits" : 0, "misses" : 0, "remove_hits" : 0, "remove_misses" : 0, "evictions" : 0, "average_read_time" : 0, "average_read_time_nanos" : 0, "average_write_time" : 0, "average_write_time_nanos" : 0, "average_remove_time" : 0, "average_remove_time_nanos" : 0, "required_minimum_number_of_nodes" : -1 }
stats /containers/default/caches/mycache
{ "time_since_start" : -1, "time_since_reset" : -1, "current_number_of_entries" : -1, "current_number_of_entries_in_memory" : -1, "off_heap_memory_used" : -1, "data_memory_used" : -1, "stores" : -1, "retrievals" : -1, "hits" : -1, "misses" : -1, "remove_hits" : -1, "remove_misses" : -1, "evictions" : -1, "average_read_time" : -1, "average_read_time_nanos" : -1, "average_write_time" : -1, "average_write_time_nanos" : -1, "average_remove_time" : -1, "average_remove_time_nanos" : -1, "required_minimum_number_of_nodes" : -1 }
17.4. 通过 REST 访问集群健康状况
通过 REST API 获取 Data Grid 集群健康状况。
流程
调用
GET
请求以检索集群健康状况。GET /rest/v2/container/health
Data Grid 使用 JSON
文档进行响应,如下所示:
{ "cluster_health":{ "cluster_name":"ISPN", "health_status":"HEALTHY", "number_of_nodes":2, "node_names":[ "NodeA-36229", "NodeB-28703" ] }, "cache_health":[ { "status":"HEALTHY", "cache_name":"___protobuf_metadata" }, { "status":"HEALTHY", "cache_name":"cache2" }, { "status":"HEALTHY", "cache_name":"mycache" }, { "status":"HEALTHY", "cache_name":"cache1" } ] }
获取缓存管理器状态,如下所示:
GET /rest/v2/container/health/status
参考
如需更多信息,请参阅 REST v2 (版本 2)API 文档。
17.5. 通过 JMX 访问集群健康状况
通过 JMX 检索 Data Grid 集群运行状况统计信息。
流程
使用任何 JMX 功能工具(如 JConsole)连接到 Data Grid 服务器,并导航到以下对象:
org.infinispan:type=CacheManager,name="default",component=CacheContainerHealth
- 选择 available MBeans 来检索集群健康统计。
第 18 章 参考
18.1. Data Grid Server 8.5.2 Readme
有关 Data Grid Server 14.0.21.Final-redhat-00001 分发的信息。
18.1.1. 要求
Data Grid 服务器需要 JDK 11 或更高版本。
18.1.2. 启动服务器
使用 服务器
脚本运行 Data Grid 服务器实例。
Unix/Linux
$RHDG_HOME/bin/server.sh
Windows
$RHDG_HOME\bin\server.bat
包含用于查看命令参数的-- help
或 -h
选项。
18.1.3. 停止服务器
通过 CLI 使用 shutdown
命令来执行安全关闭。
或者,从终端输入 Ctrl-C,以中断服务器进程或通过 TERM 信号终止它。
18.1.4. 配置
服务器配置扩展了 Data Grid 配置,包括以下特定于服务器的元素:
cache-container
- 定义用于管理缓存生命周期的缓存容器。
端点
- 为客户端协议启用和配置端点连接器。
安全
- 配置端点安全域。
socket-bindings
- 将端点连接器映射到接口和端口。
默认配置文件为 $RHDG_HOME/server/conf/infinispan.xml
。
infinispan.xml
- 提供配置,以使用启用了统计信息和授权的默认缓存容器运行 Data Grid 服务器。演示如何使用安全域设置身份验证和授权。
Data Grid 提供其他随时可用的配置文件,它们主要用于开发和测试目的。
$RHDG_HOME/server/conf/
提供以下配置文件:
infinispan-dev-mode.xml
-
配置 Data Grid 服务器,专门用于使用 IP 多播发现的跨站点复制。该配置提供了
BASIC
身份验证,以连接到 Hot Rod 和 REST 端点。配置是为开发模式而设计的,不应在生产环境中使用。 infinispan-local.xml
- 在没有集群功能的情况下配置 Data Grid 服务器。
infinispan-xsite.xml
- 在单一主机上配置跨站点复制,并使用 IP 多播进行发现。
infinispan-memcached.xml
- 将 Data Grid 服务器配置为默认 Memcached 服务器,侦听端口 11221 且没有身份验证。
infinispan-resp.xml
- 将 Data Grid 服务器配置为的行为与默认 Redis 服务器类似,侦听端口 6379 且没有身份验证。
log4j2.xml
- 配置 Data Grid 服务器日志记录。
使用带有 -c
参数的不同配置文件,如下例所示:
Unix/Linux
$RHDG_HOME/bin/server.sh -c infinispan-local.xml
Windows
$RHDG_HOME\bin\server.bat -c infinispan-local.xml
18.1.5. 绑定地址
默认情况下,Data Grid 服务器绑定到网络上的环回 IP 地址 localhost
。
使用 -b
参数设置不同的 IP 地址,如下例所示:
Unix/Linux
$RHDG_HOME/bin/server.sh -b 0.0.0.0
Windows
$RHDG_HOME\bin\server.bat -b 0.0.0.0
18.1.6. 绑定端口
默认情况下,Data Grid 服务器侦听端口 11222
。
使用 -p
参数设置替代端口:
Unix/Linux
$RHDG_HOME/bin/server.sh -p 30000
Windows
$RHDG_HOME\bin\server.bat -p 30000
18.1.7. 集群地址
Data Grid 服务器配置定义了集群传输,同一网络上的多个实例会互相发现,并自动组成集群。
使用 -k
参数更改集群流量的 IP 地址:
Unix/Linux
$RHDG_HOME/bin/server.sh -k 192.168.1.100
Windows
$RHDG_HOME\bin\server.bat -k 192.168.1.100
18.1.8. 集群堆栈
JGroups 堆栈配置集群传输的协议。Data Grid 服务器默认使用 tcp
堆栈。
将替代集群堆栈与 -j
参数一起使用,如下例所示,它使用 UDP 进行集群传输:
Unix/Linux
$RHDG_HOME/bin/server.sh -j udp
Windows
$RHDG_HOME\bin\server.bat -j udp
18.1.9. 身份验证
Data Grid 服务器需要身份验证。
使用 CLI 创建用户名和密码,如下所示:
Unix/Linux
$RHDG_HOME/bin/cli.sh user create username -p "qwer1234!"
Windows
$RHDG_HOME\bin\cli.bat user create username -p "qwer1234!"
18.1.10. 服务器主目录
Data Grid 服务器使用 infinispan.server.home.path
来查找主机文件系统上服务器分发的内容。
服务器主目录称为 $RHDG_HOME
,包含以下文件夹:
├── bin ├── boot ├── docs ├── lib ├── server └── static
目录 | 描述 |
---|---|
| 包含用于启动服务器和 CLI 的脚本。 |
|
包含要引导服务器的 |
| 提供配置示例、架构、组件许可证和其他资源。 |
|
包含服务器在内部所需的 |
| 为 Data Grid 服务器实例提供根文件夹。 |
| 包含 Data Grid 控制台的静态资源。 |
18.1.11. 服务器根目录
Data Grid 服务器使用 infinispan.server.root.path
来查找 Data Grid 服务器实例的配置文件和数据。
您可以在同一目录或不同的目录中创建多个服务器根文件夹,然后使用 -s
or-- server-root
参数指定位置,如下例所示:
Unix/Linux
$RHDG_HOME/bin/server.sh -s server2
Windows
$RHDG_HOME\bin\server.bat -s server2
每个服务器根目录包含以下文件夹:
├── server │ ├── conf │ ├── data │ ├── lib │ └── log
目录 | 描述 | 系统属性覆盖 |
---|---|---|
| 包含服务器配置文件。 |
|
| 包含按容器名称组织的数据文件。 |
|
|
包含服务器扩展文件。 |
|
| 包含服务器日志文件。 |
|
18.1.12. 日志记录
使用 server/conf
文件夹中的 log4j2.xml
文件配置 Data Grid 服务器日志记录。
使用 --logging-config=<path_to_logfile
> 参数使用自定义路径,如下所示:
Unix/Linux
$RHDG_HOME/bin/server.sh --logging-config=/path/to/log4j2.xml
为确保自定义路径生效,请不要使用 ~
快捷方式。
Windows
$RHDG_HOME\bin\server.bat --logging-config=path\to\log4j2.xml