ಡಾಕರ್‌ನಲ್ಲಿ Node.js ನಲ್ಲಿ "ಮಿಸ್ಸಿಂಗ್ ಸ್ಟಾರ್ಟ್ ಸ್ಕ್ರಿಪ್ಟ್" ದೋಷವನ್ನು ಪರಿಹರಿಸಲಾಗುತ್ತಿದೆ

ಡಾಕರ್‌ನಲ್ಲಿ Node.js ಬ್ಯಾಕೆಂಡ್ ಅನ್ನು ಪ್ರಾರಂಭಿಸಲಾಗುತ್ತಿದೆ: ಎ ಟ್ರಬಲ್‌ಶೂಟಿಂಗ್ ಗೈಡ್

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

ಅನೇಕ ಸಂದರ್ಭಗಳಲ್ಲಿ, ನಿಮ್ಮ ಪ್ಯಾಕೇಜ್.json ಮತ್ತು ಡಾಕರ್ ಸೆಟ್ಟಿಂಗ್‌ಗಳ ನಡುವೆ ತಪ್ಪಾದ ಮಾರ್ಗಗಳು ಅಥವಾ ತಪ್ಪಾಗಿ ಜೋಡಿಸಲಾದ ಕಾನ್ಫಿಗರೇಶನ್‌ಗಳಿಗೆ ಸಮಸ್ಯೆಯು ಕುದಿಯುತ್ತದೆ. ವ್ಯವಹರಿಸುವಾಗ ಸಣ್ಣ ವಿವರವನ್ನು ಕಡೆಗಣಿಸುವುದು ಸುಲಭ , ಕಂಟೈನರೈಸೇಶನ್ ಮತ್ತು ಕಾನ್ಫಿಗರೇಶನ್ ಫೈಲ್‌ಗಳು. ಈ ಸಮಸ್ಯೆಯನ್ನು ನಾನೇ ಎದುರಿಸಿದ ನಂತರ, ಅದನ್ನು ಸರಿಪಡಿಸುವುದು ಪ್ರತಿ ಫೈಲ್‌ನ ನಿಯೋಜನೆ ಮತ್ತು ಸ್ಕ್ರಿಪ್ಟ್‌ಗಳನ್ನು ಪರಿಶೀಲಿಸುವುದನ್ನು ಒಳಗೊಂಡಿರುತ್ತದೆ ಎಂದು ನಾನು ಹೇಳಬಲ್ಲೆ.

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

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

