🥇ನಾವು ಪ್ಲಗಿನ್‌ಗಳು, SMS ಮತ್ತು ನೋಂದಣಿ ಇಲ್ಲದೆ GKE ನಲ್ಲಿ ನಿಯೋಜನೆಗಾಗಿ ಕಾರ್ಯವನ್ನು ಮಾಡುತ್ತಿದ್ದೇವೆ. ಜೆಂಕಿನ್ಸ್ ಜಾಕೆಟ್ ಕೆಳಗೆ ಇಣುಕಿ ನೋಡೋಣ

ನಮ್ಮ ಡೆವಲಪ್‌ಮೆಂಟ್ ಟೀಮ್‌ಗಳ ಟೀಮ್ ಲೀಡ್ ಅವರ ಹೊಸ ಅಪ್ಲಿಕೇಶನ್ ಅನ್ನು ಪರೀಕ್ಷಿಸಲು ಕೇಳಿದಾಗ ಇದು ಪ್ರಾರಂಭವಾಯಿತು, ಅದನ್ನು ಹಿಂದಿನ ದಿನ ಕಂಟೈನರೈಸ್ ಮಾಡಲಾಗಿದೆ. ನಾನು ಅದನ್ನು ಪೋಸ್ಟ್ ಮಾಡಿದ್ದೇನೆ. ಸುಮಾರು 20 ನಿಮಿಷಗಳ ನಂತರ, ಅಪ್ಲಿಕೇಶನ್ ಅನ್ನು ನವೀಕರಿಸಲು ವಿನಂತಿಯನ್ನು ಸ್ವೀಕರಿಸಲಾಯಿತು, ಏಕೆಂದರೆ ಅಲ್ಲಿ ಬಹಳ ಅಗತ್ಯವಾದ ವಿಷಯವನ್ನು ಸೇರಿಸಲಾಗಿದೆ. ನಾನು ನವೀಕರಿಸಿದೆ. ಇನ್ನೆರಡು ಗಂಟೆಗಳ ನಂತರ... ಸರಿ, ಮುಂದೆ ಏನಾಗಲು ಶುರುವಾಯಿತು ಎಂದು ನೀವು ಊಹಿಸಬಹುದು...

ನಾನು ಒಪ್ಪಿಕೊಳ್ಳಲೇಬೇಕು, ನಾನು ತುಂಬಾ ಸೋಮಾರಿಯಾಗಿದ್ದೇನೆ (ನಾನು ಇದನ್ನು ಮೊದಲೇ ಒಪ್ಪಿಕೊಳ್ಳಲಿಲ್ಲವೇ? ಇಲ್ಲವೇ?), ಮತ್ತು ತಂಡದ ನಾಯಕರಿಗೆ ಜೆಂಕಿನ್ಸ್‌ಗೆ ಪ್ರವೇಶವಿದೆ, ಇದರಲ್ಲಿ ನಾವು ಎಲ್ಲಾ CI/CD ಅನ್ನು ಹೊಂದಿದ್ದೇವೆ, ನಾನು ಯೋಚಿಸಿದೆ: ಅವನನ್ನು ನಿಯೋಜಿಸಲಿ ಅವನು ಬಯಸಿದಷ್ಟು! ನಾನು ಒಂದು ತಮಾಷೆಯನ್ನು ನೆನಪಿಸಿಕೊಂಡೆ: ಒಬ್ಬ ಮನುಷ್ಯನಿಗೆ ಮೀನು ನೀಡಿ ಮತ್ತು ಅವನು ಒಂದು ದಿನ ತಿನ್ನುತ್ತಾನೆ; ಒಬ್ಬ ವ್ಯಕ್ತಿಯನ್ನು ಫೆಡ್ ಎಂದು ಕರೆಯಿರಿ ಮತ್ತು ಅವನ ಜೀವನದುದ್ದಕ್ಕೂ ಅವನಿಗೆ ಆಹಾರವನ್ನು ನೀಡಲಾಗುತ್ತದೆ. ಮತ್ತು ಹೋದರು ಕೆಲಸದಲ್ಲಿ ತಂತ್ರಗಳನ್ನು ಆಡುತ್ತಾರೆ, ಇದು ಕುಬೇರ್‌ಗೆ ಯಾವುದೇ ಯಶಸ್ವಿಯಾಗಿ ನಿರ್ಮಿಸಲಾದ ಆವೃತ್ತಿಯ ಅಪ್ಲಿಕೇಶನ್ ಅನ್ನು ಹೊಂದಿರುವ ಕಂಟೇನರ್ ಅನ್ನು ನಿಯೋಜಿಸಲು ಮತ್ತು ಅದಕ್ಕೆ ಯಾವುದೇ ಮೌಲ್ಯಗಳನ್ನು ವರ್ಗಾಯಿಸಲು ಸಾಧ್ಯವಾಗುತ್ತದೆ ಇಎನ್‌ವಿ (ಹಿಂದೆ ನನ್ನ ಅಜ್ಜ, ಭಾಷಾಶಾಸ್ತ್ರಜ್ಞ, ಇಂಗ್ಲಿಷ್ ಶಿಕ್ಷಕರು, ಈಗ ಅವರ ದೇವಾಲಯದ ಕಡೆಗೆ ಬೆರಳನ್ನು ತಿರುಗಿಸುತ್ತಿದ್ದರು ಮತ್ತು ಈ ವಾಕ್ಯವನ್ನು ಓದಿದ ನಂತರ ನನ್ನನ್ನು ಬಹಳ ಅಭಿವ್ಯಕ್ತವಾಗಿ ನೋಡುತ್ತಿದ್ದರು).

ಆದ್ದರಿಂದ, ಈ ಟಿಪ್ಪಣಿಯಲ್ಲಿ ನಾನು ಹೇಗೆ ಕಲಿತಿದ್ದೇನೆ ಎಂದು ನಾನು ನಿಮಗೆ ಹೇಳುತ್ತೇನೆ:

ಕೆಲಸದಿಂದ ಅಥವಾ ಇತರ ಉದ್ಯೋಗಗಳಿಂದ ಜೆಂಕಿನ್ಸ್‌ನಲ್ಲಿ ಕೆಲಸಗಳನ್ನು ಕ್ರಿಯಾತ್ಮಕವಾಗಿ ನವೀಕರಿಸಿ;
ಸ್ಥಾಪಿಸಲಾದ ಜೆಂಕಿನ್ಸ್ ಏಜೆಂಟ್‌ನೊಂದಿಗೆ ನೋಡ್‌ನಿಂದ ಕ್ಲೌಡ್ ಕನ್ಸೋಲ್‌ಗೆ (ಕ್ಲೌಡ್ ಶೆಲ್) ಸಂಪರ್ಕಪಡಿಸಿ;
Google Kubernetes ಎಂಜಿನ್‌ಗೆ ಕೆಲಸದ ಹೊರೆಯನ್ನು ನಿಯೋಜಿಸಿ.

ವಾಸ್ತವವಾಗಿ, ನಾನು ಸ್ವಲ್ಪಮಟ್ಟಿಗೆ ಅಸಹ್ಯಕರನಾಗಿದ್ದೇನೆ. ನೀವು Google ಕ್ಲೌಡ್‌ನಲ್ಲಿ ಮೂಲಸೌಕರ್ಯದ ಕನಿಷ್ಠ ಭಾಗವನ್ನು ಹೊಂದಿದ್ದೀರಿ ಎಂದು ಭಾವಿಸಲಾಗಿದೆ ಮತ್ತು ಆದ್ದರಿಂದ, ನೀವು ಅದರ ಬಳಕೆದಾರರಾಗಿದ್ದೀರಿ ಮತ್ತು ಸಹಜವಾಗಿ, ನೀವು GCP ಖಾತೆಯನ್ನು ಹೊಂದಿದ್ದೀರಿ. ಆದರೆ ಈ ಟಿಪ್ಪಣಿ ಅದರ ಬಗ್ಗೆ ಅಲ್ಲ.

