Lafen Keycloak am HA Modus op Kubernetes

TL; DR: et gëtt eng Beschreiwung vu Keycloak, en Open Source Zougangskontrollsystem, Analyse vun der interner Struktur, Konfiguratiounsdetailer.

Aféierung a Schlëssel Iddien

An dësem Artikel wäerte mir d'Basis Iddien gesinn fir am Kapp ze halen wann Dir e Keycloak Cluster op Kubernetes ofsetzt.

Wann Dir méi iwwer Keycloak wësse wëllt, kuckt op d'Links um Enn vum Artikel. Fir méi an der Praxis ënnerzegoen, kënnt Dir studéieren eise Repository mat engem Modul deen d'Haaptiddi vun dësem Artikel implementéiert (de Startguide ass do, dësen Artikel gëtt en Iwwerbléck iwwer den Apparat an d'Astellungen, ca. Iwwersetzer).

Keycloak ass e komplette System geschriwwen a Java an uewen op engem Applikatiounsserver gebaut Wildfly. Kuerz gesot, et ass e Kader fir d'Autorisatioun, deen d'Applikatioun Benotzer Federatioun an SSO (Single Sign-on) Fäegkeeten gëtt.

Mir invitéieren Iech den offiziellen ze liesen Websäit oder Wikipedia fir detailléiert Versteesdemech.

Keycloak starten

Keycloak erfuerdert zwou persistent Datequellen fir ze lafen:

• Eng Datebank déi benotzt gëtt fir etabléiert Donnéeën ze späicheren, sou wéi Benotzerinformatioun
• Datagrid Cache, dee benotzt gëtt fir Daten aus der Datebank ze cache, souwéi fir e puer kuerzlieweg an dacks verännerend Metadaten ze späicheren, sou wéi Benotzersessiounen. Ëmgesat Infinispan, déi normalerweis däitlech méi séier ass wéi d'Datebank. Awer op alle Fall sinn d'Daten, déi am Infinispan gespäichert sinn, ephemeral - an et muss net iwwerall gespäichert ginn wann de Stärekoup nei gestart gëtt.

Keycloak funktionnéiert a véier verschiddene Modi:

• gewéinlech - een an nëmmen ee Prozess, konfiguréiert iwwer eng Datei standalone.xml
• Regelméisseg Cluster (Héich Disponibilitéit Optioun) - all Prozesser mussen déi selwecht Configuratioun benotzen, déi manuell synchroniséiert muss. Astellunge ginn an enger Datei gespäichert standalone-ha.xml, Zousätzlech musst Dir e gemeinsame Zougang zu der Datebank an e Lastbalancer maachen.
• Domain Cluster - e Cluster am normalen Modus starten gëtt séier eng Routine a langweileg Aufgab wéi de Cluster wiisst, well all Kéier wann d'Konfiguratioun ännert, musse all Ännerungen op all Cluster Node gemaach ginn. Domain Operatiounsmodus léist dëst Thema andeems Dir e puer gemeinsame Späicherplaz opstellt an d'Konfiguratioun publizéiert. Dës Astellunge sinn an der Datei gespäichert domain.xml
• Replikatioun tëscht Datenzentren - wann Dir Keycloak an engem Cluster vu verschiddenen Datenzentere wëllt lafen, meeschtens op verschiddene geographesche Plazen. An dëser Optioun wäert all Datenzenter säin eegene Cluster vu Keycloak Serveren hunn.

An dësem Artikel wäerte mir am Detail déi zweet Optioun betruecht, dat ass regelméisseg Cluster, a mir wäerten och e bëssen iwwer d'Thema vun der Replikatioun tëscht Datenzenter beréieren, well et Sënn mécht dës zwou Optiounen an Kubernetes ze lafen. Glécklecherweis gëtt et a Kubernetes kee Problem mat der Synchroniséierung vun den Astellunge vu verschiddene Pods (Keycloak Node), also Domain Cluster Et wäert net ganz schwéier sinn ze maachen.

Notéiert och weg datt d'Wuert Stärekoup fir de Rescht vum Artikel gëlt eleng fir eng Grupp vu Keycloak Noden déi zesumme schaffen, et ass net néideg op e Kubernetes Cluster ze referenzéieren.

Regelméisseg Keycloak Cluster

Fir Keycloak an dësem Modus ze lafen braucht Dir:

• extern gedeelt Datebank konfiguréieren
• installéieren Laaschtbalancer
• hunn en internt Netzwierk mat IP Multicast Ënnerstëtzung

Mir diskutéieren net iwwer d'Opstelle vun enger externer Datebank, well et net den Zweck vun dësem Artikel ass. Loosst eis unhuelen datt et iergendwou eng Aarbechtsdatenbank gëtt - a mir hunn e Verbindungspunkt dozou. Mir addéieren dës Donnéeën einfach un d'Ëmfeldvariablen.

Fir besser ze verstoen wéi Keycloak an engem Failover (HA) Stärekoup funktionnéiert, ass et wichteg ze wëssen wéi vill et alles vun de Clusterfäegkeeten vum Wildfly hänkt.

Wildfly benotzt verschidde Subsystemer, e puer vun hinnen ginn als Lastbalancer benotzt, e puer fir Feelertoleranz. D'Laaschtbalancer suergt fir d'Disponibilitéit vun der Applikatioun wann e Cluster Node iwwerlaascht ass, a Feeler Toleranz garantéiert d'Disponibilitéit vun der Applikatioun och wann e puer Clusternoden versoen. E puer vun dësen Ënnersystemer:

• mod_cluster: Schafft a Verbindung mat Apache als HTTP-Laaschtbalancer, hänkt vun TCP Multicast of fir Hosten als Standard ze fannen. Kann duerch en externen Equiliber ersat ginn.

• infinispan: A verdeelt Cache benotzt JGroups Channels als Transport Layer. Zousätzlech kann et den HotRod Protokoll benotze fir mat engem externen Infinispan Cluster ze kommunizéieren fir Cache Inhalter ze synchroniséieren.

• jgroups: Bitt Grupp Kommunikatioun Ënnerstëtzung fir héich verfügbare Servicer baséiert op JGroups Channels. Benannt Päifen erlaben Applikatiounsinstanzen an engem Cluster a Gruppen ze verbannen, sou datt d'Kommunikatioun Eegeschaften huet wéi Zouverlässegkeet, Uerdnung, a Sensibilitéit fir Feeler.

Load Balancer

Wann Dir e Balancer als Ingress Controller an engem Kubernetes Cluster installéiert, ass et wichteg déi folgend Saachen am Kapp ze halen:

Keycloak gëtt ugeholl datt d'Remote Adress vum Client, deen iwwer HTTP mam Authentifikatiounsserver verbënnt, déi richteg IP Adress vum Clientcomputer ass. Balancer an Ingress Astellunge sollten HTTP Header korrekt setzen X-Forwarded-For и X-Forwarded-Proto, an och den Originaltitel späicheren HOST. Läscht Versioun ingress-nginx (>0.22.0) deaktivéiert dëst Par défaut

Fändel aktivéieren proxy-address-forwarding andeems Dir eng Ëmfeldvariabel setzt PROXY_ADDRESS_FORWARDING в true gëtt Keycloak d'Verständnis datt et hannert engem Proxy funktionnéiert.

Dir musst och aktivéieren plakeg Sessiounen an Agrëff. Keycloak benotzt e verdeelt Infinispan Cache fir Daten ze späicheren, déi mat der aktueller Authentifikatiounssession an der Benotzersitzung verbonne sinn. Cache funktionnéieren par défaut mat engem eenzege Besëtzer, an anere Wierder, déi bestëmmte Sessioun ass op e puer Node am Cluster gespäichert, an aner Wirbelen mussen et op afstand ufroen wa se Zougang zu där Sessioun brauchen.

Konkret, am Géigesaz zu der Dokumentatioun, eng Sessioun mam Numm Cookie ze befestegt huet fir eis net geschafft AUTH_SESSION_ID. Keycloak huet eng Viruleedung Loop, sou datt mir recommandéieren en anere Cookie Numm fir déi plakeg Sessioun ze wielen.

Keycloak befestegt och den Numm vum Node op deen als éischt geäntwert huet AUTH_SESSION_ID, a well all Node an der héich verfügbarer Versioun déiselwecht Datebank benotzt, jidderee vun hinnen muss hunn eng separat an eenzegaarteg Node Identifizéierer fir Gestioun Transaktiounen. Et ass recommandéiert ze setzen JAVA_OPTS Parameteren jboss.node.name и jboss.tx.node.id eenzegaarteg fir all Node - Dir kënnt zum Beispill den Numm vum Pod setzen. Wann Dir e Podnumm setzt, vergiesst net iwwer d'23 Charakterlimit fir jboss Variablen, also ass et besser e StatefulSet ze benotzen anstatt en Deployment.

Eng aner Rake - wann de Pod geläscht oder nei gestart gëtt, ass säi Cache verluer. Wann Dir dëst berücksichtegt, ass et derwäert d'Zuel vun de Cache-Besëtzer fir all Cache op d'mannst zwee ze setzen, sou datt eng Kopie vum Cache bleift. D'Léisung ass ze lafen Skript fir Wildfly wann Dir de Pod ufänkt, setzt se an de Verzeechnes /opt/jboss/startup-scripts am Container:

Skript Inhalt

embed-server --server-config=standalone-ha.xml --std-out=echo
batch

echo * Setting CACHE_OWNERS to "${env.CACHE_OWNERS}" in all cache-containers

/subsystem=infinispan/cache-container=keycloak/distributed-cache=sessions:write-attribute(name=owners, value=${env.CACHE_OWNERS:1})
/subsystem=infinispan/cache-container=keycloak/distributed-cache=authenticationSessions:write-attribute(name=owners, value=${env.CACHE_OWNERS:1})
/subsystem=infinispan/cache-container=keycloak/distributed-cache=actionTokens:write-attribute(name=owners, value=${env.CACHE_OWNERS:1})
/subsystem=infinispan/cache-container=keycloak/distributed-cache=offlineSessions:write-attribute(name=owners, value=${env.CACHE_OWNERS:1})
/subsystem=infinispan/cache-container=keycloak/distributed-cache=clientSessions:write-attribute(name=owners, value=${env.CACHE_OWNERS:1})
/subsystem=infinispan/cache-container=keycloak/distributed-cache=offlineClientSessions:write-attribute(name=owners, value=${env.CACHE_OWNERS:1})
/subsystem=infinispan/cache-container=keycloak/distributed-cache=loginFailures:write-attribute(name=owners, value=${env.CACHE_OWNERS:1})

run-batch
stop-embedded-server

setzt dann de Wäert vun der Ëmfeldvariabel CACHE_OWNERS op déi néideg.

Privat Netzwierk mat IP Multicast Ënnerstëtzung

Wann Dir Weavenet als CNI benotzt, funktionnéiert Multicast direkt - an Är Keycloak Node gesinn sech soubal se lancéiert ginn.

Wann Dir keng IP Multicast Support an Ärem Kubernetes Cluster hutt, kënnt Dir JGroups konfiguréieren fir mat anere Protokoller ze schaffen fir Noden ze fannen.

Déi éischt Optioun ass ze benotzen KUBE_DNSdéi benotzt headless service fir Keycloak Wirbelen ze fannen, gitt Dir einfach JGroups den Numm vum Service deen benotzt gëtt fir d'Noden ze fannen.

Eng aner Optioun ass d'Methode ze benotzen KUBE_PING, déi mat der API funktionnéiert fir no Noden ze sichen (Dir musst konfiguréieren serviceAccount mat Rechter list и get, an dann d'Pods konfiguréieren fir mat dësem ze schaffen serviceAccount).

