ಕುಬರ್ನೆಟ್ಸ್ ಅತ್ಯುತ್ತಮ ಅಭ್ಯಾಸಗಳು. ಸಣ್ಣ ಪಾತ್ರೆಗಳನ್ನು ರಚಿಸುವುದು

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

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

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

ಆದ್ದರಿಂದ ಈ ಎಲ್ಲಾ ಹೆಚ್ಚುವರಿ ಕೆಲಸದ ಹೊರೆಯು ಡಿಜಿಟಲ್ ಸ್ಥಳದ ವ್ಯರ್ಥವಾಗಿದೆ ಮತ್ತು ಭದ್ರತಾ ದೋಷಗಳು ಮತ್ತು ದೋಷಗಳಿಗೆ ಉತ್ತಮ ಅಡಗುತಾಣವಾಗಿದೆ. ಆದ್ದರಿಂದ ಕಂಟೇನರ್ ಚಿತ್ರದ ಗಾತ್ರವನ್ನು ಕಡಿಮೆ ಮಾಡಲು ಎರಡು ಮಾರ್ಗಗಳನ್ನು ನೋಡೋಣ.

ಮೊದಲನೆಯದು ಸಣ್ಣ ಮೂಲ ಚಿತ್ರಗಳ ಬಳಕೆ, ಎರಡನೆಯದು ಬಿಲ್ಡರ್ ಪ್ಯಾಟರ್ನ್ ಬಳಕೆ. ನಿಮ್ಮ ಕಂಟೇನರ್‌ನ ಗಾತ್ರವನ್ನು ಕಡಿಮೆ ಮಾಡಲು ಚಿಕ್ಕ ಮೂಲ ಚಿತ್ರಗಳನ್ನು ಬಳಸುವುದು ಬಹುಶಃ ಸುಲಭವಾದ ಮಾರ್ಗವಾಗಿದೆ. ಹೆಚ್ಚಾಗಿ, ನೀವು ಬಳಸುತ್ತಿರುವ ಭಾಷೆ ಅಥವಾ ಸ್ಟ್ಯಾಕ್ ಡೀಫಾಲ್ಟ್ ಚಿತ್ರಕ್ಕಿಂತ ಚಿಕ್ಕದಾಗಿರುವ ಮೂಲ ಅಪ್ಲಿಕೇಶನ್ ಚಿತ್ರವನ್ನು ಒದಗಿಸುತ್ತದೆ. ನಮ್ಮ node.js ಧಾರಕವನ್ನು ನೋಡೋಣ.

ಡಾಕರ್‌ನಲ್ಲಿ ಪೂರ್ವನಿಯೋಜಿತವಾಗಿ, ನೋಡ್:8 ಬೇಸ್ ಇಮೇಜ್ ಗಾತ್ರವು 670 MB ಆಗಿದೆ, ಮತ್ತು ನೋಡ್: 8-ಆಲ್ಪೈನ್ ಚಿತ್ರದ ಗಾತ್ರವು ಕೇವಲ 65 MB ಆಗಿದೆ, ಅಂದರೆ, 10 ಪಟ್ಟು ಚಿಕ್ಕದಾಗಿದೆ. ಚಿಕ್ಕದಾದ ಆಲ್ಪೈನ್ ಬೇಸ್ ಚಿತ್ರವನ್ನು ಬಳಸುವುದರಿಂದ, ನಿಮ್ಮ ಕಂಟೇನರ್‌ನ ಗಾತ್ರವನ್ನು ನೀವು ಗಮನಾರ್ಹವಾಗಿ ಕಡಿಮೆಗೊಳಿಸುತ್ತೀರಿ. ಆಲ್ಪೈನ್ ಒಂದು ಸಣ್ಣ ಮತ್ತು ಹಗುರವಾದ ಲಿನಕ್ಸ್ ವಿತರಣೆಯಾಗಿದ್ದು ಅದು ಡಾಕರ್ ಬಳಕೆದಾರರಲ್ಲಿ ಬಹಳ ಜನಪ್ರಿಯವಾಗಿದೆ ಏಕೆಂದರೆ ಇದು ಕಂಟೇನರ್‌ಗಳನ್ನು ಚಿಕ್ಕದಾಗಿಸುವಾಗ ಅನೇಕ ಅಪ್ಲಿಕೇಶನ್‌ಗಳೊಂದಿಗೆ ಹೊಂದಿಕೊಳ್ಳುತ್ತದೆ. ಸ್ಟ್ಯಾಂಡರ್ಡ್ ಡಾಕರ್ "ನೋಡ್" ಇಮೇಜ್‌ಗಿಂತ ಭಿನ್ನವಾಗಿ, "ನೋಡ್: ಆಲ್ಪೈನ್" ಬಹಳಷ್ಟು ಸೇವಾ ಫೈಲ್‌ಗಳು ಮತ್ತು ಪ್ರೋಗ್ರಾಂಗಳನ್ನು ತೆಗೆದುಹಾಕುತ್ತದೆ, ನಿಮ್ಮ ಅಪ್ಲಿಕೇಶನ್ ಅನ್ನು ಚಲಾಯಿಸಲು ಸಾಕಷ್ಟು ಮಾತ್ರ ಉಳಿದಿದೆ.

