OpenShift ಗಾಗಿ GitOps ಗೆ ಪರಿಚಯ

ಇಂದು ನಾವು GitOps ನ ತತ್ವಗಳು ಮತ್ತು ಮಾದರಿಗಳ ಬಗ್ಗೆ ಮಾತನಾಡುತ್ತೇವೆ, ಹಾಗೆಯೇ ಈ ಮಾದರಿಗಳನ್ನು OpenShift ವೇದಿಕೆಯಲ್ಲಿ ಹೇಗೆ ಅಳವಡಿಸಲಾಗಿದೆ. ಈ ವಿಷಯದ ಕುರಿತು ಸಂವಾದಾತ್ಮಕ ಮಾರ್ಗದರ್ಶಿ ಲಭ್ಯವಿದೆ ಲಿಂಕ್.

ಸಂಕ್ಷಿಪ್ತವಾಗಿ, GitOps ಮೂಲಸೌಕರ್ಯ ಮತ್ತು ಅಪ್ಲಿಕೇಶನ್ ಕಾನ್ಫಿಗರೇಶನ್‌ಗಳನ್ನು ನಿರ್ವಹಿಸಲು Git ಪುಲ್ ವಿನಂತಿಗಳನ್ನು ಬಳಸುವ ಅಭ್ಯಾಸಗಳ ಒಂದು ಗುಂಪಾಗಿದೆ. GitOps ನಲ್ಲಿನ Git ರೆಪೊಸಿಟರಿಯನ್ನು ಸಿಸ್ಟಮ್‌ನ ಸ್ಥಿತಿಯ ಬಗ್ಗೆ ಮಾಹಿತಿಯ ಏಕೈಕ ಮೂಲವಾಗಿ ಪರಿಗಣಿಸಲಾಗುತ್ತದೆ ಮತ್ತು ಈ ಸ್ಥಿತಿಗೆ ಯಾವುದೇ ಬದಲಾವಣೆಗಳನ್ನು ಸಂಪೂರ್ಣವಾಗಿ ಪತ್ತೆಹಚ್ಚಬಹುದಾಗಿದೆ ಮತ್ತು ಆಡಿಟ್ ಮಾಡಬಹುದಾಗಿದೆ.

GitOps ನಲ್ಲಿ ಬದಲಾವಣೆ ಟ್ರ್ಯಾಕಿಂಗ್ ಕಲ್ಪನೆಯು ಹೊಸದಲ್ಲ; ಅಪ್ಲಿಕೇಶನ್ ಮೂಲ ಕೋಡ್‌ನೊಂದಿಗೆ ಕೆಲಸ ಮಾಡುವಾಗ ಈ ವಿಧಾನವನ್ನು ಸಾರ್ವತ್ರಿಕವಾಗಿ ದೀರ್ಘಕಾಲ ಬಳಸಲಾಗಿದೆ. ಮೂಲಸೌಕರ್ಯ ಮತ್ತು ಅಪ್ಲಿಕೇಶನ್ ಕಾನ್ಫಿಗರೇಶನ್ ನಿರ್ವಹಣೆಯಲ್ಲಿ GitOps ಒಂದೇ ರೀತಿಯ ವೈಶಿಷ್ಟ್ಯಗಳನ್ನು (ವಿಮರ್ಶೆಗಳು, ಪುಲ್ ವಿನಂತಿಗಳು, ಟ್ಯಾಗ್‌ಗಳು, ಇತ್ಯಾದಿ) ಕಾರ್ಯಗತಗೊಳಿಸುತ್ತದೆ ಮತ್ತು ಮೂಲ ಕೋಡ್ ನಿರ್ವಹಣೆಯ ಸಂದರ್ಭದಲ್ಲಿ ಅದೇ ರೀತಿಯ ಪ್ರಯೋಜನಗಳನ್ನು ಒದಗಿಸುತ್ತದೆ.

GitOps ಗಾಗಿ ಯಾವುದೇ ಶೈಕ್ಷಣಿಕ ವ್ಯಾಖ್ಯಾನ ಅಥವಾ ಅನುಮೋದಿತ ನಿಯಮಗಳಿಲ್ಲ, ಈ ಅಭ್ಯಾಸವನ್ನು ನಿರ್ಮಿಸಿದ ತತ್ವಗಳ ಒಂದು ಸೆಟ್ ಮಾತ್ರ:

• ಸಿಸ್ಟಮ್ನ ಘೋಷಣಾತ್ಮಕ ವಿವರಣೆಯನ್ನು Git ರೆಪೊಸಿಟರಿಯಲ್ಲಿ ಸಂಗ್ರಹಿಸಲಾಗಿದೆ (ಸಂರಚನೆಗಳು, ಮೇಲ್ವಿಚಾರಣೆ, ಇತ್ಯಾದಿ.).
• ಪುಲ್ ವಿನಂತಿಗಳ ಮೂಲಕ ರಾಜ್ಯ ಬದಲಾವಣೆಗಳನ್ನು ಮಾಡಲಾಗುತ್ತದೆ.
• Git ಪುಶ್ ವಿನಂತಿಗಳನ್ನು ಬಳಸಿಕೊಂಡು ರೆಪೊಸಿಟರಿಯಲ್ಲಿರುವ ಡೇಟಾದೊಂದಿಗೆ ಚಾಲನೆಯಲ್ಲಿರುವ ಸಿಸ್ಟಮ್‌ಗಳ ಸ್ಥಿತಿಯನ್ನು ತರಲಾಗುತ್ತದೆ.

GitOps ತತ್ವಗಳು

• ಸಿಸ್ಟಮ್ ವ್ಯಾಖ್ಯಾನಗಳನ್ನು ಮೂಲ ಕೋಡ್ ಎಂದು ವಿವರಿಸಲಾಗಿದೆ

ಸಿಸ್ಟಮ್ಸ್ ಕಾನ್ಫಿಗರೇಶನ್ ಅನ್ನು ಕೋಡ್ ಎಂದು ಪರಿಗಣಿಸಲಾಗುತ್ತದೆ ಆದ್ದರಿಂದ ಇದನ್ನು Git ರೆಪೊಸಿಟರಿಯಲ್ಲಿ ಸಂಗ್ರಹಿಸಬಹುದು ಮತ್ತು ಸ್ವಯಂಚಾಲಿತವಾಗಿ ಆವೃತ್ತಿ ಮಾಡಬಹುದು, ಇದು ಸತ್ಯದ ಏಕೈಕ ಮೂಲವಾಗಿ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತದೆ. ಈ ವಿಧಾನವು ಸಿಸ್ಟಂಗಳಲ್ಲಿ ರೋಲ್‌ಔಟ್ ಮತ್ತು ರೋಲ್‌ಬ್ಯಾಕ್ ಬದಲಾವಣೆಗಳನ್ನು ಸುಲಭಗೊಳಿಸುತ್ತದೆ.

• ಸಿಸ್ಟಮ್‌ಗಳ ಅಪೇಕ್ಷಿತ ಸ್ಥಿತಿ ಮತ್ತು ಸಂರಚನೆಯನ್ನು Git ನಲ್ಲಿ ಹೊಂದಿಸಲಾಗಿದೆ ಮತ್ತು ಆವೃತ್ತಿ ಮಾಡಲಾಗಿದೆ

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

• ಪುಲ್ ವಿನಂತಿಗಳ ಮೂಲಕ ಕಾನ್ಫಿಗರೇಶನ್ ಬದಲಾವಣೆಗಳನ್ನು ಸ್ವಯಂಚಾಲಿತವಾಗಿ ಅನ್ವಯಿಸಬಹುದು