De Wee wéi JGroups Noden fannen ass konfiguréiert andeems Dir Ëmfeldvariablen setzt JGROUPS_DISCOVERY_PROTOCOL и JGROUPS_DISCOVERY_PROPERTIES. fir KUBE_PING Dir musst Pods auswielen andeems Dir frot namespace и labels.

️ Wann Dir Multicast benotzt an zwee oder méi Keycloak Cluster an engem Kubernetes Cluster leeft (loosst eis een am Nummraum soen production, déi zweet - staging) - Node vun engem Keycloak Stärekoup kënnen an engem anere Stärekoup bäitrieden. Gitt sécher eng eenzegaarteg Multicast Adress fir all Stärekoup ze benotzen andeems Dir Variabelen setztjboss.default.multicast.address и jboss.modcluster.multicast.address в JAVA_OPTS.

Replikatioun tëscht Datenzentren

Konnektivitéit

Keycloak benotzt verschidde getrennten Infinispan Cache Cluster fir all Datenzenter wou Keycloack Cluster aus Keycloak Noden sinn. Awer et gëtt keen Ënnerscheed tëscht Keycloak Noden a verschiddenen Rechenzentren.

Keycloak Node benotzen en externen Java Data Grid (Infinispan Server) fir Kommunikatioun tëscht Datenzenteren. Kommunikatioun funktionnéiert no dem Protokoll Infinispan HotRod.