ಇದು ನನ್ನ ಮುಂದಿನ ಚೀಟ್ ಶೀಟ್. ನಾನು ಅಂತಹ ಟಿಪ್ಪಣಿಗಳನ್ನು ಒಂದು ಸಂದರ್ಭದಲ್ಲಿ ಮಾತ್ರ ಬರೆಯಲು ಬಯಸುತ್ತೇನೆ: ನಾನು ಸಮಸ್ಯೆಯನ್ನು ಎದುರಿಸಿದೆ, ಅದನ್ನು ಹೇಗೆ ಪರಿಹರಿಸಬೇಕೆಂದು ನನಗೆ ಆರಂಭದಲ್ಲಿ ತಿಳಿದಿರಲಿಲ್ಲ, ಪರಿಹಾರವನ್ನು ರೆಡಿಮೇಡ್ ಗೂಗಲ್ ಮಾಡಲಾಗಿಲ್ಲ, ಆದ್ದರಿಂದ ನಾನು ಅದನ್ನು ಭಾಗಗಳಲ್ಲಿ ಗೂಗಲ್ ಮಾಡಿ ಅಂತಿಮವಾಗಿ ಸಮಸ್ಯೆಯನ್ನು ಪರಿಹರಿಸಿದೆ. ಮತ್ತು ಭವಿಷ್ಯದಲ್ಲಿ, ನಾನು ಅದನ್ನು ಹೇಗೆ ಮಾಡಿದ್ದೇನೆ ಎಂಬುದನ್ನು ನಾನು ಮರೆತಾಗ, ನಾನು ಎಲ್ಲವನ್ನೂ ಮತ್ತೆ ತುಂಡು ತುಂಡು ಮಾಡಿ ಮತ್ತು ಒಟ್ಟಿಗೆ ಕಂಪೈಲ್ ಮಾಡಬೇಕಾಗಿಲ್ಲ, ಅಂತಹ ಚೀಟ್ ಶೀಟ್‌ಗಳನ್ನು ನಾನೇ ಬರೆಯುತ್ತೇನೆ.

ಹಕ್ಕುತ್ಯಾಗ: 1. ಟಿಪ್ಪಣಿಯನ್ನು "ನನಗಾಗಿ", ಪಾತ್ರಕ್ಕಾಗಿ ಬರೆಯಲಾಗಿದೆ ಉತ್ತಮ ಅಭ್ಯಾಸ ಅನ್ವಯಿಸುವುದಿಲ್ಲ. ಕಾಮೆಂಟ್‌ಗಳಲ್ಲಿ "ಈ ರೀತಿ ಮಾಡಿದರೆ ಉತ್ತಮ" ಆಯ್ಕೆಗಳನ್ನು ಓದಲು ನನಗೆ ಸಂತೋಷವಾಗಿದೆ.
2. ಟಿಪ್ಪಣಿಯ ಅನ್ವಯಿಕ ಭಾಗವನ್ನು ಉಪ್ಪು ಎಂದು ಪರಿಗಣಿಸಿದರೆ, ನನ್ನ ಹಿಂದಿನ ಎಲ್ಲಾ ಟಿಪ್ಪಣಿಗಳಂತೆ, ಇದು ದುರ್ಬಲ ಉಪ್ಪು ಪರಿಹಾರವಾಗಿದೆ.

ಜೆಂಕಿನ್ಸ್‌ನಲ್ಲಿ ಕೆಲಸದ ಸೆಟ್ಟಿಂಗ್‌ಗಳನ್ನು ಕ್ರಿಯಾತ್ಮಕವಾಗಿ ನವೀಕರಿಸಲಾಗುತ್ತಿದೆ

ನಿಮ್ಮ ಪ್ರಶ್ನೆಯನ್ನು ನಾನು ಮುನ್ಸೂಚಿಸುತ್ತೇನೆ: ಡೈನಾಮಿಕ್ ಕೆಲಸದ ನವೀಕರಣವು ಅದರೊಂದಿಗೆ ಏನು ಮಾಡಬೇಕು? ಸ್ಟ್ರಿಂಗ್ ಪ್ಯಾರಾಮೀಟರ್‌ನ ಮೌಲ್ಯವನ್ನು ಹಸ್ತಚಾಲಿತವಾಗಿ ನಮೂದಿಸಿ ಮತ್ತು ನೀವು ಹೋಗಿ!

ನಾನು ಉತ್ತರಿಸುತ್ತೇನೆ: ನಾನು ನಿಜವಾಗಿಯೂ ಸೋಮಾರಿಯಾಗಿದ್ದೇನೆ, ಅವರು ದೂರು ನೀಡಿದಾಗ ನನಗೆ ಇಷ್ಟವಿಲ್ಲ: ಮಿಶಾ, ನಿಯೋಜನೆಯು ಕ್ರ್ಯಾಶ್ ಆಗುತ್ತಿದೆ, ಎಲ್ಲವೂ ಹೋಗಿದೆ! ನೀವು ನೋಡಲು ಪ್ರಾರಂಭಿಸುತ್ತೀರಿ, ಮತ್ತು ಕೆಲವು ಟಾಸ್ಕ್ ಲಾಂಚ್ ಪ್ಯಾರಾಮೀಟರ್‌ನ ಮೌಲ್ಯದಲ್ಲಿ ಮುದ್ರಣದೋಷವಿದೆ. ಆದ್ದರಿಂದ, ನಾನು ಎಲ್ಲವನ್ನೂ ಸಾಧ್ಯವಾದಷ್ಟು ಪರಿಣಾಮಕಾರಿಯಾಗಿ ಮಾಡಲು ಬಯಸುತ್ತೇನೆ. ಆಯ್ಕೆ ಮಾಡಲು ಮೌಲ್ಯಗಳ ಪಟ್ಟಿಯನ್ನು ನೀಡುವ ಮೂಲಕ ಬಳಕೆದಾರರನ್ನು ನೇರವಾಗಿ ಡೇಟಾವನ್ನು ನಮೂದಿಸುವುದನ್ನು ತಡೆಯಲು ಸಾಧ್ಯವಾದರೆ, ನಾನು ಆಯ್ಕೆಯನ್ನು ಆಯೋಜಿಸುತ್ತೇನೆ.

ಯೋಜನೆ ಹೀಗಿದೆ: ನಾವು ಜೆಂಕಿನ್ಸ್‌ನಲ್ಲಿ ಕೆಲಸವನ್ನು ರಚಿಸುತ್ತೇವೆ, ಇದರಲ್ಲಿ, ಪ್ರಾರಂಭಿಸುವ ಮೊದಲು, ನಾವು ಪಟ್ಟಿಯಿಂದ ಆವೃತ್ತಿಯನ್ನು ಆಯ್ಕೆ ಮಾಡಬಹುದು, ಮೂಲಕ ಕಂಟೇನರ್‌ಗೆ ರವಾನಿಸಲಾದ ನಿಯತಾಂಕಗಳಿಗಾಗಿ ಮೌಲ್ಯಗಳನ್ನು ನಿರ್ದಿಷ್ಟಪಡಿಸಬಹುದು ಇಎನ್‌ವಿ, ನಂತರ ಅದು ಕಂಟೇನರ್ ಅನ್ನು ಸಂಗ್ರಹಿಸುತ್ತದೆ ಮತ್ತು ಅದನ್ನು ಕಂಟೈನರ್ ರಿಜಿಸ್ಟ್ರಿಗೆ ತಳ್ಳುತ್ತದೆ. ನಂತರ ಅಲ್ಲಿಂದ ಕಂಟೇನರ್ ಅನ್ನು ಕ್ಯೂಬರ್‌ನಲ್ಲಿ ಲಾಂಚ್ ಮಾಡಲಾಗುತ್ತದೆ ಕೆಲಸದ ಹೊರೆ ಕೆಲಸದಲ್ಲಿ ನಿರ್ದಿಷ್ಟಪಡಿಸಿದ ನಿಯತಾಂಕಗಳೊಂದಿಗೆ.

