ಕಂಟೈನರೈಸೇಶನ್: ಕೃತಕ ಬುದ್ಧಿಮತ್ತೆಯೊಂದಿಗೆ ಡಾಕರ್‌ಫೈಲ್ ಮತ್ತು ಇಮೇಜ್ ಆಪ್ಟಿಮೈಸೇಶನ್

ಲಾಭಗಳು:

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

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

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

ಡಾಕರ್‌ಫೈಲ್‌ನ ಮೂಲ ಸೂಚನೆಗಳು

ಡಾಕರ್‌ಫೈಲ್ ಅನ್ನು ಆಡಿಟ್ ಮಾಡಲು, ನೀವು ಮೂಲ ಸೂಚನೆಗಳನ್ನು ತಿಳಿದಿರಬೇಕು:

• `FROM`: ಮೂಲ ಚಿತ್ರವನ್ನು ಆಯ್ಕೆ ಮಾಡುತ್ತದೆ (ಉದಾಹರಣೆಗೆ ಪೈಥಾನ್:3.12-ಸ್ಲಿಮ್). ಇಲ್ಲಿಯೇ ಚಿತ್ರದ ಗಾತ್ರ ಮತ್ತು ಸುರಕ್ಷತೆಯು ಹೆಚ್ಚಾಗಿ ಬರುತ್ತದೆ.
• `WORKDIR`: ಕೆಲಸ ಮಾಡುವ ಡೈರೆಕ್ಟರಿಯನ್ನು ನಿರ್ದಿಷ್ಟಪಡಿಸುತ್ತದೆ.
• `ಕಾಪಿ` / `ಸೇರಿಸು`: ಚಿತ್ರಕ್ಕೆ ಫೈಲ್‌ಗಳನ್ನು ನಕಲಿಸುತ್ತದೆ.
• `RUN`: ನಿರ್ಮಾಣದ ಸಮಯದಲ್ಲಿ ಆಜ್ಞೆಯನ್ನು ರನ್ ಮಾಡುತ್ತದೆ (ಉದಾಹರಣೆಗೆ ಅವಲಂಬನೆಯನ್ನು ಸ್ಥಾಪಿಸುತ್ತದೆ). ಪ್ರತಿಯೊಂದು RUN ಹೊಸ ಪದರವನ್ನು ರಚಿಸುತ್ತದೆ.
• `ENV`: ಪರಿಸರ ವೇರಿಯಬಲ್ ಅನ್ನು ವ್ಯಾಖ್ಯಾನಿಸುತ್ತದೆ.
• `ಎಕ್ಸ್‌ಪೋಸ್`: ಕಂಟೇನರ್ ಯಾವ ಪೋರ್ಟ್‌ನಲ್ಲಿ ಕೇಳುತ್ತಿದೆ ಎಂಬುದನ್ನು ಡಾಕ್ಯುಮೆಂಟ್‌ಗಳು.
• `CMD` / `ENTRYPOINT`: ಕಂಟೇನರ್ ಪ್ರಾರಂಭವಾದಾಗ ರನ್ ಆಗುವ ಆಜ್ಞೆಯನ್ನು ನಿರ್ಧರಿಸುತ್ತದೆ.

ಒಂದು ನಿರ್ಣಾಯಕ ಪರಿಕಲ್ಪನೆಯು ಲೇಯರ್ ಆಗಿದೆ: ಡಾಕರ್ ಪ್ರತಿ ಸೂಚನೆಯನ್ನು ಒಂದು ಪದರವಾಗಿ ಸಂಗ್ರಹಿಸುತ್ತದೆ. ನೀವು ಆಗಾಗ್ಗೆ ಬದಲಾಗುವ ಹಂತಗಳನ್ನು ಕೊನೆಯಲ್ಲಿ ಹಾಕಿದರೆ, ಬದಲಾಗದ ಪದರಗಳು ಸಂಗ್ರಹದಿಂದ ಬರುತ್ತವೆ ಮತ್ತು ನಿರ್ಮಾಣವು ವೇಗಗೊಳ್ಳುತ್ತದೆ.

