🥇Kubernetes ನಲ್ಲಿ HA ಮೋಡ್‌ನಲ್ಲಿ ರನ್ನಿಂಗ್ ಕೀಕ್ಲೋಕ್

ಟಿಎಲ್; ಡಿಆರ್: ಕೀಕ್ಲೋಕ್, ಓಪನ್ ಸೋರ್ಸ್ ಪ್ರವೇಶ ನಿಯಂತ್ರಣ ವ್ಯವಸ್ಥೆ, ಆಂತರಿಕ ರಚನೆಯ ವಿಶ್ಲೇಷಣೆ, ಕಾನ್ಫಿಗರೇಶನ್ ವಿವರಗಳ ವಿವರಣೆ ಇರುತ್ತದೆ.

ಪರಿಚಯ ಮತ್ತು ಪ್ರಮುಖ ವಿಚಾರಗಳು

ಈ ಲೇಖನದಲ್ಲಿ, ಕುಬರ್ನೆಟ್ಸ್‌ನ ಮೇಲ್ಭಾಗದಲ್ಲಿ ಕೀಕ್ಲೋಕ್ ಕ್ಲಸ್ಟರ್ ಅನ್ನು ನಿಯೋಜಿಸುವಾಗ ನೆನಪಿನಲ್ಲಿಟ್ಟುಕೊಳ್ಳಬೇಕಾದ ಮೂಲ ವಿಚಾರಗಳನ್ನು ನಾವು ನೋಡುತ್ತೇವೆ.

ನೀವು ಕೀಕ್ಲೋಕ್ ಬಗ್ಗೆ ಇನ್ನಷ್ಟು ತಿಳಿದುಕೊಳ್ಳಲು ಬಯಸಿದರೆ, ಲೇಖನದ ಕೊನೆಯಲ್ಲಿ ಲಿಂಕ್‌ಗಳನ್ನು ನೋಡಿ. ಅಭ್ಯಾಸದಲ್ಲಿ ಹೆಚ್ಚು ಮುಳುಗಲು, ನೀವು ಅಧ್ಯಯನ ಮಾಡಬಹುದು ನಮ್ಮ ಭಂಡಾರ ಈ ಲೇಖನದ ಮುಖ್ಯ ಆಲೋಚನೆಗಳನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸುವ ಮಾಡ್ಯೂಲ್‌ನೊಂದಿಗೆ (ಉಡಾವಣಾ ಮಾರ್ಗದರ್ಶಿ ಇದೆ, ಈ ಲೇಖನವು ಸಾಧನ ಮತ್ತು ಸೆಟ್ಟಿಂಗ್‌ಗಳ ಅವಲೋಕನವನ್ನು ಒದಗಿಸುತ್ತದೆ, ಅಂದಾಜು ಅನುವಾದಕ).

ಕೀಕ್ಲೋಕ್ ಜಾವಾದಲ್ಲಿ ಬರೆಯಲಾದ ಮತ್ತು ಅಪ್ಲಿಕೇಶನ್ ಸರ್ವರ್‌ನ ಮೇಲ್ಭಾಗದಲ್ಲಿ ನಿರ್ಮಿಸಲಾದ ಸಮಗ್ರ ವ್ಯವಸ್ಥೆಯಾಗಿದೆ ವೈಲ್ಡ್ ಫ್ಲೈ. ಸಂಕ್ಷಿಪ್ತವಾಗಿ, ಇದು ಅಪ್ಲಿಕೇಶನ್ ಬಳಕೆದಾರರಿಗೆ ಫೆಡರೇಶನ್ ಮತ್ತು SSO (ಏಕ ಸೈನ್-ಆನ್) ಸಾಮರ್ಥ್ಯಗಳನ್ನು ನೀಡುವ ದೃಢೀಕರಣದ ಚೌಕಟ್ಟಾಗಿದೆ.