ಸಣ್ಣ ಬೇಸ್ ಇಮೇಜ್‌ಗೆ ಸರಿಸಲು, ಹೊಸ ಬೇಸ್ ಇಮೇಜ್‌ನೊಂದಿಗೆ ಕೆಲಸ ಮಾಡಲು ಡಾಕರ್‌ಫೈಲ್ ಅನ್ನು ನವೀಕರಿಸಿ:

ಈಗ, ಹಳೆಯ ಆನ್‌ಬಿಲ್ಡ್ ಇಮೇಜ್‌ಗಿಂತ ಭಿನ್ನವಾಗಿ, ನೀವು ನಿಮ್ಮ ಕೋಡ್ ಅನ್ನು ಕಂಟೇನರ್‌ಗೆ ನಕಲಿಸಬೇಕು ಮತ್ತು ಯಾವುದೇ ಅವಲಂಬನೆಗಳನ್ನು ಸ್ಥಾಪಿಸಬೇಕು. ಹೊಸ ಡಾಕರ್‌ಫೈಲ್‌ನಲ್ಲಿ, ಧಾರಕವು ನೋಡ್: ಆಲ್ಪೈನ್ ಇಮೇಜ್‌ನೊಂದಿಗೆ ಪ್ರಾರಂಭವಾಗುತ್ತದೆ, ನಂತರ ಕೋಡ್‌ಗಾಗಿ ಡೈರೆಕ್ಟರಿಯನ್ನು ರಚಿಸುತ್ತದೆ, NPM ಪ್ಯಾಕೇಜ್ ಮ್ಯಾನೇಜರ್ ಅನ್ನು ಬಳಸಿಕೊಂಡು ಅವಲಂಬನೆಗಳನ್ನು ಸ್ಥಾಪಿಸುತ್ತದೆ ಮತ್ತು ಅಂತಿಮವಾಗಿ server.js ಅನ್ನು ರನ್ ಮಾಡುತ್ತದೆ.

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

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

ಕೋಡ್ ಅನ್ನು ಮೊದಲ ಕಂಟೇನರ್ನಲ್ಲಿ ರಚಿಸಲಾಗಿದೆ ಮತ್ತು ಸಂಕಲಿಸಲಾಗಿದೆ. ಕಂಪೈಲ್ ಮಾಡಿದ ಕೋಡ್ ಅನ್ನು ಆ ಕೋಡ್ ಅನ್ನು ಕಂಪೈಲ್ ಮಾಡಲು ಅಗತ್ಯವಿರುವ ಕಂಪೈಲರ್‌ಗಳು ಮತ್ತು ಉಪಕರಣಗಳಿಲ್ಲದೆ ಅಂತಿಮ ಕಂಟೇನರ್‌ಗೆ ಪ್ಯಾಕ್ ಮಾಡಲಾಗುತ್ತದೆ. ಈ ಪ್ರಕ್ರಿಯೆಯ ಮೂಲಕ Go ಅಪ್ಲಿಕೇಶನ್ ಅನ್ನು ರನ್ ಮಾಡೋಣ. ಮೊದಲಿಗೆ, ನಾವು ಆನ್‌ಬಿಲ್ಡ್ ಇಮೇಜ್‌ನಿಂದ ಆಲ್ಪೈನ್ ಲಿನಕ್ಸ್‌ಗೆ ಚಲಿಸುತ್ತೇವೆ.

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

