ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಅಭಿವೃದ್ಧಿ ಪರಿಸರ: ಡಾಕರ್ ಕಂಟೇನರ್ ಕಾನ್ಫಿಗರೇಶನ್

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

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

ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಅಭಿವೃದ್ಧಿಗಾಗಿ ಡಾಕರ್ ಅನ್ನು ಏಕೆ ಬಳಸಬೇಕು?

ವಿಶೇಷತೆಗಳಿಗೆ ಧುಮುಕುವ ಮೊದಲು, ನಿಮ್ಮ ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಅಭಿವೃದ್ಧಿ ಪರಿಸರಕ್ಕಾಗಿ ಡಾಕರ್ ಬಳಸುವ ಪ್ರಯೋಜನಗಳನ್ನು ಅನ್ವೇಷಿಸೋಣ:

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

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

ನೀವು ಪ್ರಾರಂಭಿಸುವ ಮೊದಲು, ನೀವು ಈ ಕೆಳಗಿನವುಗಳನ್ನು ಇನ್‌ಸ್ಟಾಲ್ ಮಾಡಿದ್ದೀರಿ ಎಂದು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಿ:

• ಡಾಕರ್: ಅಧಿಕೃತ ಡಾಕರ್ ವೆಬ್‌ಸೈಟ್‌ನಿಂದ (docker.com) ನಿಮ್ಮ ಆಪರೇಟಿಂಗ್ ಸಿಸ್ಟಮ್‌ಗಾಗಿ ಡಾಕರ್ ಡೆಸ್ಕ್‌ಟಾಪ್ ಅನ್ನು ಡೌನ್‌ಲೋಡ್ ಮಾಡಿ ಮತ್ತು ಇನ್‌ಸ್ಟಾಲ್ ಮಾಡಿ. ಡಾಕರ್ ಡೆಸ್ಕ್‌ಟಾಪ್‌ನಲ್ಲಿ ಡಾಕರ್ ಎಂಜಿನ್, ಡಾಕರ್ CLI, ಡಾಕರ್ ಕಂಪೋಸ್ ಮತ್ತು ಇತರ ಅಗತ್ಯ ಉಪಕರಣಗಳು ಸೇರಿವೆ.
• Node.js ಮತ್ತು npm (ಐಚ್ಛಿಕ): ನಿಮ್ಮ ಹೋಸ್ಟ್ ಯಂತ್ರದಲ್ಲಿ ಇದು ಕಟ್ಟುನಿಟ್ಟಾಗಿ ಅಗತ್ಯವಿಲ್ಲ ಏಕೆಂದರೆ ಅವು ಕಂಟೇನರ್‌ನೊಳಗೆ ಇರುತ್ತವೆ, ಸ್ಥಳೀಯವಾಗಿ Node.js ಮತ್ತು npm ಅನ್ನು ಸ್ಥಾಪಿಸಿದ್ದರೆ ಕಂಟೇನರ್‌ನ ಹೊರಗಿನ ಕಾರ್ಯಗಳಿಗಾಗಿ ಅಥವಾ ನಿಮ್ಮ ಆರಂಭಿಕ ಪ್ರಾಜೆಕ್ಟ್ ರಚನೆಯನ್ನು ಸ್ಥಾಪಿಸುವಾಗ ಸಹಾಯಕವಾಗಬಹುದು. ನೀವು ಅವುಗಳನ್ನು nodejs.org ನಿಂದ ಡೌನ್‌ಲೋಡ್ ಮಾಡಬಹುದು.
• ಕೋಡ್ ಎಡಿಟರ್: ನಿಮ್ಮ ಆದ್ಯತೆಯ ಕೋಡ್ ಎಡಿಟರ್ ಅನ್ನು ಆಯ್ಕೆಮಾಡಿ (ಉದಾ., VS ಕೋಡ್, ಸಬ್‌ಲೈಮ್ ಟೆಕ್ಸ್ಟ್, ಆಟಮ್). VS ಕೋಡ್ ಅತ್ಯುತ್ತಮ ಡಾಕರ್ ವಿಸ್ತರಣೆಗಳನ್ನು ಹೊಂದಿದೆ, ಅದು ನಿಮ್ಮ ಕೆಲಸದ ಹರಿವನ್ನು ಸರಳಗೊಳಿಸುತ್ತದೆ.

ಮೂಲಭೂತ ಡಾಕರ್ಫೈಲ್ ಕಾನ್ಫಿಗರೇಶನ್

ಯಾವುದೇ ಡಾಕರ್-ಆಧಾರಿತ ಪರಿಸರದ ಅಡಿಪಾಯವೆಂದರೆ Dockerfile. ಈ ಫೈಲ್ ನಿಮ್ಮ ಡಾಕರ್ ಇಮೇಜ್ ಅನ್ನು ನಿರ್ಮಿಸಲು ಸೂಚನೆಗಳನ್ನು ಒಳಗೊಂಡಿದೆ. Node.js ಅಪ್ಲಿಕೇಶನ್‌ಗಾಗಿ ಮೂಲಭೂತ Dockerfile ಅನ್ನು ರಚಿಸೋಣ:

# ಅಧಿಕೃತ Node.js ರನ್‌ಟೈಮ್ ಅನ್ನು ಪೇರೆಂಟ್ ಇಮೇಜ್ ಆಗಿ ಬಳಸಿ
FROM node:18-alpine

# ಕಂಟೇನರ್‌ನಲ್ಲಿ ವರ್ಕಿಂಗ್ ಡೈರೆಕ್ಟರಿಯನ್ನು ಸೆಟ್ ಮಾಡಿ
WORKDIR /app

# package.json ಮತ್ತು package-lock.json ಅನ್ನು ವರ್ಕಿಂಗ್ ಡೈರೆಕ್ಟರಿಗೆ ಕಾಪಿ ಮಾಡಿ
COPY package*.json ./

# ಅಪ್ಲಿಕೇಶನ್ ಡಿಪೆಂಡೆನ್ಸಿಗಳನ್ನು ಇನ್‌ಸ್ಟಾಲ್ ಮಾಡಿ
RUN npm install

# ಅಪ್ಲಿಕೇಶನ್ ಸೋರ್ಸ್ ಕೋಡ್ ಅನ್ನು ವರ್ಕಿಂಗ್ ಡೈರೆಕ್ಟರಿಗೆ ಕಾಪಿ ಮಾಡಿ
COPY . .

