CI/CD ಸರಣಿಯನ್ನು ರಚಿಸುವುದು ಮತ್ತು ಡಾಕರ್‌ನೊಂದಿಗೆ ಕೆಲಸವನ್ನು ಸ್ವಯಂಚಾಲಿತಗೊಳಿಸುವುದು

90 ರ ದಶಕದ ಉತ್ತರಾರ್ಧದಲ್ಲಿ ನಾನು ನನ್ನ ಮೊದಲ ವೆಬ್‌ಸೈಟ್‌ಗಳನ್ನು ಬರೆದಿದ್ದೇನೆ. ಆಗ ಅವುಗಳನ್ನು ಕಾರ್ಯರೂಪಕ್ಕೆ ತರುವುದು ತುಂಬಾ ಸುಲಭ. ಕೆಲವು ಹಂಚಿಕೆಯ ಹೋಸ್ಟಿಂಗ್‌ನಲ್ಲಿ ಅಪಾಚೆ ಸರ್ವರ್ ಇತ್ತು, ನೀವು ಈ ರೀತಿಯದನ್ನು ಬರೆಯುವ ಮೂಲಕ FTP ಮೂಲಕ ಈ ಸರ್ವರ್‌ಗೆ ಲಾಗ್ ಇನ್ ಮಾಡಬಹುದು ftp://ftp.example.com. ನಂತರ ನೀವು ನಿಮ್ಮ ಹೆಸರು ಮತ್ತು ಪಾಸ್‌ವರ್ಡ್ ಅನ್ನು ನಮೂದಿಸಬೇಕು ಮತ್ತು ಫೈಲ್‌ಗಳನ್ನು ಸರ್ವರ್‌ಗೆ ಅಪ್‌ಲೋಡ್ ಮಾಡಬೇಕು. ವಿಭಿನ್ನ ಸಮಯಗಳು ಇದ್ದವು, ಈಗ ಎಲ್ಲವೂ ಆಗ ಸರಳವಾಗಿತ್ತು.

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

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

ನೀವು ಸಣ್ಣ ಪ್ರಾಜೆಕ್ಟ್ ಹೊಂದಿದ್ದರೆ (ಈ ಸಂದರ್ಭದಲ್ಲಿ, Node.js ಯೋಜನೆ) ಮತ್ತು ಈ ಯೋಜನೆಯ ನಿಯೋಜನೆಯನ್ನು ಸ್ವಯಂಚಾಲಿತಗೊಳಿಸುವುದು ಹೇಗೆ ಎಂದು ತಿಳಿಯಲು ನೀವು ಬಯಸಿದರೆ, ರೆಪೊಸಿಟರಿಯಲ್ಲಿ ಶೇಖರಿಸಿರುವುದು ಉತ್ಪಾದನೆಯಲ್ಲಿ ಏನು ಕೆಲಸ ಮಾಡುತ್ತದೆ ಎಂಬುದನ್ನು ಖಚಿತಪಡಿಸುತ್ತದೆ, ಆಗ ನಾನು ನೀವು ಈ ಲೇಖನದಲ್ಲಿ ಆಸಕ್ತಿ ಹೊಂದಿರಬಹುದು ಎಂದು ಭಾವಿಸುತ್ತೇನೆ.

ಪೂರ್ವಾಪೇಕ್ಷಿತಗಳು

ಈ ಲೇಖನದ ಓದುಗರು ಕಮಾಂಡ್ ಲೈನ್ ಮತ್ತು ಬ್ಯಾಷ್ ಸ್ಕ್ರಿಪ್ಟ್‌ಗಳನ್ನು ಬರೆಯುವ ಮೂಲಭೂತ ತಿಳುವಳಿಕೆಯನ್ನು ಹೊಂದಿರುತ್ತಾರೆ ಎಂದು ನಿರೀಕ್ಷಿಸಲಾಗಿದೆ. ಹೆಚ್ಚುವರಿಯಾಗಿ, ಅವನಿಗೆ ಖಾತೆಗಳು ಬೇಕಾಗುತ್ತವೆ ಟ್ರಾವಿಸ್ ಸಿಐ и ಡಾಕರ್ ಹಬ್.

ಉದ್ದೇಶಗಳು

ಈ ಲೇಖನವನ್ನು ಬೇಷರತ್ತಾಗಿ "ಟ್ಯುಟೋರಿಯಲ್" ಎಂದು ಕರೆಯಬಹುದು ಎಂದು ನಾನು ಹೇಳುವುದಿಲ್ಲ. ಇದು ನಾನು ಕಲಿತದ್ದನ್ನು ಕುರಿತು ಮಾತನಾಡುವ ಹೆಚ್ಚಿನ ಡಾಕ್ಯುಮೆಂಟ್ ಆಗಿದೆ ಮತ್ತು ಒಂದು ಸ್ವಯಂಚಾಲಿತ ಪಾಸ್‌ನಲ್ಲಿ ನಿರ್ವಹಿಸಲಾದ ಉತ್ಪಾದನೆಗೆ ಕೋಡ್ ಅನ್ನು ಪರೀಕ್ಷಿಸಲು ಮತ್ತು ನಿಯೋಜಿಸಲು ನನಗೆ ಸೂಕ್ತವಾದ ಪ್ರಕ್ರಿಯೆಯನ್ನು ವಿವರಿಸುತ್ತದೆ.

ಇದು ನನ್ನ ಕೆಲಸದ ಹರಿವು ಕೊನೆಗೊಂಡಿತು.

ಹೊರತುಪಡಿಸಿ ಯಾವುದೇ ರೆಪೊಸಿಟರಿ ಶಾಖೆಗೆ ಪೋಸ್ಟ್ ಮಾಡಿದ ಕೋಡ್‌ಗಾಗಿ master, ಕೆಳಗಿನ ಕ್ರಿಯೆಗಳನ್ನು ನಡೆಸಲಾಗುತ್ತದೆ:

• ಟ್ರಾವಿಸ್ CI ನಲ್ಲಿ ಯೋಜನೆಯ ನಿರ್ಮಾಣವು ಪ್ರಾರಂಭವಾಗುತ್ತದೆ.
• ಎಲ್ಲಾ ಘಟಕ, ಏಕೀಕರಣ ಮತ್ತು ಅಂತ್ಯದಿಂದ ಕೊನೆಯವರೆಗೆ ಪರೀಕ್ಷೆಗಳನ್ನು ನಡೆಸಲಾಗುತ್ತದೆ.

ಬೀಳುವ ಕೋಡ್‌ಗಾಗಿ ಮಾತ್ರ master, ಕೆಳಗಿನವುಗಳನ್ನು ನಡೆಸಲಾಗುತ್ತದೆ:

• ಮೇಲೆ ತಿಳಿಸಿದ ಎಲ್ಲವೂ, ಜೊತೆಗೆ...
• ಪ್ರಸ್ತುತ ಕೋಡ್, ಸೆಟ್ಟಿಂಗ್‌ಗಳು ಮತ್ತು ಪರಿಸರದ ಆಧಾರದ ಮೇಲೆ ಡಾಕರ್ ಚಿತ್ರವನ್ನು ನಿರ್ಮಿಸುವುದು.
• ಚಿತ್ರವನ್ನು ಡಾಕರ್ ಹಬ್‌ಗೆ ನಿಯೋಜಿಸಲಾಗುತ್ತಿದೆ.
• ಉತ್ಪಾದನಾ ಸರ್ವರ್‌ಗೆ ಸಂಪರ್ಕ.
• ಡಾಕರ್ ಹಬ್‌ನಿಂದ ಸರ್ವರ್‌ಗೆ ಚಿತ್ರವನ್ನು ಅಪ್‌ಲೋಡ್ ಮಾಡಲಾಗುತ್ತಿದೆ.
• ಪ್ರಸ್ತುತ ಕಂಟೇನರ್ ಅನ್ನು ನಿಲ್ಲಿಸುವುದು ಮತ್ತು ಹೊಸ ಚಿತ್ರವನ್ನು ಆಧರಿಸಿ ಹೊಸದನ್ನು ಪ್ರಾರಂಭಿಸುವುದು.

ಡಾಕರ್, ಚಿತ್ರಗಳು ಮತ್ತು ಕಂಟೈನರ್‌ಗಳ ಬಗ್ಗೆ ನಿಮಗೆ ಸಂಪೂರ್ಣವಾಗಿ ತಿಳಿದಿಲ್ಲದಿದ್ದರೆ, ಚಿಂತಿಸಬೇಡಿ. ನಾನು ಅದರ ಬಗ್ಗೆ ಎಲ್ಲವನ್ನೂ ಹೇಳುತ್ತೇನೆ.

CI/CD ಎಂದರೇನು?

CI/CD ಎಂಬ ಸಂಕ್ಷೇಪಣವು "ನಿರಂತರ ಏಕೀಕರಣ/ನಿರಂತರ ನಿಯೋಜನೆ"ಯನ್ನು ಸೂಚಿಸುತ್ತದೆ.