Infinispan Cache musse mam Attribut konfiguréiert sinn remoteStore, sou datt d'Donnéeën op afstand gespäichert kënne ginn (an engem aneren Datenzenter, ca. Iwwersetzer) Cache. Et gi separat infinispan Cluster tëscht de JDG Serveren, sou datt d'Donnéeën op JDG1 op der Plaz gespäichert sinn site1 wäert op JDG2 op der Plaz replizéiert ginn site2.

A schliisslech informéiert den Empfang JDG Server de Keycloak Server vu sengem Cluster duerch Clientverbindungen, wat e Feature vum HotRod Protokoll ass. Keycloak Noden op site2 update hir Infinispan Cache an déi spezifesch Benotzer Sessioun gëtt och verfügbar op de Keycloak Noden op site2.

Fir e puer Cache ass et och méiglech keng Backups ze maachen an d'Donnéeën komplett iwwer den Infinispan Server ze schreiwen. Fir dëst ze maachen, musst Dir d'Astellung erofhuelen remote-store spezifesche Infinispan Cache (an der Datei standalone-ha.xml), duerno e puer spezifesch replicated-cache wäert och net méi op der Infinispan Server Säit néideg ginn.

Cache opsetzen

Et ginn zwou Zorte vu Cache am Keycloak:

• Lokal. Et läit nieft der Datebank an déngt fir d'Laascht op der Datebank ze reduzéieren, souwéi d'Äntwertlatenz ze reduzéieren. Dës Zort Cache späichert Räich, Clienten, Rollen a Benotzermetadaten. Dës Zort Cache gëtt net replizéiert, och wann de Cache Deel vun engem Keycloak Cluster ass. Wann eng Entrée am Cache ännert, gëtt e Message iwwer d'Ännerung un déi verbleiwen Serveren am Cluster geschéckt, duerno gëtt d'Entrée aus dem Cache ausgeschloss. Gesinn Beschreiwung work Kuckt hei ënnen fir eng méi detailléiert Beschreiwung vun der Prozedur.

• Replizéiert. Veraarbechtt Benotzersessiounen, offline Tokens, an iwwerwaacht och Loginfehler fir Passwuert Phishing Versich an aner Attacken z'entdecken. D'Daten, déi an dëse Cache gespäichert sinn, sinn temporär, nëmmen am RAM gespäichert, awer kënnen iwwer de Cluster replizéiert ginn.

Infinispan Cache

Sëtzungen - e Konzept an Keycloak, separat Cache genannt authenticationSessions, gi benotzt fir Daten vu spezifesche Benotzer ze späicheren. Ufroe vun dëse Cache ginn normalerweis vum Browser a Keycloak Server gebraucht, net vun Uwendungen. Dëst ass wou d'Ofhängegkeet vu Sticky Sessiounen an d'Spill kënnt, an esou Cache selwer brauche net replizéiert ze ginn, och am Fall vum Active-Active Modus.