ಈ ಡಾಕರ್ ಫೈಲ್‌ನಲ್ಲಿ ನೀವು ವಿಚಿತ್ರವಾದದ್ದನ್ನು ಗಮನಿಸಬಹುದು: ಇದು ಎರಡು FROM ಸಾಲುಗಳನ್ನು ಒಳಗೊಂಡಿದೆ. ಮೊದಲ 4 ಸಾಲಿನ ವಿಭಾಗವು ಈ ಹಂತವನ್ನು ಹೆಸರಿಸಲು AS ಕೀವರ್ಡ್ ಅನ್ನು ಬಳಸುವುದನ್ನು ಹೊರತುಪಡಿಸಿ ಹಿಂದಿನ ಡಾಕರ್‌ಫೈಲ್‌ನಂತೆಯೇ ಕಾಣುತ್ತದೆ. ಮುಂದಿನ ವಿಭಾಗವು ಹೊಸ ಚಿತ್ರವನ್ನು ಪ್ರಾರಂಭಿಸಲು ಹೊಸ FROM ಲೈನ್ ಅನ್ನು ಹೊಂದಿದೆ, ಅಲ್ಲಿ ಗೋಲಾಂಗ್: ಆಲ್ಪೈನ್ ಚಿತ್ರದ ಬದಲಿಗೆ ನಾವು ಮೂಲ ಚಿತ್ರವಾಗಿ ರಾ ಆಲ್ಪೈನ್ ಅನ್ನು ಬಳಸುತ್ತೇವೆ.

Raw Alpine Linux ಯಾವುದೇ SSL ಪ್ರಮಾಣಪತ್ರಗಳನ್ನು ಸ್ಥಾಪಿಸಿಲ್ಲ, ಇದು HTTPS ಮೂಲಕ ಹೆಚ್ಚಿನ API ಕರೆಗಳು ವಿಫಲಗೊಳ್ಳಲು ಕಾರಣವಾಗುತ್ತದೆ, ಆದ್ದರಿಂದ ನಾವು ಕೆಲವು ರೂಟ್ CA ಪ್ರಮಾಣಪತ್ರಗಳನ್ನು ಸ್ಥಾಪಿಸೋಣ.

ಈಗ ಮೋಜಿನ ಭಾಗವು ಬರುತ್ತದೆ: ಮೊದಲ ಕಂಟೇನರ್‌ನಿಂದ ಎರಡನೆಯದಕ್ಕೆ ಸಂಕಲಿಸಿದ ಕೋಡ್ ಅನ್ನು ನಕಲಿಸಲು, ನೀವು ಎರಡನೇ ವಿಭಾಗದ 5 ನೇ ಸಾಲಿನಲ್ಲಿರುವ COPY ಆಜ್ಞೆಯನ್ನು ಸರಳವಾಗಿ ಬಳಸಬಹುದು. ಇದು ಕೇವಲ ಒಂದು ಅಪ್ಲಿಕೇಶನ್ ಫೈಲ್ ಅನ್ನು ನಕಲಿಸುತ್ತದೆ ಮತ್ತು Go ಯುಟಿಲಿಟಿ ಪರಿಕರಗಳ ಮೇಲೆ ಪರಿಣಾಮ ಬೀರುವುದಿಲ್ಲ. ಹೊಸ ಬಹು-ಹಂತದ ಡಾಕರ್ ಫೈಲ್ 12 ಮೆಗಾಬೈಟ್‌ಗಳ ಮೂಲ ಕಂಟೇನರ್ ಇಮೇಜ್‌ಗೆ ಹೋಲಿಸಿದರೆ ಕೇವಲ 700 ಮೆಗಾಬೈಟ್‌ಗಳ ಗಾತ್ರದ ಕಂಟೇನರ್ ಇಮೇಜ್ ಅನ್ನು ಹೊಂದಿರುತ್ತದೆ, ಇದು ದೊಡ್ಡ ವ್ಯತ್ಯಾಸವಾಗಿದೆ!
ಆದ್ದರಿಂದ ಸಣ್ಣ ಬೇಸ್ ಚಿತ್ರಗಳು ಮತ್ತು ಬಿಲ್ಡರ್ ಪ್ಯಾಟರ್ನ್ ಅನ್ನು ಬಳಸುವುದು ಹೆಚ್ಚಿನ ಕೆಲಸವಿಲ್ಲದೆ ಚಿಕ್ಕದಾದ ಕಂಟೇನರ್‌ಗಳನ್ನು ರಚಿಸಲು ಉತ್ತಮ ಮಾರ್ಗವಾಗಿದೆ.
ಅಪ್ಲಿಕೇಶನ್ ಸ್ಟಾಕ್ ಅನ್ನು ಅವಲಂಬಿಸಿ, ಇಮೇಜ್ ಮತ್ತು ಕಂಟೇನರ್ ಗಾತ್ರವನ್ನು ಕಡಿಮೆ ಮಾಡಲು ಹೆಚ್ಚುವರಿ ಮಾರ್ಗಗಳಿವೆ, ಆದರೆ ಸಣ್ಣ ಕಂಟೇನರ್ಗಳು ನಿಜವಾಗಿಯೂ ಅಳೆಯಬಹುದಾದ ಪ್ರಯೋಜನವನ್ನು ಹೊಂದಿವೆಯೇ? ಸಣ್ಣ ಪಾತ್ರೆಗಳು ಅತ್ಯಂತ ಪರಿಣಾಮಕಾರಿಯಾದ ಎರಡು ಕ್ಷೇತ್ರಗಳನ್ನು ನೋಡೋಣ - ಕಾರ್ಯಕ್ಷಮತೆ ಮತ್ತು ಭದ್ರತೆ.

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