Git ಪುಲ್ ವಿನಂತಿಗಳನ್ನು ಬಳಸಿಕೊಂಡು, ರೆಪೊಸಿಟರಿಯಲ್ಲಿನ ಕಾನ್ಫಿಗರೇಶನ್‌ಗಳಿಗೆ ಹೇಗೆ ಬದಲಾವಣೆಗಳನ್ನು ಅನ್ವಯಿಸಲಾಗುತ್ತದೆ ಎಂಬುದನ್ನು ನಾವು ಸುಲಭವಾಗಿ ನಿಯಂತ್ರಿಸಬಹುದು. ಉದಾಹರಣೆಗೆ, ಅವುಗಳನ್ನು ವಿಮರ್ಶೆಗಾಗಿ ಇತರ ತಂಡದ ಸದಸ್ಯರಿಗೆ ನೀಡಬಹುದು ಅಥವಾ CI ಪರೀಕ್ಷೆಗಳ ಮೂಲಕ ಚಲಾಯಿಸಬಹುದು, ಇತ್ಯಾದಿ.

ಮತ್ತು ಅದೇ ಸಮಯದಲ್ಲಿ, ನಿರ್ವಾಹಕ ಅಧಿಕಾರವನ್ನು ಎಡ ಮತ್ತು ಬಲಕ್ಕೆ ವಿತರಿಸಲು ಅಗತ್ಯವಿಲ್ಲ. ಕಾನ್ಫಿಗರೇಶನ್ ಬದಲಾವಣೆಗಳನ್ನು ಮಾಡಲು, ಬಳಕೆದಾರರಿಗೆ ಆ ಕಾನ್ಫಿಗರೇಶನ್‌ಗಳನ್ನು ಸಂಗ್ರಹಿಸಲಾಗಿರುವ Git ರೆಪೊಸಿಟರಿಯಲ್ಲಿ ಮಾತ್ರ ಸೂಕ್ತವಾದ ಅನುಮತಿಗಳ ಅಗತ್ಯವಿದೆ.

• ಕಾನ್ಫಿಗರೇಶನ್‌ಗಳ ಅನಿಯಂತ್ರಿತ ಡ್ರಿಫ್ಟ್‌ನ ಸಮಸ್ಯೆಯನ್ನು ಸರಿಪಡಿಸುವುದು

ಸಿಸ್ಟಮ್‌ನ ಅಪೇಕ್ಷಿತ ಸ್ಥಿತಿಯನ್ನು ಒಮ್ಮೆ Git ರೆಪೊಸಿಟರಿಯಲ್ಲಿ ಸಂಗ್ರಹಿಸಿದರೆ, ನಾವು ಮಾಡಬೇಕಾಗಿರುವುದು ಸಿಸ್ಟಮ್‌ನ ಪ್ರಸ್ತುತ ಸ್ಥಿತಿಯು ಅದರ ಅಪೇಕ್ಷಿತ ಸ್ಥಿತಿಗೆ ಹೊಂದಿಕೆಯಾಗುತ್ತದೆ ಎಂದು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳುವ ಸಾಫ್ಟ್‌ವೇರ್ ಅನ್ನು ಕಂಡುಹಿಡಿಯುವುದು. ಇದು ಹಾಗಲ್ಲದಿದ್ದರೆ, ಈ ಸಾಫ್ಟ್‌ವೇರ್ - ಸೆಟ್ಟಿಂಗ್‌ಗಳನ್ನು ಅವಲಂಬಿಸಿ - ತನ್ನದೇ ಆದ ವ್ಯತ್ಯಾಸವನ್ನು ನಿವಾರಿಸಬೇಕು ಅಥವಾ ಕಾನ್ಫಿಗರೇಶನ್ ಡ್ರಿಫ್ಟ್ ಬಗ್ಗೆ ನಮಗೆ ಸೂಚಿಸಬೇಕು.

OpenShift ಗಾಗಿ GitOps ಮಾದರಿಗಳು

ಆನ್-ಕ್ಲಸ್ಟರ್ ರಿಸೋರ್ಸ್ ರಿಕಾನ್ಸಿಲರ್

ಈ ಮಾದರಿಯ ಪ್ರಕಾರ, ಕ್ಲಸ್ಟರ್ ನಿಯಂತ್ರಕವನ್ನು ಹೊಂದಿದ್ದು, ಇದು Git ರೆಪೊಸಿಟರಿಯಲ್ಲಿನ ಕುಬರ್ನೆಟ್ಸ್ ಸಂಪನ್ಮೂಲಗಳನ್ನು (YAML ಫೈಲ್‌ಗಳು) ಕ್ಲಸ್ಟರ್‌ನ ನೈಜ ಸಂಪನ್ಮೂಲಗಳೊಂದಿಗೆ ಹೋಲಿಸಲು ಕಾರಣವಾಗಿದೆ. ವ್ಯತ್ಯಾಸಗಳು ಪತ್ತೆಯಾದರೆ, ನಿಯಂತ್ರಕವು ಅಧಿಸೂಚನೆಗಳನ್ನು ಕಳುಹಿಸುತ್ತದೆ ಮತ್ತು ವ್ಯತ್ಯಾಸಗಳನ್ನು ಸರಿಪಡಿಸಲು ಪ್ರಾಯಶಃ ಕ್ರಮ ತೆಗೆದುಕೊಳ್ಳುತ್ತದೆ. ಈ GitOps ಮಾದರಿಯನ್ನು Anthos ಕಾನ್ಫಿಗ್ ಮ್ಯಾನೇಜ್ಮೆಂಟ್ ಮತ್ತು Weaveworks ಫ್ಲಕ್ಸ್ನಲ್ಲಿ ಬಳಸಲಾಗುತ್ತದೆ.

ಬಾಹ್ಯ ಸಂಪನ್ಮೂಲ ಸಮನ್ವಯಕಾರ (ಪುಶ್)

"Git ರೆಪೊಸಿಟರಿ - ಕುಬರ್ನೆಟ್ಸ್ ಕ್ಲಸ್ಟರ್" ಜೋಡಿಗಳಲ್ಲಿ ಸಂಪನ್ಮೂಲಗಳನ್ನು ಸಿಂಕ್ರೊನೈಸ್ ಮಾಡಲು ನಾವು ಒಂದು ಅಥವಾ ಹೆಚ್ಚಿನ ನಿಯಂತ್ರಕಗಳನ್ನು ಹೊಂದಿರುವಾಗ ಈ ಮಾದರಿಯನ್ನು ಹಿಂದಿನದಕ್ಕೆ ಒಂದು ಬದಲಾವಣೆ ಎಂದು ಪರಿಗಣಿಸಬಹುದು. ಇಲ್ಲಿ ವ್ಯತ್ಯಾಸವೆಂದರೆ ಪ್ರತಿಯೊಂದು ನಿರ್ವಹಿಸಲಾದ ಕ್ಲಸ್ಟರ್ ತನ್ನದೇ ಆದ ಪ್ರತ್ಯೇಕ ನಿಯಂತ್ರಕವನ್ನು ಹೊಂದಿರುವುದಿಲ್ಲ. Git - k8s ಕ್ಲಸ್ಟರ್ ಜೋಡಿಗಳನ್ನು ಸಾಮಾನ್ಯವಾಗಿ CRD ಗಳು (ಕಸ್ಟಮ್ ಸಂಪನ್ಮೂಲ ವ್ಯಾಖ್ಯಾನಗಳು) ಎಂದು ವ್ಯಾಖ್ಯಾನಿಸಲಾಗುತ್ತದೆ, ಇದು ನಿಯಂತ್ರಕ ಸಿಂಕ್ರೊನೈಸೇಶನ್ ಅನ್ನು ಹೇಗೆ ನಿರ್ವಹಿಸಬೇಕು ಎಂಬುದನ್ನು ವಿವರಿಸುತ್ತದೆ. ಈ ಮಾದರಿಯೊಳಗೆ, ನಿಯಂತ್ರಕರು CRD ಯಲ್ಲಿ ನಿರ್ದಿಷ್ಟಪಡಿಸಿದ Git ರೆಪೊಸಿಟರಿಯನ್ನು ಕುಬರ್ನೆಟ್ಸ್ ಕ್ಲಸ್ಟರ್ ಸಂಪನ್ಮೂಲಗಳೊಂದಿಗೆ ಹೋಲಿಸುತ್ತಾರೆ, ಇದು CRD ನಲ್ಲಿಯೂ ಸಹ ನಿರ್ದಿಷ್ಟಪಡಿಸಲಾಗಿದೆ ಮತ್ತು ಹೋಲಿಕೆಯ ಫಲಿತಾಂಶಗಳ ಆಧಾರದ ಮೇಲೆ ಸೂಕ್ತ ಕ್ರಮಗಳನ್ನು ನಿರ್ವಹಿಸುತ್ತದೆ. ನಿರ್ದಿಷ್ಟವಾಗಿ, ಈ GitOps ಮಾದರಿಯನ್ನು ArgoCD ನಲ್ಲಿ ಬಳಸಲಾಗುತ್ತದೆ.