ಅಧಿಕೃತವನ್ನು ಓದಲು ನಾವು ನಿಮ್ಮನ್ನು ಆಹ್ವಾನಿಸುತ್ತೇವೆ ವೆಬ್ಸೈಟ್ ಅಥವಾ ವಿಕಿಪೀಡಿಯಾ ವಿವರವಾದ ತಿಳುವಳಿಕೆಗಾಗಿ.

ಕೀಕ್ಲೋಕ್ ಅನ್ನು ಪ್ರಾರಂಭಿಸಲಾಗುತ್ತಿದೆ

ಕೀಕ್ಲೋಕ್ ರನ್ ಮಾಡಲು ಎರಡು ನಿರಂತರ ಡೇಟಾ ಮೂಲಗಳ ಅಗತ್ಯವಿದೆ:

ಬಳಕೆದಾರರ ಮಾಹಿತಿಯಂತಹ ಸ್ಥಾಪಿತ ಡೇಟಾವನ್ನು ಸಂಗ್ರಹಿಸಲು ಬಳಸುವ ಡೇಟಾಬೇಸ್
ಡೇಟಾಬೇಸ್‌ನಿಂದ ಡೇಟಾವನ್ನು ಸಂಗ್ರಹಿಸಲು ಬಳಸಲಾಗುವ ಡೇಟಾಗ್ರಿಡ್ ಸಂಗ್ರಹ, ಹಾಗೆಯೇ ಬಳಕೆದಾರರ ಅವಧಿಗಳಂತಹ ಕೆಲವು ಅಲ್ಪಾವಧಿಯ ಮತ್ತು ಆಗಾಗ್ಗೆ ಬದಲಾಗುತ್ತಿರುವ ಮೆಟಾಡೇಟಾವನ್ನು ಸಂಗ್ರಹಿಸಲು ಬಳಸಲಾಗುತ್ತದೆ. ಅಳವಡಿಸಲಾಗಿದೆ ಇನ್ಫಿನಿಸ್ಪಾನ್, ಇದು ಸಾಮಾನ್ಯವಾಗಿ ಡೇಟಾಬೇಸ್‌ಗಿಂತ ಗಮನಾರ್ಹವಾಗಿ ವೇಗವಾಗಿರುತ್ತದೆ. ಆದರೆ ಯಾವುದೇ ಸಂದರ್ಭದಲ್ಲಿ, ಇನ್ಫಿನಿಸ್ಪಾನ್‌ನಲ್ಲಿ ಉಳಿಸಲಾದ ಡೇಟಾವು ಅಲ್ಪಕಾಲಿಕವಾಗಿರುತ್ತದೆ - ಮತ್ತು ಕ್ಲಸ್ಟರ್ ಅನ್ನು ಮರುಪ್ರಾರಂಭಿಸಿದಾಗ ಅದನ್ನು ಎಲ್ಲಿಯೂ ಉಳಿಸಬೇಕಾಗಿಲ್ಲ.

ಕೀಕ್ಲೋಕ್ ನಾಲ್ಕು ವಿಭಿನ್ನ ವಿಧಾನಗಳಲ್ಲಿ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತದೆ:

ಸಾಮಾನ್ಯ - ಒಂದು ಮತ್ತು ಒಂದೇ ಒಂದು ಪ್ರಕ್ರಿಯೆ, ಫೈಲ್ ಮೂಲಕ ಕಾನ್ಫಿಗರ್ ಮಾಡಲಾಗಿದೆ ಸ್ವತಂತ್ರ.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 ಕೀಕ್ಲೋಕ್ ಪ್ರಾಕ್ಸಿಯ ಹಿಂದೆ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತಿದೆ ಎಂಬ ತಿಳುವಳಿಕೆಯನ್ನು ನೀಡುತ್ತದೆ.