Aktioun Tokens. En anert Konzept, normalerweis fir verschidden Szenarie benotzt, wann zum Beispill de Benotzer eppes asynchron per Mail muss maachen. Zum Beispill, während der Prozedur forget password Cache actionTokens benotzt fir Metadaten vun assoziéierten Token ze verfolgen - zum Beispill, en Token gouf scho benotzt a kann net erëm ageschalt ginn. Dës Zort Cache muss typesch tëscht Datenzenter replizéiert ginn.

Caching an Alterung vun gespäichert Daten funktionnéiert fir d'Laascht op der Datebank ze entlaaschten. Dës Aart vu Caching verbessert d'Performance, awer füügt en offensichtleche Problem. Wann ee Keycloak-Server Daten aktualiséiert, mussen déi aner Serveren informéiert ginn, fir datt se d'Donnéeën an hire Cache aktualiséieren. Keycloak benotzt lokal Cache realms, users и authorization fir Daten aus der Datebank ze cachen.

Et gëtt och e separaten Cache work, déi iwwer all Datenzenter replizéiert gëtt. Et selwer späichert keng Daten aus der Datebank, awer déngt fir Messagen iwwer Datenalterung op Clusternoden tëscht Datenzenteren ze schécken. An anere Wierder, soubal d'Donnéeën aktualiséiert ginn, schéckt de Keycloak Node e Message un aner Wirbelen an hirem Rechenzentrum, souwéi Knäpper an aneren Rechenzentren. Nodeems Dir esou e Message kritt hutt, läscht all Node déi entspriechend Donnéeën a senge lokalen Cache.

Benotzer Sessiounen. Cache mat Nimm sessions, clientSessions, offlineSessions и offlineClientSessions, ginn normalerweis tëscht Datenzenter replizéiert an déngen fir Daten iwwer Benotzersessiounen ze späicheren déi aktiv sinn, während de Benotzer am Browser aktiv ass. Dës Cache funktionnéieren mat der Applikatioun déi HTTP-Ufroe vun Endbenotzer veraarbecht, sou datt se mat plakeg Sessiounen assoziéiert sinn a musse replizéiert ginn tëscht Datenzenteren.

Brute Kraaft Schutz. Cache loginFailures Benotzt fir Umeldungsfehlerdaten ze verfolgen, wéi wéi oft e Benotzer e falscht Passwuert aginn huet. Replikatioun vun dësem Cache ass d'Verantwortung vum Administrateur. Awer fir eng korrekt Berechnung ass et derwäert d'Replikatioun tëscht Datenzenteren z'aktivéieren. Awer op der anerer Säit, wann Dir dës Donnéeën net replizéiert, wäert Dir d'Performance verbesseren, a wann dëst Thema entsteet, kann d'Replikatioun net aktivéiert ginn.

Wann Dir en Infinispan-Cluster ausrollt, musst Dir Cache-Definitiounen an d'Astellungsdatei addéieren:

<replicated-cache-configuration name="keycloak-sessions" mode="ASYNC" start="EAGER" batching="false">
</replicated-cache-configuration>

