కుబెర్నెట్స్‌లో HA మోడ్‌లో కీక్లోక్ రన్ అవుతోంది

TL; DR: Keycloak యొక్క వివరణ, ఓపెన్ సోర్స్ యాక్సెస్ కంట్రోల్ సిస్టమ్, అంతర్గత నిర్మాణం యొక్క విశ్లేషణ, కాన్ఫిగరేషన్ వివరాలు ఉంటాయి.

పరిచయం మరియు ముఖ్య ఆలోచనలు

ఈ ఆర్టికల్‌లో, Kubernetes పైన కీక్లోక్ క్లస్టర్‌ని అమర్చేటప్పుడు గుర్తుంచుకోవలసిన ప్రాథమిక ఆలోచనలను మేము చూస్తాము.

మీరు కీక్లోక్ గురించి మరింత తెలుసుకోవాలనుకుంటే, వ్యాసం చివర ఉన్న లింక్‌లను చూడండి. అభ్యాసంలో మరింత మునిగిపోవడానికి, మీరు చదువుకోవచ్చు మా రిపోజిటరీ ఈ కథనం యొక్క ప్రధాన ఆలోచనలను అమలు చేసే మాడ్యూల్‌తో (లాంచ్ గైడ్ ఉంది, ఈ కథనం పరికరం మరియు సెట్టింగ్‌ల యొక్క అవలోకనాన్ని అందిస్తుంది, సుమారు అనువాదకుడు).

కీక్లోక్ అనేది జావాలో వ్రాయబడిన మరియు అప్లికేషన్ సర్వర్ పైన నిర్మించబడిన సమగ్ర వ్యవస్థ వైల్డ్‌ఫ్లై. సంక్షిప్తంగా, ఇది అప్లికేషన్ వినియోగదారులకు సమాఖ్య మరియు SSO (సింగిల్ సైన్-ఆన్) సామర్థ్యాలను అందించే అధికారం కోసం ఒక ఫ్రేమ్‌వర్క్.

అధికారికంగా చదవమని మేము మిమ్మల్ని ఆహ్వానిస్తున్నాము వెబ్సైట్ లేదా వికీపీడియా వివరణాత్మక అవగాహన కోసం.

కీక్లాక్‌ని ప్రారంభిస్తోంది

Keycloak అమలు చేయడానికి రెండు నిరంతర డేటా మూలాధారాలు అవసరం:

• వినియోగదారు సమాచారం వంటి స్థాపించబడిన డేటాను నిల్వ చేయడానికి ఉపయోగించే డేటాబేస్
• డేటాగ్రిడ్ కాష్, ఇది డేటాబేస్ నుండి డేటాను కాష్ చేయడానికి, అలాగే వినియోగదారు సెషన్‌ల వంటి స్వల్పకాలిక మరియు తరచుగా మారుతున్న మెటాడేటాను నిల్వ చేయడానికి ఉపయోగించబడుతుంది. అమలు చేశారు ఇన్ఫినిస్పాన్, ఇది సాధారణంగా డేటాబేస్ కంటే చాలా వేగంగా ఉంటుంది. ఏ సందర్భంలోనైనా, ఇన్ఫినిస్పాన్‌లో సేవ్ చేయబడిన డేటా అశాశ్వతమైనది - మరియు క్లస్టర్ పునఃప్రారంభించబడినప్పుడు అది ఎక్కడైనా సేవ్ చేయవలసిన అవసరం లేదు.

కీక్లోక్ నాలుగు వేర్వేరు మోడ్‌లలో పనిచేస్తుంది:

• సాధారణ - ఒకే ఒక ప్రక్రియ, ఫైల్ ద్వారా కాన్ఫిగర్ చేయబడింది స్వతంత్ర.xml
• రెగ్యులర్ క్లస్టర్ (అధిక లభ్యత ఎంపిక) - అన్ని ప్రక్రియలు తప్పనిసరిగా ఒకే కాన్ఫిగరేషన్‌ను ఉపయోగించాలి, ఇది మానవీయంగా సమకాలీకరించబడాలి. సెట్టింగ్‌లు ఫైల్‌లో నిల్వ చేయబడతాయి స్వతంత్ర-ha.xml, అదనంగా మీరు డేటాబేస్ మరియు లోడ్ బ్యాలెన్సర్‌కు భాగస్వామ్య యాక్సెస్ చేయాలి.
• డొమైన్ క్లస్టర్ — సాధారణ మోడ్‌లో క్లస్టర్‌ను ప్రారంభించడం అనేది క్లస్టర్ పెరిగేకొద్దీ త్వరగా సాధారణ మరియు బోరింగ్ టాస్క్‌గా మారుతుంది, ప్రతిసారీ కాన్ఫిగరేషన్ మారినప్పుడు, ప్రతి క్లస్టర్ నోడ్‌లో తప్పనిసరిగా అన్ని మార్పులు చేయాలి. కొన్ని భాగస్వామ్య నిల్వ స్థానాన్ని సెటప్ చేయడం మరియు కాన్ఫిగరేషన్‌ను ప్రచురించడం ద్వారా డొమైన్ మోడ్ ఆపరేషన్ ఈ సమస్యను పరిష్కరిస్తుంది. ఈ సెట్టింగ్‌లు ఫైల్‌లో నిల్వ చేయబడతాయి domain.xml
• డేటా కేంద్రాల మధ్య ప్రతిరూపం — మీరు కీక్లోక్‌ని అనేక డేటా సెంటర్‌ల క్లస్టర్‌లో అమలు చేయాలనుకుంటే, చాలా తరచుగా వివిధ భౌగోళిక స్థానాల్లో. ఈ ఎంపికలో, ప్రతి డేటా సెంటర్‌కి దాని స్వంత కీక్లోక్ సర్వర్‌ల క్లస్టర్ ఉంటుంది.

ఈ వ్యాసంలో మేము రెండవ ఎంపికను వివరంగా పరిశీలిస్తాము, అనగా సాధారణ క్లస్టర్, మరియు మేము డేటా సెంటర్‌ల మధ్య ప్రతిరూపణ అనే అంశంపై కూడా కొంచెం టచ్ చేస్తాము, ఎందుకంటే ఈ రెండు ఎంపికలను కుబెర్నెట్స్‌లో అమలు చేయడం అర్ధమే. అదృష్టవశాత్తూ, కుబెర్నెట్స్‌లో అనేక పాడ్‌ల (కీక్లోక్ నోడ్స్) సెట్టింగ్‌లను సమకాలీకరించడంలో సమస్య లేదు. డొమైన్ క్లస్టర్ దీన్ని చేయడం చాలా కష్టం కాదు.

అనే పదాన్ని కూడా దయచేసి గమనించండి క్లస్టర్ మిగిలిన కథనం కలిసి పనిచేసే కీక్లోక్ నోడ్‌ల సమూహానికి మాత్రమే వర్తిస్తుంది, కుబెర్నెటెస్ క్లస్టర్‌ని సూచించాల్సిన అవసరం లేదు.

రెగ్యులర్ కీక్లోక్ క్లస్టర్

ఈ మోడ్‌లో కీక్లోక్‌ని అమలు చేయడానికి మీకు ఇది అవసరం:

• బాహ్య భాగస్వామ్య డేటాబేస్ను కాన్ఫిగర్ చేయండి
• లోడ్ బాలన్సర్‌ను ఇన్‌స్టాల్ చేయండి
• IP మల్టీకాస్ట్ మద్దతుతో అంతర్గత నెట్‌వర్క్‌ను కలిగి ఉండండి

బాహ్య డేటాబేస్ను సెటప్ చేయడం గురించి మేము చర్చించము, ఎందుకంటే ఇది ఈ కథనం యొక్క ఉద్దేశ్యం కాదు. ఎక్కడో పని చేసే డేటాబేస్ ఉందని అనుకుందాం - మరియు దానికి మనకు కనెక్షన్ పాయింట్ ఉంది. మేము ఈ డేటాను ఎన్విరాన్మెంట్ వేరియబుల్స్‌కు జోడిస్తాము.

