ਕੁਬਰਨੇਟਸ ਉੱਤੇ HA ਮੋਡ ਵਿੱਚ ਕੀਕਲੋਕ ਚੱਲ ਰਿਹਾ ਹੈ

TL; ਡਾ: ਇੱਥੇ ਕੀਕਲੌਕ, ਇੱਕ ਓਪਨ ਸੋਰਸ ਐਕਸੈਸ ਕੰਟਰੋਲ ਸਿਸਟਮ, ਅੰਦਰੂਨੀ ਢਾਂਚੇ ਦਾ ਵਿਸ਼ਲੇਸ਼ਣ, ਸੰਰਚਨਾ ਵੇਰਵੇ ਦਾ ਵਰਣਨ ਹੋਵੇਗਾ।

ਜਾਣ-ਪਛਾਣ ਅਤੇ ਮੁੱਖ ਵਿਚਾਰ

ਇਸ ਲੇਖ ਵਿੱਚ, ਅਸੀਂ ਕੁਬਰਨੇਟਸ ਦੇ ਸਿਖਰ 'ਤੇ ਇੱਕ ਕੀਕਲੌਕ ਕਲੱਸਟਰ ਨੂੰ ਤੈਨਾਤ ਕਰਦੇ ਸਮੇਂ ਧਿਆਨ ਵਿੱਚ ਰੱਖਣ ਲਈ ਬੁਨਿਆਦੀ ਵਿਚਾਰਾਂ ਨੂੰ ਦੇਖਾਂਗੇ।

ਜੇ ਤੁਸੀਂ ਕੀਕਲੌਕ ਬਾਰੇ ਹੋਰ ਜਾਣਨਾ ਚਾਹੁੰਦੇ ਹੋ, ਤਾਂ ਲੇਖ ਦੇ ਅੰਤ ਵਿੱਚ ਦਿੱਤੇ ਲਿੰਕ ਵੇਖੋ। ਅਭਿਆਸ ਵਿੱਚ ਵਧੇਰੇ ਲੀਨ ਹੋਣ ਲਈ, ਤੁਸੀਂ ਅਧਿਐਨ ਕਰ ਸਕਦੇ ਹੋ ਸਾਡੀ ਰਿਪੋਜ਼ਟਰੀ ਇੱਕ ਮੋਡੀਊਲ ਦੇ ਨਾਲ ਜੋ ਇਸ ਲੇਖ ਦੇ ਮੁੱਖ ਵਿਚਾਰਾਂ ਨੂੰ ਲਾਗੂ ਕਰਦਾ ਹੈ (ਲਾਂਚ ਗਾਈਡ ਉੱਥੇ ਹੈ, ਇਹ ਲੇਖ ਡਿਵਾਈਸ ਅਤੇ ਸੈਟਿੰਗਾਂ ਦੀ ਇੱਕ ਸੰਖੇਪ ਜਾਣਕਾਰੀ ਪ੍ਰਦਾਨ ਕਰੇਗਾ, ਲਗਭਗ ਅਨੁਵਾਦਕ).

ਕੀਕਲੌਕ ਇੱਕ ਵਿਆਪਕ ਸਿਸਟਮ ਹੈ ਜੋ Java ਵਿੱਚ ਲਿਖਿਆ ਗਿਆ ਹੈ ਅਤੇ ਇੱਕ ਐਪਲੀਕੇਸ਼ਨ ਸਰਵਰ ਦੇ ਸਿਖਰ 'ਤੇ ਬਣਾਇਆ ਗਿਆ ਹੈ ਜੰਗਲੀ ਮੱਖੀ. ਸੰਖੇਪ ਵਿੱਚ, ਇਹ ਅਧਿਕਾਰ ਲਈ ਇੱਕ ਢਾਂਚਾ ਹੈ ਜੋ ਐਪਲੀਕੇਸ਼ਨ ਉਪਭੋਗਤਾਵਾਂ ਨੂੰ ਫੈਡਰੇਸ਼ਨ ਅਤੇ SSO (ਸਿੰਗਲ ਸਾਈਨ-ਆਨ) ਸਮਰੱਥਾਵਾਂ ਦਿੰਦਾ ਹੈ।

ਅਸੀਂ ਤੁਹਾਨੂੰ ਅਧਿਕਾਰੀ ਨੂੰ ਪੜ੍ਹਨ ਲਈ ਸੱਦਾ ਦਿੰਦੇ ਹਾਂ ਵੈਬਸਾਈਟ ਜ ਵਿਕੀਪੀਡੀਆ ਵਿਸਤ੍ਰਿਤ ਸਮਝ ਲਈ.

ਕੀਕਲੌਕ ਲਾਂਚ ਕੀਤਾ ਜਾ ਰਿਹਾ ਹੈ

Keycloak ਨੂੰ ਚਲਾਉਣ ਲਈ ਦੋ ਨਿਰੰਤਰ ਡੇਟਾ ਸਰੋਤਾਂ ਦੀ ਲੋੜ ਹੁੰਦੀ ਹੈ:

• ਇੱਕ ਡੇਟਾਬੇਸ ਸਥਾਪਤ ਡੇਟਾ ਨੂੰ ਸਟੋਰ ਕਰਨ ਲਈ ਵਰਤਿਆ ਜਾਂਦਾ ਹੈ, ਜਿਵੇਂ ਕਿ ਉਪਭੋਗਤਾ ਜਾਣਕਾਰੀ
• ਡੈਟਾਗ੍ਰਿਡ ਕੈਸ਼, ਜੋ ਕਿ ਡੇਟਾਬੇਸ ਤੋਂ ਡੇਟਾ ਨੂੰ ਕੈਸ਼ ਕਰਨ ਲਈ ਵਰਤਿਆ ਜਾਂਦਾ ਹੈ, ਨਾਲ ਹੀ ਕੁਝ ਥੋੜ੍ਹੇ ਸਮੇਂ ਲਈ ਅਤੇ ਅਕਸਰ ਬਦਲਣ ਵਾਲੇ ਮੈਟਾਡੇਟਾ ਨੂੰ ਸਟੋਰ ਕਰਨ ਲਈ, ਜਿਵੇਂ ਕਿ ਉਪਭੋਗਤਾ ਸੈਸ਼ਨ। ਲਾਗੂ ਕੀਤਾ ਇਨਫਿਨਿਸਪੈਨ, ਜੋ ਕਿ ਆਮ ਤੌਰ 'ਤੇ ਡਾਟਾਬੇਸ ਨਾਲੋਂ ਕਾਫ਼ੀ ਤੇਜ਼ ਹੁੰਦਾ ਹੈ। ਪਰ ਕਿਸੇ ਵੀ ਸਥਿਤੀ ਵਿੱਚ, ਇਨਫਿਨਿਸਪੈਨ ਵਿੱਚ ਸੁਰੱਖਿਅਤ ਕੀਤਾ ਗਿਆ ਡੇਟਾ ਥੋੜ੍ਹੇ ਸਮੇਂ ਲਈ ਹੁੰਦਾ ਹੈ - ਅਤੇ ਜਦੋਂ ਕਲੱਸਟਰ ਮੁੜ ਚਾਲੂ ਹੁੰਦਾ ਹੈ ਤਾਂ ਇਸਨੂੰ ਕਿਤੇ ਵੀ ਸੁਰੱਖਿਅਤ ਕਰਨ ਦੀ ਲੋੜ ਨਹੀਂ ਹੁੰਦੀ ਹੈ।