ಡಾಕರ್ ಲೇಯರ್‌ಗಳನ್ನು ಕ್ಯಾಶ್ ಮಾಡುತ್ತದೆ ಆದ್ದರಿಂದ ನಂತರದ ನಿರ್ಮಾಣಗಳು ತುಂಬಾ ವೇಗವಾಗಿರುತ್ತವೆ. ಆದಾಗ್ಯೂ, ಕಂಟೇನರ್‌ಗಳನ್ನು ನಿರ್ಮಿಸಲು ಮತ್ತು ಪರೀಕ್ಷಿಸಲು ಬಳಸಲಾಗುವ ಅನೇಕ CI ವ್ಯವಸ್ಥೆಗಳು ಪದರಗಳನ್ನು ಸಂಗ್ರಹಿಸುವುದಿಲ್ಲ, ಆದ್ದರಿಂದ ಗಮನಾರ್ಹ ಸಮಯ ಉಳಿತಾಯವಿದೆ. ನೀವು ನೋಡುವಂತೆ, ನಿಮ್ಮ ಯಂತ್ರದ ಶಕ್ತಿಯನ್ನು ಅವಲಂಬಿಸಿ ದೊಡ್ಡ ಕಂಟೇನರ್ ಅನ್ನು ನಿರ್ಮಿಸುವ ಸಮಯವು 34 ರಿಂದ 54 ಸೆಕೆಂಡುಗಳವರೆಗೆ ಇರುತ್ತದೆ ಮತ್ತು ಕಂಟೇನರ್ ಅನ್ನು ಬಳಸುವಾಗ ಬಿಲ್ಡರ್ ಪ್ಯಾಟರ್ನ್ ಬಳಸಿ ಕಡಿಮೆಯಾಗಿದೆ - 23 ರಿಂದ 28 ಸೆಕೆಂಡುಗಳವರೆಗೆ. ಈ ರೀತಿಯ ಕಾರ್ಯಾಚರಣೆಗಳಿಗಾಗಿ, ಉತ್ಪಾದಕತೆಯ ಹೆಚ್ಚಳವು 40-50% ಆಗಿರುತ್ತದೆ. ಆದ್ದರಿಂದ ನಿಮ್ಮ ಕೋಡ್ ಅನ್ನು ನೀವು ಎಷ್ಟು ಬಾರಿ ನಿರ್ಮಿಸುತ್ತೀರಿ ಮತ್ತು ಪರೀಕ್ಷಿಸುತ್ತೀರಿ ಎಂಬುದರ ಕುರಿತು ಯೋಚಿಸಿ.

