🥇ដំណើរការ Keycloak ក្នុងរបៀប HA នៅលើ Kubernetes

TL; កុង៖ នឹងមានការពិពណ៌នាអំពី Keycloak ដែលជាប្រព័ន្ធគ្រប់គ្រងការចូលប្រើប្រភពបើកចំហ ការវិភាគរចនាសម្ព័ន្ធខាងក្នុង ព័ត៌មានលម្អិតនៃការកំណត់។

សេចក្តីផ្តើម និងគំនិតសំខាន់ៗ

នៅក្នុងអត្ថបទនេះ យើងនឹងឃើញគំនិតជាមូលដ្ឋានដែលត្រូវចងចាំនៅពេលដាក់ពង្រាយ Keycloak cluster នៅលើ Kubernetes ។

ប្រសិនបើអ្នកចង់ដឹងបន្ថែមអំពី Keycloak សូមមើលតំណភ្ជាប់នៅចុងបញ្ចប់នៃអត្ថបទ។ ដើម្បីកាន់តែស៊ីជម្រៅក្នុងការអនុវត្ត អ្នកអាចសិក្សាបាន។ ឃ្លាំងរបស់យើង។ ជាមួយនឹងម៉ូឌុលដែលអនុវត្តគំនិតសំខាន់ៗនៃអត្ថបទនេះ (ការណែនាំចាប់ផ្តើមគឺនៅទីនោះ អត្ថបទនេះនឹងផ្តល់នូវទិដ្ឋភាពទូទៅនៃឧបករណ៍ និងការកំណត់។ ប្រហែល អ្នកបកប្រែ).

Keycloak គឺជាប្រព័ន្ធដ៏ទូលំទូលាយមួយដែលត្រូវបានសរសេរនៅក្នុង Java និងត្រូវបានបង្កើតឡើងនៅលើកំពូលនៃម៉ាស៊ីនមេកម្មវិធី សត្វស្លាប. សរុបមក វាគឺជាក្របខ័ណ្ឌសម្រាប់ការអនុញ្ញាតដែលផ្តល់ឱ្យអ្នកប្រើប្រាស់នូវកម្មវិធីសហព័ន្ធ និង SSO (single sign-on) សមត្ថភាព។

យើងសូមអញ្ជើញអ្នកឱ្យអានជាផ្លូវការ វេបសាយ ឬ វិគីភីឌា សម្រាប់ការយល់ដឹងលម្អិត។

ការបើកដំណើរការ Keycloak

Keycloak ត្រូវការប្រភពទិន្នន័យជាប់លាប់ពីរដើម្បីដំណើរការ៖

មូលដ្ឋានទិន្នន័យដែលប្រើដើម្បីរក្សាទុកទិន្នន័យដែលបានបង្កើតឡើង ដូចជាព័ត៌មានអ្នកប្រើប្រាស់
ឃ្លាំងសម្ងាត់ Datagrid ដែលត្រូវបានប្រើដើម្បីរក្សាទុកទិន្នន័យពីមូលដ្ឋានទិន្នន័យ ក៏ដូចជារក្សាទុកទិន្នន័យមេតាដែលផ្លាស់ប្តូររយៈពេលខ្លី និងញឹកញាប់មួយចំនួន ដូចជាវគ្គអ្នកប្រើប្រាស់ជាដើម។ បានអនុវត្ត ក្រុមហ៊ុន Infinispanដែលជាធម្មតាលឿនជាងមូលដ្ឋានទិន្នន័យ។ ប៉ុន្តែក្នុងករណីណាក៏ដោយ ទិន្នន័យដែលបានរក្សាទុកនៅក្នុង Infinispan គឺមានភាពច្របូកច្របល់ ហើយវាមិនចាំបាច់ត្រូវរក្សាទុកនៅកន្លែងណានោះទេ នៅពេលដែលចង្កោមត្រូវបានចាប់ផ្តើមឡើងវិញ។

Keycloak ដំណើរការក្នុងរបៀបបួនផ្សេងគ្នា៖