▍ನಿರಂತರ ಏಕೀಕರಣ

ನಿರಂತರ ಏಕೀಕರಣವು ಒಂದು ಪ್ರಕ್ರಿಯೆಯಾಗಿದ್ದು, ಇದರಲ್ಲಿ ಡೆವಲಪರ್‌ಗಳು ಯೋಜನೆಯ ಮುಖ್ಯ ಮೂಲ ಕೋಡ್ ರೆಪೊಸಿಟರಿಗೆ (ಸಾಮಾನ್ಯವಾಗಿ ಶಾಖೆ master) ಅದೇ ಸಮಯದಲ್ಲಿ, ಸ್ವಯಂಚಾಲಿತ ಪರೀಕ್ಷೆಯ ಮೂಲಕ ಕೋಡ್‌ನ ಗುಣಮಟ್ಟವನ್ನು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಲಾಗುತ್ತದೆ.

▍ನಿರಂತರ ನಿಯೋಜನೆ

ನಿರಂತರ ನಿಯೋಜನೆಯು ಉತ್ಪಾದನೆಗೆ ಕೋಡ್‌ನ ಆಗಾಗ್ಗೆ, ಸ್ವಯಂಚಾಲಿತ ನಿಯೋಜನೆಯಾಗಿದೆ. CI/CD ಸಂಕ್ಷೇಪಣದ ಎರಡನೇ ಭಾಗವನ್ನು ಕೆಲವೊಮ್ಮೆ "ನಿರಂತರ ವಿತರಣೆ" ಎಂದು ಉಚ್ಚರಿಸಲಾಗುತ್ತದೆ. ಇದು ಮೂಲತಃ "ನಿರಂತರ ನಿಯೋಜನೆ" ಯಂತೆಯೇ ಇರುತ್ತದೆ, ಆದರೆ "ನಿರಂತರ ವಿತರಣೆ" ಯೋಜನೆಯ ನಿಯೋಜನೆ ಪ್ರಕ್ರಿಯೆಯನ್ನು ಪ್ರಾರಂಭಿಸುವ ಮೊದಲು ಬದಲಾವಣೆಗಳನ್ನು ಹಸ್ತಚಾಲಿತವಾಗಿ ದೃಢೀಕರಿಸುವ ಅಗತ್ಯವನ್ನು ಸೂಚಿಸುತ್ತದೆ.

ಆರಂಭಿಸುವಿಕೆ

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

ನನ್ನ ಸಂದರ್ಭದಲ್ಲಿ, ಅಪ್ಲಿಕೇಶನ್ Node.js ಪರಿಸರದಲ್ಲಿ ಚಾಲನೆಯಲ್ಲಿರುವ ಎಕ್ಸ್‌ಪ್ರೆಸ್ ಸರ್ವರ್ ಆಗಿದ್ದು, ಒಂದೇ ಪುಟದ ರಿಯಾಕ್ಟ್ ಅಪ್ಲಿಕೇಶನ್ ಅನ್ನು ಒದಗಿಸುತ್ತದೆ ಮತ್ತು ಸುರಕ್ಷಿತ ಸರ್ವರ್-ಸೈಡ್ API ಅನ್ನು ಬೆಂಬಲಿಸುತ್ತದೆ. ಈ ವಾಸ್ತುಶಿಲ್ಪವು ಕಂಡುಬರುವ ತಂತ್ರವನ್ನು ಅನುಸರಿಸುತ್ತದೆ ಈ ಪೂರ್ಣ ಸ್ಟಾಕ್ ದೃಢೀಕರಣ ಮಾರ್ಗದರ್ಶಿ.

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

ಡಾಕರ್

ಡಾಕರ್ ಎಂಬುದು ಒಂದು ಸಾಧನವಾಗಿದ್ದು, ಕಂಟೈನರೈಸೇಶನ್ ತಂತ್ರಜ್ಞಾನಕ್ಕೆ ಧನ್ಯವಾದಗಳು, ಡಾಕರ್ ಪ್ಲಾಟ್‌ಫಾರ್ಮ್ ಸ್ವತಃ ವಿಭಿನ್ನ ಪರಿಸರದಲ್ಲಿ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತಿದ್ದರೂ ಸಹ, ಅಪ್ಲಿಕೇಶನ್‌ಗಳನ್ನು ಸುಲಭವಾಗಿ ವಿತರಿಸಲು, ನಿಯೋಜಿಸಲು ಮತ್ತು ಒಂದೇ ಪರಿಸರದಲ್ಲಿ ಚಲಾಯಿಸಲು ಅನುಮತಿಸುತ್ತದೆ. ಮೊದಲಿಗೆ, ನಾನು ಡಾಕರ್ ಕಮಾಂಡ್ ಲೈನ್ ಟೂಲ್ಸ್ (CLI) ಮೇಲೆ ನನ್ನ ಕೈಗಳನ್ನು ಪಡೆಯಬೇಕಾಗಿತ್ತು. ಸೂಚನಾ ಡಾಕರ್ ಅನುಸ್ಥಾಪನಾ ಮಾರ್ಗದರ್ಶಿಯನ್ನು ಅತ್ಯಂತ ಸ್ಪಷ್ಟ ಮತ್ತು ಅರ್ಥವಾಗುವಂತಹದ್ದಾಗಿ ಕರೆಯಲಾಗುವುದಿಲ್ಲ, ಆದರೆ ಅದರಿಂದ ನೀವು ಮೊದಲ ಅನುಸ್ಥಾಪನ ಹಂತವನ್ನು ತೆಗೆದುಕೊಳ್ಳಲು, ನೀವು ಡಾಕರ್ ಡೆಸ್ಕ್‌ಟಾಪ್ ಅನ್ನು (ಮ್ಯಾಕ್ ಅಥವಾ ವಿಂಡೋಸ್‌ಗಾಗಿ) ಡೌನ್‌ಲೋಡ್ ಮಾಡಬೇಕಾಗುತ್ತದೆ ಎಂದು ಕಲಿಯಬಹುದು.

ಡಾಕರ್ ಹಬ್ ಸರಿಸುಮಾರು ಅದೇ ವಿಷಯವಾಗಿದೆ GitHub git ರೆಪೊಸಿಟರಿಗಳು ಅಥವಾ ನೋಂದಾವಣೆಗಾಗಿ npm JavaScript ಪ್ಯಾಕೇಜುಗಳಿಗಾಗಿ. ಇದು ಡಾಕರ್ ಚಿತ್ರಗಳಿಗಾಗಿ ಆನ್‌ಲೈನ್ ರೆಪೊಸಿಟರಿಯಾಗಿದೆ. ಇದಕ್ಕೆ ಡಾಕರ್ ಡೆಸ್ಕ್‌ಟಾಪ್ ಸಂಪರ್ಕಿಸುತ್ತದೆ.

ಆದ್ದರಿಂದ, ಡಾಕರ್‌ನೊಂದಿಗೆ ಪ್ರಾರಂಭಿಸಲು, ನೀವು ಎರಡು ಕೆಲಸಗಳನ್ನು ಮಾಡಬೇಕಾಗಿದೆ:

• ಸ್ಥಾಪಿಸಿ ಡಾಕರ್ ಡೆಸ್ಕ್‌ಟಾಪ್.
• ಗಾಗಿ ನೋಂದಾಯಿಸಿ ಡಾಕರ್ ಹಬ್.

ಇದರ ನಂತರ, ಡಾಕರ್ ಆವೃತ್ತಿಯನ್ನು ಪರಿಶೀಲಿಸಲು ಈ ಕೆಳಗಿನ ಆಜ್ಞೆಯನ್ನು ಚಲಾಯಿಸುವ ಮೂಲಕ ಡಾಕರ್ CLI ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತಿದೆಯೇ ಎಂದು ನೀವು ಪರಿಶೀಲಿಸಬಹುದು:

docker -v

ಮುಂದೆ, ಕೇಳಿದಾಗ ನಿಮ್ಮ ಬಳಕೆದಾರಹೆಸರು ಮತ್ತು ಪಾಸ್‌ವರ್ಡ್ ಅನ್ನು ನಮೂದಿಸುವ ಮೂಲಕ ಡಾಕರ್ ಹಬ್‌ಗೆ ಲಾಗ್ ಇನ್ ಮಾಡಿ:

docker login

ಡಾಕರ್ ಅನ್ನು ಬಳಸಲು, ನೀವು ಚಿತ್ರಗಳು ಮತ್ತು ಕಂಟೈನರ್‌ಗಳ ಪರಿಕಲ್ಪನೆಗಳನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳಬೇಕು.

▍ಚಿತ್ರಗಳು

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

# Вывод сведений обо всех образах
docker images