<replicated-cache name="work" configuration="keycloak-sessions" />
<replicated-cache name="sessions" configuration="keycloak-sessions" />
<replicated-cache name="offlineSessions" configuration="keycloak-sessions" />
<replicated-cache name="actionTokens" configuration="keycloak-sessions" />
<replicated-cache name="loginFailures" configuration="keycloak-sessions" />
<replicated-cache name="clientSessions" configuration="keycloak-sessions" />
<replicated-cache name="offlineClientSessions" configuration="keycloak-sessions" />

Dir musst den Infinispan Cluster konfiguréieren an starten ier Dir de Keycloak Cluster ufänkt

Da musst Dir konfiguréieren remoteStore fir Keycloak Cache. Fir dëst ze maachen ass e Skript genuch, deen ähnlech wéi dee virdrun gemaach gëtt, deen benotzt gëtt fir d'Variabel ze setzen CACHE_OWNERS, Dir musst et an eng Datei späicheren an en an engem Verzeichnis setzen /opt/jboss/startup-scripts:

Skript Inhalt

embed-server --server-config=standalone-ha.xml --std-out=echo
batch

echo *** Update infinispan subsystem ***
/subsystem=infinispan/cache-container=keycloak:write-attribute(name=module, value=org.keycloak.keycloak-model-infinispan)

echo ** Add remote socket binding to infinispan server **
/socket-binding-group=standard-sockets/remote-destination-outbound-socket-binding=remote-cache:add(host=${remote.cache.host:localhost}, port=${remote.cache.port:11222})

echo ** Update replicated-cache work element **
/subsystem=infinispan/cache-container=keycloak/replicated-cache=work/store=remote:add( 
    passivation=false, 
    fetch-state=false, 
    purge=false, 
    preload=false, 
    shared=true, 
    remote-servers=["remote-cache"], 
    cache=work, 
    properties={ 
        rawValues=true, 
        marshaller=org.keycloak.cluster.infinispan.KeycloakHotRodMarshallerFactory, 
        protocolVersion=${keycloak.connectionsInfinispan.hotrodProtocolVersion} 
    } 
)

/subsystem=infinispan/cache-container=keycloak/replicated-cache=work:write-attribute(name=statistics-enabled,value=true)

echo ** Update distributed-cache sessions element **
/subsystem=infinispan/cache-container=keycloak/distributed-cache=sessions/store=remote:add( 
    passivation=false, 
    fetch-state=false, 
    purge=false, 
    preload=false, 
    shared=true, 
    remote-servers=["remote-cache"], 
    cache=sessions, 
    properties={ 
        rawValues=true, 
        marshaller=org.keycloak.cluster.infinispan.KeycloakHotRodMarshallerFactory, 
        protocolVersion=${keycloak.connectionsInfinispan.hotrodProtocolVersion} 
    } 
)
/subsystem=infinispan/cache-container=keycloak/distributed-cache=sessions:write-attribute(name=statistics-enabled,value=true)

echo ** Update distributed-cache offlineSessions element **
/subsystem=infinispan/cache-container=keycloak/distributed-cache=offlineSessions/store=remote:add( 
    passivation=false, 
    fetch-state=false, 
    purge=false, 
    preload=false, 
    shared=true, 
    remote-servers=["remote-cache"], 
    cache=offlineSessions, 
    properties={ 
        rawValues=true, 
        marshaller=org.keycloak.cluster.infinispan.KeycloakHotRodMarshallerFactory, 
        protocolVersion=${keycloak.connectionsInfinispan.hotrodProtocolVersion} 
    } 
)
/subsystem=infinispan/cache-container=keycloak/distributed-cache=offlineSessions:write-attribute(name=statistics-enabled,value=true)

echo ** Update distributed-cache clientSessions element **
/subsystem=infinispan/cache-container=keycloak/distributed-cache=clientSessions/store=remote:add( 
    passivation=false, 
    fetch-state=false, 
    purge=false, 
    preload=false, 
    shared=true, 
    remote-servers=["remote-cache"], 
    cache=clientSessions, 
    properties={ 
        rawValues=true, 
        marshaller=org.keycloak.cluster.infinispan.KeycloakHotRodMarshallerFactory, 
        protocolVersion=${keycloak.connectionsInfinispan.hotrodProtocolVersion} 
    } 
)
/subsystem=infinispan/cache-container=keycloak/distributed-cache=clientSessions:write-attribute(name=statistics-enabled,value=true)