ធម្មតា - ដំណើរការមួយ និងតែមួយគត់ កំណត់រចនាសម្ព័ន្ធតាមរយៈឯកសារ standalone.xml
ចង្កោមធម្មតា។ (ជម្រើសដែលអាចរកបានខ្ពស់) - ដំណើរការទាំងអស់ត្រូវតែប្រើការកំណត់ដូចគ្នា ដែលត្រូវតែធ្វើសមកាលកម្មដោយដៃ។ ការកំណត់ត្រូវបានរក្សាទុកក្នុងឯកសារ ឯករាជ្យ-ha.xmlលើសពីនេះ អ្នកត្រូវបង្កើតការចូលប្រើរួមគ្នាទៅកាន់មូលដ្ឋានទិន្នន័យ និងឧបករណ៍ផ្ទុកតុល្យភាព។
ចង្កោមដែន — ការចាប់ផ្តើមចង្កោមក្នុងរបៀបធម្មតាក្លាយជាកិច្ចការធម្មតា និងគួរឱ្យធុញយ៉ាងឆាប់រហ័ស នៅពេលដែលចង្កោមរីកចម្រើន ចាប់តាំងពីរាល់ពេលដែលការផ្លាស់ប្តូរការកំណត់រចនាសម្ព័ន្ធ ការផ្លាស់ប្តូរទាំងអស់ត្រូវតែធ្វើឡើងនៅលើថ្នាំងចង្កោមនីមួយៗ។ របៀបប្រតិបត្តិការរបស់ដែនដោះស្រាយបញ្ហានេះដោយរៀបចំទីតាំងផ្ទុកដែលបានចែករំលែកមួយចំនួន និងការបោះពុម្ពការកំណត់រចនាសម្ព័ន្ធ។ ការកំណត់ទាំងនេះត្រូវបានរក្សាទុកក្នុងឯកសារ domain.xml
ការចម្លងរវាងមជ្ឈមណ្ឌលទិន្នន័យ — ប្រសិនបើអ្នកចង់ដំណើរការ Keycloak នៅក្នុងចង្កោមនៃមជ្ឈមណ្ឌលទិន្នន័យជាច្រើន ដែលភាគច្រើនជាញឹកញាប់នៅក្នុងទីតាំងភូមិសាស្រ្តផ្សេងៗគ្នា។ នៅក្នុងជម្រើសនេះ មជ្ឈមណ្ឌលទិន្នន័យនីមួយៗនឹងមានចង្កោមម៉ាស៊ីនមេ Keycloak ផ្ទាល់ខ្លួន។

នៅក្នុងអត្ថបទនេះយើងនឹងពិចារណាលម្អិតអំពីជម្រើសទីពីរ នោះគឺ ចង្កោមធម្មតា។ហើយយើងក៏នឹងប៉ះបន្តិចលើប្រធានបទនៃការចម្លងរវាងមជ្ឈមណ្ឌលទិន្នន័យ ព្រោះវាសមហេតុផលក្នុងការដំណើរការជម្រើសទាំងពីរនេះនៅក្នុង Kubernetes។ ជាសំណាងល្អនៅក្នុង Kubernetes មិនមានបញ្ហាជាមួយនឹងការធ្វើសមកាលកម្មការកំណត់របស់ pods ជាច្រើន (Keycloak nodes) ដូច្នេះ ចង្កោមដែន វានឹងមិនពិបាកធ្វើទេ។

សូមចំណាំផងដែរថាពាក្យ ចង្កោម សម្រាប់អត្ថបទដែលនៅសល់នឹងអនុវត្តចំពោះតែក្រុមនៃថ្នាំង Keycloak ដែលធ្វើការជាមួយគ្នា មិនចាំបាច់យោងទៅលើចង្កោម Kubernetes ទេ។

ចង្កោម Keycloak ធម្មតា។

ដើម្បីដំណើរការ Keycloak ក្នុងរបៀបនេះ អ្នកត្រូវការ៖

កំណត់រចនាសម្ព័ន្ធមូលដ្ឋានទិន្នន័យដែលបានចែករំលែកខាងក្រៅ
ដំឡើងឧបករណ៍ផ្ទុកតុល្យភាព
មានបណ្តាញខាងក្នុងដែលមានការគាំទ្រ IP multicast

យើងនឹងមិនពិភាក្សាអំពីការដំឡើងមូលដ្ឋានទិន្នន័យខាងក្រៅទេ ព្រោះវាមិនមែនជាគោលបំណងនៃអត្ថបទនេះទេ។ ចូរសន្មតថាមានមូលដ្ឋានទិន្នន័យធ្វើការនៅកន្លែងណាមួយ - ហើយយើងមានចំណុចតភ្ជាប់ទៅវា។ យើងនឹងបន្ថែមទិន្នន័យនេះទៅអថេរបរិស្ថាន។