ఫెయిల్‌ఓవర్ (HA) క్లస్టర్‌లో కీక్లోక్ ఎలా పనిచేస్తుందో బాగా అర్థం చేసుకోవడానికి, వైల్డ్‌ఫ్లై యొక్క క్లస్టరింగ్ సామర్థ్యాలపై ఇది ఎంతవరకు ఆధారపడి ఉంటుందో తెలుసుకోవడం ముఖ్యం.

వైల్డ్‌ఫ్లై అనేక సబ్‌సిస్టమ్‌లను ఉపయోగిస్తుంది, వాటిలో కొన్ని లోడ్ బ్యాలెన్సర్‌గా ఉపయోగించబడతాయి, కొన్ని తప్పు సహనం కోసం ఉపయోగించబడతాయి. క్లస్టర్ నోడ్ ఓవర్‌లోడ్ అయినప్పుడు లోడ్ బ్యాలెన్సర్ అప్లికేషన్ లభ్యతను నిర్ధారిస్తుంది మరియు కొన్ని క్లస్టర్ నోడ్‌లు విఫలమైనప్పటికీ ఫాల్ట్ టాలరెన్స్ అప్లికేషన్ లభ్యతను నిర్ధారిస్తుంది. ఈ ఉపవ్యవస్థలలో కొన్ని:

• mod_cluster: HTTP లోడ్ బ్యాలెన్సర్‌గా Apacheతో కలిసి పని చేస్తుంది, డిఫాల్ట్‌గా హోస్ట్‌లను కనుగొనడానికి TCP మల్టీక్యాస్ట్‌పై ఆధారపడి ఉంటుంది. బాహ్య బాలన్సర్‌తో భర్తీ చేయవచ్చు.

• infinispan: రవాణా పొరగా JGroups ఛానెల్‌లను ఉపయోగించి పంపిణీ చేయబడిన కాష్. అదనంగా, ఇది కాష్ కంటెంట్‌లను సమకాలీకరించడానికి బాహ్య ఇన్ఫినిస్పాన్ క్లస్టర్‌తో కమ్యూనికేట్ చేయడానికి HotRod ప్రోటోకాల్‌ను ఉపయోగించవచ్చు.

• jgroups: JGroups ఛానెల్‌ల ఆధారంగా అత్యంత అందుబాటులో ఉన్న సేవలకు సమూహ కమ్యూనికేషన్ మద్దతును అందిస్తుంది. పేరు పెట్టబడిన పైపులు క్లస్టర్‌లోని అప్లికేషన్ ఇన్‌స్టాన్స్‌లను గ్రూపులుగా కనెక్ట్ చేయడానికి అనుమతిస్తాయి, తద్వారా కమ్యూనికేషన్ విశ్వసనీయత, క్రమబద్ధత మరియు వైఫల్యాలకు సున్నితత్వం వంటి లక్షణాలను కలిగి ఉంటుంది.

లోడ్ బ్యాలెన్సర్

కుబెర్నెటెస్ క్లస్టర్‌లో బ్యాలెన్సర్‌ను ఇన్‌గ్రెస్ కంట్రోలర్‌గా ఇన్‌స్టాల్ చేస్తున్నప్పుడు, ఈ క్రింది విషయాలను గుర్తుంచుకోవడం ముఖ్యం:

HTTP ద్వారా ప్రామాణీకరణ సర్వర్‌కు కనెక్ట్ అయ్యే క్లయింట్ యొక్క రిమోట్ చిరునామా క్లయింట్ కంప్యూటర్ యొక్క నిజమైన IP చిరునామాగా కీక్లోక్ ఊహిస్తుంది. బ్యాలెన్సర్ మరియు ప్రవేశ సెట్టింగ్‌లు HTTP హెడర్‌లను సరిగ్గా సెట్ చేయాలి X-Forwarded-For и X-Forwarded-Proto, మరియు అసలు శీర్షికను కూడా సేవ్ చేయండి HOST. తాజా వెర్షన్ ingress-nginx (>0.22.0) దీన్ని డిఫాల్ట్‌గా నిలిపివేస్తుంది