ಈ ಆಜ್ಞೆಯು ಈ ಕೆಳಗಿನ ಹೆಡರ್ನೊಂದಿಗೆ ಟೇಬಲ್ ಅನ್ನು ಔಟ್ಪುಟ್ ಮಾಡುತ್ತದೆ:

REPOSITORY     TAG     IMAGE ID     CREATED     SIZE
---

ಮುಂದೆ ನಾವು ಅದೇ ಸ್ವರೂಪದಲ್ಲಿ ಆಜ್ಞೆಗಳ ಕೆಲವು ಉದಾಹರಣೆಗಳನ್ನು ನೋಡುತ್ತೇವೆ - ಮೊದಲು ಕಾಮೆಂಟ್ನೊಂದಿಗೆ ಕಮಾಂಡ್ ಇದೆ, ಮತ್ತು ನಂತರ ಅದು ಏನನ್ನು ಔಟ್ಪುಟ್ ಮಾಡಬಹುದು ಎಂಬುದರ ಉದಾಹರಣೆ.

▍ ಕಂಟೈನರ್‌ಗಳು

ಕಂಟೈನರ್ ಎನ್ನುವುದು ಕಾರ್ಯಗತಗೊಳಿಸಬಹುದಾದ ಪ್ಯಾಕೇಜ್ ಆಗಿದ್ದು ಅದು ಅಪ್ಲಿಕೇಶನ್ ಅನ್ನು ಚಲಾಯಿಸಲು ಅಗತ್ಯವಿರುವ ಎಲ್ಲವನ್ನೂ ಒಳಗೊಂಡಿರುತ್ತದೆ. ಈ ವಿಧಾನವನ್ನು ಹೊಂದಿರುವ ಅಪ್ಲಿಕೇಶನ್ ಮೂಲಸೌಕರ್ಯವನ್ನು ಲೆಕ್ಕಿಸದೆ ಯಾವಾಗಲೂ ಒಂದೇ ರೀತಿ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತದೆ: ಪ್ರತ್ಯೇಕ ಪರಿಸರದಲ್ಲಿ ಮತ್ತು ಅದೇ ಪರಿಸರದಲ್ಲಿ. ಒಂದೇ ಚಿತ್ರದ ನಿದರ್ಶನಗಳನ್ನು ವಿಭಿನ್ನ ಪರಿಸರದಲ್ಲಿ ಪ್ರಾರಂಭಿಸಲಾಗಿದೆ ಎಂಬುದು ಪಾಯಿಂಟ್.

# Перечисление всех контейнеров
docker ps -a
CONTAINER ID     IMAGE     COMMAND     CREATED     STATUS     PORTS     NAMES
---

▍ಟ್ಯಾಗ್‌ಗಳು

ಟ್ಯಾಗ್ ಎನ್ನುವುದು ಚಿತ್ರದ ನಿರ್ದಿಷ್ಟ ಆವೃತ್ತಿಯ ಸೂಚನೆಯಾಗಿದೆ.

▍ಡಾಕರ್ ಆಜ್ಞೆಗಳಿಗೆ ತ್ವರಿತ ಉಲ್ಲೇಖ

ಸಾಮಾನ್ಯವಾಗಿ ಬಳಸುವ ಕೆಲವು ಡಾಕರ್ ಕಮಾಂಡ್‌ಗಳ ಅವಲೋಕನ ಇಲ್ಲಿದೆ.

ತಂಡದ

ಸಂದರ್ಭ

ಪರಿಣಾಮ

ಡಾಕರ್ ನಿರ್ಮಾಣ

ಚಿತ್ರ

ಡಾಕರ್‌ಫೈಲ್‌ನಿಂದ ಚಿತ್ರವನ್ನು ನಿರ್ಮಿಸುವುದು

ಡಾಕರ್ ಟ್ಯಾಗ್

ಚಿತ್ರ

ಚಿತ್ರ ಟ್ಯಾಗಿಂಗ್

ಡಾಕರ್ ಚಿತ್ರಗಳು

ಚಿತ್ರ

ಚಿತ್ರಗಳನ್ನು ಪಟ್ಟಿ ಮಾಡುವುದು

ಡಾಕರ್ ರನ್

ಕಂಟೇನರ್

ಚಿತ್ರದ ಆಧಾರದ ಮೇಲೆ ಧಾರಕವನ್ನು ನಡೆಸುವುದು

ಡಾಕರ್ ಪುಶ್

ಚಿತ್ರ

ನೋಂದಾವಣೆಗೆ ಚಿತ್ರವನ್ನು ಅಪ್‌ಲೋಡ್ ಮಾಡಲಾಗುತ್ತಿದೆ

ಡಾಕರ್ ಪುಲ್

ಚಿತ್ರ

ನೋಂದಾವಣೆಯಿಂದ ಚಿತ್ರವನ್ನು ಲೋಡ್ ಮಾಡಲಾಗುತ್ತಿದೆ

ಡಾಕರ್ ಪಿಎಸ್

ಕಂಟೇನರ್

ಪಟ್ಟಿ ಧಾರಕಗಳು

ಡಾಕರ್ ಸಿಸ್ಟಮ್ ಪ್ರೂನ್

ಚಿತ್ರ/ಧಾರಕ

ಬಳಕೆಯಾಗದ ಪಾತ್ರೆಗಳು ಮತ್ತು ಚಿತ್ರಗಳನ್ನು ತೆಗೆದುಹಾಕಲಾಗುತ್ತಿದೆ

▍ಡಾಕರ್‌ಫೈಲ್

ಸ್ಥಳೀಯವಾಗಿ ಉತ್ಪಾದನಾ ಅಪ್ಲಿಕೇಶನ್ ಅನ್ನು ಹೇಗೆ ಚಲಾಯಿಸಬೇಕು ಎಂದು ನನಗೆ ತಿಳಿದಿದೆ. ನಾನು ರೆಡಿಮೇಡ್ ರಿಯಾಕ್ಟ್ ಅಪ್ಲಿಕೇಶನ್ ಅನ್ನು ನಿರ್ಮಿಸಲು ವಿನ್ಯಾಸಗೊಳಿಸಿದ ವೆಬ್‌ಪ್ಯಾಕ್ ಕಾನ್ಫಿಗರೇಶನ್ ಅನ್ನು ಹೊಂದಿದ್ದೇನೆ. ಮುಂದೆ, ನಾನು ಬಂದರಿನಲ್ಲಿ Node.js ಆಧಾರಿತ ಸರ್ವರ್ ಅನ್ನು ಪ್ರಾರಂಭಿಸುವ ಆಜ್ಞೆಯನ್ನು ಹೊಂದಿದ್ದೇನೆ 5000. ಇದು ಈ ರೀತಿ ಕಾಣುತ್ತದೆ:

npm i         # установка зависимостей
npm run build # сборка React-приложения
npm run start # запуск Node-сервера

ಈ ವಸ್ತುವಿಗೆ ನಾನು ಉದಾಹರಣೆ ಅಪ್ಲಿಕೇಶನ್ ಹೊಂದಿಲ್ಲ ಎಂದು ಗಮನಿಸಬೇಕು. ಆದರೆ ಇಲ್ಲಿ, ಪ್ರಯೋಗಗಳಿಗಾಗಿ, ಯಾವುದೇ ಸರಳ ನೋಡ್ ಅಪ್ಲಿಕೇಶನ್ ಮಾಡುತ್ತದೆ.

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

ಆದರೆ ಅದು ಒಳಗೊಂಡಿರುವುದು ವಿಶೇಷ ಆಜ್ಞೆಗಳೊಂದಿಗೆ, ಕೆಲಸದ ವಾತಾವರಣವನ್ನು ಹೊಂದಿಸುವಂತೆಯೇ ವಿವರಿಸುತ್ತದೆ. ಈ ಕೆಲವು ಆಜ್ಞೆಗಳು ಇಲ್ಲಿವೆ:

• FROM - ಈ ಆಜ್ಞೆಯು ಫೈಲ್ ಅನ್ನು ಪ್ರಾರಂಭಿಸುತ್ತದೆ. ಇದು ಧಾರಕವನ್ನು ನಿರ್ಮಿಸಿದ ಮೂಲ ಚಿತ್ರವನ್ನು ನಿರ್ದಿಷ್ಟಪಡಿಸುತ್ತದೆ.
• ಕಾಪಿ — ಸ್ಥಳೀಯ ಮೂಲದಿಂದ ಕಂಟೇನರ್‌ಗೆ ಫೈಲ್‌ಗಳನ್ನು ನಕಲಿಸುವುದು.
• ವರ್ಕ್ಡೈರ್ - ಈ ಕೆಳಗಿನ ಆಜ್ಞೆಗಳಿಗಾಗಿ ಕಾರ್ಯನಿರ್ವಹಿಸುವ ಡೈರೆಕ್ಟರಿಯನ್ನು ಹೊಂದಿಸುವುದು.
• ರನ್ - ಆಜ್ಞೆಗಳನ್ನು ಚಲಾಯಿಸಿ.
• ಎಕ್ಸ್‌ಪೋಸ್ ಮಾಡಿ - ಪೋರ್ಟ್ ಸೆಟ್ಟಿಂಗ್‌ಗಳು.
• ENTRYPOINT - ಕಾರ್ಯಗತಗೊಳಿಸಬೇಕಾದ ಆಜ್ಞೆಯ ಸೂಚನೆ.