ដើម្បីយល់កាន់តែច្បាស់អំពីរបៀបដែល Keycloak ដំណើរការនៅក្នុងចង្កោមដែលបរាជ័យ (HA) វាជារឿងសំខាន់ដើម្បីដឹងថាតើវាច្រើនប៉ុណ្ណា អាស្រ័យលើសមត្ថភាពនៃការធ្វើចង្កោមរបស់ Wildfly ។

Wildfly ប្រើប្រព័ន្ធរងជាច្រើន ដែលមួយចំនួនត្រូវបានគេប្រើជាឧបករណ៍ផ្ទុកតុល្យភាព ខ្លះសម្រាប់ការអត់ឱនចំពោះកំហុស។ Load Balancer ធានាភាពអាចរកបាននៃកម្មវិធី នៅពេលដែលថ្នាំងចង្កោមផ្ទុកលើសទម្ងន់ ហើយការអត់ឱនចំពោះកំហុសធានានូវភាពអាចរកបាននៃកម្មវិធី ទោះបីជាថ្នាំងចង្កោមមួយចំនួនបរាជ័យក៏ដោយ។ ប្រព័ន្ធរងទាំងនេះមួយចំនួន៖

mod_cluster៖ ដំណើរការដោយភ្ជាប់ជាមួយ Apache ជាឧបករណ៍ផ្ទុក HTTP អាស្រ័យលើ TCP multicast ដើម្បីស្វែងរកម៉ាស៊ីនតាមលំនាំដើម។ អាចត្រូវបានជំនួសដោយតុល្យភាពខាងក្រៅ។
infinispan៖ ឃ្លាំងសម្ងាត់ដែលបានចែកចាយដោយប្រើប៉ុស្តិ៍ JGroups ជាស្រទាប់ដឹកជញ្ជូន។ លើសពីនេះទៀត វាអាចប្រើពិធីការ HotRod ដើម្បីទំនាក់ទំនងជាមួយក្រុម Infinispan ខាងក្រៅដើម្បីធ្វើសមកាលកម្មមាតិកាឃ្លាំងសម្ងាត់។
jgroups៖ ផ្តល់ការគាំទ្រទំនាក់ទំនងជាក្រុមសម្រាប់សេវាកម្មដែលមានកម្រិតខ្ពស់ដោយផ្អែកលើបណ្តាញ JGroups ។ បំពង់ដែលមានឈ្មោះអនុញ្ញាតឱ្យឧទាហរណ៍កម្មវិធីនៅក្នុងចង្កោមត្រូវបានភ្ជាប់ជាក្រុម ដូច្នេះទំនាក់ទំនងមានលក្ខណៈសម្បត្តិដូចជា ភាពជឿជាក់ សណ្តាប់ធ្នាប់ និងភាពប្រែប្រួលទៅនឹងការបរាជ័យ។

ផ្ទុកតុល្យភាព

នៅពេលដំឡើងសមតុល្យជាឧបករណ៍បញ្ជា ingress នៅក្នុងចង្កោម Kubernetes វាជាការសំខាន់ក្នុងការចងចាំរឿងខាងក្រោម៖

Keycloak សន្មត់ថាអាសយដ្ឋានពីចម្ងាយរបស់អតិថិជនដែលភ្ជាប់តាមរយៈ HTTP ទៅម៉ាស៊ីនមេការផ្ទៀងផ្ទាត់គឺជាអាសយដ្ឋាន IP ពិតប្រាកដរបស់កុំព្យូទ័រអតិថិជន។ ការកំណត់តុល្យភាព និងច្រកចូលគួរតែកំណត់បឋមកថា HTTP ឱ្យបានត្រឹមត្រូវ X-Forwarded-For и X-Forwarded-Protoនិងរក្សាទុកចំណងជើងដើមផងដែរ។ HOST. ជំនាន់ចុងក្រោយ ingress-nginx (> 0.22.0) បិទវាតាមលំនាំដើម

ការធ្វើឱ្យទង់ជាតិសកម្ម proxy-address-forwarding ដោយកំណត់អថេរបរិស្ថាន PROXY_ADDRESS_FORWARDING в true ផ្តល់ឱ្យ Keycloak ការយល់ដឹងថាវាកំពុងធ្វើការនៅពីក្រោយប្រូកស៊ី។