OpenShift ವೇದಿಕೆಯಲ್ಲಿ GitOps

ಬಹು-ಕ್ಲಸ್ಟರ್ ಕುಬರ್ನೆಟ್ಸ್ ಮೂಲಸೌಕರ್ಯದ ಆಡಳಿತ

ಕುಬರ್ನೆಟ್ಸ್‌ನ ಹರಡುವಿಕೆ ಮತ್ತು ಬಹು-ಕ್ಲೌಡ್ ತಂತ್ರಗಳು ಮತ್ತು ಎಡ್ಜ್ ಕಂಪ್ಯೂಟಿಂಗ್‌ನ ಹೆಚ್ಚುತ್ತಿರುವ ಜನಪ್ರಿಯತೆಯೊಂದಿಗೆ, ಪ್ರತಿ ಗ್ರಾಹಕನಿಗೆ ಸರಾಸರಿ ಓಪನ್‌ಶಿಫ್ಟ್ ಕ್ಲಸ್ಟರ್‌ಗಳ ಸಂಖ್ಯೆಯೂ ಹೆಚ್ಚುತ್ತಿದೆ.

ಉದಾಹರಣೆಗೆ, ಎಡ್ಜ್ ಕಂಪ್ಯೂಟಿಂಗ್ ಅನ್ನು ಬಳಸುವಾಗ, ಒಬ್ಬ ಗ್ರಾಹಕರ ಕ್ಲಸ್ಟರ್‌ಗಳನ್ನು ನೂರಾರು ಅಥವಾ ಸಾವಿರಾರು ಸಂಖ್ಯೆಯಲ್ಲಿ ನಿಯೋಜಿಸಬಹುದು. ಪರಿಣಾಮವಾಗಿ, ಸಾರ್ವಜನಿಕ ಕ್ಲೌಡ್ ಮತ್ತು ಆನ್-ಪ್ರಿಮೈಸ್‌ನಲ್ಲಿ ಹಲವಾರು ಸ್ವತಂತ್ರ ಅಥವಾ ಸಂಘಟಿತ ಓಪನ್‌ಶಿಫ್ಟ್ ಕ್ಲಸ್ಟರ್‌ಗಳನ್ನು ನಿರ್ವಹಿಸಲು ಅವನು ಬಲವಂತವಾಗಿ.

ಈ ಸಂದರ್ಭದಲ್ಲಿ, ಹಲವಾರು ಸಮಸ್ಯೆಗಳನ್ನು ಪರಿಹರಿಸಬೇಕಾಗಿದೆ, ನಿರ್ದಿಷ್ಟವಾಗಿ:

• ಕ್ಲಸ್ಟರ್‌ಗಳು ಒಂದೇ ಸ್ಥಿತಿಯಲ್ಲಿವೆ ಎಂಬುದನ್ನು ನಿಯಂತ್ರಿಸಿ (ಸಂರಚನೆಗಳು, ಮೇಲ್ವಿಚಾರಣೆ, ಸಂಗ್ರಹಣೆ, ಇತ್ಯಾದಿ)
• ತಿಳಿದಿರುವ ಸ್ಥಿತಿಯನ್ನು ಆಧರಿಸಿ ಕ್ಲಸ್ಟರ್‌ಗಳನ್ನು ಮರುಸೃಷ್ಟಿಸಿ (ಅಥವಾ ಮರುಸ್ಥಾಪಿಸಿ).
• ತಿಳಿದಿರುವ ಸ್ಥಿತಿಯನ್ನು ಆಧರಿಸಿ ಹೊಸ ಕ್ಲಸ್ಟರ್‌ಗಳನ್ನು ರಚಿಸಿ.
• ಬಹು OpenShift ಕ್ಲಸ್ಟರ್‌ಗಳಿಗೆ ಬದಲಾವಣೆಗಳನ್ನು ರೋಲ್ ಮಾಡಿ.
• ಬಹು OpenShift ಕ್ಲಸ್ಟರ್‌ಗಳಾದ್ಯಂತ ಬದಲಾವಣೆಗಳನ್ನು ಹಿಂತಿರುಗಿಸಿ.
• ವಿವಿಧ ಪರಿಸರಗಳಿಗೆ ಟೆಂಪ್ಲೇಟ್ ಮಾಡಿದ ಕಾನ್ಫಿಗರೇಶನ್‌ಗಳನ್ನು ಲಿಂಕ್ ಮಾಡಿ.

ಅಪ್ಲಿಕೇಶನ್ ಕಾನ್ಫಿಗರೇಶನ್‌ಗಳು

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

ಈ ಸಂದರ್ಭದಲ್ಲಿ, ಈ ಕೆಳಗಿನ ಕಾರ್ಯಗಳನ್ನು ಪರಿಹರಿಸಬೇಕು:

• ಕ್ಲಸ್ಟರ್‌ಗಳ (dev, ಹಂತ, ಇತ್ಯಾದಿ) ನಡುವೆ ಅಪ್ಲಿಕೇಶನ್‌ಗಳ ಚಲನೆಯನ್ನು (ಬೈನರಿಗಳು, ಸಂರಚನೆಗಳು, ಇತ್ಯಾದಿ) ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಿ.
• ಹಲವಾರು OpenShift ಕ್ಲಸ್ಟರ್‌ಗಳಲ್ಲಿ ಅಪ್ಲಿಕೇಶನ್‌ಗಳಿಗೆ (ಬೈನರಿಗಳು, ಸಂರಚನೆಗಳು, ಇತ್ಯಾದಿ) ಬದಲಾವಣೆಗಳನ್ನು ರೋಲ್ ಮಾಡಿ.
• ಹಿಂದಿನ ತಿಳಿದಿರುವ ಸ್ಥಿತಿಗೆ ಅಪ್ಲಿಕೇಶನ್‌ಗಳಿಗೆ ಬದಲಾವಣೆಗಳನ್ನು ಹಿಂತಿರುಗಿಸಿ.

OpenShift GitOps ಬಳಕೆಯ ಪ್ರಕರಣಗಳು