ಆಜ್ಞೆ	ವಿವರಣೆ
CMD ["node", "dist/server.js"]	ಪ್ರಾರಂಭದಲ್ಲಿ ಡಾಕರ್ ಕಂಟೇನರ್‌ನಲ್ಲಿ ಚಲಿಸುವ ಪ್ರಾಥಮಿಕ ಆಜ್ಞೆಯನ್ನು ವಿವರಿಸುತ್ತದೆ. ಇಲ್ಲಿ, ಇದು ಡಿಸ್ಟ್ ಫೋಲ್ಡರ್‌ನೊಳಗೆ server.js ಅನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸುವ ಮೂಲಕ ಅಪ್ಲಿಕೇಶನ್ ಅನ್ನು ಪ್ರಾರಂಭಿಸಲು ಡಾಕರ್ ಅನ್ನು ನಿರ್ದೇಶಿಸುತ್ತದೆ. ಯಾವ ಸ್ಕ್ರಿಪ್ಟ್ ಅನ್ನು ಚಲಾಯಿಸಬೇಕೆಂದು ಡಾಕರ್‌ಗೆ ತಿಳಿದಿದೆ ಎಂದು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳುವ ಮೂಲಕ ಸಮಸ್ಯೆ.
WORKDIR /app	ಧಾರಕದಲ್ಲಿ ಕಾರ್ಯನಿರ್ವಹಿಸುವ ಡೈರೆಕ್ಟರಿಯನ್ನು / ಅಪ್ಲಿಕೇಶನ್‌ಗೆ ಹೊಂದಿಸುತ್ತದೆ. ಈ ಡೈರೆಕ್ಟರಿಯನ್ನು ಉಲ್ಲೇಖಿಸಿ, ಡಾಕರ್‌ನಲ್ಲಿನ ಬಿಲ್ಡ್ ಮತ್ತು ರನ್‌ಟೈಮ್ ಪ್ರಕ್ರಿಯೆಗಳನ್ನು ಸುವ್ಯವಸ್ಥಿತಗೊಳಿಸುವ ನಂತರದ ಆಜ್ಞೆಗಳಲ್ಲಿನ ಎಲ್ಲಾ ಫೈಲ್ ಪಾತ್‌ಗಳನ್ನು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಲು ಇದು ನಿರ್ಣಾಯಕವಾಗಿದೆ.
COPY --from=builder /app/dist ./dist	ಬಿಲ್ಡರ್ ಹಂತದಲ್ಲಿರುವ ಡಿಸ್ಟ್ ಫೋಲ್ಡರ್‌ನಿಂದ ರನ್‌ಟೈಮ್ ಪರಿಸರದ ಡಿಸ್ಟ್ ಡೈರೆಕ್ಟರಿಗೆ ಬಿಲ್ಟ್ ಮಾಡಿದ ಫೈಲ್‌ಗಳನ್ನು ನಕಲಿಸುತ್ತದೆ. ಕಂಟೈನರ್‌ನಲ್ಲಿ ಕಂಪೈಲ್ ಮಾಡಿದ ಟೈಪ್‌ಸ್ಕ್ರಿಪ್ಟ್ ಫೈಲ್‌ಗಳು ಲಭ್ಯವಿದೆಯೇ ಎಂದು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಲು ಈ ಆಜ್ಞೆಯು ಅತ್ಯಗತ್ಯ.
RUN npm install --omit=dev	ದೇವ್ ಅವಲಂಬನೆಗಳನ್ನು ಬಿಟ್ಟುಬಿಡುವ ಮೂಲಕ ಉತ್ಪಾದನಾ ಅವಲಂಬನೆಗಳನ್ನು ಮಾತ್ರ ಸ್ಥಾಪಿಸುತ್ತದೆ. ಈ ಆಜ್ಞೆಯನ್ನು ಪ್ರೊಡಕ್ಷನ್ ಬಿಲ್ಡ್‌ಗಳಿಗೆ ಹೊಂದುವಂತೆ ಮಾಡಲಾಗಿದೆ, ಕಂಟೇನರ್‌ನ ಅಂತಿಮ ಗಾತ್ರವನ್ನು ಕಡಿಮೆ ಮಾಡುತ್ತದೆ ಮತ್ತು ಅಭಿವೃದ್ಧಿ ಸಾಧನಗಳನ್ನು ಹೊರತುಪಡಿಸಿ ಸುರಕ್ಷತೆಯನ್ನು ಸುಧಾರಿಸುತ್ತದೆ.
healthcheck: test: ["CMD", "curl", "-f", "http://localhost:8000"]	ಡಾಕರ್‌ನಲ್ಲಿ ಡೈನಮೋಡಿಬಿ ಸೇವೆಯು ಚಾಲನೆಯಲ್ಲಿದೆಯೇ ಎಂದು ಪರಿಶೀಲಿಸಲು ಆರೋಗ್ಯ ತಪಾಸಣೆಯನ್ನು ವಿವರಿಸುತ್ತದೆ. ಬ್ಯಾಕೆಂಡ್ ಪ್ರಾರಂಭವಾಗುವ ಮೊದಲು ಸೇವೆಯು ಲಭ್ಯವಿರುವುದನ್ನು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಲು, ನಿರ್ದಿಷ್ಟಪಡಿಸಿದ ಸ್ಥಳೀಯ ಎಂಡ್‌ಪಾಯಿಂಟ್‌ಗೆ ಸಂಪರ್ಕವನ್ನು ಪ್ರಯತ್ನಿಸಲು ಇದು ಕರ್ಲ್ ಅನ್ನು ಬಳಸುತ್ತದೆ.
depends_on:	docker-compose.yml ನಲ್ಲಿ ಅವಲಂಬನೆಗಳನ್ನು ನಿರ್ದಿಷ್ಟಪಡಿಸುತ್ತದೆ. ಇಲ್ಲಿ, ಬ್ಯಾಕೆಂಡ್ ಸೇವೆಯು DynamoDB ಅನ್ನು ಪ್ರಾರಂಭಿಸಲು ಕಾಯುತ್ತಿದೆ ಎಂದು ಖಚಿತಪಡಿಸುತ್ತದೆ, ಸಿದ್ಧವಿಲ್ಲದ ಸೇವೆಗೆ ಸಂಪರ್ಕಿಸಲು ಪ್ರಯತ್ನಿಸುವುದರಿಂದ ದೋಷಗಳನ್ನು ತಡೆಯುತ್ತದೆ.
EXPOSE 3001	ಪೋರ್ಟ್ 3001 ಅನ್ನು ಡಾಕರ್ ಕಂಟೇನರ್‌ನಲ್ಲಿ ತೆರೆಯುತ್ತದೆ, ಈ ಪೋರ್ಟ್‌ನಲ್ಲಿ ಬ್ಯಾಕೆಂಡ್ ಸೇವೆಯನ್ನು ಪ್ರವೇಶಿಸುವಂತೆ ಮಾಡುತ್ತದೆ. ನೆಟ್‌ವರ್ಕಿಂಗ್ ಅನ್ನು ಹೊಂದಿಸಲು ಮತ್ತು ಬಾಹ್ಯ ಸೇವೆಗಳು ಅಥವಾ ಇತರ ಕಂಟೈನರ್‌ಗಳಿಗೆ ಬ್ಯಾಕೆಂಡ್ ಅನ್ನು ಪ್ರವೇಶಿಸಲು ಈ ಆಜ್ಞೆಯು ಅಗತ್ಯವಿದೆ.
test('dist folder exists', ...)	ಡಿಸ್ಟ್ ಫೋಲ್ಡರ್ ಅನ್ನು ಸರಿಯಾಗಿ ರಚಿಸಲಾಗಿದೆಯೇ ಎಂದು ಪರಿಶೀಲಿಸುವ ಜೆಸ್ಟ್ ಯುನಿಟ್ ಪರೀಕ್ಷೆ. ಡಿಸ್ಟ್ ಡೈರೆಕ್ಟರಿಯಲ್ಲಿ ಕಾಣೆಯಾದ ಫೈಲ್‌ಗಳೊಂದಿಗೆ ಸಂಭಾವ್ಯ ಸಮಸ್ಯೆಗಳನ್ನು ಕ್ಯಾಚ್ ಮಾಡುವ ಮೂಲಕ ನಿರ್ಮಾಣ ಹಂತವು ಯಶಸ್ವಿಯಾಗಿದೆ ಎಂದು ಪರಿಶೀಲಿಸಲು ಈ ಪರೀಕ್ಷೆಯು ಸಹಾಯ ಮಾಡುತ್ತದೆ.
expect(packageJson.scripts.start)	ಪ್ಯಾಕೇಜ್.json ನಲ್ಲಿ ಪ್ರಾರಂಭ ಸ್ಕ್ರಿಪ್ಟ್ ಅಸ್ತಿತ್ವದಲ್ಲಿದೆ ಎಂದು ಖಚಿತಪಡಿಸುವ ಜೆಸ್ಟ್ ಪರೀಕ್ಷಾ ಸಾಲು. ನಿಯೋಜನೆಯ ಮೊದಲು ಕಾನ್ಫಿಗರೇಶನ್ ನಿಖರತೆಯನ್ನು ಖಾತ್ರಿಪಡಿಸುವ ಮೂಲಕ ಪ್ರಾರಂಭದ ಆಜ್ಞೆಗಳನ್ನು ಕಾಣೆಯಾಗುವುದರಿಂದ ರನ್‌ಟೈಮ್ ದೋಷಗಳನ್ನು ತಡೆಯಲು ಇದು ಸಹಾಯ ಮಾಡುತ್ತದೆ.