អ្នកក៏ត្រូវបើកដំណើរការផងដែរ។ វគ្គស្អិត នៅក្នុងការចូល។ Keycloak ប្រើឃ្លាំងសម្ងាត់ Infinispan ដែលបានចែកចាយដើម្បីរក្សាទុកទិន្នន័យដែលភ្ជាប់ជាមួយវគ្គផ្ទៀងផ្ទាត់បច្ចុប្បន្ន និងសម័យអ្នកប្រើប្រាស់។ ឃ្លាំងសម្ងាត់ដំណើរការជាមួយម្ចាស់តែមួយតាមលំនាំដើម ម្យ៉ាងវិញទៀត វគ្គពិសេសនោះត្រូវបានរក្សាទុកនៅលើថ្នាំងមួយចំនួននៅក្នុងចង្កោម ហើយថ្នាំងផ្សេងទៀតត្រូវតែសួរវាពីចម្ងាយ ប្រសិនបើពួកគេត្រូវការចូលប្រើវគ្គនោះ។

ជាពិសេស ផ្ទុយពីឯកសារ ការភ្ជាប់វគ្គជាមួយខូគីឈ្មោះមិនដំណើរការសម្រាប់យើងទេ។ AUTH_SESSION_ID. Keycloak មានរង្វិលជុំបញ្ជូនបន្ត ដូច្នេះយើងសូមណែនាំឱ្យជ្រើសរើសឈ្មោះខូគីផ្សេងសម្រាប់វគ្គស្អិត។

Keycloak ក៏ភ្ជាប់ឈ្មោះថ្នាំងដែលឆ្លើយតបដំបូង AUTH_SESSION_IDហើយចាប់តាំងពីថ្នាំងនីមួយៗនៅក្នុងកំណែដែលមានកម្រិតខ្ពស់ប្រើមូលដ្ឋានទិន្នន័យដូចគ្នា ពួកវានីមួយៗ ត្រូវតែមាន ឧបករណ៍សម្គាល់ថ្នាំងដាច់ដោយឡែក និងតែមួយគត់សម្រាប់គ្រប់គ្រងប្រតិបត្តិការ។ វាត្រូវបានណែនាំឱ្យដាក់ JAVA_OPTS ប៉ារ៉ាម៉ែត្រ jboss.node.name и jboss.tx.node.id តែមួយគត់សម្រាប់ថ្នាំងនីមួយៗ - ឧទាហរណ៍អ្នកអាចដាក់ឈ្មោះរបស់ផត។ ប្រសិនបើអ្នកដាក់ឈ្មោះផត សូមកុំភ្លេចអំពីដែនកំណត់តួអក្សរ 23 សម្រាប់អថេរ jboss ដូច្នេះវាជាការប្រសើរក្នុងការប្រើ StatefulSet ជាជាងការដាក់ឱ្យប្រើប្រាស់។

តុងរួចមួយទៀត - ប្រសិនបើផតត្រូវបានលុប ឬចាប់ផ្តើមឡើងវិញ ឃ្លាំងសម្ងាត់របស់វាត្រូវបានបាត់បង់។ ដោយគិតពីចំណុចនេះ វាមានតម្លៃកំណត់ចំនួនម្ចាស់ឃ្លាំងសម្ងាត់សម្រាប់ឃ្លាំងសម្ងាត់ទាំងអស់យ៉ាងហោចណាស់ពីរ ដូច្នេះច្បាប់ចម្លងនៃឃ្លាំងសម្ងាត់នឹងនៅដដែល។ ដំណោះស្រាយគឺត្រូវរត់ ស្គ្រីបសម្រាប់ Wildfly នៅពេលចាប់ផ្តើម pod ដាក់វានៅក្នុងថត /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 multicast

ប្រសិនបើអ្នកប្រើ Weavenet ជា CNI ពហុខាសនឹងដំណើរការភ្លាមៗ ហើយថ្នាំង Keycloak របស់អ្នកនឹងឃើញគ្នាទៅវិញទៅមកភ្លាមៗនៅពេលដែលពួកវាត្រូវបានដាក់ឱ្យដំណើរការ។

