ನಮ್ಮ ಕೋರಿಕೆಯ ಮೇರೆಗೆ, ಹಬ್ ಹಬ್ ಅನ್ನು ರಚಿಸಿದ್ದಾರೆ ಮತ್ತು ಅದರಲ್ಲಿ ಮೊದಲ ಪ್ರಕಟಣೆಯನ್ನು ಇರಿಸಲು ನಾವು ಸಂತೋಷಪಡುತ್ತೇವೆ. ಚಂದಾದಾರರಾಗಿ!
ಕುಬರ್ನೆಟ್ಸ್ ಸುಲಭ. ಕೆಲವೇ ಗಂಟೆಗಳಲ್ಲಿ ಯಾರಾದರೂ ಈ ತಂತ್ರಜ್ಞಾನವನ್ನು ಕರಗತ ಮಾಡಿಕೊಳ್ಳಬಹುದಾದಾಗ, ಈ ಪ್ರದೇಶದಲ್ಲಿ ಕೆಲಸ ಮಾಡಲು ಬ್ಯಾಂಕ್‌ಗಳು ನನಗೆ ಹೆಚ್ಚಿನ ಹಣವನ್ನು ಏಕೆ ಪಾವತಿಸುತ್ತವೆ?
ಕುಬರ್ನೆಟ್ಸ್ ಅನ್ನು ಶೀಘ್ರವಾಗಿ ಕಲಿಯಬಹುದೆಂದು ನೀವು ಅನುಮಾನಿಸಿದರೆ, ಅದನ್ನು ನೀವೇ ಪ್ರಯತ್ನಿಸಲು ನಾನು ಸಲಹೆ ನೀಡುತ್ತೇನೆ. ಅವುಗಳೆಂದರೆ, ಈ ವಸ್ತುವನ್ನು ಮಾಸ್ಟರಿಂಗ್ ಮಾಡಿದ ನಂತರ, ನೀವು ಕುಬರ್ನೆಟ್ಸ್ ಕ್ಲಸ್ಟರ್‌ನಲ್ಲಿ ಮೈಕ್ರೊ ಸರ್ವೀಸ್‌ಗಳ ಆಧಾರದ ಮೇಲೆ ಅಪ್ಲಿಕೇಶನ್ ಅನ್ನು ಚಲಾಯಿಸಲು ಸಾಧ್ಯವಾಗುತ್ತದೆ. ನಾನು ಇದನ್ನು ಖಾತರಿಪಡಿಸಬಲ್ಲೆ, ಏಕೆಂದರೆ ಇಲ್ಲಿ ಬಳಸಲಾದ ಅದೇ ವಿಧಾನವನ್ನು ನಾನು ನಮ್ಮ ಗ್ರಾಹಕರಿಗೆ ಕುಬರ್ನೆಟ್ಸ್‌ನೊಂದಿಗೆ ಕೆಲಸ ಮಾಡಲು ಕಲಿಸುತ್ತೇನೆ. ಈ ಮಾರ್ಗದರ್ಶಿ ಇತರರಿಗಿಂತ ಭಿನ್ನವಾಗಿರುವುದು ಯಾವುದು? ವಾಸ್ತವವಾಗಿ, ಬಹಳಷ್ಟು ವಿಷಯಗಳಿವೆ. ಆದ್ದರಿಂದ, ಈ ಹೆಚ್ಚಿನ ವಸ್ತುಗಳು ಸರಳ ವಿಷಯಗಳ ವಿವರಣೆಯೊಂದಿಗೆ ಪ್ರಾರಂಭವಾಗುತ್ತವೆ - ಕುಬರ್ನೆಟ್ಸ್ನ ಪರಿಕಲ್ಪನೆಗಳು ಮತ್ತು kubectl ಆಜ್ಞೆಯ ವೈಶಿಷ್ಟ್ಯಗಳು. ಈ ವಸ್ತುಗಳ ಲೇಖಕರು ತಮ್ಮ ಓದುಗರಿಗೆ ಅಪ್ಲಿಕೇಶನ್ ಅಭಿವೃದ್ಧಿ, ಮೈಕ್ರೋಸರ್ವಿಸ್ ಮತ್ತು ಡಾಕರ್ ಕಂಟೈನರ್‌ಗಳ ಬಗ್ಗೆ ಪರಿಚಿತರಾಗಿದ್ದಾರೆ ಎಂದು ಊಹಿಸುತ್ತಾರೆ. ನಾವು ಬೇರೆ ದಾರಿಯಲ್ಲಿ ಹೋಗುತ್ತೇವೆ. ಮೊದಲಿಗೆ, ಕಂಪ್ಯೂಟರ್‌ನಲ್ಲಿ ಮೈಕ್ರೋಸರ್ವಿಸ್‌ಗಳ ಆಧಾರದ ಮೇಲೆ ಅಪ್ಲಿಕೇಶನ್ ಅನ್ನು ಹೇಗೆ ಚಲಾಯಿಸಬೇಕು ಎಂಬುದರ ಕುರಿತು ನಾವು ಮಾತನಾಡುತ್ತೇವೆ. ನಂತರ ನಾವು ಪ್ರತಿ ಮೈಕ್ರೋ ಸರ್ವಿಸ್‌ಗಾಗಿ ಕಂಟೇನರ್ ಚಿತ್ರಗಳನ್ನು ನಿರ್ಮಿಸಲು ನೋಡುತ್ತೇವೆ. ಮತ್ತು ಅದರ ನಂತರ, ನಾವು ಕುಬರ್ನೆಟ್ಸ್‌ನೊಂದಿಗೆ ಪರಿಚಯ ಮಾಡಿಕೊಳ್ಳುತ್ತೇವೆ ಮತ್ತು ಕುಬರ್ನೆಟ್ಸ್ ನಿರ್ವಹಿಸುವ ಕ್ಲಸ್ಟರ್‌ನಲ್ಲಿ ಮೈಕ್ರೋ ಸರ್ವಿಸ್‌ಗಳ ಆಧಾರದ ಮೇಲೆ ಅಪ್ಲಿಕೇಶನ್ ಅನ್ನು ನಿಯೋಜಿಸಲು ನೋಡುತ್ತೇವೆ.
ಈ ವಿಧಾನವು ಕುಬರ್ನೆಟ್ಸ್‌ಗೆ ಕ್ರಮೇಣವಾದ ವಿಧಾನದೊಂದಿಗೆ, ಕುಬರ್ನೆಟ್ಸ್‌ನಲ್ಲಿ ಎಲ್ಲವೂ ಎಷ್ಟು ಸರಳವಾಗಿ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತದೆ ಎಂಬುದನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳಲು ಸರಾಸರಿ ವ್ಯಕ್ತಿಗೆ ಅಗತ್ಯವಿರುವ ಏನಾಗುತ್ತಿದೆ ಎಂಬುದನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳುವ ಆಳವನ್ನು ನೀಡುತ್ತದೆ. ಕುಬರ್ನೆಟ್ಸ್ ನಿಸ್ಸಂಶಯವಾಗಿ ಸರಳ ತಂತ್ರಜ್ಞಾನವಾಗಿದೆ, ಇದನ್ನು ಕಲಿಯಲು ಬಯಸುವವರಿಗೆ ಅದನ್ನು ಎಲ್ಲಿ ಮತ್ತು ಹೇಗೆ ಬಳಸಲಾಗಿದೆ ಎಂದು ತಿಳಿದಿರುತ್ತದೆ.
ಈಗ, ಮತ್ತಷ್ಟು ಸಡಗರವಿಲ್ಲದೆ, ಪ್ರಾರಂಭಿಸೋಣ ಮತ್ತು ನಾವು ಕೆಲಸ ಮಾಡುವ ಅಪ್ಲಿಕೇಶನ್ ಬಗ್ಗೆ ಮಾತನಾಡೋಣ.
ಪ್ರಾಯೋಗಿಕ ಅಪ್ಲಿಕೇಶನ್
ನಮ್ಮ ಅಪ್ಲಿಕೇಶನ್ ಕೇವಲ ಒಂದು ಕಾರ್ಯವನ್ನು ನಿರ್ವಹಿಸುತ್ತದೆ. ಇದು ಒಂದು ವಾಕ್ಯವನ್ನು ಇನ್ಪುಟ್ ಆಗಿ ತೆಗೆದುಕೊಳ್ಳುತ್ತದೆ, ಅದರ ನಂತರ, ಪಠ್ಯ ವಿಶ್ಲೇಷಣಾ ಸಾಧನಗಳನ್ನು ಬಳಸಿಕೊಂಡು, ಈ ವಾಕ್ಯದ ಭಾವನೆ ವಿಶ್ಲೇಷಣೆಯನ್ನು ಮಾಡುತ್ತದೆ, ನಿರ್ದಿಷ್ಟ ವಸ್ತುವಿಗೆ ವಾಕ್ಯದ ಲೇಖಕರ ಭಾವನಾತ್ಮಕ ವರ್ತನೆಯ ಮೌಲ್ಯಮಾಪನವನ್ನು ಪಡೆಯುತ್ತದೆ.
ಈ ಅಪ್ಲಿಕೇಶನ್‌ನ ಮುಖ್ಯ ವಿಂಡೋ ಹೀಗಿದೆ.
ಪಠ್ಯಗಳ ಭಾವನೆ ವಿಶ್ಲೇಷಣೆಗಾಗಿ ವೆಬ್ ಅಪ್ಲಿಕೇಶನ್
ತಾಂತ್ರಿಕ ದೃಷ್ಟಿಕೋನದಿಂದ, ಅಪ್ಲಿಕೇಶನ್ ಮೂರು ಸೂಕ್ಷ್ಮ ಸೇವೆಗಳನ್ನು ಒಳಗೊಂಡಿದೆ, ಪ್ರತಿಯೊಂದೂ ನಿರ್ದಿಷ್ಟ ಸಮಸ್ಯೆಗಳನ್ನು ಪರಿಹರಿಸುತ್ತದೆ:
- SA-Frontend ಒಂದು Nginx ವೆಬ್ ಸರ್ವರ್ ಆಗಿದ್ದು ಅದು ಸ್ಥಿರ ರಿಯಾಕ್ಟ್ ಫೈಲ್‌ಗಳನ್ನು ಒದಗಿಸುತ್ತದೆ.
- SA-WebApp ಎನ್ನುವುದು ಜಾವಾದಲ್ಲಿ ಬರೆಯಲಾದ ವೆಬ್ ಅಪ್ಲಿಕೇಶನ್ ಆಗಿದ್ದು ಅದು ಮುಂಭಾಗದಿಂದ ವಿನಂತಿಗಳನ್ನು ಪ್ರಕ್ರಿಯೆಗೊಳಿಸುತ್ತದೆ.
- SA-Logic ಎಂಬುದು ಪೈಥಾನ್ ಅಪ್ಲಿಕೇಶನ್ ಆಗಿದ್ದು ಅದು ಪಠ್ಯದ ಮೇಲೆ ಭಾವನೆ ವಿಶ್ಲೇಷಣೆಯನ್ನು ಮಾಡುತ್ತದೆ.
ಸೂಕ್ಷ್ಮ ಸೇವೆಗಳು ಪ್ರತ್ಯೇಕವಾಗಿ ಅಸ್ತಿತ್ವದಲ್ಲಿಲ್ಲ ಎಂಬುದನ್ನು ಗಮನಿಸುವುದು ಮುಖ್ಯ. ಅವರು "ಜವಾಬ್ದಾರಿಗಳ ಪ್ರತ್ಯೇಕತೆ" ಎಂಬ ಕಲ್ಪನೆಯನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸುತ್ತಾರೆ, ಆದರೆ ಅದೇ ಸಮಯದಲ್ಲಿ ಅವರು ಪರಸ್ಪರ ಸಂವಹನ ಮಾಡಬೇಕಾಗುತ್ತದೆ.
ಅಪ್ಲಿಕೇಶನ್‌ನಲ್ಲಿ ಡೇಟಾ ಹರಿಯುತ್ತದೆ
ಮೇಲಿನ ರೇಖಾಚಿತ್ರದಲ್ಲಿ, ನೀವು ಸಿಸ್ಟಮ್‌ನ ಸಂಖ್ಯೆಯ ಹಂತಗಳನ್ನು ನೋಡಬಹುದು, ಅಪ್ಲಿಕೇಶನ್‌ನಲ್ಲಿ ಡೇಟಾ ಹರಿವುಗಳನ್ನು ವಿವರಿಸುತ್ತದೆ. ಅವುಗಳನ್ನು ನೋಡೋಣ:
- ಬ್ರೌಸರ್ ಸರ್ವರ್‌ನಿಂದ ಫೈಲ್ ಅನ್ನು ವಿನಂತಿಸುತ್ತದೆ
index.html(ಇದು ಪ್ರತಿಯಾಗಿ, ರಿಯಾಕ್ಟ್ ಅಪ್ಲಿಕೇಶನ್ ಪ್ಯಾಕೇಜ್ ಅನ್ನು ಡೌನ್‌ಲೋಡ್ ಮಾಡುತ್ತದೆ). - ಬಳಕೆದಾರರು ಅಪ್ಲಿಕೇಶನ್‌ನೊಂದಿಗೆ ಸಂವಹನ ನಡೆಸುತ್ತಾರೆ, ಇದು ಸ್ಪ್ರಿಂಗ್-ಆಧಾರಿತ ವೆಬ್ ಅಪ್ಲಿಕೇಶನ್‌ಗೆ ಕರೆಯನ್ನು ಉಂಟುಮಾಡುತ್ತದೆ.
- ವೆಬ್ ಅಪ್ಲಿಕೇಶನ್ ಪಠ್ಯ ವಿಶ್ಲೇಷಣೆಯನ್ನು ಮಾಡಲು ವಿನಂತಿಯನ್ನು ಪೈಥಾನ್ ಅಪ್ಲಿಕೇಶನ್‌ಗೆ ರವಾನಿಸುತ್ತದೆ.
- ಪೈಥಾನ್ ಅಪ್ಲಿಕೇಶನ್ ಪಠ್ಯದ ಭಾವನೆ ವಿಶ್ಲೇಷಣೆಯನ್ನು ಮಾಡುತ್ತದೆ ಮತ್ತು ವಿನಂತಿಗೆ ಪ್ರತಿಕ್ರಿಯೆಯಾಗಿ ಫಲಿತಾಂಶವನ್ನು ನೀಡುತ್ತದೆ.
- ಸ್ಪ್ರಿಂಗ್ ಅಪ್ಲಿಕೇಶನ್ ರಿಯಾಕ್ಟ್ ಅಪ್ಲಿಕೇಶನ್‌ಗೆ ಪ್ರತಿಕ್ರಿಯೆಯನ್ನು ಕಳುಹಿಸುತ್ತದೆ (ಇದು ಪ್ರತಿಯಾಗಿ, ಬಳಕೆದಾರರಿಗೆ ಪಠ್ಯ ವಿಶ್ಲೇಷಣೆಯ ಫಲಿತಾಂಶವನ್ನು ತೋರಿಸುತ್ತದೆ).
ಈ ಎಲ್ಲಾ ಅಪ್ಲಿಕೇಶನ್‌ಗಳ ಕೋಡ್ ಅನ್ನು ಕಾಣಬಹುದು . ಈ ಭಂಡಾರವನ್ನು ಇದೀಗ ನಿಮಗಾಗಿ ನಕಲಿಸಬೇಕೆಂದು ನಾನು ಶಿಫಾರಸು ಮಾಡುತ್ತೇವೆ, ಏಕೆಂದರೆ ನಮ್ಮ ಮುಂದೆ ಅನೇಕ ಆಸಕ್ತಿದಾಯಕ ಪ್ರಯೋಗಗಳಿವೆ.
ನಿಮ್ಮ ಸ್ಥಳೀಯ ಗಣಕದಲ್ಲಿ ಮೈಕ್ರೋ ಸರ್ವೀಸ್ ಆಧಾರಿತ ಅಪ್ಲಿಕೇಶನ್ ಅನ್ನು ರನ್ ಮಾಡಲಾಗುತ್ತಿದೆ
ಅಪ್ಲಿಕೇಶನ್ ಕೆಲಸ ಮಾಡಲು, ನಾವು ಎಲ್ಲಾ ಮೂರು ಮೈಕ್ರೋಸರ್ವಿಸ್ಗಳನ್ನು ಪ್ರಾರಂಭಿಸಬೇಕಾಗಿದೆ. ಅವುಗಳಲ್ಲಿ ಅತ್ಯಂತ ಮೋಹಕವಾದ - ಫ್ರಂಟ್-ಎಂಡ್ ಅಪ್ಲಿಕೇಶನ್‌ನೊಂದಿಗೆ ಪ್ರಾರಂಭಿಸೋಣ.
▍ಸ್ಥಳೀಯ ಅಭಿವೃದ್ಧಿಗಾಗಿ ರಿಯಾಕ್ಟ್ ಅನ್ನು ಹೊಂದಿಸಿ
ರಿಯಾಕ್ಟ್ ಅಪ್ಲಿಕೇಶನ್ ಅನ್ನು ರನ್ ಮಾಡಲು, ನೀವು ನಿಮ್ಮ ಕಂಪ್ಯೂಟರ್‌ನಲ್ಲಿ Node.js ಪ್ಲಾಟ್‌ಫಾರ್ಮ್ ಮತ್ತು NPM ಅನ್ನು ಸ್ಥಾಪಿಸಬೇಕಾಗುತ್ತದೆ. ಒಮ್ಮೆ ನೀವು ಎಲ್ಲವನ್ನೂ ಸ್ಥಾಪಿಸಿದ ನಂತರ, ನಿಮ್ಮ ಪ್ರಾಜೆಕ್ಟ್ ಫೋಲ್ಡರ್‌ಗೆ ನ್ಯಾವಿಗೇಟ್ ಮಾಡಲು ಟರ್ಮಿನಲ್ ಅನ್ನು ಬಳಸಿ sa-frontend ಮತ್ತು ಈ ಕೆಳಗಿನ ಆಜ್ಞೆಯನ್ನು ಚಲಾಯಿಸಿ:
npm install
ಫೋಲ್ಡರ್ನಲ್ಲಿ ಈ ಆಜ್ಞೆಯನ್ನು ಚಲಾಯಿಸುವ ಮೂಲಕ node_modules ರಿಯಾಕ್ಟ್ ಅಪ್ಲಿಕೇಶನ್‌ನ ಅವಲಂಬನೆಗಳನ್ನು ಲೋಡ್ ಮಾಡಲಾಗುತ್ತದೆ, ಅದರ ದಾಖಲೆಗಳು ಫೈಲ್‌ನಲ್ಲಿವೆ package.json. ಒಂದೇ ಫೋಲ್ಡರ್ನಲ್ಲಿ ಅವಲಂಬನೆಗಳನ್ನು ಡೌನ್‌ಲೋಡ್ ಮಾಡಿದ ನಂತರ, ಈ ಕೆಳಗಿನ ಆಜ್ಞೆಯನ್ನು ಚಲಾಯಿಸಿ:
npm start
ಅಷ್ಟೇ. ಈಗ ರಿಯಾಕ್ಟ್ ಅಪ್ಲಿಕೇಶನ್ ಚಾಲನೆಯಲ್ಲಿದೆ, ನಿಮ್ಮ ಬ್ರೌಸರ್‌ನಲ್ಲಿ ಈ ಕೆಳಗಿನ ವಿಳಾಸಕ್ಕೆ ಹೋಗುವ ಮೂಲಕ ನೀವು ಅದನ್ನು ಪ್ರವೇಶಿಸಬಹುದು: localhost:3000. ನೀವು ಅದರ ಕೋಡ್‌ನಲ್ಲಿ ಏನನ್ನಾದರೂ ಬದಲಾಯಿಸಬಹುದು. ಬ್ರೌಸರ್‌ನಲ್ಲಿ ಈ ಬದಲಾವಣೆಗಳ ಪರಿಣಾಮವನ್ನು ನೀವು ತಕ್ಷಣ ನೋಡುತ್ತೀರಿ. ಮಾಡ್ಯೂಲ್ಗಳ "ಬಿಸಿ" ಬದಲಿ ಎಂದು ಕರೆಯಲ್ಪಡುವ ಧನ್ಯವಾದಗಳು ಇದು ಸಾಧ್ಯ. ಇದು ಮುಂಭಾಗದ ಅಭಿವೃದ್ಧಿಯನ್ನು ಸರಳ ಮತ್ತು ಆನಂದದಾಯಕ ಅನುಭವವನ್ನಾಗಿ ಮಾಡುತ್ತದೆ.
▍ಉತ್ಪಾದನೆಗಾಗಿ ರಿಯಾಕ್ಟ್ ಅಪ್ಲಿಕೇಶನ್ ಅನ್ನು ಸಿದ್ಧಪಡಿಸುವುದು
ವಾಸ್ತವವಾಗಿ ರಿಯಾಕ್ಟ್ ಅಪ್ಲಿಕೇಶನ್ ಅನ್ನು ಬಳಸುವ ಉದ್ದೇಶಕ್ಕಾಗಿ, ನಾವು ಅದನ್ನು ಸ್ಥಿರ ಫೈಲ್‌ಗಳ ಗುಂಪಾಗಿ ಪರಿವರ್ತಿಸಬೇಕು ಮತ್ತು ವೆಬ್ ಸರ್ವರ್ ಬಳಸುವ ಕ್ಲೈಂಟ್‌ಗಳಿಗೆ ಸೇವೆ ಸಲ್ಲಿಸಬೇಕು.
ರಿಯಾಕ್ಟ್ ಅಪ್ಲಿಕೇಶನ್ ಅನ್ನು ನಿರ್ಮಿಸಲು, ಮತ್ತೊಮ್ಮೆ ಟರ್ಮಿನಲ್ ಬಳಸಿ, ಫೋಲ್ಡರ್‌ಗೆ ನ್ಯಾವಿಗೇಟ್ ಮಾಡಿ sa-frontend ಮತ್ತು ಈ ಕೆಳಗಿನ ಆಜ್ಞೆಯನ್ನು ಚಲಾಯಿಸಿ:
npm run build
ಇದು ಪ್ರಾಜೆಕ್ಟ್ ಫೋಲ್ಡರ್ನಲ್ಲಿ ಡೈರೆಕ್ಟರಿಯನ್ನು ರಚಿಸುತ್ತದೆ build. ಇದು ರಿಯಾಕ್ಟ್ ಅಪ್ಲಿಕೇಶನ್ ಕೆಲಸ ಮಾಡಲು ಅಗತ್ಯವಿರುವ ಎಲ್ಲಾ ಸ್ಥಿರ ಫೈಲ್‌ಗಳನ್ನು ಹೊಂದಿರುತ್ತದೆ.
▍Nginx ಬಳಸಿಕೊಂಡು ಸ್ಥಿರ ಫೈಲ್‌ಗಳನ್ನು ಒದಗಿಸಲಾಗುತ್ತಿದೆ
ಮೊದಲು ನೀವು Nginx ವೆಬ್ ಸರ್ವರ್ ಅನ್ನು ಸ್ಥಾಪಿಸಿ ಮತ್ತು ಚಲಾಯಿಸಬೇಕು. ನೀವು ಅದನ್ನು ಡೌನ್‌ಲೋಡ್ ಮಾಡಬಹುದು ಮತ್ತು ಅದನ್ನು ಹೇಗೆ ಸ್ಥಾಪಿಸಬೇಕು ಮತ್ತು ಚಲಾಯಿಸಬೇಕು ಎಂಬುದರ ಕುರಿತು ಸೂಚನೆಗಳನ್ನು ಕಾಣಬಹುದು. ನಂತರ ನೀವು ಫೋಲ್ಡರ್ನ ವಿಷಯಗಳನ್ನು ನಕಲಿಸಬೇಕಾಗಿದೆ sa-frontend/build ಫೋಲ್ಡರ್ ಗೆ [your_nginx_installation_dir]/html.
ಈ ವಿಧಾನದೊಂದಿಗೆ, ರಿಯಾಕ್ಟ್ ಅಪ್ಲಿಕೇಶನ್‌ನ ನಿರ್ಮಾಣ ಪ್ರಕ್ರಿಯೆಯಲ್ಲಿ ಫೈಲ್ ಅನ್ನು ರಚಿಸಲಾಗಿದೆ index.html ನಲ್ಲಿ ಲಭ್ಯವಿರುತ್ತದೆ [your_nginx_installation_dir]/html/index.html. ಇದು ಪೂರ್ವನಿಯೋಜಿತವಾಗಿ, ಅದನ್ನು ಪ್ರವೇಶಿಸುವಾಗ Nginx ಸರ್ವರ್ ಉತ್ಪಾದಿಸುವ ಫೈಲ್ ಆಗಿದೆ. ಪೋರ್ಟ್‌ನಲ್ಲಿ ಕೇಳಲು ಸರ್ವರ್ ಅನ್ನು ಕಾನ್ಫಿಗರ್ ಮಾಡಲಾಗಿದೆ 80, ಆದರೆ ಫೈಲ್ ಅನ್ನು ಸಂಪಾದಿಸುವ ಮೂಲಕ ನಿಮಗೆ ಬೇಕಾದ ರೀತಿಯಲ್ಲಿ ಕಸ್ಟಮೈಸ್ ಮಾಡಬಹುದು [your_nginx_installation_dir]/conf/nginx.conf.
ಈಗ ನಿಮ್ಮ ಬ್ರೌಸರ್ ತೆರೆಯಿರಿ ಮತ್ತು ಹೋಗಿ localhost:80. ನೀವು ರಿಯಾಕ್ಟ್ ಅಪ್ಲಿಕೇಶನ್ ಪುಟವನ್ನು ನೋಡುತ್ತೀರಿ.
Nginx ಸರ್ವರ್ ಸೇವೆ ಸಲ್ಲಿಸಿದ ರಿಯಾಕ್ಟ್ ಅಪ್ಲಿಕೇಶನ್
ನೀವು ಈಗ ಕ್ಷೇತ್ರಕ್ಕೆ ಏನನ್ನಾದರೂ ನಮೂದಿಸಿದರೆ Type your sentence ಮತ್ತು ಬಟನ್ ಒತ್ತಿರಿ Send - ಏನೂ ಆಗುವುದಿಲ್ಲ. ಆದರೆ, ನೀವು ಕನ್ಸೋಲ್ ಅನ್ನು ನೋಡಿದರೆ, ನೀವು ಅಲ್ಲಿ ದೋಷ ಸಂದೇಶಗಳನ್ನು ನೋಡಬಹುದು. ಈ ದೋಷಗಳು ನಿಖರವಾಗಿ ಎಲ್ಲಿ ಸಂಭವಿಸುತ್ತವೆ ಎಂಬುದನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳಲು, ಅಪ್ಲಿಕೇಶನ್ ಕೋಡ್ ಅನ್ನು ವಿಶ್ಲೇಷಿಸೋಣ.
▍ಮುಂಭಾಗದ ಅಪ್ಲಿಕೇಶನ್ ಕೋಡ್ ವಿಶ್ಲೇಷಣೆ
ಫೈಲ್ ಕೋಡ್ ಅನ್ನು ನೋಡೋಣ App.js, ಗುಂಡಿಯನ್ನು ಒತ್ತುವುದನ್ನು ನಾವು ನೋಡಬಹುದು Send ಒಂದು ವಿಧಾನವನ್ನು ಕರೆಯುತ್ತದೆ analyzeSentence(). ಈ ವಿಧಾನದ ಕೋಡ್ ಅನ್ನು ಕೆಳಗೆ ನೀಡಲಾಗಿದೆ. ಫಾರ್ಮ್‌ನ ಕಾಮೆಂಟ್ ಹೊಂದಿರುವ ಪ್ರತಿ ಸಾಲಿಗೆ ದಯವಿಟ್ಟು ಗಮನಿಸಿ # Номер, ಕೋಡ್ ಕೆಳಗೆ ವಿವರಣೆಯನ್ನು ನೀಡಲಾಗಿದೆ. ನಾವು ಇತರ ಕೋಡ್ ತುಣುಕುಗಳನ್ನು ಅದೇ ರೀತಿಯಲ್ಲಿ ವಿಶ್ಲೇಷಿಸುತ್ತೇವೆ.
analyzeSentence() {
fetch('http://localhost:8080/sentiment', { // #1
method: 'POST',
headers: {
'Content-Type': 'application/json'
},
body: JSON.stringify({
sentence: this.textField.getValue()})// #2
})
.then(response => response.json())
.then(data => this.setState(data)); // #3
}1. ಪೋಸ್ಟ್ ವಿನಂತಿಯನ್ನು ಮಾಡಿದ URL. ಈ ವಿಳಾಸದಲ್ಲಿ ಅಂತಹ ವಿನಂತಿಗಳನ್ನು ನಿರೀಕ್ಷಿಸುವ ಅಪ್ಲಿಕೇಶನ್ ಇದೆ ಎಂದು ಭಾವಿಸಲಾಗಿದೆ.
2.ವಿನಂತಿಯ ದೇಹವನ್ನು ಅಪ್ಲಿಕೇಶನ್‌ಗೆ ಕಳುಹಿಸಲಾಗಿದೆ. ಒಂದು ಉದಾಹರಣೆ ವಿನಂತಿಯ ದೇಹ ಇಲ್ಲಿದೆ:
{
sentence: "I like yogobella!"
}
3.ವಿನಂತಿಗೆ ಪ್ರತಿಕ್ರಿಯೆಯನ್ನು ಸ್ವೀಕರಿಸಿದಾಗ, ಘಟಕದ ಸ್ಥಿತಿಯನ್ನು ನವೀಕರಿಸಲಾಗುತ್ತದೆ. ಇದು ಘಟಕವನ್ನು ಮರು ನಿರೂಪಿಸಲು ಕಾರಣವಾಗುತ್ತದೆ. ನಾವು ಡೇಟಾವನ್ನು ಸ್ವೀಕರಿಸಿದರೆ (ಅಂದರೆ, ಇನ್ಪುಟ್ ಡೇಟಾ ಮತ್ತು ಲೆಕ್ಕಹಾಕಿದ ಪಠ್ಯ ಸ್ಕೋರ್ ಹೊಂದಿರುವ JSON ವಸ್ತು), ನಾವು ಘಟಕವನ್ನು ಔಟ್‌ಪುಟ್ ಮಾಡುತ್ತೇವೆ Polarity, ಸೂಕ್ತ ಷರತ್ತುಗಳನ್ನು ಪೂರೈಸಲಾಗುವುದು ರಿಂದ. ನಾವು ಘಟಕವನ್ನು ಹೇಗೆ ವಿವರಿಸುತ್ತೇವೆ:
const polarityComponent = this.state.polarity !== undefined ?
<Polarity sentence={this.state.sentence}
polarity={this.state.polarity}/> :
null;
ಕೋಡ್ ಸಾಕಷ್ಟು ಉತ್ತಮವಾಗಿ ಕಾರ್ಯನಿರ್ವಹಿಸುವಂತೆ ತೋರುತ್ತಿದೆ. ಹಾಗಿದ್ದರೂ ಇದರಲ್ಲಿ ತಪ್ಪೇನು? ಅಪ್ಲಿಕೇಶನ್ POST ವಿನಂತಿಯನ್ನು ಕಳುಹಿಸಲು ಪ್ರಯತ್ನಿಸುತ್ತಿರುವ ವಿಳಾಸದಲ್ಲಿ, ಈ ವಿನಂತಿಯನ್ನು ಸ್ವೀಕರಿಸಲು ಮತ್ತು ಪ್ರಕ್ರಿಯೆಗೊಳಿಸಲು ಇನ್ನೂ ಏನೂ ಇಲ್ಲ ಎಂದು ನೀವು ಭಾವಿಸಿದರೆ, ನೀವು ಸಂಪೂರ್ಣವಾಗಿ ಸರಿಯಾಗುತ್ತೀರಿ. ಅವುಗಳೆಂದರೆ, ಸ್ವೀಕರಿಸಿದ ವಿನಂತಿಗಳನ್ನು ಪ್ರಕ್ರಿಯೆಗೊಳಿಸಲು http://localhost:8080/sentiment, ನಾವು ಸ್ಪ್ರಿಂಗ್ ಅನ್ನು ಆಧರಿಸಿ ವೆಬ್ ಅಪ್ಲಿಕೇಶನ್ ಅನ್ನು ರನ್ ಮಾಡಬೇಕಾಗಿದೆ.
ನಮಗೆ POST ವಿನಂತಿಯನ್ನು ಸ್ವೀಕರಿಸುವ ಸ್ಪ್ರಿಂಗ್ ಅಪ್ಲಿಕೇಶನ್ ಅಗತ್ಯವಿದೆ
▍ಸ್ಪ್ರಿಂಗ್ ಆಧಾರಿತ ವೆಬ್ ಅಪ್ಲಿಕೇಶನ್ ಅನ್ನು ಹೊಂದಿಸಲಾಗುತ್ತಿದೆ
ಸ್ಪ್ರಿಂಗ್ ಅಪ್ಲಿಕೇಶನ್ ಅನ್ನು ನಿಯೋಜಿಸಲು, ನಿಮಗೆ JDK8 ಮತ್ತು Maven ಮತ್ತು ಸರಿಯಾಗಿ ಕಾನ್ಫಿಗರ್ ಮಾಡಲಾದ ಪರಿಸರ ವೇರಿಯೇಬಲ್‌ಗಳ ಅಗತ್ಯವಿದೆ. ಒಮ್ಮೆ ನೀವು ಎಲ್ಲವನ್ನೂ ಸ್ಥಾಪಿಸಿದ ನಂತರ, ನೀವು ನಮ್ಮ ಯೋಜನೆಯಲ್ಲಿ ಕೆಲಸ ಮಾಡುವುದನ್ನು ಮುಂದುವರಿಸಬಹುದು.
▍ಅಪ್ಲಿಕೇಶನ್ ಅನ್ನು ಜಾರ್ ಫೈಲ್‌ಗೆ ಪ್ಯಾಕೇಜಿಂಗ್ ಮಾಡುವುದು
ಟರ್ಮಿನಲ್ ಬಳಸಿ, ಫೋಲ್ಡರ್‌ಗೆ ನ್ಯಾವಿಗೇಟ್ ಮಾಡಿ sa-webapp ಮತ್ತು ಈ ಕೆಳಗಿನ ಆಜ್ಞೆಯನ್ನು ನಮೂದಿಸಿ:
mvn install
ಫೋಲ್ಡರ್ನಲ್ಲಿ ಈ ಆಜ್ಞೆಯನ್ನು ಚಲಾಯಿಸಿದ ನಂತರ sa-webapp ಡೈರೆಕ್ಟರಿಯನ್ನು ರಚಿಸಲಾಗುವುದು target. ಜಾವಾ ಅಪ್ಲಿಕೇಶನ್ ಅನ್ನು ಜಾರ್ ಫೈಲ್ನಲ್ಲಿ ಪ್ಯಾಕ್ ಮಾಡಲಾಗಿದ್ದು, ಫೈಲ್‌ನಿಂದ ಪ್ರತಿನಿಧಿಸಲಾಗುತ್ತದೆ sentiment-analysis-web-0.0.1-SNAPSHOT.jar.
▍ಜಾವಾ ಅಪ್ಲಿಕೇಶನ್ ಅನ್ನು ರನ್ ಮಾಡಲಾಗುತ್ತಿದೆ
ಫೋಲ್ಡರ್‌ಗೆ ಹೋಗಿ target ಮತ್ತು ಈ ಕೆಳಗಿನ ಆಜ್ಞೆಯೊಂದಿಗೆ ಅಪ್ಲಿಕೇಶನ್ ಅನ್ನು ರನ್ ಮಾಡಿ:
java -jar sentiment-analysis-web-0.0.1-SNAPSHOT.jarಈ ಆಜ್ಞೆಯನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸುವಾಗ ದೋಷ ಸಂಭವಿಸುತ್ತದೆ. ಅದನ್ನು ಸರಿಪಡಿಸಲು ಪ್ರಾರಂಭಿಸಲು, ನಾವು ಸ್ಟಾಕ್ ಟ್ರೇಸ್ ಡೇಟಾದಲ್ಲಿ ವಿನಾಯಿತಿ ವಿವರಗಳನ್ನು ವಿಶ್ಲೇಷಿಸಬಹುದು:
Error creating bean with name 'sentimentController': Injection of autowired dependencies failed; nested exception is java.lang.IllegalArgumentException: Could not resolve placeholder 'sa.logic.api.url' in value "${sa.logic.api.url}"
ನಮಗೆ, ಇಲ್ಲಿ ಪ್ರಮುಖ ವಿಷಯವೆಂದರೆ ಅರ್ಥವನ್ನು ಸ್ಪಷ್ಟಪಡಿಸುವ ಅಸಾಧ್ಯತೆಯ ಉಲ್ಲೇಖವಾಗಿದೆ sa.logic.api.url. ದೋಷ ಸಂಭವಿಸುವ ಕೋಡ್ ಅನ್ನು ವಿಶ್ಲೇಷಿಸೋಣ.
▍ಜಾವಾ ಅಪ್ಲಿಕೇಶನ್ ಕೋಡ್ ವಿಶ್ಲೇಷಣೆ
ದೋಷ ಸಂಭವಿಸುವ ಕೋಡ್ ತುಣುಕು ಇಲ್ಲಿದೆ.
@CrossOrigin(origins = "*")
@RestController
public class SentimentController {
@Value("${sa.logic.api.url}") // #1
private String saLogicApiUrl;
@PostMapping("/sentiment")
public SentimentDto sentimentAnalysis(
@RequestBody SentenceDto sentenceDto)
{
RestTemplate restTemplate = new RestTemplate();
return restTemplate.postForEntity(
saLogicApiUrl + "/analyse/sentiment", // #2
sentenceDto, SentimentDto.class)
.getBody();
}
}- ಎಸ್ ನಲ್ಲಿ
entimentControllerಒಂದು ಕ್ಷೇತ್ರವಿದೆsaLogicApiUrl. ಅದರ ಮೌಲ್ಯವನ್ನು ಆಸ್ತಿಯಿಂದ ನಿರ್ದಿಷ್ಟಪಡಿಸಲಾಗಿದೆsa.logic.api.url. - ಸ್ಟ್ರಿಂಗ್
saLogicApiUrlಮೌಲ್ಯದೊಂದಿಗೆ ಸಂಯೋಜಿಸುತ್ತದೆ/analyse/sentiment. ಪಠ್ಯ ವಿಶ್ಲೇಷಣೆಯನ್ನು ನಿರ್ವಹಿಸುವ ಮೈಕ್ರೋ ಸರ್ವೀಸ್‌ಗೆ ಕರೆ ಮಾಡಲು ಅವರು ಒಟ್ಟಿಗೆ ವಿಳಾಸವನ್ನು ರೂಪಿಸುತ್ತಾರೆ.
▍ಆಸ್ತಿ ಮೌಲ್ಯವನ್ನು ಹೊಂದಿಸಿ
ವಸಂತಕಾಲದಲ್ಲಿ, ಆಸ್ತಿ ಮೌಲ್ಯಗಳ ಪ್ರಮಾಣಿತ ಮೂಲವು ಫೈಲ್ ಆಗಿದೆ application.properties, ನಲ್ಲಿ ಕಾಣಬಹುದು sa-webapp/src/main/resources. ಆದರೆ ಅದರ ಬಳಕೆಯು ಆಸ್ತಿ ಮೌಲ್ಯಗಳನ್ನು ಹೊಂದಿಸುವ ಏಕೈಕ ಮಾರ್ಗವಲ್ಲ. ಕೆಳಗಿನ ಆಜ್ಞೆಯನ್ನು ಬಳಸಿಕೊಂಡು ಇದನ್ನು ಸಹ ಮಾಡಬಹುದು:
java -jar sentiment-analysis-web-0.0.1-SNAPSHOT.jar --sa.logic.api.url=WHAT.IS.THE.SA.LOGIC.API.URLಈ ಆಸ್ತಿಯ ಮೌಲ್ಯವು ನಮ್ಮ ಪೈಥಾನ್ ಅಪ್ಲಿಕೇಶನ್‌ನ ವಿಳಾಸವನ್ನು ಸೂಚಿಸಬೇಕು.
ಅದನ್ನು ಕಾನ್ಫಿಗರ್ ಮಾಡುವ ಮೂಲಕ, ಪಠ್ಯ ವಿಶ್ಲೇಷಣೆ ವಿನಂತಿಗಳನ್ನು ನಿರ್ವಹಿಸಲು ಎಲ್ಲಿ ಹೋಗಬೇಕು ಎಂದು ನಾವು ಸ್ಪ್ರಿಂಗ್ ವೆಬ್ ಅಪ್ಲಿಕೇಶನ್‌ಗೆ ಹೇಳುತ್ತೇವೆ.
ನಮ್ಮ ಜೀವನವನ್ನು ಸಂಕೀರ್ಣಗೊಳಿಸದಿರಲು, ಪೈಥಾನ್ ಅಪ್ಲಿಕೇಶನ್ ಇಲ್ಲಿ ಲಭ್ಯವಿರುತ್ತದೆ ಎಂದು ನಾವು ನಿರ್ಧರಿಸುತ್ತೇವೆ localhost:5000 ಮತ್ತು ಅದರ ಬಗ್ಗೆ ಮರೆಯದಿರಲು ಪ್ರಯತ್ನಿಸೋಣ. ಪರಿಣಾಮವಾಗಿ, ಸ್ಪ್ರಿಂಗ್ ಅಪ್ಲಿಕೇಶನ್ ಅನ್ನು ಪ್ರಾರಂಭಿಸುವ ಆಜ್ಞೆಯು ಈ ರೀತಿ ಕಾಣುತ್ತದೆ:
java -jar sentiment-analysis-web-0.0.1-SNAPSHOT.jar --sa.logic.api.url=http://localhost:5000
ನಮ್ಮ ಸಿಸ್ಟಂನಲ್ಲಿ ಪೈಥಾನ್ ಅಪ್ಲಿಕೇಶನ್ ಕಾಣೆಯಾಗಿದೆ
ಈಗ ನಾವು ಮಾಡಬೇಕಾಗಿರುವುದು ಪೈಥಾನ್ ಅಪ್ಲಿಕೇಶನ್ ಅನ್ನು ರನ್ ಮಾಡುವುದು ಮತ್ತು ಸಿಸ್ಟಮ್ ನಿರೀಕ್ಷೆಯಂತೆ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತದೆ.
▍ಪೈಥಾನ್ ಅಪ್ಲಿಕೇಶನ್ ಅನ್ನು ಹೊಂದಿಸಲಾಗುತ್ತಿದೆ
ಪೈಥಾನ್ ಅಪ್ಲಿಕೇಶನ್ ಅನ್ನು ಚಲಾಯಿಸಲು, ನೀವು ಪೈಥಾನ್ 3 ಮತ್ತು ಪಿಪ್ ಅನ್ನು ಸ್ಥಾಪಿಸಿರಬೇಕು ಮತ್ತು ಸೂಕ್ತವಾದ ಪರಿಸರ ವೇರಿಯಬಲ್‌ಗಳನ್ನು ಸರಿಯಾಗಿ ಹೊಂದಿಸಬೇಕು.
▍ಅವಲಂಬನೆಗಳನ್ನು ಸ್ಥಾಪಿಸಲಾಗುತ್ತಿದೆ
ನಿಮ್ಮ ಪ್ರಾಜೆಕ್ಟ್ ಫೋಲ್ಡರ್‌ಗೆ ಹೋಗಿ sa-logic/sa ಮತ್ತು ಕೆಳಗಿನ ಆಜ್ಞೆಗಳನ್ನು ಚಲಾಯಿಸಿ:
python -m pip install -r requirements.txt
python -m textblob.download_corpora▍ಅಪ್ಲಿಕೇಶನ್ ಅನ್ನು ಪ್ರಾರಂಭಿಸಿ
ಅವಲಂಬನೆಗಳನ್ನು ಸ್ಥಾಪಿಸಿದ ನಂತರ, ನಾವು ಅಪ್ಲಿಕೇಶನ್ ಅನ್ನು ಚಲಾಯಿಸಲು ಸಿದ್ಧರಿದ್ದೇವೆ:
python sentiment_analysis.pyಈ ಆಜ್ಞೆಯನ್ನು ಚಲಾಯಿಸಿದ ನಂತರ ನಮಗೆ ಈ ಕೆಳಗಿನವುಗಳನ್ನು ಹೇಳಲಾಗುತ್ತದೆ:
* Running on http://0.0.0.0:5000/ (Press CTRL+C to quit)
ಇದರರ್ಥ ಅಪ್ಲಿಕೇಶನ್ ಚಾಲನೆಯಲ್ಲಿದೆ ಮತ್ತು ವಿನಂತಿಗಳಿಗಾಗಿ ಕಾಯುತ್ತಿದೆ localhost:5000/
▍ಕೋಡ್ ಸಂಶೋಧನೆ
ವಿನಂತಿಗಳಿಗೆ ಅದು ಹೇಗೆ ಪ್ರತಿಕ್ರಿಯಿಸುತ್ತದೆ ಎಂಬುದನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳಲು ಪೈಥಾನ್ ಅಪ್ಲಿಕೇಶನ್ ಕೋಡ್ ಅನ್ನು ನೋಡೋಣ:
from textblob import TextBlob
from flask import Flask, request, jsonify
app = Flask(__name__) #1
@app.route("/analyse/sentiment", methods=['POST']) #2
def analyse_sentiment():
sentence = request.get_json()['sentence'] #3
polarity = TextBlob(sentence).sentences[0].polarity #4
return jsonify( #5
sentence=sentence,
polarity=polarity
)
if __name__ == '__main__':
app.run(host='0.0.0.0', port=5000) #6- ವಸ್ತುವನ್ನು ಪ್ರಾರಂಭಿಸುವುದು
Flask. - POST ವಿನಂತಿಗಳನ್ನು ನಿರ್ವಹಿಸಲು ವಿಳಾಸವನ್ನು ನಿರ್ದಿಷ್ಟಪಡಿಸುವುದು.
- ಆಸ್ತಿಯನ್ನು ಹಿಂಪಡೆಯುವುದು
sentenceವಿನಂತಿಯ ದೇಹದಿಂದ. - ಅನಾಮಧೇಯ ವಸ್ತುವನ್ನು ಪ್ರಾರಂಭಿಸುವುದು
TextBlobಮತ್ತು ಮೌಲ್ಯವನ್ನು ಪಡೆಯುವುದುpolarityವಿನಂತಿಯ ದೇಹದಲ್ಲಿ ಸ್ವೀಕರಿಸಿದ ಮೊದಲ ವಾಕ್ಯಕ್ಕಾಗಿ (ನಮ್ಮ ಸಂದರ್ಭದಲ್ಲಿ, ಇದು ವಿಶ್ಲೇಷಣೆಗಾಗಿ ಕಳುಹಿಸಲಾದ ಏಕೈಕ ವಾಕ್ಯವಾಗಿದೆ). - ವಾಕ್ಯದ ಪಠ್ಯ ಮತ್ತು ಅದರ ಲೆಕ್ಕಾಚಾರದ ಸೂಚಕವನ್ನು ಒಳಗೊಂಡಿರುವ ಪ್ರತಿಕ್ರಿಯೆಯನ್ನು ಹಿಂತಿರುಗಿಸುವುದು
polarity. - ಫ್ಲಾಸ್ಕ್ ಅಪ್ಲಿಕೇಶನ್ ಅನ್ನು ಪ್ರಾರಂಭಿಸಿ, ಅದು ಇಲ್ಲಿ ಲಭ್ಯವಿರುತ್ತದೆ
0.0.0.0:5000(ಫಾರ್ಮ್‌ನ ನಿರ್ಮಾಣವನ್ನು ಬಳಸಿಕೊಂಡು ನೀವು ಅದನ್ನು ಪ್ರವೇಶಿಸಬಹುದುlocalhost:5000).
ಅಪ್ಲಿಕೇಶನ್ ಅನ್ನು ರೂಪಿಸುವ ಮೈಕ್ರೋ ಸರ್ವೀಸ್‌ಗಳು ಈಗ ಚಾಲನೆಯಲ್ಲಿವೆ. ಅವರು ಪರಸ್ಪರ ಸಂವಹನ ನಡೆಸಲು ಟ್ಯೂನ್ ಮಾಡಲಾಗಿದೆ. ಕೆಲಸದ ಈ ಹಂತದಲ್ಲಿ ಅಪ್ಲಿಕೇಶನ್ ರೇಖಾಚಿತ್ರವು ಹೇಗೆ ಕಾಣುತ್ತದೆ.
ಅಪ್ಲಿಕೇಶನ್ ಅನ್ನು ರೂಪಿಸುವ ಎಲ್ಲಾ ಸೂಕ್ಷ್ಮ ಸೇವೆಗಳನ್ನು ಕಾರ್ಯ ಕ್ರಮಕ್ಕೆ ತರಲಾಗುತ್ತದೆ
ಈಗ, ನೀವು ಮುಂದುವರಿಯುವ ಮೊದಲು, ನಿಮ್ಮ ರಿಯಾಕ್ಟ್ ಅಪ್ಲಿಕೇಶನ್ ಅನ್ನು ಬ್ರೌಸರ್‌ನಲ್ಲಿ ತೆರೆಯಿರಿ ಮತ್ತು ಅದರೊಂದಿಗೆ ಕೆಲವು ವಾಕ್ಯಗಳನ್ನು ಪಾರ್ಸ್ ಮಾಡಲು ಪ್ರಯತ್ನಿಸಿ. ಎಲ್ಲವನ್ನೂ ಸರಿಯಾಗಿ ಮಾಡಿದರೆ - ಗುಂಡಿಯನ್ನು ಒತ್ತುವ ನಂತರ Send ನೀವು ಪಠ್ಯ ಕ್ಷೇತ್ರದ ಕೆಳಗೆ ವಿಶ್ಲೇಷಣೆ ಫಲಿತಾಂಶಗಳನ್ನು ನೋಡುತ್ತೀರಿ.
ಮುಂದಿನ ವಿಭಾಗದಲ್ಲಿ, ಡಾಕರ್ ಕಂಟೈನರ್‌ಗಳಲ್ಲಿ ನಮ್ಮ ಮೈಕ್ರೊ ಸರ್ವೀಸ್‌ಗಳನ್ನು ಹೇಗೆ ರನ್ ಮಾಡುವುದು ಎಂಬುದರ ಕುರಿತು ನಾವು ಮಾತನಾಡುತ್ತೇವೆ. ಕುಬರ್ನೆಟ್ಸ್ ಕ್ಲಸ್ಟರ್‌ನಲ್ಲಿ ರನ್ ಮಾಡಲು ಅಪ್ಲಿಕೇಶನ್ ಅನ್ನು ಸಿದ್ಧಪಡಿಸಲು ಇದು ಅವಶ್ಯಕವಾಗಿದೆ.
ಡಾಕರ್ ಕಂಟೈನರ್ಗಳು
ಕಂಟೈನರೈಸ್ಡ್ ಅಪ್ಲಿಕೇಶನ್‌ಗಳ ನಿಯೋಜನೆ, ಸ್ಕೇಲಿಂಗ್ ಮತ್ತು ನಿರ್ವಹಣೆಯನ್ನು ಸ್ವಯಂಚಾಲಿತಗೊಳಿಸುವ ವ್ಯವಸ್ಥೆಯಾಗಿದೆ. ಇದನ್ನು "ಕಂಟೇನರ್ ಆರ್ಕೆಸ್ಟ್ರೇಟರ್" ಎಂದೂ ಕರೆಯುತ್ತಾರೆ. ಕುಬರ್ನೆಟ್ಸ್ ಕಂಟೇನರ್‌ಗಳೊಂದಿಗೆ ಕೆಲಸ ಮಾಡುತ್ತಿದ್ದರೆ, ಈ ವ್ಯವಸ್ಥೆಯನ್ನು ಬಳಸುವ ಮೊದಲು ನಾವು ಮೊದಲು ಈ ಪಾತ್ರೆಗಳನ್ನು ಪಡೆದುಕೊಳ್ಳಬೇಕು. ಆದರೆ ಮೊದಲು, ಪಾತ್ರೆಗಳು ಯಾವುವು ಎಂಬುದರ ಕುರಿತು ಮಾತನಾಡೋಣ. ಬಹುಶಃ ಅದು ಏನು ಎಂಬ ಪ್ರಶ್ನೆಗೆ ಉತ್ತಮ ಉತ್ತರವನ್ನು ಕಾಣಬಹುದು ಡಾಕರ್‌ಗೆ:
ಕಂಟೈನರ್ ಚಿತ್ರವು ಹಗುರವಾದ, ಸ್ವಯಂ-ಒಳಗೊಂಡಿರುವ, ಕಾರ್ಯಗತಗೊಳಿಸಬಹುದಾದ ಅಪ್ಲಿಕೇಶನ್ ಅನ್ನು ಹೊಂದಿರುವ ಅಪ್ಲಿಕೇಶನ್ ಆಗಿದೆ, ಇದು ಅದನ್ನು ಚಲಾಯಿಸಲು ಅಗತ್ಯವಿರುವ ಎಲ್ಲವನ್ನೂ ಒಳಗೊಂಡಿರುತ್ತದೆ: ಅಪ್ಲಿಕೇಶನ್ ಕೋಡ್, ಎಕ್ಸಿಕ್ಯೂಶನ್ ಪರಿಸರ, ಸಿಸ್ಟಮ್ ಪರಿಕರಗಳು ಮತ್ತು ಲೈಬ್ರರಿಗಳು, ಸೆಟ್ಟಿಂಗ್‌ಗಳು. ಕಂಟೈನರೈಸ್ಡ್ ಪ್ರೋಗ್ರಾಂಗಳನ್ನು ಲಿನಕ್ಸ್ ಮತ್ತು ವಿಂಡೋಸ್ ಪರಿಸರದಲ್ಲಿ ಬಳಸಬಹುದು ಮತ್ತು ಮೂಲಸೌಕರ್ಯವನ್ನು ಲೆಕ್ಕಿಸದೆ ಅವು ಯಾವಾಗಲೂ ಒಂದೇ ರೀತಿ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತವೆ.
ಇದರರ್ಥ ಪ್ರೊಡಕ್ಷನ್ ಸರ್ವರ್‌ಗಳು ಸೇರಿದಂತೆ ಯಾವುದೇ ಕಂಪ್ಯೂಟರ್‌ನಲ್ಲಿ ಕಂಟೇನರ್‌ಗಳನ್ನು ಚಲಾಯಿಸಬಹುದು ಮತ್ತು ಅವುಗಳಲ್ಲಿ ಒಳಗೊಂಡಿರುವ ಅಪ್ಲಿಕೇಶನ್‌ಗಳು ಯಾವುದೇ ಪರಿಸರದಲ್ಲಿ ಒಂದೇ ರೀತಿ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತವೆ.
ಕಂಟೇನರ್‌ಗಳ ವೈಶಿಷ್ಟ್ಯಗಳನ್ನು ಅನ್ವೇಷಿಸಲು ಮತ್ತು ಅಪ್ಲಿಕೇಶನ್‌ಗಳನ್ನು ಚಲಾಯಿಸಲು ಇತರ ವಿಧಾನಗಳೊಂದಿಗೆ ಹೋಲಿಸಲು, ವರ್ಚುವಲ್ ಯಂತ್ರ ಮತ್ತು ಕಂಟೇನರ್ ಅನ್ನು ಬಳಸಿಕೊಂಡು ರಿಯಾಕ್ಟ್ ಅಪ್ಲಿಕೇಶನ್ ಅನ್ನು ಒದಗಿಸುವ ಉದಾಹರಣೆಯನ್ನು ನೋಡೋಣ.
▍ವರ್ಚುವಲ್ ಯಂತ್ರವನ್ನು ಬಳಸಿಕೊಂಡು ರಿಯಾಕ್ಟ್ ಅಪ್ಲಿಕೇಶನ್‌ನ ಸ್ಥಿರ ಫೈಲ್‌ಗಳನ್ನು ಒದಗಿಸುವುದು
ವರ್ಚುವಲ್ ಯಂತ್ರಗಳನ್ನು ಬಳಸಿಕೊಂಡು ಸ್ಥಿರ ಫೈಲ್‌ಗಳ ಸೇವೆಯನ್ನು ಸಂಘಟಿಸಲು ಪ್ರಯತ್ನಿಸುವಾಗ, ನಾವು ಈ ಕೆಳಗಿನ ಅನಾನುಕೂಲಗಳನ್ನು ಎದುರಿಸುತ್ತೇವೆ:
- ಸಂಪನ್ಮೂಲಗಳ ಅಸಮರ್ಥ ಬಳಕೆ, ಏಕೆಂದರೆ ಪ್ರತಿ ವರ್ಚುವಲ್ ಯಂತ್ರವು ಪೂರ್ಣ ಪ್ರಮಾಣದ ಆಪರೇಟಿಂಗ್ ಸಿಸ್ಟಮ್ ಆಗಿದೆ.
- ವೇದಿಕೆ ಅವಲಂಬನೆ. ಸ್ಥಳೀಯ ಕಂಪ್ಯೂಟರ್‌ನಲ್ಲಿ ಏನು ಕೆಲಸ ಮಾಡುತ್ತದೆ ಎಂಬುದು ಉತ್ಪಾದನಾ ಸರ್ವರ್‌ನಲ್ಲಿ ಕಾರ್ಯನಿರ್ವಹಿಸದಿರಬಹುದು.
- ವರ್ಚುವಲ್ ಯಂತ್ರ-ಆಧಾರಿತ ಪರಿಹಾರದ ನಿಧಾನ ಮತ್ತು ಸಂಪನ್ಮೂಲ-ತೀವ್ರ ಸ್ಕೇಲಿಂಗ್.
Nginx ವೆಬ್ ಸರ್ವರ್ ವರ್ಚುವಲ್ ಗಣಕದಲ್ಲಿ ಚಾಲನೆಯಲ್ಲಿರುವ ಸ್ಥಿರ ಫೈಲ್‌ಗಳನ್ನು ಒದಗಿಸುತ್ತದೆ
ಇದೇ ರೀತಿಯ ಸಮಸ್ಯೆಯನ್ನು ಪರಿಹರಿಸಲು ಕಂಟೇನರ್‌ಗಳನ್ನು ಬಳಸಿದರೆ, ವರ್ಚುವಲ್ ಯಂತ್ರಗಳಿಗೆ ಹೋಲಿಸಿದರೆ, ಈ ಕೆಳಗಿನ ಸಾಮರ್ಥ್ಯಗಳನ್ನು ಗಮನಿಸಬಹುದು:
- ಸಂಪನ್ಮೂಲಗಳ ಸಮರ್ಥ ಬಳಕೆ: ಡಾಕರ್ ಬಳಸಿ ಆಪರೇಟಿಂಗ್ ಸಿಸ್ಟಮ್‌ನೊಂದಿಗೆ ಕೆಲಸ ಮಾಡುವುದು.
- ವೇದಿಕೆ ಸ್ವತಂತ್ರ. ಡೆವಲಪರ್ ತನ್ನ ಕಂಪ್ಯೂಟರ್‌ನಲ್ಲಿ ರನ್ ಮಾಡಬಹುದಾದ ಕಂಟೇನರ್ ಎಲ್ಲಿಯಾದರೂ ಕೆಲಸ ಮಾಡುತ್ತದೆ.
- ಇಮೇಜ್ ಲೇಯರ್‌ಗಳ ಬಳಕೆಯ ಮೂಲಕ ಹಗುರವಾದ ನಿಯೋಜನೆ.
ಕಂಟೇನರ್‌ನಲ್ಲಿ ಚಾಲನೆಯಲ್ಲಿರುವ ಸ್ಥಿರ ಫೈಲ್‌ಗಳನ್ನು ಒದಗಿಸುವ Nginx ವೆಬ್ ಸರ್ವರ್
ನಾವು ವರ್ಚುವಲ್ ಯಂತ್ರಗಳು ಮತ್ತು ಕಂಟೇನರ್‌ಗಳನ್ನು ಕೆಲವು ಅಂಶಗಳಲ್ಲಿ ಮಾತ್ರ ಹೋಲಿಸಿದ್ದೇವೆ, ಆದರೆ ಕಂಟೈನರ್‌ಗಳ ಸಾಮರ್ಥ್ಯದ ಅನುಭವವನ್ನು ಪಡೆಯಲು ಇದು ಸಾಕು. ಡಾಕರ್ ಕಂಟೈನರ್‌ಗಳ ಕುರಿತು ನೀವು ವಿವರಗಳನ್ನು ಕಾಣಬಹುದು.
▍ಪ್ರತಿಕ್ರಿಯಾತ್ಮಕ ಅಪ್ಲಿಕೇಶನ್ಗಾಗಿ ಕಂಟೇನರ್ ಚಿತ್ರವನ್ನು ನಿರ್ಮಿಸುವುದು
ಡಾಕರ್ ಕಂಟೇನರ್‌ನ ಮೂಲ ಬಿಲ್ಡಿಂಗ್ ಬ್ಲಾಕ್ ಫೈಲ್ ಆಗಿದೆ Dockerfile. ಈ ಫೈಲ್‌ನ ಆರಂಭದಲ್ಲಿ, ಕಂಟೇನರ್‌ನ ಬೇಸ್ ಇಮೇಜ್‌ನಿಂದ ದಾಖಲೆಯನ್ನು ಮಾಡಲಾಗಿದೆ, ನಂತರ ನಿರ್ದಿಷ್ಟ ಅಪ್ಲಿಕೇಶನ್‌ನ ಅಗತ್ಯತೆಗಳನ್ನು ಪೂರೈಸುವ ಕಂಟೇನರ್ ಅನ್ನು ಹೇಗೆ ರಚಿಸುವುದು ಎಂದು ಸೂಚಿಸುವ ಸೂಚನೆಗಳ ಅನುಕ್ರಮವಿದೆ.
ನಾವು ಫೈಲ್ನೊಂದಿಗೆ ಕೆಲಸ ಮಾಡಲು ಪ್ರಾರಂಭಿಸುವ ಮೊದಲು Dockerfile, Nginx ಸರ್ವರ್‌ಗೆ ಅಪ್‌ಲೋಡ್ ಮಾಡಲು ರಿಯಾಕ್ಟ್ ಅಪ್ಲಿಕೇಶನ್ ಫೈಲ್‌ಗಳನ್ನು ತಯಾರಿಸಲು ನಾವು ಏನು ಮಾಡಿದ್ದೇವೆ ಎಂಬುದನ್ನು ನೆನಪಿಸೋಣ:
- ರಿಯಾಕ್ಟ್ ಅಪ್ಲಿಕೇಶನ್ ಪ್ಯಾಕೇಜ್ ಅನ್ನು ನಿರ್ಮಿಸುವುದು (
npm run build). - Nginx ಸರ್ವರ್ ಅನ್ನು ಪ್ರಾರಂಭಿಸಲಾಗುತ್ತಿದೆ.
- ಡೈರೆಕ್ಟರಿ ವಿಷಯಗಳನ್ನು ನಕಲಿಸಲಾಗುತ್ತಿದೆ
buildಯೋಜನೆಯ ಫೋಲ್ಡರ್ನಿಂದsa-frontendಸರ್ವರ್ ಫೋಲ್ಡರ್‌ಗೆnginx/html.
ಕಂಟೇನರ್ ಅನ್ನು ರಚಿಸುವುದು ಮತ್ತು ನಿಮ್ಮ ಸ್ಥಳೀಯ ಕಂಪ್ಯೂಟರ್‌ನಲ್ಲಿ ನಿರ್ವಹಿಸಲಾದ ಮೇಲಿನ ಹಂತಗಳ ನಡುವಿನ ಸಮಾನಾಂತರಗಳನ್ನು ನೀವು ಕೆಳಗೆ ನೋಡಬಹುದು.
▍ಎಸ್‌ಎ-ಫ್ರಂಟೆಂಡ್ ಅಪ್ಲಿಕೇಶನ್ಗಾಗಿ ಡಾಕರ್‌ಫೈಲ್ ಅನ್ನು ಸಿದ್ಧಪಡಿಸುವುದು
ಒಳಗೊಂಡಿರುವ ಸೂಚನೆಗಳು Dockerfile ಅಪ್ಲಿಕೇಶನ್ಗಾಗಿ SA-Frontend, ಕೇವಲ ಎರಡು ತಂಡಗಳನ್ನು ಒಳಗೊಂಡಿರುತ್ತದೆ. ವಾಸ್ತವವಾಗಿ Nginx ಅಭಿವೃದ್ಧಿ ತಂಡವು ಮೂಲಭೂತವನ್ನು ಸಿದ್ಧಪಡಿಸಿದೆ Nginx ಗಾಗಿ, ನಮ್ಮ ಚಿತ್ರವನ್ನು ರಚಿಸಲು ನಾವು ಬಳಸುತ್ತೇವೆ. ನಾವು ವಿವರಿಸಬೇಕಾದ ಎರಡು ಹಂತಗಳು ಇವು:
- ಚಿತ್ರದ ಆಧಾರವು Nginx ಚಿತ್ರವಾಗಿರಬೇಕು.
- ಫೋಲ್ಡರ್ ವಿಷಯಗಳು
sa-frontend/buildಇಮೇಜ್ ಫೋಲ್ಡರ್‌ಗೆ ನಕಲಿಸಬೇಕಾಗಿದೆnginx/html.
ನೀವು ಈ ವಿವರಣೆಯಿಂದ ಫೈಲ್‌ಗೆ ಹೋದರೆ Dockerfile, ನಂತರ ಅದು ಈ ರೀತಿ ಕಾಣುತ್ತದೆ:
FROM nginx
COPY build /usr/share/nginx/html
ನೀವು ನೋಡುವಂತೆ, ಇಲ್ಲಿ ಎಲ್ಲವೂ ತುಂಬಾ ಸರಳವಾಗಿದೆ, ಮತ್ತು ಫೈಲ್‌ನ ವಿಷಯಗಳು ಸಾಕಷ್ಟು ಓದಬಲ್ಲ ಮತ್ತು ಅರ್ಥವಾಗುವಂತಹದ್ದಾಗಿದೆ. ಈ ಫೈಲ್ ಚಿತ್ರವನ್ನು ತೆಗೆದುಕೊಳ್ಳಲು ಸಿಸ್ಟಮ್‌ಗೆ ಹೇಳುತ್ತದೆ nginx ಈಗಾಗಲೇ ಅದರಲ್ಲಿರುವ ಎಲ್ಲದರೊಂದಿಗೆ, ಮತ್ತು ಡೈರೆಕ್ಟರಿಯ ವಿಷಯಗಳನ್ನು ನಕಲಿಸಿ build ಡೈರೆಕ್ಟರಿಗೆ nginx/html.
ಇಲ್ಲಿ ನೀವು ಫೋಲ್ಡರ್ನಿಂದ ಫೈಲ್‌ಗಳನ್ನು ನಿಖರವಾಗಿ ಎಲ್ಲಿ ನಕಲಿಸಬೇಕು ಎಂದು ನನಗೆ ಹೇಗೆ ಗೊತ್ತು ಎಂಬ ಪ್ರಶ್ನೆಯನ್ನು ನೀವು ಹೊಂದಿರಬಹುದು build, ಅಂದರೆ, ಮಾರ್ಗವು ಎಲ್ಲಿಂದ ಬಂತು /usr/share/nginx/html. ವಾಸ್ತವವಾಗಿ, ಇಲ್ಲಿ ಸಂಕೀರ್ಣವಾದ ಏನೂ ಇಲ್ಲ. ಸತ್ಯವೆಂದರೆ ಸಂಬಂಧಿತ ಮಾಹಿತಿಯನ್ನು ಕಾಣಬಹುದು ಚಿತ್ರ.
▍ಚಿತ್ರವನ್ನು ನಿರ್ಮಿಸುವುದು ಮತ್ತು ಅದನ್ನು ರೆಪೊಸಿಟರಿಗೆ ಅಪ್‌ಲೋಡ್ ಮಾಡುವುದು
ನಾವು ಮುಗಿದ ಚಿತ್ರದೊಂದಿಗೆ ಕೆಲಸ ಮಾಡುವ ಮೊದಲು, ನಾವು ಅದನ್ನು ಇಮೇಜ್ ರೆಪೊಸಿಟರಿಗೆ ತಳ್ಳಬೇಕು. ಇದನ್ನು ಮಾಡಲು, ನಾವು ಉಚಿತ ಕ್ಲೌಡ್ ಇಮೇಜ್ ಹೋಸ್ಟಿಂಗ್ ಪ್ಲಾಟ್‌ಫಾರ್ಮ್ ಡಾಕರ್ ಹಬ್ ಅನ್ನು ಬಳಸುತ್ತೇವೆ. ಕೆಲಸದ ಈ ಹಂತದಲ್ಲಿ ನೀವು ಈ ಕೆಳಗಿನವುಗಳನ್ನು ಮಾಡಬೇಕಾಗಿದೆ:
- ಸ್ಥಾಪಿಸಿ .
- ಡಾಕರ್ ಹಬ್ ವೆಬ್‌ಸೈಟ್‌ನಲ್ಲಿ ನೋಂದಾಯಿಸಿ.
- ಟರ್ಮಿನಲ್‌ನಲ್ಲಿ ಈ ಕೆಳಗಿನ ಆಜ್ಞೆಯನ್ನು ಚಲಾಯಿಸುವ ಮೂಲಕ ನಿಮ್ಮ ಖಾತೆಗೆ ಲಾಗ್ ಇನ್ ಮಾಡಿ:
docker login -u="$DOCKER_USERNAME" -p="$DOCKER_PASSWORD"
ಈಗ ನೀವು ಡೈರೆಕ್ಟರಿಗೆ ಹೋಗಲು ಟರ್ಮಿನಲ್ ಅನ್ನು ಬಳಸಬೇಕಾಗುತ್ತದೆ sa-frontend ಮತ್ತು ಕೆಳಗಿನ ಆಜ್ಞೆಯನ್ನು ಅಲ್ಲಿ ಚಲಾಯಿಸಿ:
docker build -f Dockerfile -t $DOCKER_USER_ID/sentiment-analysis-frontend .
ಇಲ್ಲಿ ಮತ್ತು ಮುಂದೆ ಇದೇ ರೀತಿಯ ಆಜ್ಞೆಗಳಲ್ಲಿ $DOCKER_USER_ID ನಿಮ್ಮ ಡಾಕರ್ ಹಬ್ ಬಳಕೆದಾರಹೆಸರಿನೊಂದಿಗೆ ಬದಲಾಯಿಸಬೇಕು. ಉದಾಹರಣೆಗೆ, ಆಜ್ಞೆಯ ಈ ಭಾಗವು ಈ ರೀತಿ ಕಾಣಿಸಬಹುದು: rinormaloku/sentiment-analysis-frontend.
ಈ ಸಂದರ್ಭದಲ್ಲಿ, ಈ ಆಜ್ಞೆಯನ್ನು ಅದರಿಂದ ತೆಗೆದುಹಾಕುವ ಮೂಲಕ ಕಡಿಮೆ ಮಾಡಬಹುದು -f Dockerfile, ನಾವು ಈ ಆಜ್ಞೆಯನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸುತ್ತಿರುವ ಫೋಲ್ಡರ್ನಲ್ಲಿ ಈ ಫೈಲ್ ಈಗಾಗಲೇ ಅಸ್ತಿತ್ವದಲ್ಲಿದೆ.
ಸಿದ್ಧಪಡಿಸಿದ ಚಿತ್ರವನ್ನು ರೆಪೊಸಿಟರಿಗೆ ಕಳುಹಿಸಲು, ನಮಗೆ ಈ ಕೆಳಗಿನ ಆಜ್ಞೆಯ ಅಗತ್ಯವಿದೆ:
docker push $DOCKER_USER_ID/sentiment-analysis-frontendಅದನ್ನು ಪೂರ್ಣಗೊಳಿಸಿದ ನಂತರ, ಕ್ಲೌಡ್ ಸಂಗ್ರಹಣೆಗೆ ಚಿತ್ರದ ಅಪ್‌ಲೋಡ್ ಯಶಸ್ವಿಯಾಗಿದೆಯೇ ಎಂಬುದನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳಲು ಡಾಕರ್ ಹಬ್‌ನಲ್ಲಿ ನಿಮ್ಮ ರೆಪೊಸಿಟರಿಗಳ ಪಟ್ಟಿಯನ್ನು ಪರಿಶೀಲಿಸಿ.
▍ಒಂದು ಕಂಟೇನರ್ ರನ್ನಿಂಗ್
ಈಗ ಯಾರಾದರೂ ಚಿತ್ರವನ್ನು ಡೌನ್‌ಲೋಡ್ ಮಾಡಬಹುದು ಮತ್ತು ರನ್ ಮಾಡಬಹುದು, ಎಂದು ಕರೆಯಲಾಗುತ್ತದೆ $DOCKER_USER_ID/sentiment-analysis-frontend. ಇದನ್ನು ಮಾಡಲು, ನೀವು ಈ ಕೆಳಗಿನ ಆಜ್ಞೆಗಳ ಅನುಕ್ರಮವನ್ನು ಚಲಾಯಿಸಬೇಕು:
docker pull $DOCKER_USER_ID/sentiment-analysis-frontend
docker run -d -p 80:80 $DOCKER_USER_ID/sentiment-analysis-frontend
ಈಗ ಕಂಟೇನರ್ ಚಾಲನೆಯಲ್ಲಿದೆ, ನಮಗೆ ಅಗತ್ಯವಿರುವ ಇತರ ಚಿತ್ರಗಳನ್ನು ರಚಿಸುವ ಮೂಲಕ ನಾವು ಕೆಲಸವನ್ನು ಮುಂದುವರಿಸಬಹುದು. ಆದರೆ ನಾವು ಮುಂದುವರಿಯುವ ಮೊದಲು, ವಿನ್ಯಾಸವನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳೋಣ 80:80, ಇದು ಇಮೇಜ್ ಲಾಂಚ್ ಆಜ್ಞೆಯಲ್ಲಿ ಕಾಣಿಸಿಕೊಳ್ಳುತ್ತದೆ ಮತ್ತು ಗೊಂದಲಮಯವಾಗಿ ಕಾಣಿಸಬಹುದು.
- ಮೊದಲ ಸಂಖ್ಯೆ
80— ಇದು ಹೋಸ್ಟ್ ಪೋರ್ಟ್ ಸಂಖ್ಯೆ (ಅಂದರೆ, ಸ್ಥಳೀಯ ಕಂಪ್ಯೂಟರ್). - ಎರಡನೇ ಸಂಖ್ಯೆ
80ವಿನಂತಿಯನ್ನು ಫಾರ್ವರ್ಡ್ ಮಾಡಬೇಕಾದ ಕಂಟೇನರ್‌ನ ಪೋರ್ಟ್ ಆಗಿದೆ.
ಕೆಳಗಿನ ದೃಷ್ಟಾಂತವನ್ನು ಪರಿಗಣಿಸಿ.
ಪೋರ್ಟ್ ಫಾರ್ವರ್ಡ್ ಮಾಡುವಿಕೆ
ಸಿಸ್ಟಮ್ ಪೋರ್ಟ್‌ನಿಂದ ವಿನಂತಿಗಳನ್ನು ಮರುನಿರ್ದೇಶಿಸುತ್ತದೆ <hostPort> ಬಂದರಿಗೆ <containerPort>. ಅಂದರೆ, ಬಂದರಿಗೆ ಪ್ರವೇಶ 80 ಕಂಪ್ಯೂಟರ್ ಅನ್ನು ಪೋರ್ಟ್‌ಗೆ ಮರುನಿರ್ದೇಶಿಸಲಾಗುತ್ತದೆ 80 ಕಂಟೇನರ್.
ಬಂದರಿನಿಂದ 80 ಸ್ಥಳೀಯ ಕಂಪ್ಯೂಟರ್‌ನಲ್ಲಿ ತೆರೆಯಲಾಗಿದೆ, ನಂತರ ನೀವು ಈ ಕಂಪ್ಯೂಟರ್‌ನಿಂದ ಅಪ್ಲಿಕೇಶನ್ ಅನ್ನು ಪ್ರವೇಶಿಸಬಹುದು localhost:80. ನಿಮ್ಮ ಸಿಸ್ಟಮ್ ಡಾಕರ್ ಅನ್ನು ಬೆಂಬಲಿಸದಿದ್ದರೆ, ಅಪ್ಲಿಕೇಶನ್ ಅನ್ನು ಡಾಕರ್ ವರ್ಚುವಲ್ ಗಣಕದಲ್ಲಿ ರನ್ ಮಾಡಬಹುದು, ಅದರ ವಿಳಾಸವು ಈ ರೀತಿ ಕಾಣುತ್ತದೆ <docker-machine ip>:80. ಡಾಕರ್ ವರ್ಚುವಲ್ ಯಂತ್ರದ IP ವಿಳಾಸವನ್ನು ಕಂಡುಹಿಡಿಯಲು, ನೀವು ಆಜ್ಞೆಯನ್ನು ಬಳಸಬಹುದು docker-machine ip.
ಈ ಹಂತದಲ್ಲಿ, ಫ್ರಂಟ್-ಎಂಡ್ ಅಪ್ಲಿಕೇಶನ್ ಕಂಟೇನರ್ ಅನ್ನು ಯಶಸ್ವಿಯಾಗಿ ಪ್ರಾರಂಭಿಸಿದ ನಂತರ, ನೀವು ಅದರ ಪುಟವನ್ನು ಬ್ರೌಸರ್‌ನಲ್ಲಿ ತೆರೆಯಲು ಸಾಧ್ಯವಾಗುತ್ತದೆ.
▍The .dockerignore ಫೈಲ್
ಅಪ್ಲಿಕೇಶನ್ ಚಿತ್ರವನ್ನು ಸಂಗ್ರಹಿಸಲಾಗುತ್ತಿದೆ SA-Frontend, ಈ ಪ್ರಕ್ರಿಯೆಯು ಅತ್ಯಂತ ನಿಧಾನವಾಗಿದೆ ಎಂದು ನಾವು ಗಮನಿಸಬಹುದು. ಇದು ಸಂಭವಿಸುತ್ತದೆ ಏಕೆಂದರೆ ಚಿತ್ರದ ನಿರ್ಮಾಣ ಸಂದರ್ಭವನ್ನು ಡಾಕರ್ ಡೀಮನ್‌ಗೆ ಕಳುಹಿಸಬೇಕು. ನಿರ್ಮಾಣ ಸಂದರ್ಭವನ್ನು ಪ್ರತಿನಿಧಿಸುವ ಡೈರೆಕ್ಟರಿಯನ್ನು ಆಜ್ಞೆಯ ಕೊನೆಯ ಆರ್ಗ್ಯುಮೆಂಟ್ ಎಂದು ನಿರ್ದಿಷ್ಟಪಡಿಸಲಾಗಿದೆ docker build. ನಮ್ಮ ಸಂದರ್ಭದಲ್ಲಿ, ಈ ಆಜ್ಞೆಯ ಕೊನೆಯಲ್ಲಿ ಒಂದು ಚುಕ್ಕೆ ಇದೆ. ಇದು ನಿರ್ಮಾಣದ ಸಂದರ್ಭದಲ್ಲಿ ಈ ಕೆಳಗಿನ ರಚನೆಯನ್ನು ಸೇರಿಸಲು ಕಾರಣವಾಗುತ್ತದೆ:
sa-frontend:
| .dockerignore
| Dockerfile
| package.json
| README.md
+---build
+---node_modules
+---public
---src
ಆದರೆ ಇಲ್ಲಿ ಇರುವ ಎಲ್ಲಾ ಫೋಲ್ಡರ್‌ಗಳಲ್ಲಿ ನಮಗೆ ಫೋಲ್ಡರ್ ಮಾತ್ರ ಅಗತ್ಯವಿದೆ build. ಬೇರೆ ಯಾವುದನ್ನಾದರೂ ಲೋಡ್ ಮಾಡುವುದು ಸಮಯ ವ್ಯರ್ಥ. ಯಾವ ಡೈರೆಕ್ಟರಿಗಳನ್ನು ನಿರ್ಲಕ್ಷಿಸಬೇಕೆಂದು ಡಾಕರ್‌ಗೆ ಹೇಳುವ ಮೂಲಕ ನೀವು ನಿರ್ಮಾಣವನ್ನು ವೇಗಗೊಳಿಸಬಹುದು. ಇದನ್ನು ಮಾಡಲು ನಮಗೆ ಫೈಲ್ ಅಗತ್ಯವಿದೆ .dockerignore. ನೀವು, ನೀವು ಫೈಲ್ ಪರಿಚಿತರಾಗಿದ್ದರೆ .gitignore, ಈ ಫೈಲ್‌ನ ರಚನೆಯು ಬಹುಶಃ ಪರಿಚಿತವಾಗಿದೆ ಎಂದು ತೋರುತ್ತದೆ. ಇಮೇಜ್ ಬಿಲ್ಡ್ ಸಿಸ್ಟಮ್ ನಿರ್ಲಕ್ಷಿಸಬಹುದಾದ ಡೈರೆಕ್ಟರಿಗಳನ್ನು ಇದು ಪಟ್ಟಿ ಮಾಡುತ್ತದೆ. ನಮ್ಮ ಸಂದರ್ಭದಲ್ಲಿ, ಈ ಫೈಲ್‌ನ ವಿಷಯಗಳು ಈ ರೀತಿ ಕಾಣುತ್ತವೆ:
node_modules
src
public
ಕಡತ .dockerignore ಫೈಲ್‌ನ ಅದೇ ಫೋಲ್ಡರ್‌ನಲ್ಲಿರಬೇಕು Dockerfile. ಈಗ ಚಿತ್ರವನ್ನು ನಿರ್ಮಿಸಲು ಸೆಕೆಂಡುಗಳು ತೆಗೆದುಕೊಳ್ಳುತ್ತದೆ.
ಈಗ ಜಾವಾ ಅಪ್ಲಿಕೇಶನ್ಗಾಗಿ ಚಿತ್ರದ ಮೇಲೆ ಕೆಲಸ ಮಾಡೋಣ.
▍ಜಾವಾ ಅಪ್ಲಿಕೇಶನ್ಗಾಗಿ ಕಂಟೇನರ್ ಚಿತ್ರವನ್ನು ನಿರ್ಮಿಸುವುದು
ಧಾರಕ ಚಿತ್ರಗಳನ್ನು ರಚಿಸಲು ನೀವು ತಿಳಿದುಕೊಳ್ಳಬೇಕಾದ ಎಲ್ಲವನ್ನೂ ನೀವು ಈಗಾಗಲೇ ಕಲಿತಿದ್ದೀರಿ ಎಂದು ನಿಮಗೆ ತಿಳಿದಿದೆ. ಅದಕ್ಕಾಗಿಯೇ ಈ ವಿಭಾಗವು ತುಂಬಾ ಚಿಕ್ಕದಾಗಿರುತ್ತದೆ.
ಫೈಲ್ ತೆರೆಯಿರಿ Dockerfileಇದು ಯೋಜನೆಯ ಫೋಲ್ಡರ್‌ನಲ್ಲಿದೆ sa-webapp. ನೀವು ಈ ಫೈಲ್‌ನ ಪಠ್ಯವನ್ನು ಓದಿದರೆ, ಕೀವರ್ಡ್‌ಗಳಿಂದ ಪ್ರಾರಂಭಿಸಿ ಅದರಲ್ಲಿ ಎರಡು ಹೊಸ ನಿರ್ಮಾಣಗಳನ್ನು ಮಾತ್ರ ನೀವು ನೋಡುತ್ತೀರಿ ENV и EXPOSE:
ENV SA_LOGIC_API_URL http://localhost:5000
…
EXPOSE 8080
ಕೀವರ್ಡ್ ENV ಡಾಕರ್ ಕಂಟೈನರ್‌ಗಳ ಒಳಗೆ ಪರಿಸರ ವೇರಿಯಬಲ್‌ಗಳನ್ನು ಘೋಷಿಸಲು ನಿಮಗೆ ಅನುಮತಿಸುತ್ತದೆ. ನಿರ್ದಿಷ್ಟವಾಗಿ, ನಮ್ಮ ಸಂದರ್ಭದಲ್ಲಿ, ಪಠ್ಯ ವಿಶ್ಲೇಷಣೆಯನ್ನು ನಿರ್ವಹಿಸುವ ಅಪ್ಲಿಕೇಶನ್‌ನ API ಅನ್ನು ಪ್ರವೇಶಿಸಲು URL ಅನ್ನು ನಿರ್ದಿಷ್ಟಪಡಿಸಲು ಇದು ನಿಮಗೆ ಅನುಮತಿಸುತ್ತದೆ.
ಕೀವರ್ಡ್ EXPOSE ಪೋರ್ಟ್ ತೆರೆಯಲು ಡಾಕರ್‌ಗೆ ಹೇಳಲು ನಿಮಗೆ ಅನುಮತಿಸುತ್ತದೆ. ಅಪ್ಲಿಕೇಶನ್ ಅನ್ನು ಚಾಲನೆ ಮಾಡುವಾಗ ನಾವು ಈ ಪೋರ್ಟ್ ಅನ್ನು ಬಳಸಲಿದ್ದೇವೆ. ಇಲ್ಲಿ ನೀವು ಅದನ್ನು ಗಮನಿಸಬಹುದು Dockerfile ಅಪ್ಲಿಕೇಶನ್ಗಾಗಿ SA-Frontend ಅಂತಹ ಯಾವುದೇ ಆಜ್ಞೆ ಇಲ್ಲ. ಇದು ದಸ್ತಾವೇಜನ್ನು ಉದ್ದೇಶಗಳಿಗಾಗಿ ಮಾತ್ರ, ಬೇರೆ ರೀತಿಯಲ್ಲಿ ಹೇಳುವುದಾದರೆ, ಈ ನಿರ್ಮಾಣವನ್ನು ಓದುವವರಿಗೆ ಉದ್ದೇಶಿಸಲಾಗಿದೆ Dockerfile.
ಚಿತ್ರವನ್ನು ನಿರ್ಮಿಸುವುದು ಮತ್ತು ಅದನ್ನು ರೆಪೊಸಿಟರಿಗೆ ತಳ್ಳುವುದು ಹಿಂದಿನ ಉದಾಹರಣೆಯಲ್ಲಿರುವಂತೆಯೇ ಕಾಣುತ್ತದೆ. ನಿಮ್ಮ ಸಾಮರ್ಥ್ಯಗಳಲ್ಲಿ ನೀವು ಇನ್ನೂ ಹೆಚ್ಚು ವಿಶ್ವಾಸ ಹೊಂದಿಲ್ಲದಿದ್ದರೆ, ಅನುಗುಣವಾದ ಆಜ್ಞೆಗಳನ್ನು ಫೈಲ್ನಲ್ಲಿ ಕಾಣಬಹುದು README.md ಫೋಲ್ಡರ್ನಲ್ಲಿ sa-webapp.
▍ಪೈಥಾನ್ ಅಪ್ಲಿಕೇಶನ್ಗಾಗಿ ಕಂಟೇನರ್ ಚಿತ್ರವನ್ನು ನಿರ್ಮಿಸುವುದು
ನೀವು ಫೈಲ್‌ನ ವಿಷಯಗಳನ್ನು ನೋಡಿದರೆ Dockerfile ಫೋಲ್ಡರ್ನಲ್ಲಿ sa-logic, ನಂತರ ನೀವು ನಿಮಗಾಗಿ ಹೊಸದನ್ನು ಕಂಡುಕೊಳ್ಳುವುದಿಲ್ಲ. ಚಿತ್ರವನ್ನು ನಿರ್ಮಿಸಲು ಮತ್ತು ಅದನ್ನು ರೆಪೊಸಿಟರಿಗೆ ಕಳುಹಿಸುವ ಆಜ್ಞೆಗಳು ಈಗಾಗಲೇ ನಿಮಗೆ ಪರಿಚಿತವಾಗಿರಬೇಕು, ಆದರೆ, ನಮ್ಮ ಇತರ ಅಪ್ಲಿಕೇಶನ್‌ಗಳಂತೆ, ಅವುಗಳನ್ನು ಫೈಲ್ನಲ್ಲಿ ಕಾಣಬಹುದು README.md ಫೋಲ್ಡರ್ನಲ್ಲಿ sa-logic.
▍ ಕಂಟೈನರೈಸ್ ಮಾಡಿದ ಅಪ್ಲಿಕೇಶನ್‌ಗಳನ್ನು ಪರೀಕ್ಷಿಸಲಾಗುತ್ತಿದೆ
ನೀವು ಪರೀಕ್ಷಿಸದ ಯಾವುದನ್ನಾದರೂ ನೀವು ನಂಬಬಹುದೇ? ನನಗೂ ಸಾಧ್ಯವಿಲ್ಲ. ನಮ್ಮ ಪಾತ್ರೆಗಳನ್ನು ಪರೀಕ್ಷಿಸೋಣ.
- ಅಪ್ಲಿಕೇಶನ್ ಕಂಟೇನರ್ ಅನ್ನು ಪ್ರಾರಂಭಿಸೋಣ
sa-logicಮತ್ತು ಅದನ್ನು ಪೋರ್ಟ್‌ನಲ್ಲಿ ಕೇಳಲು ಕಾನ್ಫಿಗರ್ ಮಾಡಿ5050:docker run -d -p 5050:5000 $DOCKER_USER_ID/sentiment-analysis-logic - ಅಪ್ಲಿಕೇಶನ್ ಕಂಟೇನರ್ ಅನ್ನು ಪ್ರಾರಂಭಿಸೋಣ
sa-webappಮತ್ತು ಅದನ್ನು ಪೋರ್ಟ್‌ನಲ್ಲಿ ಕೇಳಲು ಕಾನ್ಫಿಗರ್ ಮಾಡಿ8080. ಹೆಚ್ಚುವರಿಯಾಗಿ, ಪರಿಸರ ವೇರಿಯಬಲ್ ಅನ್ನು ಮರುಹೊಂದಿಸುವ ಮೂಲಕ ಜಾವಾ ಅಪ್ಲಿಕೇಶನ್‌ನಿಂದ ವಿನಂತಿಗಳನ್ನು ಪೈಥಾನ್ ಅಪ್ಲಿಕೇಶನ್ ಆಲಿಸುವ ಪೋರ್ಟ್ ಅನ್ನು ನಾವು ಕಾನ್ಫಿಗರ್ ಮಾಡಬೇಕಾಗುತ್ತದೆ.SA_LOGIC_API_URL:$ docker run -d -p 8080:8080 -e SA_LOGIC_API_URL='http://<container_ip or docker machine ip>:5000' $DOCKER_USER_ID/sentiment-analysis-web-app
ಡಾಕರ್ ಕಂಟೇನರ್ ಅಥವಾ ವರ್ಚುವಲ್ ಗಣಕದ IP ವಿಳಾಸವನ್ನು ಕಂಡುಹಿಡಿಯುವುದು ಹೇಗೆ ಎಂದು ತಿಳಿಯಲು, ಫೈಲ್ ಅನ್ನು ನೋಡಿ .
ಅಪ್ಲಿಕೇಶನ್ ಕಂಟೇನರ್ ಅನ್ನು ಪ್ರಾರಂಭಿಸೋಣ sa-frontend:
docker run -d -p 80:80 $DOCKER_USER_ID/sentiment-analysis-frontend
ಈಗ ಬ್ರೌಸರ್‌ನಲ್ಲಿರುವ ವಿಳಾಸಕ್ಕೆ ಹೋಗಲು ಎಲ್ಲವೂ ಸಿದ್ಧವಾಗಿದೆ localhost:80 ಮತ್ತು ಅಪ್ಲಿಕೇಶನ್ ಅನ್ನು ಪ್ರಯತ್ನಿಸಿ.
ನೀವು ಪೋರ್ಟ್ ಅನ್ನು ಬದಲಾಯಿಸಿದರೆ ಎಂಬುದನ್ನು ದಯವಿಟ್ಟು ಗಮನಿಸಿ sa-webapp, ಅಥವಾ ನೀವು ಡಾಕರ್ ವರ್ಚುವಲ್ ಯಂತ್ರವನ್ನು ಚಲಾಯಿಸುತ್ತಿದ್ದರೆ, ನೀವು ಫೈಲ್ ಅನ್ನು ಸಂಪಾದಿಸಬೇಕಾಗುತ್ತದೆ App.js ಫೋಲ್ಡರ್ನಿಂದ sa-frontendವಿಧಾನದಲ್ಲಿ IP ವಿಳಾಸ ಅಥವಾ ಪೋರ್ಟ್ ಸಂಖ್ಯೆಯನ್ನು ಬದಲಾಯಿಸುವ ಮೂಲಕ analyzeSentence(), ಹಳತಾದ ಡೇಟಾದ ಬದಲಿಗೆ ಪ್ರಸ್ತುತ ಮಾಹಿತಿಯನ್ನು ಬದಲಿಸುವುದು. ಇದರ ನಂತರ, ನೀವು ಚಿತ್ರವನ್ನು ಮತ್ತೆ ಜೋಡಿಸಬೇಕು ಮತ್ತು ಅದನ್ನು ಬಳಸಬೇಕು.
ನಮ್ಮ ಅಪ್ಲಿಕೇಶನ್ ರೇಖಾಚಿತ್ರವು ಈಗ ತೋರುತ್ತಿದೆ.
ಮೈಕ್ರೊ ಸರ್ವೀಸ್ ಕಂಟೈನರ್‌ಗಳಲ್ಲಿ ಚಲಿಸುತ್ತದೆ
ಸಾರಾಂಶ: ನಮಗೆ ಕುಬರ್ನೆಟ್ಸ್ ಕ್ಲಸ್ಟರ್ ಏಕೆ ಬೇಕು?
ಈಗಷ್ಟೇ ಕಡತಗಳನ್ನು ಪರಿಶೀಲಿಸಿದ್ದೇವೆ Dockerfile, ಚಿತ್ರಗಳನ್ನು ಹೇಗೆ ನಿರ್ಮಿಸುವುದು ಮತ್ತು ಅವುಗಳನ್ನು ಡಾಕರ್ ರೆಪೊಸಿಟರಿಗೆ ತಳ್ಳುವುದು ಹೇಗೆ ಎಂಬುದರ ಕುರಿತು ಮಾತನಾಡಿದರು. ಹೆಚ್ಚುವರಿಯಾಗಿ, ಫೈಲ್ ಅನ್ನು ಬಳಸಿಕೊಂಡು ಚಿತ್ರದ ಜೋಡಣೆಯನ್ನು ಹೇಗೆ ವೇಗಗೊಳಿಸುವುದು ಎಂದು ನಾವು ಕಲಿತಿದ್ದೇವೆ .dockerignore. ಪರಿಣಾಮವಾಗಿ, ನಮ್ಮ ಮೈಕ್ರೋ ಸರ್ವೀಸ್‌ಗಳು ಈಗ ಡಾಕರ್ ಕಂಟೇನರ್‌ಗಳಲ್ಲಿ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತವೆ. ನಮಗೆ ಕುಬರ್ನೆಟ್ಸ್ ಏಕೆ ಬೇಕು ಎಂಬುದರ ಕುರಿತು ಇಲ್ಲಿ ನೀವು ಸಂಪೂರ್ಣವಾಗಿ ಸಮರ್ಥನೀಯ ಪ್ರಶ್ನೆಯನ್ನು ಹೊಂದಿರಬಹುದು. ಈ ವಿಷಯದ ಎರಡನೇ ಭಾಗವನ್ನು ಈ ಪ್ರಶ್ನೆಗೆ ಉತ್ತರಿಸಲು ಮೀಸಲಿಡಲಾಗುವುದು. ಈ ಮಧ್ಯೆ, ಈ ಕೆಳಗಿನ ಪ್ರಶ್ನೆಯನ್ನು ಪರಿಗಣಿಸಿ:
ಪಠ್ಯ ವಿಶ್ಲೇಷಣೆಗಾಗಿ ನಮ್ಮ ವೆಬ್ ಅಪ್ಲಿಕೇಶನ್ ಜಾಗತಿಕವಾಗಿ ಜನಪ್ರಿಯವಾಗಿದೆ ಎಂದು ಭಾವಿಸೋಣ. ಪ್ರತಿ ನಿಮಿಷವೂ ಲಕ್ಷಾಂತರ ವಿನಂತಿಗಳು ಅವನಿಗೆ ಬರುತ್ತವೆ. ಇದರರ್ಥ ಮೈಕ್ರೋ ಸರ್ವೀಸ್ sa-webapp и sa-logic ಅಗಾಧವಾದ ಹೊರೆ ಇರುತ್ತದೆ. ಮೈಕ್ರೊ ಸರ್ವಿಸ್ ಚಾಲನೆಯಲ್ಲಿರುವ ಕಂಟೇನರ್‌ಗಳನ್ನು ಅಳೆಯುವುದು ಹೇಗೆ?
ಮೂಲ: www.habr.com