ಜೆಂಕಿನ್ಸ್‌ನಲ್ಲಿ ಉದ್ಯೋಗವನ್ನು ರಚಿಸುವ ಮತ್ತು ಸ್ಥಾಪಿಸುವ ಪ್ರಕ್ರಿಯೆಯನ್ನು ನಾವು ಪರಿಗಣಿಸುವುದಿಲ್ಲ, ಇದು ವಿಷಯವಲ್ಲ. ಕಾರ್ಯ ಸಿದ್ಧವಾಗಿದೆ ಎಂದು ನಾವು ಭಾವಿಸುತ್ತೇವೆ. ಆವೃತ್ತಿಗಳೊಂದಿಗೆ ನವೀಕರಿಸಿದ ಪಟ್ಟಿಯನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸಲು, ನಮಗೆ ಎರಡು ವಿಷಯಗಳ ಅಗತ್ಯವಿದೆ: ಅಸ್ತಿತ್ವದಲ್ಲಿರುವ ಮೂಲ ಪಟ್ಟಿಯು ಮಾನ್ಯವಾದ ಆವೃತ್ತಿ ಸಂಖ್ಯೆಗಳೊಂದಿಗೆ ಮತ್ತು ವೇರಿಯಬಲ್ ನಂತಹ ಆಯ್ಕೆಯ ನಿಯತಾಂಕ ಕಾರ್ಯದಲ್ಲಿ. ನಮ್ಮ ಉದಾಹರಣೆಯಲ್ಲಿ, ವೇರಿಯಬಲ್ ಅನ್ನು ಹೆಸರಿಸೋಣ BUILD_VERSION, ನಾವು ಅದರ ಮೇಲೆ ವಿವರವಾಗಿ ವಾಸಿಸುವುದಿಲ್ಲ. ಆದರೆ ಮೂಲ ಪಟ್ಟಿಯನ್ನು ಹತ್ತಿರದಿಂದ ನೋಡೋಣ.

ಅಷ್ಟು ಆಯ್ಕೆಗಳಿಲ್ಲ. ಎರಡು ವಿಷಯಗಳು ತಕ್ಷಣ ನೆನಪಿಗೆ ಬಂದವು:

ಜೆಂಕಿನ್ಸ್ ತನ್ನ ಬಳಕೆದಾರರಿಗೆ ನೀಡುವ ರಿಮೋಟ್ ಪ್ರವೇಶ API ಅನ್ನು ಬಳಸಿ;
ರಿಮೋಟ್ ರೆಪೊಸಿಟರಿ ಫೋಲ್ಡರ್‌ನ ವಿಷಯಗಳನ್ನು ವಿನಂತಿಸಿ (ನಮ್ಮ ಸಂದರ್ಭದಲ್ಲಿ ಇದು ಜೆಫ್ರಾಗ್ ಆರ್ಟಿಫ್ಯಾಕ್ಟರಿ, ಇದು ಮುಖ್ಯವಲ್ಲ).

ಜೆಂಕಿನ್ಸ್ ರಿಮೋಟ್ ಪ್ರವೇಶ API

ಸ್ಥಾಪಿತವಾದ ಅತ್ಯುತ್ತಮ ಸಂಪ್ರದಾಯದ ಪ್ರಕಾರ, ನಾನು ಸುದೀರ್ಘ ವಿವರಣೆಯನ್ನು ತಪ್ಪಿಸಲು ಬಯಸುತ್ತೇನೆ.
ಮೊದಲ ಪ್ಯಾರಾಗ್ರಾಫ್‌ನ ಒಂದು ಭಾಗದ ಉಚಿತ ಅನುವಾದವನ್ನು ಮಾತ್ರ ನಾನು ಅನುಮತಿಸುತ್ತೇನೆ API ದಸ್ತಾವೇಜನ್ನು ಮೊದಲ ಪುಟ:

ಜೆಂಕಿನ್ಸ್ ತನ್ನ ಕಾರ್ಯಚಟುವಟಿಕೆಗೆ ದೂರಸ್ಥ ಯಂತ್ರ-ಓದಬಲ್ಲ ಪ್ರವೇಶಕ್ಕಾಗಿ API ಅನ್ನು ಒದಗಿಸುತ್ತದೆ. <…> ರಿಮೋಟ್ ಪ್ರವೇಶವನ್ನು REST ತರಹದ ಶೈಲಿಯಲ್ಲಿ ನೀಡಲಾಗುತ್ತದೆ. ಇದರರ್ಥ ಎಲ್ಲಾ ವೈಶಿಷ್ಟ್ಯಗಳಿಗೆ ಒಂದೇ ಪ್ರವೇಶ ಬಿಂದುವಿಲ್ಲ, ಬದಲಿಗೆ "ನಂತಹ URL.../api/", ಎಲ್ಲಿ"..." ಎಂದರೆ API ಸಾಮರ್ಥ್ಯಗಳನ್ನು ಅನ್ವಯಿಸುವ ವಸ್ತು.

ಬೇರೆ ರೀತಿಯಲ್ಲಿ ಹೇಳುವುದಾದರೆ, ನಾವು ಪ್ರಸ್ತುತ ಮಾತನಾಡುತ್ತಿರುವ ನಿಯೋಜನೆ ಕಾರ್ಯವು ಲಭ್ಯವಿದ್ದರೆ http://jenkins.mybuild.er/view/AweSomeApp/job/AweSomeApp_build, ನಂತರ ಈ ಕಾರ್ಯಕ್ಕಾಗಿ API ಸೀಟಿಗಳು ಇಲ್ಲಿ ಲಭ್ಯವಿರುತ್ತವೆ http://jenkins.mybuild.er/view/AweSomeApp/job/AweSomeApp_build/api/

ಮುಂದೆ, ಔಟ್ಪುಟ್ ಅನ್ನು ಯಾವ ರೂಪದಲ್ಲಿ ಸ್ವೀಕರಿಸಲು ನಮಗೆ ಆಯ್ಕೆ ಇದೆ. XML ಮೇಲೆ ಗಮನಹರಿಸೋಣ, ಏಕೆಂದರೆ API ಈ ಸಂದರ್ಭದಲ್ಲಿ ಮಾತ್ರ ಫಿಲ್ಟರಿಂಗ್ ಅನ್ನು ಅನುಮತಿಸುತ್ತದೆ.

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

http://jenkins.mybuild.er/view/AweSomeApp/job/AweSomeApp_build/api/xml?tree=allBuilds[displayName,result]

ಅದು ಕೆಲಸ ಮಾಡಿದೆಯೇ?

ಈಗ ಫಲಿತಾಂಶದೊಂದಿಗೆ ಕೊನೆಗೊಳ್ಳುವ ರನ್‌ಗಳನ್ನು ಮಾತ್ರ ಫಿಲ್ಟರ್ ಮಾಡೋಣ ಯಶಸ್ಸು. ವಾದವನ್ನು ಬಳಸೋಣ & ಹೊರತುಪಡಿಸಿ ಮತ್ತು ಪ್ಯಾರಾಮೀಟರ್ ಆಗಿ ನಾವು ಅದನ್ನು ಸಮಾನವಲ್ಲದ ಮೌಲ್ಯಕ್ಕೆ ಮಾರ್ಗವನ್ನು ಹಾದು ಹೋಗುತ್ತೇವೆ ಯಶಸ್ಸು. ಹೌದು ಹೌದು. ಡಬಲ್ ನೆಗೆಟಿವ್ ಒಂದು ಹೇಳಿಕೆಯಾಗಿದೆ. ನಮಗೆ ಆಸಕ್ತಿಯಿಲ್ಲದ ಎಲ್ಲವನ್ನೂ ನಾವು ಹೊರಗಿಡುತ್ತೇವೆ:

http://jenkins.mybuild.er/view/AweSomeApp/job/AweSomeApp_build/api/xml?tree=allBuilds[displayName,result]&exclude=freeStyleProject/allBuild[result!='SUCCESS']

ಯಶಸ್ವಿ ಪಟ್ಟಿಯ ಸ್ಕ್ರೀನ್‌ಶಾಟ್

ಒಳ್ಳೆಯದು, ವಿನೋದಕ್ಕಾಗಿ, ಫಿಲ್ಟರ್ ನಮ್ಮನ್ನು ಮೋಸಗೊಳಿಸಲಿಲ್ಲ ಎಂದು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳೋಣ (ಫಿಲ್ಟರ್‌ಗಳು ಎಂದಿಗೂ ಸುಳ್ಳು ಹೇಳುವುದಿಲ್ಲ!) ಮತ್ತು "ವಿಫಲವಾದ" ಪಟ್ಟಿಯನ್ನು ಪ್ರದರ್ಶಿಸಿ:

http://jenkins.mybuild.er/view/AweSomeApp/job/AweSomeApp_build/api/xml?tree=allBuilds[displayName,result]&exclude=freeStyleProject/allBuild[result='SUCCESS']

ಯಶಸ್ವಿಯಾಗದವರ ಪಟ್ಟಿಯ ಸ್ಕ್ರೀನ್‌ಶಾಟ್

ರಿಮೋಟ್ ಸರ್ವರ್‌ನಲ್ಲಿರುವ ಫೋಲ್ಡರ್‌ನಿಂದ ಆವೃತ್ತಿಗಳ ಪಟ್ಟಿ

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

ಒಂದು ಸಾಲಿನ ಆಜ್ಞೆ
ದಯವಿಟ್ಟು ಎರಡು ವಿಷಯಗಳನ್ನು ಗಮನಿಸಿ: ನಾನು ಹೆಡರ್‌ನಲ್ಲಿ ಸಂಪರ್ಕ ವಿವರಗಳನ್ನು ರವಾನಿಸುತ್ತೇನೆ ಮತ್ತು ಫೋಲ್ಡರ್‌ನಿಂದ ನನಗೆ ಎಲ್ಲಾ ಆವೃತ್ತಿಗಳು ಅಗತ್ಯವಿಲ್ಲ, ಮತ್ತು ಒಂದು ತಿಂಗಳೊಳಗೆ ರಚಿಸಲಾದವುಗಳನ್ನು ಮಾತ್ರ ನಾನು ಆಯ್ಕೆ ಮಾಡುತ್ತೇನೆ. ನಿಮ್ಮ ನೈಜತೆಗಳು ಮತ್ತು ಅಗತ್ಯಗಳಿಗೆ ಸರಿಹೊಂದುವಂತೆ ಆಜ್ಞೆಯನ್ನು ಸಂಪಾದಿಸಿ:

curl -H "X-JFrog-Art-Api:VeryLongAPIKey" -s http://arts.myre.po/artifactory/awesomeapp/ | sed 's/a href=//' | grep "$(date +%b)-$(date +%Y)|$(date +%b --date='-1 month')-$(date +%Y)" | awk '{print $1}' | grep -oP '>K[^/]+' )

ಜೆಂಕಿನ್ಸ್‌ನಲ್ಲಿ ಉದ್ಯೋಗಗಳು ಮತ್ತು ಉದ್ಯೋಗ ಕಾನ್ಫಿಗರೇಶನ್ ಫೈಲ್ ಅನ್ನು ಹೊಂದಿಸಲಾಗುತ್ತಿದೆ

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

ಅಸೆಂಬ್ಲಿ ಕಾರ್ಯ ಸೆಟ್ಟಿಂಗ್‌ಗಳನ್ನು ತೆರೆಯಿರಿ ಮತ್ತು ಅತ್ಯಂತ ಕೆಳಕ್ಕೆ ಸ್ಕ್ರಾಲ್ ಮಾಡಿ. ಗುಂಡಿಗಳ ಮೇಲೆ ಕ್ಲಿಕ್ ಮಾಡಿ: ನಿರ್ಮಾಣ ಹಂತವನ್ನು ಸೇರಿಸಿ -> ಷರತ್ತುಬದ್ಧ ಹಂತ (ಏಕ). ಹಂತದ ಸೆಟ್ಟಿಂಗ್‌ಗಳಲ್ಲಿ, ಸ್ಥಿತಿಯನ್ನು ಆಯ್ಕೆಮಾಡಿ ಪ್ರಸ್ತುತ ನಿರ್ಮಾಣ ಸ್ಥಿತಿ, ಮೌಲ್ಯವನ್ನು ಹೊಂದಿಸಿ ಯಶಸ್ಸು, ಯಶಸ್ವಿಯಾದರೆ ಮಾಡಬೇಕಾದ ಕ್ರಿಯೆ ಶೆಲ್ ಆಜ್ಞೆಯನ್ನು ಚಲಾಯಿಸಿ.

ಮತ್ತು ಈಗ ಮೋಜಿನ ಭಾಗ. ಜೆಂಕಿನ್ಸ್ ಫೈಲ್‌ಗಳಲ್ಲಿ ಉದ್ಯೋಗ ಸಂರಚನೆಗಳನ್ನು ಸಂಗ್ರಹಿಸುತ್ತಾನೆ. XML ಸ್ವರೂಪದಲ್ಲಿ. ದಾರಿಯುದ್ದಕ್ಕೂ http://путь-до-задания/config.xml ಅಂತೆಯೇ, ನೀವು ಕಾನ್ಫಿಗರೇಶನ್ ಫೈಲ್ ಅನ್ನು ಡೌನ್‌ಲೋಡ್ ಮಾಡಬಹುದು, ಅದನ್ನು ಅಗತ್ಯವಿರುವಂತೆ ಸಂಪಾದಿಸಿ ಮತ್ತು ನೀವು ಅದನ್ನು ಪಡೆದ ಸ್ಥಳದಲ್ಲಿ ಇರಿಸಬಹುದು.

ನೆನಪಿಡಿ, ಆವೃತ್ತಿಗಳ ಪಟ್ಟಿಗಾಗಿ ನಾವು ಪ್ಯಾರಾಮೀಟರ್ ಅನ್ನು ರಚಿಸುತ್ತೇವೆ ಎಂದು ನಾವು ಮೇಲೆ ಒಪ್ಪಿಕೊಂಡಿದ್ದೇವೆ BUILD_VERSION?

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

ಸ್ಪಾಯ್ಲರ್ ಅಡಿಯಲ್ಲಿ ಸ್ಕ್ರೀನ್ಶಾಟ್.

ನಿಮ್ಮ config.xml ತುಣುಕು ಒಂದೇ ರೀತಿ ಕಾಣಬೇಕು. ಆಯ್ಕೆಯ ಅಂಶದ ವಿಷಯಗಳು ಇನ್ನೂ ಕಾಣೆಯಾಗಿವೆ ಎಂಬುದನ್ನು ಹೊರತುಪಡಿಸಿ

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

ಸ್ಪಾಯ್ಲರ್ ಅಡಿಯಲ್ಲಿ, ಮೇಲಿನ ಅನುಕ್ರಮವನ್ನು ಸಂಪೂರ್ಣವಾಗಿ ನಿರ್ವಹಿಸುವ ಕೋಡ್ ಅನ್ನು ನಾನು ಪ್ರಸ್ತುತಪಡಿಸುತ್ತೇನೆ.