# ಹೊರಗಿನ ಪ್ರಪಂಚಕ್ಕೆ ಪೋರ್ಟ್ 3000 ಅನ್ನು ಎಕ್ಸ್‌ಪೋಸ್ ಮಾಡಿ (ನಿಮ್ಮ ಅಪ್ಲಿಕೇಶನ್ ಬೇರೆ ಪೋರ್ಟ್ ಬಳಸುತ್ತಿದ್ದರೆ ಹೊಂದಿಸಿ)
EXPOSE 3000

# ಕಂಟೇನರ್ ಪ್ರಾರಂಭವಾದಾಗ ಚಲಾಯಿಸಲು ಕಮಾಂಡ್ ಅನ್ನು ಡಿಫೈನ್ ಮಾಡಿ
CMD ["npm", "start"]

ಪ್ರತಿ ಸಾಲನ್ನು ವಿಭಜಿಸೋಣ:

• FROM node:18-alpine: ಕಂಟೇನರ್‌ಗಾಗಿ ಬೇಸ್ ಇಮೇಜ್ ಅನ್ನು ನಿರ್ದಿಷ್ಟಪಡಿಸುತ್ತದೆ. ಈ ಸಂದರ್ಭದಲ್ಲಿ, ನಾವು ಅಧಿಕೃತ Node.js 18 ಆಲ್ಪೈನ್ ಇಮೇಜ್ ಅನ್ನು ಬಳಸುತ್ತಿದ್ದೇವೆ, ಇದು ಹಗುರವಾದ ಲಿನಕ್ಸ್ ವಿತರಣೆಯಾಗಿದೆ. ಆಲ್ಪೈನ್ ತನ್ನ ಸಣ್ಣ ಗಾತ್ರಕ್ಕೆ ಹೆಸರುವಾಸಿಯಾಗಿದೆ, ಇದು ನಿಮ್ಮ ಡಾಕರ್ ಇಮೇಜ್ ಅನ್ನು ತೆಳ್ಳಗೆ ಇಡಲು ಸಹಾಯ ಮಾಡುತ್ತದೆ. ನಿಮ್ಮ ಪ್ರಾಜೆಕ್ಟ್‌ಗೆ ಸೂಕ್ತವಾದ ಇತರ Node.js ಆವೃತ್ತಿಗಳನ್ನು ಪರಿಗಣಿಸಿ.
• WORKDIR /app: ಕಂಟೇನರ್‌ನೊಳಗಿನ ವರ್ಕಿಂಗ್ ಡೈರೆಕ್ಟರಿಯನ್ನು /app ಗೆ ಹೊಂದಿಸುತ್ತದೆ. ಇಲ್ಲಿ ನಿಮ್ಮ ಅಪ್ಲಿಕೇಶನ್ ಕೋಡ್ ಇರುತ್ತದೆ.
• COPY package*.json ./: package.json ಮತ್ತು package-lock.json (ಅಥವಾ ನೀವು Yarn ಬಳಸಿದರೆ yarn.lock) ಫೈಲ್‌ಗಳನ್ನು ವರ್ಕಿಂಗ್ ಡೈರೆಕ್ಟರಿಗೆ ಕಾಪಿ ಮಾಡುತ್ತದೆ. ಈ ಫೈಲ್‌ಗಳನ್ನು ಮೊದಲು ಕಾಪಿ ಮಾಡುವುದರಿಂದ ಡಾಕರ್ npm install ಹಂತವನ್ನು ಕ್ಯಾಶ್ ಮಾಡಲು ಅನುವು ಮಾಡಿಕೊಡುತ್ತದೆ, ನೀವು ಕೇವಲ ಅಪ್ಲಿಕೇಶನ್ ಕೋಡ್ ಅನ್ನು ಬದಲಾಯಿಸಿದಾಗ ಬಿಲ್ಡ್ ಸಮಯವನ್ನು ಗಮನಾರ್ಹವಾಗಿ ವೇಗಗೊಳಿಸುತ್ತದೆ.
• RUN npm install: package.json ನಲ್ಲಿ ವಿವರಿಸಿದ ಅಪ್ಲಿಕೇಶನ್ ಡಿಪೆಂಡೆನ್ಸಿಗಳನ್ನು ಇನ್‌ಸ್ಟಾಲ್ ಮಾಡುತ್ತದೆ.
• COPY . .: ನಿಮ್ಮ ಸ್ಥಳೀಯ ಪ್ರಾಜೆಕ್ಟ್ ಡೈರೆಕ್ಟರಿಯಿಂದ ಉಳಿದ ಎಲ್ಲಾ ಫೈಲ್‌ಗಳು ಮತ್ತು ಡೈರೆಕ್ಟರಿಗಳನ್ನು ಕಂಟೇನರ್‌ನೊಳಗಿನ ವರ್ಕಿಂಗ್ ಡೈರೆಕ್ಟರಿಗೆ ಕಾಪಿ ಮಾಡುತ್ತದೆ.
• EXPOSE 3000: ಪೋರ್ಟ್ 3000 ಅನ್ನು ಎಕ್ಸ್‌ಪೋಸ್ ಮಾಡುತ್ತದೆ, ಅದನ್ನು ಹೋಸ್ಟ್ ಯಂತ್ರದಿಂದ ಪ್ರವೇಶಿಸಲು ಸಾಧ್ಯವಾಗಿಸುತ್ತದೆ. ನಿಮ್ಮ ಅಪ್ಲಿಕೇಶನ್ ಈ ಪೋರ್ಟ್‌ನಲ್ಲಿ ಕೇಳುತ್ತಿದ್ದರೆ ಇದು ಮುಖ್ಯವಾಗಿದೆ. ನಿಮ್ಮ ಅಪ್ಲಿಕೇಶನ್ ಬೇರೆ ಪೋರ್ಟ್ ಬಳಸಿದರೆ ಪೋರ್ಟ್ ಸಂಖ್ಯೆಯನ್ನು ಹೊಂದಿಸಿ.
• CMD ["npm", "start"]: ಕಂಟೇನರ್ ಪ್ರಾರಂಭವಾದಾಗ ಚಲಾಯಿಸಲು ಕಮಾಂಡ್ ಅನ್ನು ನಿರ್ದಿಷ್ಟಪಡಿಸುತ್ತದೆ. ಈ ಸಂದರ್ಭದಲ್ಲಿ, ನಾವು npm start ಅನ್ನು ಬಳಸುತ್ತಿದ್ದೇವೆ, ಇದು Node.js ಅಪ್ಲಿಕೇಶನ್‌ಗಳನ್ನು ಪ್ರಾರಂಭಿಸಲು ಸಾಮಾನ್ಯ ಕಮಾಂಡ್ ಆಗಿದೆ. ಈ ಕಮಾಂಡ್ ನಿಮ್ಮ package.json ನ scripts ವಿಭಾಗದಲ್ಲಿ ವಿವರಿಸಿದ ಕಮಾಂಡ್‌ಗೆ ಹೊಂದಿಕೆಯಾಗಿದೆಯೆ ಎಂದು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಿ.