జెండాను సక్రియం చేస్తోంది proxy-address-forwarding ఎన్విరాన్మెంట్ వేరియబుల్ సెట్ చేయడం ద్వారా PROXY_ADDRESS_FORWARDING в true కీక్లోక్‌కి ప్రాక్సీ వెనుక పని చేస్తుందన్న అవగాహనను ఇస్తుంది.

మీరు కూడా ఎనేబుల్ చేయాలి అంటుకునే సెషన్లు ప్రవేశంలో. ప్రస్తుత ప్రమాణీకరణ సెషన్ మరియు వినియోగదారు సెషన్‌తో అనుబంధించబడిన డేటాను నిల్వ చేయడానికి Keycloak పంపిణీ చేయబడిన Infinispan కాష్‌ని ఉపయోగిస్తుంది. కాష్‌లు డిఫాల్ట్‌గా ఒకే యజమానితో పనిచేస్తాయి, మరో మాటలో చెప్పాలంటే, ఆ నిర్దిష్ట సెషన్ క్లస్టర్‌లోని ఏదో ఒక నోడ్‌లో నిల్వ చేయబడుతుంది మరియు ఇతర నోడ్‌లు ఆ సెషన్‌కు యాక్సెస్ కావాలంటే రిమోట్‌గా దానిని ప్రశ్నించాలి.

ప్రత్యేకంగా, డాక్యుమెంటేషన్‌కు విరుద్ధంగా, కుక్కీ పేరుతో సెషన్‌ను జోడించడం మాకు పని చేయలేదు AUTH_SESSION_ID. Keycloak దారిమార్పు లూప్‌ను కలిగి ఉంది, కాబట్టి మేము స్టిక్కీ సెషన్ కోసం వేరే కుక్కీ పేరును ఎంచుకోమని సిఫార్సు చేస్తున్నాము.

కీక్లోక్ మొదట స్పందించిన నోడ్ పేరును కూడా జత చేస్తుంది AUTH_SESSION_ID, మరియు అత్యంత అందుబాటులో ఉన్న సంస్కరణలోని ప్రతి నోడ్ ఒకే డేటాబేస్ను ఉపయోగిస్తుంది కాబట్టి, వాటిలో ప్రతి ఒక్కటి కలిగి ఉండాలి లావాదేవీలను నిర్వహించడానికి ప్రత్యేక మరియు ప్రత్యేకమైన నోడ్ ఐడెంటిఫైయర్. ఉంచాలని సిఫార్సు చేయబడింది JAVA_OPTS పారామితులు jboss.node.name и jboss.tx.node.id ప్రతి నోడ్ కోసం ప్రత్యేకమైనది - మీరు ఉదాహరణకు, పాడ్ పేరును ఉంచవచ్చు. మీరు పాడ్ పేరును ఉంచినట్లయితే, jboss వేరియబుల్స్ కోసం 23 అక్షరాల పరిమితిని మర్చిపోకండి, కాబట్టి డిప్లాయ్‌మెంట్ కాకుండా స్టేట్‌ఫుల్‌సెట్‌ను ఉపయోగించడం ఉత్తమం.

మరొక రేక్ - పాడ్ తొలగించబడినా లేదా పునఃప్రారంభించబడినా, దాని కాష్ పోతుంది. దీన్ని పరిగణనలోకి తీసుకుంటే, అన్ని కాష్‌ల కోసం కాష్ యజమానుల సంఖ్యను కనీసం రెండుకి సెట్ చేయడం విలువైనది, తద్వారా కాష్ కాపీ అలాగే ఉంటుంది. పరిగెత్తడమే పరిష్కారం వైల్డ్‌ఫ్లై కోసం స్క్రిప్ట్ పాడ్‌ను ప్రారంభించేటప్పుడు, దానిని డైరెక్టరీలో ఉంచడం /opt/jboss/startup-scripts కంటైనర్‌లో:

స్క్రిప్ట్ విషయాలు

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