ರಿಮೋಟ್ ಸರ್ವರ್‌ನಲ್ಲಿರುವ ಫೋಲ್ಡರ್‌ನಿಂದ ಸಂರಚನೆಗೆ ಆವೃತ್ತಿಗಳ ಪಟ್ಟಿಯನ್ನು ಬರೆಯಿರಿ

#!/bin/bash
############## Скачиваем конфиг
curl -X GET -u username:apiKey http://jenkins.mybuild.er/view/AweSomeApp/job/AweSomeApp_k8s/config.xml -o appConfig.xml

############## Удаляем и заново создаем xml-элемент для списка версий
xmlstarlet ed --inplace -d '/project/properties/hudson.model.ParametersDefinitionProperty/parameterDefinitions/hudson.model.ChoiceParameterDefinition[name="BUILD_VERSION"]/choices[@class="java.util.Arrays$ArrayList"]/a[@class="string-array"]' appConfig.xml

xmlstarlet ed --inplace --subnode '/project/properties/hudson.model.ParametersDefinitionProperty/parameterDefinitions/hudson.model.ChoiceParameterDefinition[name="BUILD_VERSION"]/choices[@class="java.util.Arrays$ArrayList"]' --type elem -n a appConfig.xml

xmlstarlet ed --inplace --insert '/project/properties/hudson.model.ParametersDefinitionProperty/parameterDefinitions/hudson.model.ChoiceParameterDefinition[name="BUILD_VERSION"]/choices[@class="java.util.Arrays$ArrayList"]/a' --type attr -n class -v string-array appConfig.xml