echo ** Update distributed-cache offlineClientSessions element **
/subsystem=infinispan/cache-container=keycloak/distributed-cache=offlineClientSessions/store=remote:add( 
    passivation=false, 
    fetch-state=false, 
    purge=false, 
    preload=false, 
    shared=true, 
    remote-servers=["remote-cache"], 
    cache=offlineClientSessions, 
    properties={ 
        rawValues=true, 
        marshaller=org.keycloak.cluster.infinispan.KeycloakHotRodMarshallerFactory, 
        protocolVersion=${keycloak.connectionsInfinispan.hotrodProtocolVersion} 
    } 
)
/subsystem=infinispan/cache-container=keycloak/distributed-cache=offlineClientSessions:write-attribute(name=statistics-enabled,value=true)

echo ** Update distributed-cache loginFailures element **
/subsystem=infinispan/cache-container=keycloak/distributed-cache=loginFailures/store=remote:add( 
    passivation=false, 
    fetch-state=false, 
    purge=false, 
    preload=false, 
    shared=true, 
    remote-servers=["remote-cache"], 
    cache=loginFailures, 
    properties={ 
        rawValues=true, 
        marshaller=org.keycloak.cluster.infinispan.KeycloakHotRodMarshallerFactory, 
        protocolVersion=${keycloak.connectionsInfinispan.hotrodProtocolVersion} 
    } 
)
/subsystem=infinispan/cache-container=keycloak/distributed-cache=loginFailures:write-attribute(name=statistics-enabled,value=true)

echo ** Update distributed-cache actionTokens element **
/subsystem=infinispan/cache-container=keycloak/distributed-cache=actionTokens/store=remote:add( 
    passivation=false, 
    fetch-state=false, 
    purge=false, 
    preload=false, 
    shared=true, 
    cache=actionTokens, 
    remote-servers=["remote-cache"], 
    properties={ 
        rawValues=true, 
        marshaller=org.keycloak.cluster.infinispan.KeycloakHotRodMarshallerFactory, 
        protocolVersion=${keycloak.connectionsInfinispan.hotrodProtocolVersion} 
    } 
)
/subsystem=infinispan/cache-container=keycloak/distributed-cache=actionTokens:write-attribute(name=statistics-enabled,value=true)

echo ** Update distributed-cache authenticationSessions element **
/subsystem=infinispan/cache-container=keycloak/distributed-cache=authenticationSessions:write-attribute(name=statistics-enabled,value=true)

echo *** Update undertow subsystem ***
/subsystem=undertow/server=default-server/http-listener=default:write-attribute(name=proxy-address-forwarding,value=true)

run-batch
stop-embedded-server

Vergiesst net ze installéieren JAVA_OPTS fir Keycloak Noden fir HotRod ze lafen: remote.cache.host, remote.cache.port an Service Numm jboss.site.name.

Linken an zousätzlech Dokumentatioun

• https://www.keycloak.org/docs/latest/server_installation/index.html
• https://docs.wildfly.org/17/High_Availability_Guide.html#cluster-configuration
• https://infinispan.org/docs/9.4.x/user_guide/user_guide.html
• https://hub.docker.com/r/jboss/keycloak
• https://hub.docker.com/r/jboss/infinispan

Den Artikel gouf vu Mataarbechter iwwersat a virbereet fir Habr Slurm Training Zentrum - intensiv Coursen, Videocoursen a Firmenausbildung vu praktizéierende Spezialisten (Kubernetes, DevOps, Docker, Ansible, Ceph, SRE)

Source: will.com