1. Git ರೆಪೊಸಿಟರಿಯಿಂದ ಬದಲಾವಣೆಗಳನ್ನು ಅನ್ವಯಿಸಲಾಗುತ್ತಿದೆ

ಕ್ಲಸ್ಟರ್ ನಿರ್ವಾಹಕರು ಓಪನ್‌ಶಿಫ್ಟ್ ಕ್ಲಸ್ಟರ್ ಕಾನ್ಫಿಗರೇಶನ್‌ಗಳನ್ನು Git ರೆಪೊಸಿಟರಿಯಲ್ಲಿ ಸಂಗ್ರಹಿಸಬಹುದು ಮತ್ತು ಹೊಸ ಕ್ಲಸ್ಟರ್‌ಗಳನ್ನು ಸಲೀಸಾಗಿ ರಚಿಸಲು ಮತ್ತು ಅವುಗಳನ್ನು Git ರೆಪೊಸಿಟರಿಯಲ್ಲಿ ಸಂಗ್ರಹವಾಗಿರುವ ತಿಳಿದಿರುವ ಸ್ಥಿತಿಗೆ ತರಲು ಸ್ವಯಂಚಾಲಿತವಾಗಿ ಅನ್ವಯಿಸಬಹುದು.

2. ಸೀಕ್ರೆಟ್ ಮ್ಯಾನೇಜರ್‌ನೊಂದಿಗೆ ಸಿಂಕ್ರೊನೈಸೇಶನ್

ಇದಕ್ಕಾಗಿ ವಿಶೇಷವಾಗಿ ರಚಿಸಲಾದ ಪರಿಕರಗಳನ್ನು ಬಳಸಿಕೊಂಡು ಅವುಗಳನ್ನು ನಿರ್ವಹಿಸಲು ವಾಲ್ಟ್‌ನಂತಹ ಸೂಕ್ತವಾದ ಸಾಫ್ಟ್‌ವೇರ್‌ನೊಂದಿಗೆ OpenShift ರಹಸ್ಯ ವಸ್ತುಗಳನ್ನು ಸಿಂಕ್ರೊನೈಸ್ ಮಾಡುವ ಸಾಮರ್ಥ್ಯದಿಂದ ನಿರ್ವಾಹಕರು ಪ್ರಯೋಜನ ಪಡೆಯುತ್ತಾರೆ.

3. ಡ್ರಿಫ್ಟ್ ಕಾನ್ಫಿಗರೇಶನ್‌ಗಳ ನಿಯಂತ್ರಣ

ನೈಜ ಕಾನ್ಫಿಗರೇಶನ್‌ಗಳು ಮತ್ತು ರೆಪೊಸಿಟರಿಯಲ್ಲಿ ನಿರ್ದಿಷ್ಟಪಡಿಸಿದ ನಡುವಿನ ವ್ಯತ್ಯಾಸಗಳ ಬಗ್ಗೆ OpenShift GitOps ಸ್ವತಃ ಗುರುತಿಸಿದರೆ ಮತ್ತು ಎಚ್ಚರಿಕೆ ನೀಡಿದರೆ ಮಾತ್ರ ನಿರ್ವಾಹಕರು ಪರವಾಗಿರುತ್ತಾರೆ, ಇದರಿಂದಾಗಿ ಅವರು ಡ್ರಿಫ್ಟ್‌ಗೆ ತ್ವರಿತವಾಗಿ ಪ್ರತಿಕ್ರಿಯಿಸಬಹುದು.

4. ಕಾನ್ಫಿಗರೇಶನ್ ಡ್ರಿಫ್ಟ್ ಬಗ್ಗೆ ಅಧಿಸೂಚನೆಗಳು

ನಿರ್ವಾಹಕರು ತಮ್ಮದೇ ಆದ ಸೂಕ್ತ ಕ್ರಮಗಳನ್ನು ತ್ವರಿತವಾಗಿ ತೆಗೆದುಕೊಳ್ಳುವ ಸಲುವಾಗಿ ಕಾನ್ಫಿಗರೇಶನ್ ಡ್ರಿಫ್ಟ್ ಪ್ರಕರಣಗಳ ಬಗ್ಗೆ ತ್ವರಿತವಾಗಿ ತಿಳಿದುಕೊಳ್ಳಲು ಬಯಸಿದಾಗ ಅವು ಉಪಯುಕ್ತವಾಗಿವೆ.

5. ಡ್ರಿಫ್ಟಿಂಗ್ ಮಾಡುವಾಗ ಸಂರಚನೆಗಳ ಹಸ್ತಚಾಲಿತ ಸಿಂಕ್ರೊನೈಸೇಶನ್

ಹಿಂದಿನ ತಿಳಿದಿರುವ ಸ್ಥಿತಿಗೆ ಕ್ಲಸ್ಟರ್ ಅನ್ನು ತ್ವರಿತವಾಗಿ ಹಿಂತಿರುಗಿಸಲು, ಕಾನ್ಫಿಗರೇಶನ್ ಡ್ರಿಫ್ಟ್ ಸಂದರ್ಭದಲ್ಲಿ ಓಪನ್‌ಶಿಫ್ಟ್ ಕ್ಲಸ್ಟರ್ ಅನ್ನು Git ರೆಪೊಸಿಟರಿಯೊಂದಿಗೆ ಸಿಂಕ್ರೊನೈಸ್ ಮಾಡಲು ನಿರ್ವಾಹಕರಿಗೆ ಅನುಮತಿಸುತ್ತದೆ.

6.ಡ್ರಿಫ್ಟಿಂಗ್ ಮಾಡುವಾಗ ಕಾನ್ಫಿಗರೇಶನ್‌ಗಳ ಸ್ವಯಂ-ಸಿಂಕ್ರೊನೈಸೇಶನ್

ಡ್ರಿಫ್ಟ್ ಪತ್ತೆಯಾದಾಗ ರೆಪೊಸಿಟರಿಯೊಂದಿಗೆ ಸ್ವಯಂಚಾಲಿತವಾಗಿ ಸಿಂಕ್ರೊನೈಸ್ ಮಾಡಲು ನಿರ್ವಾಹಕರು OpenShift ಕ್ಲಸ್ಟರ್ ಅನ್ನು ಕಾನ್ಫಿಗರ್ ಮಾಡಬಹುದು, ಇದರಿಂದಾಗಿ ಕ್ಲಸ್ಟರ್ ಕಾನ್ಫಿಗರೇಶನ್ ಯಾವಾಗಲೂ Git ನಲ್ಲಿನ ಸಂರಚನೆಗಳಿಗೆ ಹೊಂದಿಕೆಯಾಗುತ್ತದೆ.

7. ಹಲವಾರು ಕ್ಲಸ್ಟರ್‌ಗಳು - ಒಂದು ರೆಪೊಸಿಟರಿ

ನಿರ್ವಾಹಕರು ಒಂದು Git ರೆಪೊಸಿಟರಿಯಲ್ಲಿ ಹಲವಾರು ವಿಭಿನ್ನ OpenShift ಕ್ಲಸ್ಟರ್‌ಗಳ ಸಂರಚನೆಗಳನ್ನು ಸಂಗ್ರಹಿಸಬಹುದು ಮತ್ತು ಅಗತ್ಯವಿರುವಂತೆ ಅವುಗಳನ್ನು ಆಯ್ಕೆ ಮಾಡಬಹುದು.

8. ಕ್ಲಸ್ಟರ್ ಕಾನ್ಫಿಗರೇಶನ್‌ಗಳ ಕ್ರಮಾನುಗತ (ಆನುವಂಶಿಕತೆ)