అప్పుడు పర్యావరణ వేరియబుల్ విలువను సెట్ చేయండి CACHE_OWNERS అవసరానికి.

IP మల్టీకాస్ట్ మద్దతుతో ప్రైవేట్ నెట్‌వర్క్

మీరు Weavenetని CNIగా ఉపయోగిస్తే, మల్టీక్యాస్ట్ వెంటనే పని చేస్తుంది - మరియు మీ కీక్లోక్ నోడ్‌లు లాంచ్ అయిన వెంటనే ఒకదానికొకటి కనిపిస్తాయి.

మీ కుబెర్నెటెస్ క్లస్టర్‌లో మీకు ip మల్టీకాస్ట్ సపోర్ట్ లేకపోతే, నోడ్‌లను కనుగొనడానికి ఇతర ప్రోటోకాల్‌లతో పని చేయడానికి మీరు JGroupలను కాన్ఫిగర్ చేయవచ్చు.

మొదటి ఎంపికను ఉపయోగించడం KUBE_DNSఇది ఉపయోగిస్తుంది headless service కీక్లోక్ నోడ్‌లను కనుగొనడానికి, మీరు నోడ్‌లను కనుగొనడానికి ఉపయోగించే సేవ పేరును JGroupలకు పాస్ చేయండి.

పద్ధతిని ఉపయోగించడం మరొక ఎంపిక KUBE_PING, ఇది నోడ్‌ల కోసం శోధించడానికి APIతో పని చేస్తుంది (మీరు కాన్ఫిగర్ చేయాలి serviceAccount హక్కులతో list и get, ఆపై దీనితో పని చేయడానికి పాడ్‌లను కాన్ఫిగర్ చేయండి serviceAccount).

JGroups నోడ్‌లను కనుగొనే విధానం ఎన్విరాన్‌మెంట్ వేరియబుల్‌లను సెట్ చేయడం ద్వారా కాన్ఫిగర్ చేయబడింది JGROUPS_DISCOVERY_PROTOCOL и JGROUPS_DISCOVERY_PROPERTIES. కోసం KUBE_PING మీరు అడగడం ద్వారా పాడ్‌లను ఎంచుకోవాలి namespace и labels.

️ మీరు మల్టీక్యాస్ట్‌ని ఉపయోగిస్తుంటే మరియు ఒక కుబెర్నెటెస్ క్లస్టర్‌లో రెండు లేదా అంతకంటే ఎక్కువ కీక్లోక్ క్లస్టర్‌లను అమలు చేస్తే (నేమ్‌స్పేస్‌లో ఒకటి చెప్పుకుందాం production, రెండవ - staging) - ఒక కీక్లోక్ క్లస్టర్ యొక్క నోడ్‌లు మరొక క్లస్టర్‌లో చేరవచ్చు. వేరియబుల్‌లను సెట్ చేయడం ద్వారా ప్రతి క్లస్టర్‌కు ప్రత్యేకమైన మల్టీక్యాస్ట్ చిరునామాను ఉపయోగించాలని నిర్ధారించుకోండిjboss.default.multicast.address и jboss.modcluster.multicast.address в JAVA_OPTS.

డేటా కేంద్రాల మధ్య ప్రతిరూపం

Связь

కీక్లోక్ నోడ్‌లతో రూపొందించబడిన కీక్లాక్ క్లస్టర్‌లు ఉన్న ప్రతి డేటా సెంటర్ కోసం కీక్లోక్ బహుళ ప్రత్యేక ఇన్ఫినిస్పాన్ కాష్ క్లస్టర్‌లను ఉపయోగిస్తుంది. కానీ వేర్వేరు డేటా సెంటర్‌లలో కీక్లోక్ నోడ్‌ల మధ్య తేడా లేదు.

డేటా కేంద్రాల మధ్య కమ్యూనికేషన్ కోసం కీక్లోక్ నోడ్‌లు బాహ్య జావా డేటా గ్రిడ్ (ఇన్ఫినిస్పాన్ సర్వర్లు)ని ఉపయోగిస్తాయి. ప్రోటోకాల్ ప్రకారం కమ్యూనికేషన్ పనిచేస్తుంది ఇన్ఫినిస్పాన్ హాట్‌రోడ్.