Node.js ಮತ್ತು ಡೇಟಾಬೇಸ್ ಸಂಪರ್ಕಕ್ಕಾಗಿ ಡಾಕರ್ ಕಾನ್ಫಿಗರೇಶನ್

ಮೇಲಿನ ಉದಾಹರಣೆಯಲ್ಲಿ, ಡಾಕರ್ ಸೆಟಪ್ ಬಹು-ಹಂತದ ನಿರ್ಮಾಣವನ್ನು ನಿಯಂತ್ರಿಸುತ್ತದೆ, ಇದು ಸಮರ್ಥ ಉತ್ಪಾದನೆ-ಸಿದ್ಧ ಧಾರಕಗಳನ್ನು ರಚಿಸಲು ಉಪಯುಕ್ತವಾಗಿದೆ. "ಬಿಲ್ಡರ್" ಎಂದು ವ್ಯಾಖ್ಯಾನಿಸಲಾದ ಮೊದಲ ಹಂತವು ಅವಲಂಬನೆಗಳನ್ನು ಸ್ಥಾಪಿಸುತ್ತದೆ ಮತ್ತು ಕಂಪೈಲ್ ಮಾಡುತ್ತದೆ ರಲ್ಲಿ JavaScript ಗೆ ಫೈಲ್‌ಗಳು ಫೋಲ್ಡರ್. ಈ ಹಂತವು ಅನಾವಶ್ಯಕ ದೇವ್ ಅವಲಂಬನೆಗಳನ್ನು ಸೇರಿಸದೆಯೇ ಕಂಪೈಲ್ ಮಾಡಿದ ಕೋಡ್ ಉತ್ಪಾದನೆಗೆ ಸಿದ್ಧವಾಗಿದೆ ಎಂದು ಖಚಿತಪಡಿಸುತ್ತದೆ. ಒಮ್ಮೆ ನಿರ್ಮಿಸಿದ ನಂತರ, ಎರಡನೇ ಹಂತವು (ರನ್‌ಟೈಮ್) ಕಂಪೈಲ್ ಮಾಡಿದ ಫೈಲ್‌ಗಳು ಮತ್ತು ಉತ್ಪಾದನಾ ಅವಲಂಬನೆಗಳನ್ನು ಮಾತ್ರ ನಕಲಿಸುತ್ತದೆ, ಕಂಟೇನರ್ ಗಾತ್ರವನ್ನು ಕಡಿಮೆ ಮಾಡುತ್ತದೆ. ಪ್ರತಿ ಬಿಟ್ ಆಪ್ಟಿಮೈಸೇಶನ್ ಎಣಿಕೆಯಾಗುವ ಕ್ಲೌಡ್ ಪರಿಸರಕ್ಕೆ ನೀವು ಆಗಾಗ್ಗೆ ನಿಯೋಜಿಸುತ್ತಿದ್ದರೆ ಈ ಸೆಟಪ್ ವಿಶೇಷವಾಗಿ ಸಹಾಯಕವಾಗಿರುತ್ತದೆ! 🚀