ಡಾಕರ್ ಇಮೇಜ್ ಅನ್ನು ನಿರ್ಮಿಸುವುದು

ಒಮ್ಮೆ ನೀವು ನಿಮ್ಮ Dockerfile ಅನ್ನು ರಚಿಸಿದ ನಂತರ, ನೀವು ಈ ಕೆಳಗಿನ ಕಮಾಂಡ್ ಬಳಸಿ ಡಾಕರ್ ಇಮೇಜ್ ಅನ್ನು ನಿರ್ಮಿಸಬಹುದು:

docker build -t my-node-app .

ಇಲ್ಲಿ:

• docker build: ಇಮೇಜ್‌ಗಳನ್ನು ನಿರ್ಮಿಸಲು ಡಾಕರ್ ಕಮಾಂಡ್.
• -t my-node-app: ಇಮೇಜ್‌ಗೆ ಟ್ಯಾಗ್ (ಹೆಸರು) ಅನ್ನು ನಿರ್ದಿಷ್ಟಪಡಿಸುತ್ತದೆ. ನಿಮ್ಮ ಅಪ್ಲಿಕೇಶನ್‌ಗೆ ವಿವರಣಾತ್ಮಕ ಹೆಸರನ್ನು ಆಯ್ಕೆಮಾಡಿ.
• .: ಬಿಲ್ಡ್ ಸಂದರ್ಭವನ್ನು ನಿರ್ದಿಷ್ಟಪಡಿಸುತ್ತದೆ, ಇದು ಪ್ರಸ್ತುತ ಡೈರೆಕ್ಟರಿಯಾಗಿದೆ. ಡಾಕರ್ ಈ ಡೈರೆಕ್ಟರಿಯಲ್ಲಿನ Dockerfile ಅನ್ನು ಬಳಸಿ ಇಮೇಜ್ ಅನ್ನು ನಿರ್ಮಿಸುತ್ತದೆ.

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

ಡಾಕರ್ ಕಂಟೇನರ್ ಅನ್ನು ಚಲಾಯಿಸುವುದು

ಇಮೇಜ್ ನಿರ್ಮಿಸಿದ ನಂತರ, ನೀವು ಈ ಕೆಳಗಿನ ಕಮಾಂಡ್ ಬಳಸಿ ಅದರಿಂದ ಕಂಟೇನರ್ ಅನ್ನು ಚಲಾಯಿಸಬಹುದು:

docker run -p 3000:3000 my-node-app

ಇಲ್ಲಿ:

• docker run: ಕಂಟೇನರ್‌ಗಳನ್ನು ಚಲಾಯಿಸಲು ಡಾಕರ್ ಕಮಾಂಡ್.
• -p 3000:3000: ಹೋಸ್ಟ್ ಯಂತ್ರದಲ್ಲಿನ ಪೋರ್ಟ್ 3000 ಅನ್ನು ಕಂಟೇನರ್‌ನೊಳಗಿನ ಪೋರ್ಟ್ 3000 ಗೆ ಮ್ಯಾಪ್ ಮಾಡುತ್ತದೆ. ಇದು ನಿಮ್ಮ ಬ್ರೌಸರ್‌ನಿಂದ localhost:3000 ಬಳಸಿ ನಿಮ್ಮ ಅಪ್ಲಿಕೇಶನ್ ಅನ್ನು ಪ್ರವೇಶಿಸಲು ಅನುವು ಮಾಡಿಕೊಡುತ್ತದೆ. ಮೊದಲ ಸಂಖ್ಯೆ ಹೋಸ್ಟ್ ಪೋರ್ಟ್, ಮತ್ತು ಎರಡನೇ ಸಂಖ್ಯೆ ಕಂಟೇನರ್ ಪೋರ್ಟ್.
• my-node-app: ನೀವು ಚಲಾಯಿಸಲು ಬಯಸುವ ಇಮೇಜ್‌ನ ಹೆಸರು.

ನಿಮ್ಮ ಅಪ್ಲಿಕೇಶನ್ ಈಗ ಡಾಕರ್ ಕಂಟೇನರ್‌ನೊಳಗೆ ಚಾಲನೆಯಲ್ಲಿರಬೇಕು. ನಿಮ್ಮ ಬ್ರೌಸರ್ ತೆರೆದು localhost:3000 ಗೆ (ಅಥವಾ ನೀವು ನಿರ್ದಿಷ್ಟಪಡಿಸಿದ ಪೋರ್ಟ್‌ಗೆ) ನ್ಯಾವಿಗೇಟ್ ಮಾಡುವ ಮೂಲಕ ನೀವು ಅದನ್ನು ಪ್ರವೇಶಿಸಬಹುದು. ನೀವು ನಿಮ್ಮ ಅಪ್ಲಿಕೇಶನ್‌ನ ಸ್ವಾಗತ ಪರದೆ ಅಥವಾ ಆರಂಭಿಕ UI ಅನ್ನು ನೋಡಬೇಕು.

ಡಾಕರ್ ಕಂಪೋಸ್ ಬಳಸುವುದು

ಬಹು ಸೇವೆಗಳೊಂದಿಗೆ ಹೆಚ್ಚು ಸಂಕೀರ್ಣವಾದ ಅಪ್ಲಿಕೇಶನ್‌ಗಳಿಗಾಗಿ, ಡಾಕರ್ ಕಂಪೋಸ್ ಒಂದು ಅಮೂಲ್ಯವಾದ ಸಾಧನವಾಗಿದೆ. ಇದು ನಿಮಗೆ YAML ಫೈಲ್ ಬಳಸಿ ಬಹು-ಕಂಟೇನರ್ ಅಪ್ಲಿಕೇಶನ್‌ಗಳನ್ನು ಡಿಫೈನ್ ಮಾಡಲು ಮತ್ತು ನಿರ್ವಹಿಸಲು ಅನುವು ಮಾಡಿಕೊಡುತ್ತದೆ. ನಮ್ಮ Node.js ಅಪ್ಲಿಕೇಶನ್‌ಗಾಗಿ docker-compose.yml ಫೈಲ್ ಅನ್ನು ರಚಿಸೋಣ:

version: "3.9"
services:
  app:
    build: .
    ports:
      - "3000:3000"
    volumes:
      - .:/app
    environment:
      NODE_ENV: development
    command: npm run dev

ಪ್ರತಿ ವಿಭಾಗವನ್ನು ಪರಿಶೀಲಿಸೋಣ:

• version: "3.9": ಡಾಕರ್ ಕಂಪೋಸ್ ಫೈಲ್ ಫಾರ್ಮ್ಯಾಟ್‌ನ ಆವೃತ್ತಿಯನ್ನು ನಿರ್ದಿಷ್ಟಪಡಿಸುತ್ತದೆ.
• services: ನಿಮ್ಮ ಅಪ್ಲಿಕೇಶನ್ ಅನ್ನು ರೂಪಿಸುವ ಸೇವೆಗಳನ್ನು ಡಿಫೈನ್ ಮಾಡುತ್ತದೆ. ಈ ಸಂದರ್ಭದಲ್ಲಿ, ನಮಗೆ app ಹೆಸರಿನ ಒಂದೇ ಸೇವೆ ಇದೆ.
• build: .: ಪ್ರಸ್ತುತ ಡೈರೆಕ್ಟರಿಯಲ್ಲಿನ Dockerfile ನಿಂದ ಇಮೇಜ್ ಅನ್ನು ನಿರ್ಮಿಸಬೇಕು ಎಂದು ನಿರ್ದಿಷ್ಟಪಡಿಸುತ್ತದೆ.
• ports: - "3000:3000": docker run ಕಮಾಂಡ್‌ನಂತೆಯೇ ಹೋಸ್ಟ್ ಯಂತ್ರದಲ್ಲಿನ ಪೋರ್ಟ್ 3000 ಅನ್ನು ಕಂಟೇನರ್‌ನೊಳಗಿನ ಪೋರ್ಟ್ 3000 ಗೆ ಮ್ಯಾಪ್ ಮಾಡುತ್ತದೆ.
• volumes: - .:/app: ನಿಮ್ಮ ಹೋಸ್ಟ್ ಯಂತ್ರದಲ್ಲಿನ ಪ್ರಸ್ತುತ ಡೈರೆಕ್ಟರಿಯನ್ನು ಕಂಟೇನರ್‌ನೊಳಗಿನ /app ಡೈರೆಕ್ಟರಿಗೆ ಮೌಂಟ್ ಮಾಡುವ ವಾಲ್ಯೂಮ್ ಅನ್ನು ರಚಿಸುತ್ತದೆ. ಇದು ನಿಮ್ಮ ಹೋಸ್ಟ್ ಯಂತ್ರದಲ್ಲಿ ನಿಮ್ಮ ಕೋಡ್‌ಗೆ ಬದಲಾವಣೆಗಳನ್ನು ಮಾಡಲು ಮತ್ತು ಅವುಗಳು ಕಂಟೇನರ್‌ನೊಳಗೆ ಸ್ವಯಂಚಾಲಿತವಾಗಿ ಪ್ರತಿಫಲಿಸಲು ಅನುವು ಮಾಡಿಕೊಡುತ್ತದೆ, ಹಾಟ್ ರಿಲೋಡಿಂಗ್ ಅನ್ನು ಸಕ್ರಿಯಗೊಳಿಸುತ್ತದೆ.
• environment: NODE_ENV: development: ಕಂಟೇನರ್‌ನೊಳಗಿನ NODE_ENV ಎನ್ವಿರಾನ್ಮೆಂಟ್ ವೇರಿಯಬಲ್ ಅನ್ನು development ಗೆ ಹೊಂದಿಸುತ್ತದೆ. ನಿಮ್ಮ ಅಪ್ಲಿಕೇಶನ್ ಅನ್ನು ಡೆವಲಪ್‌ಮೆಂಟ್ ಮೋಡ್‌ನಲ್ಲಿ ಚಲಾಯಿಸಲು ಕಾನ್ಫಿಗರ್ ಮಾಡಲು ಇದು ಉಪಯುಕ್ತವಾಗಿದೆ.
• command: npm run dev: ಡಾಕರ್ಫೈಲ್‌ನಲ್ಲಿ ವಿವರಿಸಿದ ಡೀಫಾಲ್ಟ್ ಕಮಾಂಡ್ ಅನ್ನು ಓವರ್‌ರೈಡ್ ಮಾಡುತ್ತದೆ. ಈ ಸಂದರ್ಭದಲ್ಲಿ, ನಾವು npm run dev ಅನ್ನು ಬಳಸುತ್ತಿದ್ದೇವೆ, ಇದನ್ನು ಸಾಮಾನ್ಯವಾಗಿ ಹಾಟ್ ರಿಲೋಡಿಂಗ್‌ನೊಂದಿಗೆ ಡೆವಲಪ್‌ಮೆಂಟ್ ಸರ್ವರ್ ಅನ್ನು ಪ್ರಾರಂಭಿಸಲು ಬಳಸಲಾಗುತ್ತದೆ.

ಡಾಕರ್ ಕಂಪೋಸ್ ಬಳಸಿ ಅಪ್ಲಿಕೇಶನ್ ಅನ್ನು ಪ್ರಾರಂಭಿಸಲು, docker-compose.yml ಫೈಲ್ ಹೊಂದಿರುವ ಡೈರೆಕ್ಟರಿಗೆ ನ್ಯಾವಿಗೇಟ್ ಮಾಡಿ ಮತ್ತು ಈ ಕೆಳಗಿನ ಕಮಾಂಡ್ ಅನ್ನು ಚಲಾಯಿಸಿ:

docker-compose up

ಡಾಕರ್ ಕಂಪೋಸ್ ಇಮೇಜ್ ಅನ್ನು ನಿರ್ಮಿಸುತ್ತದೆ (ಅಗತ್ಯವಿದ್ದರೆ) ಮತ್ತು ಕಂಟೇನರ್ ಅನ್ನು ಪ್ರಾರಂಭಿಸುತ್ತದೆ. ಕಂಟೇನರ್ ಅನ್ನು ಡಿಟ್ಯಾಚ್ಡ್ ಮೋಡ್‌ನಲ್ಲಿ (ಹಿನ್ನೆಲೆಯಲ್ಲಿ) ಚಲಾಯಿಸಲು -d ಫ್ಲ್ಯಾಗ್ ಅನ್ನು ಸೇರಿಸಬಹುದು.