ನೀವು ಸಹ ಸಕ್ರಿಯಗೊಳಿಸಬೇಕು ಜಿಗುಟಾದ ಅವಧಿಗಳು ಪ್ರವೇಶದಲ್ಲಿ. ಪ್ರಸ್ತುತ ದೃಢೀಕರಣ ಸೆಷನ್ ಮತ್ತು ಬಳಕೆದಾರ ಸೆಶನ್‌ಗೆ ಸಂಬಂಧಿಸಿದ ಡೇಟಾವನ್ನು ಸಂಗ್ರಹಿಸಲು ಕೀಕ್ಲೋಕ್ ವಿತರಿಸಿದ ಇನ್ಫಿನಿಸ್ಪಾನ್ ಸಂಗ್ರಹವನ್ನು ಬಳಸುತ್ತದೆ. ಸಂಗ್ರಹಗಳು ಪೂರ್ವನಿಯೋಜಿತವಾಗಿ ಒಂದೇ ಮಾಲೀಕರೊಂದಿಗೆ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತವೆ, ಬೇರೆ ರೀತಿಯಲ್ಲಿ ಹೇಳುವುದಾದರೆ, ನಿರ್ದಿಷ್ಟ ಸೆಶನ್ ಅನ್ನು ಕ್ಲಸ್ಟರ್‌ನಲ್ಲಿ ಕೆಲವು ನೋಡ್‌ನಲ್ಲಿ ಸಂಗ್ರಹಿಸಲಾಗುತ್ತದೆ ಮತ್ತು ಆ ಸೆಷನ್‌ಗೆ ಪ್ರವೇಶದ ಅಗತ್ಯವಿದ್ದರೆ ಇತರ ನೋಡ್‌ಗಳು ಅದನ್ನು ದೂರದಿಂದಲೇ ಪ್ರಶ್ನಿಸಬೇಕು.

ನಿರ್ದಿಷ್ಟವಾಗಿ ಹೇಳುವುದಾದರೆ, ದಾಖಲಾತಿಗೆ ವಿರುದ್ಧವಾಗಿ, ಕುಕೀ ಹೆಸರಿನೊಂದಿಗೆ ಸೆಶನ್ ಅನ್ನು ಲಗತ್ತಿಸುವುದು ನಮಗೆ ಕೆಲಸ ಮಾಡಲಿಲ್ಲ 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 ಮಲ್ಟಿಕಾಸ್ಟ್ ಬೆಂಬಲದೊಂದಿಗೆ ಖಾಸಗಿ ನೆಟ್‌ವರ್ಕ್

ನೀವು Weavenet ಅನ್ನು CNI ಆಗಿ ಬಳಸಿದರೆ, ಮಲ್ಟಿಕ್ಯಾಸ್ಟ್ ತಕ್ಷಣವೇ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತದೆ - ಮತ್ತು ನಿಮ್ಮ ಕೀಕ್ಲೋಕ್ ನೋಡ್‌ಗಳು ಪ್ರಾರಂಭವಾದ ತಕ್ಷಣ ಪರಸ್ಪರ ನೋಡುತ್ತವೆ.

ನಿಮ್ಮ ಕುಬರ್ನೆಟ್ಸ್ ಕ್ಲಸ್ಟರ್‌ನಲ್ಲಿ ನೀವು 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.

ಡೇಟಾ ಕೇಂದ್ರಗಳ ನಡುವಿನ ಪ್ರತಿರೂಪ

ಸಂಪರ್ಕ

ಕೀಕ್ಲೋಕ್ ಕೀಕ್ಲೋಕ್ ನೋಡ್‌ಗಳಿಂದ ಮಾಡಲ್ಪಟ್ಟ ಕೀಕ್ಲಾಕ್ ಕ್ಲಸ್ಟರ್‌ಗಳು ಇರುವ ಪ್ರತಿಯೊಂದು ಡೇಟಾ ಸೆಂಟರ್‌ಗಾಗಿ ಅನೇಕ ಪ್ರತ್ಯೇಕ ಇನ್ಫಿನಿಸ್ಪಾನ್ ಕ್ಯಾಶ್ ಕ್ಲಸ್ಟರ್‌ಗಳನ್ನು ಬಳಸುತ್ತದೆ. ಆದರೆ ವಿವಿಧ ಡೇಟಾ ಕೇಂದ್ರಗಳಲ್ಲಿ ಕೀಕ್ಲೋಕ್ ನೋಡ್‌ಗಳ ನಡುವೆ ಯಾವುದೇ ವ್ಯತ್ಯಾಸವಿಲ್ಲ.