ದಿ ಎರಡೂ ಹಂತಗಳಲ್ಲಿನ ಆಜ್ಞೆಯು ಕಂಟೇನರ್‌ನ ಕಾರ್ಯ ಡೈರೆಕ್ಟರಿಯನ್ನು / ಅಪ್ಲಿಕೇಶನ್‌ಗೆ ಹೊಂದಿಸುತ್ತದೆ. ಇದು ಫೈಲ್ ಮಾರ್ಗಗಳನ್ನು ಸರಳಗೊಳಿಸುತ್ತದೆ ಮತ್ತು ಈ ಡೈರೆಕ್ಟರಿಯ ಸುತ್ತ ಎಲ್ಲಾ ಕಾರ್ಯಾಚರಣೆಗಳನ್ನು ಆಯೋಜಿಸುತ್ತದೆ. ಅದನ್ನು ಅನುಸರಿಸಿ, ಸೂಚನೆಗಳು ನಿರ್ದಿಷ್ಟ ಫೈಲ್‌ಗಳನ್ನು ಹೋಸ್ಟ್ ಯಂತ್ರದಿಂದ ಕಂಟೇನರ್‌ಗೆ ಸರಿಸುತ್ತವೆ. ಮೊದಲ ಹಂತದಲ್ಲಿ, ಪ್ಯಾಕೇಜ್*.json ಫೈಲ್‌ಗಳು ಮತ್ತು tsconfig.json ಅನ್ನು ಅವಲಂಬನೆ ಸ್ಥಾಪನೆ ಮತ್ತು ಟೈಪ್‌ಸ್ಕ್ರಿಪ್ಟ್ ಸಂಕಲನವನ್ನು ಅನುಮತಿಸಲು ನಕಲಿಸಲಾಗುತ್ತದೆ, ಮತ್ತು ಮತ್ತು npm ರನ್ ಬಿಲ್ಡ್ ಅನ್ನು ರನ್ ಮಾಡಿ ಆಜ್ಞೆಗಳು ಎಲ್ಲವನ್ನೂ ಸರಿಯಾಗಿ ಹೊಂದಿಸಲಾಗಿದೆ ಎಂದು ಖಚಿತಪಡಿಸುತ್ತದೆ. ಈ ಸೆಟಪ್ ಎಲ್ಲಾ ಫೈಲ್‌ಗಳನ್ನು ಸರಿಯಾಗಿ ನಕಲಿಸಲಾಗಿದೆ ಮತ್ತು ಕಾನ್ಫಿಗರ್ ಮಾಡಲಾಗಿದೆಯೆ ಎಂದು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳುವ ಮೂಲಕ ಪ್ರಾರಂಭದ ಸ್ಕ್ರಿಪ್ಟ್‌ಗಳನ್ನು ಕಳೆದುಕೊಂಡಿರುವಂತಹ ಸಮಸ್ಯೆಗಳನ್ನು ತಪ್ಪಿಸಲು ಸಹಾಯ ಮಾಡುತ್ತದೆ.

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

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