Infinispan కాష్‌లు తప్పనిసరిగా లక్షణంతో కాన్ఫిగర్ చేయబడాలి remoteStore, తద్వారా డేటా రిమోట్‌గా నిల్వ చేయబడుతుంది (మరొక డేటా సెంటర్‌లో, సుమారు అనువాదకుడు) కాష్‌లు. JDG సర్వర్‌లలో ప్రత్యేక ఇన్ఫినిస్పాన్ క్లస్టర్‌లు ఉన్నాయి, తద్వారా సైట్‌లోని JDG1లో డేటా నిల్వ చేయబడుతుంది site1 సైట్‌లో JDG2కి ప్రతిరూపం చేయబడుతుంది site2.

చివరకు, స్వీకరించే JDG సర్వర్ క్లయింట్ కనెక్షన్‌ల ద్వారా దాని క్లస్టర్ యొక్క కీక్లోక్ సర్వర్‌లకు తెలియజేస్తుంది, ఇది HotRod ప్రోటోకాల్ యొక్క లక్షణం. కీక్లోక్ నోడ్‌లు ఆన్‌లో ఉన్నాయి site2 వారి ఇన్ఫినిస్పాన్ కాష్‌లను నవీకరించండి మరియు నిర్దిష్ట వినియోగదారు సెషన్ కీక్లోక్ నోడ్‌లలో కూడా అందుబాటులో ఉంటుంది site2.

కొన్ని కాష్‌ల కోసం, బ్యాకప్‌లు చేయకపోవడం మరియు ఇన్‌ఫినిస్పాన్ సర్వర్ ద్వారా డేటా రాయడం పూర్తిగా నివారించడం కూడా సాధ్యమే. దీన్ని చేయడానికి మీరు సెట్టింగ్‌ను తీసివేయాలి remote-store నిర్దిష్ట Infinispan కాష్ (ఫైల్‌లో స్వతంత్ర-ha.xml), దాని తర్వాత కొన్ని నిర్దిష్టమైనవి replicated-cache ఇన్ఫినిస్పాన్ సర్వర్ వైపు కూడా ఇకపై అవసరం ఉండదు.

కాష్‌లను సెటప్ చేస్తోంది

కీక్లోక్‌లో రెండు రకాల కాష్‌లు ఉన్నాయి:

• స్థానిక. ఇది డేటాబేస్ పక్కన ఉంది మరియు డేటాబేస్పై లోడ్ని తగ్గించడానికి, అలాగే ప్రతిస్పందన జాప్యాన్ని తగ్గించడానికి ఉపయోగపడుతుంది. ఈ రకమైన కాష్ రాజ్యం, క్లయింట్లు, పాత్రలు మరియు వినియోగదారు మెటాడేటాను నిల్వ చేస్తుంది. కాష్ కీక్లోక్ క్లస్టర్‌లో భాగమైనప్పటికీ, ఈ రకమైన కాష్ ప్రతిరూపం చేయబడదు. కాష్‌లో నమోదు మారితే, మార్పు గురించి సందేశం క్లస్టర్‌లోని మిగిలిన సర్వర్‌లకు పంపబడుతుంది, ఆ తర్వాత ఎంట్రీ కాష్ నుండి మినహాయించబడుతుంది. వివరణ చూడండి work ప్రక్రియ యొక్క మరింత వివరణాత్మక వివరణ కోసం క్రింద చూడండి.

• ప్రతిరూపం. యూజర్ సెషన్‌లు, ఆఫ్‌లైన్ టోకెన్‌లను ప్రాసెస్ చేస్తుంది మరియు పాస్‌వర్డ్ ఫిషింగ్ ప్రయత్నాలు మరియు ఇతర దాడులను గుర్తించడానికి లాగిన్ ఎర్రర్‌లను కూడా పర్యవేక్షిస్తుంది. ఈ కాష్‌లలో నిల్వ చేయబడిన డేటా తాత్కాలికమైనది, RAMలో మాత్రమే నిల్వ చేయబడుతుంది, కానీ క్లస్టర్‌లో ప్రతిరూపం చేయవచ్చు.