ಕೀಕ್ಲೋಕ್ ನೋಡ್‌ಗಳು ಡೇಟಾ ಕೇಂದ್ರಗಳ ನಡುವಿನ ಸಂವಹನಕ್ಕಾಗಿ ಬಾಹ್ಯ ಜಾವಾ ಡೇಟಾ ಗ್ರಿಡ್ (ಇನ್‌ಫಿನಿಸ್ಪಾನ್ ಸರ್ವರ್‌ಗಳು) ಅನ್ನು ಬಳಸುತ್ತವೆ. ಪ್ರೋಟೋಕಾಲ್ ಪ್ರಕಾರ ಸಂವಹನವು ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತದೆ ಇನ್ಫಿನಿಸ್ಪಾನ್ ಹಾಟ್ರಾಡ್.

Infinispan ಕ್ಯಾಶ್‌ಗಳನ್ನು ಗುಣಲಕ್ಷಣದೊಂದಿಗೆ ಕಾನ್ಫಿಗರ್ ಮಾಡಬೇಕು remoteStore, ಇದರಿಂದ ಡೇಟಾವನ್ನು ದೂರದಿಂದಲೇ ಸಂಗ್ರಹಿಸಬಹುದು (ಮತ್ತೊಂದು ಡೇಟಾ ಕೇಂದ್ರದಲ್ಲಿ, ಅಂದಾಜು ಅನುವಾದಕ) ಸಂಗ್ರಹಗಳು. JDG ಸರ್ವರ್‌ಗಳಲ್ಲಿ ಪ್ರತ್ಯೇಕ ಇನ್‌ಫಿನಿಸ್ಪಾನ್ ಕ್ಲಸ್ಟರ್‌ಗಳಿವೆ, ಇದರಿಂದಾಗಿ ಸೈಟ್‌ನಲ್ಲಿ JDG1 ನಲ್ಲಿ ಡೇಟಾವನ್ನು ಸಂಗ್ರಹಿಸಲಾಗಿದೆ site1 ಸೈಟ್‌ನಲ್ಲಿ JDG2 ಗೆ ಪುನರಾವರ್ತಿಸಲಾಗುತ್ತದೆ site2.

ಮತ್ತು ಅಂತಿಮವಾಗಿ, ಸ್ವೀಕರಿಸುವ JDG ಸರ್ವರ್ ಕ್ಲೈಂಟ್ ಸಂಪರ್ಕಗಳ ಮೂಲಕ ಅದರ ಕ್ಲಸ್ಟರ್‌ನ ಕೀಕ್ಲೋಕ್ ಸರ್ವರ್‌ಗಳಿಗೆ ಸೂಚನೆ ನೀಡುತ್ತದೆ, ಇದು HotRod ಪ್ರೋಟೋಕಾಲ್‌ನ ವೈಶಿಷ್ಟ್ಯವಾಗಿದೆ. ಕೀಕ್ಲೋಕ್ ನೋಡ್‌ಗಳು ಆನ್ ಆಗಿವೆ site2 ಅವರ ಇನ್ಫಿನಿಸ್ಪಾನ್ ಕ್ಯಾಶ್‌ಗಳನ್ನು ನವೀಕರಿಸಿ ಮತ್ತು ನಿರ್ದಿಷ್ಟ ಬಳಕೆದಾರ ಸೆಶನ್ ಕೀಕ್ಲೋಕ್ ನೋಡ್‌ಗಳಲ್ಲಿ ಸಹ ಲಭ್ಯವಾಗುತ್ತದೆ site2.