ಸುಧಾರಿತ ಕಾನ್ಫಿಗರೇಶನ್ ಆಯ್ಕೆಗಳು

ನಿಮ್ಮ ಡಾಕರೀಕರಿಸಿದ ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಅಭಿವೃದ್ಧಿ ಪರಿಸರವನ್ನು ಹೆಚ್ಚಿಸಲು ಕೆಲವು ಸುಧಾರಿತ ಕಾನ್ಫಿಗರೇಶನ್ ಆಯ್ಕೆಗಳು ಇಲ್ಲಿವೆ:

1. ಬಹು-ಹಂತದ ಬಿಲ್ಡ್‌ಗಳು

ಬಹು-ಹಂತದ ಬಿಲ್ಡ್‌ಗಳು ನಿಮ್ಮ Dockerfile ನಲ್ಲಿ ಬಹು FROM ಸೂಚನೆಗಳನ್ನು ಬಳಸಲು ಅನುವು ಮಾಡಿಕೊಡುತ್ತವೆ, ಪ್ರತಿಯೊಂದೂ ವಿಭಿನ್ನ ಬಿಲ್ಡ್ ಹಂತವನ್ನು ಪ್ರತಿನಿಧಿಸುತ್ತದೆ. ಬಿಲ್ಡ್ ಪರಿಸರವನ್ನು ರನ್‌ಟೈಮ್ ಪರಿಸರದಿಂದ ಪ್ರತ್ಯೇಕಿಸುವ ಮೂಲಕ ನಿಮ್ಮ ಅಂತಿಮ ಇಮೇಜ್‌ನ ಗಾತ್ರವನ್ನು ಕಡಿಮೆ ಮಾಡಲು ಇದು ಉಪಯುಕ್ತವಾಗಿದೆ.

# ಹಂತ 1: ಅಪ್ಲಿಕೇಶನ್ ಅನ್ನು ನಿರ್ಮಿಸಿ
FROM node:18-alpine AS builder
WORKDIR /app
COPY package*.json ./
RUN npm install
COPY . .
RUN npm run build

# ಹಂತ 2: ರನ್‌ಟೈಮ್ ಇಮೇಜ್ ಅನ್ನು ರಚಿಸಿ
FROM nginx:alpine
COPY --from=builder /app/dist /usr/share/nginx/html
EXPOSE 80
CMD ["nginx", "-g", "daemon off;"]

ಈ ಉದಾಹರಣೆಯಲ್ಲಿ, ಮೊದಲ ಹಂತ (builder) Node.js ಬಳಸಿ ಅಪ್ಲಿಕೇಶನ್ ಅನ್ನು ನಿರ್ಮಿಸುತ್ತದೆ. ಎರಡನೇ ಹಂತವು ನಿರ್ಮಿಸಿದ ಅಪ್ಲಿಕೇಶನ್ ಫೈಲ್‌ಗಳನ್ನು ಸರ್ವ್ ಮಾಡಲು Nginx ಅನ್ನು ಬಳಸುತ್ತದೆ. ಮೊದಲ ಹಂತದಿಂದ ನಿರ್ಮಿಸಲಾದ ಫೈಲ್‌ಗಳನ್ನು ಮಾತ್ರ ಎರಡನೇ ಹಂತಕ್ಕೆ ಕಾಪಿ ಮಾಡಲಾಗುತ್ತದೆ, ಇದರ ಪರಿಣಾಮವಾಗಿ ಸಣ್ಣ ಮತ್ತು ಹೆಚ್ಚು ದಕ್ಷ ಇಮೇಜ್ ಆಗುತ್ತದೆ.

2. ಎನ್ವಿರಾನ್ಮೆಂಟ್ ವೇರಿಯಬಲ್‌ಗಳನ್ನು ಬಳಸುವುದು

ಕೋಡ್ ಅನ್ನು ಮಾರ್ಪಡಿಸದೆ ನಿಮ್ಮ ಅಪ್ಲಿಕೇಶನ್ ಅನ್ನು ಕಾನ್ಫಿಗರ್ ಮಾಡಲು ಎನ್ವಿರಾನ್ಮೆಂಟ್ ವೇರಿಯಬಲ್‌ಗಳು ಒಂದು ಶಕ್ತಿಯುತ ಮಾರ್ಗವಾಗಿದೆ. ನಿಮ್ಮ docker-compose.yml ಫೈಲ್‌ನಲ್ಲಿ ಎನ್ವಿರಾನ್ಮೆಂಟ್ ವೇರಿಯಬಲ್‌ಗಳನ್ನು ಡಿಫೈನ್ ಮಾಡಬಹುದು ಅಥವಾ -e ಫ್ಲ್ಯಾಗ್ ಬಳಸಿ ರನ್‌ಟೈಮ್‌ನಲ್ಲಿ ಅವುಗಳನ್ನು ಪಾಸ್ ಮಾಡಬಹುದು.

services:
  app:
    environment:
      API_URL: "http://api.example.com"

ನಿಮ್ಮ ಅಪ್ಲಿಕೇಶನ್‌ನೊಳಗೆ, ನೀವು process.env ಬಳಸಿ ಈ ಎನ್ವಿರಾನ್ಮೆಂಟ್ ವೇರಿಯಬಲ್‌ಗಳನ್ನು ಪ್ರವೇಶಿಸಬಹುದು.

const apiUrl = process.env.API_URL;

3. ಅಭಿವೃದ್ಧಿಗಾಗಿ ವಾಲ್ಯೂಮ್ ಮೌಂಟಿಂಗ್