ប្រសិនបើអ្នកមិនមានការគាំទ្រ ip multicast នៅក្នុងចង្កោម Kubernetes របស់អ្នកទេ អ្នកអាចកំណត់រចនាសម្ព័ន្ធ JGroups ដើម្បីធ្វើការជាមួយពិធីការផ្សេងទៀតដើម្បីស្វែងរកថ្នាំង។

ជម្រើសដំបូងគឺត្រូវប្រើ KUBE_DNSដែលប្រើ headless service ដើម្បីស្វែងរកថ្នាំង Keycloak អ្នកគ្រាន់តែឆ្លងកាត់ JGroups ឈ្មោះសេវាកម្មដែលនឹងត្រូវបានប្រើដើម្បីស្វែងរកថ្នាំង។

ជម្រើសមួយទៀតគឺត្រូវប្រើវិធីសាស្ត្រ KUBE_PINGដែលធ្វើការជាមួយ API ដើម្បីស្វែងរកថ្នាំង (អ្នកត្រូវកំណត់រចនាសម្ព័ន្ធ serviceAccount ជាមួយនឹងសិទ្ធិ list и getហើយបន្ទាប់មកកំណត់រចនាសម្ព័ន្ធ pods ដើម្បីធ្វើការជាមួយវា។ serviceAccount).

វិធីដែល JGroups ស្វែងរកថ្នាំងត្រូវបានកំណត់រចនាសម្ព័ន្ធដោយការកំណត់អថេរបរិស្ថាន JGROUPS_DISCOVERY_PROTOCOL и JGROUPS_DISCOVERY_PROPERTIES។ សម្រាប់ KUBE_PING អ្នកត្រូវជ្រើសរើស pods ដោយសួរ namespace и labels.

️ ប្រសិនបើអ្នកប្រើពហុខាស ហើយដំណើរការចង្កោម Keycloak ពីរឬច្រើននៅក្នុងចង្កោម Kubernetes មួយ (សូមនិយាយមួយនៅក្នុង namespace production, ទីពីរ - staging) - ថ្នាំងនៃចង្កោម Keycloak មួយអាចចូលរួមចង្កោមមួយផ្សេងទៀត។ ត្រូវប្រាកដថាប្រើអាសយដ្ឋានពហុខាសតែមួយគត់សម្រាប់ចង្កោមនីមួយៗដោយកំណត់អថេរjboss.default.multicast.address и jboss.modcluster.multicast.address в JAVA_OPTS.

ការចម្លងរវាងមជ្ឈមណ្ឌលទិន្នន័យ

ការតភ្ជាប់

Keycloak ប្រើចង្កោមឃ្លាំងសម្ងាត់ Infinispan ដាច់ដោយឡែកជាច្រើនសម្រាប់មជ្ឈមណ្ឌលទិន្នន័យនីមួយៗ ដែលចង្កោម Keycloack ដែលបង្កើតឡើងដោយថ្នាំង Keycloak មានទីតាំងនៅ។ ប៉ុន្តែមិនមានភាពខុសប្លែកគ្នារវាងថ្នាំង Keycloak នៅក្នុងមជ្ឈមណ្ឌលទិន្នន័យផ្សេងៗគ្នាទេ។

ថ្នាំង Keycloak ប្រើបណ្តាញទិន្នន័យ Java ខាងក្រៅ (ម៉ាស៊ីនមេ Infinispan) សម្រាប់ទំនាក់ទំនងរវាងមជ្ឈមណ្ឌលទិន្នន័យ។ ការទំនាក់ទំនងដំណើរការដោយអនុលោមតាមពិធីការ ក្រុមហ៊ុន Infinispan HotRod.

ឃ្លាំងសម្ងាត់ Infinispan ត្រូវតែកំណត់រចនាសម្ព័ន្ធជាមួយគុណលក្ខណៈ remoteStoreដើម្បីឱ្យទិន្នន័យអាចត្រូវបានរក្សាទុកពីចម្ងាយ (នៅក្នុងមជ្ឈមណ្ឌលទិន្នន័យផ្សេងទៀត ប្រហែល អ្នកបកប្រែ) ឃ្លាំងសម្ងាត់។ មានចង្កោម infinispan ដាច់ដោយឡែកក្នុងចំណោមម៉ាស៊ីនមេ JDG ដូច្នេះទិន្នន័យដែលបានរក្សាទុកនៅលើ JDG1 នៅលើគេហទំព័រ site1 នឹងត្រូវបានចម្លងទៅ JDG2 នៅលើគេហទំព័រ site2.