ಸಲಹೆ: ಚಿತ್ರದ ಗಾತ್ರವನ್ನು ಕಡಿಮೆ ಮಾಡಲು ಎರಡು ದೊಡ್ಡ ಲಿವರ್‌ಗಳು: (1) ಸ್ಲಿಮ್ ಅಥವಾ ಆಲ್ಪೈನ್‌ನಂತಹ ಸಣ್ಣ ಮೂಲ ಚಿತ್ರವನ್ನು ಆರಿಸುವುದು; (2) ಬಹು-ಹಂತದ ನಿರ್ಮಾಣವನ್ನು ಬಳಸುವುದು - ಒಂದು ಹಂತದಲ್ಲಿ ನಿರ್ಮಾಣ ಸಾಧನಗಳನ್ನು ತ್ಯಜಿಸುವುದು ಮತ್ತು ಅಂತಿಮ ಉತ್ಪನ್ನವನ್ನು ತೆಳುವಾದ ಚಿತ್ರಕ್ಕೆ ಮಾತ್ರ ಪೋರ್ಟ್ ಮಾಡುವುದು. AI ತನಗೆ ಬೇಕಾದಾಗ ಈ ಎರಡನ್ನು ಪರಿಣಿತವಾಗಿ ಕಾರ್ಯಗತಗೊಳಿಸಬಹುದು.

ಚಿಕ್ಕ ಚಿತ್ರ ಏಕೆ ಮುಖ್ಯ? ಏಕೆಂದರೆ ಚಿತ್ರದ ಗಾತ್ರವು ಕೇವಲ ಡಿಸ್ಕ್ ಸಮಸ್ಯೆಯಲ್ಲ. ಒಂದು ದೊಡ್ಡ ಚಿತ್ರವು ಪ್ರತಿ ನಿಯೋಜನೆಯೊಂದಿಗೆ ಎಳೆಯಲು ಹೆಚ್ಚು ಸಮಯ ತೆಗೆದುಕೊಳ್ಳುತ್ತದೆ, ನೋಂದಾವಣೆಯಲ್ಲಿ ಹೆಚ್ಚಿನ ಸ್ಥಳವನ್ನು ತೆಗೆದುಕೊಳ್ಳುತ್ತದೆ, ಹೊಸ ಪಾಡ್‌ಗಳ ಪ್ರಾರಂಭವನ್ನು ಅದು ಮಾಪಕವಾಗುವಂತೆ ನಿಧಾನಗೊಳಿಸುತ್ತದೆ ಮತ್ತು ಇದು ಹೆಚ್ಚಿನ ಪ್ಯಾಕೇಜುಗಳನ್ನು ಒಳಗೊಂಡಿರುವ ಕಾರಣ, ಇದು ದೊಡ್ಡ ಆಕ್ರಮಣಕಾರಿ ಮೇಲ್ಮೈಯನ್ನು ಒದಗಿಸುತ್ತದೆ-ಅಂದರೆ, ಆಕ್ರಮಣಕಾರರಿಗೆ ಬಳಸಿಕೊಳ್ಳಲು ಮುಕ್ತ ಸ್ಥಳವನ್ನು ಒದಗಿಸುತ್ತದೆ. 1 GB ಚಿತ್ರದ ಬದಲಿಗೆ 100 MB ಚಿತ್ರವನ್ನು ಬಳಸುವುದು; ಇದು ನಿಯೋಜನೆಯ ಸಮಯವನ್ನು ಕಡಿಮೆ ಮಾಡುತ್ತದೆ, ವೆಚ್ಚವನ್ನು ಕಡಿಮೆ ಮಾಡುತ್ತದೆ ಮತ್ತು ಭದ್ರತೆಯನ್ನು ಹೆಚ್ಚಿಸುತ್ತದೆ. ಡಾಕರ್‌ಫೈಲ್ ಅನ್ನು ಆಪ್ಟಿಮೈಜ್ ಮಾಡುವುದು ಈ ಮೂರು ಪ್ರಯೋಜನಗಳನ್ನು ಏಕಕಾಲದಲ್ಲಿ ಪಡೆಯುತ್ತಿದೆ. ಆಪ್ಟಿಮೈಸ್ ಮಾಡಿದ ಡಾಕರ್‌ಫೈಲ್‌ಗಾಗಿ AI ಅನ್ನು ಕೇಳುವಾಗ "ಚಿಕ್ಕ ಅಂತಿಮ ಚಿತ್ರ" ಗುರಿಯನ್ನು ಸ್ಪಷ್ಟವಾಗಿ ತಿಳಿಸಿ; ಹೀಗಾಗಿ, ಇದು ಸಂಕಲನ ಹಂತವನ್ನು ಪ್ರತ್ಯೇಕಿಸಲು ಮತ್ತು ಅನಗತ್ಯ ಪ್ಯಾಕೇಜ್‌ಗಳನ್ನು ತ್ಯಜಿಸಲು ಆದ್ಯತೆ ನೀಡುತ್ತದೆ.

ಹಂತ ಹಂತವಾಗಿ: AI ನೊಂದಿಗೆ ಡಾಕರ್‌ಫೈಲ್ ಅನ್ನು ರಚಿಸುವುದು ಮತ್ತು ಉತ್ತಮಗೊಳಿಸುವುದು