ಕಂಟೇನರ್ ಅನ್ನು ನಿರ್ಮಿಸಿದ ನಂತರ, ನೀವು ಅದರ ಚಿತ್ರವನ್ನು (ಪುಶ್ ಕಂಟೇನರ್ ಇಮೇಜ್) ಕಂಟೇನರ್ ರಿಜಿಸ್ಟ್ರಿಗೆ ತಳ್ಳುವ ಅಗತ್ಯವಿದೆ ಇದರಿಂದ ನೀವು ಅದನ್ನು ನಿಮ್ಮ ಕುಬರ್ನೆಟ್ಸ್ ಕ್ಲಸ್ಟರ್‌ನಲ್ಲಿ ಬಳಸಬಹುದು. Google ಕಂಟೈನರ್ ರಿಜಿಸ್ಟ್ರಿಯನ್ನು ಬಳಸಲು ನಾನು ಶಿಫಾರಸು ಮಾಡುತ್ತೇವೆ.

Google ಕಂಟೈನರ್ ರಿಜಿಸ್ಟ್ರಿ (GCR) ಜೊತೆಗೆ, ನೀವು ಕಚ್ಚಾ ಸಂಗ್ರಹಣೆ ಮತ್ತು ನೆಟ್‌ವರ್ಕಿಂಗ್‌ಗೆ ಮಾತ್ರ ಪಾವತಿಸುತ್ತೀರಿ ಮತ್ತು ಯಾವುದೇ ಹೆಚ್ಚುವರಿ ಕಂಟೇನರ್ ನಿರ್ವಹಣಾ ಶುಲ್ಕಗಳಿಲ್ಲ. ಇದು ಖಾಸಗಿ, ಸುರಕ್ಷಿತ ಮತ್ತು ಅತ್ಯಂತ ವೇಗವಾಗಿದೆ. ಪುಲ್ ಕಾರ್ಯಾಚರಣೆಯನ್ನು ವೇಗಗೊಳಿಸಲು GCR ಹಲವು ತಂತ್ರಗಳನ್ನು ಬಳಸುತ್ತದೆ. ನೀವು ನೋಡುವಂತೆ, go:onbuild ಅನ್ನು ಬಳಸಿಕೊಂಡು ಡಾಕರ್ ಕಂಟೈನರ್ ಇಮೇಜ್ ಕಂಟೇನರ್ ಅನ್ನು ಸೇರಿಸುವುದು ಕಂಪ್ಯೂಟರ್ ಕಾರ್ಯಕ್ಷಮತೆಯನ್ನು ಅವಲಂಬಿಸಿ 15 ರಿಂದ 48 ಸೆಕೆಂಡುಗಳವರೆಗೆ ತೆಗೆದುಕೊಳ್ಳುತ್ತದೆ ಮತ್ತು ಸಣ್ಣ ಕಂಟೇನರ್‌ನೊಂದಿಗೆ ಅದೇ ಕಾರ್ಯಾಚರಣೆಯು 14 ರಿಂದ 16 ಸೆಕೆಂಡುಗಳವರೆಗೆ ತೆಗೆದುಕೊಳ್ಳುತ್ತದೆ ಮತ್ತು ಕಡಿಮೆ ಉತ್ಪಾದಕ ಯಂತ್ರಗಳಿಗೆ ಕಾರ್ಯಾಚರಣೆಯ ವೇಗದಲ್ಲಿ ಪ್ರಯೋಜನವು 3 ಪಟ್ಟು ಹೆಚ್ಚಾಗುತ್ತದೆ. ದೊಡ್ಡ ಯಂತ್ರಗಳಿಗೆ, ಸಮಯವು ಒಂದೇ ಆಗಿರುತ್ತದೆ, ಏಕೆಂದರೆ GCR ಚಿತ್ರಗಳ ಹಂಚಿದ ಡೇಟಾಬೇಸ್‌ಗಾಗಿ ಜಾಗತಿಕ ಸಂಗ್ರಹವನ್ನು ಬಳಸುತ್ತದೆ, ಅಂದರೆ ನೀವು ಅವುಗಳನ್ನು ಲೋಡ್ ಮಾಡುವ ಅಗತ್ಯವಿಲ್ಲ. ಕಡಿಮೆ-ಶಕ್ತಿಯ ಕಂಪ್ಯೂಟರ್‌ನಲ್ಲಿ, ಸಿಪಿಯು ಅಡಚಣೆಯಾಗಿದೆ, ಆದ್ದರಿಂದ ಸಣ್ಣ ಪಾತ್ರೆಗಳನ್ನು ಬಳಸುವ ಅನುಕೂಲವು ಇಲ್ಲಿ ಹೆಚ್ಚು.