# Dockerfile
FROM node:18 AS builder
WORKDIR /app
# Copy necessary config files and install dependencies
COPY package*.json tsconfig.json ./
RUN npm install
# Copy all source files and build the project
COPY . .
RUN npm run build
# Production stage
FROM node:18-alpine
WORKDIR /app
COPY --from=builder /app/package*.json ./
RUN npm install --omit=dev
COPY --from=builder /app/dist ./dist
EXPOSE 3001
# Adjust command to start the server
CMD ["node", "dist/server.js"]

# docker-compose.yml
version: "3.9"
services:
  backend:
    build:
      context: .
      dockerfile: Dockerfile
    ports:
      - "3001:3001"
    environment:
      PORT: 3001
    depends_on:
      - dynamodb
    command: ["npm", "run", "start"]
  dynamodb:
    image: amazon/dynamodb-local
    ports:
      - "8001:8000"
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:8000"]
      interval: 10s
      timeout: 5s
      retries: 5

{
  "name": "backend",
  "version": "1.0.0",
  "main": "dist/server.js",
  "scripts": {
    "build": "tsc",
    "start": "node dist/server.js",
    "dev": "nodemon --exec ts-node src/server.ts",
    "clean": "rimraf dist"
  }
}

// test/deployment.test.js
const fs = require('fs');
describe('Deployment Tests', () => {
  test('dist folder exists', () => {
    expect(fs.existsSync('./dist')).toBe(true);
  });
  test('start script exists in package.json', () => {
    const packageJson = require('../package.json');
    expect(packageJson.scripts.start).toBe("node dist/server.js");
  });
  test('Dockerfile has correct CMD', () => {
    const dockerfile = fs.readFileSync('./Dockerfile', 'utf8');
    expect(dockerfile).toMatch(/CMD \["node", "dist\/server.js"\]/);
  });
});

Node.js ಯೋಜನೆಗಳಿಗಾಗಿ ಡಾಕರ್‌ನಲ್ಲಿ ಸರಿಯಾದ ಫೈಲ್ ನಕಲು ಮತ್ತು ರಚನೆಯನ್ನು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳುವುದು

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