ನಿರ್ವಾಹಕರು ರೆಪೊಸಿಟರಿಯಲ್ಲಿ ಕ್ಲಸ್ಟರ್ ಕಾನ್ಫಿಗರೇಶನ್‌ಗಳ ಕ್ರಮಾನುಗತವನ್ನು ಹೊಂದಿಸಬಹುದು (ಹಂತ, ಪ್ರಾಡ್, ಅಪ್ಲಿಕೇಶನ್ ಪೋರ್ಟ್‌ಫೋಲಿಯೊ, ಇತ್ಯಾದಿ. ಉತ್ತರಾಧಿಕಾರದೊಂದಿಗೆ). ಬೇರೆ ರೀತಿಯಲ್ಲಿ ಹೇಳುವುದಾದರೆ, ಒಂದು ಅಥವಾ ಹೆಚ್ಚಿನ ಕ್ಲಸ್ಟರ್‌ಗಳಿಗೆ ಕಾನ್ಫಿಗರೇಶನ್‌ಗಳನ್ನು ಅನ್ವಯಿಸಬೇಕೆ ಎಂದು ನಿರ್ಧರಿಸಬಹುದು.

ಉದಾಹರಣೆಗೆ, ನಿರ್ವಾಹಕರು Git ರೆಪೊಸಿಟರಿಯಲ್ಲಿ "ಪ್ರೊಡಕ್ಷನ್ ಕ್ಲಸ್ಟರ್‌ಗಳು (ಉತ್ಪನ್ನ) → ಸಿಸ್ಟಮ್ ಎಕ್ಸ್ ಕ್ಲಸ್ಟರ್‌ಗಳು → ಪ್ರೊಡಕ್ಷನ್ ಕ್ಲಸ್ಟರ್‌ಗಳು ಸಿಸ್ಟಮ್ ಎಕ್ಸ್" ಅನ್ನು ಹೊಂದಿಸಿದರೆ, ಈ ಕೆಳಗಿನ ಕಾನ್ಫಿಗರ್‌ಗಳ ಸಂಯೋಜನೆಯನ್ನು ಸಿಸ್ಟಮ್ ಎಕ್ಸ್‌ನ ಉತ್ಪಾದನಾ ಕ್ಲಸ್ಟರ್‌ಗಳಿಗೆ ಅನ್ವಯಿಸಲಾಗುತ್ತದೆ:

• ಎಲ್ಲಾ ಉತ್ಪಾದನಾ ಕ್ಲಸ್ಟರ್‌ಗಳಿಗೆ ಸಾಮಾನ್ಯವಾದ ಸಂರಚನೆಗಳು.
• ಸಿಸ್ಟಮ್ X ಕ್ಲಸ್ಟರ್‌ಗಾಗಿ ಸಂರಚನೆಗಳು.
• X ಸಿಸ್ಟಮ್ ಪ್ರೊಡಕ್ಷನ್ ಕ್ಲಸ್ಟರ್‌ಗಾಗಿ ಸಂರಚನೆಗಳು.

9. ಟೆಂಪ್ಲೇಟ್‌ಗಳು ಮತ್ತು ಕಾನ್ಫಿಗರೇಶನ್ ಅತಿಕ್ರಮಿಸುತ್ತದೆ

ನಿರ್ವಾಹಕರು ಅನುವಂಶಿಕವಾಗಿ ಪಡೆದ ಸಂರಚನೆಗಳನ್ನು ಮತ್ತು ಅವುಗಳ ಮೌಲ್ಯಗಳನ್ನು ಅತಿಕ್ರಮಿಸಬಹುದು, ಉದಾಹರಣೆಗೆ, ನಿರ್ದಿಷ್ಟ ಕ್ಲಸ್ಟರ್‌ಗಳಿಗೆ ಅವುಗಳನ್ನು ಅನ್ವಯಿಸುವ ಸಂರಚನೆಯನ್ನು ಉತ್ತಮಗೊಳಿಸಲು.

10. ಕಾನ್ಫಿಗರೇಶನ್‌ಗಳು, ಅಪ್ಲಿಕೇಶನ್ ಕಾನ್ಫಿಗರೇಶನ್‌ಗಳಿಗಾಗಿ ಆಯ್ದ ಸೇರಿವೆ ಮತ್ತು ಹೊರಗಿಡಿ

ನಿರ್ವಾಹಕರು ಕೆಲವು ಗುಣಲಕ್ಷಣಗಳೊಂದಿಗೆ ಕ್ಲಸ್ಟರ್‌ಗಳಿಗೆ ಕೆಲವು ಕಾನ್ಫಿಗರೇಶನ್‌ಗಳ ಅಪ್ಲಿಕೇಶನ್ ಅಥವಾ ಅನ್ವಯಿಸದಿರುವ ಷರತ್ತುಗಳನ್ನು ಹೊಂದಿಸಬಹುದು.

11. ಟೆಂಪ್ಲೇಟ್ ಬೆಂಬಲ

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

OpenShift ವೇದಿಕೆಯಲ್ಲಿ GitOps ಪರಿಕರಗಳು

ಆರ್ಗೋಸಿಡಿ

ArgoCD ಬಾಹ್ಯ ಸಂಪನ್ಮೂಲ ಸಮನ್ವಯ ಮಾದರಿಯನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸುತ್ತದೆ ಮತ್ತು ಕ್ಲಸ್ಟರ್‌ಗಳು ಮತ್ತು Git ರೆಪೊಸಿಟರಿಗಳ ನಡುವೆ ಒಂದರಿಂದ ಹಲವು ಸಂಬಂಧಗಳನ್ನು ಸಂಘಟಿಸಲು ಕೇಂದ್ರೀಕೃತ UI ಅನ್ನು ನೀಡುತ್ತದೆ. ಈ ಕಾರ್ಯಕ್ರಮದ ಅನಾನುಕೂಲಗಳು ArgoCD ಕಾರ್ಯನಿರ್ವಹಿಸದಿದ್ದಾಗ ಅಪ್ಲಿಕೇಶನ್‌ಗಳನ್ನು ನಿರ್ವಹಿಸಲು ಅಸಮರ್ಥತೆಯನ್ನು ಒಳಗೊಂಡಿವೆ.

ಅಧಿಕೃತ ವೆಬ್ಸೈಟ್

ಹರಿಯುವಂತೆ

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

ಅಧಿಕೃತ ವೆಬ್ಸೈಟ್

OpenShift ನಲ್ಲಿ ArgoCD ಅನ್ನು ಸ್ಥಾಪಿಸಲಾಗುತ್ತಿದೆ

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

OpenShift 4 ಪ್ಲಾಟ್‌ಫಾರ್ಮ್‌ನಲ್ಲಿ ArgoCD ಅನ್ನು ನಿಯೋಜಿಸಲು, ಕ್ಲಸ್ಟರ್ ನಿರ್ವಾಹಕರಾಗಿ ಈ ಹಂತಗಳನ್ನು ಅನುಸರಿಸಿ:

OpenShift ಪ್ಲಾಟ್‌ಫಾರ್ಮ್‌ನಲ್ಲಿ ArgoCD ಘಟಕಗಳನ್ನು ನಿಯೋಜಿಸಲಾಗುತ್ತಿದೆ

# Create a new namespace for ArgoCD components
oc create namespace argocd
# Apply the ArgoCD Install Manifest
oc -n argocd apply -f https://raw.githubusercontent.com/argoproj/argo-cd/v1.2.2/manifests/install.yaml
# Get the ArgoCD Server password
ARGOCD_SERVER_PASSWORD=$(oc -n argocd get pod -l "app.kubernetes.io/name=argocd-server" -o jsonpath='{.items[*].metadata.name}')