ហើយចុងក្រោយ ម៉ាស៊ីនមេ JDG ដែលទទួលបានជូនដំណឹងដល់ម៉ាស៊ីនមេ Keycloak នៃចង្កោមរបស់វាតាមរយៈការភ្ជាប់ម៉ាស៊ីនភ្ញៀវ ដែលជាលក្ខណៈនៃពិធីការ HotRod ។ ថ្នាំង Keycloak បើក site2 ធ្វើបច្ចុប្បន្នភាពឃ្លាំងសម្ងាត់ Infinispan របស់ពួកគេ ហើយវគ្គអ្នកប្រើប្រាស់ជាក់លាក់ក៏មាននៅលើថ្នាំង Keycloak ផងដែរ។ site2.

សម្រាប់ឃ្លាំងសម្ងាត់មួយចំនួន វាក៏អាចធ្វើទៅបានផងដែរក្នុងការមិនធ្វើការបម្រុងទុក និងជៀសវាងការសរសេរទិន្នន័យតាមរយៈម៉ាស៊ីនមេ Infinispan ទាំងស្រុង។ ដើម្បីធ្វើដូចនេះអ្នកត្រូវដកការកំណត់ចេញ remote-store ឃ្លាំងសម្ងាត់ Infinispan ជាក់លាក់ (នៅក្នុងឯកសារ ឯករាជ្យ-ha.xml), បន្ទាប់ពីនោះជាក់លាក់មួយចំនួន replicated-cache ក៏នឹងលែងត្រូវការនៅលើផ្នែកម៉ាស៊ីនមេ Infinispan ទៀតហើយ។

ការដំឡើងឃ្លាំងសម្ងាត់

មានឃ្លាំងសម្ងាត់ពីរប្រភេទនៅក្នុង Keycloak៖

ក្នុងស្រុក។ វាមានទីតាំងនៅជាប់នឹងមូលដ្ឋានទិន្នន័យ និងបម្រើដើម្បីកាត់បន្ថយការផ្ទុកនៅលើមូលដ្ឋានទិន្នន័យ ក៏ដូចជាកាត់បន្ថយភាពយឺតយ៉ាវនៃការឆ្លើយតប។ ប្រភេទនៃឃ្លាំងសម្ងាត់នេះរក្សាទុកអាណាចក្រ អតិថិជន តួនាទី និងទិន្នន័យមេតារបស់អ្នកប្រើប្រាស់។ ប្រភេទឃ្លាំងសម្ងាត់នេះមិនត្រូវបានចម្លងទេ ទោះបីជាឃ្លាំងសម្ងាត់ជាផ្នែកមួយនៃចង្កោម Keycloak ក៏ដោយ។ ប្រសិនបើធាតុនៅក្នុងឃ្លាំងសម្ងាត់ផ្លាស់ប្តូរ សារអំពីការផ្លាស់ប្តូរត្រូវបានផ្ញើទៅកាន់ម៉ាស៊ីនមេដែលនៅសល់ក្នុងចង្កោម បន្ទាប់ពីនោះធាតុត្រូវបានដកចេញពីឃ្លាំងសម្ងាត់។ សូមមើលការពិពណ៌នា work សូមមើលខាងក្រោមសម្រាប់ការពិពណ៌នាលម្អិតបន្ថែមទៀតនៃនីតិវិធី។
ចម្លង។ ដំណើរការវគ្គរបស់អ្នកប្រើ សញ្ញាសម្ងាត់ក្រៅបណ្តាញ និងត្រួតពិនិត្យកំហុសក្នុងការចូលផងដែរ ដើម្បីស្វែងរកការប៉ុនប៉ងលួចបន្លំពាក្យសម្ងាត់ និងការវាយប្រហារផ្សេងទៀត។ ទិន្នន័យដែលរក្សាទុកក្នុងឃ្លាំងសម្ងាត់ទាំងនេះគឺបណ្តោះអាសន្ន រក្សាទុកតែក្នុង RAM ប៉ុណ្ណោះ ប៉ុន្តែអាចចម្លងតាមចង្កោមបាន។

ឃ្លាំងសម្ងាត់ Infinispan