ವಾಲ್ಯೂಮ್ ಮೌಂಟಿಂಗ್ (ಡಾಕರ್ ಕಂಪೋಸ್ ಉದಾಹರಣೆಯಲ್ಲಿ ತೋರಿಸಿರುವಂತೆ) ಅಭಿವೃದ್ಧಿಗೆ ನಿರ್ಣಾಯಕವಾಗಿದೆ ಏಕೆಂದರೆ ಇದು ನಿಮ್ಮ ಹೋಸ್ಟ್ ಯಂತ್ರದಲ್ಲಿ ನಿಮ್ಮ ಕೋಡ್‌ಗೆ ಬದಲಾವಣೆಗಳನ್ನು ಮಾಡಲು ಮತ್ತು ಅವುಗಳನ್ನು ತಕ್ಷಣವೇ ಕಂಟೇನರ್‌ನೊಳಗೆ ಪ್ರತಿಫಲಿಸಲು ಅನುವು ಮಾಡಿಕೊಡುತ್ತದೆ. ಇದು ನೀವು ಬದಲಾವಣೆ ಮಾಡಿದಾಗಲೆಲ್ಲಾ ಇಮೇಜ್ ಅನ್ನು ಪುನರ್ನಿರ್ಮಿಸುವ ಅಗತ್ಯವನ್ನು ನಿವಾರಿಸುತ್ತದೆ.

4. VS ಕೋಡ್‌ನೊಂದಿಗೆ ಡೀಬಗ್ಗಿಂಗ್

ಡಾಕರ್ ಕಂಟೇನರ್‌ಗಳೊಳಗೆ ಚಾಲನೆಯಲ್ಲಿರುವ Node.js ಅಪ್ಲಿಕೇಶನ್‌ಗಳನ್ನು ಡೀಬಗ್ ಮಾಡಲು VS ಕೋಡ್ ಅತ್ಯುತ್ತಮ ಬೆಂಬಲವನ್ನು ಹೊಂದಿದೆ. ಚಾಲನೆಯಲ್ಲಿರುವ ಕಂಟೇನರ್‌ಗೆ ಅಟ್ಯಾಚ್ ಮಾಡಲು ಮತ್ತು ಬ್ರೇಕ್‌ಪಾಯಿಂಟ್‌ಗಳನ್ನು ಹೊಂದಿಸಲು, ವೇರಿಯಬಲ್‌ಗಳನ್ನು ಪರಿಶೀಲಿಸಲು ಮತ್ತು ನಿಮ್ಮ ಕೋಡ್ ಮೂಲಕ ಹಂತ ಹಂತವಾಗಿ ಸಾಗಲು ನೀವು VS ಕೋಡ್ ಡಾಕರ್ ವಿಸ್ತರಣೆಯನ್ನು ಬಳಸಬಹುದು.

ಮೊದಲು, VS ಕೋಡ್‌ನಲ್ಲಿ ಡಾಕರ್ ವಿಸ್ತರಣೆಯನ್ನು ಇನ್‌ಸ್ಟಾಲ್ ಮಾಡಿ. ನಂತರ, ನಿಮ್ಮ .vscode ಡೈರೆಕ್ಟರಿಯಲ್ಲಿ ಈ ಕೆಳಗಿನ ಕಾನ್ಫಿಗರೇಶನ್‌ನೊಂದಿಗೆ launch.json ಫೈಲ್ ಅನ್ನು ರಚಿಸಿ:

{
  "version": "0.2.0",
  "configurations": [
    {
      "type": "node",
      "request": "attach",
      "name": "Attach to Docker",
      "port": 9229,
      "address": "localhost",
      "remoteRoot": "/app",
      "localRoot": "${workspaceFolder}"
    }
  ]
}

ನಿಮ್ಮ Node.js ಅಪ್ಲಿಕೇಶನ್ --inspect ಅಥವಾ --inspect-brk ಫ್ಲ್ಯಾಗ್‌ನೊಂದಿಗೆ ಪ್ರಾರಂಭವಾಗಿದೆ ಎಂದು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಿ. ಉದಾಹರಣೆಗೆ, ಈ ಫ್ಲ್ಯಾಗ್ ಅನ್ನು ಸೇರಿಸಲು ನಿಮ್ಮ docker-compose.yml ಫೈಲ್ ಅನ್ನು ನೀವು ಮಾರ್ಪಡಿಸಬಹುದು:

services:
  app:
    command: npm run dev -- --inspect=0.0.0.0:9229

ನಂತರ, VS ಕೋಡ್‌ನಲ್ಲಿ, "Attach to Docker" ಕಾನ್ಫಿಗರೇಶನ್ ಅನ್ನು ಆಯ್ಕೆಮಾಡಿ ಮತ್ತು ಡೀಬಗ್ಗಿಂಗ್ ಪ್ರಾರಂಭಿಸಿ. ನೀವು ಬ್ರೇಕ್‌ಪಾಯಿಂಟ್‌ಗಳನ್ನು ಹೊಂದಿಸಲು ಮತ್ತು ಕಂಟೇನರ್‌ನೊಳಗೆ ಚಾಲನೆಯಲ್ಲಿರುವ ನಿಮ್ಮ ಕೋಡ್ ಅನ್ನು ಡೀಬಗ್ ಮಾಡಲು ಸಾಧ್ಯವಾಗುತ್ತದೆ.

5. ಖಾಸಗಿ npm ರಿಜಿಸ್ಟ್ರಿ ಬಳಸುವುದು

ನೀವು ಖಾಸಗಿ npm ಪ್ಯಾಕೇಜ್‌ಗಳೊಂದಿಗೆ ಪ್ರಾಜೆಕ್ಟ್‌ನಲ್ಲಿ ಕೆಲಸ ಮಾಡುತ್ತಿದ್ದರೆ, ನಿಮ್ಮ ಡಾಕರ್ ಕಂಟೇನರ್ ಅನ್ನು ನಿಮ್ಮ ಖಾಸಗಿ npm ರಿಜಿಸ್ಟ್ರಿಯೊಂದಿಗೆ ದೃಢೀಕರಿಸಲು ಕಾನ್ಫಿಗರ್ ಮಾಡಬೇಕಾಗುತ್ತದೆ. ನಿಮ್ಮ docker-compose.yml ಫೈಲ್‌ನಲ್ಲಿ NPM_TOKEN ಎನ್ವಿರಾನ್ಮೆಂಟ್ ವೇರಿಯಬಲ್ ಅನ್ನು ಹೊಂದಿಸುವ ಮೂಲಕ ಅಥವಾ ನಿಮ್ಮ ಪ್ರಾಜೆಕ್ಟ್ ಡೈರೆಕ್ಟರಿಯಲ್ಲಿ .npmrc ಫೈಲ್ ಅನ್ನು ರಚಿಸಿ ಮತ್ತು ಅದನ್ನು ಕಂಟೇನರ್‌ಗೆ ಕಾಪಿ ಮಾಡುವ ಮೂಲಕ ಇದನ್ನು ಮಾಡಬಹುದು.