ਕੀਕਲੌਕ ਚਾਰ ਵੱਖ-ਵੱਖ ਮੋਡਾਂ ਵਿੱਚ ਕੰਮ ਕਰਦਾ ਹੈ:

• ਆਮ - ਇੱਕ ਅਤੇ ਕੇਵਲ ਇੱਕ ਪ੍ਰਕਿਰਿਆ, ਇੱਕ ਫਾਈਲ ਦੁਆਰਾ ਕੌਂਫਿਗਰ ਕੀਤੀ ਗਈ standalone.xml
• ਨਿਯਮਤ ਕਲੱਸਟਰ (ਉੱਚ ਉਪਲਬਧਤਾ ਵਿਕਲਪ) - ਸਾਰੀਆਂ ਪ੍ਰਕਿਰਿਆਵਾਂ ਨੂੰ ਇੱਕੋ ਸੰਰਚਨਾ ਦੀ ਵਰਤੋਂ ਕਰਨੀ ਚਾਹੀਦੀ ਹੈ, ਜੋ ਕਿ ਦਸਤੀ ਸਮਕਾਲੀ ਹੋਣੀ ਚਾਹੀਦੀ ਹੈ। ਸੈਟਿੰਗਾਂ ਇੱਕ ਫਾਈਲ ਵਿੱਚ ਸਟੋਰ ਕੀਤੀਆਂ ਜਾਂਦੀਆਂ ਹਨ standalone-ha.xml, ਇਸ ਤੋਂ ਇਲਾਵਾ ਤੁਹਾਨੂੰ ਡੇਟਾਬੇਸ ਅਤੇ ਇੱਕ ਲੋਡ ਬੈਲੇਂਸਰ ਤੱਕ ਸਾਂਝੀ ਪਹੁੰਚ ਬਣਾਉਣ ਦੀ ਲੋੜ ਹੈ।
• ਡੋਮੇਨ ਕਲੱਸਟਰ — ਆਮ ਮੋਡ ਵਿੱਚ ਕਲੱਸਟਰ ਸ਼ੁਰੂ ਕਰਨਾ ਇੱਕ ਰੁਟੀਨ ਅਤੇ ਬੋਰਿੰਗ ਕੰਮ ਬਣ ਜਾਂਦਾ ਹੈ ਜਿਵੇਂ ਕਿ ਕਲੱਸਟਰ ਵਧਦਾ ਹੈ, ਕਿਉਂਕਿ ਹਰ ਵਾਰ ਸੰਰਚਨਾ ਬਦਲਦੀ ਹੈ, ਹਰ ਇੱਕ ਕਲੱਸਟਰ ਨੋਡ ਵਿੱਚ ਸਾਰੀਆਂ ਤਬਦੀਲੀਆਂ ਕੀਤੀਆਂ ਜਾਣੀਆਂ ਚਾਹੀਦੀਆਂ ਹਨ। ਸੰਚਾਲਨ ਦਾ ਡੋਮੇਨ ਮੋਡ ਕੁਝ ਸਾਂਝਾ ਸਟੋਰੇਜ ਸਥਾਨ ਸਥਾਪਤ ਕਰਕੇ ਅਤੇ ਸੰਰਚਨਾ ਪ੍ਰਕਾਸ਼ਿਤ ਕਰਕੇ ਇਸ ਮੁੱਦੇ ਨੂੰ ਹੱਲ ਕਰਦਾ ਹੈ। ਇਹ ਸੈਟਿੰਗਾਂ ਫਾਈਲ ਵਿੱਚ ਸਟੋਰ ਕੀਤੀਆਂ ਜਾਂਦੀਆਂ ਹਨ domain.xml
• ਡਾਟਾ ਸੈਂਟਰਾਂ ਵਿਚਕਾਰ ਪ੍ਰਤੀਕ੍ਰਿਤੀ — ਜੇਕਰ ਤੁਸੀਂ ਕਈ ਡਾਟਾ ਸੈਂਟਰਾਂ ਦੇ ਕਲੱਸਟਰ ਵਿੱਚ ਕੀਕਲੋਕ ਚਲਾਉਣਾ ਚਾਹੁੰਦੇ ਹੋ, ਅਕਸਰ ਵੱਖ-ਵੱਖ ਭੂਗੋਲਿਕ ਸਥਾਨਾਂ ਵਿੱਚ। ਇਸ ਵਿਕਲਪ ਵਿੱਚ, ਹਰੇਕ ਡੇਟਾ ਸੈਂਟਰ ਦਾ ਕੀਕਲੌਕ ਸਰਵਰਾਂ ਦਾ ਆਪਣਾ ਕਲੱਸਟਰ ਹੋਵੇਗਾ।