ಕೆಲವು ಕ್ಯಾಶ್‌ಗಳಿಗಾಗಿ, ಬ್ಯಾಕ್‌ಅಪ್‌ಗಳನ್ನು ಮಾಡದಿರುವುದು ಮತ್ತು Infinispan ಸರ್ವರ್ ಮೂಲಕ ಡೇಟಾವನ್ನು ಬರೆಯುವುದನ್ನು ಸಂಪೂರ್ಣವಾಗಿ ತಪ್ಪಿಸುವುದು ಸಹ ಸಾಧ್ಯವಿದೆ. ಇದನ್ನು ಮಾಡಲು ನೀವು ಸೆಟ್ಟಿಂಗ್ ಅನ್ನು ತೆಗೆದುಹಾಕಬೇಕು remote-store ನಿರ್ದಿಷ್ಟ Infinispan ಸಂಗ್ರಹ (ಫೈಲ್‌ನಲ್ಲಿ ಸ್ವತಂತ್ರ-ha.xml), ಅದರ ನಂತರ ಕೆಲವು ನಿರ್ದಿಷ್ಟ replicated-cache ಇನ್ಫಿನಿಸ್ಪಾನ್ ಸರ್ವರ್ ಬದಿಯಲ್ಲಿ ಇನ್ನು ಮುಂದೆ ಅಗತ್ಯವಿರುವುದಿಲ್ಲ.

ಸಂಗ್ರಹಗಳನ್ನು ಹೊಂದಿಸಲಾಗುತ್ತಿದೆ

ಕೀಕ್ಲೋಕ್‌ನಲ್ಲಿ ಎರಡು ರೀತಿಯ ಕ್ಯಾಶ್‌ಗಳಿವೆ:

ಸ್ಥಳೀಯ. ಇದು ಡೇಟಾಬೇಸ್‌ನ ಪಕ್ಕದಲ್ಲಿದೆ ಮತ್ತು ಡೇಟಾಬೇಸ್‌ನಲ್ಲಿನ ಲೋಡ್ ಅನ್ನು ಕಡಿಮೆ ಮಾಡಲು ಮತ್ತು ಪ್ರತಿಕ್ರಿಯೆ ಸುಪ್ತತೆಯನ್ನು ಕಡಿಮೆ ಮಾಡಲು ಸಹಾಯ ಮಾಡುತ್ತದೆ. ಈ ರೀತಿಯ ಸಂಗ್ರಹವು ಕ್ಷೇತ್ರ, ಕ್ಲೈಂಟ್‌ಗಳು, ಪಾತ್ರಗಳು ಮತ್ತು ಬಳಕೆದಾರರ ಮೆಟಾಡೇಟಾವನ್ನು ಸಂಗ್ರಹಿಸುತ್ತದೆ. ಸಂಗ್ರಹವು ಕೀಕ್ಲೋಕ್ ಕ್ಲಸ್ಟರ್‌ನ ಭಾಗವಾಗಿದ್ದರೂ ಸಹ, ಈ ರೀತಿಯ ಸಂಗ್ರಹವನ್ನು ಪುನರಾವರ್ತಿಸಲಾಗುವುದಿಲ್ಲ. ಸಂಗ್ರಹದಲ್ಲಿನ ನಮೂದು ಬದಲಾದರೆ, ಬದಲಾವಣೆಯ ಕುರಿತು ಸಂದೇಶವನ್ನು ಕ್ಲಸ್ಟರ್‌ನಲ್ಲಿ ಉಳಿದಿರುವ ಸರ್ವರ್‌ಗಳಿಗೆ ಕಳುಹಿಸಲಾಗುತ್ತದೆ, ಅದರ ನಂತರ ಪ್ರವೇಶವನ್ನು ಸಂಗ್ರಹದಿಂದ ಹೊರಗಿಡಲಾಗುತ್ತದೆ. ವಿವರಣೆಯನ್ನು ನೋಡಿ work ಕಾರ್ಯವಿಧಾನದ ಹೆಚ್ಚು ವಿವರವಾದ ವಿವರಣೆಗಾಗಿ ಕೆಳಗೆ ನೋಡಿ.
ಪುನರಾವರ್ತಿಸಲಾಗಿದೆ. ಬಳಕೆದಾರರ ಅವಧಿಗಳು, ಆಫ್‌ಲೈನ್ ಟೋಕನ್‌ಗಳನ್ನು ಪ್ರಕ್ರಿಯೆಗೊಳಿಸುತ್ತದೆ ಮತ್ತು ಪಾಸ್‌ವರ್ಡ್ ಫಿಶಿಂಗ್ ಪ್ರಯತ್ನಗಳು ಮತ್ತು ಇತರ ದಾಳಿಗಳನ್ನು ಪತ್ತೆಹಚ್ಚಲು ಲಾಗಿನ್ ದೋಷಗಳನ್ನು ಸಹ ಮೇಲ್ವಿಚಾರಣೆ ಮಾಡುತ್ತದೆ. ಈ ಕ್ಯಾಶ್‌ಗಳಲ್ಲಿ ಸಂಗ್ರಹವಾಗಿರುವ ಡೇಟಾ ತಾತ್ಕಾಲಿಕವಾಗಿರುತ್ತದೆ, RAM ನಲ್ಲಿ ಮಾತ್ರ ಸಂಗ್ರಹಿಸಲಾಗುತ್ತದೆ, ಆದರೆ ಕ್ಲಸ್ಟರ್‌ನಾದ್ಯಂತ ಪುನರಾವರ್ತಿಸಬಹುದು.