1. ಅಪ್ಲಿಕೇಶನ್ ಅನ್ನು ವಿವರಿಸಿ. ಭಾಷೆ, ಆವೃತ್ತಿ, ಇನ್‌ಪುಟ್ ಆಜ್ಞೆ, ಆಲಿಸಿದ ಪೋರ್ಟ್.
2. ಮೊದಲ ಕರಡನ್ನು ತಯಾರಿಸಿ. ಸರಳವಾಗಿ ಕಾರ್ಯನಿರ್ವಹಿಸುವ ಡಾಕರ್‌ಫೈಲ್ ಅನ್ನು ವಿನಂತಿಸಿ.
3. ಅದನ್ನು ಆಪ್ಟಿಮೈಜ್ ಮಾಡಿ. ಬಹು-ಹಂತದ ನಿರ್ಮಾಣ, ಮೈನರ್ ಬೇಸ್ ಇಮೇಜ್ ಮತ್ತು ಲೇಯರ್ ಆರ್ಡರ್ ಆಪ್ಟಿಮೈಸೇಶನ್‌ಗಾಗಿ ಅದೇ AI ಅನ್ನು ಕೇಳಿ.
4. ಭದ್ರತೆಯನ್ನು ಪರಿಶೀಲಿಸಿ. ರಹಸ್ಯವು ಹುದುಗಿದೆಯೇ, ಅದು ಮೂಲವಾಗಿ ಚಲಿಸುತ್ತದೆಯೇ, ಯಾವುದೇ ಅನಗತ್ಯ ಸಾಧನಗಳಿವೆಯೇ?
5. ಗಾತ್ರವನ್ನು ನಿರ್ಮಿಸಿ ಮತ್ತು ಅಳತೆ ಮಾಡಿ. ಡಾಕರ್ ನಿರ್ಮಾಣದ ನಂತರ ಡಾಕರ್ ಚಿತ್ರಗಳೊಂದಿಗೆ ಗಾತ್ರವನ್ನು ನೋಡಿ.
6. ಸ್ಕ್ಯಾನ್ ಮಾಡಿ. ಡಾಕರ್ ಸ್ಕೌಟ್ ಅಥವಾ ಟ್ರಿವಿಯಂತಹ ಶೋಷಣೆ ಸ್ಕ್ಯಾನರ್‌ನೊಂದಿಗೆ ತಿಳಿದಿರುವ ದುರ್ಬಲತೆಗಳನ್ನು ಪರಿಶೀಲಿಸಿ.

ಭದ್ರತೆ: ಕಂಟೇನರ್-ನಿರ್ದಿಷ್ಟ ಅಪಾಯಗಳು

ಕಂಟೇನರ್ ಭದ್ರತೆಯನ್ನು ಸುಲಭವಾಗಿ ಕಡೆಗಣಿಸಲಾಗುತ್ತದೆ. ಮೂರು ನಿಯಮಗಳು:

1. ಚಿತ್ರದಲ್ಲಿ ರಹಸ್ಯವನ್ನು ಎಂಬೆಡ್ ಮಾಡಬೇಡಿ. ENV API_KEY=... ಅಥವಾ COPY .env ನಂತಹ ಸಾಲುಗಳು ಚಿತ್ರದ ಲೇಯರ್‌ಗಳಿಗೆ ರಹಸ್ಯವನ್ನು ಶಾಶ್ವತವಾಗಿ ಬರೆಯುತ್ತವೆ; ಚಿತ್ರವನ್ನು ಸ್ವೀಕರಿಸುವ ಯಾರಾದರೂ ಅದನ್ನು ಓದಬಹುದು. ರನ್ಟೈಮ್ನಲ್ಲಿ ಪರಿಸರ ವೇರಿಯಬಲ್ ಅಥವಾ ವಾಲ್ಟ್ನಿಂದ ರಹಸ್ಯವನ್ನು ನೀಡಿ.
2. ರೂಟ್ ಆಗಿ ರನ್ ಆಗುತ್ತಿದೆ. ಪೂರ್ವನಿಯೋಜಿತವಾಗಿ, ಕಂಟೈನರ್‌ಗಳು ರೂಟ್ ಆಗಿ ಚಲಿಸುತ್ತವೆ; ಒಂದು ತೆರೆಯುವಿಕೆಯು ಕಂಟೇನರ್ನಿಂದ ತಪ್ಪಿಸಿಕೊಳ್ಳಲು ಬದಲಾಗಬಹುದು. USER ಸೂಚನೆಯೊಂದಿಗೆ ಅನಧಿಕೃತ ಬಳಕೆದಾರರಿಗೆ ಡ್ರಾಪ್ ಮಾಡಿ.
3. ಚಿಕ್ಕ ಮತ್ತು ನವೀಕೃತ ಮೂಲ ಚಿತ್ರ. ಉಬ್ಬಿದ ಚಿತ್ರಗಳು ನಿಧಾನವಾಗಿರುತ್ತವೆ ಮತ್ತು ಹೆಚ್ಚು ದುರ್ಬಲತೆಗಳನ್ನು ಹೊಂದಿರುತ್ತವೆ. ಸ್ಲಿಮ್/ಆಲ್ಪೈನ್ ಆಯ್ಕೆಮಾಡಿ, ಆವೃತ್ತಿಯನ್ನು ಸರಿಪಡಿಸಿ (ಬಳಸಬೇಡಿ: ಇತ್ತೀಚಿನದು).

