ಈ ಬ್ಲಾಗ್‌ನಲ್ಲಿರುವ ಎಲ್ಲರಿಗೂ ನಮಸ್ಕಾರ! Red Hat OpenShift ನಲ್ಲಿ ಆಧುನಿಕ ವೆಬ್ ಅಪ್ಲಿಕೇಶನ್ಗಳನ್ನು ಹೇಗೆ ನಿಯೋಜಿಸಬೇಕು ಎಂಬುದನ್ನು ನಾವು ತೋರಿಸುವ ಸರಣಿಯಲ್ಲಿ ಇದು ಮೂರನೇ ಪೋಸ್ಟ್ ಆಗಿದೆ.
ಹಿಂದಿನ ಎರಡು ಪೋಸ್ಟ್‌ಗಳಲ್ಲಿ, ಆಧುನಿಕ ವೆಬ್ ಅಪ್ಲಿಕೇಶನ್ಗಳನ್ನು ಕೆಲವೇ ಹಂತಗಳಲ್ಲಿ ಹೇಗೆ ನಿಯೋಜಿಸುವುದು ಮತ್ತು ಉತ್ಪಾದನಾ ನಿಯೋಜನೆಗಳನ್ನು ಆರ್ಕೆಸ್ಟ್ರೇಟ್ ಮಾಡಲು ಚೈನ್ಡ್ ಬಿಲ್ಡ್‌ಗಳನ್ನು ಬಳಸಿಕೊಂಡು NGINX ನಂತಹ ಆಫ್-ದಿ-ಶೆಲ್ಫ್ HTTP ಸರ್ವರ್ ಇಮೇಜ್‌ನೊಂದಿಗೆ ಹೊಸ S2I ಚಿತ್ರವನ್ನು ಹೇಗೆ ಬಳಸುವುದು ಎಂಬುದನ್ನು ನಾವು ತೋರಿಸಿದ್ದೇವೆ. .
ಓಪನ್‌ಶಿಫ್ಟ್ ಪ್ಲಾಟ್‌ಫಾರ್ಮ್‌ನಲ್ಲಿ ನಿಮ್ಮ ಅಪ್ಲಿಕೇಶನ್‌ಗಾಗಿ ಡೆವಲಪ್‌ಮೆಂಟ್ ಸರ್ವರ್ ಅನ್ನು ಹೇಗೆ ರನ್ ಮಾಡುವುದು ಮತ್ತು ಅದನ್ನು ಸ್ಥಳೀಯ ಫೈಲ್ ಸಿಸ್ಟಮ್‌ನೊಂದಿಗೆ ಸಿಂಕ್ರೊನೈಸ್ ಮಾಡುವುದು ಮತ್ತು ಓಪನ್‌ಶಿಫ್ಟ್ ಪೈಪ್‌ಲೈನ್‌ಗಳು ಯಾವುವು ಮತ್ತು ಲಿಂಕ್ ಮಾಡಿದ ಅಸೆಂಬ್ಲಿಗಳಿಗೆ ಪರ್ಯಾಯವಾಗಿ ಅವುಗಳನ್ನು ಹೇಗೆ ಬಳಸಬಹುದು ಎಂಬುದರ ಕುರಿತು ಇಂದು ನಾವು ತೋರಿಸುತ್ತೇವೆ.
ಅಭಿವೃದ್ಧಿ ಪರಿಸರವಾಗಿ OpenShift
ಅಭಿವೃದ್ಧಿ ಕೆಲಸದ ಹರಿವು
ಈಗಾಗಲೇ ಹೇಳಿದಂತೆ , ಆಧುನಿಕ ವೆಬ್ ಅಪ್ಲಿಕೇಶನ್‌ಗಳಿಗೆ ವಿಶಿಷ್ಟವಾದ ಅಭಿವೃದ್ಧಿ ಪ್ರಕ್ರಿಯೆಯು ಸ್ಥಳೀಯ ಫೈಲ್‌ಗಳಿಗೆ ಬದಲಾವಣೆಗಳನ್ನು ಟ್ರ್ಯಾಕ್ ಮಾಡುವ ಕೆಲವು ರೀತಿಯ "ಅಭಿವೃದ್ಧಿ ಸರ್ವರ್" ಆಗಿದೆ. ಅವು ಸಂಭವಿಸಿದಾಗ, ಅಪ್ಲಿಕೇಶನ್ ಬಿಲ್ಡ್ ಅನ್ನು ಪ್ರಚೋದಿಸಲಾಗುತ್ತದೆ ಮತ್ತು ನಂತರ ಅದನ್ನು ಬ್ರೌಸರ್‌ಗೆ ನವೀಕರಿಸಲಾಗುತ್ತದೆ.
ಹೆಚ್ಚಿನ ಆಧುನಿಕ ಚೌಕಟ್ಟುಗಳಲ್ಲಿ, ಅಂತಹ "ಅಭಿವೃದ್ಧಿ ಸರ್ವರ್" ಅನ್ನು ಅನುಗುಣವಾದ ಆಜ್ಞಾ ಸಾಲಿನ ಉಪಕರಣಗಳಲ್ಲಿ ನಿರ್ಮಿಸಲಾಗಿದೆ.
ಸ್ಥಳೀಯ ಉದಾಹರಣೆ
ಮೊದಲಿಗೆ, ಸ್ಥಳೀಯವಾಗಿ ಅಪ್ಲಿಕೇಶನ್ಗಳನ್ನು ಚಲಾಯಿಸುವಾಗ ಇದು ಹೇಗೆ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತದೆ ಎಂಬುದನ್ನು ನೋಡೋಣ. ಅಪ್ಲಿಕೇಶನ್ ಅನ್ನು ಉದಾಹರಣೆಯಾಗಿ ತೆಗೆದುಕೊಳ್ಳೋಣ ಹಿಂದಿನ ಲೇಖನಗಳಿಂದ, ಎಲ್ಲಾ ಇತರ ಆಧುನಿಕ ಚೌಕಟ್ಟುಗಳಲ್ಲಿ ಬಹುತೇಕ ಒಂದೇ ರೀತಿಯ ವರ್ಕ್‌ಫ್ಲೋ ಪರಿಕಲ್ಪನೆಗಳು ಅನ್ವಯಿಸುತ್ತವೆ.
ಆದ್ದರಿಂದ, ನಮ್ಮ ಪ್ರತಿಕ್ರಿಯೆಯ ಉದಾಹರಣೆಯಲ್ಲಿ "dev ಸರ್ವರ್" ಅನ್ನು ಪ್ರಾರಂಭಿಸಲು, ನಾವು ಈ ಕೆಳಗಿನ ಆಜ್ಞೆಯನ್ನು ನಮೂದಿಸುತ್ತೇವೆ:
$ npm run start
ನಂತರ ಟರ್ಮಿನಲ್ ವಿಂಡೋದಲ್ಲಿ ನಾವು ಈ ರೀತಿಯದನ್ನು ನೋಡುತ್ತೇವೆ:
ಮತ್ತು ನಮ್ಮ ಅಪ್ಲಿಕೇಶನ್ ಡೀಫಾಲ್ಟ್ ಬ್ರೌಸರ್‌ನಲ್ಲಿ ತೆರೆಯುತ್ತದೆ:
ಈಗ, ನಾವು ಫೈಲ್‌ಗೆ ಬದಲಾವಣೆಗಳನ್ನು ಮಾಡಿದರೆ, ಅಪ್ಲಿಕೇಶನ್ ಬ್ರೌಸರ್‌ನಲ್ಲಿ ನವೀಕರಿಸಬೇಕು.
ಸರಿ, ಸ್ಥಳೀಯ ಮೋಡ್‌ನಲ್ಲಿ ಅಭಿವೃದ್ಧಿಯೊಂದಿಗೆ ಎಲ್ಲವೂ ಸ್ಪಷ್ಟವಾಗಿದೆ, ಆದರೆ ಓಪನ್‌ಶಿಫ್ಟ್‌ನಲ್ಲಿ ಅದೇ ರೀತಿ ಸಾಧಿಸುವುದು ಹೇಗೆ?
OpenShift ನಲ್ಲಿ ಅಭಿವೃದ್ಧಿ ಸರ್ವರ್
ನೀವು ನೆನಪಿಸಿಕೊಂಡರೆ, ರಲ್ಲಿ , ನಾವು S2I ಚಿತ್ರದ ರನ್ ಹಂತ ಎಂದು ಕರೆಯುವುದನ್ನು ನೋಡಿದ್ದೇವೆ ಮತ್ತು ಡೀಫಾಲ್ಟ್ ಆಗಿ, ಸರ್ವ್ ಮಾಡ್ಯೂಲ್ ನಮ್ಮ ವೆಬ್ ಅಪ್ಲಿಕೇಶನ್‌ಗೆ ಸೇವೆ ಸಲ್ಲಿಸಲು ಕಾರಣವಾಗಿದೆ ಎಂದು ನೋಡಿದೆವು.
ಆದಾಗ್ಯೂ, ನೀವು ಹತ್ತಿರದಿಂದ ನೋಡಿದರೆ ಆ ಉದಾಹರಣೆಯಿಂದ, ಇದು $NPM_RUN ಪರಿಸರ ವೇರಿಯೇಬಲ್ ಅನ್ನು ಒಳಗೊಂಡಿದೆ, ಇದು ನಿಮ್ಮ ಆಜ್ಞೆಯನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸಲು ನಿಮಗೆ ಅನುಮತಿಸುತ್ತದೆ.
ಉದಾಹರಣೆಗೆ, ನಮ್ಮ ಅಪ್ಲಿಕೇಶನ್ ಅನ್ನು ನಿಯೋಜಿಸಲು ನಾವು ನೋಡ್‌ಶಿಫ್ಟ್ ಮಾಡ್ಯೂಲ್ ಅನ್ನು ಬಳಸಬಹುದು:
$ npx nodeshift --deploy.env NPM_RUN="yarn start" --dockerImage=nodeshift/ubi8-s2i-web-app
ಗಮನಿಸಿ: ಸಾಮಾನ್ಯ ಕಲ್ಪನೆಯನ್ನು ವಿವರಿಸಲು ಮೇಲಿನ ಉದಾಹರಣೆಯನ್ನು ಸಂಕ್ಷಿಪ್ತಗೊಳಿಸಲಾಗಿದೆ.
ಇಲ್ಲಿ ನಾವು NPM_RUN ಪರಿಸರ ವೇರಿಯೇಬಲ್ ಅನ್ನು ನಮ್ಮ ನಿಯೋಜನೆಗೆ ಸೇರಿಸಿದ್ದೇವೆ, ಇದು ನಮ್ಮ OpenShift ಪಾಡ್‌ನಲ್ಲಿ ರಿಯಾಕ್ಟ್ ಡೆವಲಪ್‌ಮೆಂಟ್ ಸರ್ವರ್ ಅನ್ನು ಪ್ರಾರಂಭಿಸುವ ನೂಲು ಪ್ರಾರಂಭ ಆಜ್ಞೆಯನ್ನು ಚಲಾಯಿಸಲು ರನ್ಟೈಮ್ ಅನ್ನು ಹೇಳುತ್ತದೆ.
ಚಾಲನೆಯಲ್ಲಿರುವ ಪಾಡ್‌ನ ಲಾಗ್ ಅನ್ನು ನೀವು ನೋಡಿದರೆ, ಅದು ಈ ರೀತಿ ಕಾಣುತ್ತದೆ:
ಸಹಜವಾಗಿ, ನಾವು ಸ್ಥಳೀಯ ಕೋಡ್ ಅನ್ನು ಕೋಡ್‌ನೊಂದಿಗೆ ಸಿಂಕ್ರೊನೈಸ್ ಮಾಡುವವರೆಗೆ ಇವೆಲ್ಲವೂ ಏನೂ ಆಗಿರುವುದಿಲ್ಲ, ಇದು ಬದಲಾವಣೆಗಳಿಗೆ ಸಹ ಮೇಲ್ವಿಚಾರಣೆ ಮಾಡುತ್ತದೆ, ಆದರೆ ರಿಮೋಟ್ ಸರ್ವರ್‌ನಲ್ಲಿ ವಾಸಿಸುತ್ತದೆ.
ರಿಮೋಟ್ ಮತ್ತು ಸ್ಥಳೀಯ ಕೋಡ್ ಅನ್ನು ಸಿಂಕ್ರೊನೈಸ್ ಮಾಡುವುದು
ಅದೃಷ್ಟವಶಾತ್, ನೋಡ್‌ಶಿಫ್ಟ್ ಸಿಂಕ್ರೊನೈಸೇಶನ್‌ಗೆ ಸುಲಭವಾಗಿ ಸಹಾಯ ಮಾಡುತ್ತದೆ ಮತ್ತು ಬದಲಾವಣೆಗಳನ್ನು ಟ್ರ್ಯಾಕ್ ಮಾಡಲು ನೀವು ವಾಚ್ ಆಜ್ಞೆಯನ್ನು ಬಳಸಬಹುದು.
ಆದ್ದರಿಂದ ನಮ್ಮ ಅಪ್ಲಿಕೇಶನ್‌ಗಾಗಿ ಅಭಿವೃದ್ಧಿ ಸರ್ವರ್ ಅನ್ನು ನಿಯೋಜಿಸಲು ನಾವು ಆಜ್ಞೆಯನ್ನು ಚಲಾಯಿಸಿದ ನಂತರ, ನಾವು ಈ ಕೆಳಗಿನ ಆಜ್ಞೆಯನ್ನು ಸುರಕ್ಷಿತವಾಗಿ ಬಳಸಬಹುದು:
$ npx nodeshift watch
ಪರಿಣಾಮವಾಗಿ, ನಾವು ಸ್ವಲ್ಪ ಮುಂಚಿತವಾಗಿ ರಚಿಸಿದ ಚಾಲನೆಯಲ್ಲಿರುವ ಪಾಡ್‌ಗೆ ಸಂಪರ್ಕವನ್ನು ಮಾಡಲಾಗುವುದು, ರಿಮೋಟ್ ಕ್ಲಸ್ಟರ್‌ನೊಂದಿಗೆ ನಮ್ಮ ಸ್ಥಳೀಯ ಫೈಲ್‌ಗಳ ಸಿಂಕ್ರೊನೈಸೇಶನ್ ಅನ್ನು ಸಕ್ರಿಯಗೊಳಿಸಲಾಗುತ್ತದೆ ಮತ್ತು ನಮ್ಮ ಸ್ಥಳೀಯ ಸಿಸ್ಟಮ್‌ನಲ್ಲಿರುವ ಫೈಲ್‌ಗಳು ಬದಲಾವಣೆಗಳಿಗಾಗಿ ಮೇಲ್ವಿಚಾರಣೆ ಮಾಡಲು ಪ್ರಾರಂಭಿಸುತ್ತವೆ.
ಆದ್ದರಿಂದ, ನಾವು ಈಗ src/App.js ಫೈಲ್ ಅನ್ನು ನವೀಕರಿಸಿದರೆ, ಸಿಸ್ಟಮ್ ಈ ಬದಲಾವಣೆಗಳಿಗೆ ಪ್ರತಿಕ್ರಿಯಿಸುತ್ತದೆ, ಅವುಗಳನ್ನು ರಿಮೋಟ್ ಕ್ಲಸ್ಟರ್‌ಗೆ ನಕಲಿಸಿ ಮತ್ತು ಅಭಿವೃದ್ಧಿ ಸರ್ವರ್ ಅನ್ನು ಪ್ರಾರಂಭಿಸುತ್ತದೆ, ಅದು ನಂತರ ಬ್ರೌಸರ್‌ನಲ್ಲಿ ನಮ್ಮ ಅಪ್ಲಿಕೇಶನ್ ಅನ್ನು ನವೀಕರಿಸುತ್ತದೆ.
ಚಿತ್ರವನ್ನು ಪೂರ್ಣಗೊಳಿಸಲು, ಈ ಸಂಪೂರ್ಣ ಆಜ್ಞೆಗಳು ಹೇಗಿವೆ ಎಂಬುದನ್ನು ತೋರಿಸೋಣ:
$ npx nodeshift --strictSSL=false --dockerImage=nodeshift/ubi8-s2i-web-app --build.env YARN_ENABLED=true --expose --deploy.env NPM_RUN="yarn start" --deploy.port 3000
$ npx nodeshift watch --strictSSL=false
ವಾಚ್ ಆಜ್ಞೆಯು oc rsync ಆಜ್ಞೆಯ ಮೇಲಿನ ಅಮೂರ್ತವಾಗಿದೆ, ಅದು ಹೇಗೆ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತದೆ ಎಂಬುದರ ಕುರಿತು ನೀವು ಇನ್ನಷ್ಟು ತಿಳಿದುಕೊಳ್ಳಬಹುದು .
ಇದು ರಿಯಾಕ್ಟ್‌ಗೆ ಒಂದು ಉದಾಹರಣೆಯಾಗಿದೆ, ಆದರೆ ನಿಖರವಾದ ಅದೇ ವಿಧಾನವನ್ನು ಇತರ ಫ್ರೇಮ್‌ವರ್ಕ್‌ಗಳೊಂದಿಗೆ ಬಳಸಬಹುದು, ಅಗತ್ಯವಿರುವಂತೆ NPM_RUN ಪರಿಸರ ವೇರಿಯೇಬಲ್ ಅನ್ನು ಹೊಂದಿಸಿ.
ಓಪನ್‌ಶಿಫ್ಟ್ ಪೈಪ್‌ಲೈನ್‌ಗಳು
ಮುಂದೆ ನಾವು ಓಪನ್‌ಶಿಫ್ಟ್ ಪೈಪ್‌ಲೈನ್‌ಗಳಂತಹ ಉಪಕರಣದ ಬಗ್ಗೆ ಮಾತನಾಡುತ್ತೇವೆ ಮತ್ತು ಚೈನ್ಡ್ ಬಿಲ್ಡ್‌ಗಳಿಗೆ ಪರ್ಯಾಯವಾಗಿ ಅದನ್ನು ಹೇಗೆ ಬಳಸಬಹುದು.
ಓಪನ್‌ಶಿಫ್ಟ್ ಪೈಪ್‌ಲೈನ್‌ಗಳು ಯಾವುವು
ಓಪನ್‌ಶಿಫ್ಟ್ ಪೈಪ್‌ಲೈನ್‌ಗಳು ಕ್ಲೌಡ್-ಸ್ಥಳೀಯ CI/CD ನಿರಂತರ ಏಕೀಕರಣ ಮತ್ತು ಟೆಕ್ಟಾನ್ ಬಳಸಿಕೊಂಡು ಪೈಪ್‌ಲೈನ್‌ಗಳನ್ನು ಸಂಘಟಿಸಲು ವಿನ್ಯಾಸಗೊಳಿಸಲಾದ ವಿತರಣಾ ವ್ಯವಸ್ಥೆಯಾಗಿದೆ. ಟೆಕ್ಟಾನ್ ಒಂದು ಹೊಂದಿಕೊಳ್ಳುವ ಮುಕ್ತ-ಮೂಲ ಕುಬರ್ನೆಟ್ಸ್-ಸ್ಥಳೀಯ CI/CD ಫ್ರೇಮ್‌ವರ್ಕ್ ಆಗಿದ್ದು ಅದು ಆಧಾರವಾಗಿರುವ ಲೇಯರ್‌ನಿಂದ ಅಮೂರ್ತಗೊಳಿಸುವ ಮೂಲಕ ವಿವಿಧ ಪ್ಲಾಟ್‌ಫಾರ್ಮ್‌ಗಳಲ್ಲಿ (ಕುಬರ್ನೆಟ್ಸ್, ಸರ್ವರ್‌ಲೆಸ್, ವರ್ಚುವಲ್ ಯಂತ್ರಗಳು, ಇತ್ಯಾದಿ) ನಿಯೋಜನೆಯನ್ನು ಸ್ವಯಂಚಾಲಿತಗೊಳಿಸಲು ನಿಮಗೆ ಅನುಮತಿಸುತ್ತದೆ.
ಈ ಲೇಖನವನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳಲು ಪೈಪ್ಲೈನ್ಗಳ ಬಗ್ಗೆ ಸ್ವಲ್ಪ ಜ್ಞಾನದ ಅಗತ್ಯವಿದೆ, ಆದ್ದರಿಂದ ನೀವು ಮೊದಲು ಓದಬೇಕೆಂದು ನಾವು ಬಲವಾಗಿ ಶಿಫಾರಸು ಮಾಡುತ್ತೇವೆ .
ನಿಮ್ಮ ಕೆಲಸದ ವಾತಾವರಣವನ್ನು ಹೊಂದಿಸುವುದು
ಈ ಲೇಖನದ ಉದಾಹರಣೆಗಳೊಂದಿಗೆ ಆಡಲು, ನೀವು ಮೊದಲು ನಿಮ್ಮ ಕೆಲಸದ ವಾತಾವರಣವನ್ನು ಸಿದ್ಧಪಡಿಸಬೇಕು:
- OpenShift 4 ಕ್ಲಸ್ಟರ್ ಅನ್ನು ಸ್ಥಾಪಿಸಿ ಮತ್ತು ಕಾನ್ಫಿಗರ್ ಮಾಡಿ. ನಮ್ಮ ಉದಾಹರಣೆಗಳು ಇದಕ್ಕಾಗಿ CodeReady ಕಂಟೈನರ್‌ಗಳನ್ನು (CRD) ಬಳಸುತ್ತವೆ, ಇದಕ್ಕಾಗಿ ಅನುಸ್ಥಾಪನಾ ಸೂಚನೆಗಳನ್ನು ಕಾಣಬಹುದು .
- ಕ್ಲಸ್ಟರ್ ಸಿದ್ಧವಾದ ನಂತರ, ನೀವು ಅದರ ಮೇಲೆ ಪೈಪ್ಲೈನ್ ಆಪರೇಟರ್ ಅನ್ನು ಸ್ಥಾಪಿಸಬೇಕು. ಹಿಂಜರಿಯದಿರಿ, ಇದು ಸುಲಭ, ಅನುಸ್ಥಾಪನಾ ಸೂಚನೆಗಳು .
- ಡೌನ್ಲೋಡ್ (ಟಿಕೆಎನ್) .
- ನೀವು ನಂತರ ನಿಯೋಜಿಸುವ ಅಪ್ಲಿಕೇಶನ್ ಅನ್ನು ರಚಿಸಲು create-react-app ಕಮಾಂಡ್ ಲೈನ್ ಉಪಕರಣವನ್ನು ರನ್ ಮಾಡಿ (ಇದು ಸರಳವಾದ ಅಪ್ಲಿಕೇಶನ್ ಆಗಿದೆ ).
- (ಐಚ್ಛಿಕ) npm ಸ್ಥಾಪನೆಯೊಂದಿಗೆ ಸ್ಥಳೀಯವಾಗಿ ಉದಾಹರಣೆ ಅಪ್ಲಿಕೇಶನ್ ಅನ್ನು ರನ್ ಮಾಡಲು ರೆಪೊಸಿಟರಿಯನ್ನು ಕ್ಲೋನ್ ಮಾಡಿ ಮತ್ತು ನಂತರ npm ಪ್ರಾರಂಭ.
ಅಪ್ಲಿಕೇಶನ್ ರೆಪೊಸಿಟರಿಯು k8s ಫೋಲ್ಡರ್ ಅನ್ನು ಸಹ ಹೊಂದಿರುತ್ತದೆ, ಇದು ಅಪ್ಲಿಕೇಶನ್ ಅನ್ನು ನಿಯೋಜಿಸಲು ಬಳಸುವ Kubernetes/OpenShift YAML ಗಳನ್ನು ಹೊಂದಿರುತ್ತದೆ. ಇದರಲ್ಲಿ ನಾವು ರಚಿಸುವ ಕಾರ್ಯಗಳು, ಕ್ಲಸ್ಟರ್‌ಟಾಸ್ಕ್‌ಗಳು, ಸಂಪನ್ಮೂಲಗಳು ಮತ್ತು ಪೈಪ್‌ಲೈನ್‌ಗಳು ಇರುತ್ತವೆ .
ನಾವೀಗ ಆರಂಭಿಸೋಣ
ಓಪನ್‌ಶಿಫ್ಟ್ ಕ್ಲಸ್ಟರ್‌ನಲ್ಲಿ ಹೊಸ ಯೋಜನೆಯನ್ನು ರಚಿಸುವುದು ನಮ್ಮ ಉದಾಹರಣೆಯ ಮೊದಲ ಹಂತವಾಗಿದೆ. ಈ ಯೋಜನೆಯನ್ನು ವೆಬ್‌ಅಪ್-ಪೈಪ್ಲೈನ್ ಎಂದು ಕರೆಯೋಣ ಮತ್ತು ಈ ಕೆಳಗಿನ ಆಜ್ಞೆಯೊಂದಿಗೆ ಅದನ್ನು ರಚಿಸೋಣ:
$ oc new-project webapp-pipeline
ಈ ಯೋಜನೆಯ ಹೆಸರು ನಂತರ ಕೋಡ್‌ನಲ್ಲಿ ಗೋಚರಿಸುತ್ತದೆ, ಆದ್ದರಿಂದ ನೀವು ಬೇರೆ ಯಾವುದನ್ನಾದರೂ ಹೆಸರಿಸಲು ನಿರ್ಧರಿಸಿದರೆ, ಅದಕ್ಕೆ ಅನುಗುಣವಾಗಿ ಉದಾಹರಣೆ ಕೋಡ್ ಅನ್ನು ಸಂಪಾದಿಸಲು ಮರೆಯಬೇಡಿ. ಈ ಹಂತದಿಂದ ಪ್ರಾರಂಭಿಸಿ, ನಾವು ಮೇಲಿನಿಂದ ಕೆಳಕ್ಕೆ ಹೋಗುವುದಿಲ್ಲ, ಆದರೆ ಕೆಳಗಿನಿಂದ ಮೇಲಕ್ಕೆ ಹೋಗುತ್ತೇವೆ: ಅಂದರೆ, ನಾವು ಮೊದಲು ಕನ್ವೇಯರ್ನ ಎಲ್ಲಾ ಘಟಕಗಳನ್ನು ರಚಿಸುತ್ತೇವೆ ಮತ್ತು ನಂತರ ಮಾತ್ರ ಕನ್ವೇಯರ್ ಸ್ವತಃ.
ಆದ್ದರಿಂದ, ಮೊದಲನೆಯದಾಗಿ ...
ಕಾರ್ಯಗಳು
ನಾವು ಒಂದೆರಡು ಕಾರ್ಯಗಳನ್ನು ರಚಿಸೋಣ, ಅದು ನಮ್ಮ ಪೈಪ್‌ಲೈನ್‌ನಲ್ಲಿ ಅಪ್ಲಿಕೇಶನ್ ಅನ್ನು ನಿಯೋಜಿಸಲು ಸಹಾಯ ಮಾಡುತ್ತದೆ. ಮೊದಲ ಕಾರ್ಯ - apply_manifests_task - ನಮ್ಮ ಅಪ್ಲಿಕೇಶನ್‌ನ k8s ಫೋಲ್ಡರ್‌ನಲ್ಲಿರುವ ಆ ಕುಬರ್ನೆಟ್ಸ್ ಸಂಪನ್ಮೂಲಗಳ (ಸೇವೆ, ನಿಯೋಜನೆ ಮತ್ತು ಮಾರ್ಗ) YAML ಅನ್ನು ಅನ್ವಯಿಸುವ ಜವಾಬ್ದಾರಿಯನ್ನು ಹೊಂದಿದೆ. ಎರಡನೇ ಕಾರ್ಯ - update_deployment_task - ನಮ್ಮ ಪೈಪ್‌ಲೈನ್‌ನಿಂದ ರಚಿಸಲಾದ ಚಿತ್ರಕ್ಕೆ ಈಗಾಗಲೇ ನಿಯೋಜಿಸಲಾದ ಚಿತ್ರವನ್ನು ನವೀಕರಿಸಲು ಕಾರಣವಾಗಿದೆ.
ಇದು ಇನ್ನೂ ಸ್ಪಷ್ಟವಾಗಿಲ್ಲದಿದ್ದರೆ ಚಿಂತಿಸಬೇಡಿ. ವಾಸ್ತವವಾಗಿ, ಈ ಕಾರ್ಯಗಳು ಉಪಯುಕ್ತತೆಗಳಂತೆಯೇ ಇರುತ್ತವೆ ಮತ್ತು ಸ್ವಲ್ಪ ಸಮಯದ ನಂತರ ನಾವು ಅವುಗಳನ್ನು ಹೆಚ್ಚು ವಿವರವಾಗಿ ನೋಡುತ್ತೇವೆ. ಸದ್ಯಕ್ಕೆ, ಅವುಗಳನ್ನು ರಚಿಸೋಣ:
$ oc create -f https://raw.githubusercontent.com/nodeshift/webapp-pipeline-tutorial/master/tasks/update_deployment_task.yaml
$ oc create -f https://raw.githubusercontent.com/nodeshift/webapp-pipeline-tutorial/master/tasks/apply_manifests_task.yaml
ನಂತರ, tkn CLI ಆಜ್ಞೆಯನ್ನು ಬಳಸಿ, ಕಾರ್ಯಗಳನ್ನು ರಚಿಸಲಾಗಿದೆಯೇ ಎಂದು ನಾವು ಪರಿಶೀಲಿಸುತ್ತೇವೆ:
$ tkn task ls
NAME AGE
apply-manifests 1 minute ago
update-deployment 1 minute ago
ಗಮನಿಸಿ: ಇವುಗಳು ನಿಮ್ಮ ಪ್ರಸ್ತುತ ಪ್ರಾಜೆಕ್ಟ್‌ಗಾಗಿ ಸ್ಥಳೀಯ ಕಾರ್ಯಗಳಾಗಿವೆ.
ಕ್ಲಸ್ಟರ್ ಕಾರ್ಯಗಳು
ಕ್ಲಸ್ಟರ್ ಕಾರ್ಯಗಳು ಮೂಲತಃ ಸರಳ ಕಾರ್ಯಗಳಂತೆಯೇ ಇರುತ್ತವೆ. ಅಂದರೆ, ಇದು ಒಂದು ನಿರ್ದಿಷ್ಟ ಕಾರ್ಯವನ್ನು ನಡೆಸುವಾಗ ಒಂದು ರೀತಿಯಲ್ಲಿ ಅಥವಾ ಇನ್ನೊಂದರಲ್ಲಿ ಸಂಯೋಜಿಸಲ್ಪಟ್ಟ ಹಂತಗಳ ಮರುಬಳಕೆಯ ಸಂಗ್ರಹವಾಗಿದೆ. ವ್ಯತ್ಯಾಸವೆಂದರೆ ಕ್ಲಸ್ಟರ್ ಕಾರ್ಯವು ಕ್ಲಸ್ಟರ್‌ನಲ್ಲಿ ಎಲ್ಲೆಡೆ ಲಭ್ಯವಿದೆ. ಪೈಪ್ಲೈನ್ ಆಪರೇಟರ್ ಅನ್ನು ಸೇರಿಸುವಾಗ ಸ್ವಯಂಚಾಲಿತವಾಗಿ ರಚಿಸಲಾದ ಕ್ಲಸ್ಟರ್ ಕಾರ್ಯಗಳ ಪಟ್ಟಿಯನ್ನು ನೋಡಲು, ನಾವು ಮತ್ತೆ tkn CLI ಆಜ್ಞೆಯನ್ನು ಬಳಸುತ್ತೇವೆ:
$ tkn clustertask ls
NAME AGE
buildah 1 day ago
buildah-v0-10-0 1 day ago
jib-maven 1 day ago
kn 1 day ago
maven 1 day ago
openshift-client 1 day ago
openshift-client-v0-10-0 1 day ago
s2i 1 day ago
s2i-go 1 day ago
s2i-go-v0-10-0 1 day ago
s2i-java-11 1 day ago
s2i-java-11-v0-10-0 1 day ago
s2i-java-8 1 day ago
s2i-java-8-v0-10-0 1 day ago
s2i-nodejs 1 day ago
s2i-nodejs-v0-10-0 1 day ago
s2i-perl 1 day ago
s2i-perl-v0-10-0 1 day ago
s2i-php 1 day ago
s2i-php-v0-10-0 1 day ago
s2i-python-3 1 day ago
s2i-python-3-v0-10-0 1 day ago
s2i-ruby 1 day ago
s2i-ruby-v0-10-0 1 day ago
s2i-v0-10-0 1 day ago
ಈಗ ಎರಡು ಕ್ಲಸ್ಟರ್ ಕಾರ್ಯಗಳನ್ನು ರಚಿಸೋಣ. ಮೊದಲನೆಯದು S2I ಚಿತ್ರವನ್ನು ರಚಿಸುತ್ತದೆ ಮತ್ತು ಅದನ್ನು ಆಂತರಿಕ OpenShift ನೋಂದಾವಣೆಗೆ ಕಳುಹಿಸುತ್ತದೆ; ಎರಡನೆಯದು, ನಾವು ಈಗಾಗಲೇ ವಿಷಯವಾಗಿ ನಿರ್ಮಿಸಿದ ಅಪ್ಲಿಕೇಶನ್ ಅನ್ನು ಬಳಸಿಕೊಂಡು NGINX ಅನ್ನು ಆಧರಿಸಿ ನಮ್ಮ ಚಿತ್ರವನ್ನು ನಿರ್ಮಿಸುವುದು.
ಚಿತ್ರವನ್ನು ರಚಿಸಿ ಮತ್ತು ಕಳುಹಿಸಿ
ಮೊದಲ ಕಾರ್ಯವನ್ನು ರಚಿಸುವಾಗ, ಲಿಂಕ್ ಮಾಡಲಾದ ಅಸೆಂಬ್ಲಿಗಳ ಬಗ್ಗೆ ಹಿಂದಿನ ಲೇಖನದಲ್ಲಿ ನಾವು ಈಗಾಗಲೇ ಮಾಡಿದ್ದನ್ನು ನಾವು ಪುನರಾವರ್ತಿಸುತ್ತೇವೆ. ನಮ್ಮ ಅಪ್ಲಿಕೇಶನ್ ಅನ್ನು "ಬಿಲ್ಡ್" ಮಾಡಲು ನಾವು S2I ಇಮೇಜ್ ಅನ್ನು (ubi8-s2i-web-app) ಬಳಸಿದ್ದೇವೆ ಮತ್ತು OpenShift ಆಂತರಿಕ ನೋಂದಾವಣೆಯಲ್ಲಿ ಸಂಗ್ರಹವಾಗಿರುವ ಚಿತ್ರದೊಂದಿಗೆ ಕೊನೆಗೊಂಡಿದ್ದೇವೆ ಎಂಬುದನ್ನು ನೆನಪಿಸಿಕೊಳ್ಳಿ. ಈಗ ನಾವು ನಮ್ಮ ಅಪ್ಲಿಕೇಶನ್‌ಗಾಗಿ ಡಾಕರ್‌ಫೈಲ್ ಅನ್ನು ರಚಿಸಲು ಈ S2I ವೆಬ್ ಅಪ್ಲಿಕೇಶನ್ ಚಿತ್ರವನ್ನು ಬಳಸುತ್ತೇವೆ ಮತ್ತು ನಂತರ ನಿಜವಾದ ನಿರ್ಮಾಣವನ್ನು ಮಾಡಲು Buildah ಅನ್ನು ಬಳಸುತ್ತೇವೆ ಮತ್ತು ಫಲಿತಾಂಶದ ಚಿತ್ರವನ್ನು OpenShift ಆಂತರಿಕ ನೋಂದಾವಣೆಗೆ ತಳ್ಳುತ್ತೇವೆ, ಏಕೆಂದರೆ ನೀವು NodeShift ಬಳಸಿಕೊಂಡು ನಿಮ್ಮ ಅಪ್ಲಿಕೇಶನ್ಗಳನ್ನು ನಿಯೋಜಿಸಿದಾಗ OpenShift ನಿಖರವಾಗಿ ಏನು ಮಾಡುತ್ತದೆ .
ಇದೆಲ್ಲ ನಮಗೆ ಹೇಗೆ ಗೊತ್ತಾಯಿತು, ನೀವು ಕೇಳುತ್ತೀರಾ? ಇಂದ , ನಾವು ಅದನ್ನು ನಕಲಿಸಿದ್ದೇವೆ ಮತ್ತು ಅದನ್ನು ನಮಗಾಗಿ ಮಾರ್ಪಡಿಸಿದ್ದೇವೆ.
ಆದ್ದರಿಂದ, ಈಗ ನಾವು s2i-web-app ಕ್ಲಸ್ಟರ್ ಕಾರ್ಯವನ್ನು ರಚಿಸೋಣ:
$ oc create -f https://raw.githubusercontent.com/nodeshift/webapp-pipeline-tutorial/master/clustertasks/s2i-web-app-task.yaml
ನಾವು ಇದನ್ನು ವಿವರವಾಗಿ ವಿಶ್ಲೇಷಿಸುವುದಿಲ್ಲ, ಆದರೆ OUTPUT_DIR ಪ್ಯಾರಾಮೀಟರ್ ಮೇಲೆ ಮಾತ್ರ ಕೇಂದ್ರೀಕರಿಸುತ್ತೇವೆ:
params:
- name: OUTPUT_DIR
description: The location of the build output directory
default: build
ಪೂರ್ವನಿಯೋಜಿತವಾಗಿ, ಈ ಪ್ಯಾರಾಮೀಟರ್ ನಿರ್ಮಿಸಲು ಸಮನಾಗಿರುತ್ತದೆ, ಅಲ್ಲಿ ರಿಯಾಕ್ಟ್ ಜೋಡಿಸಲಾದ ವಿಷಯವನ್ನು ಇರಿಸುತ್ತದೆ. ಇತರ ಚೌಕಟ್ಟುಗಳು ವಿಭಿನ್ನ ಮಾರ್ಗಗಳನ್ನು ಬಳಸುತ್ತವೆ, ಉದಾಹರಣೆಗೆ, ಎಂಬರ್ನಲ್ಲಿ ಇದು ದೂರವಾಗಿದೆ. ನಮ್ಮ ಮೊದಲ ಕ್ಲಸ್ಟರ್ ಕಾರ್ಯದ ಔಟ್ಪುಟ್ ನಾವು ಸಂಗ್ರಹಿಸಿದ HTML, JavaScript ಮತ್ತು CSS ಅನ್ನು ಒಳಗೊಂಡಿರುವ ಚಿತ್ರವಾಗಿರುತ್ತದೆ.
NGINX ಆಧರಿಸಿ ಚಿತ್ರವನ್ನು ನಿರ್ಮಿಸಿ
ನಮ್ಮ ಎರಡನೇ ಕ್ಲಸ್ಟರ್ ಕಾರ್ಯಕ್ಕೆ ಸಂಬಂಧಿಸಿದಂತೆ, ನಾವು ಈಗಾಗಲೇ ನಿರ್ಮಿಸಿದ ಅಪ್ಲಿಕೇಶನ್‌ನ ವಿಷಯವನ್ನು ಬಳಸಿಕೊಂಡು ಅದು ನಮಗಾಗಿ NGINX-ಆಧಾರಿತ ಚಿತ್ರವನ್ನು ನಿರ್ಮಿಸಬೇಕು. ಮೂಲಭೂತವಾಗಿ, ನಾವು ಚೈನ್ಡ್ ಬಿಲ್ಡ್‌ಗಳನ್ನು ನೋಡಿದ ಹಿಂದಿನ ವಿಭಾಗದ ಭಾಗವಾಗಿದೆ.
ಇದನ್ನು ಮಾಡಲು, ನಾವು - ಮೇಲಿನಂತೆಯೇ - ಕ್ಲಸ್ಟರ್ ಟಾಸ್ಕ್ ವೆಬ್‌ಅಪ್-ಬಿಲ್ಡ್-ರನ್ಟೈಮ್ ಅನ್ನು ರಚಿಸುತ್ತೇವೆ:
$ oc create -f https://raw.githubusercontent.com/nodeshift/webapp-pipeline-tutorial/master/clustertasks/webapp-build-runtime-task.yaml
ಈ ಕ್ಲಸ್ಟರ್ ಕಾರ್ಯಗಳ ಕೋಡ್ ಅನ್ನು ನೀವು ನೋಡಿದರೆ, ಅದು ನಾವು ಕೆಲಸ ಮಾಡುತ್ತಿರುವ Git ರೆಪೊಸಿಟರಿಯನ್ನು ಅಥವಾ ನಾವು ರಚಿಸುತ್ತಿರುವ ಚಿತ್ರಗಳ ಹೆಸರನ್ನು ನಿರ್ದಿಷ್ಟಪಡಿಸುವುದಿಲ್ಲ ಎಂದು ನೀವು ನೋಡಬಹುದು. ನಾವು Git ಗೆ ನಿಖರವಾಗಿ ಏನನ್ನು ವರ್ಗಾಯಿಸುತ್ತಿದ್ದೇವೆ ಅಥವಾ ಅಂತಿಮ ಚಿತ್ರವು ಔಟ್ಪುಟ್ ಆಗಬೇಕಾದ ನಿರ್ದಿಷ್ಟ ಚಿತ್ರವನ್ನು ಮಾತ್ರ ನಾವು ನಿರ್ದಿಷ್ಟಪಡಿಸುತ್ತೇವೆ. ಅದಕ್ಕಾಗಿಯೇ ಇತರ ಅಪ್ಲಿಕೇಶನ್‌ಗಳೊಂದಿಗೆ ಕೆಲಸ ಮಾಡುವಾಗ ಈ ಕ್ಲಸ್ಟರ್ ಕಾರ್ಯಗಳನ್ನು ಮರುಬಳಕೆ ಮಾಡಬಹುದು.
ಮತ್ತು ಇಲ್ಲಿ ನಾವು ಆಕರ್ಷಕವಾಗಿ ಮುಂದಿನ ಹಂತಕ್ಕೆ ಹೋಗುತ್ತೇವೆ ...
ಸಂಪನ್ಮೂಲಗಳು
ಆದ್ದರಿಂದ, ನಾವು ಹೇಳಿದಂತೆ, ಕ್ಲಸ್ಟರ್ ಕಾರ್ಯಗಳು ಸಾಧ್ಯವಾದಷ್ಟು ಸಾಮಾನ್ಯವಾಗಿರಬೇಕು, ನಾವು ಸಂಪನ್ಮೂಲಗಳನ್ನು ರಚಿಸಬೇಕಾಗಿದೆ, ಅದನ್ನು ಇನ್‌ಪುಟ್ (Git ರೆಪೊಸಿಟರಿ) ಮತ್ತು ಔಟ್ಪುಟ್ (ಅಂತಿಮ ಚಿತ್ರಗಳು) ಆಗಿ ಬಳಸಲಾಗುತ್ತದೆ. ನಮಗೆ ಅಗತ್ಯವಿರುವ ಮೊದಲ ಸಂಪನ್ಮೂಲವೆಂದರೆ Git, ಅಲ್ಲಿ ನಮ್ಮ ಅಪ್ಲಿಕೇಶನ್ ವಾಸಿಸುತ್ತದೆ, ಈ ರೀತಿಯದ್ದು:
# This resource is the location of the git repo with the web application source
apiVersion: tekton.dev/v1alpha1
kind: PipelineResource
metadata:
name: web-application-repo
spec:
type: git
params:
- name: url
value: https://github.com/nodeshift-starters/react-pipeline-example
- name: revision
value: master
ಇಲ್ಲಿ ಪೈಪ್ಲೈನ್ ರಿಸೋರ್ಸ್ ಗಿಟ್ ಪ್ರಕಾರವಾಗಿದೆ. ಪ್ಯಾರಮ್ಸ್ ವಿಭಾಗದಲ್ಲಿನ url ಕೀ ನಿರ್ದಿಷ್ಟ ರೆಪೊಸಿಟರಿಯನ್ನು ಸೂಚಿಸುತ್ತದೆ ಮತ್ತು ಮಾಸ್ಟರ್ ಶಾಖೆಯನ್ನು ನಿರ್ದಿಷ್ಟಪಡಿಸುತ್ತದೆ (ಇದು ಐಚ್ಛಿಕವಾಗಿದೆ, ಆದರೆ ನಾವು ಅದನ್ನು ಸಂಪೂರ್ಣತೆಗಾಗಿ ಬರೆಯುತ್ತೇವೆ).
ಈಗ ನಾವು s2i-web-app ಕಾರ್ಯದ ಫಲಿತಾಂಶಗಳನ್ನು ಉಳಿಸುವ ಚಿತ್ರಕ್ಕಾಗಿ ಸಂಪನ್ಮೂಲವನ್ನು ರಚಿಸಬೇಕಾಗಿದೆ, ಇದನ್ನು ಈ ರೀತಿ ಮಾಡಲಾಗುತ್ತದೆ:
# This resource is the result of running "npm run build", the resulting built files will be located in /opt/app-root/output
apiVersion: tekton.dev/v1alpha1
kind: PipelineResource
metadata:
name: built-web-application-image
spec:
type: image
params:
- name: url
value: image-registry.openshift-image-registry.svc:5000/webapp-pipeline/built-web-application:latest
ಇಲ್ಲಿ ಪೈಪ್ಲೈನ್ ರಿಸೋರ್ಸ್ ಟೈಪ್ ಇಮೇಜ್ ಆಗಿದೆ, ಮತ್ತು url ಪ್ಯಾರಾಮೀಟರ್‌ನ ಮೌಲ್ಯವು ಆಂತರಿಕ ಓಪನ್‌ಶಿಫ್ಟ್ ಇಮೇಜ್ ರಿಜಿಸ್ಟ್ರಿಗೆ ಸೂಚಿಸುತ್ತದೆ, ನಿರ್ದಿಷ್ಟವಾಗಿ ವೆಬ್‌ಅಪ್-ಪೈಪ್ಲೈನ್ ನೇಮ್‌ಸ್ಪೇಸ್‌ನಲ್ಲಿದೆ. ನೀವು ಬೇರೆ ನೇಮ್‌ಸ್ಪೇಸ್ ಬಳಸುತ್ತಿದ್ದರೆ ಈ ಸೆಟ್ಟಿಂಗ್ ಅನ್ನು ಬದಲಾಯಿಸಲು ಮರೆಯಬೇಡಿ.
ಮತ್ತು ಅಂತಿಮವಾಗಿ, ನಮಗೆ ಅಗತ್ಯವಿರುವ ಕೊನೆಯ ಸಂಪನ್ಮೂಲವು ಟೈಪ್ ಇಮೇಜ್ ಆಗಿರುತ್ತದೆ ಮತ್ತು ಇದು ಅಂತಿಮ ಎನ್‌ಜಿಎನ್‌ಎಕ್ಸ್ ಇಮೇಜ್ ಆಗಿದ್ದು ಅದನ್ನು ನಿಯೋಜನೆಯ ಸಮಯದಲ್ಲಿ ಬಳಸಲಾಗುತ್ತದೆ:
# This resource is the image that will be just the static html, css, js files being run with nginx
apiVersion: tekton.dev/v1alpha1
kind: PipelineResource
metadata:
name: runtime-web-application-image
spec:
type: image
params:
- name: url
value: image-registry.openshift-image-registry.svc:5000/webapp-pipeline/runtime-web-application:latest
ಮತ್ತೊಮ್ಮೆ, ಈ ಸಂಪನ್ಮೂಲವು ವೆಬ್‌ಅಪ್-ಪೈಪ್ಲೈನ್ ನೇಮ್‌ಸ್ಪೇಸ್‌ನಲ್ಲಿ ಆಂತರಿಕ ಓಪನ್‌ಶಿಫ್ಟ್ ರಿಜಿಸ್ಟ್ರಿಯಲ್ಲಿ ಚಿತ್ರವನ್ನು ಸಂಗ್ರಹಿಸುತ್ತದೆ ಎಂಬುದನ್ನು ಗಮನಿಸಿ.
ಈ ಎಲ್ಲಾ ಸಂಪನ್ಮೂಲಗಳನ್ನು ಏಕಕಾಲದಲ್ಲಿ ರಚಿಸಲು, ನಾವು ರಚಿಸು ಆಜ್ಞೆಯನ್ನು ಬಳಸುತ್ತೇವೆ:
$ oc create -f https://raw.githubusercontent.com/nodeshift/webapp-pipeline-tutorial/master/resources/resource.yaml
ಸಂಪನ್ಮೂಲಗಳನ್ನು ಈ ರೀತಿ ರಚಿಸಲಾಗಿದೆ ಎಂದು ನೀವು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಬಹುದು:
$ tkn resource ls
ಕನ್ವೇಯರ್ ಪೈಪ್ಲೈನ್
ಈಗ ನಾವು ಅಗತ್ಯವಿರುವ ಎಲ್ಲಾ ಘಟಕಗಳನ್ನು ಹೊಂದಿದ್ದೇವೆ, ಕೆಳಗಿನ ಆಜ್ಞೆಯೊಂದಿಗೆ ಅದನ್ನು ರಚಿಸುವ ಮೂಲಕ ಪೈಪ್ಲೈನ್ ಅನ್ನು ಜೋಡಿಸೋಣ:
$ oc create -f https://raw.githubusercontent.com/nodeshift/webapp-pipeline-tutorial/master/pipelines/build-and-deploy-react.yaml
ಆದರೆ ನಾವು ಈ ಆಜ್ಞೆಯನ್ನು ಚಲಾಯಿಸುವ ಮೊದಲು, ಈ ಘಟಕಗಳನ್ನು ನೋಡೋಣ. ಮೊದಲನೆಯದು ಹೆಸರು:
apiVersion: tekton.dev/v1alpha1
kind: Pipeline
metadata:
name: build-and-deploy-react
ನಂತರ ಸ್ಪೆಕ್ ವಿಭಾಗದಲ್ಲಿ ನಾವು ಮೊದಲು ರಚಿಸಿದ ಸಂಪನ್ಮೂಲಗಳ ಸೂಚನೆಯನ್ನು ನೋಡುತ್ತೇವೆ:
spec:
resources:
- name: web-application-repo
type: git
- name: built-web-application-image
type: image
- name: runtime-web-application-image
type: image
ನಂತರ ನಾವು ನಮ್ಮ ಪೈಪ್ಲೈನ್ ಪೂರ್ಣಗೊಳಿಸಬೇಕಾದ ಕಾರ್ಯಗಳನ್ನು ರಚಿಸುತ್ತೇವೆ. ಮೊದಲನೆಯದಾಗಿ, ನಾವು ಈಗಾಗಲೇ ರಚಿಸಿದ s2i-web-app ಕಾರ್ಯವನ್ನು ಇದು ಕಾರ್ಯಗತಗೊಳಿಸಬೇಕು:
tasks:
- name: build-web-application
taskRef:
name: s2i-web-app
kind: ClusterTask
ಈ ಕಾರ್ಯವು ಇನ್‌ಪುಟ್ (ಗಿರ್ ಸಂಪನ್ಮೂಲ) ಮತ್ತು ಔಟ್ಪುಟ್ (ಬಿಲ್ಟ್-ವೆಬ್-ಅಪ್ಲಿಕೇಶನ್-ಇಮೇಜ್ ರಿಸೋರ್ಸ್) ನಿಯತಾಂಕಗಳನ್ನು ತೆಗೆದುಕೊಳ್ಳುತ್ತದೆ. ನಾವು ಅದನ್ನು ವಿಶೇಷ ಪ್ಯಾರಾಮೀಟರ್ ಅನ್ನು ಸಹ ರವಾನಿಸುತ್ತೇವೆ ಆದ್ದರಿಂದ ನಾವು ಸ್ವಯಂ-ಸಹಿ ಪ್ರಮಾಣಪತ್ರಗಳನ್ನು ಬಳಸುತ್ತಿರುವುದರಿಂದ ಅದು TLS ಅನ್ನು ಪರಿಶೀಲಿಸುವುದಿಲ್ಲ:
resources:
inputs:
- name: source
resource: web-application-repo
outputs:
- name: image
resource: built-web-application-image
params:
- name: TLSVERIFY
value: "false"
ಮುಂದಿನ ಕಾರ್ಯವು ಬಹುತೇಕ ಒಂದೇ ಆಗಿರುತ್ತದೆ, ಇಲ್ಲಿ ಮಾತ್ರ ನಾವು ಈಗಾಗಲೇ ರಚಿಸಿರುವ ವೆಬ್‌ಅಪ್-ಬಿಲ್ಡ್-ರನ್ಟೈಮ್ ಕ್ಲಸ್ಟರ್ ಕಾರ್ಯವನ್ನು ಕರೆಯಲಾಗುತ್ತದೆ:
name: build-runtime-image
taskRef:
name: webapp-build-runtime
kind: ClusterTask
ಹಿಂದಿನ ಕಾರ್ಯದಂತೆ, ನಾವು ಸಂಪನ್ಮೂಲದಲ್ಲಿ ಹಾದು ಹೋಗುತ್ತೇವೆ, ಆದರೆ ಈಗ ಅದು ಅಂತರ್ನಿರ್ಮಿತ ವೆಬ್-ಅಪ್ಲಿಕೇಶನ್-ಇಮೇಜ್ (ನಮ್ಮ ಹಿಂದಿನ ಕಾರ್ಯದ ಔಟ್ಪುಟ್). ಮತ್ತು ಔಟ್ಪುಟ್ ಆಗಿ ನಾವು ಮತ್ತೊಮ್ಮೆ ಚಿತ್ರವನ್ನು ಹೊಂದಿಸುತ್ತೇವೆ. ಹಿಂದಿನ ಕಾರ್ಯದ ನಂತರ ಈ ಕಾರ್ಯವನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸಬೇಕಾಗಿರುವುದರಿಂದ, ನಾವು ರನ್ಆಫ್ಟರ್ ಕ್ಷೇತ್ರವನ್ನು ಸೇರಿಸುತ್ತೇವೆ:
resources:
inputs:
- name: image
resource: built-web-application-image
outputs:
- name: image
resource: runtime-web-application-image
params:
- name: TLSVERIFY
value: "false"
runAfter:
- build-web-application
ನಮ್ಮ ವೆಬ್ ಅಪ್ಲಿಕೇಶನ್‌ನ k8s ಡೈರೆಕ್ಟರಿಯಲ್ಲಿ ವಾಸಿಸುವ ಸೇವೆ, ಮಾರ್ಗ ಮತ್ತು ನಿಯೋಜನೆ YAML ಫೈಲ್‌ಗಳನ್ನು ಬಳಸಲು ಮುಂದಿನ ಎರಡು ಕಾರ್ಯಗಳು ಜವಾಬ್ದಾರವಾಗಿವೆ ಮತ್ತು ಹೊಸ ಚಿತ್ರಗಳನ್ನು ರಚಿಸುವಾಗ ಈ ನಿಯೋಜನೆಯನ್ನು ನವೀಕರಿಸಲು ಸಹ ಜವಾಬ್ದಾರರಾಗಿರುತ್ತಾರೆ. ಲೇಖನದ ಆರಂಭದಲ್ಲಿ ನಾವು ಈ ಎರಡು ಕ್ಲಸ್ಟರ್ ಕಾರ್ಯಗಳನ್ನು ವ್ಯಾಖ್ಯಾನಿಸಿದ್ದೇವೆ.
ಕನ್ವೇಯರ್ ಅನ್ನು ಪ್ರಾರಂಭಿಸಲಾಗುತ್ತಿದೆ
ಆದ್ದರಿಂದ, ನಮ್ಮ ಪೈಪ್‌ಲೈನ್‌ನ ಎಲ್ಲಾ ಭಾಗಗಳನ್ನು ರಚಿಸಲಾಗಿದೆ, ಮತ್ತು ನಾವು ಅದನ್ನು ಈ ಕೆಳಗಿನ ಆಜ್ಞೆಯೊಂದಿಗೆ ಚಲಾಯಿಸುತ್ತೇವೆ:
$ tkn pipeline start build-and-deploy-react
ಈ ಹಂತದಲ್ಲಿ, ಕಮಾಂಡ್ ಲೈನ್ ಅನ್ನು ಸಂವಾದಾತ್ಮಕವಾಗಿ ಬಳಸಲಾಗುತ್ತದೆ ಮತ್ತು ಅದರ ಪ್ರತಿಯೊಂದು ವಿನಂತಿಗಳಿಗೆ ಪ್ರತಿಕ್ರಿಯೆಯಾಗಿ ನೀವು ಸೂಕ್ತವಾದ ಸಂಪನ್ಮೂಲಗಳನ್ನು ಆಯ್ಕೆ ಮಾಡಬೇಕಾಗುತ್ತದೆ: git ಸಂಪನ್ಮೂಲಕ್ಕಾಗಿ, ವೆಬ್-ಅಪ್ಲಿಕೇಶನ್-ರೆಪೋ ಆಯ್ಕೆಮಾಡಿ, ನಂತರ ಮೊದಲ ಇಮೇಜ್ ಸಂಪನ್ಮೂಲಕ್ಕಾಗಿ, ಅಂತರ್ನಿರ್ಮಿತ ವೆಬ್-ಅಪ್ಲಿಕೇಶನ್ -ಚಿತ್ರ, ಮತ್ತು ಅಂತಿಮವಾಗಿ, ಎರಡನೇ ಚಿತ್ರ ಸಂಪನ್ಮೂಲಕ್ಕಾಗಿ - ರನ್ಟೈಮ್-ವೆಬ್-ಅಪ್ಲಿಕೇಶನ್-ಚಿತ್ರ:
? Choose the git resource to use for web-application-repo: web-application-repo (https://github.com/nodeshift-starters/react-pipeline-example)
? Choose the image resource to use for built-web-application-image: built-web-application-image (image-registry.openshift-image-registry.svc:5000/webapp-pipeline/built-web-
application:latest)
? Choose the image resource to use for runtime-web-application-image: runtime-web-application-image (image-registry.openshift-image-registry.svc:5000/webapp-pipeline/runtim
e-web-application:latest)
Pipelinerun started: build-and-deploy-react-run-4xwsr
ಈಗ ಈ ಕೆಳಗಿನ ಆಜ್ಞೆಯನ್ನು ಬಳಸಿಕೊಂಡು ಪೈಪ್‌ಲೈನ್‌ನ ಸ್ಥಿತಿಯನ್ನು ಪರಿಶೀಲಿಸೋಣ:
$ tkn pipeline logs -f
ಪೈಪ್ಲೈನ್ ಪ್ರಾರಂಭವಾದ ನಂತರ ಮತ್ತು ಅಪ್ಲಿಕೇಶನ್ ಅನ್ನು ನಿಯೋಜಿಸಿದ ನಂತರ, ನಾವು ಈ ಕೆಳಗಿನ ಆಜ್ಞೆಯೊಂದಿಗೆ ಪ್ರಕಟಿಸಿದ ಮಾರ್ಗವನ್ನು ವಿನಂತಿಸಬಹುದು:
$ oc get route react-pipeline-example --template='http://{{.spec.host}}'
ಹೆಚ್ಚಿನ ದೃಶ್ಯೀಕರಣಕ್ಕಾಗಿ, ವಿಭಾಗದಲ್ಲಿನ ವೆಬ್ ಕನ್ಸೋಲ್‌ನ ಡೆವಲಪರ್ ಮೋಡ್‌ನಲ್ಲಿ ನಮ್ಮ ಪೈಪ್ಲೈನ್ ಅನ್ನು ನೀವು ವೀಕ್ಷಿಸಬಹುದು ಪೈಪ್‌ಲೈನ್‌ಗಳು, ಅಂಜೂರದಲ್ಲಿ ತೋರಿಸಿರುವಂತೆ. 1.
ಚಿತ್ರ.1. ಚಾಲನೆಯಲ್ಲಿರುವ ಪೈಪ್ಲೈನ್ಗಳ ವಿಮರ್ಶೆ.
ಚಾಲನೆಯಲ್ಲಿರುವ ಪೈಪ್ಲೈನ್ ಅನ್ನು ಕ್ಲಿಕ್ ಮಾಡುವುದರಿಂದ ಚಿತ್ರ 2 ರಲ್ಲಿ ತೋರಿಸಿರುವಂತೆ ಹೆಚ್ಚುವರಿ ವಿವರಗಳನ್ನು ಪ್ರದರ್ಶಿಸುತ್ತದೆ.
ಅಕ್ಕಿ. 2. ಪೈಪ್ಲೈನ್ ಬಗ್ಗೆ ಹೆಚ್ಚುವರಿ ಮಾಹಿತಿ.
ಹೆಚ್ಚಿನ ಮಾಹಿತಿಯ ನಂತರ, ನೀವು ವೀಕ್ಷಣೆಯಲ್ಲಿ ಚಾಲನೆಯಲ್ಲಿರುವ ಅಪ್ಲಿಕೇಶನ್ಗಳನ್ನು ನೋಡಬಹುದು ಟೋಪೋಲಜಿ, Fig.3 ರಲ್ಲಿ ತೋರಿಸಿರುವಂತೆ.
ಚಿತ್ರ 3. ಲಾಂಚ್ ಪಾಡ್.
ಐಕಾನ್‌ನ ಮೇಲಿನ ಬಲ ಮೂಲೆಯಲ್ಲಿರುವ ವೃತ್ತದ ಮೇಲೆ ಕ್ಲಿಕ್ ಮಾಡುವುದರಿಂದ ಚಿತ್ರ 4 ರಲ್ಲಿ ತೋರಿಸಿರುವಂತೆ ನಮ್ಮ ಅಪ್ಲಿಕೇಶನ್ ತೆರೆಯುತ್ತದೆ.
ಅಕ್ಕಿ. 4. ರಿಯಾಕ್ಟ್ ಅಪ್ಲಿಕೇಶನ್ ರನ್ನಿಂಗ್.
ತೀರ್ಮಾನಕ್ಕೆ
ಆದ್ದರಿಂದ, OpenShift ನಲ್ಲಿ ನಿಮ್ಮ ಅಪ್ಲಿಕೇಶನ್‌ಗಾಗಿ ಡೆವಲಪ್‌ಮೆಂಟ್ ಸರ್ವರ್ ಅನ್ನು ಹೇಗೆ ಚಲಾಯಿಸಬೇಕು ಮತ್ತು ಅದನ್ನು ಸ್ಥಳೀಯ ಫೈಲ್ ಸಿಸ್ಟಮ್‌ನೊಂದಿಗೆ ಸಿಂಕ್ರೊನೈಸ್ ಮಾಡುವುದು ಹೇಗೆ ಎಂದು ನಾವು ತೋರಿಸಿದ್ದೇವೆ. ಓಪನ್‌ಶಿಫ್ಟ್ ಪೈಪ್‌ಲೈನ್‌ಗಳನ್ನು ಬಳಸಿಕೊಂಡು ಚೈನ್ಡ್-ಬಿಲ್ಡ್ ಟೆಂಪ್ಲೇಟ್ ಅನ್ನು ಹೇಗೆ ಅನುಕರಿಸುವುದು ಎಂಬುದನ್ನು ಸಹ ನಾವು ನೋಡಿದ್ದೇವೆ. ಈ ಲೇಖನದಿಂದ ಎಲ್ಲಾ ಉದಾಹರಣೆ ಕೋಡ್‌ಗಳನ್ನು ಕಾಣಬಹುದು .
ಹೆಚ್ಚುವರಿ ಸಂಪನ್ಮೂಲಗಳು (EN)
- ಉಚಿತ ಇ-ಪುಸ್ತಕ
- ಇತರ ಲೇಖನಗಳು Red Hat ವೆಬ್‌ಸೈಟ್‌ನಲ್ಲಿ
ಮುಂಬರುವ ವೆಬ್‌ನಾರ್‌ಗಳ ಪ್ರಕಟಣೆಗಳು
ನಾವು Red Hat OpenShift ಕಂಟೈನರ್ ಪ್ಲಾಟ್‌ಫಾರ್ಮ್ ಮತ್ತು ಕುಬರ್ನೆಟ್‌ಗಳನ್ನು ಬಳಸಿಕೊಂಡು ಸ್ಥಳೀಯ ಅನುಭವದ ಕುರಿತು ಶುಕ್ರವಾರ ವೆಬ್‌ನಾರ್‌ಗಳ ಸರಣಿಯನ್ನು ಪ್ರಾರಂಭಿಸುತ್ತಿದ್ದೇವೆ:
ಮೂಲ: www.habr.com