ಆರ್ಗೋಸಿಡಿ ಸರ್ವರ್‌ನ ಸುಧಾರಣೆ ಇದರಿಂದ ಓಪನ್‌ಶಿಫ್ಟ್ ಮಾರ್ಗದಿಂದ ನೋಡಬಹುದಾಗಿದೆ

# Patch ArgoCD Server so no TLS is configured on the server (--insecure)
PATCH='{"spec":{"template":{"spec":{"$setElementOrder/containers":[{"name":"argocd-server"}],"containers":[{"command":["argocd-server","--insecure","--staticassets","/shared/app"],"name":"argocd-server"}]}}}}'
oc -n argocd patch deployment argocd-server -p $PATCH
# Expose the ArgoCD Server using an Edge OpenShift Route so TLS is used for incoming connections
oc -n argocd create route edge argocd-server --service=argocd-server --port=http --insecure-policy=Redirect

ArgoCD Cli ಉಪಕರಣವನ್ನು ನಿಯೋಜಿಸಲಾಗುತ್ತಿದೆ

# Download the argocd binary, place it under /usr/local/bin and give it execution permissions
curl -L https://github.com/argoproj/argo-cd/releases/download/v1.2.2/argocd-linux-amd64 -o /usr/local/bin/argocd
chmod +x /usr/local/bin/argocd

ArgoCD ಸರ್ವರ್ ನಿರ್ವಾಹಕ ಗುಪ್ತಪದವನ್ನು ಬದಲಾಯಿಸಲಾಗುತ್ತಿದೆ

# Get ArgoCD Server Route Hostname
ARGOCD_ROUTE=$(oc -n argocd get route argocd-server -o jsonpath='{.spec.host}')
# Login with the current admin password
argocd --insecure --grpc-web login ${ARGOCD_ROUTE}:443 --username admin --password ${ARGOCD_SERVER_PASSWORD}
# Update admin's password
argocd --insecure --grpc-web --server ${ARGOCD_ROUTE}:443 account update-password --current-password ${ARGOCD_SERVER_PASSWORD} --new-password

ಈ ಹಂತಗಳನ್ನು ಪೂರ್ಣಗೊಳಿಸಿದ ನಂತರ, ನೀವು ArgoCD WebUI ವೆಬ್ ಕನ್ಸೋಲ್ ಅಥವಾ ArgoCD Cli ಕಮಾಂಡ್ ಲೈನ್ ಟೂಲ್ ಮೂಲಕ ArgoCD ಸರ್ವರ್‌ನೊಂದಿಗೆ ಕೆಲಸ ಮಾಡಬಹುದು.
https://blog.openshift.com/is-it-too-late-to-integrate-gitops/

GitOps - ಇದು ಎಂದಿಗೂ ತಡವಾಗಿಲ್ಲ

"ರೈಲು ಹೊರಟಿದೆ" - ಏನನ್ನಾದರೂ ಮಾಡುವ ಅವಕಾಶ ತಪ್ಪಿಹೋದಾಗ ಅವರು ಪರಿಸ್ಥಿತಿಯ ಬಗ್ಗೆ ಹೀಗೆ ಹೇಳುತ್ತಾರೆ. ಓಪನ್‌ಶಿಫ್ಟ್‌ನ ಸಂದರ್ಭದಲ್ಲಿ, ಈ ತಂಪಾದ ಹೊಸ ಪ್ಲಾಟ್‌ಫಾರ್ಮ್ ಅನ್ನು ತಕ್ಷಣವೇ ಬಳಸಲು ಪ್ರಾರಂಭಿಸುವ ಬಯಕೆಯು ಮಾರ್ಗಗಳು, ನಿಯೋಜನೆಗಳು ಮತ್ತು ಇತರ ಓಪನ್‌ಶಿಫ್ಟ್ ವಸ್ತುಗಳ ನಿರ್ವಹಣೆ ಮತ್ತು ನಿರ್ವಹಣೆಯೊಂದಿಗೆ ನಿಖರವಾಗಿ ಈ ಪರಿಸ್ಥಿತಿಯನ್ನು ಸೃಷ್ಟಿಸುತ್ತದೆ. ಆದರೆ ಅವಕಾಶ ಯಾವಾಗಲೂ ಸಂಪೂರ್ಣವಾಗಿ ಕಳೆದುಹೋಗಿದೆಯೇ?

ಬಗ್ಗೆ ಲೇಖನಗಳ ಸರಣಿಯನ್ನು ಮುಂದುವರಿಸುವುದು GitOps, ಇಂದು ನಾವು ಕರಕುಶಲ ಅಪ್ಲಿಕೇಶನ್ ಮತ್ತು ಅದರ ಸಂಪನ್ಮೂಲಗಳನ್ನು GitOps ಪರಿಕರಗಳಿಂದ ನಿರ್ವಹಿಸುವ ಪ್ರಕ್ರಿಯೆಯಾಗಿ ಹೇಗೆ ಮಾರ್ಪಡಿಸುವುದು ಎಂದು ನಿಮಗೆ ತೋರಿಸುತ್ತೇವೆ. ಇದನ್ನು ಮಾಡಲು, ನಾವು ಮೊದಲು httpd ಅಪ್ಲಿಕೇಶನ್ ಅನ್ನು ಹಸ್ತಚಾಲಿತವಾಗಿ ನಿಯೋಜಿಸುತ್ತೇವೆ. ಕೆಳಗಿನ ಸ್ಕ್ರೀನ್‌ಶಾಟ್ ನಾವು ನೇಮ್‌ಸ್ಪೇಸ್, ​​ನಿಯೋಜನೆ ಮತ್ತು ಸೇವೆಯನ್ನು ಹೇಗೆ ರಚಿಸುತ್ತೇವೆ ಎಂಬುದನ್ನು ತೋರಿಸುತ್ತದೆ ಮತ್ತು ನಂತರ ಮಾರ್ಗವನ್ನು ರಚಿಸಲು ಈ ಸೇವೆಯನ್ನು ಬಹಿರಂಗಪಡಿಸುತ್ತೇವೆ.

oc create -f https://raw.githubusercontent.com/openshift/federation-dev/master/labs/lab-4-assets/namespace.yaml
oc create -f https://raw.githubusercontent.com/openshift/federation-dev/master/labs/lab-4-assets/deployment.yaml
oc create -f https://raw.githubusercontent.com/openshift/federation-dev/master/labs/lab-4-assets/service.yaml
oc expose svc/httpd -n simple-app

ಆದ್ದರಿಂದ ನಾವು ಕರಕುಶಲ ಅಪ್ಲಿಕೇಶನ್ ಅನ್ನು ಹೊಂದಿದ್ದೇವೆ. ಈಗ ಅದನ್ನು ಲಭ್ಯತೆಯ ನಷ್ಟವಿಲ್ಲದೆಯೇ GitOps ನಿರ್ವಹಣೆಯ ಅಡಿಯಲ್ಲಿ ವರ್ಗಾಯಿಸಬೇಕಾಗಿದೆ. ಸಂಕ್ಷಿಪ್ತವಾಗಿ, ಇದು ಹೀಗೆ ಮಾಡುತ್ತದೆ:

• ಕೋಡ್‌ಗಾಗಿ Git ರೆಪೊಸಿಟರಿಯನ್ನು ರಚಿಸಿ.
• ನಾವು ನಮ್ಮ ಪ್ರಸ್ತುತ ವಸ್ತುಗಳನ್ನು ರಫ್ತು ಮಾಡುತ್ತೇವೆ ಮತ್ತು ಅವುಗಳನ್ನು Git ರೆಪೊಸಿಟರಿಗೆ ಅಪ್‌ಲೋಡ್ ಮಾಡುತ್ತೇವೆ.
• GitOps ಪರಿಕರಗಳನ್ನು ಆಯ್ಕೆ ಮಾಡುವುದು ಮತ್ತು ನಿಯೋಜಿಸುವುದು.
• ನಾವು ಈ ಟೂಲ್‌ಕಿಟ್‌ಗೆ ನಮ್ಮ ರೆಪೊಸಿಟರಿಯನ್ನು ಸೇರಿಸುತ್ತೇವೆ.
• ನಮ್ಮ GitOps ಟೂಲ್‌ಕಿಟ್‌ನಲ್ಲಿ ನಾವು ಅಪ್ಲಿಕೇಶನ್ ಅನ್ನು ವ್ಯಾಖ್ಯಾನಿಸುತ್ತೇವೆ.
• ನಾವು GitOps ಟೂಲ್‌ಕಿಟ್ ಅನ್ನು ಬಳಸಿಕೊಂಡು ಅಪ್ಲಿಕೇಶನ್‌ನ ಪರೀಕ್ಷಾ ರನ್ ಅನ್ನು ನಿರ್ವಹಿಸುತ್ತೇವೆ.
• ನಾವು GitOps ಟೂಲ್ಕಿಟ್ ಅನ್ನು ಬಳಸಿಕೊಂಡು ವಸ್ತುಗಳನ್ನು ಸಿಂಕ್ರೊನೈಸ್ ಮಾಡುತ್ತೇವೆ.
• ವಸ್ತುಗಳ ಸಮರುವಿಕೆಯನ್ನು ಮತ್ತು ಸ್ವಯಂ ಸಿಂಕ್ರೊನೈಸೇಶನ್ ಅನ್ನು ಸಕ್ರಿಯಗೊಳಿಸಿ.

ಹಿಂದೆ ಹೇಳಿದಂತೆ ಲೇಖನ, GitOps ನಲ್ಲಿ ಕುಬರ್ನೆಟ್ಸ್ ಕ್ಲಸ್ಟರ್ (ಗಳು) - Git ರೆಪೊಸಿಟರಿಯಲ್ಲಿನ ಎಲ್ಲಾ ವಸ್ತುಗಳ ಬಗ್ಗೆ ಮಾಹಿತಿಯ ಒಂದೇ ಒಂದು ಮೂಲವಿದೆ. ಮುಂದೆ, ನಿಮ್ಮ ಸಂಸ್ಥೆಯು ಈಗಾಗಲೇ Git ರೆಪೊಸಿಟರಿಯನ್ನು ಬಳಸುತ್ತಿದೆ ಎಂಬ ಪ್ರಮೇಯದಿಂದ ನಾವು ಮುಂದುವರಿಯುತ್ತೇವೆ. ಇದು ಸಾರ್ವಜನಿಕ ಅಥವಾ ಖಾಸಗಿಯಾಗಿರಬಹುದು, ಆದರೆ ಇದು ಕುಬರ್ನೆಟ್ಸ್ ಕ್ಲಸ್ಟರ್‌ಗಳಿಗೆ ಪ್ರವೇಶಿಸಬಹುದು. ಇದು ಅಪ್ಲಿಕೇಶನ್ ಕೋಡ್‌ಗಾಗಿ ಅದೇ ರೆಪೊಸಿಟರಿಯಾಗಿರಬಹುದು ಅಥವಾ ನಿಯೋಜನೆಗಳಿಗಾಗಿ ವಿಶೇಷವಾಗಿ ರಚಿಸಲಾದ ಪ್ರತ್ಯೇಕ ರೆಪೊಸಿಟರಿಯಾಗಿರಬಹುದು. ರೆಪೊಸಿಟರಿಯಲ್ಲಿ ಕಟ್ಟುನಿಟ್ಟಾದ ಅನುಮತಿಗಳನ್ನು ಹೊಂದಲು ಶಿಫಾರಸು ಮಾಡಲಾಗಿದೆ ಏಕೆಂದರೆ ರಹಸ್ಯಗಳು, ಮಾರ್ಗಗಳು ಮತ್ತು ಇತರ ಭದ್ರತಾ-ಸೂಕ್ಷ್ಮ ವಿಷಯಗಳನ್ನು ಅಲ್ಲಿ ಸಂಗ್ರಹಿಸಲಾಗುತ್ತದೆ.

ನಮ್ಮ ಉದಾಹರಣೆಯಲ್ಲಿ, ನಾವು GitHub ನಲ್ಲಿ ಹೊಸ ಸಾರ್ವಜನಿಕ ರೆಪೊಸಿಟರಿಯನ್ನು ರಚಿಸುತ್ತೇವೆ. ನೀವು ಇಷ್ಟಪಡುವದನ್ನು ನೀವು ಕರೆಯಬಹುದು, ನಾವು ಬ್ಲಾಗ್‌ಪೋಸ್ಟ್ ಹೆಸರನ್ನು ಬಳಸುತ್ತೇವೆ.

YAML ಆಬ್ಜೆಕ್ಟ್ ಫೈಲ್‌ಗಳನ್ನು ಸ್ಥಳೀಯವಾಗಿ ಅಥವಾ Git ನಲ್ಲಿ ಸಂಗ್ರಹಿಸದಿದ್ದರೆ, ನೀವು oc ಅಥವಾ kubectl ಬೈನರಿಗಳನ್ನು ಬಳಸಬೇಕಾಗುತ್ತದೆ. ಕೆಳಗಿನ ಸ್ಕ್ರೀನ್‌ಶಾಟ್‌ನಲ್ಲಿ ನಾವು ನಮ್ಮ ನೇಮ್‌ಸ್ಪೇಸ್, ​​ನಿಯೋಜನೆ, ಸೇವೆ ಮತ್ತು ಮಾರ್ಗಕ್ಕಾಗಿ YAML ಅನ್ನು ವಿನಂತಿಸುತ್ತಿದ್ದೇವೆ. ಇದಕ್ಕೂ ಮೊದಲು, ನಾವು ಹೊಸದಾಗಿ ರಚಿಸಲಾದ ರೆಪೊಸಿಟರಿ ಮತ್ತು ಸಿಡಿಯನ್ನು ಕ್ಲೋನ್ ಮಾಡಿದ್ದೇವೆ.

oc get namespace simple-app -o yaml --export > namespace.yaml
oc get deployment httpd -o yaml -n simple-app --export > deployment.yaml
oc get service httpd -o yaml -n simple-app --export > service.yaml
oc get route httpd -o yaml -n simple-app --export > route.yaml

ಈಗ Argo CD ಸಿಂಕ್ ಮಾಡಲಾಗದ ಕ್ಷೇತ್ರವನ್ನು ತೆಗೆದುಹಾಕಲು deployment.yaml ಫೈಲ್ ಅನ್ನು ಸಂಪಾದಿಸೋಣ.

sed -i '/sgeneration: .*/d' deployment.yaml

ಜತೆಗೆ ಮಾರ್ಗ ಬದಲಾವಣೆ ಮಾಡಬೇಕಿದೆ. ನಾವು ಮೊದಲು ಮಲ್ಟಿಲೈನ್ ವೇರಿಯೇಬಲ್ ಅನ್ನು ಹೊಂದಿಸುತ್ತೇವೆ ಮತ್ತು ನಂತರ ಪ್ರವೇಶವನ್ನು ಬದಲಾಯಿಸುತ್ತೇವೆ: ಆ ವೇರಿಯಬಲ್‌ನ ವಿಷಯಗಳೊಂದಿಗೆ ಶೂನ್ಯ.