ಎಚ್ಚರಿಕೆ: ನೀವು RUN ನಲ್ಲಿ ರಹಸ್ಯವನ್ನು ಬಳಸಿ ನಂತರ ಅದನ್ನು ಅಳಿಸಿದರೂ ಸಹ, ಅದು ಮಿಡಲ್‌ವೇರ್‌ನಲ್ಲಿ ಉಳಿಯುತ್ತದೆ ಮತ್ತು ಡಾಕರ್ ಇತಿಹಾಸದ ಮೂಲಕ ಮತ್ತೆ ಓದಬಹುದು. ನಿರ್ಮಾಣದ ಸಮಯದಲ್ಲಿ ರಹಸ್ಯ ಅಗತ್ಯವಿದ್ದರೆ, ಡಾಕರ್ಸ್ --ಸೀಕ್ರೆಟ್ ಮೆಕ್ಯಾನಿಸಂ ಅನ್ನು ಬಳಸಿ, ENV/COPY ಅಲ್ಲ.

ಆಪ್ಟಿಮೈಸೇಶನ್ ಪರಿಣಾಮ ಟೇಬಲ್

ತಾಂತ್ರಿಕ

ಏನು ಮಾಡುತ್ತದೆ

ವಿಶಿಷ್ಟ ಪರಿಣಾಮ

ಸ್ಲಿಮ್/ಆಲ್ಪೈನ್ ಬೇಸ್ ಚಿತ್ರ

ಅನಗತ್ಯ ಪ್ಯಾಕೇಜ್‌ಗಳನ್ನು ತ್ಯಜಿಸುತ್ತದೆ

900MB → 120MB

ಬಹು-ಹಂತದ ನಿರ್ಮಾಣ

ನಿರ್ಮಾಣ ಪರಿಕರಗಳನ್ನು ಹೊರತುಪಡಿಸಿ

700MB → 90MB

.ಡಾಕೆರಿಗ್ನೋರ್

ನಿರ್ಮಾಣದಲ್ಲಿ ಅನಗತ್ಯ ಫೈಲ್‌ಗಳನ್ನು ಒಳಗೊಂಡಿಲ್ಲ

ವೇಗದ ನಿರ್ಮಾಣ, ಸಣ್ಣ ಸಂದರ್ಭ

ಶ್ರೇಣಿ ವಿಂಗಡಣೆ

ಸಂಗ್ರಹ ಹಿಟ್ ಅನ್ನು ಹೆಚ್ಚಿಸುತ್ತದೆ

5 ನಿಮಿಷ → 40 ಸೆಕೆಂಡು ನಿರ್ಮಿಸಿ

ಆವೃತ್ತಿ ಫಿಕ್ಸಿಂಗ್ (:15)

ಪುನರಾವರ್ತನೆ + ಭದ್ರತೆ

ಹಠಾತ್ ಕ್ಷೀಣಿಸುವಿಕೆಯನ್ನು ತಡೆಯುತ್ತದೆ

ಮೂರು ಸಣ್ಣ ಪ್ರಕರಣಗಳು

ಪ್ರಕರಣ 1 — 1.1 GB ಚಿತ್ರವನ್ನು 95 MB ಗೆ ಕಡಿಮೆ ಮಾಡಲಾಗಿದೆ. ಒಂದು ತಂಡದ Node.js ಚಿತ್ರವು 1.1 GB ಆಗಿತ್ತು; ಪ್ರತಿ ನಿಯೋಜನೆಯು ನಿಮಿಷಗಳನ್ನು ತೆಗೆದುಕೊಂಡಿತು. ಅವರು AI ಗೆ "ಬಹು-ಹಂತದ ನಿರ್ಮಾಣ ಮತ್ತು ಆಲ್ಪೈನ್‌ನೊಂದಿಗೆ ಇದನ್ನು ಆಪ್ಟಿಮೈಜ್ ಮಾಡಿ" ಎಂದು ಹೇಳಿದರು. AI ಸಂಕಲನ ಹಂತವನ್ನು ಪ್ರತ್ಯೇಕಿಸಿತು ಮತ್ತು ರಚಿಸಿದ ಫೈಲ್‌ಗಳನ್ನು ಮಾತ್ರ ತೆಳುವಾದ ಚಿತ್ರಕ್ಕೆ ಸರಿಸಿತು; ಫಲಿತಾಂಶವು 95 MB ಆಗಿತ್ತು, ನಿಯೋಜನೆ ಸಮಯವು ಮೂರನೇ ಒಂದು ಭಾಗದಷ್ಟು ಕಡಿಮೆಯಾಗಿದೆ.