Node.js ಗಾಗಿ ಡಾಕರ್‌ನ ಅತ್ಯಗತ್ಯ ಅಂಶವೆಂದರೆ ಸಂಘಟಿಸುವುದು ಮತ್ತು ನಿಖರವಾಗಿ. ಡಾಕರ್‌ಫೈಲ್‌ನಲ್ಲಿ ಪಥಗಳನ್ನು ಸ್ಪಷ್ಟವಾಗಿ ಸೂಚಿಸುವ ಮೂಲಕ ಮತ್ತು ಪ್ರಾರಂಭ ಆಜ್ಞೆಯನ್ನು ಸರಿಯಾಗಿ ಹೊಂದಿಸಲಾಗಿದೆ ಎಂದು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳುವ ಮೂಲಕ pack.json, "ಪ್ರಾರಂಭದ ಸ್ಕ್ರಿಪ್ಟ್ ಕಾಣೆಯಾಗಿದೆ" ನಂತಹ ದೋಷಗಳನ್ನು ನೀವು ಕಡಿಮೆಗೊಳಿಸುತ್ತೀರಿ. ವಿಶೇಷವಾಗಿ ಬಹು ಸೇವೆಗಳು ಅಥವಾ ಫೋಲ್ಡರ್‌ಗಳನ್ನು ಒಳಗೊಂಡಿರುವ ಸಂಕೀರ್ಣ ಸೆಟಪ್‌ಗಳಲ್ಲಿ ಪ್ರತಿಯೊಂದು ಫೈಲ್ ಎಲ್ಲಿರಬೇಕು ಎಂದು ಡಾಕರ್‌ಗೆ ತಿಳಿದಿದೆ ಎಂದು ಖಚಿತಪಡಿಸಲು ಇದು ನಿರ್ಣಾಯಕವಾಗಿದೆ. ಉದಾಹರಣೆಗೆ, ಕೇವಲ ಸೇರಿಸಲು COPY ಆಜ್ಞೆಯನ್ನು ಬಳಸಿ ಫೋಲ್ಡರ್ ಮತ್ತು ಅಂತಿಮ ಕಂಟೇನರ್‌ಗೆ ಅಗತ್ಯವಾದ ಕಾನ್ಫಿಗರೇಶನ್‌ಗಳು ಉತ್ಪಾದನೆಯಲ್ಲಿ ಅಗತ್ಯ ಫೈಲ್‌ಗಳು ಮಾತ್ರ ಲಭ್ಯವಿರುವುದನ್ನು ಖಚಿತಪಡಿಸುತ್ತದೆ 📂.

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