Dockerfile ಈ ರೀತಿ ಕಾಣಿಸಬಹುದು:

# Загрузить базовый образ
FROM node:12-alpine

# Скопировать файлы из текущей директории в директорию app/
COPY . app/

# Использовать app/ в роли рабочей директории
WORKDIR app/

# Установить зависимости (команда npm ci похожа npm i, но используется для автоматизированных сборок)
RUN npm ci --only-production

# Собрать клиентское React-приложение для продакшна
RUN npm run build

# Прослушивать указанный порт
EXPOSE 5000

# Запустить Node-сервер
ENTRYPOINT npm run start

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

▍ಕಂಟೇನರ್ ಅನ್ನು ನಿರ್ಮಿಸುವುದು, ಟ್ಯಾಗ್ ಮಾಡುವುದು ಮತ್ತು ಚಾಲನೆ ಮಾಡುವುದು

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

▍ಅಸೆಂಬ್ಲಿ

ಮೊದಲು ನೀವು ಸಂಗ್ರಹಿಸಬೇಕಾಗಿದೆ ಚಿತ್ರ, ಹೆಸರನ್ನು ನಿರ್ದಿಷ್ಟಪಡಿಸುವುದು ಮತ್ತು, ಐಚ್ಛಿಕವಾಗಿ, ಟ್ಯಾಗ್ (ಟ್ಯಾಗ್ ಅನ್ನು ನಿರ್ದಿಷ್ಟಪಡಿಸದಿದ್ದರೆ, ಸಿಸ್ಟಮ್ ಸ್ವಯಂಚಾಲಿತವಾಗಿ ಚಿತ್ರಕ್ಕೆ ಟ್ಯಾಗ್ ಅನ್ನು ನಿಯೋಜಿಸುತ್ತದೆ latest).

# Сборка образа
docker build -t <image>:<tag> .

ಈ ಆಜ್ಞೆಯನ್ನು ಚಲಾಯಿಸಿದ ನಂತರ, ಡಾಕರ್ ಚಿತ್ರವನ್ನು ನಿರ್ಮಿಸುವುದನ್ನು ನೀವು ವೀಕ್ಷಿಸಬಹುದು.

Sending build context to Docker daemon   2.88MB
Step 1/9 : FROM node:12-alpine
 ---> ...выполнение этапов сборки...
Successfully built 123456789123
Successfully tagged <image>:<tag>

ನಿರ್ಮಾಣವು ಒಂದೆರಡು ನಿಮಿಷಗಳನ್ನು ತೆಗೆದುಕೊಳ್ಳಬಹುದು - ಇದು ನೀವು ಎಷ್ಟು ಅವಲಂಬನೆಗಳನ್ನು ಹೊಂದಿದ್ದೀರಿ ಎಂಬುದರ ಮೇಲೆ ಅವಲಂಬಿತವಾಗಿರುತ್ತದೆ. ನಿರ್ಮಾಣ ಪೂರ್ಣಗೊಂಡ ನಂತರ, ನೀವು ಆಜ್ಞೆಯನ್ನು ಚಲಾಯಿಸಬಹುದು docker images ಮತ್ತು ನಿಮ್ಮ ಹೊಸ ಚಿತ್ರದ ವಿವರಣೆಯನ್ನು ನೋಡಿ.

REPOSITORY          TAG               IMAGE ID            CREATED              SIZE
<image>             latest            123456789123        About a minute ago   x.xxGB

▍ಲಾಂಚ್

ಚಿತ್ರವನ್ನು ರಚಿಸಲಾಗಿದೆ. ಇದರರ್ಥ ನೀವು ಅದರ ಆಧಾರದ ಮೇಲೆ ಕಂಟೇನರ್ ಅನ್ನು ಚಲಾಯಿಸಬಹುದು. ಏಕೆಂದರೆ ಕಂಟೇನರ್‌ನಲ್ಲಿ ಚಾಲನೆಯಲ್ಲಿರುವ ಅಪ್ಲಿಕೇಶನ್ ಅನ್ನು ನಾನು ಪ್ರವೇಶಿಸಲು ಬಯಸುತ್ತೇನೆ localhost:5000, ನಾನು, ಜೋಡಿಯ ಎಡಭಾಗದಲ್ಲಿ 5000:5000 ಸ್ಥಾಪಿಸಲಾದ ಮುಂದಿನ ಆಜ್ಞೆಯಲ್ಲಿ 5000. ಬಲಭಾಗದಲ್ಲಿ ಕಂಟೇನರ್ ಪೋರ್ಟ್ ಇದೆ.

# Запуск с использованием локального порта 5000 и порта контейнера 5000
docker run -p 5000:5000 <image>:<tag>

ಈಗ ಕಂಟೇನರ್ ಅನ್ನು ರಚಿಸಲಾಗಿದೆ ಮತ್ತು ಚಾಲನೆಯಲ್ಲಿದೆ, ನೀವು ಆಜ್ಞೆಯನ್ನು ಬಳಸಬಹುದು docker ps ಈ ಕಂಟೇನರ್ ಬಗ್ಗೆ ಮಾಹಿತಿಯನ್ನು ನೋಡಲು (ಅಥವಾ ನೀವು ಆಜ್ಞೆಯನ್ನು ಬಳಸಬಹುದು docker ps -a, ಇದು ಎಲ್ಲಾ ಧಾರಕಗಳ ಬಗ್ಗೆ ಮಾಹಿತಿಯನ್ನು ಪ್ರದರ್ಶಿಸುತ್ತದೆ, ಕೇವಲ ಚಾಲನೆಯಲ್ಲಿರುವವುಗಳಲ್ಲ).

CONTAINER ID        IMAGE               COMMAND                  CREATED              STATUS                      PORTS                    NAMES
987654321234        <image>             "/bin/sh -c 'npm run…"   6 seconds ago        Up 6 seconds                0.0.0.0:5000->5000/tcp   stoic_darwin

ನೀವು ಈಗ ವಿಳಾಸಕ್ಕೆ ಹೋದರೆ localhost:5000 - ಉತ್ಪಾದನಾ ಪರಿಸರದಲ್ಲಿ ಚಾಲನೆಯಲ್ಲಿರುವ ಅಪ್ಲಿಕೇಶನ್‌ನ ಪುಟದಂತೆಯೇ ಕಾಣುವ ಚಾಲನೆಯಲ್ಲಿರುವ ಅಪ್ಲಿಕೇಶನ್‌ನ ಪುಟವನ್ನು ನೀವು ನೋಡಬಹುದು.

▍ಟ್ಯಾಗ್ ಮಾಡುವುದು ಮತ್ತು ಪ್ರಕಟಿಸುವುದು

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

ಈಗ ನೀವು ಹೊಸ ಹೆಸರಿನೊಂದಿಗೆ ಚಿತ್ರವನ್ನು ನಿರ್ಮಿಸಬಹುದು ಮತ್ತು ಆಜ್ಞೆಯನ್ನು ಚಲಾಯಿಸಬಹುದು docker push ಅದನ್ನು ಡಾಕರ್ ಹಬ್ ರೆಪೊಸಿಟರಿಗೆ ತಳ್ಳಲು.

docker build -t <username>/<repository>:<tag> .
docker tag <username>/<repository>:<tag> <username>/<repository>:latest
docker push <username>/<repository>:<tag>

# На практике это может выглядеть, например, так:
docker build -t user/app:v1.0.0 .
docker tag user/app:v1.0.0 user/app:latest
docker push user/app:v1.0.0

ಎಲ್ಲವೂ ಸರಿಯಾಗಿ ನಡೆದರೆ, ಚಿತ್ರವು ಡಾಕರ್ ಹಬ್‌ನಲ್ಲಿ ಲಭ್ಯವಿರುತ್ತದೆ ಮತ್ತು ಸುಲಭವಾಗಿ ಸರ್ವರ್‌ಗೆ ಅಪ್‌ಲೋಡ್ ಮಾಡಬಹುದು ಅಥವಾ ಇತರ ಡೆವಲಪರ್‌ಗಳಿಗೆ ವರ್ಗಾಯಿಸಬಹುದು.

ಮುಂದಿನ ಹಂತಗಳು