ಪ್ರಕರಣ 2 - ಸಮಾಧಿ ರಹಸ್ಯ ಸಿಕ್ಕಿಬಿದ್ದಿದೆ. YZ ನಿರ್ಮಿಸಿದ ಡಾಕರ್‌ಫೈಲ್‌ನಲ್ಲಿ ENV DB_PASSWORD=prod_secret ಎಂಬ ಸಾಲನ್ನು ಎಂಜಿನಿಯರ್ ಗಮನಿಸಿದ್ದಾರೆ. AI ಚಿತ್ರಕ್ಕೆ ಗುಪ್ತಪದವನ್ನು ಎಂಬೆಡ್ ಮಾಡಿದ್ದರಿಂದ ಅದು "ಕೆಲಸ ಮಾಡುತ್ತದೆ". ಇಂಜಿನಿಯರ್ ಇದನ್ನು ತೆಗೆದುಹಾಕಿದರು ಮತ್ತು ರನ್ಟೈಮ್ನಲ್ಲಿ ಎನ್ವಿರಾನ್ಮೆಂಟ್ ವೇರಿಯೇಬಲ್ನಿಂದ ಪಾಸ್ವರ್ಡ್ ಅನ್ನು ಓದುವಂತೆ ಬದಲಾಯಿಸಿದರು. ಇಲ್ಲದಿದ್ದರೆ, ಚಿತ್ರವನ್ನು ಸೆರೆಹಿಡಿದ ಯಾರಾದರೂ ಪಾಸ್ವರ್ಡ್ ಅನ್ನು ಓದಬಹುದು.

ಪ್ರಕರಣ 3 - ರೂಟ್ ತಪ್ಪಿಸಿಕೊಳ್ಳುವ ಅಪಾಯ. AI ನಿರ್ಮಿಸಿದ ಚಿತ್ರವು ರೂಟ್ ಆಗಿ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತಿದೆ ಮತ್ತು ನಿರ್ಣಾಯಕ ದುರ್ಬಲತೆಯನ್ನು ಹೊಂದಿದೆ ಎಂದು ಸ್ಕ್ಯಾನಿಂಗ್ ಉಪಕರಣವು ವರದಿ ಮಾಡಿದೆ. ತಂಡವು USER appuser ಅನ್ನು ಸೇರಿಸಿದೆ ಮತ್ತು ಮೂಲ ಚಿತ್ರವನ್ನು ಪ್ರಸ್ತುತ ಆವೃತ್ತಿಗೆ ತಳ್ಳಿದೆ; ಸ್ಕ್ಯಾನ್ ತೆರವುಗೊಳಿಸಲಾಗಿದೆ. ಪಾಠ: ಪ್ರಕಟಿಸುವ ಮೊದಲು ಪ್ರತಿ ಚಿತ್ರವನ್ನು ಸ್ಕ್ಯಾನ್ ಮಾಡಿ ಮತ್ತು ಅನಧಿಕೃತ ಬಳಕೆದಾರರಿಗೆ ಅದನ್ನು ಬಹಿರಂಗಪಡಿಸಿ.

ನಾಲ್ಕು ನಕಲಿಸಬಹುದಾದ ಟೆಂಪ್ಲೇಟ್‌ಗಳು

1) ಆಪ್ಟಿಮೈಸ್ಡ್ ಡಾಕರ್‌ಫೈಲ್ ಅನ್ನು ರಚಿಸುವುದು:

[ಭಾಷೆ/ಫ್ರೇಮ್‌ವರ್ಕ್] ಅಪ್ಲಿಕೇಶನ್‌ಗಾಗಿ ಉತ್ಪಾದನೆಗೆ ಸಿದ್ಧವಾಗಿರುವ ಡಾಕರ್‌ಫೈಲ್ ಅನ್ನು ಬರೆಯಿರಿ. ಮಾರ್ಗಸೂಚಿಗಳು:- ಬಹು-ಹಂತದ ನಿರ್ಮಾಣವನ್ನು ಬಳಸಿ; ಅಂತಿಮ ಚಿತ್ರವನ್ನು ಸಾಧ್ಯವಾದಷ್ಟು ಚಿಕ್ಕದಾಗಿಸಿ.- ಮೂಲ ಚಿತ್ರವು ಸ್ಲಿಮ್/ಆಲ್ಪೈನ್ ಆಗಿದೆ ಮತ್ತು ಆವೃತ್ತಿಯು ಸ್ಥಿರವಾಗಿದೆ (": ಇತ್ತೀಚಿನ" ಅನ್ನು ಬಳಸಬೇಡಿ).- ಅನಧಿಕೃತ ಬಳಕೆದಾರರೊಂದಿಗೆ ಕಂಟೇನರ್ ಅನ್ನು ರನ್ ಮಾಡಿ, ರೂಟ್ ಅಲ್ಲ.- ಚಿತ್ರದಲ್ಲಿ ರಹಸ್ಯವನ್ನು ಎಂಬೆಡ್ ಮಾಡಬೇಡಿ; ರನ್ಟೈಮ್ನಲ್ಲಿ ಪರಿಸರ ವೇರಿಯಬಲ್ಗಾಗಿ ನಿರೀಕ್ಷಿಸಿ. - .dockerignore ಸಲಹೆಯನ್ನು ಸೇರಿಸಿ. ಇನ್‌ಪುಟ್ ಆಜ್ಞೆ: [X], ಆಲಿಸುವ ಪೋರ್ಟ್: [Y].

2) ಅಸ್ತಿತ್ವದಲ್ಲಿರುವ ಡಾಕರ್‌ಫೈಲ್ ಅನ್ನು ಆಪ್ಟಿಮೈಜ್ ಮಾಡಿ:

ಕಡಿಮೆಗೊಳಿಸಲು ಮತ್ತು ವೇಗಗೊಳಿಸಲು ಈ ಡಾಕರ್‌ಫೈಲ್ ಅನ್ನು ಪರಿಶೀಲಿಸಿ. ಲೇಯರ್ ಆರ್ಡರ್, ಮಲ್ಟಿ-ಫೇಸ್ ಬಿಲ್ಡ್, ಬೇಸ್ ಇಮೇಜ್ ಮತ್ತು ರಿಡಂಡೆಂಟ್ ಪ್ಯಾಕೇಜುಗಳ ವಿಷಯದಲ್ಲಿ ಕಾಂಕ್ರೀಟ್ ಬದಲಾವಣೆಗಳನ್ನು ಶಿಫಾರಸು ಮಾಡಿ; ಪ್ರತಿ ಬದಲಾವಣೆಯ ಅಂದಾಜು ಗಾತ್ರ/ವೇಗದ ಪ್ರಭಾವವನ್ನು ಬರೆಯಿರಿ. ಡಾಕರ್‌ಫೈಲ್: [CONTENT]

3) ಭದ್ರತಾ ಲೆಕ್ಕಪರಿಶೋಧನೆ:

ಭದ್ರತೆಗಾಗಿ ಈ ಡಾಕರ್‌ಫೈಲ್ ಅನ್ನು ಪರಿಶೀಲಿಸಿ: ಯಾವುದೇ ಎಂಬೆಡೆಡ್ ರಹಸ್ಯಗಳು, ರೂಟ್ ಬಳಕೆದಾರರು, ಸ್ಥಿರವಲ್ಲದ ಆವೃತ್ತಿಗಳು, ಅನಗತ್ಯ ಪರಿಕರಗಳು, ಹಳೆಯ ಬೇಸ್ ಚಿತ್ರಗಳು ಇವೆಯೇ? ಪ್ರಾಮುಖ್ಯತೆ ಮತ್ತು ಯಾವುದೇ ತಿದ್ದುಪಡಿಗಳ ಕ್ರಮದಲ್ಲಿ ಸಂಶೋಧನೆಗಳನ್ನು ಪಟ್ಟಿ ಮಾಡಿ. ಡಾಕರ್‌ಫೈಲ್: [CONTENT]

4) ದೋಷ ಪರಿಹಾರವನ್ನು ನಿರ್ಮಿಸಿ:

ಈ ಡಾಕರ್ ಬಿಲ್ಡ್ ದೋಷಕ್ಕೆ ಕಾರಣವೇನು ಮತ್ತು ಅದನ್ನು ಹೇಗೆ ಪರಿಹರಿಸುವುದು? ನನಗೆ ಮೂಲ ಕಾರಣ ಮತ್ತು ಪರಿಹಾರವನ್ನು ಕನಿಷ್ಠ ಬದಲಾವಣೆಗಳೊಂದಿಗೆ ನೀಡಿ. ನೀವು ಸೀಕ್ರೆಟ್ ಅನ್ನು ನೋಡುವ ಸ್ಥಳದಲ್ಲಿ ನೈಜ ಮೌಲ್ಯವನ್ನು ಉತ್ಪಾದಿಸಬೇಡಿ, ಪ್ಲೇಸ್‌ಹೋಲ್ಡರ್ ಬಳಸಿ. ದೋಷ: [LOG] ಡಾಕರ್‌ಫೈಲ್: [ವಿಷಯ]