វគ្គ - គំនិតនៅក្នុង Keycloak, ឃ្លាំងសម្ងាត់ដាច់ដោយឡែកហៅថា authenticationSessionsត្រូវបានប្រើដើម្បីរក្សាទុកទិន្នន័យរបស់អ្នកប្រើប្រាស់ជាក់លាក់។ សំណើពីឃ្លាំងសម្ងាត់ទាំងនេះជាធម្មតាត្រូវការដោយកម្មវិធីរុករក និងម៉ាស៊ីនមេ Keycloak មិនមែនដោយកម្មវិធីទេ។ នេះគឺជាកន្លែងដែលការពឹងផ្អែកលើវគ្គស្អិតចូលមកលេង ហើយឃ្លាំងសម្ងាត់បែបនេះមិនចាំបាច់ចម្លងទេ សូម្បីតែក្នុងករណីសកម្ម-សកម្មក៏ដោយ។

សញ្ញាសម្គាល់សកម្មភាព. គោលគំនិតមួយផ្សេងទៀត ដែលជាធម្មតាត្រូវបានប្រើប្រាស់សម្រាប់សេណារីយ៉ូផ្សេងៗ នៅពេលដែលឧទាហរណ៍ អ្នកប្រើប្រាស់ត្រូវតែធ្វើអ្វីមួយដោយអសមកាលតាមសំបុត្រ។ ឧទាហរណ៍ក្នុងអំឡុងពេលនីតិវិធី forget password ឃ្លាំងសម្ងាត់ actionTokens ប្រើដើម្បីតាមដានទិន្នន័យមេតានៃថូខឹនដែលពាក់ព័ន្ធ - ឧទាហរណ៍ សញ្ញាសម្ងាត់មួយត្រូវបានប្រើប្រាស់រួចហើយ ហើយមិនអាចដំណើរការម្តងទៀតបានទេ។ ប្រភេទនៃឃ្លាំងសម្ងាត់នេះជាធម្មតាត្រូវការចម្លងរវាងមជ្ឈមណ្ឌលទិន្នន័យ។

ឃ្លាំងសម្ងាត់ និងភាពចាស់នៃទិន្នន័យដែលបានរក្សាទុក ធ្វើការដើម្បីសម្រាលបន្ទុកលើមូលដ្ឋានទិន្នន័យ។ ប្រភេទនៃឃ្លាំងសម្ងាត់នេះធ្វើអោយដំណើរការប្រសើរឡើង ប៉ុន្តែបន្ថែមបញ្ហាជាក់ស្តែង។ ប្រសិនបើម៉ាស៊ីនមេ Keycloak មួយធ្វើបច្ចុប្បន្នភាពទិន្នន័យ នោះម៉ាស៊ីនមេផ្សេងទៀតត្រូវតែត្រូវបានជូនដំណឹង ដូច្នេះពួកគេអាចធ្វើបច្ចុប្បន្នភាពទិន្នន័យនៅក្នុងឃ្លាំងសម្ងាត់របស់ពួកគេ។ Keycloak ប្រើឃ្លាំងសម្ងាត់ក្នុងស្រុក realms, users и authorization សម្រាប់ការរក្សាទុកទិន្នន័យពីមូលដ្ឋានទិន្នន័យ។

វាក៏មានឃ្លាំងសម្ងាត់ដាច់ដោយឡែកផងដែរ។ workដែលត្រូវបានចម្លងតាមមជ្ឈមណ្ឌលទិន្នន័យទាំងអស់។ ខ្លួនវាមិនរក្សាទុកទិន្នន័យណាមួយពីមូលដ្ឋានទិន្នន័យទេ ប៉ុន្តែបម្រើដើម្បីផ្ញើសារអំពីភាពចាស់នៃទិន្នន័យទៅកាន់ថ្នាំងចង្កោមរវាងមជ្ឈមណ្ឌលទិន្នន័យ។ ម្យ៉ាងវិញទៀត ដរាបណាទិន្នន័យត្រូវបានធ្វើបច្ចុប្បន្នភាព ថ្នាំង Keycloak ផ្ញើសារទៅកាន់ថ្នាំងផ្សេងទៀតនៅក្នុងមជ្ឈមណ្ឌលទិន្នន័យរបស់វា ក៏ដូចជាថ្នាំងនៅក្នុងមជ្ឈមណ្ឌលទិន្នន័យផ្សេងទៀត។ បន្ទាប់ពីបានទទួលសារបែបនេះ ថ្នាំងនីមួយៗសម្អាតទិន្នន័យដែលត្រូវគ្នានៅក្នុងឃ្លាំងសម្ងាត់មូលដ្ឋានរបស់វា។