1. NPM ನಲ್ಲಿ "ಮಿಸ್ಸಿಂಗ್ ಸ್ಟಾರ್ಟ್ ಸ್ಕ್ರಿಪ್ಟ್" ದೋಷಕ್ಕೆ ಕಾರಣವೇನು?
2. ಯಾವಾಗ ಈ ದೋಷವು ಹೆಚ್ಚಾಗಿ ಸಂಭವಿಸುತ್ತದೆ ಫೈಲ್ ಎ ಹೊಂದಿಲ್ಲ ಸ್ಕ್ರಿಪ್ಟ್ ವ್ಯಾಖ್ಯಾನಿಸಲಾಗಿದೆ. ಅಪ್ಲಿಕೇಶನ್ ಅನ್ನು ಪ್ರಾರಂಭಿಸಲು NPM ಸರಿಯಾದ ಪ್ರವೇಶ ಬಿಂದುವನ್ನು ಹುಡುಕಲು ಸಾಧ್ಯವಿಲ್ಲ.
3. ಮಾಡುತ್ತದೆ ಕಡತದಲ್ಲಿ ಇರಬೇಕು ಫೋಲ್ಡರ್?
4. ಇಲ್ಲ, ದಿ ವಿಶಿಷ್ಟವಾಗಿ ರೂಟ್ ಡೈರೆಕ್ಟರಿಯಲ್ಲಿ ವಾಸಿಸುತ್ತದೆ ಮತ್ತು ಅಗತ್ಯವಿರುವ ಫೈಲ್‌ಗಳನ್ನು ಮಾತ್ರ ನಕಲಿಸಲಾಗುತ್ತದೆ ಫೋಲ್ಡರ್.
5. ಡಾಕರ್‌ನಲ್ಲಿ ನಾವು ಬಹು-ಹಂತದ ನಿರ್ಮಾಣಗಳನ್ನು ಏಕೆ ಬಳಸುತ್ತೇವೆ?
6. ಬಹು-ಹಂತದ ನಿರ್ಮಾಣಗಳು ಹಗುರವಾದ, ಉತ್ಪಾದನೆಗೆ ಸಿದ್ಧವಾದ ಕಂಟೇನರ್ಗಳನ್ನು ರಚಿಸಲು ನಮಗೆ ಅನುಮತಿಸುತ್ತದೆ. ನಿರ್ಮಾಣ ಮತ್ತು ರನ್‌ಟೈಮ್ ಪರಿಸರವನ್ನು ಪ್ರತ್ಯೇಕಿಸುವ ಮೂಲಕ, ಅನಗತ್ಯ ಫೈಲ್‌ಗಳನ್ನು ಹೊರಗಿಡಲಾಗುತ್ತದೆ, ಸುರಕ್ಷತೆ ಮತ್ತು ದಕ್ಷತೆಯನ್ನು ಸುಧಾರಿಸುತ್ತದೆ.
7. ಹೇಗೆ ಮಾಡುತ್ತದೆ ಡಾಕರ್ ಕಂಪೋಸ್ ಸಹಾಯದಲ್ಲಿ?
8. ದಿ ಒಂದು ಸೇವೆಯು ಚಾಲನೆಯಲ್ಲಿದೆಯೇ ಮತ್ತು ಚಾಲನೆಯಲ್ಲಿದೆಯೇ ಎಂದು ಆಜ್ಞೆಯು ಪರಿಶೀಲಿಸುತ್ತದೆ, ಡೇಟಾಬೇಸ್‌ಗಳಂತಹ ಅವಲಂಬಿತ ಸೇವೆಗಳು ಮೊದಲು ಸಿದ್ಧವಾಗಬೇಕಾದ ಸಂದರ್ಭಗಳಲ್ಲಿ ಇದು ಅತ್ಯಗತ್ಯವಾಗಿರುತ್ತದೆ.
9. ಈ ಸೆಟಪ್‌ನಲ್ಲಿ ನಾನು DynamoDB ಬದಲಿಗೆ ಇತರ ಡೇಟಾಬೇಸ್‌ಗಳನ್ನು ಬಳಸಬಹುದೇ?
10. ಹೌದು, ನೀವು ಬದಲಾಯಿಸಬಹುದು ಇತರ ಡೇಟಾಬೇಸ್ಗಳೊಂದಿಗೆ. ನಿಮ್ಮ ಆದ್ಯತೆಯ ಡೇಟಾಬೇಸ್ ಸೇವೆಗೆ ಸರಿಹೊಂದುವಂತೆ ಡಾಕರ್ ಕಂಪೋಸ್ ಕಾನ್ಫಿಗರೇಶನ್ ಅನ್ನು ಹೊಂದಿಸಿ.
11. ನಾವು ಏಕೆ ಬಳಸುತ್ತೇವೆ ಆಜ್ಞೆ?
12. ಈ ಆಜ್ಞೆಯು ಉತ್ಪಾದನಾ ಅವಲಂಬನೆಗಳನ್ನು ಮಾತ್ರ ಸ್ಥಾಪಿಸುತ್ತದೆ, ಇದು ಅಭಿವೃದ್ಧಿ ಸಾಧನಗಳನ್ನು ಹೊರತುಪಡಿಸಿ ಕಂಟೇನರ್ ಅನ್ನು ಹಗುರವಾಗಿಡಲು ಸಹಾಯ ಮಾಡುತ್ತದೆ.
13. ನಾನು ಹೇಗೆ ದೃಢೀಕರಿಸಬಹುದು ಫೋಲ್ಡರ್ ಅನ್ನು ಸರಿಯಾಗಿ ನಕಲಿಸಲಾಗಿದೆಯೇ?
14. ಎಂಬುದನ್ನು ಪರಿಶೀಲಿಸಲು ನಿಮ್ಮ ಕೋಡ್‌ನಲ್ಲಿ ನೀವು ಪರೀಕ್ಷೆಯನ್ನು ಸೇರಿಸಬಹುದು ಅಸ್ತಿತ್ವದಲ್ಲಿದೆ, ಅಥವಾ ನಿರ್ಮಾಣದ ನಂತರ ಕಂಟೇನರ್‌ನ ವಿಷಯಗಳನ್ನು ಪರಿಶೀಲಿಸಲು ಡಾಕರ್ CLI ಅನ್ನು ಬಳಸಿ.
15. ನಾನು Dockerfile ಮತ್ತು Docker Compose ಎರಡರಲ್ಲೂ ಪೋರ್ಟ್ ಅನ್ನು ನಿರ್ದಿಷ್ಟಪಡಿಸಬೇಕೇ?
16. ಹೌದು, ಎರಡರಲ್ಲೂ ಪೋರ್ಟ್ ಅನ್ನು ನಿರ್ದಿಷ್ಟಪಡಿಸುವುದರಿಂದ ಕಂಟೇನರ್ ಪೋರ್ಟ್ ಹೋಸ್ಟ್ ಪೋರ್ಟ್‌ಗೆ ಹೊಂದಿಕೆಯಾಗುತ್ತದೆ ಎಂದು ಖಚಿತಪಡಿಸುತ್ತದೆ, ಡಾಕರ್ ಹೊರಗಿನಿಂದ ಸೇವೆಯನ್ನು ಪ್ರವೇಶಿಸುವಂತೆ ಮಾಡುತ್ತದೆ.
17. ಏಕೆ ಹೊಂದಿಸಲಾಗುತ್ತಿದೆ ಡಾಕರ್‌ನಲ್ಲಿ ಮುಖ್ಯವೇ?
18. ಸೆಟ್ಟಿಂಗ್ ಎಲ್ಲಾ ಆಜ್ಞೆಗಳಿಗೆ ಡೀಫಾಲ್ಟ್ ಡೈರೆಕ್ಟರಿ ಮಾರ್ಗವನ್ನು ರಚಿಸುತ್ತದೆ, ಫೈಲ್ ಮಾರ್ಗಗಳನ್ನು ಸರಳಗೊಳಿಸುತ್ತದೆ ಮತ್ತು ಕಂಟೇನರ್ ಫೈಲ್‌ಗಳನ್ನು ವ್ಯವಸ್ಥಿತವಾಗಿ ಸಂಘಟಿಸುತ್ತದೆ.
19. ಈ ದೋಷವನ್ನು ಡೀಬಗ್ ಮಾಡಲು ನಾನು ಡಾಕರ್ ಲಾಗ್‌ಗಳನ್ನು ಹೇಗೆ ವೀಕ್ಷಿಸಬಹುದು?
20. ಬಳಸಿ ಲಾಗ್‌ಗಳನ್ನು ಪ್ರವೇಶಿಸಲು, ಇದು ಯಾವುದೇ ಆರಂಭಿಕ ದೋಷಗಳು ಅಥವಾ ಕಾಣೆಯಾದ ಫೈಲ್‌ಗಳ ಒಳನೋಟಗಳನ್ನು ಒದಗಿಸುತ್ತದೆ.