############## Читаем в массив список версий из репозитория
readarray -t vers < <( curl -H "X-JFrog-Art-Api:Api:VeryLongAPIKey" -s http://arts.myre.po/artifactory/awesomeapp/ | sed 's/a href=//' | grep "$(date +%b)-$(date +%Y)|$(date +%b --date='-1 month')-$(date +%Y)" | awk '{print $1}' | grep -oP '>K[^/]+' )

############## Пишем массив элемент за элементом в конфиг
printf '%sn' "${vers[@]}" | sort -r | 
                while IFS= read -r line
                do
                    xmlstarlet ed --inplace --subnode '/project/properties/hudson.model.ParametersDefinitionProperty/parameterDefinitions/hudson.model.ChoiceParameterDefinition[name="BUILD_VERSION"]/choices[@class="java.util.Arrays$ArrayList"]/a[@class="string-array"]' --type elem -n string -v "$line" appConfig.xml
                done

############## Кладем конфиг взад
curl -X POST -u username:apiKey http://jenkins.mybuild.er/view/AweSomeApp/job/AweSomeApp_k8s/config.xml --data-binary @appConfig.xml

############## Приводим рабочее место в порядок
rm -f appConfig.xml

ಜೆಂಕಿನ್ಸ್‌ನಿಂದ ಆವೃತ್ತಿಗಳನ್ನು ಪಡೆಯುವ ಆಯ್ಕೆಯನ್ನು ನೀವು ಬಯಸಿದರೆ ಮತ್ತು ನೀವು ನನ್ನಂತೆ ಸೋಮಾರಿಯಾಗಿದ್ದರೆ, ಸ್ಪಾಯ್ಲರ್ ಅಡಿಯಲ್ಲಿ ಅದೇ ಕೋಡ್ ಇರುತ್ತದೆ, ಆದರೆ ಜೆಂಕಿನ್ಸ್‌ನಿಂದ ಪಟ್ಟಿ:

ಜೆಂಕಿನ್ಸ್‌ನಿಂದ ಸಂರಚನೆಗೆ ಆವೃತ್ತಿಗಳ ಪಟ್ಟಿಯನ್ನು ಬರೆಯಿರಿ
ಇದನ್ನು ನೆನಪಿನಲ್ಲಿಡಿ: ನನ್ನ ಅಸೆಂಬ್ಲಿ ಹೆಸರು ಅನುಕ್ರಮ ಸಂಖ್ಯೆ ಮತ್ತು ಆವೃತ್ತಿ ಸಂಖ್ಯೆಯನ್ನು ಕೊಲೊನ್‌ನಿಂದ ಬೇರ್ಪಡಿಸಲಾಗಿದೆ. ಅಂತೆಯೇ, awk ಅನಗತ್ಯ ಭಾಗವನ್ನು ಕತ್ತರಿಸುತ್ತದೆ. ನಿಮಗಾಗಿ, ನಿಮ್ಮ ಅಗತ್ಯಗಳಿಗೆ ಸರಿಹೊಂದುವಂತೆ ಈ ಸಾಲನ್ನು ಬದಲಾಯಿಸಿ.

#!/bin/bash
############## Скачиваем конфиг
curl -X GET -u username:apiKey http://jenkins.mybuild.er/view/AweSomeApp/job/AweSomeApp_k8s/config.xml -o appConfig.xml

############## Удаляем и заново создаем xml-элемент для списка версий
xmlstarlet ed --inplace -d '/project/properties/hudson.model.ParametersDefinitionProperty/parameterDefinitions/hudson.model.ChoiceParameterDefinition[name="BUILD_VERSION"]/choices[@class="java.util.Arrays$ArrayList"]/a[@class="string-array"]' appConfig.xml

xmlstarlet ed --inplace --subnode '/project/properties/hudson.model.ParametersDefinitionProperty/parameterDefinitions/hudson.model.ChoiceParameterDefinition[name="BUILD_VERSION"]/choices[@class="java.util.Arrays$ArrayList"]' --type elem -n a appConfig.xml

xmlstarlet ed --inplace --insert '/project/properties/hudson.model.ParametersDefinitionProperty/parameterDefinitions/hudson.model.ChoiceParameterDefinition[name="BUILD_VERSION"]/choices[@class="java.util.Arrays$ArrayList"]/a' --type attr -n class -v string-array appConfig.xml

############## Пишем в файл список версий из Jenkins
curl -g -X GET -u username:apiKey 'http://jenkins.mybuild.er/view/AweSomeApp/job/AweSomeApp_build/api/xml?tree=allBuilds[displayName,result]&exclude=freeStyleProject/allBuild[result!=%22SUCCESS%22]&pretty=true' -o builds.xml

############## Читаем в массив список версий из XML
readarray vers < <(xmlstarlet sel -t -v "freeStyleProject/allBuild/displayName" builds.xml | awk -F":" '{print $2}')

############## Пишем массив элемент за элементом в конфиг
printf '%sn' "${vers[@]}" | sort -r | 
                while IFS= read -r line
                do
                    xmlstarlet ed --inplace --subnode '/project/properties/hudson.model.ParametersDefinitionProperty/parameterDefinitions/hudson.model.ChoiceParameterDefinition[name="BUILD_VERSION"]/choices[@class="java.util.Arrays$ArrayList"]/a[@class="string-array"]' --type elem -n string -v "$line" appConfig.xml
                done

############## Кладем конфиг взад
curl -X POST -u username:apiKey http://jenkins.mybuild.er/view/AweSomeApp/job/AweSomeApp_k8s/config.xml --data-binary @appConfig.xml

############## Приводим рабочее место в порядок
rm -f appConfig.xml

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

ಆವೃತ್ತಿಗಳ ಸರಿಯಾಗಿ ಪೂರ್ಣಗೊಂಡ ಪಟ್ಟಿ

ಎಲ್ಲವೂ ಕೆಲಸ ಮಾಡಿದರೆ, ಸ್ಕ್ರಿಪ್ಟ್ ಅನ್ನು ನಕಲಿಸಿ-ಅಂಟಿಸಿ ಶೆಲ್ ಆಜ್ಞೆಯನ್ನು ಚಲಾಯಿಸಿ ಮತ್ತು ಬದಲಾವಣೆಗಳನ್ನು ಉಳಿಸಿ.

ಕ್ಲೌಡ್ ಶೆಲ್‌ಗೆ ಸಂಪರ್ಕಿಸಲಾಗುತ್ತಿದೆ

ನಾವು ಕಂಟೈನರ್‌ಗಳಲ್ಲಿ ಸಂಗ್ರಾಹಕರನ್ನು ಹೊಂದಿದ್ದೇವೆ. ನಾವು ಅನ್ಸಿಬಲ್ ಅನ್ನು ನಮ್ಮ ಅಪ್ಲಿಕೇಶನ್ ಡೆಲಿವರಿ ಟೂಲ್ ಮತ್ತು ಕಾನ್ಫಿಗರೇಶನ್ ಮ್ಯಾನೇಜರ್ ಆಗಿ ಬಳಸುತ್ತೇವೆ. ಅಂತೆಯೇ, ಕಂಟೈನರ್‌ಗಳನ್ನು ನಿರ್ಮಿಸಲು ಬಂದಾಗ, ಮೂರು ಆಯ್ಕೆಗಳು ಮನಸ್ಸಿಗೆ ಬರುತ್ತವೆ: ಡಾಕರ್‌ನಲ್ಲಿ ಡಾಕರ್ ಅನ್ನು ಸ್ಥಾಪಿಸಿ, ಅನ್ಸಿಬಲ್ ಚಾಲನೆಯಲ್ಲಿರುವ ಯಂತ್ರದಲ್ಲಿ ಡಾಕರ್ ಅನ್ನು ಸ್ಥಾಪಿಸಿ ಅಥವಾ ಕ್ಲೌಡ್ ಕನ್ಸೋಲ್‌ನಲ್ಲಿ ಕಂಟೇನರ್‌ಗಳನ್ನು ನಿರ್ಮಿಸಿ. ಈ ಲೇಖನದಲ್ಲಿ ಜೆಂಕಿನ್ಸ್‌ಗಾಗಿ ಪ್ಲಗಿನ್‌ಗಳ ಬಗ್ಗೆ ಮೌನವಾಗಿರಲು ನಾವು ಒಪ್ಪಿಕೊಂಡಿದ್ದೇವೆ. ನೆನಪಿದೆಯೇ?

ನಾನು ನಿರ್ಧರಿಸಿದೆ: ಒಳ್ಳೆಯದು, ಕ್ಲೌಡ್ ಕನ್ಸೋಲ್‌ನಲ್ಲಿ "ಬಾಕ್ಸ್‌ನ ಹೊರಗೆ" ಕಂಟೇನರ್‌ಗಳನ್ನು ಸಂಗ್ರಹಿಸಬಹುದಾದ್ದರಿಂದ, ಏಕೆ ತಲೆಕೆಡಿಸಿಕೊಳ್ಳಬೇಕು? ಅದನ್ನು ಸ್ವಚ್ಛವಾಗಿಡಿ, ಸರಿ? ನಾನು ಕ್ಲೌಡ್ ಕನ್ಸೋಲ್‌ನಲ್ಲಿ ಜೆಂಕಿನ್ಸ್ ಕಂಟೇನರ್‌ಗಳನ್ನು ಸಂಗ್ರಹಿಸಲು ಬಯಸುತ್ತೇನೆ, ತದನಂತರ ಅವುಗಳನ್ನು ಅಲ್ಲಿಂದ ಕ್ಯೂಬರ್‌ಗೆ ಪ್ರಾರಂಭಿಸುತ್ತೇನೆ. ಇದಲ್ಲದೆ, ಗೂಗಲ್ ತನ್ನ ಮೂಲಸೌಕರ್ಯದಲ್ಲಿ ಅತ್ಯಂತ ಶ್ರೀಮಂತ ಚಾನಲ್‌ಗಳನ್ನು ಹೊಂದಿದೆ, ಇದು ನಿಯೋಜನೆಯ ವೇಗದ ಮೇಲೆ ಪ್ರಯೋಜನಕಾರಿ ಪರಿಣಾಮವನ್ನು ಬೀರುತ್ತದೆ.

ಕ್ಲೌಡ್ ಕನ್ಸೋಲ್‌ಗೆ ಸಂಪರ್ಕಿಸಲು, ನಿಮಗೆ ಎರಡು ವಿಷಯಗಳು ಬೇಕಾಗುತ್ತವೆ: gCloud ಮತ್ತು ಪ್ರವೇಶ ಹಕ್ಕುಗಳು Google ಮೇಘ API VM ನಿದರ್ಶನಕ್ಕಾಗಿ ಇದೇ ಸಂಪರ್ಕವನ್ನು ಮಾಡಲಾಗುವುದು.

Google ಕ್ಲೌಡ್‌ನಿಂದ ಸಂಪರ್ಕಿಸಲು ಯೋಜಿಸುವವರಿಗೆ
Google ತನ್ನ ಸೇವೆಗಳಲ್ಲಿ ಸಂವಾದಾತ್ಮಕ ಅಧಿಕಾರವನ್ನು ನಿಷ್ಕ್ರಿಯಗೊಳಿಸುವ ಸಾಧ್ಯತೆಯನ್ನು ಅನುಮತಿಸುತ್ತದೆ. ಇದು *nix ಚಾಲನೆಯಲ್ಲಿದ್ದರೆ ಮತ್ತು ಕನ್ಸೋಲ್ ಅನ್ನು ಹೊಂದಿದ್ದರೆ, ಕಾಫಿ ಯಂತ್ರದಿಂದಲೂ ಕನ್ಸೋಲ್‌ಗೆ ಸಂಪರ್ಕಿಸಲು ಇದು ನಿಮ್ಮನ್ನು ಅನುಮತಿಸುತ್ತದೆ.

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

ವೆಬ್ ಇಂಟರ್ಫೇಸ್ ಮೂಲಕ ಹಕ್ಕುಗಳನ್ನು ನೀಡಲು ಸುಲಭವಾದ ಮಾರ್ಗವಾಗಿದೆ.

ಕ್ಲೌಡ್ ಕನ್ಸೋಲ್‌ಗೆ ನೀವು ತರುವಾಯ ಸಂಪರ್ಕಿಸುವ VM ನಿದರ್ಶನವನ್ನು ನಿಲ್ಲಿಸಿ.
ನಿದರ್ಶನದ ವಿವರಗಳನ್ನು ತೆರೆಯಿರಿ ಮತ್ತು ಕ್ಲಿಕ್ ಮಾಡಿ ತಿದ್ದುಪಡಿ.
ಪುಟದ ಅತ್ಯಂತ ಕೆಳಭಾಗದಲ್ಲಿ, ನಿದರ್ಶನ ಪ್ರವೇಶ ವ್ಯಾಪ್ತಿಯನ್ನು ಆಯ್ಕೆಮಾಡಿ ಎಲ್ಲಾ ಕ್ಲೌಡ್ API ಗಳಿಗೆ ಪೂರ್ಣ ಪ್ರವೇಶ.
ಸ್ಕ್ರೀನ್‌ಶಾಟ್
ನಿಮ್ಮ ಬದಲಾವಣೆಗಳನ್ನು ಉಳಿಸಿ ಮತ್ತು ನಿದರ್ಶನವನ್ನು ಪ್ರಾರಂಭಿಸಿ.

VM ಲೋಡ್ ಆಗುವುದನ್ನು ಪೂರ್ಣಗೊಳಿಸಿದ ನಂತರ, SSH ಮೂಲಕ ಅದಕ್ಕೆ ಸಂಪರ್ಕಪಡಿಸಿ ಮತ್ತು ಸಂಪರ್ಕವು ದೋಷವಿಲ್ಲದೆ ಸಂಭವಿಸುತ್ತದೆ ಎಂದು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಿ. ಆಜ್ಞೆಯನ್ನು ಬಳಸಿ:

gcloud alpha cloud-shell ssh

ಯಶಸ್ವಿ ಸಂಪರ್ಕವು ಈ ರೀತಿ ಕಾಣುತ್ತದೆ

GKE ಗೆ ನಿಯೋಜಿಸಿ

IaC (ಒಂದು ಕೋಡ್‌ನಂತೆ ಮೂಲಸೌಕರ್ಯ) ಗೆ ಸಂಪೂರ್ಣವಾಗಿ ಬದಲಾಯಿಸಲು ನಾವು ಸಾಧ್ಯವಿರುವ ಎಲ್ಲ ರೀತಿಯಲ್ಲಿ ಪ್ರಯತ್ನಿಸುತ್ತಿರುವುದರಿಂದ, ನಮ್ಮ ಡಾಕರ್ ಫೈಲ್‌ಗಳನ್ನು Git ನಲ್ಲಿ ಸಂಗ್ರಹಿಸಲಾಗಿದೆ. ಇದು ಒಂದು ಕಡೆ. ಮತ್ತು kubernetes ನಲ್ಲಿ ನಿಯೋಜನೆಯನ್ನು yaml ಫೈಲ್‌ನಿಂದ ವಿವರಿಸಲಾಗಿದೆ, ಇದನ್ನು ಈ ಕಾರ್ಯದಿಂದ ಮಾತ್ರ ಬಳಸಲಾಗುತ್ತದೆ, ಅದು ಕೋಡ್‌ನಂತೆಯೇ ಇರುತ್ತದೆ. ಇದು ಇನ್ನೊಂದು ಕಡೆಯಿಂದ. ಸಾಮಾನ್ಯವಾಗಿ, ನನ್ನ ಪ್ರಕಾರ, ಯೋಜನೆ ಹೀಗಿದೆ:

ನಾವು ಅಸ್ಥಿರ ಮೌಲ್ಯಗಳನ್ನು ತೆಗೆದುಕೊಳ್ಳುತ್ತೇವೆ BUILD_VERSION ಮತ್ತು, ಐಚ್ಛಿಕವಾಗಿ, ಹಾದುಹೋಗುವ ವೇರಿಯೇಬಲ್‌ಗಳ ಮೌಲ್ಯಗಳು ಇಎನ್‌ವಿ.
Git ನಿಂದ ಡಾಕರ್‌ಫೈಲ್ ಅನ್ನು ಡೌನ್‌ಲೋಡ್ ಮಾಡಿ.
ನಿಯೋಜನೆಗಾಗಿ ಯಾಮ್ಲ್ ಅನ್ನು ರಚಿಸಿ.
ನಾವು ಈ ಎರಡೂ ಫೈಲ್‌ಗಳನ್ನು scp ಮೂಲಕ ಕ್ಲೌಡ್ ಕನ್ಸೋಲ್‌ಗೆ ಅಪ್‌ಲೋಡ್ ಮಾಡುತ್ತೇವೆ.
ನಾವು ಅಲ್ಲಿ ಕಂಟೇನರ್ ಅನ್ನು ನಿರ್ಮಿಸುತ್ತೇವೆ ಮತ್ತು ಅದನ್ನು ಕಂಟೇನರ್ ರಿಜಿಸ್ಟ್ರಿಗೆ ತಳ್ಳುತ್ತೇವೆ
ನಾವು ಲೋಡ್ ನಿಯೋಜನೆ ಫೈಲ್ ಅನ್ನು ಕ್ಯೂಬರ್‌ಗೆ ಅನ್ವಯಿಸುತ್ತೇವೆ.

ಹೆಚ್ಚು ನಿರ್ದಿಷ್ಟವಾಗಿರಲಿ. ಒಮ್ಮೆ ನಾವು ಮಾತನಾಡಲು ಪ್ರಾರಂಭಿಸಿದೆವು ಇಎನ್‌ವಿ, ನಂತರ ನಾವು ಎರಡು ನಿಯತಾಂಕಗಳ ಮೌಲ್ಯಗಳನ್ನು ರವಾನಿಸಬೇಕಾಗಿದೆ ಎಂದು ಭಾವಿಸೋಣ: PARAM1 и PARAM2. ನಿಯೋಜನೆಗಾಗಿ ನಾವು ಅವರ ಕಾರ್ಯವನ್ನು ಸೇರಿಸುತ್ತೇವೆ, ಟೈಪ್ ಮಾಡಿ - ಸ್ಟ್ರಿಂಗ್ ಪ್ಯಾರಾಮೀಟರ್.

ಸ್ಕ್ರೀನ್‌ಶಾಟ್

ನಾವು ಸರಳ ಮರುನಿರ್ದೇಶನದೊಂದಿಗೆ ಯಾಮ್ಲ್ ಅನ್ನು ರಚಿಸುತ್ತೇವೆ ಪ್ರತಿಧ್ವನಿ ಕಡತಕ್ಕೆ. ನಿಮ್ಮ ಡಾಕರ್‌ಫೈಲ್‌ನಲ್ಲಿ ನೀವು ಹೊಂದಿರುವಿರಿ ಎಂದು ಭಾವಿಸಲಾಗಿದೆ PARAM1 и PARAM2ಲೋಡ್ ಹೆಸರು ಎಂದು ಅದ್ಭುತ ಅಪ್ಲಿಕೇಶನ್, ಮತ್ತು ನಿಗದಿತ ಆವೃತ್ತಿಯ ಅನ್ವಯದೊಂದಿಗೆ ಜೋಡಿಸಲಾದ ಕಂಟೇನರ್ ಇರುತ್ತದೆ ಕಂಟೈನರ್ ನೋಂದಾವಣೆ ದಾರಿಯಲ್ಲಿ gcr.io/awesomeapp/awesomeapp-$BUILD_VERSIONಅಲ್ಲಿ $BUILD_VERSION ಡ್ರಾಪ್-ಡೌನ್ ಪಟ್ಟಿಯಿಂದ ಇದೀಗ ಆಯ್ಕೆ ಮಾಡಲಾಗಿದೆ.

ತಂಡದ ಪಟ್ಟಿ

touch deploy.yaml
echo "apiVersion: apps/v1" >> deploy.yaml
echo "kind: Deployment" >> deploy.yaml
echo "metadata:" >> deploy.yaml
echo "  name: awesomeapp" >> deploy.yaml
echo "spec:" >> deploy.yaml
echo "  replicas: 1" >> deploy.yaml
echo "  selector:" >> deploy.yaml
echo "    matchLabels:" >> deploy.yaml
echo "      run: awesomeapp" >> deploy.yaml
echo "  template:" >> deploy.yaml
echo "    metadata:" >> deploy.yaml
echo "      labels:" >> deploy.yaml
echo "        run: awesomeapp" >> deploy.yaml
echo "    spec:" >> deploy.yaml
echo "      containers:" >> deploy.yaml
echo "      - name: awesomeapp" >> deploy.yaml
echo "        image: gcr.io/awesomeapp/awesomeapp-$BUILD_VERSION:latest" >> deploy.yaml
echo "        env:" >> deploy.yaml
echo "        - name: PARAM1" >> deploy.yaml
echo "          value: $PARAM1" >> deploy.yaml
echo "        - name: PARAM2" >> deploy.yaml
echo "          value: $PARAM2" >> deploy.yaml

ಬಳಸಿ ಸಂಪರ್ಕಿಸಿದ ನಂತರ ಜೆಂಕಿನ್ಸ್ ಏಜೆಂಟ್ gcloud ಆಲ್ಫಾ ಕ್ಲೌಡ್-ಶೆಲ್ ssh ಸಂವಾದಾತ್ಮಕ ಮೋಡ್ ಲಭ್ಯವಿಲ್ಲ, ಆದ್ದರಿಂದ ನಾವು ಪ್ಯಾರಾಮೀಟರ್ ಅನ್ನು ಬಳಸಿಕೊಂಡು ಕ್ಲೌಡ್ ಕನ್ಸೋಲ್‌ಗೆ ಆಜ್ಞೆಗಳನ್ನು ಕಳುಹಿಸುತ್ತೇವೆ --ಆಜ್ಞೆ.

ನಾವು ಹಳೆಯ ಡಾಕರ್‌ಫೈಲ್‌ನಿಂದ ಕ್ಲೌಡ್ ಕನ್ಸೋಲ್‌ನಲ್ಲಿ ಹೋಮ್ ಫೋಲ್ಡರ್ ಅನ್ನು ಸ್ವಚ್ಛಗೊಳಿಸುತ್ತೇವೆ:

gcloud alpha cloud-shell ssh --command="rm -f Dockerfile"

scp ಬಳಸಿಕೊಂಡು ಕ್ಲೌಡ್ ಕನ್ಸೋಲ್‌ನ ಹೋಮ್ ಫೋಲ್ಡರ್‌ನಲ್ಲಿ ಹೊಸದಾಗಿ ಡೌನ್‌ಲೋಡ್ ಮಾಡಿದ ಡಾಕರ್‌ಫೈಲ್ ಅನ್ನು ಇರಿಸಿ:

gcloud alpha cloud-shell scp localhost:./Dockerfile cloudshell:~

ನಾವು ಕಂಟೈನರ್ ರಿಜಿಸ್ಟ್ರಿಗೆ ಧಾರಕವನ್ನು ಸಂಗ್ರಹಿಸುತ್ತೇವೆ, ಟ್ಯಾಗ್ ಮಾಡುತ್ತೇವೆ ಮತ್ತು ತಳ್ಳುತ್ತೇವೆ:

gcloud alpha cloud-shell ssh --command="docker build -t awesomeapp-$BUILD_VERSION ./ --build-arg BUILD_VERSION=$BUILD_VERSION --no-cache"
gcloud alpha cloud-shell ssh --command="docker tag awesomeapp-$BUILD_VERSION gcr.io/awesomeapp/awesomeapp-$BUILD_VERSION"
gcloud alpha cloud-shell ssh --command="docker push gcr.io/awesomeapp/awesomeapp-$BUILD_VERSION"

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

gcloud alpha cloud-shell ssh --command="rm -f deploy.yaml"
gcloud alpha cloud-shell scp localhost:./deploy.yaml cloudshell:~
gcloud alpha cloud-shell ssh --command="gcloud container clusters get-credentials awsm-cluster --zone us-central1-c --project awesome-project && 
kubectl apply -f deploy.yaml"

ನಾವು ಕಾರ್ಯವನ್ನು ನಡೆಸುತ್ತೇವೆ, ಕನ್ಸೋಲ್ ಔಟ್ಪುಟ್ ಅನ್ನು ತೆರೆಯುತ್ತೇವೆ ಮತ್ತು ಕಂಟೇನರ್ನ ಯಶಸ್ವಿ ಜೋಡಣೆಯನ್ನು ನೋಡಲು ಭಾವಿಸುತ್ತೇವೆ.

ಸ್ಕ್ರೀನ್‌ಶಾಟ್

ತದನಂತರ ಜೋಡಿಸಲಾದ ಕಂಟೇನರ್ನ ಯಶಸ್ವಿ ನಿಯೋಜನೆ

ಸ್ಕ್ರೀನ್‌ಶಾಟ್

ನಾನು ಉದ್ದೇಶಪೂರ್ವಕವಾಗಿ ಸೆಟ್ಟಿಂಗ್ ಅನ್ನು ನಿರ್ಲಕ್ಷಿಸಿದೆ ಪ್ರವೇಶ. ಒಂದು ಸರಳ ಕಾರಣಕ್ಕಾಗಿ: ಒಮ್ಮೆ ನೀವು ಅದನ್ನು ಹೊಂದಿಸಿ ಕೆಲಸದ ಹೊರೆ ಕೊಟ್ಟಿರುವ ಹೆಸರಿನೊಂದಿಗೆ, ನೀವು ಈ ಹೆಸರಿನೊಂದಿಗೆ ಎಷ್ಟು ನಿಯೋಜನೆಗಳನ್ನು ನಿರ್ವಹಿಸಿದರೂ ಅದು ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತಲೇ ಇರುತ್ತದೆ. ಸರಿ, ಸಾಮಾನ್ಯವಾಗಿ, ಇದು ಇತಿಹಾಸದ ವ್ಯಾಪ್ತಿಯನ್ನು ಸ್ವಲ್ಪ ಮೀರಿದೆ.

ತೀರ್ಮಾನಗಳಿಗೆ ಬದಲಾಗಿ

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

ಮತ್ತು ನನಗಾಗಿ ಕೆಲವು ಹೊಸ ವಿಷಯವನ್ನು ತೆಗೆದುಕೊಳ್ಳಲು ನಾನು ಇಷ್ಟಪಡುತ್ತೇನೆ. ಮೇಲಿನ ಪಠ್ಯವು ಆರಂಭದಲ್ಲಿ ವಿವರಿಸಿದ ಸಮಸ್ಯೆಯನ್ನು ಪರಿಹರಿಸುವಾಗ ನಾನು ಮಾಡಿದ ಸಂಶೋಧನೆಗಳನ್ನು ಹಂಚಿಕೊಳ್ಳಲು ಒಂದು ಮಾರ್ಗವಾಗಿದೆ. ಅವನಂತೆ, ಡೆವೊಪ್ಸ್‌ನಲ್ಲಿ ಯಾವುದೇ ಭಯಂಕರ ತೋಳವಲ್ಲದವರೊಂದಿಗೆ ಹಂಚಿಕೊಳ್ಳಿ. ನನ್ನ ಸಂಶೋಧನೆಗಳು ಕನಿಷ್ಠ ಯಾರಿಗಾದರೂ ಸಹಾಯ ಮಾಡಿದರೆ, ನಾನು ಸಂತೋಷವಾಗಿರುತ್ತೇನೆ.

ಮೂಲ: www.habr.com

ಜೆಂಕಿನ್ಸ್‌ನಲ್ಲಿ ಕೆಲಸದ ಸೆಟ್ಟಿಂಗ್‌ಗಳನ್ನು ಕ್ರಿಯಾತ್ಮಕವಾಗಿ ನವೀಕರಿಸಲಾಗುತ್ತಿದೆ

ಜೆಂಕಿನ್ಸ್ ರಿಮೋಟ್ ಪ್ರವೇಶ API

ರಿಮೋಟ್ ಸರ್ವರ್‌ನಲ್ಲಿರುವ ಫೋಲ್ಡರ್‌ನಿಂದ ಆವೃತ್ತಿಗಳ ಪಟ್ಟಿ

ಜೆಂಕಿನ್ಸ್‌ನಲ್ಲಿ ಉದ್ಯೋಗಗಳು ಮತ್ತು ಉದ್ಯೋಗ ಕಾನ್ಫಿಗರೇಶನ್ ಫೈಲ್ ಅನ್ನು ಹೊಂದಿಸಲಾಗುತ್ತಿದೆ

ಕ್ಲೌಡ್ ಶೆಲ್‌ಗೆ ಸಂಪರ್ಕಿಸಲಾಗುತ್ತಿದೆ

GKE ಗೆ ನಿಯೋಜಿಸಿ

ತೀರ್ಮಾನಗಳಿಗೆ ಬದಲಾಗಿ

ಕಾಮೆಂಟ್ ಅನ್ನು ಸೇರಿಸಿ Отменить ответ