ఇన్ఫినిస్పాన్ కాష్లు

సెషన్స్ - కీక్లోక్‌లోని కాన్సెప్ట్, ప్రత్యేక కాష్‌లు అంటారు authenticationSessions, నిర్దిష్ట వినియోగదారుల డేటాను నిల్వ చేయడానికి ఉపయోగించబడతాయి. ఈ కాష్‌ల నుండి అభ్యర్థనలు సాధారణంగా అప్లికేషన్‌ల ద్వారా కాకుండా బ్రౌజర్ మరియు కీక్లోక్ సర్వర్‌లకు అవసరమవుతాయి. ఇక్కడే స్టిక్కీ సెషన్‌లపై ఆధారపడటం అమలులోకి వస్తుంది మరియు యాక్టివ్-యాక్టివ్ మోడ్ విషయంలో కూడా అటువంటి కాష్‌లు వాటిని పునరావృతం చేయవలసిన అవసరం లేదు.

యాక్షన్ టోకెన్లు. మరొక భావన, సాధారణంగా వివిధ దృశ్యాల కోసం ఉపయోగించబడుతుంది, ఉదాహరణకు, వినియోగదారు మెయిల్ ద్వారా అసమకాలికంగా ఏదైనా చేయాలి. ఉదాహరణకు, ప్రక్రియ సమయంలో forget password కాష్ actionTokens అనుబంధిత టోకెన్ల మెటాడేటాను ట్రాక్ చేయడానికి ఉపయోగించబడుతుంది - ఉదాహరణకు, టోకెన్ ఇప్పటికే ఉపయోగించబడింది మరియు మళ్లీ యాక్టివేట్ చేయబడదు. ఈ రకమైన కాష్ సాధారణంగా డేటా కేంద్రాల మధ్య పునరావృతం కావాలి.

నిల్వ చేయబడిన డేటా యొక్క కాషింగ్ మరియు వృద్ధాప్యం డేటాబేస్‌పై భారాన్ని తగ్గించడానికి పని చేస్తుంది. ఈ రకమైన కాషింగ్ పనితీరును మెరుగుపరుస్తుంది, కానీ స్పష్టమైన సమస్యను జోడిస్తుంది. ఒక Keycloak సర్వర్ డేటాను అప్‌డేట్ చేస్తే, ఇతర సర్వర్‌లకు తప్పనిసరిగా తెలియజేయాలి, తద్వారా వారు తమ కాష్‌లలోని డేటాను అప్‌డేట్ చేయవచ్చు. కీక్లోక్ స్థానిక కాష్‌లను ఉపయోగిస్తుంది realms, users и authorization డేటాబేస్ నుండి డేటాను కాషింగ్ చేయడానికి.

ప్రత్యేక కాష్ కూడా ఉంది work, ఇది అన్ని డేటా సెంటర్లలో ప్రతిరూపం చేయబడింది. ఇది డేటాబేస్ నుండి ఎటువంటి డేటాను నిల్వ చేయదు, కానీ డేటా కేంద్రాల మధ్య క్లస్టర్ నోడ్‌లకు డేటా వృద్ధాప్యం గురించి సందేశాలను పంపడానికి ఉపయోగపడుతుంది. మరో మాటలో చెప్పాలంటే, డేటా నవీకరించబడిన వెంటనే, కీక్లోక్ నోడ్ దాని డేటా సెంటర్‌లోని ఇతర నోడ్‌లకు, అలాగే ఇతర డేటా సెంటర్‌లలోని నోడ్‌లకు సందేశాన్ని పంపుతుంది. అటువంటి సందేశాన్ని స్వీకరించిన తర్వాత, ప్రతి నోడ్ దాని స్థానిక కాష్‌లలో సంబంధిత డేటాను క్లియర్ చేస్తుంది.

