问题：

Keycloak：专用Infinispan集群的远程存储配置

章琛

2023-03-14

最近，我加强了我的keybeat部署，使用专用的Infinispan集群作为远程存储，为keybeat的各种缓存提供额外的持久性层。更改本身进行得相当顺利，尽管在进行此更改后，我们开始看到许多登录错误，这是由于expired\u code错误消息引起的：

WARN [org.keycloak.events] (default task-2007) type=LOGIN_ERROR, realmId=my-realm, clientId=null, userId=null, ipAddress=192.168.50.38, error=expired_code, restart_after_timeout=true

此错误消息通常会在短时间内从同一IP地址重复数十次。其原因似乎是最终用户的浏览器在登录时无限重定向，直到浏览器本身停止循环。

我见过各种GitHub问题(https://github.com/helm/charts/issues/8355)这也记录了这种行为，大家一致认为这是由于keydepeat集群无法通过jgroup正确发现其成员造成的。

当您考虑到一些Keycloak缓存分布在standalone-ha.xml中默认配置的Keycloak节点上时，这种解释是有道理的。但是，我已将这些缓存修改为本地缓存，其中远程存储指向我的新Infinispan集群，我相信我对其工作原理做出了一些不正确的假设，导致此错误开始发生。

以下是我的Keycloak缓存的配置方式：

<subsystem xmlns="urn:jboss:domain:infinispan:7.0">
    <cache-container name="keycloak" module="org.keycloak.keycloak-model-infinispan">
        <transport lock-timeout="60000"/>
        <local-cache name="realms">
            <object-memory size="10000"/>
        </local-cache>
        <local-cache name="users">
            <object-memory size="10000"/>
        </local-cache>
        <local-cache name="authorization">
            <object-memory size="10000"/>
        </local-cache>
        <local-cache name="keys">
            <object-memory size="1000"/>
            <expiration max-idle="3600000"/>
        </local-cache>
        <local-cache name="sessions">
            <remote-store cache="sessions" remote-servers="remote-cache" fetch-state="false" passivation="false" preload="false" purge="false" shared="true">
                <property name="rawValues">
                    true
                </property>
                <property name="marshaller">
                    org.keycloak.cluster.infinispan.KeycloakHotRodMarshallerFactory
                </property>
            </remote-store>
        </local-cache>
        <local-cache name="authenticationSessions">
            <remote-store cache="authenticationSessions" remote-servers="remote-cache" fetch-state="false" passivation="false" preload="false" purge="false" shared="true">
                <property name="rawValues">
                    true
                </property>
                <property name="marshaller">
                    org.keycloak.cluster.infinispan.KeycloakHotRodMarshallerFactory
                </property>
            </remote-store>
        </local-cache>
        <local-cache name="offlineSessions">
            <remote-store cache="offlineSessions" remote-servers="remote-cache" fetch-state="false" passivation="false" preload="false" purge="false" shared="true">
                <property name="rawValues">
                    true
                </property>
                <property name="marshaller">
                    org.keycloak.cluster.infinispan.KeycloakHotRodMarshallerFactory
                </property>
            </remote-store>
        </local-cache>
        <local-cache name="clientSessions">
            <remote-store cache="clientSessions" remote-servers="remote-cache" fetch-state="false" passivation="false" preload="false" purge="false" shared="true">
                <property name="rawValues">
                    true
                </property>
                <property name="marshaller">
                    org.keycloak.cluster.infinispan.KeycloakHotRodMarshallerFactory
                </property>
            </remote-store>
        </local-cache>
        <local-cache name="offlineClientSessions">
            <remote-store cache="offlineClientSessions" remote-servers="remote-cache" fetch-state="false" passivation="false" preload="false" purge="false" shared="true">
                <property name="rawValues">
                    true
                </property>
                <property name="marshaller">
                    org.keycloak.cluster.infinispan.KeycloakHotRodMarshallerFactory
                </property>
            </remote-store>
        </local-cache>
        <local-cache name="loginFailures">
            <remote-store cache="loginFailures" remote-servers="remote-cache" fetch-state="false" passivation="false" preload="false" purge="false" shared="true">
                <property name="rawValues">
                    true
                </property>
                <property name="marshaller">
                    org.keycloak.cluster.infinispan.KeycloakHotRodMarshallerFactory
                </property>
            </remote-store>
        </local-cache>
        <local-cache name="actionTokens">
            <remote-store cache="actionTokens" remote-servers="remote-cache" fetch-state="false" passivation="false" preload="false" purge="false" shared="true">
                <property name="rawValues">
                    true
                </property>
                <property name="marshaller">
                    org.keycloak.cluster.infinispan.KeycloakHotRodMarshallerFactory
                </property>
            </remote-store>
        </local-cache>
        <replicated-cache name="work">
            <remote-store cache="work" remote-servers="remote-cache" fetch-state="false" passivation="false" preload="false" purge="false" shared="true">
                <property name="rawValues">
                    true
                </property>
                <property name="marshaller">
                    org.keycloak.cluster.infinispan.KeycloakHotRodMarshallerFactory
                </property>
            </remote-store>
        </replicated-cache>
    </cache-container>
    <cache-container name="server" aliases="singleton cluster" default-cache="default" module="org.wildfly.clustering.server">
        <transport lock-timeout="60000"/>
        <replicated-cache name="default">
            <transaction mode="BATCH"/>
        </replicated-cache>
    </cache-container>
    <cache-container name="web" default-cache="dist" module="org.wildfly.clustering.web.infinispan">
        <transport lock-timeout="60000"/>
        <distributed-cache name="dist">
            <locking isolation="REPEATABLE_READ"/>
            <transaction mode="BATCH"/>
            <file-store/>
        </distributed-cache>
    </cache-container>
    <cache-container name="ejb" aliases="sfsb" default-cache="dist" module="org.wildfly.clustering.ejb.infinispan">
        <transport lock-timeout="60000"/>
        <distributed-cache name="dist">
            <locking isolation="REPEATABLE_READ"/>
            <transaction mode="BATCH"/>
            <file-store/>
        </distributed-cache>
    </cache-container>
    <cache-container name="hibernate" module="org.infinispan.hibernate-cache">
        <transport lock-timeout="60000"/>
        <local-cache name="local-query">
            <object-memory size="10000"/>
            <expiration max-idle="100000"/>
        </local-cache>
        <invalidation-cache name="entity">
            <transaction mode="NON_XA"/>
            <object-memory size="10000"/>
            <expiration max-idle="100000"/>
        </invalidation-cache>
        <replicated-cache name="timestamps"/>
    </cache-container>
</subsystem>

请注意，与默认的standalone-ha.xml配置文件相比，此缓存配置的大部分是不变的。我在这里所做的更改是将以下缓存更改为local并将它们指向我的远程Infinispan集群：

会话

以下是我的远程缓存服务器的配置：

<socket-binding-group name="standard-sockets" default-interface="public" port-offset="${jboss.socket.binding.port-offset:0}">
    <!-- Default socket bindings from standalone-ha.xml are not listed here for brevity -->
    <outbound-socket-binding name="remote-cache">
        <remote-destination host="${env.INFINISPAN_HOST}" port="${remote.cache.port:11222}"/>
    </outbound-socket-binding>
</socket-binding-group>

以下是如何在Infinispan端配置缓存：

<subsystem xmlns="urn:infinispan:server:core:9.4" default-cache-container="clustered">
    <cache-container name="clustered" default-cache="default">
        <transport lock-timeout="60000"/>
        <global-state/>
        <replicated-cache-configuration name="replicated-keycloak" mode="SYNC">
            <locking acquire-timeout="3000" />
        </replicated-cache-configuration>
        <replicated-cache name="work" configuration="replicated-keycloak"/>
        <replicated-cache name="sessions" configuration="replicated-keycloak"/>
        <replicated-cache name="authenticationSessions" configuration="replicated-keycloak"/>
        <replicated-cache name="clientSessions" configuration="replicated-keycloak"/>
        <replicated-cache name="offlineSessions" configuration="replicated-keycloak"/>
        <replicated-cache name="offlineClientSessions" configuration="replicated-keycloak"/>
        <replicated-cache name="actionTokens" configuration="replicated-keycloak"/>
        <replicated-cache name="loginFailures" configuration="replicated-keycloak"/>
    </cache-container>
</subsystem>

我相信我对带有远程存储的本地缓存是如何工作的做出了一些错误的假设，我希望有人能够为我澄清这一点。我的目的是让Infinispan集群成为所有Keycloak缓存的真实来源。通过使每个缓存都是本地的，我假设数据将通过Infinispan集群复制到每个Keycloak节点，这样对keycloak-0上的本地验证会话缓存的写入将通过Infinispan集群同步持久化到keycloak-1。

我认为正在发生的事情是，对KeyClope上本地缓存的写入与将该值持久化到远程Infinispan集群不同步。换句话说，当对authenticationSessions缓存执行写操作时，它在等待将该值写入Infinispan集群时不会阻塞，因此在另一个KeyClope节点上立即读取该数据会导致本地和Infinispan集群中的缓存未命中。

我正在寻找一些帮助来确定为什么我当前的配置会导致这个问题，并对远程存储的行为进行一些澄清-有没有办法让缓存写入由远程存储支持的本地缓存是同步的？如果没有，是否有更好的方法来完成我在这里尝试完成的任务？

其他一些可能相关的细节：

Keyclope和Infinispan都部署到Kubernetes集群中的同一命名空间

提前感谢！

共有2个答案

华泳

2023-03-14

伙计们，这里有很好的交流，令人难以置信的是，我和你们迈克尔有着完全相同的假设，我将我的本地缓存配置为使用远程存储，并期望密钥总是从远程存储中读取/写入，但显然这不是它的工作原理。

可悲的是，从这里完成的所有交换中，我找不到为什么会这样，为什么我们不能将本地infinispan配置为仅作为远程infinispan的代理，允许保持此实例无状态并有一个更容易重新部署的过程。

嵇浩然

2023-03-14

我将试图澄清在集群中配置keydepeat时需要考虑的一些要点。

谈到“无限重定向”这个主题，几年前我在开发环境中遇到过类似的问题。虽然keydeport团队已经纠正了与无限循环相关的几个错误（例如keydeport-5856、keydeport-5022、keydeport-4717、keydeport-4552、keydeport-3878），但有时这是由于配置问题造成的。

检查站点是否为HTTPS的一件事是也要通过HTTPS访问KeyClope服务器。

我记得当keybeat被放置在HTTPS反向代理之后，并且所需的头没有传播到keybeat（头X-FOWARDED…）时，我遇到了与无限循环类似的问题。很好地营造了环境，解决了这个问题。当集群中的节点发现无法正常工作（JGroups）时，可能会发生类似的问题。

关于错误消息“expired_code”，我将验证每个节点的时钟是否同步，因为它可能导致这种过期令牌/代码错误。

现在更好地了解您的配置，将“本地缓存”模式与远程存储一起使用似乎并不合适，指向infinispan集群。

尽管通常情况下，共享存储（如远程缓存）通常与无效缓存一起使用，避免集群复制完整数据（请参阅此处可以应用的注释）https://developer.jboss.org/message/986847#986847)，与分布式缓存或无效缓存可能没有太大区别。

我相信带有远程存储的分布式缓存会更好地应用（或者无效缓存以避免将重数据复制给所有者），但是我无法确保“本地缓存”如何与远程存储（共享）一起工作，因为我从未尝试过这种配置。我会首先选择测试分布式缓存或无效缓存，具体取决于它如何处理驱逐/无效数据。通常，本地缓存不会与集群中的其他远程节点同步。如果这种实现在内存中保留本地映射，那么即使远程存储中的数据被修改，这些更改也可能在某些情况下无法反映。我可以为您提供一个可以使用的Jeter测试文件，以便您可以尝试使用这两种配置执行自己的测试。

回到您配置的主题，除了复制的缓存有一定的限制，并且通常比只将数据复制到定义的所有者的分布式缓存慢一点（复制的缓存写入所有节点）之外，您还必须考虑到。还有一种称为Scatle-cache的变体，它的性能更好，但例如缺乏Transaction支持（您可以在这里看到https://infinispan.org/docs/stable/user_guide/user_guide.html#which_cache_mode_should_i_use的比较图表）。复制通常只在小型集群（8或10台服务器以下）中表现良好，这是由于需要发送的复制消息的数量。分布式缓存允许Infinispan通过按条目定义多个副本来线性扩展。

主要原因是，当您需要独立扩展应用程序的infinispan集群或使用infinispan作为持久存储时，需要对您尝试执行的类型进行配置，而不是类似于KeyClope（独立ha.xml）提出的配置。

我将解释KeyClope是如何管理其缓存的，以及它如何基本上将其分为两个或三个组，以便您能够更好地理解所需的配置。

通常，要在集群中配置keydepeat，只需在HA模式下提升和配置keydepeat，就像处理传统的Wildfly实例一样。如果观察到独立之间的差异。xml和独立ha。在keybeat安装中附带的xml中，我们注意到基本上支持被添加到“Jgroups”、“modcluster”，缓存在Wildfly/keybeat（HA）中的节点之间分布（以前是本地的）。

详细地：

增加了jGroup子系统，负责连接集群节点并在集群中进行消息传递/通信。JGroup提供网络通信能力、可靠通信和其他功能，如节点发现、点对点通信、组播通信、故障检测和集群节点之间的数据搬迁。
EJB3缓存从简单缓存（在没有事务处理的本地内存中）到分布式缓存。但是，根据我扩展该项目的经验，我将确保Keycloak项目不需要使用EJB3。
缓存：“领域”、“用户”、“授权”和“密钥”保留在本地，因为它们仅用于减少数据库的负载。
缓存：“work”变为REPLICATED，因为Keycloak使用它来通知集群节点缓存的条目必须被驱逐/无效，因为它的状态已被修改。
缓存会话、身份验证会话、离线会话、客户会话、离线会话、loginFailures和actionTokens变得分布式，因为它们的性能优于复制缓存（请参阅https://infinispan.org/docs/stable/user_guide/user_guide.html#which_cache_mode_should_i_use），因为您只需将数据复制给所有者。
keycloak为其默认HA配置提出的其他更改是分发“web”和“ejb”（及以上）缓存容器，并将“Hibernate”缓存更改为“无效缓存”（如本地缓存，但具有无效同步）。

我认为您的缓存配置应该定义为“分布式缓存”，用于“会话”、“身份验证会话”、“离线会话”、“客户端会话”、“离线客户端会话”、“登录失败”和“动作令牌”（而不是“本地”）等缓存。然而，因为您使用的是远程共享存储，所以应该测试它，看看它是如何工作的，正如我之前所说的。

此外，名为“work”的缓存应为“复制缓存”，其他（“密钥”、“授权”、“领域”和“用户”）应定义为“本地缓存”。

在您的infinispan集群中，您可以将其定义为“分布式缓存”（或“复制缓存”）。

请记住：

在复制缓存中，集群中的所有节点都持有所有密钥，即如果密钥存在于一个节点上，它也将存在于所有其他节点上。在分布式缓存中，维护了许多副本以提供冗余和容错能力，但这通常远远少于集群中的节点数量。分布式缓存提供的可扩展性远高于复制缓存。分布式缓存还能够透明地跨集群定位密钥，并提供L1缓存以快速本地读取远程存储的状态。您可以在相关的用户指南章节中阅读更多信息。

Infinispan文件。参考：缓存模式

正如KeyCloak（6.0）留档所说：

Keycloak有两种类型的缓存。一种类型的缓存位于数据库前面，以减少数据库的负载，并通过将数据保存在内存中来减少整体响应时间。Realm、客户端、角色和用户元数据保存在这种类型的缓存中。此缓存是本地缓存。即使您在拥有更多Keycloak服务器的集群中，本地缓存也不会使用复制。相反，它们只在本地保留副本，如果条目被更新，则会向集群的其余部分发送无效消息并驱逐条目。有单独的复制缓存工作，任务是将失效消息发送到整个集群，说明应该从本地缓存中驱逐哪些条目。这大大降低了流量，提高了效率，并避免了通过网络传输敏感元数据。

第二种类型的缓存处理管理用户会话、离线令牌和跟踪登录失败，以便服务器可以检测密码网络钓鱼和其他攻击。这些缓存中保存的数据是临时的，仅在内存中，但可能会在集群中复制。

文件。参考：缓存配置

如果您想阅读另一个好的文档，可以查看“交叉直流”部分（交叉直流模式），特别是“3.4.6 Infinispan缓存”（Infinispan缓存）部分

我尝试使用Keycloak 6.0.1和Infinispan 9.4.11。最后，这是我的测试配置（基于standalone-ha.xml文件）。

键斗篷infinispan子系统：

    <subsystem xmlns="urn:jboss:domain:infinispan:8.0">
        <cache-container name="keycloak" module="org.keycloak.keycloak-model-infinispan">
            <transport lock-timeout="60000"/>
            <local-cache name="realms">
                <object-memory size="10000"/>
            </local-cache>
            <local-cache name="users">
                <object-memory size="10000"/>
            </local-cache>
            <distributed-cache name="sessions" owners="1" remote-timeout="30000">
                <remote-store cache="sessions" remote-servers="remote-cache" socket-timeout="60000" fetch-state="false" passivation="false" preload="false" purge="false" shared="true">
                <property name="rawValues">
                true
                </property>
                <property name="marshaller">
org.keycloak.cluster.infinispan.KeycloakHotRodMarshallerFactory
                </property>
                </remote-store>
                </distributed-cache>
            <distributed-cache name="authenticationSessions" owners="1" remote-timeout="30000">
                <remote-store cache="authenticationSessions" remote-servers="remote-cache" socket-timeout="60000" fetch-state="false" passivation="false" preload="false" purge="false" shared="true">
                <property name="rawValues">
                true
                </property>
                <property name="marshaller">
org.keycloak.cluster.infinispan.KeycloakHotRodMarshallerFactory
                </property>
                </remote-store>
                </distributed-cache>
            <distributed-cache name="offlineSessions" owners="1" remote-timeout="30000">
                <remote-store cache="offlineSessions" remote-servers="remote-cache" socket-timeout="60000" fetch-state="false" passivation="false" preload="false" purge="false" shared="true">
                <property name="rawValues">
true
                </property>
                <property name="marshaller">
org.keycloak.cluster.infinispan.KeycloakHotRodMarshallerFactory
                </property>
                </remote-store>
                </distributed-cache>
            <distributed-cache name="clientSessions" owners="1" remote-timeout="30000">
                <remote-store cache="clientSessions" remote-servers="remote-cache" socket-timeout="60000" fetch-state="false" passivation="false" preload="false" purge="false" shared="true">
                <property name="rawValues">
true
                </property>
                <property name="marshaller">
org.keycloak.cluster.infinispan.KeycloakHotRodMarshallerFactory
                </property>
                </remote-store>
                </distributed-cache>
            <distributed-cache name="offlineClientSessions" owners="1" remote-timeout="30000">
                <remote-store cache="offlineClientSessions" remote-servers="remote-cache" socket-timeout="60000" fetch-state="false" passivation="false" preload="false" purge="false" shared="true">
                <property name="rawValues">
                true
                </property>
                <property name="marshaller">
org.keycloak.cluster.infinispan.KeycloakHotRodMarshallerFactory
                </property>
                </remote-store>
                </distributed-cache>
            <distributed-cache name="loginFailures" owners="1" remote-timeout="30000">
                <remote-store cache="loginFailures" remote-servers="remote-cache" socket-timeout="60000" fetch-state="false" passivation="false" preload="false" purge="false" shared="true">
                <property name="rawValues">
                true
                </property>
                <property name="marshaller">
org.keycloak.cluster.infinispan.KeycloakHotRodMarshallerFactory
                </property>
                </remote-store>
                </distributed-cache>
            <replicated-cache name="work"/>
            <local-cache name="authorization">
                <object-memory size="10000"/>
            </local-cache>
            <local-cache name="keys">
                <object-memory size="1000"/>
                <expiration max-idle="3600000"/>
            </local-cache>
            <distributed-cache name="actionTokens" owners="1" remote-timeout="30000">
                <remote-store cache="actionTokens" remote-servers="remote-cache" socket-timeout="60000" fetch-state="false" passivation="false" preload="false" purge="false" shared="true">
                <property name="rawValues">
                true
                </property>
                <property name="marshaller">
org.keycloak.cluster.infinispan.KeycloakHotRodMarshallerFactory
                </property>
                </remote-store>
                <object-memory size="-1"/>
                <expiration max-idle="-1" interval="300000"/>
            </distributed-cache>
         </cache-container>

KeyClope套接字绑定：

<socket-binding-group name="standard-sockets" default-interface="public" port-offset="${jboss.socket.binding.port-offset:0}">
    <socket-binding name="management-http" interface="management" port="${jboss.management.http.port:9990}"/>
    <socket-binding name="management-https" interface="management" port="${jboss.management.https.port:9993}"/>
    <socket-binding name="ajp" port="${jboss.ajp.port:8009}"/>
    <socket-binding name="http" port="${jboss.http.port:8080}"/>
    <socket-binding name="https" port="${jboss.https.port:8443}"/>
    <socket-binding name="jgroups-mping" interface="private" multicast-address="${jboss.default.multicast.address:230.0.0.4}" multicast-port="45700"/>
    <socket-binding name="jgroups-tcp" interface="private" port="7600"/>
    <socket-binding name="jgroups-udp" interface="private" port="55200" multicast-address="${jboss.default.multicast.address:230.0.0.4}" multicast-port="45688"/>
    <socket-binding name="modcluster" multicast-address="${jboss.modcluster.multicast.address:224.0.1.105}" multicast-port="23364"/>
    <socket-binding name="txn-recovery-environment" port="4712"/>
    <socket-binding name="txn-status-manager" port="4713"/>
<outbound-socket-binding name="remote-cache">
<remote-destination host="my-server-domain.com" port="11222"/>  
</outbound-socket-binding>
    <outbound-socket-binding name="mail-smtp">
        <remote-destination host="localhost" port="25"/>
    </outbound-socket-binding>
</socket-binding-group>

Infinispan集群配置：

<subsystem xmlns="urn:infinispan:server:core:9.4" default-cache-container="clustered">
    <cache-container name="clustered" default-cache="default" statistics="true">
        <transport lock-timeout="60000"/>
        <global-state/>
        <distributed-cache-configuration name="transactional">
            <transaction mode="NON_XA" locking="PESSIMISTIC"/>
        </distributed-cache-configuration>
        <distributed-cache-configuration name="async" mode="ASYNC"/>
        <replicated-cache-configuration name="replicated"/>
        <distributed-cache-configuration name="persistent-file-store">
            <persistence>
                <file-store shared="false" fetch-state="true"/>
            </persistence>
        </distributed-cache-configuration>
        <distributed-cache-configuration name="indexed">
            <indexing index="LOCAL" auto-config="true"/>
        </distributed-cache-configuration>
        <distributed-cache-configuration name="memory-bounded">
            <memory>
                <binary size="10000000" eviction="MEMORY"/>
            </memory>
        </distributed-cache-configuration>
        <distributed-cache-configuration name="persistent-file-store-passivation">
            <memory>
                <object size="10000"/>
            </memory>
            <persistence passivation="true">
                <file-store shared="false" fetch-state="true">
                    <write-behind modification-queue-size="1024" thread-pool-size="1"/>
                </file-store>
            </persistence>
        </distributed-cache-configuration>
        <distributed-cache-configuration name="persistent-file-store-write-behind">
            <persistence>
                <file-store shared="false" fetch-state="true">
                    <write-behind modification-queue-size="1024" thread-pool-size="1"/>
                </file-store>
            </persistence>
        </distributed-cache-configuration>
        <distributed-cache-configuration name="persistent-rocksdb-store">
            <persistence>
                <rocksdb-store shared="false" fetch-state="true"/>
            </persistence>
        </distributed-cache-configuration>
        <distributed-cache-configuration name="persistent-jdbc-string-keyed">
            <persistence>
                <string-keyed-jdbc-store datasource="java:jboss/datasources/ExampleDS" fetch-state="true" preload="false" purge="false" shared="false">
                    <string-keyed-table prefix="ISPN">
                        <id-column name="id" type="VARCHAR"/>
                        <data-column name="datum" type="BINARY"/>
                        <timestamp-column name="version" type="BIGINT"/>
                    </string-keyed-table>
                    <write-behind modification-queue-size="1024" thread-pool-size="1"/>
                </string-keyed-jdbc-store>
            </persistence>
        </distributed-cache-configuration>
        <distributed-cache name="default"/>
        <replicated-cache name="repl" configuration="replicated"/>
        <replicated-cache name="work" configuration="replicated"/>
        <replicated-cache name="sessions" configuration="replicated"/>
        <replicated-cache name="authenticationSessions" configuration="replicated"/>
        <replicated-cache name="clientSessions" configuration="replicated"/>
        <replicated-cache name="offlineSessions" configuration="replicated"/>
        <replicated-cache name="offlineClientSessions" configuration="replicated"/>
        <replicated-cache name="actionTokens" configuration="replicated"/>
        <replicated-cache name="loginFailures" configuration="replicated"/>
    </cache-container>
</subsystem>

P、将属性“owners”从1更改为您最喜欢的值。

我希望能有所帮助。

类似资料：

Infinispan远程缓存访问

我是infinispan的新手，通过实验学习。在尝试访问不同名称的远程缓存失败后，我需要一些帮助。下面是我的infinispan客户端-服务器模式未嵌入的场景。 1）我在infinispan集群中启动了node1，并将默认远程缓存名称设置为node1\u cache--Hotrod服务器已启动 2）已在infinispan群集中启动node2，并将默认远程缓存名称设置为node2\u cach
Ceph 存储集群

所有 Ceph 部署都始于 Ceph 存储集群。基于 RADOS 的 Ceph 对象存储集群包括两类守护进程：term:对象存储守护进程（ OSD ）把存储节点上的数据存储为对象； term:Ceph 监视器（ MON ）维护集群运行图的主拷贝。一个 Ceph 集群可以包含数千个存储节点，最简系统至少需要一个监视器和两个 OSD 才能做到数据复制。 Ceph 文件系统、 Ceph 对象存储、和 C
在集群中使用infinispan无效缓存Hibernate

我在集群环境中使用Hibernate 5.4.22和Infinispan 11.0.4。Hibernate二级缓存配置为使用JCache提供程序： Infinispan由以下Infinispan.xml配置：我有一个测试实体“配置文件”，它应该用策略缓存：根据缓存并发策略/缓存模式兼容性表，
Infinispan：锁定远程事务缓存

我们尝试使用infinispan作为带有读锁的远程缓存。客户通过“put”进行读取，以获得钥匙锁，正如悲观事务缓存“When cache.put（k1，v1）返回时”一节中所述的infinispan文档，k1被锁定，集群中任何地方运行的其他事务都无法对其进行写入。仍然可以读取k1。当事务完成（提交或回滚）时，k1上的锁被释放。因此，该场景：远程缓存配置为具有悲观锁定的事务性缓存：客户端正在使用
Ceph 存储集群 API

Ceph 存储集群提供了消息传递层协议，用于客户端与 Ceph 监视器和 OSD 交互， librados 以库形式为 Ceph 客户端提供了这个功能。所有 Ceph 客户端可以用 librados 或 librados 里封装的相同功能和对象存储交互，例如 librbd 和 libcephfs 就利用了此功能。你可以用 librados 直接和 Ceph 交互（如和 Ceph 兼容的应用程序、你
将spark-submit配置到远程AWS EMR集群

我们正在EC2实例上构建一个airflow服务器，该服务器与EMR集群通信以运行spark作业。我们试图提交一个BashOperator DAG，它为一个简单的wordcount应用程序运行spark-submit命令。下面是我们的spark提交命令：我们得到以下错误：线程“main”org.apache.spark.sparkException中的异常：当使用主“yarn”运行时，必须在环境中

Keycloak：专用Infinispan集群的远程存储配置

共有2个答案

相关问答

相关文章

相关阅读

相关工具

相关文档