"ಮಿಸ್ಸಿಂಗ್ ಸ್ಟಾರ್ಟ್ ಸ್ಕ್ರಿಪ್ಟ್" ದೋಷವನ್ನು ಪರಿಹರಿಸಲು ವಿವರಗಳಿಗೆ ಗಮನ ನೀಡುವ ಅಗತ್ಯವಿದೆ, ವಿಶೇಷವಾಗಿ ಡಾಕರ್‌ನ ಫೈಲ್ ರಚನೆ ಮತ್ತು NPM ಸ್ಕ್ರಿಪ್ಟ್‌ಗಳನ್ನು ಕಾನ್ಫಿಗರ್ ಮಾಡುವಲ್ಲಿ. ಕಂಪೈಲ್ ಮಾಡಿದ ಫೈಲ್‌ಗಳನ್ನು ನಕಲು ಮಾಡಲಾಗಿದೆಯೆ ಎಂದು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಲು ನಿಮ್ಮ ಡಾಕರ್‌ಫೈಲ್ ಅನ್ನು ಪರಿಶೀಲಿಸಲಾಗುತ್ತಿದೆ ಫೋಲ್ಡರ್ ಮತ್ತು ಪ್ಯಾಕೇಜ್.json ನಲ್ಲಿನ ಪ್ರಾರಂಭ ಸ್ಕ್ರಿಪ್ಟ್ ಅನ್ನು ಸರಿಯಾಗಿ ವ್ಯಾಖ್ಯಾನಿಸಿರುವುದು ನಿಮಗೆ ಗಂಟೆಗಳ ಡೀಬಗ್ ಮಾಡುವುದನ್ನು ಉಳಿಸಬಹುದು.

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