వినియోగదారు సెషన్‌లు. పేర్లతో కాష్‌లు sessions, clientSessions, offlineSessions и offlineClientSessions, సాధారణంగా డేటా కేంద్రాల మధ్య ప్రతిరూపం మరియు వినియోగదారు బ్రౌజర్‌లో యాక్టివ్‌గా ఉన్నప్పుడు యాక్టివ్‌గా ఉండే యూజర్ సెషన్‌ల గురించి డేటాను నిల్వ చేయడానికి ఉపయోగపడుతుంది. ఈ కాష్‌లు తుది వినియోగదారుల నుండి HTTP అభ్యర్థనలను ప్రాసెస్ చేసే అప్లికేషన్‌తో పని చేస్తాయి, కాబట్టి అవి స్టిక్కీ సెషన్‌లతో అనుబంధించబడి ఉంటాయి మరియు డేటా సెంటర్‌ల మధ్య తప్పనిసరిగా ప్రతిరూపం పొందాలి.

బ్రూట్ ఫోర్స్ రక్షణ. కాష్ loginFailures వినియోగదారు ఎన్నిసార్లు తప్పు పాస్‌వర్డ్‌ని నమోదు చేసారు వంటి లాగిన్ ఎర్రర్ డేటాను ట్రాక్ చేయడానికి ఉపయోగించబడుతుంది. ఈ కాష్ యొక్క ప్రతిరూపం నిర్వాహకుని యొక్క బాధ్యత. కానీ ఖచ్చితమైన గణన కోసం, డేటా కేంద్రాల మధ్య ప్రతిరూపణను సక్రియం చేయడం విలువ. కానీ మరోవైపు, మీరు ఈ డేటాను పునరావృతం చేయకపోతే, మీరు పనితీరును మెరుగుపరుస్తారు మరియు ఈ సమస్య తలెత్తితే, ప్రతిరూపణ సక్రియం చేయబడకపోవచ్చు.

ఇన్ఫినిస్పాన్ క్లస్టర్‌ను రోల్ చేస్తున్నప్పుడు, మీరు సెట్టింగ్‌ల ఫైల్‌కు కాష్ నిర్వచనాలను జోడించాలి:

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

మీరు కీక్లోక్ క్లస్టర్‌ను ప్రారంభించే ముందు తప్పనిసరిగా ఇన్ఫినిస్పాన్ క్లస్టర్‌ను కాన్ఫిగర్ చేసి ప్రారంభించాలి

అప్పుడు మీరు కాన్ఫిగర్ చేయాలి remoteStore కీక్లోక్ కాష్‌ల కోసం. దీన్ని చేయడానికి, స్క్రిప్ట్ సరిపోతుంది, ఇది మునుపటి మాదిరిగానే చేయబడుతుంది, ఇది వేరియబుల్‌ను సెట్ చేయడానికి ఉపయోగించబడుతుంది CACHE_OWNERS, మీరు దానిని ఫైల్‌లో సేవ్ చేసి డైరెక్టరీలో ఉంచాలి /opt/jboss/startup-scripts:

స్క్రిప్ట్ విషయాలు

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

ఇన్స్టాల్ చేయడం మర్చిపోవద్దు JAVA_OPTS HotRodని అమలు చేయడానికి కీక్లోక్ నోడ్‌ల కోసం: remote.cache.host, remote.cache.port మరియు సేవ పేరు jboss.site.name.

లింక్‌లు మరియు అదనపు డాక్యుమెంటేషన్

• 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

ఈ కథనాన్ని ఉద్యోగులు హబ్ర్ కోసం అనువదించారు మరియు సిద్ధం చేశారు మురికివాడ శిక్షణ కేంద్రం - ఇంటెన్సివ్ కోర్సులు, వీడియో కోర్సులు మరియు ప్రాక్టీసింగ్ నిపుణుల నుండి కార్పొరేట్ శిక్షణ (కుబెర్నెట్స్, డెవొప్స్, డాకర్, అన్సిబుల్, సెఫ్, SRE)

మూలం: www.habr.com