ಡಾಕರ್ ಕಂಟೈನರ್ ರೂಪದಲ್ಲಿ ಅಪ್ಲಿಕೇಶನ್ ಸ್ಥಳೀಯವಾಗಿ ಚಾಲನೆಯಲ್ಲಿದೆ ಎಂದು ನಾವು ಈಗ ಪರಿಶೀಲಿಸಿದ್ದೇವೆ. ನಾವು ಕಂಟೇನರ್ ಅನ್ನು ಡಾಕರ್ ಹಬ್‌ಗೆ ಅಪ್‌ಲೋಡ್ ಮಾಡಿದ್ದೇವೆ. ಇದೆಲ್ಲವೂ ನಮ್ಮ ಗುರಿಯತ್ತ ನಾವು ಈಗಾಗಲೇ ಉತ್ತಮ ಪ್ರಗತಿಯನ್ನು ಸಾಧಿಸಿದ್ದೇವೆ ಎಂದರ್ಥ. ಈಗ ನಾವು ಇನ್ನೂ ಎರಡು ಪ್ರಶ್ನೆಗಳನ್ನು ಪರಿಹರಿಸಬೇಕಾಗಿದೆ:

• ಕೋಡ್ ಅನ್ನು ಪರೀಕ್ಷಿಸಲು ಮತ್ತು ನಿಯೋಜಿಸಲು CI ಉಪಕರಣವನ್ನು ಹೊಂದಿಸಲಾಗುತ್ತಿದೆ.
• ಪ್ರೊಡಕ್ಷನ್ ಸರ್ವರ್ ಅನ್ನು ಹೊಂದಿಸಲಾಗುತ್ತಿದೆ ಇದರಿಂದ ಅದು ನಮ್ಮ ಕೋಡ್ ಅನ್ನು ಡೌನ್‌ಲೋಡ್ ಮಾಡಬಹುದು ಮತ್ತು ರನ್ ಮಾಡಬಹುದು.

ನಮ್ಮ ಸಂದರ್ಭದಲ್ಲಿ, ನಾವು ಬಳಸುತ್ತೇವೆ ಟ್ರಾವಿಸ್ ಸಿಐ. ಸರ್ವರ್ ಆಗಿ - ಡಿಟಿಗಲ್ ಸಾಗರ.

ಇಲ್ಲಿ ನೀವು ಸೇವೆಗಳ ಮತ್ತೊಂದು ಸಂಯೋಜನೆಯನ್ನು ಬಳಸಬಹುದು ಎಂದು ಗಮನಿಸಬೇಕು. ಉದಾಹರಣೆಗೆ, ಟ್ರಾವಿಸ್ CI ಬದಲಿಗೆ, ನೀವು CircleCI ಅಥವಾ Github ಕ್ರಿಯೆಗಳನ್ನು ಬಳಸಬಹುದು. ಮತ್ತು ಡಿಜಿಟಲ್ ಓಷನ್ ಬದಲಿಗೆ - AWS ಅಥವಾ ಲಿನೋಡ್.

ನಾವು ಟ್ರಾವಿಸ್ CI ನೊಂದಿಗೆ ಕೆಲಸ ಮಾಡಲು ನಿರ್ಧರಿಸಿದ್ದೇವೆ ಮತ್ತು ನಾನು ಈಗಾಗಲೇ ಈ ಸೇವೆಯಲ್ಲಿ ಏನನ್ನಾದರೂ ಕಾನ್ಫಿಗರ್ ಮಾಡಿದ್ದೇನೆ. ಆದ್ದರಿಂದ, ಈಗ ನಾನು ಅದನ್ನು ಕೆಲಸಕ್ಕೆ ಹೇಗೆ ಸಿದ್ಧಪಡಿಸಬೇಕು ಎಂಬುದರ ಕುರಿತು ಸಂಕ್ಷಿಪ್ತವಾಗಿ ಮಾತನಾಡುತ್ತೇನೆ.

ಟ್ರಾವಿಸ್ ಸಿಐ

ಟ್ರಾವಿಸ್ CI ಕೋಡ್ ಅನ್ನು ಪರೀಕ್ಷಿಸಲು ಮತ್ತು ನಿಯೋಜಿಸಲು ಒಂದು ಸಾಧನವಾಗಿದೆ. ಟ್ರಾವಿಸ್ CI ಅನ್ನು ಸ್ಥಾಪಿಸುವ ಜಟಿಲತೆಗಳಿಗೆ ಹೋಗಲು ನಾನು ಬಯಸುವುದಿಲ್ಲ, ಏಕೆಂದರೆ ಪ್ರತಿಯೊಂದು ಯೋಜನೆಯು ವಿಶಿಷ್ಟವಾಗಿದೆ ಮತ್ತು ಇದು ಹೆಚ್ಚಿನ ಪ್ರಯೋಜನವನ್ನು ತರುವುದಿಲ್ಲ. ಆದರೆ ನೀವು ಟ್ರಾವಿಸ್ CI ಅನ್ನು ಬಳಸಲು ನಿರ್ಧರಿಸಿದರೆ ನೀವು ಪ್ರಾರಂಭಿಸಲು ನಾನು ಮೂಲಭೂತ ಅಂಶಗಳನ್ನು ಒಳಗೊಳ್ಳುತ್ತೇನೆ. ನೀವು Travis CI, CircleCI, Jenkins, ಅಥವಾ ಬೇರೆ ಯಾವುದನ್ನಾದರೂ ಆಯ್ಕೆಮಾಡಿದರೆ, ಇದೇ ರೀತಿಯ ಕಾನ್ಫಿಗರೇಶನ್ ವಿಧಾನಗಳನ್ನು ಎಲ್ಲೆಡೆ ಬಳಸಲಾಗುತ್ತದೆ.

ಟ್ರಾವಿಸ್ CI ನೊಂದಿಗೆ ಪ್ರಾರಂಭಿಸಲು, ಇಲ್ಲಿಗೆ ಹೋಗಿ ಯೋಜನೆಯ ವೆಬ್‌ಸೈಟ್ ಮತ್ತು ಖಾತೆಯನ್ನು ರಚಿಸಿ. ನಂತರ ನಿಮ್ಮ GitHub ಖಾತೆಯೊಂದಿಗೆ ಟ್ರಾವಿಸ್ CI ಅನ್ನು ಸಂಯೋಜಿಸಿ. ಸಿಸ್ಟಮ್ ಅನ್ನು ಹೊಂದಿಸುವಾಗ, ನೀವು ಕೆಲಸವನ್ನು ಸ್ವಯಂಚಾಲಿತಗೊಳಿಸಲು ಮತ್ತು ಅದಕ್ಕೆ ಪ್ರವೇಶವನ್ನು ಸಕ್ರಿಯಗೊಳಿಸಲು ಬಯಸುವ ರೆಪೊಸಿಟರಿಯನ್ನು ನೀವು ನಿರ್ದಿಷ್ಟಪಡಿಸಬೇಕಾಗುತ್ತದೆ. (ನಾನು GitHub ಅನ್ನು ಬಳಸುತ್ತೇನೆ, ಆದರೆ ಟ್ರಾವಿಸ್ CI BitBucket, ಮತ್ತು GitLab ಮತ್ತು ಇತರ ರೀತಿಯ ಸೇವೆಗಳೊಂದಿಗೆ ಸಂಯೋಜಿಸಬಹುದು ಎಂದು ನನಗೆ ಖಾತ್ರಿಯಿದೆ).

ಪ್ರತಿ ಬಾರಿ ಟ್ರಾವಿಸ್ CI ಅನ್ನು ಪ್ರಾರಂಭಿಸಿದಾಗ, ಸರ್ವರ್ ಅನ್ನು ಪ್ರಾರಂಭಿಸಲಾಗುತ್ತದೆ, ಸಂರಚನಾ ಕಡತದಲ್ಲಿ ಸೂಚಿಸಲಾದ ಆಜ್ಞೆಗಳನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸುವುದು, ಅನುಗುಣವಾದ ರೆಪೊಸಿಟರಿ ಶಾಖೆಗಳನ್ನು ನಿಯೋಜಿಸುವುದು ಸೇರಿದಂತೆ.

▍ಉದ್ಯೋಗ ಜೀವನ ಚಕ್ರ

ಟ್ರಾವಿಸ್ CI ಕಾನ್ಫಿಗರೇಶನ್ ಫೈಲ್ ಅನ್ನು ಕರೆಯಲಾಗುತ್ತದೆ .travis.yml ಮತ್ತು ಯೋಜನೆಯ ಮೂಲ ಡೈರೆಕ್ಟರಿಯಲ್ಲಿ ಸಂಗ್ರಹಿಸಲಾಗಿದೆ, ಘಟನೆಗಳ ಪರಿಕಲ್ಪನೆಯನ್ನು ಬೆಂಬಲಿಸುತ್ತದೆ ಜೀವನ ಚಕ್ರ ಕಾರ್ಯಗಳು. ಈ ಘಟನೆಗಳನ್ನು ಅವು ಸಂಭವಿಸುವ ಕ್ರಮದಲ್ಲಿ ಪಟ್ಟಿ ಮಾಡಲಾಗಿದೆ:

• apt addons
• cache components
• before_install
• install
• before_script
• script
• before_cache
• after_success или after_failure
• before_deploy
• deploy
• after_deploy
• after_script

▍ಪರೀಕ್ಷೆ

ಕಾನ್ಫಿಗರೇಶನ್ ಫೈಲ್‌ನಲ್ಲಿ ನಾನು ಸ್ಥಳೀಯ ಟ್ರಾವಿಸ್ ಸಿಐ ಸರ್ವರ್ ಅನ್ನು ಕಾನ್ಫಿಗರ್ ಮಾಡಲಿದ್ದೇನೆ. ನಾನು ಭಾಷೆಯಾಗಿ ನೋಡ್ 12 ಅನ್ನು ಆಯ್ಕೆ ಮಾಡಿದ್ದೇನೆ ಮತ್ತು ಡಾಕರ್ ಅನ್ನು ಬಳಸಲು ಅಗತ್ಯವಿರುವ ಅವಲಂಬನೆಗಳನ್ನು ಸ್ಥಾಪಿಸಲು ಸಿಸ್ಟಮ್‌ಗೆ ಹೇಳಿದೆ.

ಪಟ್ಟಿ ಮಾಡಲಾದ ಎಲ್ಲವೂ .travis.yml, ನಿರ್ದಿಷ್ಟಪಡಿಸದ ಹೊರತು, ರೆಪೊಸಿಟರಿಯ ಎಲ್ಲಾ ಶಾಖೆಗಳಿಗೆ ಎಲ್ಲಾ ಪುಲ್ ವಿನಂತಿಗಳನ್ನು ಮಾಡಿದಾಗ ಕಾರ್ಯಗತಗೊಳಿಸಲಾಗುತ್ತದೆ. ಇದು ಉಪಯುಕ್ತ ವೈಶಿಷ್ಟ್ಯವಾಗಿದೆ ಏಕೆಂದರೆ ನಾವು ರೆಪೊಸಿಟರಿಯಲ್ಲಿ ಬರುವ ಎಲ್ಲಾ ಕೋಡ್ ಅನ್ನು ಪರೀಕ್ಷಿಸಬಹುದು ಎಂದರ್ಥ. ಶಾಖೆಗೆ ಬರೆಯಲು ಕೋಡ್ ಸಿದ್ಧವಾಗಿದೆಯೇ ಎಂದು ಇದು ನಿಮಗೆ ತಿಳಿಸುತ್ತದೆ. master, ಮತ್ತು ಇದು ಯೋಜನೆಯ ನಿರ್ಮಾಣ ಪ್ರಕ್ರಿಯೆಯನ್ನು ಮುರಿಯುತ್ತದೆಯೇ. ಈ ಜಾಗತಿಕ ಕಾನ್ಫಿಗರೇಶನ್‌ನಲ್ಲಿ, ನಾನು ಎಲ್ಲವನ್ನೂ ಸ್ಥಳೀಯವಾಗಿ ಸ್ಥಾಪಿಸುತ್ತೇನೆ, ಹಿನ್ನೆಲೆಯಲ್ಲಿ ವೆಬ್‌ಪ್ಯಾಕ್ ದೇವ್ ಸರ್ವರ್ ಅನ್ನು ರನ್ ಮಾಡುತ್ತೇನೆ (ಇದು ನನ್ನ ವರ್ಕ್‌ಫ್ಲೋನ ವೈಶಿಷ್ಟ್ಯವಾಗಿದೆ), ಮತ್ತು ಪರೀಕ್ಷೆಗಳನ್ನು ರನ್ ಮಾಡುತ್ತೇನೆ.

ನಿಮ್ಮ ರೆಪೊಸಿಟರಿಯು ಪರೀಕ್ಷಾ ವ್ಯಾಪ್ತಿಯನ್ನು ಸೂಚಿಸುವ ಬ್ಯಾಡ್ಜ್‌ಗಳನ್ನು ಪ್ರದರ್ಶಿಸಬೇಕೆಂದು ನೀವು ಬಯಸಿದರೆ, ಇಲ್ಲಿ ಈ ಮಾಹಿತಿಯನ್ನು ಸಂಗ್ರಹಿಸಲು ಮತ್ತು ಪ್ರದರ್ಶಿಸಲು Jest, Travis CI ಮತ್ತು Coveralls ಅನ್ನು ಬಳಸುವ ಕುರಿತು ನೀವು ಕಿರು ಸೂಚನೆಗಳನ್ನು ಕಾಣಬಹುದು.

ಆದ್ದರಿಂದ ಫೈಲ್‌ನ ವಿಷಯ ಇಲ್ಲಿದೆ .travis.yml:

# Установить язык
language: node_js

# Установить версию Node.js
node_js:
  - '12'

services:
  # Использовать командную строку Docker
  - docker

install:
  # Установить зависимости для тестов
  - npm ci

before_script:
  # Запустить сервер и клиент для тестов
  - npm run dev &

script:
  # Запустить тесты
  - npm run test

ಇಲ್ಲಿ ರೆಪೊಸಿಟರಿಯ ಎಲ್ಲಾ ಶಾಖೆಗಳಿಗೆ ಮತ್ತು ಪುಲ್ ವಿನಂತಿಗಳಿಗಾಗಿ ನಿರ್ವಹಿಸುವ ಕ್ರಿಯೆಗಳು ಕೊನೆಗೊಳ್ಳುತ್ತವೆ.

▍ನಿಯೋಜನೆ

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

deploy:
  # Собрать Docker-контейнер и отправить его на Docker Hub
  provider: script
  script: bash deploy.sh
  on:
    branch: master

ನಿಯೋಜನೆ ಸ್ಕ್ರಿಪ್ಟ್ ಎರಡು ಸಮಸ್ಯೆಗಳನ್ನು ಪರಿಹರಿಸುತ್ತದೆ:

• CI ಉಪಕರಣವನ್ನು ಬಳಸಿಕೊಂಡು ಚಿತ್ರವನ್ನು ನಿರ್ಮಿಸಿ, ಟ್ಯಾಗ್ ಮಾಡಿ ಮತ್ತು ಡಾಕರ್ ಹಬ್‌ಗೆ ಕಳುಹಿಸಿ (ನಮ್ಮ ಸಂದರ್ಭದಲ್ಲಿ, ಟ್ರಾವಿಸ್ CI).
• ಸರ್ವರ್‌ನಲ್ಲಿ ಚಿತ್ರವನ್ನು ಲೋಡ್ ಮಾಡುವುದು, ಹಳೆಯ ಕಂಟೇನರ್ ಅನ್ನು ನಿಲ್ಲಿಸುವುದು ಮತ್ತು ಹೊಸದನ್ನು ಪ್ರಾರಂಭಿಸುವುದು (ನಮ್ಮ ಸಂದರ್ಭದಲ್ಲಿ, ಸರ್ವರ್ ಡಿಜಿಟಲ್ ಓಷನ್ ಪ್ಲಾಟ್‌ಫಾರ್ಮ್‌ನಲ್ಲಿ ಚಲಿಸುತ್ತದೆ).

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

ಆದ್ದರಿಂದ, ಸ್ಕ್ರಿಪ್ಟ್‌ನ ಮೊದಲ ಭಾಗವು ಚಿತ್ರವನ್ನು ಡಾಕರ್ ಹಬ್‌ಗೆ ಅಪ್‌ಲೋಡ್ ಮಾಡುತ್ತಿದೆ. ಇದನ್ನು ಮಾಡಲು ಸಾಕಷ್ಟು ಸುಲಭ. ನಾನು ಬಳಸಿದ ಟ್ಯಾಗಿಂಗ್ ಸ್ಕೀಮ್ ಒಂದು git ಹ್ಯಾಶ್ ಮತ್ತು ಒಂದು git ಟ್ಯಾಗ್ ಅನ್ನು ಸಂಯೋಜಿಸುವುದನ್ನು ಒಳಗೊಂಡಿರುತ್ತದೆ. ಇದು ಟ್ಯಾಗ್ ಅನನ್ಯವಾಗಿದೆ ಎಂದು ಖಚಿತಪಡಿಸುತ್ತದೆ ಮತ್ತು ಅದರ ಆಧಾರದ ಮೇಲೆ ಜೋಡಣೆಯನ್ನು ಗುರುತಿಸಲು ಸುಲಭವಾಗುತ್ತದೆ. DOCKER_USERNAME и DOCKER_PASSWORD ಟ್ರಾವಿಸ್ CI ಇಂಟರ್ಫೇಸ್ ಅನ್ನು ಬಳಸಿಕೊಂಡು ಹೊಂದಿಸಬಹುದಾದ ಬಳಕೆದಾರ ಪರಿಸರ ವೇರಿಯಬಲ್ಗಳಾಗಿವೆ. ಟ್ರಾವಿಸ್ CI ಸ್ವಯಂಚಾಲಿತವಾಗಿ ಸೂಕ್ಷ್ಮ ಡೇಟಾವನ್ನು ಪ್ರಕ್ರಿಯೆಗೊಳಿಸುತ್ತದೆ ಇದರಿಂದ ಅದು ತಪ್ಪು ಕೈಗೆ ಬೀಳುವುದಿಲ್ಲ.