ਇਸ ਲੇਖ ਵਿਚ ਅਸੀਂ ਦੂਜੇ ਵਿਕਲਪ 'ਤੇ ਵਿਸਥਾਰ ਨਾਲ ਵਿਚਾਰ ਕਰਾਂਗੇ, ਯਾਨੀ ਨਿਯਮਤ ਕਲੱਸਟਰ, ਅਤੇ ਅਸੀਂ ਡੇਟਾ ਸੈਂਟਰਾਂ ਦੇ ਵਿਚਕਾਰ ਪ੍ਰਤੀਕ੍ਰਿਤੀ ਦੇ ਵਿਸ਼ੇ 'ਤੇ ਵੀ ਥੋੜਾ ਜਿਹਾ ਛੂਹ ਲਵਾਂਗੇ, ਕਿਉਂਕਿ ਇਹ ਕੁਬਰਨੇਟਸ ਵਿੱਚ ਇਹਨਾਂ ਦੋ ਵਿਕਲਪਾਂ ਨੂੰ ਚਲਾਉਣਾ ਸਮਝਦਾਰ ਹੈ। ਖੁਸ਼ਕਿਸਮਤੀ ਨਾਲ, ਕੁਬਰਨੇਟਸ ਵਿੱਚ ਕਈ ਪੌਡਾਂ (ਕੀਕਲੌਕ ਨੋਡ) ਦੀਆਂ ਸੈਟਿੰਗਾਂ ਨੂੰ ਸਮਕਾਲੀ ਕਰਨ ਵਿੱਚ ਕੋਈ ਸਮੱਸਿਆ ਨਹੀਂ ਹੈ, ਇਸ ਲਈ ਡੋਮੇਨ ਕਲੱਸਟਰ ਇਹ ਕਰਨਾ ਬਹੁਤ ਮੁਸ਼ਕਲ ਨਹੀਂ ਹੋਵੇਗਾ।

ਇਹ ਵੀ ਕਿਰਪਾ ਕਰਕੇ ਧਿਆਨ ਦਿਓ ਕਿ ਸ਼ਬਦ ਕਲੱਸਟਰ ਬਾਕੀ ਦੇ ਲੇਖ ਲਈ ਸਿਰਫ਼ ਇਕੱਠੇ ਕੰਮ ਕਰਨ ਵਾਲੇ ਕੀਕਲੌਕ ਨੋਡਾਂ ਦੇ ਸਮੂਹ 'ਤੇ ਲਾਗੂ ਹੋਵੇਗਾ, ਕੁਬਰਨੇਟਸ ਕਲੱਸਟਰ ਦਾ ਹਵਾਲਾ ਦੇਣ ਦੀ ਕੋਈ ਲੋੜ ਨਹੀਂ ਹੈ।

ਰੈਗੂਲਰ ਕੀਕਲੌਕ ਕਲੱਸਟਰ

ਇਸ ਮੋਡ ਵਿੱਚ ਕੀਕਲੌਕ ਚਲਾਉਣ ਲਈ ਤੁਹਾਨੂੰ ਲੋੜ ਹੈ:

• ਬਾਹਰੀ ਸਾਂਝਾ ਡੇਟਾਬੇਸ ਕੌਂਫਿਗਰ ਕਰੋ
• ਲੋਡ ਬੈਲੈਂਸਰ ਸਥਾਪਿਤ ਕਰੋ
• IP ਮਲਟੀਕਾਸਟ ਸਮਰਥਨ ਦੇ ਨਾਲ ਇੱਕ ਅੰਦਰੂਨੀ ਨੈੱਟਵਰਕ ਹੈ

ਅਸੀਂ ਇੱਕ ਬਾਹਰੀ ਡੇਟਾਬੇਸ ਸਥਾਪਤ ਕਰਨ ਬਾਰੇ ਚਰਚਾ ਨਹੀਂ ਕਰਾਂਗੇ, ਕਿਉਂਕਿ ਇਹ ਇਸ ਲੇਖ ਦਾ ਉਦੇਸ਼ ਨਹੀਂ ਹੈ। ਚਲੋ ਇਹ ਮੰਨ ਲਓ ਕਿ ਕਿਤੇ ਇੱਕ ਕੰਮ ਕਰਨ ਵਾਲਾ ਡੇਟਾਬੇਸ ਹੈ - ਅਤੇ ਸਾਡੇ ਕੋਲ ਇਸਦਾ ਇੱਕ ਕਨੈਕਸ਼ਨ ਪੁਆਇੰਟ ਹੈ. ਅਸੀਂ ਬਸ ਇਸ ਡੇਟਾ ਨੂੰ ਵਾਤਾਵਰਣ ਵੇਰੀਏਬਲ ਵਿੱਚ ਜੋੜਾਂਗੇ।

ਫੇਲਓਵਰ (HA) ਕਲੱਸਟਰ ਵਿੱਚ Keycloak ਕਿਵੇਂ ਕੰਮ ਕਰਦਾ ਹੈ, ਇਹ ਚੰਗੀ ਤਰ੍ਹਾਂ ਸਮਝਣ ਲਈ, ਇਹ ਜਾਣਨਾ ਮਹੱਤਵਪੂਰਨ ਹੈ ਕਿ ਇਹ ਸਭ ਵਾਈਲਡਫਲਾਈ ਦੀਆਂ ਕਲੱਸਟਰਿੰਗ ਸਮਰੱਥਾਵਾਂ 'ਤੇ ਕਿੰਨਾ ਨਿਰਭਰ ਕਰਦਾ ਹੈ।

ਵਾਈਲਡਫਲਾਈ ਕਈ ਉਪ-ਪ੍ਰਣਾਲੀਆਂ ਦੀ ਵਰਤੋਂ ਕਰਦਾ ਹੈ, ਉਹਨਾਂ ਵਿੱਚੋਂ ਕੁਝ ਨੂੰ ਲੋਡ ਬੈਲੈਂਸਰ ਵਜੋਂ ਵਰਤਿਆ ਜਾਂਦਾ ਹੈ, ਕੁਝ ਨੁਕਸ ਸਹਿਣਸ਼ੀਲਤਾ ਲਈ। ਲੋਡ ਬੈਲੇਂਸਰ ਐਪਲੀਕੇਸ਼ਨ ਦੀ ਉਪਲਬਧਤਾ ਨੂੰ ਯਕੀਨੀ ਬਣਾਉਂਦਾ ਹੈ ਜਦੋਂ ਇੱਕ ਕਲੱਸਟਰ ਨੋਡ ਓਵਰਲੋਡ ਹੁੰਦਾ ਹੈ, ਅਤੇ ਨੁਕਸ ਸਹਿਣਸ਼ੀਲਤਾ ਐਪਲੀਕੇਸ਼ਨ ਦੀ ਉਪਲਬਧਤਾ ਨੂੰ ਯਕੀਨੀ ਬਣਾਉਂਦਾ ਹੈ ਭਾਵੇਂ ਕੁਝ ਕਲੱਸਟਰ ਨੋਡ ਫੇਲ ਹੋ ਜਾਣ। ਇਹਨਾਂ ਵਿੱਚੋਂ ਕੁਝ ਉਪ-ਪ੍ਰਣਾਲੀਆਂ:

• mod_cluster: ਅਪਾਚੇ ਦੇ ਨਾਲ HTTP ਲੋਡ ਬੈਲੇਂਸਰ ਦੇ ਰੂਪ ਵਿੱਚ ਕੰਮ ਕਰਦਾ ਹੈ, ਮੂਲ ਰੂਪ ਵਿੱਚ ਹੋਸਟਾਂ ਨੂੰ ਲੱਭਣ ਲਈ TCP ਮਲਟੀਕਾਸਟ 'ਤੇ ਨਿਰਭਰ ਕਰਦਾ ਹੈ। ਇੱਕ ਬਾਹਰੀ ਬੈਲੇਂਸਰ ਨਾਲ ਬਦਲਿਆ ਜਾ ਸਕਦਾ ਹੈ.

• infinispan: ਇੱਕ ਟ੍ਰਾਂਸਪੋਰਟ ਲੇਅਰ ਵਜੋਂ JGroups ਚੈਨਲਾਂ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ ਇੱਕ ਵੰਡਿਆ ਕੈਸ਼। ਇਸ ਤੋਂ ਇਲਾਵਾ, ਇਹ ਕੈਸ਼ ਸਮੱਗਰੀਆਂ ਨੂੰ ਸਮਕਾਲੀ ਕਰਨ ਲਈ ਬਾਹਰੀ ਇਨਫਿਨਿਸਪੈਨ ਕਲੱਸਟਰ ਨਾਲ ਸੰਚਾਰ ਕਰਨ ਲਈ ਹੌਟਰੋਡ ਪ੍ਰੋਟੋਕੋਲ ਦੀ ਵਰਤੋਂ ਕਰ ਸਕਦਾ ਹੈ।

• jgroups: JGroups ਚੈਨਲਾਂ 'ਤੇ ਅਧਾਰਤ ਉੱਚ ਉਪਲਬਧ ਸੇਵਾਵਾਂ ਲਈ ਸਮੂਹ ਸੰਚਾਰ ਸਹਾਇਤਾ ਪ੍ਰਦਾਨ ਕਰਦਾ ਹੈ। ਨਾਮ ਵਾਲੀਆਂ ਪਾਈਪਾਂ ਇੱਕ ਕਲੱਸਟਰ ਵਿੱਚ ਐਪਲੀਕੇਸ਼ਨ ਉਦਾਹਰਨਾਂ ਨੂੰ ਸਮੂਹਾਂ ਵਿੱਚ ਜੋੜਨ ਦੀ ਆਗਿਆ ਦਿੰਦੀਆਂ ਹਨ ਤਾਂ ਜੋ ਸੰਚਾਰ ਵਿੱਚ ਭਰੋਸੇਯੋਗਤਾ, ਵਿਵਸਥਿਤਤਾ ਅਤੇ ਅਸਫਲਤਾਵਾਂ ਪ੍ਰਤੀ ਸੰਵੇਦਨਸ਼ੀਲਤਾ ਵਰਗੀਆਂ ਵਿਸ਼ੇਸ਼ਤਾਵਾਂ ਹੋਣ।

ਲੋਡ ਬੈਲੈਂਸਰ

ਕੁਬਰਨੇਟਸ ਕਲੱਸਟਰ ਵਿੱਚ ਇੱਕ ਪ੍ਰਵੇਸ਼ ਕੰਟਰੋਲਰ ਦੇ ਤੌਰ ਤੇ ਇੱਕ ਬੈਲੇਂਸਰ ਨੂੰ ਸਥਾਪਿਤ ਕਰਦੇ ਸਮੇਂ, ਹੇਠ ਲਿਖੀਆਂ ਗੱਲਾਂ ਨੂੰ ਧਿਆਨ ਵਿੱਚ ਰੱਖਣਾ ਮਹੱਤਵਪੂਰਨ ਹੈ:

Keycloak ਇਹ ਮੰਨਦਾ ਹੈ ਕਿ ਪ੍ਰਮਾਣਿਕਤਾ ਸਰਵਰ ਨਾਲ HTTP ਰਾਹੀਂ ਕਨੈਕਟ ਕਰਨ ਵਾਲੇ ਕਲਾਇੰਟ ਦਾ ਰਿਮੋਟ ਪਤਾ ਕਲਾਇੰਟ ਕੰਪਿਊਟਰ ਦਾ ਅਸਲ IP ਪਤਾ ਹੈ। ਬੈਲੈਂਸਰ ਅਤੇ ਇਨਗਰੇਸ ਸੈਟਿੰਗਾਂ ਨੂੰ HTTP ਸਿਰਲੇਖਾਂ ਨੂੰ ਸਹੀ ਢੰਗ ਨਾਲ ਸੈੱਟ ਕਰਨਾ ਚਾਹੀਦਾ ਹੈ X-Forwarded-For и X-Forwarded-Proto, ਅਤੇ ਅਸਲੀ ਸਿਰਲੇਖ ਨੂੰ ਵੀ ਸੁਰੱਖਿਅਤ ਕਰੋ HOST. ਨਵੀਨਤਮ ਸੰਸਕਰਣ ingress-nginx (>0.22.0) ਇਸ ਨੂੰ ਮੂਲ ਰੂਪ ਵਿੱਚ ਅਯੋਗ ਕਰਦਾ ਹੈ

ਫਲੈਗ ਨੂੰ ਸਰਗਰਮ ਕੀਤਾ ਜਾ ਰਿਹਾ ਹੈ proxy-address-forwarding ਇੱਕ ਵਾਤਾਵਰਣ ਵੇਰੀਏਬਲ ਸੈੱਟ ਕਰਕੇ PROXY_ADDRESS_FORWARDING в true ਕੀਕਲੋਕ ਨੂੰ ਇਹ ਸਮਝ ਦਿੰਦਾ ਹੈ ਕਿ ਇਹ ਇੱਕ ਪ੍ਰੌਕਸੀ ਦੇ ਪਿੱਛੇ ਕੰਮ ਕਰ ਰਿਹਾ ਹੈ।