វគ្គអ្នកប្រើប្រាស់. ឃ្លាំងសម្ងាត់ជាមួយឈ្មោះ sessions, clientSessions, offlineSessions и offlineClientSessionsជាធម្មតាត្រូវបានចម្លងរវាងមជ្ឈមណ្ឌលទិន្នន័យ និងបម្រើដើម្បីរក្សាទុកទិន្នន័យអំពីវគ្គអ្នកប្រើប្រាស់ដែលសកម្មខណៈពេលដែលអ្នកប្រើប្រាស់សកម្មនៅក្នុងកម្មវិធីរុករក។ ឃ្លាំងសម្ងាត់ទាំងនេះដំណើរការជាមួយកម្មវិធីដំណើរការសំណើ HTTP ពីអ្នកប្រើប្រាស់ចុងក្រោយ ដូច្នេះពួកវាត្រូវបានភ្ជាប់ជាមួយវគ្គស្អិត ហើយត្រូវតែចម្លងគ្នារវាងមជ្ឈមណ្ឌលទិន្នន័យ។

ការការពារកម្លាំងសាហាវ. ឃ្លាំងសម្ងាត់ loginFailures ប្រើដើម្បីតាមដានទិន្នន័យកំហុសក្នុងការចូល ដូចជាចំនួនដងដែលអ្នកប្រើប្រាស់បញ្ចូលពាក្យសម្ងាត់មិនត្រឹមត្រូវ។ ការចម្លងនៃឃ្លាំងសម្ងាត់នេះគឺជាការទទួលខុសត្រូវរបស់អ្នកគ្រប់គ្រង។ ប៉ុន្តែសម្រាប់ការគណនាត្រឹមត្រូវ វាមានតម្លៃធ្វើឱ្យការចម្លងរវាងមជ្ឈមណ្ឌលទិន្នន័យសកម្ម។ ប៉ុន្តែម្យ៉ាងវិញទៀត ប្រសិនបើអ្នកមិនចម្លងទិន្នន័យនេះទេ អ្នកនឹងធ្វើឱ្យប្រសើរឡើងនូវការអនុវត្ត ហើយប្រសិនបើបញ្ហានេះកើតឡើង ការចម្លងអាចនឹងមិនដំណើរការទេ។

នៅពេលដាក់ចេញនូវចង្កោម Infinispan អ្នកត្រូវបន្ថែមនិយមន័យនៃឃ្លាំងសម្ងាត់ទៅក្នុងឯកសារការកំណត់៖

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

អ្នកត្រូវតែកំណត់រចនាសម្ព័ន្ធ និងចាប់ផ្តើមចង្កោម Infinispan មុនពេលចាប់ផ្តើមចង្កោម Keycloak

បន្ទាប់មកអ្នកត្រូវកំណត់រចនាសម្ព័ន្ធ remoteStore សម្រាប់ឃ្លាំងសម្ងាត់ Keycloak ។ ដើម្បីធ្វើដូច្នេះ ស្គ្រីបគឺគ្រប់គ្រាន់ហើយ ដែលត្រូវបានធ្វើស្រដៀងគ្នាទៅនឹងអត្ថបទមុន ដែលត្រូវបានប្រើដើម្បីកំណត់អថេរ 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 សម្រាប់ថ្នាំង Keycloak ដើម្បីដំណើរការ HotRod៖ remote.cache.host, remote.cache.port និងឈ្មោះសេវាកម្ម jboss.site.name.

តំណភ្ជាប់ និងឯកសារបន្ថែម

អត្ថបទនេះត្រូវបានបកប្រែ និងរៀបចំសម្រាប់ Habr ដោយបុគ្គលិក មជ្ឈមណ្ឌលហ្វឹកហ្វឺនអណ្តែត - វគ្គសិក្សាដែលពឹងផ្អែកខ្លាំង វគ្គវីដេអូ និងការបណ្តុះបណ្តាលសាជីវកម្មពីអ្នកជំនាញអនុវត្ត (Kubernetes, DevOps, Docker, Ansible, Ceph, SRE)

ប្រភព: www.habr.com

កំពុងដំណើរការ Keycloak នៅក្នុងរបៀប HA នៅលើ Kubernetes