ದುರ್ಬಲ ಪ್ರಾಂಪ್ಟ್ / ಬಲವಾದ ಪ್ರಾಂಪ್ಟ್

ದುರ್ಬಲ: "ನನ್ನ ನೋಡ್ ಅಪ್ಲಿಕೇಶನ್‌ಗಾಗಿ ಡಾಕರ್‌ಫೈಲ್ ಬರೆಯಿರಿ."

ಫಲಿತಾಂಶ: ಬೃಹತ್ ಬೇಸ್ ಇಮೇಜ್, ರೂಟ್ ಯೂಸರ್, ಸಿಂಗಲ್ ಸ್ಟೇಜ್, ಪ್ರಾಯಶಃ ರಹಸ್ಯಕ್ಕೆ ಗುರಿಯಾಗಬಹುದು; ಗಾತ್ರ ಮತ್ತು ಭದ್ರತೆಯನ್ನು ಪರಿಗಣಿಸದೆ ಔಟ್‌ಪುಟ್.

ಪ್ರಬಲ: "ನನ್ನ ನೋಡ್ 20 ಅಪ್ಲಿಕೇಶನ್‌ಗಾಗಿ ಪ್ರೊಡಕ್ಷನ್-ಸಿದ್ಧ ಡಾಕರ್‌ಫೈಲ್ ಬರೆಯಿರಿ: ಬಹು-ಹಂತದ ನಿರ್ಮಾಣ, ನೋಡ್: 20-ಆಲ್ಪೈನ್ ಮೂಲ ಚಿತ್ರ (ಆವೃತ್ತಿ ಸ್ಥಿರ), ಅನಧಿಕೃತ USER, ರಹಸ್ಯ ಎಂಬೆಡಿಂಗ್, ಪೋರ್ಟ್ 3000 ನಲ್ಲಿ ಆಲಿಸುವುದು, ಲಾಗಿನ್ ನೋಡ್ dist/server.js. ಸಹ ಸೂಚಿಸಿ .dockerignore."

ವ್ಯತ್ಯಾಸ: ಎರಡನೇ ಪ್ರಾಂಪ್ಟ್ ಆವೃತ್ತಿಯು ಆಪ್ಟಿಮೈಸೇಶನ್ ತಂತ್ರ, ಭದ್ರತಾ ನಿಯಮ ಮತ್ತು ಲಾಗಿನ್ ಆಜ್ಞೆಯನ್ನು ನೀಡುತ್ತದೆ; ಔಟ್ಪುಟ್ ಚಿಕ್ಕದಾಗಿದೆ, ಸುರಕ್ಷಿತ ಮತ್ತು ನೇರವಾಗಿ ಬಳಸಬಹುದಾಗಿದೆ.

ಸಾಮಾನ್ಯ ತಪ್ಪುಗಳು

• `ENV`/`COPY` ನೊಂದಿಗೆ ಚಿತ್ರದಲ್ಲಿ ರಹಸ್ಯವನ್ನು ಎಂಬೆಡ್ ಮಾಡಲಾಗುತ್ತಿದೆ. ಇದು ಪದರಗಳಲ್ಲಿ ಉಳಿದಿದೆ ಮತ್ತು ಮತ್ತೆ ಓದಲಾಗುತ್ತದೆ.
• ರೂಟ್ ಆಗಿ ರನ್ ಆಗುತ್ತಿದೆ. USER ಸೂಚನೆಯನ್ನು ಬಿಟ್ಟುಬಿಡುವುದು ಗಂಭೀರವಾದ ಭದ್ರತಾ ಅಪಾಯವಾಗಿದೆ.
• `: ಇತ್ತೀಚಿನ` ಅನ್ನು ಬಳಸಲಾಗುತ್ತಿದೆ. ಇದು ಪುನರಾವರ್ತಿಸಲಾಗದ ನಿರ್ಮಾಣಗಳು ಮತ್ತು ಅನಿರೀಕ್ಷಿತ ಅಡಚಣೆಗಳನ್ನು ಸೃಷ್ಟಿಸುತ್ತದೆ.
• ಬಹು-ಹಂತದ ನಿರ್ಮಾಣವನ್ನು ಬಿಡಲಾಗುತ್ತಿದೆ. ಸಂಕಲನ ಉಪಕರಣಗಳು ಅನಗತ್ಯವಾಗಿ ಅಂತಿಮ ಚಿತ್ರವನ್ನು ಉಬ್ಬುತ್ತವೆ.
• `.dockerignore` ಎಂದು ಬರೆಯಬೇಡಿ. .git ಮತ್ತು node_modules ನಂತಹ ಬೃಹತ್ ಡೈರೆಕ್ಟರಿಗಳನ್ನು ಬಿಲ್ಡ್‌ನಲ್ಲಿ ಸೇರಿಸಲಾಗಿದೆ.
• ಚಿತ್ರವನ್ನು ಸ್ಕ್ಯಾನ್ ಮಾಡದೆಯೇ ಪ್ರಕಟಿಸಲಾಗುತ್ತಿದೆ. ತಿಳಿದಿರುವ ದುರ್ಬಲತೆಗಳನ್ನು ಅರಿತುಕೊಳ್ಳದೆ ಉತ್ಪಾದಿಸುವುದು.