ਤੁਹਾਨੂੰ ਇਹ ਵੀ ਯੋਗ ਕਰਨ ਦੀ ਲੋੜ ਹੈ ਸਟਿੱਕੀ ਸੈਸ਼ਨ ਪ੍ਰਵੇਸ਼ ਵਿੱਚ. ਕੀਕਲੌਕ ਵਰਤਮਾਨ ਪ੍ਰਮਾਣਿਕਤਾ ਸੈਸ਼ਨ ਅਤੇ ਉਪਭੋਗਤਾ ਸੈਸ਼ਨ ਨਾਲ ਜੁੜੇ ਡੇਟਾ ਨੂੰ ਸਟੋਰ ਕਰਨ ਲਈ ਇੱਕ ਵਿਤਰਿਤ ਇਨਫਿਨਿਸਪੈਨ ਕੈਸ਼ ਦੀ ਵਰਤੋਂ ਕਰਦਾ ਹੈ। ਕੈਚ ਡਿਫੌਲਟ ਰੂਪ ਵਿੱਚ ਇੱਕ ਸਿੰਗਲ ਮਾਲਕ ਨਾਲ ਕੰਮ ਕਰਦੇ ਹਨ, ਦੂਜੇ ਸ਼ਬਦਾਂ ਵਿੱਚ, ਉਹ ਖਾਸ ਸੈਸ਼ਨ ਕਲੱਸਟਰ ਵਿੱਚ ਕੁਝ ਨੋਡ 'ਤੇ ਸਟੋਰ ਕੀਤਾ ਜਾਂਦਾ ਹੈ, ਅਤੇ ਦੂਜੇ ਨੋਡਾਂ ਨੂੰ ਇਸ ਤੋਂ ਰਿਮੋਟ ਤੋਂ ਪੁੱਛਗਿੱਛ ਕਰਨੀ ਚਾਹੀਦੀ ਹੈ ਜੇਕਰ ਉਹਨਾਂ ਨੂੰ ਉਸ ਸੈਸ਼ਨ ਤੱਕ ਪਹੁੰਚ ਦੀ ਲੋੜ ਹੁੰਦੀ ਹੈ।

ਖਾਸ ਤੌਰ 'ਤੇ, ਦਸਤਾਵੇਜ਼ਾਂ ਦੇ ਉਲਟ, ਕੂਕੀ ਨਾਮ ਦੇ ਨਾਲ ਇੱਕ ਸੈਸ਼ਨ ਜੋੜਨਾ ਸਾਡੇ ਲਈ ਕੰਮ ਨਹੀਂ ਕਰਦਾ ਹੈ AUTH_SESSION_ID. ਕੀਕਲੋਕ ਵਿੱਚ ਇੱਕ ਰੀਡਾਇਰੈਕਟ ਲੂਪ ਹੈ, ਇਸਲਈ ਅਸੀਂ ਸਟਿੱਕੀ ਸੈਸ਼ਨ ਲਈ ਇੱਕ ਵੱਖਰਾ ਕੂਕੀ ਨਾਮ ਚੁਣਨ ਦੀ ਸਿਫ਼ਾਰਿਸ਼ ਕਰਦੇ ਹਾਂ।

ਕੀਕਲੋਕ ਨੋਡ ਦਾ ਨਾਮ ਵੀ ਜੋੜਦਾ ਹੈ ਜਿਸ ਨੇ ਪਹਿਲਾਂ ਜਵਾਬ ਦਿੱਤਾ ਸੀ 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 ਮਲਟੀਕਾਸਟ ਸਮਰਥਨ ਦੇ ਨਾਲ ਪ੍ਰਾਈਵੇਟ ਨੈੱਟਵਰਕ

ਜੇ ਤੁਸੀਂ ਸੀਐਨਆਈ ਦੇ ਤੌਰ 'ਤੇ ਵੇਵਨੇਟ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋ, ਤਾਂ ਮਲਟੀਕਾਸਟ ਤੁਰੰਤ ਕੰਮ ਕਰੇਗਾ - ਅਤੇ ਤੁਹਾਡੇ ਕੀਕਲੌਕ ਨੋਡਸ ਇੱਕ ਦੂਜੇ ਨੂੰ ਜਿਵੇਂ ਹੀ ਉਹ ਲਾਂਚ ਕੀਤੇ ਜਾਣਗੇ, ਦੇਖਣਗੇ।

ਜੇਕਰ ਤੁਹਾਡੇ ਕੋਲ ਤੁਹਾਡੇ Kubernetes ਕਲੱਸਟਰ ਵਿੱਚ ip ਮਲਟੀਕਾਸਟ ਸਮਰਥਨ ਨਹੀਂ ਹੈ, ਤਾਂ ਤੁਸੀਂ ਨੋਡਾਂ ਨੂੰ ਲੱਭਣ ਲਈ ਹੋਰ ਪ੍ਰੋਟੋਕੋਲ ਨਾਲ ਕੰਮ ਕਰਨ ਲਈ JGroups ਨੂੰ ਕੌਂਫਿਗਰ ਕਰ ਸਕਦੇ ਹੋ।

ਪਹਿਲਾ ਵਿਕਲਪ ਵਰਤਣਾ ਹੈ KUBE_DNSਜੋ ਵਰਤਦਾ ਹੈ headless service ਕੀਕਲੌਕ ਨੋਡਸ ਨੂੰ ਲੱਭਣ ਲਈ, ਤੁਸੀਂ ਬਸ JGroups ਨੂੰ ਸੇਵਾ ਦਾ ਨਾਮ ਪਾਸ ਕਰੋ ਜੋ ਨੋਡਸ ਨੂੰ ਲੱਭਣ ਲਈ ਵਰਤੀ ਜਾਵੇਗੀ।

ਇੱਕ ਹੋਰ ਵਿਕਲਪ ਵਿਧੀ ਦੀ ਵਰਤੋਂ ਕਰਨਾ ਹੈ 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.

ਡਾਟਾ ਸੈਂਟਰਾਂ ਵਿਚਕਾਰ ਪ੍ਰਤੀਕ੍ਰਿਤੀ

ਕਨੈਕਟੀਵਿਟੀ