ನೀವು GCR ಅನ್ನು ಬಳಸುತ್ತಿದ್ದರೆ, ನಿಮ್ಮ ನಿರ್ಮಾಣ ವ್ಯವಸ್ಥೆಯ ಭಾಗವಾಗಿ Google ಕಂಟೈನರ್ ಬಿಲ್ಡರ್ (GCB) ಅನ್ನು ಬಳಸಲು ನಾನು ಹೆಚ್ಚು ಶಿಫಾರಸು ಮಾಡುತ್ತೇವೆ.

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

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

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

ಈ ಹೋಲಿಕೆಯನ್ನು ನೋಡೋಣ: ಸಣ್ಣ ಕಂಟೈನರ್‌ಗಳ ಮೇಲೆ ಎಳೆಯುವ ಕಾರ್ಯಾಚರಣೆಯು ಯಂತ್ರದ ಶಕ್ತಿಯನ್ನು ಅವಲಂಬಿಸಿ 4-9 ಪಟ್ಟು ಕಡಿಮೆ ಸಮಯವನ್ನು ತೆಗೆದುಕೊಳ್ಳುತ್ತದೆ, go:onbuild ಅನ್ನು ಬಳಸುವ ಅದೇ ಕಾರ್ಯಾಚರಣೆಗಿಂತ. ಹಂಚಿದ, ಸಣ್ಣ ಕಂಟೇನರ್ ಬೇಸ್ ಚಿತ್ರಗಳನ್ನು ಬಳಸುವುದರಿಂದ ಹೊಸ ಕುಬರ್ನೆಟ್ ನೋಡ್‌ಗಳನ್ನು ನಿಯೋಜಿಸಲು ಮತ್ತು ಆನ್‌ಲೈನ್‌ಗೆ ಬರುವ ಸಮಯ ಮತ್ತು ವೇಗವನ್ನು ಗಮನಾರ್ಹವಾಗಿ ವೇಗಗೊಳಿಸುತ್ತದೆ.

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

ಫಲಿತಾಂಶವು ಅದ್ಭುತವಾಗಿದೆ: ಸಣ್ಣ ಕಂಟೇನರ್‌ನಲ್ಲಿ ಕೇವಲ 3 ಮಧ್ಯಮ ದುರ್ಬಲತೆಗಳು ಪತ್ತೆಯಾಗಿವೆ ಮತ್ತು ದೊಡ್ಡ ಕಂಟೇನರ್‌ನಲ್ಲಿ 16 ನಿರ್ಣಾಯಕ ಮತ್ತು 376 ಇತರ ದುರ್ಬಲತೆಗಳು ಕಂಡುಬಂದಿವೆ. ನಾವು ದೊಡ್ಡ ಕಂಟೇನರ್‌ನ ವಿಷಯಗಳನ್ನು ನೋಡಿದರೆ, ಹೆಚ್ಚಿನ ಭದ್ರತಾ ಸಮಸ್ಯೆಗಳಿಗೆ ನಮ್ಮ ಅಪ್ಲಿಕೇಶನ್‌ಗೆ ಯಾವುದೇ ಸಂಬಂಧವಿಲ್ಲ, ಆದರೆ ನಾವು ಬಳಸದ ಪ್ರೋಗ್ರಾಂಗಳಿಗೆ ಸಂಬಂಧಿಸಿದೆ ಎಂದು ನಾವು ನೋಡಬಹುದು. ಆದ್ದರಿಂದ ಜನರು ದೊಡ್ಡ ದಾಳಿಯ ಮೇಲ್ಮೈ ಬಗ್ಗೆ ಮಾತನಾಡುವಾಗ, ಅದು ಅವರ ಅರ್ಥವಾಗಿದೆ.