export ROUTE="  ingress:                                                            
    - conditions:
        - status: 'True'
          type: Admitted"

sed -i "s/  ingress: null/$ROUTE/g" route.yaml

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

git commit -am ‘initial commit of objects’
git push origin master

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

argocd repo add https://github.com/cooktheryan/blogpost

ಈಗ ಅಪ್ಲಿಕೇಶನ್ ಅನ್ನು ರಚಿಸೋಣ. ಅಪ್ಲಿಕೇಶನ್ ಮೌಲ್ಯಗಳನ್ನು ಹೊಂದಿಸುತ್ತದೆ ಇದರಿಂದ GitOps ಟೂಲ್‌ಕಿಟ್ ಯಾವ ರೆಪೊಸಿಟರಿ ಮತ್ತು ಮಾರ್ಗಗಳನ್ನು ಬಳಸಬೇಕು, ಆಬ್ಜೆಕ್ಟ್‌ಗಳನ್ನು ನಿರ್ವಹಿಸಲು ಯಾವ OpenShift ಅಗತ್ಯವಿದೆ, ರೆಪೊಸಿಟರಿಯ ನಿರ್ದಿಷ್ಟ ಶಾಖೆ ಅಗತ್ಯವಿದೆಯೇ ಮತ್ತು ಸಂಪನ್ಮೂಲಗಳು ಸ್ವಯಂ-ಸಿಂಕ್ ಮಾಡಬೇಕೇ ಎಂಬುದನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳುತ್ತದೆ.

argocd app create --project default 
--name simple-app --repo https://github.com/cooktheryan/blogpost.git 
--path . --dest-server https://kubernetes.default.svc 
--dest-namespace simple-app --revision master --sync-policy none

ಅರ್ಗೋ ಸಿಡಿಯಲ್ಲಿ ಅಪ್ಲಿಕೇಶನ್ ಅನ್ನು ನಿರ್ದಿಷ್ಟಪಡಿಸಿದ ನಂತರ, ಟೂಲ್‌ಕಿಟ್ ರೆಪೊಸಿಟರಿಯಲ್ಲಿನ ವ್ಯಾಖ್ಯಾನಗಳ ವಿರುದ್ಧ ಈಗಾಗಲೇ ನಿಯೋಜಿಸಲಾದ ವಸ್ತುಗಳನ್ನು ಪರಿಶೀಲಿಸಲು ಪ್ರಾರಂಭಿಸುತ್ತದೆ. ನಮ್ಮ ಉದಾಹರಣೆಯಲ್ಲಿ, ಸ್ವಯಂ-ಸಿಂಕ್ ಮತ್ತು ಕ್ಲೀನಪ್ ಅನ್ನು ನಿಷ್ಕ್ರಿಯಗೊಳಿಸಲಾಗಿದೆ, ಆದ್ದರಿಂದ ಅಂಶಗಳು ಇನ್ನೂ ಬದಲಾಗುವುದಿಲ್ಲ. Argo CD ಇಂಟರ್ಫೇಸ್ನಲ್ಲಿ ನಮ್ಮ ಅಪ್ಲಿಕೇಶನ್ "ಸಿಂಕ್ನಿಂದ ಹೊರಗಿದೆ" ಸ್ಥಿತಿಯನ್ನು ಹೊಂದಿರುತ್ತದೆ ಎಂಬುದನ್ನು ದಯವಿಟ್ಟು ಗಮನಿಸಿ ಏಕೆಂದರೆ ArgoCD ಒದಗಿಸುವ ಯಾವುದೇ ಲೇಬಲ್ ಇಲ್ಲ.
ಅದಕ್ಕಾಗಿಯೇ ನಾವು ಸ್ವಲ್ಪ ಸಮಯದ ನಂತರ ಸಿಂಕ್ರೊನೈಸೇಶನ್ ಅನ್ನು ಪ್ರಾರಂಭಿಸಿದಾಗ, ವಸ್ತುಗಳನ್ನು ಮರುಹಂಚಿಕೆ ಮಾಡಲಾಗುವುದಿಲ್ಲ.

ಈಗ ನಮ್ಮ ಫೈಲ್‌ಗಳಲ್ಲಿ ಯಾವುದೇ ದೋಷಗಳಿಲ್ಲ ಎಂದು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಲು ಟೆಸ್ಟ್ ರನ್ ಮಾಡೋಣ.

argocd app sync simple-app --dry-run

ಯಾವುದೇ ದೋಷಗಳಿಲ್ಲದಿದ್ದರೆ, ನೀವು ಸಿಂಕ್ರೊನೈಸೇಶನ್ಗೆ ಮುಂದುವರಿಯಬಹುದು.

argocd app sync simple-app

ನಮ್ಮ ಅಪ್ಲಿಕೇಶನ್‌ನಲ್ಲಿ argocd get ಆಜ್ಞೆಯನ್ನು ಚಲಾಯಿಸಿದ ನಂತರ, ಅಪ್ಲಿಕೇಶನ್ ಸ್ಥಿತಿಯನ್ನು ಆರೋಗ್ಯಕರ ಅಥವಾ ಸಿಂಕ್ ಮಾಡಲಾಗಿದೆ ಎಂದು ನಾವು ನೋಡಬೇಕು. ಇದರರ್ಥ Git ರೆಪೊಸಿಟರಿಯಲ್ಲಿರುವ ಎಲ್ಲಾ ಸಂಪನ್ಮೂಲಗಳು ಈಗಾಗಲೇ ನಿಯೋಜಿಸಲಾದ ಸಂಪನ್ಮೂಲಗಳಿಗೆ ಸಂಬಂಧಿಸಿವೆ.

argocd app get simple-app
Name:               simple-app
Project:            default
Server:             https://kubernetes.default.svc
Namespace:          simple-app
URL:                https://argocd-server-route-argocd.apps.example.com/applications/simple-app
Repo:               https://github.com/cooktheryan/blogpost.git
Target:             master
Path:               .
Sync Policy:        <none>
Sync Status:        Synced to master (60e1678)
Health Status:      Healthy
...   

ಹಸ್ತಚಾಲಿತವಾಗಿ ಏನನ್ನೂ ರಚಿಸಲಾಗಿಲ್ಲ ಮತ್ತು ಪ್ರತಿ ಬಾರಿ ಆಬ್ಜೆಕ್ಟ್ ಅನ್ನು ರಚಿಸಿದಾಗ ಅಥವಾ ರೆಪೊಸಿಟರಿಗೆ ನವೀಕರಿಸಿದಾಗ, ನಿಯೋಜನೆಯು ಸಂಭವಿಸುತ್ತದೆ ಎಂದು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಲು ಈಗ ನೀವು ಸ್ವಯಂ-ಸಿಂಕ್ ಮತ್ತು ಕ್ಲೀನಪ್ ಅನ್ನು ಸಕ್ರಿಯಗೊಳಿಸಬಹುದು.

argocd app set simple-app --sync-policy automated --auto-prune

ಆದ್ದರಿಂದ, ನಾವು ಆರಂಭದಲ್ಲಿ GitOps ಅನ್ನು ಯಾವುದೇ ರೀತಿಯಲ್ಲಿ ಬಳಸದ GitOps ನಿಯಂತ್ರಣದ ಅಡಿಯಲ್ಲಿ ಅಪ್ಲಿಕೇಶನ್ ಅನ್ನು ಯಶಸ್ವಿಯಾಗಿ ತಂದಿದ್ದೇವೆ.

ಮೂಲ: www.habr.com