Keycloak ਹਰੇਕ ਡੇਟਾ ਸੈਂਟਰ ਲਈ ਮਲਟੀਪਲ ਵੱਖਰੇ ਇਨਫਿਨਿਸਪੈਨ ਕੈਸ਼ ਕਲੱਸਟਰਾਂ ਦੀ ਵਰਤੋਂ ਕਰਦਾ ਹੈ ਜਿੱਥੇ ਕੀਕਲੌਕ ਨੋਡਾਂ ਦੇ ਬਣੇ ਕੀਕਲੌਕ ਕਲੱਸਟਰ ਸਥਿਤ ਹੁੰਦੇ ਹਨ। ਪਰ ਵੱਖ-ਵੱਖ ਡੇਟਾ ਸੈਂਟਰਾਂ ਵਿੱਚ ਕੀਕਲੌਕ ਨੋਡਾਂ ਵਿੱਚ ਕੋਈ ਅੰਤਰ ਨਹੀਂ ਹੈ.

ਕੀਕਲੌਕ ਨੋਡ ਡੇਟਾ ਸੈਂਟਰਾਂ ਵਿਚਕਾਰ ਸੰਚਾਰ ਲਈ ਇੱਕ ਬਾਹਰੀ ਜਾਵਾ ਡੇਟਾ ਗਰਿੱਡ (ਇਨਫਿਨਿਸਪੈਨ ਸਰਵਰ) ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹਨ। ਸੰਚਾਰ ਪ੍ਰੋਟੋਕੋਲ ਦੇ ਅਨੁਸਾਰ ਕੰਮ ਕਰਦਾ ਹੈ Infinispan HotRod.

Infinispan ਕੈਚਾਂ ਨੂੰ ਵਿਸ਼ੇਸ਼ਤਾ ਨਾਲ ਸੰਰਚਿਤ ਕੀਤਾ ਜਾਣਾ ਚਾਹੀਦਾ ਹੈ remoteStore, ਤਾਂ ਜੋ ਡੇਟਾ ਨੂੰ ਰਿਮੋਟਲੀ ਸਟੋਰ ਕੀਤਾ ਜਾ ਸਕੇ (ਕਿਸੇ ਹੋਰ ਡੇਟਾ ਸੈਂਟਰ ਵਿੱਚ, ਲਗਭਗ ਅਨੁਵਾਦਕ) ਕੈਸ਼. JDG ਸਰਵਰਾਂ ਵਿੱਚ ਵੱਖਰੇ ਇਨਫਿਨਿਸਪੈਨ ਕਲੱਸਟਰ ਹਨ, ਤਾਂ ਜੋ ਸਾਈਟ 'ਤੇ JDG1 'ਤੇ ਸਟੋਰ ਕੀਤਾ ਡਾਟਾ site1 ਸਾਈਟ 'ਤੇ JDG2 ਨੂੰ ਦੁਹਰਾਇਆ ਜਾਵੇਗਾ site2.

ਅਤੇ ਅੰਤ ਵਿੱਚ, ਪ੍ਰਾਪਤ ਕਰਨ ਵਾਲਾ JDG ਸਰਵਰ ਕਲਾਇੰਟ ਕੁਨੈਕਸ਼ਨਾਂ ਦੁਆਰਾ ਇਸਦੇ ਕਲੱਸਟਰ ਦੇ ਕੀਕਲੌਕ ਸਰਵਰਾਂ ਨੂੰ ਸੂਚਿਤ ਕਰਦਾ ਹੈ, ਜੋ ਕਿ HotRod ਪ੍ਰੋਟੋਕੋਲ ਦੀ ਇੱਕ ਵਿਸ਼ੇਸ਼ਤਾ ਹੈ। ਕੀਕਲੌਕ ਨੋਡ ਚਾਲੂ site2 ਉਹਨਾਂ ਦੇ Infinispan ਕੈਚਾਂ ਨੂੰ ਅੱਪਡੇਟ ਕਰੋ ਅਤੇ ਖਾਸ ਉਪਭੋਗਤਾ ਸੈਸ਼ਨ ਕੀਕਲੋਕ ਨੋਡ 'ਤੇ ਵੀ ਉਪਲਬਧ ਹੋ ਜਾਵੇਗਾ site2.

ਕੁਝ ਕੈਚਾਂ ਲਈ, ਬੈਕਅੱਪ ਨਾ ਲੈਣਾ ਅਤੇ Infinispan ਸਰਵਰ ਦੁਆਰਾ ਪੂਰੀ ਤਰ੍ਹਾਂ ਨਾਲ ਡਾਟਾ ਲਿਖਣ ਤੋਂ ਬਚਣਾ ਵੀ ਸੰਭਵ ਹੈ। ਅਜਿਹਾ ਕਰਨ ਲਈ ਤੁਹਾਨੂੰ ਸੈਟਿੰਗ ਨੂੰ ਹਟਾਉਣ ਦੀ ਲੋੜ ਹੈ remote-store ਖਾਸ Infinispan ਕੈਸ਼ (ਫਾਇਲ ਵਿੱਚ standalone-ha.xml), ਜਿਸ ਤੋਂ ਬਾਅਦ ਕੁਝ ਖਾਸ replicated-cache Infinispan ਸਰਵਰ ਸਾਈਡ 'ਤੇ ਵੀ ਹੁਣ ਲੋੜ ਨਹੀਂ ਹੋਵੇਗੀ।

ਕੈਚ ਸੈੱਟਅੱਪ ਕਰ ਰਿਹਾ ਹੈ

ਕੀਕਲੋਕ ਵਿੱਚ ਦੋ ਤਰ੍ਹਾਂ ਦੇ ਕੈਚ ਹਨ:

• ਸਥਾਨਕ. ਇਹ ਡੇਟਾਬੇਸ ਦੇ ਅੱਗੇ ਸਥਿਤ ਹੈ ਅਤੇ ਡੇਟਾਬੇਸ 'ਤੇ ਲੋਡ ਨੂੰ ਘਟਾਉਣ ਦੇ ਨਾਲ-ਨਾਲ ਜਵਾਬ ਦੇ ਲੇਟੈਂਸੀ ਨੂੰ ਘਟਾਉਣ ਲਈ ਕੰਮ ਕਰਦਾ ਹੈ। ਇਸ ਕਿਸਮ ਦਾ ਕੈਸ਼ ਖੇਤਰ, ਕਲਾਇੰਟਸ, ਰੋਲ ਅਤੇ ਉਪਭੋਗਤਾ ਮੈਟਾਡੇਟਾ ਸਟੋਰ ਕਰਦਾ ਹੈ। ਇਸ ਕਿਸਮ ਦੇ ਕੈਸ਼ ਨੂੰ ਦੁਹਰਾਇਆ ਨਹੀਂ ਜਾਂਦਾ ਹੈ, ਭਾਵੇਂ ਕੈਸ਼ ਕੀਕਲੋਅਕ ਕਲੱਸਟਰ ਦਾ ਹਿੱਸਾ ਹੋਵੇ। ਜੇਕਰ ਕੈਸ਼ ਵਿੱਚ ਕੋਈ ਐਂਟਰੀ ਬਦਲ ਜਾਂਦੀ ਹੈ, ਤਾਂ ਕਲੱਸਟਰ ਵਿੱਚ ਬਾਕੀ ਸਰਵਰਾਂ ਨੂੰ ਤਬਦੀਲੀ ਬਾਰੇ ਇੱਕ ਸੁਨੇਹਾ ਭੇਜਿਆ ਜਾਂਦਾ ਹੈ, ਜਿਸ ਤੋਂ ਬਾਅਦ ਐਂਟਰੀ ਨੂੰ ਕੈਸ਼ ਵਿੱਚੋਂ ਬਾਹਰ ਕਰ ਦਿੱਤਾ ਜਾਂਦਾ ਹੈ। ਵੇਰਵਾ ਵੇਖੋ work ਵਿਧੀ ਦੇ ਵਧੇਰੇ ਵਿਸਤ੍ਰਿਤ ਵਰਣਨ ਲਈ ਹੇਠਾਂ ਦੇਖੋ।

• ਦੁਹਰਾਇਆ। ਉਪਭੋਗਤਾ ਸੈਸ਼ਨਾਂ, ਔਫਲਾਈਨ ਟੋਕਨਾਂ ਦੀ ਪ੍ਰਕਿਰਿਆ ਕਰਦਾ ਹੈ, ਅਤੇ ਪਾਸਵਰਡ ਫਿਸ਼ਿੰਗ ਕੋਸ਼ਿਸ਼ਾਂ ਅਤੇ ਹੋਰ ਹਮਲਿਆਂ ਦਾ ਪਤਾ ਲਗਾਉਣ ਲਈ ਲੌਗਇਨ ਗਲਤੀਆਂ ਦੀ ਨਿਗਰਾਨੀ ਕਰਦਾ ਹੈ। ਇਹਨਾਂ ਕੈਚਾਂ ਵਿੱਚ ਸਟੋਰ ਕੀਤਾ ਡੇਟਾ ਅਸਥਾਈ ਹੁੰਦਾ ਹੈ, ਸਿਰਫ਼ RAM ਵਿੱਚ ਸਟੋਰ ਕੀਤਾ ਜਾਂਦਾ ਹੈ, ਪਰ ਇਸ ਨੂੰ ਕਲੱਸਟਰ ਵਿੱਚ ਦੁਹਰਾਇਆ ਜਾ ਸਕਦਾ ਹੈ।

Infinispan ਕੈਸ਼

ਸੈਸ਼ਨ - ਕੀਕਲੋਕ ਵਿੱਚ ਇੱਕ ਸੰਕਲਪ, ਵੱਖਰੇ ਕੈਚ ਕਹਿੰਦੇ ਹਨ authenticationSessions, ਖਾਸ ਉਪਭੋਗਤਾਵਾਂ ਦੇ ਡੇਟਾ ਨੂੰ ਸਟੋਰ ਕਰਨ ਲਈ ਵਰਤਿਆ ਜਾਂਦਾ ਹੈ। ਇਹਨਾਂ ਕੈਚਾਂ ਤੋਂ ਬੇਨਤੀਆਂ ਦੀ ਆਮ ਤੌਰ 'ਤੇ ਬ੍ਰਾਊਜ਼ਰ ਅਤੇ ਕੀਕਲੌਕ ਸਰਵਰਾਂ ਦੁਆਰਾ ਲੋੜ ਹੁੰਦੀ ਹੈ, ਨਾ ਕਿ ਐਪਲੀਕੇਸ਼ਨਾਂ ਦੁਆਰਾ। ਇਹ ਉਹ ਥਾਂ ਹੈ ਜਿੱਥੇ ਸਟਿੱਕੀ ਸੈਸ਼ਨਾਂ 'ਤੇ ਨਿਰਭਰਤਾ ਲਾਗੂ ਹੁੰਦੀ ਹੈ, ਅਤੇ ਅਜਿਹੇ ਕੈਚਾਂ ਨੂੰ ਆਪਣੇ ਆਪ ਨੂੰ ਦੁਹਰਾਉਣ ਦੀ ਲੋੜ ਨਹੀਂ ਹੁੰਦੀ ਹੈ, ਭਾਵੇਂ ਕਿ ਐਕਟਿਵ-ਐਕਟਿਵ ਮੋਡ ਦੇ ਮਾਮਲੇ ਵਿੱਚ.

ਐਕਸ਼ਨ ਟੋਕਨ. ਇੱਕ ਹੋਰ ਸੰਕਲਪ, ਆਮ ਤੌਰ 'ਤੇ ਵੱਖ-ਵੱਖ ਦ੍ਰਿਸ਼ਾਂ ਲਈ ਵਰਤਿਆ ਜਾਂਦਾ ਹੈ ਜਦੋਂ, ਉਦਾਹਰਨ ਲਈ, ਉਪਭੋਗਤਾ ਨੂੰ ਡਾਕ ਰਾਹੀਂ ਅਸਿੰਕਰੋਨਸ ਤੌਰ 'ਤੇ ਕੁਝ ਕਰਨਾ ਚਾਹੀਦਾ ਹੈ। ਉਦਾਹਰਨ ਲਈ, ਪ੍ਰਕਿਰਿਆ ਦੇ ਦੌਰਾਨ forget password ਕੈਚ actionTokens ਸੰਬੰਧਿਤ ਟੋਕਨਾਂ ਦੇ ਮੈਟਾਡੇਟਾ ਨੂੰ ਟਰੈਕ ਕਰਨ ਲਈ ਵਰਤਿਆ ਜਾਂਦਾ ਹੈ - ਉਦਾਹਰਨ ਲਈ, ਇੱਕ ਟੋਕਨ ਪਹਿਲਾਂ ਹੀ ਵਰਤਿਆ ਜਾ ਚੁੱਕਾ ਹੈ ਅਤੇ ਇਸਨੂੰ ਦੁਬਾਰਾ ਸਰਗਰਮ ਨਹੀਂ ਕੀਤਾ ਜਾ ਸਕਦਾ ਹੈ। ਇਸ ਕਿਸਮ ਦੇ ਕੈਸ਼ ਨੂੰ ਆਮ ਤੌਰ 'ਤੇ ਡਾਟਾ ਸੈਂਟਰਾਂ ਵਿਚਕਾਰ ਦੁਹਰਾਉਣ ਦੀ ਲੋੜ ਹੁੰਦੀ ਹੈ।