ಇನ್ಫಿನಿಸ್ಪಾನ್ ಸಂಗ್ರಹಗಳು

ಸೆಷನ್ಸ್ - ಕೀಕ್ಲೋಕ್‌ನಲ್ಲಿನ ಪರಿಕಲ್ಪನೆ, ಪ್ರತ್ಯೇಕ ಸಂಗ್ರಹಗಳು ಎಂದು ಕರೆಯಲ್ಪಡುತ್ತವೆ authenticationSessions, ನಿರ್ದಿಷ್ಟ ಬಳಕೆದಾರರ ಡೇಟಾವನ್ನು ಸಂಗ್ರಹಿಸಲು ಬಳಸಲಾಗುತ್ತದೆ. ಈ ಕ್ಯಾಷ್‌ಗಳಿಂದ ವಿನಂತಿಗಳು ಸಾಮಾನ್ಯವಾಗಿ ಬ್ರೌಸರ್ ಮತ್ತು ಕೀಕ್ಲೋಕ್ ಸರ್ವರ್‌ಗಳಿಗೆ ಅಗತ್ಯವಿರುತ್ತದೆ, ಅಪ್ಲಿಕೇಶನ್‌ಗಳಿಂದ ಅಲ್ಲ. ಇಲ್ಲಿಯೇ ಜಿಗುಟಾದ ಸೆಷನ್‌ಗಳ ಮೇಲಿನ ಅವಲಂಬನೆಯು ಕಾರ್ಯರೂಪಕ್ಕೆ ಬರುತ್ತದೆ ಮತ್ತು ಸಕ್ರಿಯ-ಸಕ್ರಿಯ ಮೋಡ್‌ನ ಸಂದರ್ಭದಲ್ಲಿಯೂ ಸಹ ಅಂತಹ ಸಂಗ್ರಹಗಳನ್ನು ಸ್ವತಃ ಪುನರಾವರ್ತಿಸುವ ಅಗತ್ಯವಿಲ್ಲ.

ಆಕ್ಷನ್ ಟೋಕನ್ಗಳು. ಮತ್ತೊಂದು ಪರಿಕಲ್ಪನೆಯನ್ನು ಸಾಮಾನ್ಯವಾಗಿ ವಿವಿಧ ಸನ್ನಿವೇಶಗಳಿಗೆ ಬಳಸಲಾಗುತ್ತದೆ, ಉದಾಹರಣೆಗೆ, ಬಳಕೆದಾರರು ಮೇಲ್ ಮೂಲಕ ಅಸಮಕಾಲಿಕವಾಗಿ ಏನನ್ನಾದರೂ ಮಾಡಬೇಕು. ಉದಾಹರಣೆಗೆ, ಕಾರ್ಯವಿಧಾನದ ಸಮಯದಲ್ಲಿ forget password ಸಂಗ್ರಹ actionTokens ಸಂಯೋಜಿತ ಟೋಕನ್‌ಗಳ ಮೆಟಾಡೇಟಾವನ್ನು ಟ್ರ್ಯಾಕ್ ಮಾಡಲು ಬಳಸಲಾಗುತ್ತದೆ - ಉದಾಹರಣೆಗೆ, ಟೋಕನ್ ಅನ್ನು ಈಗಾಗಲೇ ಬಳಸಲಾಗಿದೆ ಮತ್ತು ಮತ್ತೆ ಸಕ್ರಿಯಗೊಳಿಸಲು ಸಾಧ್ಯವಿಲ್ಲ. ಈ ರೀತಿಯ ಸಂಗ್ರಹವನ್ನು ಸಾಮಾನ್ಯವಾಗಿ ಡೇಟಾ ಕೇಂದ್ರಗಳ ನಡುವೆ ಪುನರಾವರ್ತಿಸುವ ಅಗತ್ಯವಿದೆ.