# Dockerfile
FROM node:18-alpine
WORKDIR /app
COPY package*.json ./
COPY .npmrc .
RUN npm install
COPY . .
EXPOSE 3000
CMD ["npm", "start"]

.npmrc ಫೈಲ್ ನಿಮ್ಮ ದೃಢೀಕರಣ ಟೋಕನ್ ಅನ್ನು ಒಳಗೊಂಡಿರಬೇಕು:

//registry.npmjs.org/:_authToken=YOUR_NPM_TOKEN

YOUR_NPM_TOKEN ಅನ್ನು ನಿಮ್ಮ ನಿಜವಾದ npm ಟೋಕನ್‌ನೊಂದಿಗೆ ಬದಲಾಯಿಸಲು ಮರೆಯದಿರಿ. ಈ ಟೋಕನ್ ಅನ್ನು ಸುರಕ್ಷಿತವಾಗಿರಿಸಿ ಮತ್ತು ಅದನ್ನು ನಿಮ್ಮ ಸಾರ್ವಜನಿಕ ರೆಪೊಸಿಟರಿಗೆ ಕಮಿಟ್ ಮಾಡಬೇಡಿ.

6. ಇಮೇಜ್ ಗಾತ್ರವನ್ನು ಆಪ್ಟಿಮೈಜ್ ಮಾಡುವುದು

ನಿಮ್ಮ ಡಾಕರ್ ಇಮೇಜ್ ಗಾತ್ರವನ್ನು ಚಿಕ್ಕದಾಗಿಡುವುದು ವೇಗದ ಬಿಲ್ಡ್ ಮತ್ತು ನಿಯೋಜನೆ ಸಮಯಗಳಿಗೆ ಮುಖ್ಯವಾಗಿದೆ. ಇಮೇಜ್ ಗಾತ್ರವನ್ನು ಆಪ್ಟಿಮೈಜ್ ಮಾಡಲು ಕೆಲವು ಸಲಹೆಗಳು ಇಲ್ಲಿವೆ:

• node:alpine ನಂತಹ ಹಗುರವಾದ ಬೇಸ್ ಇಮೇಜ್ ಬಳಸಿ.
• ಬಿಲ್ಡ್ ಪರಿಸರವನ್ನು ರನ್‌ಟೈಮ್ ಪರಿಸರದಿಂದ ಪ್ರತ್ಯೇಕಿಸಲು ಬಹು-ಹಂತದ ಬಿಲ್ಡ್‌ಗಳನ್ನು ಬಳಸಿ.
• ಇಮೇಜ್‌ನಿಂದ ಅನಗತ್ಯ ಫೈಲ್‌ಗಳು ಮತ್ತು ಡೈರೆಕ್ಟರಿಗಳನ್ನು ತೆಗೆದುಹಾಕಿ.
• ಬಿಲ್ಡ್ ಸಂದರ್ಭದಿಂದ ಫೈಲ್‌ಗಳು ಮತ್ತು ಡೈರೆಕ್ಟರಿಗಳನ್ನು ಹೊರಗಿಡಲು .dockerignore ಫೈಲ್ ಬಳಸಿ.
• ಪದರಗಳ ಸಂಖ್ಯೆಯನ್ನು ಕಡಿಮೆ ಮಾಡಲು ಬಹು RUN ಕಮಾಂಡ್‌ಗಳನ್ನು ಒಂದೇ ಕಮಾಂಡ್ ಆಗಿ ಸಂಯೋಜಿಸಿ.

ಉದಾಹರಣೆ: ರಿಯಾಕ್ಟ್ ಅಪ್ಲಿಕೇಶನ್ ಅನ್ನು ಡಾಕರೀಕರಿಸುವುದು

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

ಮೊದಲು, ಕ್ರಿಯೇಟ್ ರಿಯಾಕ್ಟ್ ಆಪ್ ಬಳಸಿ ಹೊಸ ರಿಯಾಕ್ಟ್ ಅಪ್ಲಿಕೇಶನ್ ಅನ್ನು ರಚಿಸಿ:

npx create-react-app my-react-app
cd my-react-app

ನಂತರ, ಪ್ರಾಜೆಕ್ಟ್‌ನ ರೂಟ್ ಡೈರೆಕ್ಟರಿಯಲ್ಲಿ Dockerfile ಅನ್ನು ರಚಿಸಿ:

FROM node:18-alpine AS builder
WORKDIR /app
COPY package*.json ./
RUN npm install
COPY . .
RUN npm run build

FROM nginx:alpine
COPY --from=builder /app/build /usr/share/nginx/html
EXPOSE 80
CMD ["nginx", "-g", "daemon off;"]

docker-compose.yml ಫೈಲ್ ಅನ್ನು ರಚಿಸಿ:

version: "3.9"
services:
  app:
    build: .
    ports:
      - "3000:80"
    volumes:
      - .:/app
    environment:
      NODE_ENV: development

ಗಮನಿಸಿ: ನಾವು ಹೋಸ್ಟ್‌ನಲ್ಲಿನ ಪೋರ್ಟ್ 3000 ಅನ್ನು ಕಂಟೇನರ್‌ನೊಳಗಿನ ಪೋರ್ಟ್ 80 ಗೆ ಮ್ಯಾಪ್ ಮಾಡುತ್ತಿದ್ದೇವೆ ಏಕೆಂದರೆ Nginx ಅಪ್ಲಿಕೇಶನ್ ಅನ್ನು ಪೋರ್ಟ್ 80 ರಲ್ಲಿ ಸರ್ವ್ ಮಾಡುತ್ತಿದೆ. ನಿಮ್ಮ ಅಪ್ಲಿಕೇಶನ್‌ನ ಕಾನ್ಫಿಗರೇಶನ್‌ಗೆ ಅನುಗುಣವಾಗಿ ನೀವು ಪೋರ್ಟ್ ಮ್ಯಾಪಿಂಗ್ ಅನ್ನು ಹೊಂದಿಸಬೇಕಾಗಬಹುದು.

ಅಂತಿಮವಾಗಿ, ಅಪ್ಲಿಕೇಶನ್ ಅನ್ನು ನಿರ್ಮಿಸಲು ಮತ್ತು ಪ್ರಾರಂಭಿಸಲು docker-compose up ಅನ್ನು ಚಲಾಯಿಸಿ. ನಂತರ ನೀವು ನಿಮ್ಮ ಬ್ರೌಸರ್‌ನಲ್ಲಿ localhost:3000 ಗೆ ನ್ಯಾವಿಗೇಟ್ ಮಾಡುವ ಮೂಲಕ ಅಪ್ಲಿಕೇಶನ್ ಅನ್ನು ಪ್ರವೇಶಿಸಬಹುದು.

