Data Grid 服务器指南


Red Hat Data Grid 8.5

部署、保护和管理网格服务器部署

Red Hat Customer Content Services

摘要

安装和配置数据网格服务器部署。

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 文件)和配置文件的存档。

流程

  1. 访问红帽客户门户。
  2. 软件下载部分 下载 Red Hat Data Grid 8.5 Server。
  3. 运行 md5sumsha256sum 命令,并将服务器下载归档作为参数,例如:

    sha256sum jboss-datagrid-${version}-server.zip
  4. 与 Data Grid Software Details 页面中的 MD5SHA-256 checksum 值进行比较。

参考

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,则不会设置 XmxXms,因为这些值是从容器设置自动计算为容器大小的 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 服务器实例。

先决条件

  • 下载并安装服务器分发。

流程

  1. $RHDG_HOME 中打开一个终端。
  2. 使用 服务器 脚本启动 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

验证

  1. 在任意浏览器中打开 127.0.0.1:11222/console/
  2. 在提示符处输入您的凭证,并继续到 Data Grid Console。

1.6. 在启动时传递数据网格服务器配置

在启动 Data Grid 服务器时指定自定义配置。

Data Grid 服务器可以解析您在启动时使用 --server-config 参数覆盖的多个配置文件。您可以根据需要按任何顺序使用任意数量的配置覆盖文件。配置覆盖文件:

  • 必须是有效的 Data Grid 配置,并且包含根服务器 元素 或字段。
  • 只要您的覆盖文件组合形成完整的配置,就不需要完全配置。
重要

Data Grid 服务器不会检测覆盖文件之间的冲突配置。每个覆盖文件覆盖上述配置中的任何冲突配置。

注意

如果您在启动时将缓存配置传递给 Data Grid 服务器,则不会在集群中动态创建这些缓存。您必须手动将缓存传播到每个节点。

此外,您在启动时传递给 Data Grid 服务器的缓存配置必须包含 infinispancache-container 元素。

先决条件

  • 下载并安装服务器分发。
  • 将自定义服务器配置添加到 Data Grid Server 安装的 server/conf 目录中。

流程

  1. $RHDG_HOME 中打开一个终端。
  2. 使用 --server-config= or - c 参数指定一个或多个配置文件,例如:

    bin/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。

流程

  1. $RHDG_HOME 中打开一个终端。
  2. 使用 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 用户。

流程

  1. 创建与 Data Grid 的 CLI 连接。
  2. 使用 用户角色 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 用户。

流程

  1. 创建与 Data Grid 的 CLI 连接。
  2. 使用 user create 命令创建组。

    1. 使用 --groups 参数指定组名称。
    2. 为组设置用户名和密码。

      user create --groups=developers developers -p changeme
  3. 列出组。

    user ls --groups
  4. 为组授予角色。

    user roles grant --roles=application developers
  5. 列出组的角色。

    user roles ls developers
  6. 一次将用户添加到组中。

    user groups john --groups=developers

验证

打开 groups.properties 并确认组存在。

cat server/conf/groups.properties

1.7.3. Data Grid 用户角色和权限

Data Grid 包括多个角色,为用户提供访问缓存和数据网格资源的权限。

角色权限描述

admin

ALL

具有所有权限的超级用户,包括控制缓存管理器生命周期。

deployer

ALL_READ、ALL_WRITE、LISTEN、EXEC、MONITOR、CREATE

除了 应用程序 权限外,还可创建和删除 Data Grid 资源。

application

ALL_READ, ALL_WRITE, LISTEN, EXEC, MONITOR

观察者 权限外,还具有对 Data Grid 资源的读写访问权限。也可以侦听事件并执行服务器任务和脚本。

observer

ALL_READ, MONITOR

除了监控权限外,还具有对 Data Grid 资源 的读取访问权限。

monitor

MONITOR

可以通过 JMX 和 指标端点 查看统计信息。

1.8. 验证集群视图

同一网络上的数据网格服务器实例会自动发现彼此并组成集群。

完成此流程,使用本地运行 Data Grid 服务器实例的默认 TCP 堆栈中的 MPING 协议观察集群发现。如果要针对自定义网络要求调整集群传输,请参阅设置 Data Grid 集群的文档。

注意

此流程旨在演示集群发现的原则,它不适用于生产环境。在命令行中指定端口偏移等操作不是为生产环境配置集群传输的可靠方法。

先决条件

运行一个 Data Grid 服务器的一个实例。

流程

  1. $RHDG_HOME 中打开一个终端。
  2. 将根目录复制到 server2

    cp -r server server2
  3. 指定端口偏移和 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 服务器

停止单独运行的服务器,或者安全地关闭集群。

流程

  1. 创建与 Data Grid 的 CLI 连接。
  2. 使用以下方法之一关闭 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. 服务器根目录

除了 bindocs 文件夹中的资源外,您应当与之交互的 $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>

配置元素或属性描述

socket-bindings

包含所有网络接口和端口的 root 元素,Data Grid 服务器端点可以绑定和侦听客户端连接。

default-interface

声明 Data Grid 服务器默认侦听的网络接口。

port-offset

指定 Data Grid 服务器应用到套接字绑定的端口声明的偏移。

socket-binding

将 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/2310.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/16240.0.0.0/4
  • IPv6: fc00::/7fe80::/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 服务器提供网络端点,允许客户端访问不同的协议。

端口协议描述

11222

TCP

热 Rod 和 REST

11221

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. 端点协议的比较

 热 RodHTTP / RESTMemcachedRESP

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 属性。

3.2. 配置 Data Grid 服务器端点

控制不同的协议端点如何绑定到套接字,并使用安全域配置。您还可以配置多个端点并禁用管理功能。

注意

每个唯一的端点配置必须包含 Hot Rod 连接器和 REST 连接器。Data Grid 服务器在 端点 配置中隐式包括 hotrod-connectorrest-connector 元素或字段。您应该只将这些元素添加到自定义配置中,以指定端点的身份验证机制。

先决条件

  • 在您的 Data Grid 服务器配置中添加套接字绑定和安全域。

流程

  1. 打开 Data Grid Server 配置以进行编辑。
  2. 使用 endpoint 元素嵌套多个 端点配置
  3. 指定端点用于 socket-binding 属性的套接字绑定。
  4. 指定端点用于 security-realm 属性的安全域。
  5. 如果需要,禁用具有 admin="false" 属性的管理员访问权限。

    使用这个配置,用户无法从端点访问 Data Grid 控制台或命令行界面(CLI)。

  6. 保存对配置的更改。
多个端点配置

以下 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 连接器配置为使用套接字绑定和安全域。

hotrod-connector

在端点配置中包含 Hot Rod 端点

rest-connector

在端点配置中包含 REST 端点

resp-connector

在端点配置中包含 RESP 端点

memcached-connector

在端点配置中包含 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/810/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.0192.168.103.255 的 1024 个 IPv4 地址。
  • IPv6 块 2001:db8::/48 代表 2001:db8:0:0:0:0:0:02001:db8:0:ffff:ffff:ffff:ffff:ffff
  • ::1/128 代表 IPv6 环回地址。其前缀长度为 128,地址为位数。
IP 地址过滤器配置

在以下配置中,Data Grid 服务器仅接受来自 192.168.0.0/1610.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)。