ಸಂಗ್ರಹಿಸಿದ ಡೇಟಾದ ಕ್ಯಾಶಿಂಗ್ ಮತ್ತು ವಯಸ್ಸಾದ ಡೇಟಾಬೇಸ್‌ನಲ್ಲಿನ ಲೋಡ್ ಅನ್ನು ನಿವಾರಿಸಲು ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತದೆ. ಈ ರೀತಿಯ ಹಿಡಿದಿಟ್ಟುಕೊಳ್ಳುವಿಕೆಯು ಕಾರ್ಯಕ್ಷಮತೆಯನ್ನು ಸುಧಾರಿಸುತ್ತದೆ, ಆದರೆ ಸ್ಪಷ್ಟವಾದ ಸಮಸ್ಯೆಯನ್ನು ಸೇರಿಸುತ್ತದೆ. ಒಂದು ಕೀಕ್ಲೋಕ್ ಸರ್ವರ್ ಡೇಟಾವನ್ನು ನವೀಕರಿಸಿದರೆ, ಇತರ ಸರ್ವರ್‌ಗಳಿಗೆ ಸೂಚನೆ ನೀಡಬೇಕು ಇದರಿಂದ ಅವರು ತಮ್ಮ ಕ್ಯಾಶ್‌ಗಳಲ್ಲಿ ಡೇಟಾವನ್ನು ನವೀಕರಿಸಬಹುದು. ಕೀಕ್ಲೋಕ್ ಸ್ಥಳೀಯ ಸಂಗ್ರಹಗಳನ್ನು ಬಳಸುತ್ತದೆ 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.

ಲಿಂಕ್‌ಗಳು ಮತ್ತು ಹೆಚ್ಚುವರಿ ದಾಖಲೆಗಳು

ಲೇಖನವನ್ನು ಉದ್ಯೋಗಿಗಳಿಂದ ಹಬ್ರ್‌ಗಾಗಿ ಅನುವಾದಿಸಲಾಗಿದೆ ಮತ್ತು ಸಿದ್ಧಪಡಿಸಲಾಗಿದೆ ಸ್ಲರ್ಮ್ ತರಬೇತಿ ಕೇಂದ್ರ - ತೀವ್ರವಾದ ಕೋರ್ಸ್‌ಗಳು, ವೀಡಿಯೊ ಕೋರ್ಸ್‌ಗಳು ಮತ್ತು ಅಭ್ಯಾಸ ಮಾಡುವ ತಜ್ಞರಿಂದ ಕಾರ್ಪೊರೇಟ್ ತರಬೇತಿ (ಕುಬರ್ನೆಟ್ಸ್, ಡೆವೊಪ್ಸ್, ಡಾಕರ್, ಅನ್ಸಿಬಲ್, ಸೆಫ್, ಎಸ್‌ಆರ್‌ಇ)

ಮೂಲ: www.habr.com

ಕುಬರ್ನೆಟ್ಸ್‌ನಲ್ಲಿ HA ಮೋಡ್‌ನಲ್ಲಿ ಕೀಕ್ಲೋಕ್ ರನ್ ಆಗುತ್ತಿದೆ