ಸಾಮಾನ್ಯ ಸಮಸ್ಯೆಗಳು ಮತ್ತು ದೋಷನಿವಾರಣೆ

ಎಚ್ಚರಿಕೆಯ ಕಾನ್ಫಿಗರೇಶನ್‌ನೊಂದಿಗೆ ಸಹ, ಡಾಕರ್‌ನೊಂದಿಗೆ ಕೆಲಸ ಮಾಡುವಾಗ ನೀವು ಸಮಸ್ಯೆಗಳನ್ನು ಎದುರಿಸಬಹುದು. ಕೆಲವು ಸಾಮಾನ್ಯ ಸಮಸ್ಯೆಗಳು ಮತ್ತು ಅವುಗಳ ಪರಿಹಾರಗಳು ಇಲ್ಲಿವೆ:

• ಪೋರ್ಟ್ ಸಂಘರ್ಷಗಳು: ನಿಮ್ಮ docker-compose.yml ಅಥವಾ docker run ಕಮಾಂಡ್‌ನಲ್ಲಿ ನೀವು ಮ್ಯಾಪ್ ಮಾಡುತ್ತಿರುವ ಪೋರ್ಟ್‌ಗಳು ನಿಮ್ಮ ಹೋಸ್ಟ್ ಯಂತ್ರದಲ್ಲಿನ ಇತರ ಅಪ್ಲಿಕೇಶನ್‌ಗಳಿಂದ ಈಗಾಗಲೇ ಬಳಕೆಯಲ್ಲಿಲ್ಲ ಎಂದು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಿ.
• ವಾಲ್ಯೂಮ್ ಮೌಂಟಿಂಗ್ ಸಮಸ್ಯೆಗಳು: ನೀವು ಮೌಂಟ್ ಮಾಡುತ್ತಿರುವ ಫೈಲ್‌ಗಳು ಮತ್ತು ಡೈರೆಕ್ಟರಿಗಳ ಅನುಮತಿಗಳನ್ನು ಪರಿಶೀಲಿಸಿ. ಫೈಲ್‌ಗಳನ್ನು ಪ್ರವೇಶಿಸಲು ಡಾಕರ್‌ಗೆ ಅಗತ್ಯವಾದ ಅನುಮತಿಗಳು ಇಲ್ಲದಿರಬಹುದು.
• ಇಮೇಜ್ ಬಿಲ್ಡ್ ವೈಫಲ್ಯಗಳು: ದೋಷಗಳಿಗಾಗಿ docker build ಕಮಾಂಡ್‌ನ ಔಟ್‌ಪುಟ್ ಅನ್ನು ಎಚ್ಚರಿಕೆಯಿಂದ ಪರಿಶೀಲಿಸಿ. ಸಾಮಾನ್ಯ ಕಾರಣಗಳಲ್ಲಿ ತಪ್ಪಾದ Dockerfile ಸಿಂಟ್ಯಾಕ್ಸ್, ಕಾಣೆಯಾದ ಡಿಪೆಂಡೆನ್ಸಿಗಳು, ಅಥವಾ ನೆಟ್‌ವರ್ಕ್ ಸಮಸ್ಯೆಗಳು ಸೇರಿವೆ.
• ಕಂಟೇನರ್ ಕ್ರ್ಯಾಶ್‌ಗಳು: ನಿಮ್ಮ ಕಂಟೇನರ್‌ನ ಲಾಗ್‌ಗಳನ್ನು ವೀಕ್ಷಿಸಲು ಮತ್ತು ಕ್ರ್ಯಾಶ್‌ನ ಕಾರಣವನ್ನು ಗುರುತಿಸಲು docker logs ಕಮಾಂಡ್ ಬಳಸಿ. ಸಾಮಾನ್ಯ ಕಾರಣಗಳಲ್ಲಿ ಅಪ್ಲಿಕೇಶನ್ ದೋಷಗಳು, ಕಾಣೆಯಾದ ಎನ್ವಿರಾನ್ಮೆಂಟ್ ವೇರಿಯಬಲ್‌ಗಳು, ಅಥವಾ ಸಂಪನ್ಮೂಲ ನಿರ್ಬಂಧಗಳು ಸೇರಿವೆ.
• ನಿಧಾನ ಬಿಲ್ಡ್ ಸಮಯಗಳು: ಬಹು-ಹಂತದ ಬಿಲ್ಡ್‌ಗಳನ್ನು ಬಳಸಿಕೊಂಡು, ಡಿಪೆಂಡೆನ್ಸಿಗಳನ್ನು ಕ್ಯಾಶ್ ಮಾಡುವ ಮೂಲಕ, ಮತ್ತು ಪದರಗಳ ಸಂಖ್ಯೆಯನ್ನು ಕಡಿಮೆ ಮಾಡುವ ಮೂಲಕ ನಿಮ್ಮ Dockerfile ಅನ್ನು ಆಪ್ಟಿಮೈಜ್ ಮಾಡಿ.

ತೀರ್ಮಾನ

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

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

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

• ನಿಮ್ಮ ನಿರ್ದಿಷ್ಟ ಅಗತ್ಯಗಳಿಗೆ ಸರಿಹೊಂದುವ ಪೂರ್ವ-ನಿರ್ಮಿತ ಇಮೇಜ್‌ಗಳಿಗಾಗಿ ಡಾಕರ್ ಹಬ್ ಅನ್ನು ಅನ್ವೇಷಿಸಿ.
• ಬಹು-ಕಂಟೇನರ್ ಅಪ್ಲಿಕೇಶನ್‌ಗಳನ್ನು ನಿರ್ವಹಿಸಲು ಡಾಕರ್ ಕಂಪೋಸ್‌ನ ಬಗ್ಗೆ ಆಳವಾಗಿ ತಿಳಿಯಿರಿ.
• ಉತ್ಪಾದನಾ ಪರಿಸರದಲ್ಲಿ ಡಾಕರ್ ಕಂಟೇನರ್‌ಗಳನ್ನು ಸಂಘಟಿಸಲು ಡಾಕರ್ ಸ್ವಾರ್ಮ್ ಮತ್ತು ಕುಬರ್ನೆಟೀಸ್ ಬಗ್ಗೆ ತಿಳಿಯಿರಿ.

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