ಟೇಕ್‌ಅವೇ ಸ್ಪಷ್ಟವಾಗಿದೆ: ಸಣ್ಣ ಕಂಟೇನರ್‌ಗಳನ್ನು ನಿರ್ಮಿಸಿ ಏಕೆಂದರೆ ಅವು ನಿಮ್ಮ ಸಿಸ್ಟಮ್‌ಗೆ ನೈಜ ಕಾರ್ಯಕ್ಷಮತೆ ಮತ್ತು ಭದ್ರತಾ ಪ್ರಯೋಜನಗಳನ್ನು ಒದಗಿಸುತ್ತವೆ.

ಕುಬರ್ನೆಟ್ಸ್ ಅತ್ಯುತ್ತಮ ಅಭ್ಯಾಸಗಳು. ನೇಮ್‌ಸ್ಪೇಸ್‌ನೊಂದಿಗೆ ಕುಬರ್ನೆಟ್ಸ್ ಸಂಸ್ಥೆ

ಕೆಲವು ಜಾಹೀರಾತುಗಳು 🙂

ನಮ್ಮೊಂದಿಗೆ ಇರುವುದಕ್ಕೆ ಧನ್ಯವಾದಗಳು. ನೀವು ನಮ್ಮ ಲೇಖನಗಳನ್ನು ಇಷ್ಟಪಡುತ್ತೀರಾ? ಹೆಚ್ಚು ಆಸಕ್ತಿದಾಯಕ ವಿಷಯವನ್ನು ನೋಡಲು ಬಯಸುವಿರಾ? ಆರ್ಡರ್ ಮಾಡುವ ಮೂಲಕ ಅಥವಾ ಸ್ನೇಹಿತರಿಗೆ ಶಿಫಾರಸು ಮಾಡುವ ಮೂಲಕ ನಮ್ಮನ್ನು ಬೆಂಬಲಿಸಿ, $4.99 ರಿಂದ ಡೆವಲಪರ್‌ಗಳಿಗಾಗಿ ಕ್ಲೌಡ್ VPS, ಪ್ರವೇಶ ಮಟ್ಟದ ಸರ್ವರ್‌ಗಳ ಅನನ್ಯ ಅನಲಾಗ್, ಇದನ್ನು ನಿಮಗಾಗಿ ನಾವು ಕಂಡುಹಿಡಿದಿದ್ದೇವೆ: $5 ರಿಂದ VPS (KVM) E2697-3 v6 (10 ಕೋರ್‌ಗಳು) 4GB DDR480 1GB SSD 19Gbps ಬಗ್ಗೆ ಸಂಪೂರ್ಣ ಸತ್ಯ ಅಥವಾ ಸರ್ವರ್ ಅನ್ನು ಹೇಗೆ ಹಂಚಿಕೊಳ್ಳುವುದು? (RAID1 ಮತ್ತು RAID10, 24 ಕೋರ್‌ಗಳವರೆಗೆ ಮತ್ತು 40GB DDR4 ವರೆಗೆ ಲಭ್ಯವಿದೆ).

ಆಮ್‌ಸ್ಟರ್‌ಡ್ಯಾಮ್‌ನಲ್ಲಿರುವ Equinix Tier IV ಡೇಟಾ ಸೆಂಟರ್‌ನಲ್ಲಿ Dell R730xd 2x ಅಗ್ಗವಾಗಿದೆಯೇ? ಇಲ್ಲಿ ಮಾತ್ರ $2 ರಿಂದ 2 x Intel TetraDeca-Ceon 5x E2697-3v2.6 14GHz 64C 4GB DDR4 960x1GB SSD 100Gbps 199 TV ನೆದರ್ಲ್ಯಾಂಡ್ಸ್ನಲ್ಲಿ! Dell R420 - 2x E5-2430 2.2Ghz 6C 128GB DDR3 2x960GB SSD 1Gbps 100TB - $99 ರಿಂದ! ಬಗ್ಗೆ ಓದು ಮೂಲಸೌಕರ್ಯ ನಿಗಮವನ್ನು ಹೇಗೆ ನಿರ್ಮಿಸುವುದು ಒಂದು ಪೆನ್ನಿಗೆ 730 ಯುರೋಗಳಷ್ಟು ಮೌಲ್ಯದ Dell R5xd E2650-4 v9000 ಸರ್ವರ್‌ಗಳ ಬಳಕೆಯೊಂದಿಗೆ ವರ್ಗ?

ಮೂಲ: www.habr.com