流程

  1. 创建与 Data Grid 服务器的 CLI 连接。
  2. 根据需要,检查并修改 IP 过滤器规则 服务器连接器 ipfilter 命令。

    1. 列出集群中连接器上活跃的所有 IP 过滤规则:

      server connector ipfilter ls endpoint-default
    2. 在集群中设置 IP 过滤规则。

      注意

      此命令替换任何现有规则。

      server connector ipfilter set endpoint-default --rules=ACCEPT/192.168.0.0/16,REJECT/10.0.0.0/8`
    3. 删除所有集群中的连接器上的 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-connectorrest-connector 元素或字段。例如,如果您明确声明了 hotrod-connector,还必须声明 rest-connector,即使它没有配置身份验证机制。

先决条件

  • 根据需要,将安全域添加到您的 Data Grid 服务器配置。

流程

  1. 打开 Data Grid Server 配置以进行编辑。
  2. 添加 endpoint 元素或字段,并指定它与 security-realm 属性一起使用的安全域。
  3. 添加 hotrod-connector 元素或字段来配置 Hot Rod 端点。

    1. 添加 authentication 元素或字段。
    2. 为 Hot Rod 端点指定 SASL 身份验证机制,以用于 sasl 机制 属性。
    3. 如果适用,使用 qop 属性指定保护设置的 SASL 质量。
    4. 如有必要,使用 server-name 属性指定 Data Grid 服务器身份。
  4. 添加 rest-connector 元素或字段来配置 REST 端点。

    1. 添加 authentication 元素或字段。
    2. 为 REST 端点指定用于 mechanism 属性的 HTTP 身份验证机制
  5. 保存对配置的更改。
身份验证机制配置

以下配置指定了用于身份验证的 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 安全配置中禁用授权。

流程

  1. 打开 Data Grid Server 配置以进行编辑。
  2. 从 endpoint 元素或字段中删除 security-realm 属性。
  3. cache-container 的安全配置和每个缓存配置中删除任何 授权 元素。
  4. 保存对配置的更改。

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 端点启用 GSSAPIGS2-KRB5 身份验证机制。

重要

目前,您不能将轻量级目录访问协议(LDAP)协议与 DIGESTSCRAM 身份验证机制一起使用,因为这些机制需要访问特定的散列密码。

热 Rod 端点

当您的配置包含对应的安全域时,Data Grid 服务器为 Hot Rod 端点启用以下 SASL 身份验证机制:

安全域SASL 身份验证机制

属性域和 LDAP 域

SCRAM摘要

令牌域

OAUTHBEARER

信任域

EXTERNAL

Kerberos 身份

GSSAPI, GS2-KRB5

SSL/TLS 身份

PLAIN

REST 端点

当您的配置包含对应的安全域时,Data Grid 服务器为 REST 端点启用以下 HTTP 身份验证机制:

安全域HTTP 身份验证机制

属性域和 LDAP 域

摘要

令牌域

BEARER_TOKEN

信任域

CLIENT_CERT

Kerberos 身份

SPNEGO

SSL/TLS 身份

BASIC

memcached 端点

当您的配置包含对应的安全域时,Data Grid 服务器为 Memcached 二进制协议端点启用以下 SASL 身份验证机制:

安全域SASL 身份验证机制

属性域和 LDAP 域

SCRAM摘要

令牌域

OAUTHBEARER

信任域

EXTERNAL

Kerberos 身份

GSSAPI, GS2-KRB5

SSL/TLS 身份

PLAIN

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 验证机制:

身份验证机制描述安全域类型相关详情

PLAIN

以纯文本格式使用凭据。您应该只在加密连接中使用 PLAIN 身份验证。

属性域和 LDAP 域

BASIC HTTP 机制类似。

DIGESTJPEG

使用哈希算法和非ce 值。热 Rod 连接器支持 DIGEST-MD 5、DIGEST-SHA -256、DIGEST-SHA-256DIGEST-SHA-384DIGEST-SHA-512 哈希算法,以强度顺序。

属性域和 LDAP 域

Digest HTTP 机制类似。

SCRAM-*

除了哈希算法和非ce 值外,还使用 salt 值。热 Rod 连接器支持 SCRAM-SHASCRAM-SHA-256SCRAM-SHA-384SCRAM-SHA-512 哈希算法(按强度排序)。

属性域和 LDAP 域

Digest HTTP 机制类似。

GSSAPI

使用 Kerberos 票据并需要一个 Kerberos 域控制器。您必须在 realm 配置中添加对应的 kerberos 服务器身份。在大多数情况下,您还指定一个 ldap-realm 来提供用户成员资格信息。

Kerberos realm

SPNEGO HTTP 机制类似。

GS2-KRB5

使用 Kerberos 票据并需要一个 Kerberos 域控制器。您必须在 realm 配置中添加对应的 kerberos 服务器身份。在大多数情况下,您还指定一个 ldap-realm 来提供用户成员资格信息。

Kerberos realm

SPNEGO HTTP 机制类似。

EXTERNAL

使用客户端证书。

信任存储域

CLIENT_CERT HTTP 机制类似。

OAUTHBEARER

使用 OAuth 令牌并需要一个 token-realm 配置。

令牌域

与EARER _TOKEN HTTP 机制类似。

4.3.2. SASL 质量保护(QoP)

如果 SASL 机制支持完整性和隐私保护(QoP)设置,您可以使用 qop 属性将它们添加到 Hot Rod 和 Memcached 端点配置中。

QoP 设置描述

auth

仅进行身份验证。

auth-int

使用完整性保护进行身份验证。

auth-conf

通过完整性和隐私保护进行身份验证。

4.3.3. SASL 策略

SASL 策略提供对 Hot Rod 和 Memcached 身份验证机制的精细控制。

提示

Data Grid 缓存授权根据角色和权限限制对缓存的访问。配置缓存授权,然后设置 &lt ;no-anonymous value=false /& gt; 以允许匿名登录,并将访问逻辑委派给缓存授权。

policy描述默认值

forward-secrecy

仅使用支持会话间转发保密的 SASL 机制。这意味着,破坏一个会话不会自动提供破坏未来会话的信息。

false

pass-credentials

仅使用需要客户端凭证的 SASL 机制。

false

no-plain-text

不要使用容易受到简单普通被动攻击的 SASL 机制。

false

no-active

不要使用容易被活跃、非字典攻击的 SASL 机制。

false

no-dictionary

不要使用容易受到被动字典攻击的 SASL 机制。

false

no-anonymous

不要使用接受匿名登录的 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 身份验证机制:

身份验证机制描述安全域类型相关详情

BASIC

以纯文本格式使用凭据。您应该只使用带有加密连接的 BASIC 身份验证。

属性域和 LDAP 域

对应于 基本 HTTP 验证方案,类似于 PLAIN SASL 机制。

摘要

使用哈希算法和非ce 值。REST 连接器支持 SHA-512SHA-256MD5 哈希算法。

属性域和 LDAP 域

对应于 Digest HTTP 验证方案,类似于 DIGESTGPU SASL 机制。

SPNEGO

使用 Kerberos 票据并需要一个 Kerberos 域控制器。您必须在 realm 配置中添加对应的 kerberos 服务器身份。在大多数情况下,您还指定一个 ldap-realm 来提供用户成员资格信息。

Kerberos realm

对应于 Negotiate HTTP 验证方案,类似于 GSSAPIGS2-KRB5 SASL 机制。

BEARER_TOKEN

使用 OAuth 令牌并需要一个 token-realm 配置。

令牌域

对应于 Bearer HTTP 身份验证方案,类似于 OAUTHBEARER SASL 机制。

CLIENT_CERT

使用客户端证书。

信任存储域

EXTERNAL SASL 机制类似。

第 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 向属性域添加凭证只会在您连接的服务器实例上创建用户。您必须在属性域中手动将凭证同步到集群中的每个节点。

流程

  1. 打开 Data Grid Server 配置以进行编辑。
  2. 使用安全配置中的 security -realms 元素,使其包含多个安全域。
  3. 添加一个带有 security-realm 元素的安全域,并为它赋予 name 属性的唯一名称。

    要遵循示例,请创建一个名为 application-realm 的安全域,另一个名为 management-realm

  4. 为 Data Grid 服务器提供 TLS/SSL 识别,并提供 server-identities 元素,并根据需要配置密钥存储。
  5. 通过添加以下元素或字段来指定安全域的类型:

    • properties-realm
    • ldap-realm
    • token-realm
    • truststore-realm
  6. 指定您根据需要配置的安全域类型的属性。

    要遵循示例,请使用 user- properties group-properties 元素或字段上的 path 属性指定您使用 CLI 创建的 dcproperties 文件。

  7. 如果您在配置中添加多种不同类型的安全域,请包含 distributed-realm 元素或字段,以便 Data Grid 服务器使用域并相互组合。
  8. 配置 Data Grid 服务器端点,以使用带有 security-realm 属性的安全域。
  9. 保存对配置的更改。
多个属性域

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 服务。

流程

  1. 为 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
  2. 将 keytab 文件复制到 Data Grid Server 安装的 server/conf 目录中。
  3. 打开 Data Grid Server 配置以进行编辑。
  4. 在 Data Grid 服务器安全域中添加 server-identities 定义。
  5. 指定为 Hot Rod 和 REST 连接器提供服务主体的 keytab 文件的位置。
  6. 将 Kerberos 服务主体命名为。
  7. 保存对配置的更改。
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-MD5DIGEST 身份验证机制预先摘要密码。
  • 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://hostname:portldaps://hostname:port 用于使用 TLS 的安全连接。

主体

在 LDAp 服务器中指定有效用户的可分辨名称(DN)。DN 在 LDAP 目录结构中唯一标识用户。

credential

对应于与上述主体关联的密码。

重要

LDAP 连接的主体必须具有必要的特权,才能执行 LDAP 查询和访问特定属性。

提示

启用 连接池可显著提高 LDAP 服务器身份验证的性能。连接池机制由 JDK 提供。如需更多信息,请参阅 连接池配置和 Java Tutorials:池

5.4.2. LDAP 域用户验证方法

在 LDAP 域中配置用户验证方法。

LDAP 域可以通过两种方式验证用户:

散列化密码比较

通过比较存储在用户密码属性中的散列密码(通常为 userPassword

直接验证

使用提供的凭证对 LDAP 服务器进行身份验证

直接验证是与 Active Directory 搭配使用的唯一方法,因为禁止访问 password 属性。

重要

您不能使用通过 direct-verification 属性执行哈希的端点身份验证机制,因为此方法需要以明文形式提供密码。因此,您必须将 BASIC 身份验证机制与 REST 端点一起使用,并将 PLAIN 与 Hot Rod 端点一起使用,才能与 Active Directory Server 集成。更安全的替代方案是使用 Kerberos,它允许 SPNEGOGSSAPIGS2-KRB5 身份验证机制。

LDAP 域搜索目录以查找与经过身份验证的用户对应的条目。rdn-identifier 属性指定一个 LDAP 属性,它根据提供的标识符查找用户条目,通常是用户名;例如,uidsAMAccountName 属性。向配置中添加 search-recursive="true" 以递归搜索目录。默认情况下,搜索用户条目使用 (rdn_identifier={0}) 过滤器。您可以使用 filter-name 属性指定不同的过滤器。

5.4.3. 将用户条目映射到其关联的组

在 LDAP 域配置中,指定 attribute-mapping 元素以检索和关联用户所属的所有组。

成员资格信息通常以两种方式存储:

  • 在组条目下,通常具有 member 属性中的 class groupOfNamesgroupOfUniqueNames。这是除 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="(&amp;(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 身份验证机制获取的主体,如 GSSAPIGS2-KRB5Negotiate 通常包括域名,例如 myuser@INFINISPAN.ORG。在 LDAP 查询中使用这些主体前,需要转换它们以确保其兼容性。这个过程被称为重写。

网格包括以下转换器:

case-principal-transformer

将主体重写为所有大写或所有小写。例如,MyUser 将以大写模式和 myuser 模式重写为 MYUSER

common-name-principal-transformer

以 LDAP Distinguished Name 格式重写主体(由 RFC 4514定义)。它提取 CN (commonName)类型的第一个属性。例如,DN=CN=myuser,OU=myorg,DC=mydomain 将重写为 myuser

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 用户是 adminmonitor 组的成员。

当使用密码 strongPassword 验证用户 root 的请求时,会在其中一个端点上执行以下操作:

  • 使用所选主体转换器(可选)重写用户名。
  • realm 在 ou=People,dc=infinispan,dc=org 树中搜索,其 uid 属性等于 root,并查找 DN uid=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=orgcn=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="(&amp;(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 和/或 iPAddresssubjectAltName 扩展,以便客户端可以根据 RFC 2818 规格定义的规则正确执行主机名验证。如果使用不包括此类扩展的证书启动,服务器将发出警告。

重要

在生产环境中,服务器证书应由受信任的证书颁发机构( Root 或 Intermediate CA)签名。

提示

如果以下两者都包含,您可以使用 PEM 文件作为密钥存储:

  • PKCS1/ 或 PKCS""8 格式的私钥。
  • 一个或多个证书。

您还应该使用空密码配置 PEM 文件密钥存储(password="")。

流程

  1. 打开 Data Grid Server 配置以进行编辑。
  2. 将包含 Data Grid 服务器的 SSL/TLS 身份的密钥存储添加到 $RHDG_HOME/server/conf 目录中。
  3. 在 Data Grid Server 安全域中添加 server-identities 定义。
  4. 使用 path 属性指定密钥存储文件名。
  5. 使用 keystore-passwordalias 属性提供密钥存储密码和证书别名。
  6. 保存对配置的更改。

后续步骤

使用信任存储配置客户端,以便它们能够验证 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 客户端中直接使用的证书。

流程

  1. 打开 Data Grid Server 配置以进行编辑。
  2. 在服务器配置中包含 keystore 元素的 generate-self-signed-certificate-host 属性。
  3. 指定服务器证书的主机名作为值。
  4. 保存对配置的更改。
生成的密钥存储配置

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 协议的特定版本以及协议中的特定加密套件。

流程

  1. 打开 Data Grid Server 配置以进行编辑。
  2. engine 元素添加到 Data Grid 服务器的 SSL 配置中。
  3. 将 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" />
  4. 将 Data Grid 配置为使用带有 enabled-ciphersuites 属性(TLSv1.2 和 below)和 enabled-ciphersuites-tls13 属性(用于 TLSv1.3)的一个或多个密码套件。

    您必须确保设置了支持您计划使用的任何协议功能的密码套件;例如 HTTP/2 ALPN

  5. 保存对配置的更改。
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 数据库中安装证书。

流程

  1. 打开 Data Grid Server 配置以进行编辑。
  2. 在 Data Grid Server 安全域中添加 server-identities 定义。
  3. 使用 SunPKCS11-NSS-FIPS 供应商指定 PKCS11 密钥存储。
  4. 保存对配置的更改。
密钥存储配置

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 格式创建包含证书的密钥存储。

流程

  1. 下载 Bouncy Castle FIPS JAR 文件,并将该文件添加到 Data Grid Server 安装的 server/lib 目录中。
  2. 要安装 Bouncy Castle,请发出 install 命令:

    [disconnected]> install org.bouncycastle:bc-fips:1.0.2.3
  3. 打开 Data Grid Server 配置以进行编辑。
  4. 在 Data Grid Server 安全域中添加 server-identities 定义。
  5. 使用 BCFIPS 提供程序指定 BCFKS 密钥存储。
  6. 保存对配置的更改。
密钥存储配置

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=""

流程

  1. 打开 Data Grid Server 配置以进行编辑。
  2. require-ssl-client-auth="true" 参数添加到您的 端点 配置中。
  3. 将客户端信任存储添加到 $RHDG_HOME/server/conf 目录中。
  4. 在 Data Grid Server 安全域配置中,指定 truststore 元素 的路径 和密码 属性。
  5. 如果您希望 Data Grid 服务器验证每个客户端证书,请将 < truststore-realm /> 元素添加到安全域中。
  6. 保存对配置的更改。

后续步骤

  • 如果使用安全角色和权限控制访问权限,请在 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"

其他资源

6.4. 使用客户端证书配置授权

启用客户端证书身份验证意味着您不需要在客户端配置中指定 Data Grid 用户凭证,这意味着您必须将角色与客户端证书中的通用名称(CN)字段关联。

先决条件

  • 为客户端提供包含其公共证书的 Java 密钥存储或证书链的一部分,通常是公共 CA 证书。
  • 配置 Data Grid 服务器,以执行客户端证书身份验证。

流程

  1. 打开 Data Grid Server 配置以进行编辑。
  2. 在安全授权配置中启用 common-name-role-mapper
  3. 从客户端证书分配具有适当权限的角色的通用名称(CN)。
  4. 保存对配置的更改。
注意

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 进程的用户读取。

流程

  1. $RHDG_HOME 中打开一个终端。
  2. 创建密钥存储,并使用 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!"
  3. 检查别名是否已添加到密钥存储。

    bin/cli.sh credentials ls -p "secret1234!"
    dbpassword
  4. 打开 Data Grid Server 配置以进行编辑。
  5. 配置 Data Grid,以使用凭据密钥存储。

    1. 在安全 配置中添加 credential-stores 部分。
    2. 指定凭据密钥存储的名称和位置。
    3. 指定使用 明文-text-credential 配置访问凭据密钥存储的密码。

      注意

      除了将凭据密钥存储的明文密码添加到 Data Grid Server 配置中,而是使用外部命令或屏蔽的密码来获得额外的安全性。

      您还可以在一个凭证存储中使用密码作为另一个凭证存储的 master 密码。

  6. 在 Data Grid 服务器用来与外部系统(如数据源或 LDAP 服务器)连接的配置中引用凭据密钥存储。

    1. 添加 credentials-reference 部分。
    2. 使用 store 属性指定凭据密钥存储的名称。
    3. 使用 alias 属性指定密码别名。

      提示

      credential-reference 配置中的属性是可选的。

      • 只有在您有多个密钥存储时才需要 存储
      • 只有密钥存储包含多个密码别名时才需要 alias
  7. 保存对配置的更改。

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 包括多个角色,为用户提供访问缓存和数据网格资源的权限。

角色权限描述

admin

ALL

具有所有权限的超级用户,包括控制缓存管理器生命周期。

deployer

ALL_READ、ALL_WRITE、LISTEN、EXEC、MONITOR、CREATE

除了 应用程序 权限外,还可创建和删除 Data Grid 资源。

application

ALL_READ, ALL_WRITE, LISTEN, EXEC, MONITOR

观察者 权限外,还具有对 Data Grid 资源的读写访问权限。也可以侦听事件并执行服务器任务和脚本。

observer

ALL_READ, MONITOR

除了监控权限外,还具有对 Data Grid 资源 的读取访问权限。

monitor

MONITOR

可以通过 JMX 和 指标端点 查看统计信息。

8.1.1. 权限

用户角色是具有不同访问级别的权限集。

表 8.1. 缓存管理器权限

权限

功能

描述

配置

defineConfiguration

定义新的缓存配置。

LISTEN

addListener

针对缓存管理器注册监听程序。

生命周期

stop

停止缓存管理器。

CREATE

createCache, removeCache

创建和删除容器资源,如缓存、计数器、模式和脚本。

MONITOR

getStats

允许访问 JMX 统计信息和 指标端点

ALL

-

包括所有缓存管理器权限。

表 8.2. 缓存权限

权限

功能

描述

READ

Get包含

从缓存检索条目。

放置 , put IfAbsent,replace,remove,eviction

写入、替换、删除、驱除缓存中的数据。

EXEC

distexec,stream

允许针对缓存执行代码。

LISTEN

addListener

针对缓存注册监听程序。

BULK_READ

keySet,values,entrySet,query

执行批量检索操作。

BULK_WRITE

清除,putAll

执行批量写入操作。

生命周期

启动,stop

启动和停止缓存。

ADMIN

getVersion,addInterceptor*, removeInterceptor,getInterceptorChain,getEvictionManager,getComponentRegistry,getDistributionManager,getAuthorizationManager,evict,getRpcManager,getCacheConfiguration,getCacheManager, getInvocationContextContainer,setAvailability,getDataContainer,getStats,getXAResource

允许访问底层组件和内部结构。

MONITOR

getStats

允许访问 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 启用集群角色映射程序和集群权限映射程序。要将不同的实现用于角色映射,您必须配置角色映射程序。

流程

  1. 打开 Data Grid 配置以进行编辑。
  2. 在 Cache Manager 配置中,将角色映射器声明为安全授权的一部分。
  3. 保存对配置的更改。
角色映射器配置

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 用户。

流程

  1. 创建与 Data Grid 的 CLI 连接。
  2. 使用 用户角色 grant 命令为用户分配角色,例如:

    user roles grant --roles=deployer katie

验证

使用用户角色 ls 命令,列出您向用户授予的角色

user roles ls katie
["deployer"]
8.1.4.3. 集群角色映射程序名称重写器

默认情况下,映射是使用主体名称和角色之间的严格字符串等效性来执行。在执行查找前,可以将集群角色映射器配置为应用到主体名称的转换。

流程

  1. 打开 Data Grid 配置以进行编辑。
  2. 为集群角色映射器指定一个名称 rewriter,作为 Cache Manager 配置中的安全授权的一部分。
  3. 保存对配置的更改。

主体名称可能具有不同的表单,具体取决于安全域类型:

  • 属性和令牌域可能会返回简单字符串
  • 信任和 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 用户,并使用角色授予他们,或者将它们分配到组。

流程

  1. 打开 Data Grid 配置以进行编辑。
  2. 在配置中添加 security 部分。
  3. 指定用户必须使用 authorization 元素执行缓存操作的角色。

    您可以隐式添加缓存管理器中定义的所有角色,或者明确定义角色的子集。

  4. 保存对配置的更改。
隐式角色配置

以下配置会隐式添加缓存管理器中定义的每个角色:

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 服务器自动启用默认缓存管理器的统计信息。但是,您必须明确为您的缓存启用统计信息。

流程

  1. 打开 Data Grid 配置以进行编辑。
  2. 添加 statistics 属性或字段,并将 true 指定为值。
  3. 保存并关闭您的 Data Grid 配置。
远程缓存统计信息

XML

<distributed-cache statistics="true" />

JSON

{
  "distributed-cache": {
    "statistics": "true"
  }
}

YAML

distributedCache:
  statistics: true

9.2. 启用 Hot Rod 客户端统计信息

热 Rod Java 客户端可以提供包括远程缓存和近缓存命中和未命中的统计数据,以及连接池使用情况。

流程

  1. 打开 Hot Rod Java 客户端配置以进行编辑。
  2. true 设置为 统计 属性的值或调用 statistics ().enable () 方法。
  3. 使用 jmxjmx_domain 属性为您的 Hot Rod 客户端导出 JMX MBeans,或者调用 jmxEnable ()jmxDomain () 方法。
  4. 保存并关闭您的客户端配置。
热 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 相关的指标 在基本 范围内提供。

流程

  1. 打开 Data Grid 配置以进行编辑。
  2. metrics 元素或对象添加到缓存容器。
  3. 使用量表属性或字段启用或禁用 量表
  4. 使用 histograms 属性或字段启用或禁用直方图。
  5. 保存并关闭您的客户端配置。
指标配置

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 接收的数据更为准确。

流程

  1. 打开 Data Grid 配置以进行编辑。
  2. jmx 元素或对象添加到缓存容器,并将 true 指定为 enabled 属性或字段的值。
  3. 添加 domain 属性或字段,并指定公开 JMX MBeans 的域(如果需要)。
  4. 保存并关闭您的客户端配置。
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 会自动将全局 ADMINMONITOR 权限映射到 JMX controlRolemonitorRole 角色。

流程

使用以下方法之一启动启用了远程 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。

流程

  1. 打开 Data Grid 配置以进行编辑。
  2. mbean-server-lookup 属性或字段添加到 Cache Manager 的 JMX 配置。
  3. 指定 MBeanServerLookup 实施的完全限定名称(FQN)。
  4. 保存并关闭您的客户端配置。
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 端点,或者使用以下示例。

先决条件

  • 启用跨站点复制。

流程

  1. 实施脚本以轮询 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 的功能。

如果要使用这个脚本,您必须指定以下变量:

  • USERNAMEPASSWORD :Data Grid 用户的用户名和密码,有权访问 REST 端点。
  • POLL_INTERVAL_SEC :轮询之间的秒数。
  • SERVERS :此站点的数据网格服务器列表。该脚本只需要一个有效的响应,但提供了列表以允许故障切换。
  • REMOTE_SITES: 要监控这些服务器上的远程站点列表。
  • CACHES :要监控的缓存名称列表。
使用 Prometheus 指标监控跨站点复制

Prometheus 和其他监控系统可让您配置警报来检测站点状态何时更改为 离线

提示

监控跨站点延迟指标可帮助您发现潜在的问题。

先决条件

  • 启用跨站点复制。

流程

  1. 配置数据网格指标。
  2. 使用 Prometheus 指标格式配置警报规则。

    • 对于站点状态,在线 使用 10 代表 离线
    • 对于 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

      Prometheus xsite 警报

第 10 章 启用并配置 Data Grid OpenTelemetry 追踪

Data Grid 生成与 OpenTelemetry 标准兼容的追踪,允许您导出、视觉化和分析与最重要的缓存操作相关的追踪数据。

10.1. 配置数据网格追踪

配置 OpenTelemetry 追踪,以启用缓存操作的监控和追踪。

流程

  1. 打开 Data Grid 配置以进行编辑。
  2. tracing 元素或对象添加到缓存容器。
  3. 使用 collector_endpoint 属性或字段定义 OpenTelemetry 收集器的端点 URL。启用追踪是必需的。4318 通常是 http/protobuf OTLP 标准端口。
  4. 使用 enable 属性或字段全局启用或禁用追踪。
  5. 使用 security 属性或字段启用或禁用安全事件追踪。
  6. (可选)更改追踪导出器协议更改 exporter_protocol 属性或字段。默认情况下,它是 otlp (OpenTelemetry 协议)。
  7. (可选)更改与生成的追踪范围关联的追踪服务名称,更改 service_name 属性或字段。默认情况下,它是 infinispan-server
  8. 保存并关闭您的客户端配置。

后续步骤

要应用任何全局追踪配置更改,请停止服务器并重复这个过程。

追踪配置

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

流程

  1. 打开 Data Grid Server 配置以进行编辑。
  2. data-sources 部分添加新的数据源
  3. 使用 name 属性或字段唯一标识数据源。
  4. 使用 jndi-name 属性或字段为数据源指定 JNDI 名称。

    提示

    您可以使用 JNDI 名称在 JDBC 缓存存储配置中指定数据源。

  5. true 设置为 statistics 属性或字段的值,以通过 /metrics 端点启用数据源的统计信息。
  6. 提供 JDBC 驱动程序详细信息,用于定义如何在 connection-factory 部分中连接到数据源。

    1. 使用 driver 属性或字段指定数据库驱动程序的名称。
    2. 使用 url 属性或字段指定 JDBC 连接 url
    3. 使用 用户名和密码 属性或字段指定 凭证。
    4. 根据需要提供任何其他配置。
  7. 定义 Data Grid Server 节点如何池,并在 connection-pool 部分中定义连接池调优属性的连接。
  8. 保存对配置的更改。

验证

使用 Data Grid 命令行界面(CLI)测试数据源连接,如下所示:

  1. 启动 CLI 会话。

    bin/cli.sh
  2. 列出所有数据源,并确认您创建的数据源可用。

    server datasource ls
  3. 测试数据源连接。

    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 服务器。

流程

  1. 打开缓存配置进行编辑。
  2. data-source 元素或字段添加到基于 JDBC 的缓存存储配置中。
  3. 将受管数据源的 JNDI 名称指定为 jndi-url 属性的值。
  4. 根据情况配置基于 JDBC 的缓存存储。
  5. 保存对配置的更改。
缓存配置中的 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 连接池。

属性描述

initial-size

池应保留的初始连接数。

max-size

池中的最大连接数。

min-size

池应保留的最小连接数。

blocking-timeout

在抛出异常前等待连接时的最大时间(毫秒)。如果创建新连接需要很长时间,则这永远不会抛出异常。默认值为 0 表示调用将无限期等待。

background-validation

后台验证运行之间的时间(毫秒)。持续时间为 0 表示禁用此功能。

validate-on-acquisition

闲置的时间比这个时间更长的时间(以毫秒为单位指定)会在获取前验证(foreground 验证)。持续时间为 0 表示禁用此功能。

idle-removal

在几分钟内,连接必须处于闲置状态才能被删除。

leak-detection

在泄漏警告前,必须保留连接的时间(毫秒)。

第 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 文件。

文件名堆栈名称描述

default-jgroups-udp.xml

udp

使用 UDP 进行传输和 UDP 多播进行发现。适用于较大的集群(超过 100 个节点),或者使用复制缓存或无效模式。最小化打开的插槽数量。

default-jgroups-tcp.xml

tcp

使用 TCP 传输和 MPING 协议进行发现,它使用 UDP 多播。只有在使用分布式缓存 时,只适用于 较小的集群(在 100 个节点下),因为 TCP 比 UDP 作为点对点协议更高效。

default-jgroups-kubernetes.xml

kubernetes

使用 TCP 进行传输,DNS_PING 进行发现。适用于始终提供 UDP 多播的 Kubernetes 和 Red Hat OpenShift 节点。

default-jgroups-ec2.xml

ec2

使用 TCP 进行传输和 aws.S3_PING 进行发现。适用于 UDP 多播不可用的 Amazon EC2 节点。需要额外的依赖项。

default-jgroups-google.xml

google

使用 TCP 进行传输,GOOGLE_PING2 进行发现。适用于没有 UDP 多播的 Google Cloud Platform 节点。需要额外的依赖项。

default-jgroups-azure.xml

azure

使用 TCP 进行传输,AZURE_PING 进行发现。适用于没有 UDP 多播的 Microsoft Azure 节点。需要额外的依赖项。

default-jgroups-tunnel.xml

tunnel

使用 TUNNEL 进行传输。适用于 Data Grid 位于防火墙后面且无法在 Data Grid 节点之间直接连接的环境。它需要一个外部访问的服务(Gossip Router)来重定向流量。它要求以 host1[port],host2[port] 格式设置 jgroups.tunnel.hosts 属性,使用 Gossip Router (s)主机和端口设置…​

其他资源

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 节点,如下所示:

  1. 将 address 作为系统属性传递给 JVM;例如,-DGossipRouterAddress="10.10.2.4[12001]"
  2. 在 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 集群。

流程

  1. 将 JDBC 驱动程序 JAR 部署到 Data Grid Server server/lib 目录中
  2. 为您的数据库创建数据源。

    <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>
  3. 创建 JGroups 堆栈,它将使用 JDBC_PING2 协议进行发现。
  4. 通过使用 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" />

其他资源

12.2.7. 云发现协议

Data Grid 包括默认的 JGroups 堆栈,它使用特定于云提供商的发现协议实现。

发现协议默认堆栈文件工件Version

aws.S3_PING

default-jgroups-ec2.xml

org.jgroups.aws:jgroups-aws

3.0.0.Final

OOGLE_PING2

default-jgroups-google.xml

org.jgroups.google:jgroups-google

2.0.0.Final

azure.AZURE_PING

default-jgroups-azure.xml

org.jgroups.azure:jgroups-azure

2.0.2.final

为云发现协议提供依赖项

要使用 aws.S3_PINGGOOGLE_PING2azure.AZURE_PING 云发现协议,您需要向 Data Grid 提供依赖的库。

流程

  1. 下载工件 JAR 文件和所有依赖项。
  2. 将工件 JAR 文件和所有依赖项添加到 Data Grid Server 安装的 $RHDG_HOME/server/lib 目录中。

    如需了解更多详细信息,请参阅 用于 Data Grid Server 的 JGroups 云发现协议下载工件 (红帽知识库文章)

然后,您可以将云发现协议配置为 JGroups 堆栈文件或系统属性的一部分。

12.3. 使用默认 JGroups 堆栈

Data Grid 使用 JGroups 协议堆栈,以便节点可以在专用集群通道上发送其他消息。

Data Grid 为 UDPTCP 协议提供预配置的 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

其他资源

12.4. 自定义 JGroups 堆栈

调整和调优属性,以创建适合您的网络要求的集群传输配置。

Data Grid 提供可让您扩展默认 JGroups 堆栈以方便配置的属性。您可以在合并、删除和替换其他属性时从默认堆栈继承属性。

流程

  1. infinispan.xml 文件中创建一个新的 JGroups 堆栈声明。
  2. 添加 extends 属性,并指定 JGroups 堆栈来继承属性。
  3. 使用 stack.combine 属性修改继承堆栈中配置的协议的属性。
  4. 使用 stack.position 属性定义自定义堆栈的位置。
  5. 指定堆栈名称,作为 传输 配置中 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>
  6. 检查 Data Grid 日志,以确保它使用堆栈。

    [org.infinispan.CLUSTER] ISPN000078: Starting JGroups channel cluster with stack my-stack

参考

12.4.1. 继承属性

当您扩展 JGroups 堆栈时,继承属性允许您调整您要扩展的堆栈中的协议和属性。

  • stack.position 指定要修改的协议。
  • stack.combine 使用以下值来扩展 JGroups 堆栈:

    value描述

    组合

    覆盖协议属性。

    REPLACE

    替换协议。

    INSERT_AFTER

    在另一个协议后将协议添加到堆栈中。不会影响指定为插入点的协议。

    JGroups 堆栈中的协议会根据堆栈中的位置相互影响。例如,您应该在 SYM_ENCRYPTASYM_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 集群传输。

系统属性描述默认值必填/选填

jgroups.bind.address

集群传输的绑定地址。

SITE_LOCAL

选填

jgroups.bind.port

套接字的绑定端口。

7800

选填

jgroups.mcast_addr

用于多播的 IP 地址,包括发现和集群间通信。IP 地址必须是适合 IP 多播的有效"类 D"地址。

239.6.7.8

选填

jgroups.mcast_port

多播套接字的端口。

46655

选填

jgroups.ip_ttl

IP 多播数据包的时间到时间(TTL)。该值定义数据包在丢弃前可以进行的网络跃点数。

2

选填

jgroups.thread_pool.min_threads

线程池的最小线程数量。

0

选填

jgroups.thread_pool.max_threads

线程池的最大线程数。

200

选填

jgroups.join_timeout

等待加入请求成功的最大毫秒数。

2000

选填

jgroups.thread_dumps_threshold

在记录线程转储前,线程池需要满的次数。

10000

选填

jgroups.fd.port-offset

来自 FD (检测协议)套接字的 jgroups.bind.port 端口的偏移。

50000 (port 57800 )

选填

jgroups.frag_size

消息中的最大字节数。大于碎片的消息。

60000

选填

jgroups.diag.enabled

启用 JGroups 诊断探测。

false

选填

12.5.2. 云发现协议的系统属性

使用以下属性为托管平台配置 JGroups 发现协议:

12.5.2.1. Amazon EC2

用于配置 aws.S3_PING 的系统属性。

系统属性描述默认值必填/选填

jgroups.s3.region_name

Amazon S3 区域的名称。

没有默认值。

选填

jgroups.s3.bucket_name

Amazon S3 存储桶的名称。名称必须存在,并且必须是唯一的。

没有默认值。

选填

12.5.2.2. Google Cloud Platform

用于配置 GOOGLE_PING2 的系统属性。

系统属性描述默认值必填/选填

jgroups.google.bucket_name

Google Compute Engine 存储桶的名称。名称必须存在,并且必须是唯一的。

没有默认值。

必填

12.5.2.3. Azure

azure.AZURE_PING' 的系统属性。

系统属性描述默认值必填/选填

jboss.jgroups.azure_ping.storage_account_name

Azure 存储帐户的名称。名称必须存在,并且必须是唯一的。

没有默认值。

必填

jboss.jgroups.azure_ping.storage_access_key

Azure 存储访问密钥的名称。

没有默认值。

必填

jboss.jgroups.azure_ping.container

存储 ping 信息的容器的有效 DNS 名称。

没有默认值。

必填

12.5.2.4. OpenShift

DNS_PING 的系统属性。

系统属性描述默认值必填/选填

jgroups.dns.query

设置返回群集成员的 DNS 记录。

没有默认值。

必填

jgroups.dns.record

设置 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 堆栈的外部文件。

流程

  1. 将自定义 JGroups 堆栈文件添加到 $RHDG_HOME/server/conf 目录中。

    或者,您可以在声明外部堆栈文件时指定绝对路径。

  2. 使用 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 集群。

流程

  1. 创建一个 TLS 密钥存储,其中包含单个证书来标识 Data Grid 服务器。

    如果 PEM 文件包含 PKCS"" 或 PKCS""8 格式的私钥,则可使用证书,并且具有空密码: password=""

    注意

    如果密钥存储中的证书没有由公共证书颁发机构(CA)签名,那么您还必须创建一个包含签名证书或公钥的信任存储。

  2. 将密钥存储添加到 $RHDG_HOME/server/conf 目录中。
  3. 将密钥存储添加到 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>
  4. 使用 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)攻击的影响。

非对称加密保护集群流量,如下所示:

  1. Data Grid 集群中的第一个节点(coordinator 节点)会生成一个 secret 密钥。
  2. 加入节点使用协调器执行证书身份验证,以互相验证身份。
  3. 加入的节点从 coordinator 节点请求 secret 密钥。该请求包含加入节点的公钥。
  4. 协调器节点使用公钥加密 secret 密钥,并将其返回到加入节点。
  5. 加入节点解密并安装 secret 密钥。
  6. 节点加入集群,使用 secret 密钥加密并解密信息。

从共享密钥存储检索 secret 密钥

您可以通过在 Data Grid 配置中的 JGroups 堆栈中添加 SYM_ENCRYPT 协议来配置对称加密。这允许 Data Grid 集群从您提供的密钥存储获取 secret 密钥。

  1. 节点在启动时从 Data Grid 类路径上的密钥存储安装 secret 密钥。
  2. 节点加入集群,使用 secret 密钥加密和解密消息。

非对称和对称加密的比较

带有证书身份验证的 ASYM_ENCRYPT 提供了额外的加密层,与 SYM_ENCRYPT 相比。您提供密钥存储来为 secret 密钥加密对协调节点的请求。Data Grid 会自动生成该 secret 密钥并处理集群流量,同时允许您指定何时生成 secret 密钥。例如,您可以配置集群以在节点离开时生成新的 secret 密钥。这样可确保节点无法绕过证书身份验证,并使用旧密钥加入。

另一方面,SYM_ENCRYPTASYM_ENCRYPT 快,因为节点不需要与集群协调器交换密钥。SYM_ENCRYPT 是没有配置在集群成员资格更改时自动生成新 secret 密钥的潜在缺陷。用户负责生成和分发节点用于加密集群流量的 secret 密钥。

12.8.3. 使用非对称加密保护集群传输

配置 Data Grid 集群,以生成和分发加密 JGroups 消息的 secret 密钥。

流程

  1. 使用证书链创建密钥存储,使 Data Grid 能够验证节点身份。
  2. 将密钥存储放在集群中每个节点的 classpath 上。

    对于 Data Grid Server,您要将密钥存储放在 $RHDG_HOME 目录中。

  3. SSL_KEY_EXCHANGEASYM_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 消息。

流程

  1. 创建包含 secret 密钥的密钥存储。
  2. 将密钥存储放在集群中每个节点的 classpath 上。

    对于 Data Grid Server,您要将密钥存储放在 $RHDG_HOME 目录中。

  3. 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 对集群传输信息使用以下端口:

默认端口协议描述

7800

TCP/UDP

JGroups 集群绑定端口

46655

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 缓存配置。

流程

  1. 在任意浏览器中打开 127.0.0.1:11222/console/
  2. 选择 Create Cache 并按照步骤操作,作为 Data Grid Console 指南。

13.3. 使用 Data Grid CLI 创建远程缓存

使用 Data Grid 命令行界面(CLI)在 Data Grid Server 中添加远程缓存。

先决条件

  • 创建具有 admin 权限的 Data Grid 用户。
  • 至少启动一个 Data Grid 服务器实例。
  • 具有 Data Grid 缓存配置。

流程

  1. 启动 CLI。

    bin/cli.sh
  2. 运行 connect 命令,并在提示时输入您的用户名和密码。
  3. 使用 create cache 命令创建远程缓存。

    例如,从名为 mycache.xml 的文件创建一个名为 "mycache" 的缓存,如下所示:

    create cache --file=mycache.xml mycache

验证

  1. 使用 ls 命令列出所有远程缓存。

    ls caches
    mycache
  2. 使用 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 文件中设置 configurationconfiguration_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 服务器不支持自定义类的运行时部署。

流程

  1. 添加 META-INF/services/org.infinispan.tasks.ServerTask 文件,其中包含服务器任务的完全限定域名,例如:

    example.HelloTask
  2. 将服务器任务实施打包到 JAR 文件中。
  3. 将 JAR 文件复制到 Data Grid Server 安装的 $RHDG_HOME/server/lib 目录中。
  4. 将您的类添加到 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 角色。

流程

  1. 根据需要定义脚本。

    例如,创建一个名为 multiplication.js 的文件,它在单一 Data Grid 服务器上运行,它有两个参数,并使用 JavaScript 乘以给定值:

    // mode=local,language=javascript
    multiplicand * multiplier
  2. 创建与 Data Grid 的 CLI 连接。
  3. 使用 task 命令上传脚本,如下例所示:

    task upload --file=multiplication.js multiplication
  4. 验证您的脚本是否可用。

    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 对。
  • 使用单个(')或双引号(")分隔值。
表 14.1. 元数据属性
属性描述

模式

定义执行模式,并具有以下值:

本地 仅处理请求的节点会执行脚本。虽然脚本仍然可以调用集群操作。

分布式 Data Grid 使用集群执行器在节点间运行脚本。

language

指定执行脚本的 ScriptEngine。

extension

指定文件扩展作为设置 ScriptEngine 的替代方法。

role

指定用户必须执行脚本的角色。

parameters

指定此脚本的有效参数名称数组。调用指定此列表中未包含的参数会导致异常。

datatype

(可选)设置 MediaType (MIME type)来存储数据以及参数和返回值。此属性对仅支持特定数据格式的远程客户端很有用。

目前,您只能设置 text/plain; charset=utf-8,以将 String UTF-8 格式用于数据。

14.2.1.2. 脚本绑定

Data Grid 将内部对象公开为脚本执行的绑定。

绑定描述

缓存

指定运行脚本的缓存。

marshaller

指定用于将数据序列化到缓存的 marshaller。

cacheManager

指定缓存的 cacheManager

scriptingManager

指定运行脚本的脚本管理器的实例。您可以使用此绑定从脚本运行其他脚本。

14.2.1.3. 脚本参数

Data Grid 可让您将命名参数传递为运行脚本的绑定。

参数是 name,value 对,其中 name 是一个字符串,value 是 marshaller 可以解释的任何值。

以下示例脚本有两个参数,即 multiplicandmultiplier。脚本采用 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 服务器添加脚本或任务。

流程

  1. 创建与 Data Grid 的 CLI 连接。
  2. 使用 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 Rod RemoteCache 接口运行脚本,如下例所示:

脚本执行

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 文件中配置服务器日志。

流程

  1. 使用任何文本编辑器打开 $RHDG_HOME/server/conf/log4j2.xml
  2. 根据需要更改服务器日志记录。
  3. 保存并关闭 log4j2.xml

其他资源

15.1.2. 日志级别

日志级别表示消息的性质和严重性。

日志级别描述

TRACE

细粒度调试消息,通过应用程序捕获单个请求的流。

DEBUG

用于常规调试的消息,与单个请求无关。

INFO

有关应用程序整体进度的消息,包括生命周期事件。

WARN

可能导致错误或降低性能的事件。

ERROR

错误条件可能会阻止操作或活动成功,但不会阻止应用程序运行。

FATAL

可能导致关键服务失败和应用程序关闭的事件。

除了上面提供的单个消息级别外,配置还允许两个值: 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. 日志模式格式器

CONSOLEFILE 附加器使用 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 正在运行,则停止它。
    您无法动态启用日志处理程序。

流程

  1. 使用任何文本编辑器打开 $RHDG_HOME/server/conf/log4j2.xml
  2. 取消注释 JSON-FILE 附加器并注释掉 FILE 附加器:

    <!--<AppenderRef ref="FILE"/>-->
    <AppenderRef ref="JSON-FILE"/>
  3. (可选)根据需要配置 JSON 附加程序和 JSON 布局。
  4. 保存并关闭 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 中启用日志类别。

流程

  1. 使用任何文本编辑器打开 $RHDG_HOME/server/conf/log4j2.xml
  2. org.infinispan.HOTROD_ACCESS_LOGorg.infinispan.REST_ACCESS_LOGorg.infinispan.MEMCACHED_ACCESS_LOG 日志记录类别的级别更改为 TRACE
  3. 保存并关闭 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}] &quot;%X{method} %m
%X{protocol}&quot; %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} 表示法,并允许您修改访问日志的格式。以下是默认日志属性:

属性描述

address

X-Forwarded-For 标头或客户端 IP 地址。

user

主体名称,如果使用身份验证。

方法

使用协议的具体方法。PUTGET 等。

protocol

使用的协议。HTTP/1.1,HTTP/2,HOTROD/2.9,MCTXT,MCBIN 等等。

status

REST 端点的 HTTP 状态代码。OK 或 Hot Rod 端点的例外。

requestSize

请求的大小(以字节为单位)。

responseSize

响应的大小(以字节为单位)。

duration

服务器处理请求所花费的毫秒数。

提示

使用前缀 h: 的标头名称来记录请求中包含的标头,例如 %X{h:User-Agent}

15.3. 审计日志

审计日志可让您跟踪对 Data Grid 服务器部署的更改,以便了解何时发生更改以及哪些用户进行更改。启用并配置审计日志记录,以记录服务器配置事件和管理操作。

org.infinispan.AUDIT
将安全审计消息写入 $RHDG_HOME/server/log 目录中的 audit.log 文件的日志记录类别。

15.3.1. 启用审计日志记录

要记录安全审核消息,您需要在 log4j2.xml 中启用日志记录类别。

流程

  1. 使用任何文本编辑器打开 $RHDG_HOME/server/conf/log4j2.xml
  2. org.infinispan.AUDIT 日志记录类别的级别更改为 INFO
  3. 保存并关闭 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 中配置附加程序。

流程

  1. 使用任何文本编辑器打开 $RHDG_HOME/server/conf/log4j2.xml
  2. 注释或删除默认的 AUDIT-FILE 滚动文件附加器。

    <!--RollingFile name="AUDIT-FILE"
      ...
    </RollingFile-->
  3. 为审计消息添加所需的日志记录附加程序。

    例如,您可以为 Kafka 服务器添加日志记录附加程序,如下所示:

    <Kafka name="AUDIT-KAFKA" topic="audit">
      <PatternLayout pattern="%date %message"/>
      <Property name="bootstrap.servers">localhost:9092</Property>
    </Kafka>
  4. 保存并关闭 log4j2.xml

其他资源

15.3.3. 使用自定义审计日志记录实现

如果配置 Log4j attachers 不满足您的需要,您可以创建 org.infinispan.security.AuditLogger API 的自定义实现。

先决条件

  • 根据需要实施 org.infinispan.security.AuditLogger,并将它打包在 JAR 文件中。

流程

  1. 将您的 JAR 添加到 Data Grid Server 安装中的 server/lib 目录中。
  2. 指定自定义审计日志记录器的完全限定类名称,作为缓存容器安全配置中 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 传输配置中为目标和源集群指定唯一名称。根据您的环境,您还可以使用不同的网络接口和端口偏移来分隔目标和源集群。

流程

  1. 以 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
          }
        ]
      }
    }
  2. 使用 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
  3. 对您要迁移的每个缓存重复前面的步骤。
  4. 将客户端切换到目标集群,以便它开始处理所有请求。

    1. 使用目标集群的位置更新客户端配置。
    2. 重新启动客户端。
重要

如果您需要迁移索引缓存,您必须首先迁移内部 ___protobuf_metadata 缓存,以便源集群中定义的 .proto 模式也会存在于目标集群上。

16.2. 将数据同步到目标集群

当您设置目标 Data Grid 集群并将其连接到源集群时,目标集群可以使用远程缓存存储和按需加载数据的客户端请求。要将数据完全迁移到目标集群,以便您可以停用源集群,您可以同步数据。此操作从源集群读取数据并将其写入目标集群。数据会并行迁移到目标集群中的所有节点,每个节点都接收数据的子集。您必须对要迁移到目标集群的每个缓存执行同步。

先决条件

  • 使用适当的 Data Grid 版本设置目标集群。

流程

  1. 使用 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 使用复制到目标集群的条目总数进行响应。

  2. 断开目标集群中的每个节点与源集群的连接。

    • 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、内存、打开文件、网络套接字和路由、线程的详细信息。

流程

  1. 创建与 Data Grid 服务器的 CLI 连接。
  2. 使用 server report 命令下载 tar.gz 归档:

    server report
    Downloaded report 'infinispan-<hostname>-<timestamp>-report.tar.gz'

    命令使用报告名称进行响应,如下例所示:

    Downloaded report 'infinispan-<hostname>-<timestamp>-report.tar.gz'
  3. tar.gz 文件移动到您文件系统的适当位置。
  4. 使用任何归档工具提取 tar.gz 文件。

17.2. 在运行时更改 Data Grid 服务器日志配置

在运行时修改 Data Grid 服务器的日志记录配置,以临时调整日志记录以排除问题并执行根本原因分析。

通过 CLI 修改日志记录配置是一个仅运行时的操作,这意味着更改:

  • 不会保存到 log4j2.xml 文件中。重启服务器节点或整个集群会将日志记录配置重置为 log4j2.xml 文件中的默认属性。
  • 仅在调用 CLI 时应用到集群中的节点。更改日志记录配置后加入集群的节点使用默认属性。

流程

  1. 创建与 Data Grid 服务器的 CLI 连接。
  2. 使用 日志记录 进行必要的调整。

    • 列出服务器上定义的所有附加器:

      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 集群运行状况统计信息。

流程

  1. 使用任何 JMX 功能工具(如 JConsole)连接到 Data Grid 服务器,并导航到以下对象:

    org.infinispan:type=CacheManager,name="default",component=CacheContainerHealth
  2. 选择 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
目录描述

/bin

包含用于启动服务器和 CLI 的脚本。

/boot

包含要引导服务器的 JAR 文件。

/docs

提供配置示例、架构、组件许可证和其他资源。

/lib

包含服务器在内部所需的 JAR 文件。
不要将自定义 JAR 文件放在此文件夹中。

/server

为 Data Grid 服务器实例提供根文件夹。

/static

包含 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
目录描述系统属性覆盖

/server/conf

包含服务器配置文件。

infinispan.server.config.path

/server/data

包含按容器名称组织的数据文件。

infinispan.server.data.path

/server/lib

包含服务器扩展文件。
此目录被递归扫描,并用作类路径。

Infinispan.server.lib.path
使用以下分隔符多个路径:
: 在 Unix / Linux
在 Windows 上

/server/log

包含服务器日志文件。

infinispan.server.log.path

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

法律通告

Copyright © 2024 Red Hat, Inc.
The text of and illustrations in this document are licensed by Red Hat under a Creative Commons Attribution–Share Alike 3.0 Unported license ("CC-BY-SA"). An explanation of CC-BY-SA is available at http://creativecommons.org/licenses/by-sa/3.0/. In accordance with CC-BY-SA, if you distribute this document or an adaptation of it, you must provide the URL for the original version.
Red Hat, as the licensor of this document, waives the right to enforce, and agrees not to assert, Section 4d of CC-BY-SA to the fullest extent permitted by applicable law.
Red Hat, Red Hat Enterprise Linux, the Shadowman logo, the Red Hat logo, JBoss, OpenShift, Fedora, the Infinity logo, and RHCE are trademarks of Red Hat, Inc., registered in the United States and other countries.
Linux® is the registered trademark of Linus Torvalds in the United States and other countries.
Java® is a registered trademark of Oracle and/or its affiliates.
XFS® is a trademark of Silicon Graphics International Corp. or its subsidiaries in the United States and/or other countries.
MySQL® is a registered trademark of MySQL AB in the United States, the European Union and other countries.
Node.js® is an official trademark of Joyent. Red Hat is not formally related to or endorsed by the official Joyent Node.js open source or commercial project.
The OpenStack® Word Mark and OpenStack logo are either registered trademarks/service marks or trademarks/service marks of the OpenStack Foundation, in the United States and other countries and are used with the OpenStack Foundation's permission. We are not affiliated with, endorsed or sponsored by the OpenStack Foundation, or the OpenStack community.
All other trademarks are the property of their respective owners.
Red Hat logoGithubRedditYoutube

关于红帽文档

通过我们的产品和服务,以及可以信赖的内容,帮助红帽用户创新并实现他们的目标。

让开源更具包容性

红帽致力于替换我们的代码、文档和 Web 属性中存在问题的语言。欲了解更多详情,请参阅红帽博客.

關於紅帽

我们提供强化的解决方案,使企业能够更轻松地跨平台和环境(从核心数据中心到网络边缘)工作。

© 2024 Red Hat, Inc.