ಸಾರಾಂಶದಲ್ಲಿ

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

ಅಪ್ಲಿಕೇಶನ್ ಕಾರ್ಯ

ಸರಳ ಅಪ್ಲಿಕೇಶನ್ ಆಯ್ಕೆಮಾಡಿ. "ಆಪ್ಟಿಮೈಸ್ಡ್ ಡಾಕರ್‌ಫೈಲ್ ಜನರೇಷನ್" ಟೆಂಪ್ಲೇಟ್‌ನೊಂದಿಗೆ AI ಡಾಕರ್‌ಫೈಲ್ ಅನ್ನು ರಚಿಸುವಂತೆ ಮಾಡಿ. ನಂತರ: (1) ಎಂಬೆಡೆಡ್ ರಹಸ್ಯ ಮತ್ತು ಮೂಲ ಬಳಕೆದಾರರನ್ನು "ಭದ್ರತಾ ಪರಿಶೀಲನೆ" ಟೆಂಪ್ಲೇಟ್‌ನೊಂದಿಗೆ ಪರೀಕ್ಷಿಸಿ; (2) ಸಾಧ್ಯವಾದರೆ, ಡಾಕರ್ ಅನ್ನು ನಿರ್ಮಿಸಿ ಮತ್ತು ಡಾಕರ್ ಚಿತ್ರಗಳೊಂದಿಗೆ ಗಾತ್ರವನ್ನು ಅಳೆಯಿರಿ; (3) ಮುಂದಿನ ಹಂತವಾಗಿ ಚಿತ್ರವನ್ನು ಕಡಿಮೆ ಮಾಡಲು ಯಾವ ತಂತ್ರವು ಹೆಚ್ಚು ಪರಿಣಾಮಕಾರಿಯಾಗಿರುತ್ತದೆ ಎಂಬುದನ್ನು ಗಮನಿಸಿ.

ಪರಿಶೀಲನಾಪಟ್ಟಿ

• [ ] ನಾನು ಭಾಷೆ/ಫ್ರೇಮ್‌ವರ್ಕ್ ಆವೃತ್ತಿ, ಇನ್‌ಪುಟ್ ಕಮಾಂಡ್ ಮತ್ತು ಪೋರ್ಟ್ ಅನ್ನು ನನ್ನ ಪ್ರಾಂಪ್ಟ್‌ಗೆ ಸೇರಿಸಿದ್ದೇನೆ.
• [ ] ಡಾಕರ್‌ಫೈಲ್‌ನಲ್ಲಿ ಯಾವುದೇ ಎಂಬೆಡೆಡ್ ರಹಸ್ಯಗಳಿಲ್ಲ; ರಹಸ್ಯ ರನ್ಟೈಮ್ನಲ್ಲಿ ನಿರೀಕ್ಷಿಸಲಾಗಿದೆ.
• [ ] ಕಂಟೇನರ್ ಅನಧಿಕೃತ USER ಜೊತೆಗೆ ರನ್ ಆಗುತ್ತಿದೆ, ರೂಟ್ ಅಲ್ಲ.
• [ ] ಮೂಲ ಚಿತ್ರವು ಚಿಕ್ಕದಾಗಿದೆ (ಸ್ಲಿಮ್/ಆಲ್ಪೈನ್) ಮತ್ತು ಅದರ ಆವೃತ್ತಿಯು ಸ್ಥಿರವಾಗಿದೆ (ಇಲ್ಲ: ಇತ್ತೀಚಿನದು).
• [ ] ನಾನು ಬಹು-ಹಂತದ ನಿರ್ಮಾಣ ಮತ್ತು .dockerignore ಅನ್ನು ಬಳಸಿದ್ದೇನೆ.
• [ ] ನಾನು ಚಿತ್ರವನ್ನು ದುರ್ಬಲತೆ ಸ್ಕ್ಯಾನರ್ ಮೂಲಕ ಸ್ಕ್ಯಾನ್ ಮಾಡಿದ್ದೇನೆ.