ಸ್ಕ್ರಿಪ್ಟ್‌ನ ಮೊದಲ ಭಾಗ ಇಲ್ಲಿದೆ deploy.sh.

#!/bin/sh
set -e # Остановить скрипт при наличии ошибок

IMAGE="<username>/<repository>"                             # Образ Docker
GIT_VERSION=$(git describe --always --abbrev --tags --long) # Git-хэш и теги

# Сборка и тегирование образа
docker build -t ${IMAGE}:${GIT_VERSION} .
docker tag ${IMAGE}:${GIT_VERSION} ${IMAGE}:latest

# Вход в Docker Hub и выгрузка образа
echo "${DOCKER_PASSWORD}" | docker login -u "${DOCKER_USERNAME}" --password-stdin
docker push ${IMAGE}:${GIT_VERSION}

ಸ್ಕ್ರಿಪ್ಟ್‌ನ ಎರಡನೇ ಭಾಗವು ನೀವು ಯಾವ ಹೋಸ್ಟ್ ಅನ್ನು ಬಳಸುತ್ತಿರುವಿರಿ ಮತ್ತು ಅದರ ಸಂಪರ್ಕವನ್ನು ಹೇಗೆ ಆಯೋಜಿಸಲಾಗಿದೆ ಎಂಬುದರ ಮೇಲೆ ಸಂಪೂರ್ಣವಾಗಿ ಅವಲಂಬಿತವಾಗಿರುತ್ತದೆ. ನನ್ನ ಸಂದರ್ಭದಲ್ಲಿ, ನಾನು ಡಿಜಿಟಲ್ ಸಾಗರವನ್ನು ಬಳಸುವುದರಿಂದ, ಸರ್ವರ್‌ಗೆ ಸಂಪರ್ಕಿಸಲು ನಾನು ಆಜ್ಞೆಗಳನ್ನು ಬಳಸುತ್ತೇನೆ ಡಾಕ್ಟ್ಲ್. AWS ನೊಂದಿಗೆ ಕೆಲಸ ಮಾಡುವಾಗ, ಉಪಯುಕ್ತತೆಯನ್ನು ಬಳಸಲಾಗುತ್ತದೆ aws, ಮತ್ತು ಇತ್ಯಾದಿ.

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

ಸೇವೆಗಾಗಿ ನಿರ್ದಿಷ್ಟ ಆಜ್ಞೆಗಳ ಬಗ್ಗೆ ನಾನು ಇಲ್ಲಿ ಮಾತನಾಡುವುದಿಲ್ಲ, ಏಕೆಂದರೆ ಈ ಅಂಶವು ವಿಭಿನ್ನ ಸಂದರ್ಭಗಳಲ್ಲಿ ಹೆಚ್ಚು ಬದಲಾಗಬಹುದು. ಪ್ರಾಜೆಕ್ಟ್ ಅನ್ನು ನಿಯೋಜಿಸಲಾಗುವ ಸರ್ವರ್‌ಗೆ SSH ಮೂಲಕ ಸಂಪರ್ಕಿಸಿದ ನಂತರ ನಿರ್ವಹಿಸಬೇಕಾದ ಕ್ರಿಯೆಯ ಸಾಮಾನ್ಯ ಯೋಜನೆಯನ್ನು ನಾನು ನೀಡುತ್ತೇನೆ:

• ನಾವು ಪ್ರಸ್ತುತ ಚಾಲನೆಯಲ್ಲಿರುವ ಕಂಟೇನರ್ ಅನ್ನು ಕಂಡುಹಿಡಿಯಬೇಕು ಮತ್ತು ಅದನ್ನು ನಿಲ್ಲಿಸಬೇಕು.
• ನಂತರ ನೀವು ಹಿನ್ನೆಲೆಯಲ್ಲಿ ಹೊಸ ಕಂಟೇನರ್ ಅನ್ನು ಪ್ರಾರಂಭಿಸಬೇಕಾಗುತ್ತದೆ.
• ನೀವು ಸರ್ವರ್‌ನ ಸ್ಥಳೀಯ ಪೋರ್ಟ್ ಅನ್ನು ಹೊಂದಿಸಬೇಕಾಗುತ್ತದೆ 80 - ಈ ರೀತಿಯ ವಿಳಾಸದಲ್ಲಿ ಸೈಟ್ ಅನ್ನು ನಮೂದಿಸಲು ಇದು ನಿಮ್ಮನ್ನು ಅನುಮತಿಸುತ್ತದೆ example.com, ಪೋರ್ಟ್ ಅನ್ನು ನಿರ್ದಿಷ್ಟಪಡಿಸದೆ, ವಿಳಾಸವನ್ನು ಬಳಸುವುದಕ್ಕಿಂತ ಹೆಚ್ಚಾಗಿ example.com:5000.
• ಅಂತಿಮವಾಗಿ, ನೀವು ಎಲ್ಲಾ ಹಳೆಯ ಪಾತ್ರೆಗಳು ಮತ್ತು ಚಿತ್ರಗಳನ್ನು ಅಳಿಸಬೇಕಾಗಿದೆ.

ಸ್ಕ್ರಿಪ್ಟ್‌ನ ಮುಂದುವರಿಕೆ ಇಲ್ಲಿದೆ.

# Найти ID работающего контейнера
CONTAINER_ID=$(docker ps | grep takenote | cut -d" " -f1)

# Остановить старый контейнер, запустить новый, очистить систему
docker stop ${CONTAINER_ID}
docker run --restart unless-stopped -d -p 80:5000 ${IMAGE}:${GIT_VERSION}
docker system prune -a -f

ಗಮನ ಕೊಡಬೇಕಾದ ಕೆಲವು ವಿಷಯಗಳು

ನೀವು ಟ್ರಾವಿಸ್ CI ಯಿಂದ SSH ಮೂಲಕ ಸರ್ವರ್‌ಗೆ ಸಂಪರ್ಕಿಸಿದಾಗ, ಸಿಸ್ಟಮ್ ಬಳಕೆದಾರರ ಪ್ರತಿಕ್ರಿಯೆಗಾಗಿ ಕಾಯುವುದರಿಂದ ಅನುಸ್ಥಾಪನೆಯೊಂದಿಗೆ ಮುಂದುವರಿಯುವುದನ್ನು ತಡೆಯುವ ಎಚ್ಚರಿಕೆಯನ್ನು ನೀವು ನೋಡುವ ಸಾಧ್ಯತೆಯಿದೆ.

The authenticity of host '<hostname> (<IP address>)' can't be established.
RSA key fingerprint is <key fingerprint>.
Are you sure you want to continue connecting (yes/no)?

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

echo <public key> | base64 # выводит <публичный ключ, закодированный в base64>

ಪ್ರಾಯೋಗಿಕವಾಗಿ, ಈ ಆಜ್ಞೆಯು ಈ ರೀತಿ ಕಾಣಿಸಬಹುದು:

echo "123.45.67.89 ssh-rsa AAAAB3NzaC1yc2EAAAABIwAAAQEAklOUpkDHrfHY17SbrmTIpNLTGK9Tjom/BWDSU
GPl+nafzlHDTYW7hdI4yZ5ew18JH4JW9jbhUFrviQzM7xlELEVf4h9lFX5QVkbPppSwg0cda3
Pbv7kOdJ/MTyBlWXFCR+HAo3FXRitBqxiX1nKhXpHAZsMciLq8V6RjsNAQwdsdMFvSlVK/7XA
t3FaoJoAsncM1Q9x5+3V0Ww68/eIFmb1zuUFljQJKprrX88XypNDvjYNby6vw/Pb0rwert/En
mZ+AW4OZPnTPI89ZPmVMLuayrD2cE86Z/il8b+gw3r3+1nKatmIkjn2so1d01QraTlMqVSsbx
NrRFi9wrf+M7Q== [email protected]" | base64

ಮತ್ತು ಅದು ಏನು ಉತ್ಪಾದಿಸುತ್ತದೆ ಎಂಬುದು ಇಲ್ಲಿದೆ - ಬೇಸ್ 64 ಎನ್ಕೋಡ್ ಮಾಡಿದ ಸ್ಟ್ರಿಂಗ್:

MTIzLjQ1LjY3Ljg5IHNzaC1yc2EgQUFBQUIzTnphQzF5YzJFQUFBQUJJd0FBQVFFQWtsT1Vwa0RIcmZIWTE3U2JybVRJcE5MVEdLOVRqb20vQldEU1UKR1BsK25hZnpsSERUWVc3aGRJNHlaNWV3MThKSDRKVzlqYmhVRnJ2aVF6TTd4bEVMRVZmNGg5bEZYNVFWa2JQcHBTd2cwY2RhMwpQYnY3a09kSi9NVHlCbFdYRkNSK0hBbzNGWFJpdEJxeGlYMW5LaFhwSEFac01jaUxxOFY2UmpzTkFRd2RzZE1GdlNsVksvN1hBCnQzRmFvSm9Bc25jTTFROXg1KzNWMFd3NjgvZUlGbWIxenVVRmxqUUpLcHJyWDg4WHlwTkR2allOYnk2dncvUGIwcndlcnQvRW4KbVorQVc0T1pQblRQSTg5WlBtVk1MdWF5ckQyY0U4NlovaWw4YitndzNyMysxbkthdG1Ja2puMnNvMWQwMVFyYVRsTXFWU3NieApOclJGaTl3cmYrTTdRPT0geW91QGV4YW1wbGUuY29tCg==

ಮೇಲೆ ತಿಳಿಸಿದ ಆಜ್ಞೆ ಇಲ್ಲಿದೆ

install:
  - echo < публичный ключ, закодированный в base64> | base64 -d >> $HOME/.ssh/known_hosts

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

ಗಮನಿಸಬೇಕಾದ ಇನ್ನೊಂದು ವಿಷಯವೆಂದರೆ ನೀವು ಸಂಪೂರ್ಣ ನಿಯೋಜನೆ ಸ್ಕ್ರಿಪ್ಟ್ ಅನ್ನು ಒಂದು ಸಾಲಿನಂತೆ ರನ್ ಮಾಡಬೇಕಾಗಬಹುದು, ಉದಾಹರಣೆಗೆ - ಜೊತೆಗೆ doctl. ಇದಕ್ಕೆ ಸ್ವಲ್ಪ ಹೆಚ್ಚುವರಿ ಪ್ರಯತ್ನ ಬೇಕಾಗಬಹುದು.

doctl compute ssh <droplet> --ssh-command "все команды будут здесь && здесь"

TLS/SSL ಮತ್ತು ಲೋಡ್ ಬ್ಯಾಲೆನ್ಸಿಂಗ್

ನಾನು ಮೇಲೆ ತಿಳಿಸಿದ ಎಲ್ಲವನ್ನೂ ಮಾಡಿದ ನಂತರ, ನಾನು ಎದುರಿಸಿದ ಕೊನೆಯ ಸಮಸ್ಯೆ ಎಂದರೆ ಸರ್ವರ್ SSL ಅನ್ನು ಹೊಂದಿಲ್ಲ. ನಾನು Node.js ಸರ್ವರ್ ಅನ್ನು ಬಳಸುವುದರಿಂದ, ಒತ್ತಾಯಿಸಲು ಕೆಲಸ ಮಾಡಲು ರಿವರ್ಸ್ ಪ್ರಾಕ್ಸಿ Nginx ಮತ್ತು ಲೆಟ್ಸ್ ಎನ್‌ಕ್ರಿಪ್ಟ್, ನೀವು ಬಹಳಷ್ಟು ಟಿಂಕರ್ ಮಾಡಬೇಕಾಗುತ್ತದೆ.

ಈ ಎಲ್ಲಾ SSL ಕಾನ್ಫಿಗರೇಶನ್ ಅನ್ನು ಹಸ್ತಚಾಲಿತವಾಗಿ ಮಾಡಲು ನಾನು ನಿಜವಾಗಿಯೂ ಬಯಸಲಿಲ್ಲ, ಆದ್ದರಿಂದ ನಾನು ಲೋಡ್ ಬ್ಯಾಲೆನ್ಸರ್ ಅನ್ನು ರಚಿಸಿದ್ದೇನೆ ಮತ್ತು ಅದರ ವಿವರಗಳನ್ನು DNS ನಲ್ಲಿ ದಾಖಲಿಸಿದ್ದೇನೆ. DigitalOcean ನ ಸಂದರ್ಭದಲ್ಲಿ, ಉದಾಹರಣೆಗೆ, ಲೋಡ್ ಬ್ಯಾಲೆನ್ಸರ್‌ನಲ್ಲಿ ಸ್ವಯಂ-ನವೀಕರಿಸುವ ಸ್ವಯಂ-ಸಹಿ ಪ್ರಮಾಣಪತ್ರವನ್ನು ರಚಿಸುವುದು ಸರಳ, ಉಚಿತ ಮತ್ತು ವೇಗದ ಕಾರ್ಯವಿಧಾನವಾಗಿದೆ. ಈ ವಿಧಾನವು ಹೆಚ್ಚುವರಿ ಪ್ರಯೋಜನವನ್ನು ಹೊಂದಿದೆ, ಅಗತ್ಯವಿದ್ದರೆ ಲೋಡ್ ಬ್ಯಾಲೆನ್ಸರ್ ಹಿಂದೆ ಚಾಲನೆಯಲ್ಲಿರುವ ಬಹು ಸರ್ವರ್‌ಗಳಲ್ಲಿ SSL ಅನ್ನು ಹೊಂದಿಸಲು ಇದು ತುಂಬಾ ಸುಲಭವಾಗುತ್ತದೆ. ಇದು ಸರ್ವರ್‌ಗಳು SSL ಬಗ್ಗೆ "ಆಲೋಚಿಸದಂತೆ" ಅನುಮತಿಸುತ್ತದೆ, ಆದರೆ ಅದೇ ಸಮಯದಲ್ಲಿ ಎಂದಿನಂತೆ ಪೋರ್ಟ್ ಅನ್ನು ಬಳಸಿ 80. ಆದ್ದರಿಂದ ಲೋಡ್ ಬ್ಯಾಲೆನ್ಸರ್ನಲ್ಲಿ SSL ಅನ್ನು ಹೊಂದಿಸುವುದು SSL ಅನ್ನು ಹೊಂದಿಸುವ ಪರ್ಯಾಯ ವಿಧಾನಗಳಿಗಿಂತ ಹೆಚ್ಚು ಸುಲಭ ಮತ್ತು ಹೆಚ್ಚು ಅನುಕೂಲಕರವಾಗಿದೆ.

ಈಗ ನೀವು ಒಳಬರುವ ಸಂಪರ್ಕಗಳನ್ನು ಸ್ವೀಕರಿಸುವ ಸರ್ವರ್‌ನಲ್ಲಿ ಎಲ್ಲಾ ಪೋರ್ಟ್‌ಗಳನ್ನು ಮುಚ್ಚಬಹುದು - ಪೋರ್ಟ್ ಹೊರತುಪಡಿಸಿ 80, ಲೋಡ್ ಬ್ಯಾಲೆನ್ಸರ್ ಮತ್ತು ಪೋರ್ಟ್‌ನೊಂದಿಗೆ ಸಂವಹನ ನಡೆಸಲು ಬಳಸಲಾಗುತ್ತದೆ 22 SSH ಗಾಗಿ. ಪರಿಣಾಮವಾಗಿ, ಈ ಎರಡನ್ನು ಹೊರತುಪಡಿಸಿ ಯಾವುದೇ ಪೋರ್ಟ್‌ಗಳಲ್ಲಿ ಸರ್ವರ್ ಅನ್ನು ನೇರವಾಗಿ ಪ್ರವೇಶಿಸುವ ಪ್ರಯತ್ನವು ವಿಫಲಗೊಳ್ಳುತ್ತದೆ.

ಫಲಿತಾಂಶಗಳು

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

ಪಿಎಸ್ ನಮ್ಮಲ್ಲಿ ಮಾರುಕಟ್ಟೆ ಒಂದು ಚಿತ್ರವಿದೆ ಡಾಕರ್, ಇದನ್ನು ಒಂದೇ ಕ್ಲಿಕ್‌ನಲ್ಲಿ ಸ್ಥಾಪಿಸಬಹುದು. ನೀವು ಧಾರಕಗಳ ಕಾರ್ಯಾಚರಣೆಯನ್ನು ಪರಿಶೀಲಿಸಬಹುದು VPS. ಎಲ್ಲಾ ಹೊಸ ಕ್ಲೈಂಟ್‌ಗಳಿಗೆ 3 ದಿನಗಳ ಪರೀಕ್ಷೆಯನ್ನು ಉಚಿತವಾಗಿ ನೀಡಲಾಗುತ್ತದೆ.

ಆತ್ಮೀಯ ಓದುಗರು! ನಿಮ್ಮ ಯೋಜನೆಗಳಲ್ಲಿ ನೀವು CI/CD ತಂತ್ರಜ್ಞಾನಗಳನ್ನು ಬಳಸುತ್ತೀರಾ?

ಮೂಲ: www.habr.com