ਸਟੋਰ ਕੀਤੇ ਡੇਟਾ ਦੀ ਕੈਚਿੰਗ ਅਤੇ ਬੁਢਾਪਾ ਡਾਟਾਬੇਸ 'ਤੇ ਲੋਡ ਨੂੰ ਦੂਰ ਕਰਨ ਲਈ ਕੰਮ ਕਰਦਾ ਹੈ. ਇਸ ਕਿਸਮ ਦੀ ਕੈਚਿੰਗ ਕਾਰਗੁਜ਼ਾਰੀ ਵਿੱਚ ਸੁਧਾਰ ਕਰਦੀ ਹੈ, ਪਰ ਇੱਕ ਸਪੱਸ਼ਟ ਸਮੱਸਿਆ ਜੋੜਦੀ ਹੈ। ਜੇਕਰ ਇੱਕ Keycloak ਸਰਵਰ ਡਾਟਾ ਅੱਪਡੇਟ ਕਰਦਾ ਹੈ, ਤਾਂ ਦੂਜੇ ਸਰਵਰਾਂ ਨੂੰ ਸੂਚਿਤ ਕੀਤਾ ਜਾਣਾ ਚਾਹੀਦਾ ਹੈ ਤਾਂ ਜੋ ਉਹ ਆਪਣੇ ਕੈਚ ਵਿੱਚ ਡੇਟਾ ਨੂੰ ਅੱਪਡੇਟ ਕਰ ਸਕਣ। ਕੀਕਲੌਕ ਸਥਾਨਕ ਕੈਚਾਂ ਦੀ ਵਰਤੋਂ ਕਰਦਾ ਹੈ realms, users и authorization ਡਾਟਾਬੇਸ ਤੋਂ ਡਾਟਾ ਕੈਸ਼ ਕਰਨ ਲਈ।

ਇੱਕ ਵੱਖਰਾ ਕੈਸ਼ ਵੀ ਹੈ work, ਜੋ ਸਾਰੇ ਡਾਟਾ ਕੇਂਦਰਾਂ ਵਿੱਚ ਦੁਹਰਾਇਆ ਜਾਂਦਾ ਹੈ। ਇਹ ਆਪਣੇ ਆਪ ਵਿੱਚ ਡੇਟਾਬੇਸ ਤੋਂ ਕੋਈ ਡੇਟਾ ਸਟੋਰ ਨਹੀਂ ਕਰਦਾ ਹੈ, ਪਰ ਡੇਟਾ ਸੈਂਟਰਾਂ ਦੇ ਵਿਚਕਾਰ ਕਲੱਸਟਰ ਨੋਡਾਂ ਵਿੱਚ ਡੇਟਾ ਦੀ ਉਮਰ ਬਾਰੇ ਸੰਦੇਸ਼ ਭੇਜਣ ਲਈ ਕੰਮ ਕਰਦਾ ਹੈ। ਦੂਜੇ ਸ਼ਬਦਾਂ ਵਿੱਚ, ਜਿਵੇਂ ਹੀ ਡੇਟਾ ਅੱਪਡੇਟ ਹੁੰਦਾ ਹੈ, ਕੀਕਲੌਕ ਨੋਡ ਆਪਣੇ ਡੇਟਾ ਸੈਂਟਰ ਵਿੱਚ ਦੂਜੇ ਨੋਡਾਂ ਦੇ ਨਾਲ-ਨਾਲ ਦੂਜੇ ਡੇਟਾ ਸੈਂਟਰਾਂ ਵਿੱਚ ਨੋਡਾਂ ਨੂੰ ਇੱਕ ਸੁਨੇਹਾ ਭੇਜਦਾ ਹੈ। ਅਜਿਹਾ ਸੁਨੇਹਾ ਪ੍ਰਾਪਤ ਕਰਨ ਤੋਂ ਬਾਅਦ, ਹਰੇਕ ਨੋਡ ਆਪਣੇ ਸਥਾਨਕ ਕੈਚਾਂ ਵਿੱਚ ਸੰਬੰਧਿਤ ਡੇਟਾ ਨੂੰ ਸਾਫ਼ ਕਰਦਾ ਹੈ।

ਉਪਭੋਗਤਾ ਸੈਸ਼ਨ. ਨਾਵਾਂ ਦੇ ਨਾਲ ਕੈਸ਼ 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" />

ਕੀਕਲੌਕ ਕਲੱਸਟਰ ਸ਼ੁਰੂ ਕਰਨ ਤੋਂ ਪਹਿਲਾਂ ਤੁਹਾਨੂੰ ਇਨਫਿਨਿਸਪੈਨ ਕਲੱਸਟਰ ਨੂੰ ਸੰਰਚਿਤ ਅਤੇ ਚਾਲੂ ਕਰਨਾ ਚਾਹੀਦਾ ਹੈ

ਫਿਰ ਤੁਹਾਨੂੰ ਸੰਰਚਨਾ ਕਰਨ ਦੀ ਲੋੜ ਹੈ 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

ਲੇਖ ਦਾ ਅਨੁਵਾਦ ਅਤੇ ਕਰਮਚਾਰੀਆਂ ਦੁਆਰਾ ਹੈਬਰ ਲਈ ਤਿਆਰ ਕੀਤਾ ਗਿਆ ਸੀ ਝੁੱਗੀ ਸਿਖਲਾਈ ਕੇਂਦਰ — ਅਭਿਆਸ ਕਰਨ ਵਾਲੇ ਮਾਹਰਾਂ (ਕੁਬਰਨੇਟਸ, ਦੇਵਓਪਸ, ਡੌਕਰ, ਜਵਾਬਦੇਹ, ਸੇਫ, ਐਸਆਰਈ) ਤੋਂ ਤੀਬਰ ਕੋਰਸ, ਵੀਡੀਓ ਕੋਰਸ ਅਤੇ ਕਾਰਪੋਰੇਟ ਸਿਖਲਾਈ

ਸਰੋਤ: www.habr.com