ಕಳೆದ ಕೆಲವು ವರ್ಷಗಳಲ್ಲಿ ನೀವು ಪ್ರೋಗ್ರಾಮಿಂಗ್ ಜಗತ್ತಿನ ಇತ್ತೀಚಿನ ಬೆಳವಣಿಗೆಗಳೊಂದಿಗೆ ಸಂಪರ್ಕದಲ್ಲಿದ್ದರೆ, ಡಾಕರ್ ಮತ್ತು ಡಾಕರ್ ಕಂಟೇನರ್ಗಳನ್ನು ಸುತ್ತುವರೆದಿರುವ ದೊಡ್ಡ ಬ zz ್ ಅನ್ನು ನೀವು ಗಮನಿಸಿರಬಹುದು. ಡಾಕರ್ನ ಈ ಜನಪ್ರಿಯತೆಯು ಕಾರಣವಿಲ್ಲದೆ ಅಲ್ಲ. ಡೆವಲಪರ್ಗಳು ಅಪ್ಲಿಕೇಶನ್ ಅಭಿವೃದ್ಧಿಯನ್ನು ಹೇಗೆ ಸಂಪರ್ಕಿಸುತ್ತಾರೆ ಎಂಬುದನ್ನು ಡಾಕರ್ನ ಪರಿಚಯವು ಬಹಳವಾಗಿ ಬದಲಾಯಿಸಿದೆ.
ಇಂತಹ ಕ್ರಾಂತಿಕಾರಕ ತಂತ್ರಜ್ಞಾನವು ಪ್ರೋಗ್ರಾಮಿಂಗ್ ಜಗತ್ತನ್ನು ಮುಟ್ಟಿದಾಗ ಯಾರು ಹಿಂದೆ ಉಳಿಯಲು ಬಯಸುತ್ತಾರೆ? ಆದ್ದರಿಂದ, ಅಪ್ಲಿಕೇಶನ್ ಅಭಿವೃದ್ಧಿಗೆ ಡಾಕರ್ ಅನ್ನು ಹೇಗೆ ಬಳಸುವುದು ಎಂದು ತಿಳಿಯಲು ನಾವು ಇಂದು ಹೊಸ ಟ್ಯುಟೋರಿಯಲ್ ಸರಣಿಯನ್ನು ಪ್ರಾರಂಭಿಸುತ್ತಿದ್ದೇವೆ. ನೀವು ಡಾಕರ್ಗೆ ಸಂಪೂರ್ಣ ಹರಿಕಾರರಾಗಿದ್ದರೆ, ಈ ಟ್ಯುಟೋರಿಯಲ್ ಸರಣಿಯು ನಿಮಗೆ ಪ್ರಾರಂಭಿಸಲು ಸರಿಯಾದ ಸ್ಥಳವಾಗಿದೆ.
ನಮ್ಮ ಟ್ಯುಟೋರಿಯಲ್ ಸರಣಿಯ ಮೊದಲ ಲೇಖನದಲ್ಲಿ, ಡಾಕರ್ ನಿಖರವಾಗಿ ಏನು ಮತ್ತು ಡೆವಲಪರ್ಗಳು ಡಾಕರ್ ಅನ್ನು ಏಕೆ ತುಂಬಾ ಪ್ರೀತಿಸುತ್ತಾರೆ ಎಂಬುದನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳಲು ನಾವು ನೋಡುತ್ತಿದ್ದೇವೆ. ಡಾಕರ್ನ ಮೂಲ ಪರಿಕಲ್ಪನೆಗಳನ್ನು ನಿಮಗೆ ಪರಿಚಯಿಸಲು ನಾವು ಸರಳವಾದ ನೋಡ್.ಜೆಎಸ್ ಅಪ್ಲಿಕೇಶನ್ ಅನ್ನು ಸಹ ಡಾಕರೈಸಿಂಗ್ ಮಾಡುತ್ತೇವೆ.
ಇನ್ನು ಮುಂದೆ ಏಕೆ ಕಾಯಬೇಕು? ಪ್ರಾರಂಭಿಸೋಣ!
ಡಾಕರ್ ಎನ್ನುವುದು ಅಪ್ಲಿಕೇಶನ್ಗಳನ್ನು ನಿರ್ಮಿಸಲು ಬಳಸುವ ಸಾಧನವಾಗಿದೆ; ಅಂದರೆ ಕಂಟೇನರ್ಗಳ ಮೂಲಕ ಅಪ್ಲಿಕೇಶನ್ಗಳನ್ನು ರಚಿಸುವುದು, ನಿಯೋಜಿಸುವುದು ಮತ್ತು ಚಲಾಯಿಸುವುದು.
ಕಂಟೇನರ್ನೊಂದಿಗೆ, ಎಲ್ಲಾ ಲೈಬ್ರರಿಗಳು ಮತ್ತು ಅಪ್ಲಿಕೇಶನ್ ಅನ್ನು ಚಲಾಯಿಸಲು ಅಗತ್ಯವಿರುವ ಇತರ ಅವಲಂಬನೆಗಳನ್ನು ನಿಯೋಜನೆಗಾಗಿ ಒಂದೇ ಪ್ಯಾಕೇಜ್ನಂತೆ ಪ್ಯಾಕ್ ಮಾಡಲಾಗುತ್ತದೆ.
ಅಪ್ಲಿಕೇಶನ್ ಅನ್ನು ಕಂಟೈನರೈಜ್ ಮಾಡುವ ಮುಖ್ಯ ಗುರಿ ಅದೇ ವ್ಯವಸ್ಥೆಯಲ್ಲಿ ಚಾಲನೆಯಲ್ಲಿರುವ ಇತರ ಅಪ್ಲಿಕೇಶನ್ಗಳಿಂದ ಅವುಗಳನ್ನು ಪ್ರತ್ಯೇಕಿಸುವುದು. ಈ ವಿಧಾನವು ಅಪ್ಲಿಕೇಶನ್ಗಳು ಪರಸ್ಪರ ಕಾರ್ಯಾಚರಣೆಯಲ್ಲಿ ಹಸ್ತಕ್ಷೇಪ ಮಾಡುವುದಿಲ್ಲ ಮತ್ತು ಅಪ್ಲಿಕೇಶನ್ ನಿರ್ವಹಣೆಯನ್ನು ಹೆಚ್ಚು ಸುಲಭಗೊಳಿಸುತ್ತದೆ ಎಂದು ಖಚಿತಪಡಿಸುತ್ತದೆ.
ಒಂದೇ ವ್ಯವಸ್ಥೆಯಲ್ಲಿ ಚಾಲನೆಯಲ್ಲಿರುವ ಪಾತ್ರೆಗಳು ಮರಣದಂಡನೆಯಲ್ಲಿ ಪರಸ್ಪರ ಪ್ರತ್ಯೇಕವಾಗಿದ್ದರೂ, ಅವು ಒಂದೇ ಓಎಸ್ ಕರ್ನಲ್ ಅನ್ನು ಹಂಚಿಕೊಳ್ಳುತ್ತವೆ. ಆದ್ದರಿಂದ, ಅಪ್ಲಿಕೇಶನ್ ಎಕ್ಸಿಕ್ಯೂಶನ್, ವರ್ಚುವಲ್ ಯಂತ್ರಗಳನ್ನು ಪ್ರತ್ಯೇಕಿಸುವ ಪರ್ಯಾಯ ಆಯ್ಕೆಗೆ ಹೋಲಿಸಿದರೆ ಕಂಟೇನರ್ಗಳು ಹೆಚ್ಚು ಹಗುರವಾಗಿರುತ್ತವೆ.
ನಿಮ್ಮ ವಿಂಡೋಸ್ ಓಎಸ್ನಲ್ಲಿ ಚಾಲನೆಯಲ್ಲಿರುವ ಕಂಟೇನರೈಸ್ಡ್ ಅಪ್ಲಿಕೇಶನ್ ಪರಿಸರದ ಬದಲಾವಣೆಯ ಹೊರತಾಗಿಯೂ ಇನ್ನೊಬ್ಬ ಬಳಕೆದಾರರ ವಿಂಡೋಸ್ ಯಂತ್ರದಲ್ಲಿ ಸಮಸ್ಯೆಯಿಲ್ಲದೆ ಚಲಿಸುವ ಭರವಸೆ ಇದೆ.
ಡಾಕರ್ಗೆ ಮೊದಲು ಕಂಟೇನರ್ಗಳು ಬಹಳ ಬಳಕೆಯಲ್ಲಿದ್ದರೂ, ಡಾಕರ್ನ ಪರಿಚಯವು ಡೆವಲಪರ್ ಸಮುದಾಯದಲ್ಲಿ ಕಂಟೇನರ್ಗಳನ್ನು ಬಳಸಿಕೊಂಡು ಜನಪ್ರಿಯಗೊಳಿಸಿತು. ಅಪ್ಲಿಕೇಶನ್ ಅನ್ನು ಡಾಕರೈಸ್ ಮಾಡುವಾಗ ಎರಡು ಘಟಕಗಳನ್ನು ಬಳಸಲಾಗುತ್ತದೆ: ಡಾಕರ್ಫೈಲ್ ಮತ್ತು ಡಾಕರ್ ಚಿತ್ರ . ಅವು ಯಾವುವು ಎಂಬುದನ್ನು ಕಂಡುಹಿಡಿಯೋಣ.
ಡಾಕರ್ಫೈಲ್ ಎನ್ನುವುದು ಪಠ್ಯ ಫೈಲ್ ಆಗಿದ್ದು ಅದು ಡಾಕರ್ ಚಿತ್ರವನ್ನು ನಿರ್ಮಿಸಲು ಅಗತ್ಯವಾದ ಆಜ್ಞೆಗಳ ಗುಂಪನ್ನು ಹೊಂದಿರುತ್ತದೆ. ಡಾಕರ್ಫೈಲ್ ಆಧಾರವಾಗಿರುವ ಓಎಸ್, ಭಾಷೆ, ಫೈಲ್ ಸ್ಥಳ ಮತ್ತು ನೆಟ್ವರ್ಕ್ ಪೋರ್ಟ್ಗಳ ಬಗ್ಗೆ ಮಾಹಿತಿಯನ್ನು ಒಳಗೊಂಡಿದೆ.
ನೀವು ಡಾಕರ್ಫೈಲ್ನೊಂದಿಗೆ ಡಾಕರ್ನ ಬಿಲ್ಡ್ ಆಜ್ಞೆಯನ್ನು ಚಲಾಯಿಸಿದಾಗ, ಡಾಕರ್ಫೈಲ್ ಅನ್ನು ಆಧರಿಸಿ ಡಾಕರ್ ಚಿತ್ರವನ್ನು ರಚಿಸಲಾಗುತ್ತದೆ. ಅಂತಿಮ ಡಾಕರ್ ಕಂಟೇನರ್ ರಚಿಸಲು ಅವು ಟೆಂಪ್ಲೆಟ್ಗಳಾಗಿ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತವೆ. ಒಮ್ಮೆ ರಚಿಸಿದ ನಂತರ, ಡಾಕರ್ ಚಿತ್ರಗಳು ಸ್ಥಿರವಾಗಿರುತ್ತದೆ. ಡಾಕರ್ ಚಿತ್ರವನ್ನು ಬಳಸಿಕೊಂಡು ಡಾಕರ್ ಕಂಟೇನರ್ ರಚಿಸಲು ನೀವು ಡಾಕರ್ ರನ್ ಆಜ್ಞೆಯನ್ನು ಆಹ್ವಾನಿಸಬಹುದು.
ಈ ಟ್ಯುಟೋರಿಯಲ್ ನಲ್ಲಿ, ನಾವು Node.js ಅಪ್ಲಿಕೇಶನ್ ಅನ್ನು ಡಾಕರೈಸ್ ಮಾಡಲು ಹೋಗುತ್ತೇವೆ. ಡಾಕರ್ ಕಂಟೇನರ್ ಅನ್ನು ಪಡೆಯಲು ಮತ್ತು ಚಾಲನೆಯಲ್ಲಿರಲು ನಾವು ಹಂತ ಹಂತವಾಗಿ ಅನುಸರಿಸುತ್ತೇವೆ.
1 - Node.js ಅಪ್ಲಿಕೇಶನ್ ಅನ್ನು ರಚಿಸಿ 2 - ಡಾಕರ್ ಫೈಲ್ 3 ಅನ್ನು ರಚಿಸಿ - ಡಾಕರ್ ಇಮೇಜ್ ಅನ್ನು ನಿರ್ಮಿಸಿ 4 - ಅಪ್ಲಿಕೇಶನ್ ಕಂಟೇನರ್ ರಚಿಸಿ
ನಮ್ಮ ಅಪ್ಲಿಕೇಶನ್ ಅನ್ನು ಡಾಕರೈಸಿಂಗ್ ಮಾಡುವ ಮೊದಲು, ನಿಮ್ಮ ಸಿಸ್ಟಂನಲ್ಲಿ ಡಾಕರ್ ಮತ್ತು ನೋಡ್.ಜೆಗಳನ್ನು ಸ್ಥಾಪಿಸಲಾಗಿದೆ ಎಂದು ನೀವು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಬೇಕು
ಆಜ್ಞಾ ಸಾಲಿನಿಂದ ಹೊಸ ಪ್ರಾಜೆಕ್ಟ್ ಡೈರೆಕ್ಟರಿಗೆ ನ್ಯಾವಿಗೇಟ್ ಮಾಡಿ ಮತ್ತು ಅಪ್ಲಿಕೇಶನ್ನ ಅವಲಂಬನೆಗಳ ಮಾಹಿತಿಯನ್ನು ಒಳಗೊಂಡಿರುವ ಪ್ಯಾಕೇಜ್.ಜೆಸನ್ ಫೈಲ್ ಅನ್ನು ರಚಿಸಲು ಈ ಕೆಳಗಿನ ಆಜ್ಞೆಯನ್ನು ಚಲಾಯಿಸಿ ಮತ್ತು ಸ್ಕ್ರಿಪ್ಟ್ ಪ್ರಾರಂಭಿಸಿ.
npm init -y
ನಂತರ, ಈ ಆಜ್ಞೆಯನ್ನು ಆಜ್ಞಾ ಸಾಲಿನಲ್ಲಿ ಚಲಾಯಿಸುವ ಮೂಲಕ ನಿಮ್ಮ ಅಪ್ಲಿಕೇಶನ್ಗೆ ಅವಲಂಬನೆಯಾಗಿ ಎಕ್ಸ್ಪ್ರೆಸ್ ಅನ್ನು ಸ್ಥಾಪಿಸಿ ಮತ್ತು ಸೇರಿಸಿ. ಅಪ್ಲಿಕೇಶನ್ ರಚಿಸಲು ನಾವು ಎಕ್ಸ್ಪ್ರೆಸ್ ಅನ್ನು ಬಳಸುತ್ತೇವೆ.
npm install express --save
ಇದು ನಮ್ಮ package.json
ಗೆ ಅವಲಂಬನೆಯಾಗಿ ಎಕ್ಸ್ಪ್ರೆಸ್ ಅನ್ನು ಸೇರಿಸುತ್ತದೆ ಫೈಲ್.
ಈಗ ನಾವು ಎಕ್ಸ್ಪ್ರೆಸ್ ಸಹಾಯದಿಂದ ನೋಡ್ ಅಪ್ಲಿಕೇಶನ್ ಅನ್ನು ರಚಿಸಬಹುದು.
app.js
ಹೆಸರಿನ ಫೈಲ್ ಅನ್ನು ರಚಿಸಿ ಪ್ರಾಜೆಕ್ಟ್ ಡೈರೆಕ್ಟರಿಯಲ್ಲಿ ಮತ್ತು ಕೆಳಗಿನ ಕೋಡ್ ಅನ್ನು ಫೈಲ್ಗೆ ಸೇರಿಸಿ.
const express = require('express') const app = express() app.get('/', (req, res) => {
res.send('Hello World!') }) app.listen(3000, () => {
console.log('Node server has started running') })
ಮೇಲಿನ ಕೋಡ್ 3000 ಪೋರ್ಟ್ನಲ್ಲಿ ಒಳಬರುವ ವಿನಂತಿಗಳನ್ನು ಆಲಿಸುವ ನೋಡ್ ಸರ್ವರ್ ಅನ್ನು ರಚಿಸುತ್ತದೆ. ನೋಡ್ ಸರ್ವರ್ ಅನ್ನು ಪ್ರಾರಂಭಿಸಲು ನೀವು ಈ ಆಜ್ಞೆಯನ್ನು ಆಜ್ಞಾ ಸಾಲಿನಲ್ಲಿ ಚಲಾಯಿಸಬಹುದು.
node app.js
ಈಗ ನಿಮ್ಮ ಬ್ರೌಸರ್ಗೆ ಹೋಗಿ ಮತ್ತು URL http://localhost:3000
ಅನ್ನು ಅನುಸರಿಸಿ ಮತ್ತು ನೀವು Hello World!
ಪಠ್ಯವನ್ನು ನೋಡುತ್ತೀರಿ ಪುಟದಲ್ಲಿ.
ನಮ್ಮ ಯೋಜನೆಗಾಗಿ ನಾವು ಸರಳ ನೋಡ್ ಅಪ್ಲಿಕೇಶನ್ ಅನ್ನು ನಿರ್ಮಿಸಿದ್ದೇವೆ. ಈಗ ಡಾಕರ್ಫೈಲ್ ರಚಿಸಲು ಮುಂದುವರಿಯೋಣ.
ಡಾಕರ್ಫೈಲ್ನಲ್ಲಿ, ಡಾಕರ್ ಪರಿಸರದೊಂದಿಗೆ ನಮ್ಮ ನೋಡ್ ಅಪ್ಲಿಕೇಶನ್ ಅನ್ನು ನಿರ್ಮಿಸಲು ಮತ್ತು ಚಲಾಯಿಸಲು ಅಗತ್ಯವಾದ ಮಾಹಿತಿಯನ್ನು ನಾವು ಒದಗಿಸುತ್ತೇವೆ.
ಅಪ್ಲಿಕೇಶನ್ನಲ್ಲಿ ಬಳಸಲಾದ ಭಾಷೆ ಮತ್ತು ಅದರ ಆವೃತ್ತಿಯನ್ನು ನಿರ್ದಿಷ್ಟಪಡಿಸುವುದು, ನಮ್ಮ ಪ್ರಾಜೆಕ್ಟ್ ಡೈರೆಕ್ಟರಿಯನ್ನು ವರ್ಕಿಂಗ್ ಡೈರೆಕ್ಟರಿಯಂತೆ ಹೊಂದಿಸುವುದು, ವರ್ಕಿಂಗ್ ಡೈರೆಕ್ಟರಿಯಲ್ಲಿನ ಎಲ್ಲಾ ಫೈಲ್ಗಳನ್ನು ನಕಲಿಸುವುದು, ನೆಟ್ವರ್ಕ್ ಪೋರ್ಟ್ ಅನ್ನು ಹೊಂದಿಸುವುದು ಮತ್ತು ಯಾವ ಫೈಲ್ ಅನ್ನು ಅಪ್ಲಿಕೇಶನ್ಗೆ ಪ್ರವೇಶ ಬಿಂದು ಎಂದು ನಿರ್ದಿಷ್ಟಪಡಿಸುವುದು ಇದರಲ್ಲಿ ಸೇರಿದೆ. ಹೆಚ್ಚು ಸಂಕೀರ್ಣವಾದ ಅಪ್ಲಿಕೇಶನ್ಗಳಲ್ಲಿ, ನೀವು ಪರಿಸರ ಅಸ್ಥಿರಗಳನ್ನು ಮತ್ತು ಡೇಟಾಬೇಸ್ URL ಅನ್ನು ಡಾಕರ್ಫೈಲ್ನಲ್ಲಿ ಹೊಂದಿಸಬೇಕಾಗುತ್ತದೆ.
FROM node:latest WORKDIR /dockerTutorial COPY . . RUN npm install EXPOSE 3000 ENTRYPOINT ['node', 'app.js']
package.json
ನಲ್ಲಿ ನಿರ್ದಿಷ್ಟಪಡಿಸಿದ ಎಲ್ಲಾ ಅವಲಂಬನೆಗಳನ್ನು ಒಳಗೊಂಡಿದೆ ಫೈಲ್.node app.js
.ಡಾಕರ್ಫೈಲ್ನಿಂದ ಡಾಕರ್ ಚಿತ್ರವನ್ನು ರಚಿಸಲು ಈ ಕೆಳಗಿನ ಆಜ್ಞೆಯನ್ನು ಬಳಸಿ.
docker build -t docker-tutorial .
Docker-tutorial
ಇದು ಡಾಕರ್ ಚಿತ್ರದ ಹೆಸರು. ಪ್ರಾಜೆಕ್ಟ್ ಡೈರೆಕ್ಟರಿಗೆ ಫೈಲ್ ಪಥವನ್ನು ಡಾಟ್ ಸೂಚಿಸುತ್ತದೆ, ಅದು ನಾವು ಪ್ರಸ್ತುತ ಆಜ್ಞಾ ಸಾಲಿನಲ್ಲಿರುತ್ತೇವೆ.
ಓಎಸ್ ಚಿತ್ರವನ್ನು ನಿರ್ದಿಷ್ಟಪಡಿಸಿದರೆ FROM ಆಜ್ಞೆ, ನೋಡ್: ಇತ್ತೀಚಿನದು , ಈ ಸಮಯದಲ್ಲಿ ನಿಮ್ಮ ಸಾಧನದಲ್ಲಿಲ್ಲ, ನೀವು ಮೇಲಿನ ಆಜ್ಞೆಯನ್ನು ಚಲಾಯಿಸುವಾಗ ಅದನ್ನು ಡಾಕರ್ ಹಬ್ನಿಂದ ಎಳೆಯಲಾಗುತ್ತದೆ.
ಚಿತ್ರವನ್ನು ಎಳೆದ ನಂತರ, ಡಾಕರ್ಫೈಲ್ನಲ್ಲಿನ ಪ್ರತಿಯೊಂದು ಆಜ್ಞೆಯನ್ನು ಒಂದೊಂದಾಗಿ ಕಾರ್ಯಗತಗೊಳಿಸಲಾಗುತ್ತದೆ.
ಮರಣದಂಡನೆಯ ಕೊನೆಯಲ್ಲಿ, ನೀವು ಸಂದೇಶವನ್ನು ನೋಡಿದರೆ ಯಶಸ್ವಿಯಾಗಿ ನಿರ್ಮಿಸಲಾಗಿದೆ , ಅಪ್ಲಿಕೇಶನ್ನ ಡಾಕರ್ ಚಿತ್ರವನ್ನು ಯಶಸ್ವಿಯಾಗಿ ನಿರ್ಮಿಸಲಾಗಿದೆ. ಸ್ಥಳೀಯ ಚಿತ್ರ ಭಂಡಾರದಲ್ಲಿ ನಿರ್ಮಿಸಲಾದ ಡಾಕರ್ ಚಿತ್ರವನ್ನು ನೋಡಲು ಈ ಆಜ್ಞೆಯನ್ನು ಚಲಾಯಿಸಿ.
docker images
Output ಟ್ಪುಟ್ ಈ ರೀತಿ ಕಾಣುತ್ತದೆ
ಈಗ ನಾವು ನಮ್ಮ ಡಾಕರ್ ಕಂಟೇನರ್ ರಚಿಸಲು ನಿರ್ಮಿಸಿದ ಚಿತ್ರವನ್ನು ಬಳಸಬಹುದು. ಧಾರಕವನ್ನು ರಚಿಸಲು ಡಾಕರ್ ರನ್ ಆಜ್ಞೆಯನ್ನು ಬಳಸಿ.
docker run -p 8080:3000 docker-tutorial
ಇಲ್ಲಿ, 8080 ಮತ್ತು 3000 ಸಂಖ್ಯೆಗಳು ಪಾತ್ರೆಯ ಬಾಹ್ಯ ಮತ್ತು ಆಂತರಿಕವನ್ನು ಸೂಚಿಸುತ್ತವೆ. ಬಾಹ್ಯ ಪೋರ್ಟ್, 8080, ನಮ್ಮ ಬ್ರೌಸರ್ ಮೂಲಕ ಅಪ್ಲಿಕೇಶನ್ಗೆ ಸಂಪರ್ಕಿಸಲು ನಾವು ಬಳಸುವ ಪೋರ್ಟ್. ಆಂತರಿಕ ಪೋರ್ಟ್, 3000, ಒಳಬರುವ ವಿನಂತಿಗಳಿಗಾಗಿ ನಮ್ಮ ಅಪ್ಲಿಕೇಶನ್ ಕೇಳುವ ಪೋರ್ಟ್ ಆಗಿದೆ. ಡಾಕರ್ ಕಂಟೇನರ್ ನೀಡಿರುವ ಬಾಹ್ಯ ಬಂದರನ್ನು ಆಂತರಿಕ ಬಂದರಿಗೆ ನಕ್ಷೆ ಮಾಡುತ್ತದೆ.
URL ಗೆ ಭೇಟಿ ನೀಡಿ http://localhost:8080
ಬ್ರೌಸರ್ನಲ್ಲಿ ಮತ್ತು ನೀವು ಪುಟವನ್ನು Hello World!
ನೊಂದಿಗೆ ಪಡೆಯುತ್ತೀರಾ ಎಂದು ನೋಡಿ http://localhost:3000
ಗೆ ಭೇಟಿ ನೀಡಿದಾಗ ನಿಮಗೆ ದೊರೆತ ಸಂದೇಶ ಮೊದಲು. ಹೌದು ಎಂದಾದರೆ, ನಿಮ್ಮ ಡಾಕರ್ ಕಂಟೇನರ್ ಚಾಲನೆಯಲ್ಲಿದೆ.
ನಿಮ್ಮ ಸಾಧನದಲ್ಲಿ ಚಾಲನೆಯಲ್ಲಿರುವ ಎಲ್ಲಾ ಡಾಕರ್ ಪಾತ್ರೆಗಳನ್ನು ವೀಕ್ಷಿಸಲು ನೀವು ಈ ಆಜ್ಞೆಯನ್ನು ಬಳಸಬಹುದು.
docker ps
ಆಜ್ಞೆಯು ನಿಮಗೆ ಈ ರೀತಿಯ output ಟ್ಪುಟ್ ನೀಡುತ್ತದೆ. ಚಾಲನೆಯಲ್ಲಿರುವ ಪಾತ್ರೆಯ CONTAINER_ID ಮತ್ತು NAME ಅನ್ನು ನಾವು ಇಲ್ಲಿ ಕಾಣಬಹುದು.
ಪರಿಸರ ಅಸ್ಥಿರಗಳೊಂದಿಗಿನ ಅಪ್ಲಿಕೇಶನ್ಗೆ ಡಾಕರ್ಫೈಲ್ನಲ್ಲಿ ಹೆಚ್ಚಿನ ಸೂಚನೆಗಳು ಬೇಕಾಗಿವೆ ಎಂದು ನಾನು ಹೇಗೆ ಉಲ್ಲೇಖಿಸಿದ್ದೇನೆ? ಪರಿಸರ ವೇರಿಯಬಲ್ ಮೌಲ್ಯವು ಅವು ಚಾಲನೆಯಲ್ಲಿರುವ ಪರಿಸರದೊಂದಿಗೆ ಬದಲಾಗುತ್ತದೆ.
ನಮ್ಮ ನೋಡ್ ಅಪ್ಲಿಕೇಶನ್ ಸರ್ವರ್ ಚಾಲನೆಯಲ್ಲಿರುವಾಗ ಕೇಳುವ ಪೋರ್ಟ್ ಅನ್ನು ನಾವು ಹೇಗೆ ಸ್ಪಷ್ಟವಾಗಿ ಉಲ್ಲೇಖಿಸಿದ್ದೇವೆ ಎಂಬುದನ್ನು ಗಮನಿಸಿ. ಈ ವಿಧಾನವು ಹೊಂದಿಕೊಳ್ಳುವ ಮತ್ತು ದೋಷ-ಪೀಡಿತವಾಗಿದೆ. ಒಂದು ವೇಳೆ ನಾವು ನೋಡ್ ಸರ್ವರ್ಗಾಗಿ ಪೋರ್ಟ್ 3000 ಅನ್ನು ತೆರೆಯದ ವಾತಾವರಣದಲ್ಲಿ ನಮ್ಮ ಅಪ್ಲಿಕೇಶನ್ ಅನ್ನು ಚಲಾಯಿಸಿದರೆ, ನಮ್ಮ ಅಪ್ಲಿಕೇಶನ್ ಕಾರ್ಯನಿರ್ವಹಿಸುವುದನ್ನು ನಿಲ್ಲಿಸುತ್ತದೆ.
ಅಪ್ಲಿಕೇಶನ್ನಿಂದ ಪೋರ್ಟ್ ಸಂಖ್ಯೆಯನ್ನು ಹೊರತೆಗೆಯುವುದು ಅತ್ಯಂತ ಸೂಕ್ತವಾದ ಅನುಷ್ಠಾನವಾಗಿದೆ. ಬದಲಾಗಿ, ನಾವು ಪೋರ್ಟ್ ಸಂಖ್ಯೆಯ ಬದಲಿಗೆ ವೇರಿಯಬಲ್ ಹೆಸರನ್ನು ಬಳಸುತ್ತೇವೆ ಮತ್ತು ಚಾಲನೆಯಲ್ಲಿರುವ ಪರಿಸರದಲ್ಲಿ ಆ ವೇರಿಯೇಬಲ್ಗೆ ಮೌಲ್ಯವನ್ನು ಹೊಂದಿಸುತ್ತೇವೆ. ನಮ್ಮ ಸಂದರ್ಭದಲ್ಲಿ, ಚಾಲನೆಯಲ್ಲಿರುವ ಪರಿಸರವು ಡಾಕರ್ ಕಂಟೇನರ್ ಆಗಿದೆ. ಆದ್ದರಿಂದ, ನಾವು ಪೋರ್ಟ್ ಸಂಖ್ಯೆಯನ್ನು ಡಾಕರ್ಫೈಲ್ಗೆ ಪರಿಸರ ವೇರಿಯೇಬಲ್ ಆಗಿ ಸೇರಿಸಬೇಕಾಗಿದೆ.
ನಾವು ಅದನ್ನು ಹೇಗೆ ಮಾಡಬಹುದೆಂದು ನೋಡೋಣ.
ಮೊದಲಿಗೆ, ಪರಿಸರ ಮೌಲ್ಯವನ್ನು ನಮ್ಮ ಡಾಕರ್ಫೈಲ್ಗೆ ಅದರ ಮೌಲ್ಯದೊಂದಿಗೆ ಸೇರಿಸಿ. ಇದನ್ನು ಸಾಧಿಸಲು ನಾವು ಡಾಕರ್ಫೈಲ್ಗೆ ಹೊಸ ಆಜ್ಞೆಯನ್ನು ಸೇರಿಸಬೇಕಾಗಿದೆ.
FROM node:latest WORKDIR /dockerTutorial COPY . . ENV PORT=3000 RUN npm install EXPOSE $PORT ENTRYPOINT ['node', 'app.js']
ವೇರಿಯಬಲ್ ಹೆಸರು ಮತ್ತು ಮೌಲ್ಯ ನಿಯೋಜನೆಯ ನಂತರ ENV ಆಜ್ಞೆಯನ್ನು ಬಳಸಿ, ನಾವು ನಮ್ಮ ಡಾಕರ್ಫೈಲ್ಗೆ ಹೊಸ ಪರಿಸರ ವೇರಿಯಬಲ್ ಅನ್ನು ಸೇರಿಸಬಹುದು. ಪೋರ್ಟ್ ಸಂಖ್ಯೆಯನ್ನು ಸ್ಪಷ್ಟವಾಗಿ ನಮೂದಿಸದಂತೆ ಎಕ್ಸ್ಪೋಸ್ 3000 ಆಜ್ಞೆಯನ್ನು ಹೇಗೆ ಬದಲಾಯಿಸಲಾಗಿದೆ ಎಂಬುದನ್ನು ನೀವು ಗಮನಿಸಿದ್ದೀರಾ? ಬದಲಾಗಿ, ನಿಖರವಾದ ಪೋರ್ಟ್ ಸಂಖ್ಯೆಯನ್ನು ಪಡೆಯಲು ಇದು ರಚಿಸಿದ PORT ವೇರಿಯೇಬಲ್ ಅನ್ನು ಸೂಚಿಸುತ್ತದೆ. ಈ ವಿಧಾನದಿಂದ, ನಾವು ಪೋರ್ಟ್ ಸಂಖ್ಯೆಯನ್ನು ಬದಲಾಯಿಸಬೇಕಾದರೆ, ನಾವು ನಮ್ಮ ಕೋಡ್ನಲ್ಲಿ ಒಂದೇ ಸ್ಥಳವನ್ನು ಮಾತ್ರ ಬದಲಾಯಿಸಬೇಕಾಗಿದೆ, ಇದು ನಮ್ಮ ಅಪ್ಲಿಕೇಶನ್ ಅನ್ನು ನಿರ್ವಹಿಸಲು ಸುಲಭವಾಗಿಸುತ್ತದೆ.
ಈಗ ನಾವು ಡಾಕರ್ಫೈಲ್ ಅನ್ನು ಬದಲಾಯಿಸಿದ್ದೇವೆ, ಮುಂದಿನ ಹಂತವು ರಚಿಸಿದ ಪರಿಸರ ವೇರಿಯೇಬಲ್ ಅನ್ನು ಉಲ್ಲೇಖಿಸಲು app.js ಅನ್ನು ಬದಲಾಯಿಸುತ್ತಿದೆ. ಇದಕ್ಕಾಗಿ, ಆಲಿಸುವ ವಿಧಾನದ ಒಳಗೆ ಬಳಸಲಾದ ಪೋರ್ಟ್ ಸಂಖ್ಯೆ 3000 ಅನ್ನು ನಾವು process.env.PORT ನೊಂದಿಗೆ ಬದಲಾಯಿಸುತ್ತೇವೆ.
const express = require('express') const app = express() app.get('/', (req, res) => {
res.send('Hello World!') }) app.listen(process.env.PORT, () => {
console.log('Node server has started running') })
ನಮ್ಮ ಅಪ್ಲಿಕೇಶನ್ ಫೈಲ್ಗಳು ಮತ್ತು ಡಾಕರ್ಫೈಲ್ನಲ್ಲಿ ನಾವು ಬದಲಾವಣೆಗಳನ್ನು ಮಾಡಿರುವುದರಿಂದ, ಹೊಸ ಕಂಟೇನರ್ಗಾಗಿ ನಾವು ಹೊಸ ಚಿತ್ರವನ್ನು ನಿರ್ಮಿಸಬೇಕಾಗಿದೆ. ಆದರೆ ಮೊದಲು, ಇದನ್ನು ಸಾಧಿಸಲು ನಾವು ಪ್ರಸ್ತುತ ಚಾಲನೆಯಲ್ಲಿರುವ ಡಾಕರ್ ಕಂಟೇನರ್ ಅನ್ನು ನಿಲ್ಲಿಸಬೇಕು.
ಧಾರಕವನ್ನು ನಿಲ್ಲಿಸಲು ನಾವು ಡಾಕರ್ ಸ್ಟಾಪ್ ಆಜ್ಞೆಯನ್ನು ಬಳಸಬಹುದು.
docker stop f10
ಈ ಆಜ್ಞೆಯಲ್ಲಿ ಬಳಸಲಾದ ಎಫ್ 10 ಮೌಲ್ಯವು ಕಂಟೇನರ್ ಐಡಿಯ ಮೊದಲ ಮೂರು ಅಂಕೆಗಳು.
ಚಾಲನೆಯಲ್ಲಿರುವ ಪಾತ್ರೆಯನ್ನು ನಿಲ್ಲಿಸಲು ನಾವು ಡಾಕರ್ ಕಿಲ್ ಎಂಬ ಆಜ್ಞೆಯನ್ನು ಬಳಸಬಹುದು.
docker kill f10
ಡಾಕರ್ ಕಿಲ್ ಮತ್ತು ಡಾಕರ್ ಸ್ಟಾಪ್ ನಡುವಿನ ವ್ಯತ್ಯಾಸವೆಂದರೆ ಸಂಪನ್ಮೂಲಗಳನ್ನು ಬಳಸಿಕೊಂಡು ಬಿಡುಗಡೆ ಮಾಡುವ ಮೂಲಕ ಮತ್ತು ರಾಜ್ಯವನ್ನು ಉಳಿಸುವ ಮೂಲಕ ಡಾಕರ್ ಸ್ಟಾಪ್ ಕಂಟೇನರ್ ಅನ್ನು ಹೆಚ್ಚು ಮನೋಹರವಾಗಿ ನಿಲ್ಲಿಸುತ್ತದೆ. ಆದಾಗ್ಯೂ, ಡಾಕರ್ ಕಿಲ್ ಸಂಪನ್ಮೂಲಗಳನ್ನು ಸರಿಯಾಗಿ ಬಿಡುಗಡೆ ಮಾಡದೆ ಅಥವಾ ರಾಜ್ಯವನ್ನು ಉಳಿಸದೆ ಧಾರಕವನ್ನು ಹೆಚ್ಚು ಥಟ್ಟನೆ ನಿಲ್ಲಿಸುತ್ತದೆ. ಉತ್ಪಾದನಾ ಪರಿಸರದಲ್ಲಿ ಚಲಿಸುವ ಕಂಟೇನರ್ಗೆ, ಧಾರಕವನ್ನು ನಿಲ್ಲಿಸಲು ಡಾಕರ್ ಸ್ಟಾಪ್ ಬಳಸುವುದು ಉತ್ತಮ ಆಯ್ಕೆಯಾಗಿದೆ.
ಚಾಲನೆಯಲ್ಲಿರುವ ಧಾರಕವನ್ನು ನಿಲ್ಲಿಸಿದ ನಂತರ, ಈ ಕೆಳಗಿನ ಆಜ್ಞೆಯನ್ನು ಬಳಸಿಕೊಂಡು ಆತಿಥೇಯ ಪರಿಸರದಿಂದ ಧಾರಕದಿಂದ ಉಳಿದಿರುವ ಉಳಿಕೆಗಳನ್ನು ಸ್ವಚ್ clean ಗೊಳಿಸಲು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಿ.
ಕಂಟೇನರ್ ಅನ್ನು ನಿಲ್ಲಿಸಲು ಮೇಲಿನ ಆಜ್ಞೆಗಳನ್ನು ಚಲಾಯಿಸಲು ನೀವು ಪ್ರಯತ್ನಿಸಿದಾಗ, ನಾವು ಕಂಟೇನರ್ ಅನ್ನು ರಚಿಸಲು ಬಳಸಿದ ಟರ್ಮಿನಲ್ ಟ್ಯಾಬ್ ಅನ್ನು ನಾವು ಕಂಟೇನರ್ ಅನ್ನು ಕೊಲ್ಲದ ಹೊರತು ಹೆಚ್ಚಿನ ಆಜ್ಞೆಗಳನ್ನು ಚಲಾಯಿಸಲು ಬಳಸಲಾಗುವುದಿಲ್ಲ ಎಂದು ನೀವು ಗಮನಿಸಬಹುದು. ಹೊಸ ಆಜ್ಞೆಗಳನ್ನು ಚಲಾಯಿಸಲು ಪ್ರತ್ಯೇಕ ಟ್ಯಾಬ್ ಅನ್ನು ಬಳಸುವ ಮೂಲಕ ನಾವು ಇದಕ್ಕಾಗಿ ಪರಿಹಾರವನ್ನು ಕಂಡುಹಿಡಿಯಬಹುದು.
ಆದರೆ ಇದಕ್ಕಿಂತ ಉತ್ತಮವಾದ ವಿಧಾನವಿದೆ. ನಾವು ಕಂಟೇನರ್ ಅನ್ನು ಡೀಮನ್ ಮೋಡ್ನಲ್ಲಿ ಚಲಾಯಿಸಬಹುದು. ಡೀಮನ್ ಮೋಡ್ನೊಂದಿಗೆ, container ಟ್ಪುಟ್ಗಳನ್ನು ತೋರಿಸಲು ಪ್ರಸ್ತುತ ಟ್ಯಾಬ್ ಬಳಸದೆ ಕಂಟೇನರ್ ಹಿನ್ನೆಲೆಯಲ್ಲಿ ಚಲಿಸುತ್ತದೆ.
ಡೀಮನ್ ಮೋಡ್ನಲ್ಲಿ ಧಾರಕವನ್ನು ಪ್ರಾರಂಭಿಸಲು, ನೀವು ಡಾಕರ್ ರನ್ ಆಜ್ಞೆಗೆ ಹೆಚ್ಚುವರಿ -d ಧ್ವಜವನ್ನು ಸೇರಿಸಬೇಕಾಗುತ್ತದೆ.
docker run -d -p 8080:3000 docker-tutorial
ಸಂವಾದಾತ್ಮಕ ಮೋಡ್ನಲ್ಲಿ ಕಂಟೇನರ್ ಅನ್ನು ಚಲಾಯಿಸಲು, ಕಂಟೇನರ್ ಈಗಾಗಲೇ ಚಾಲನೆಯಲ್ಲಿರಬೇಕು. ಸಂವಾದಾತ್ಮಕ ಮೋಡ್ನಲ್ಲಿ ಒಮ್ಮೆ, ಕಂಟೇನರ್ಗೆ ಫೈಲ್ಗಳನ್ನು ಸೇರಿಸಲು ಅಥವಾ ತೆಗೆದುಹಾಕಲು, ಫೈಲ್ಗಳನ್ನು ಪಟ್ಟಿ ಮಾಡಲು ಅಥವಾ ನಾವು ಸಾಮಾನ್ಯವಾಗಿ ಬಳಸುವ ಇತರ ಬ್ಯಾಷ್ ಆಜ್ಞೆಗಳನ್ನು ಚಲಾಯಿಸಲು ನೀವು ಆಜ್ಞೆಗಳನ್ನು ಚಲಾಯಿಸಬಹುದು.
ಕಂಟೇನರ್ ಅನ್ನು ಸಂವಾದಾತ್ಮಕ ಮೋಡ್ನಲ್ಲಿ ಚಲಾಯಿಸಲು ಈ ಕೆಳಗಿನ ಆಜ್ಞೆಯನ್ನು ಬಳಸಿ.
docker exec -it e37 bash
ಇಲ್ಲಿ, ಇ 37 ಕಂಟೇನರ್ ಐಡಿ ಆಗಿದೆ. ಬ್ಯಾಷ್ ಆಜ್ಞೆಗಳನ್ನು ಬಳಸಿಕೊಂಡು ಸಂವಾದಾತ್ಮಕ ಮೋಡ್ನೊಂದಿಗೆ ಆಟವಾಡಿ.
ನಮ್ಮ ಡಾಕರ್ ಟ್ಯುಟೋರಿಯಲ್ ಸರಣಿಯ ಮೊದಲ ಟ್ಯುಟೋರಿಯಲ್ ನಲ್ಲಿ, ಸರಳವಾದ ನೋಡ್.ಜೆಎಸ್ ಅಪ್ಲಿಕೇಶನ್ಗಾಗಿ ಡಾಕರ್ ಕಂಟೇನರ್ ಅನ್ನು ಹೇಗೆ ರಚಿಸುವುದು ಎಂದು ನೀವು ಕಲಿತಿದ್ದೀರಿ. ಆದರೆ ಡಾಕರ್ ಮತ್ತು ಕಂಟೇನರ್ಗಳೊಂದಿಗೆ ನೀವು ಮಾಡಬಹುದಾದ ಹೆಚ್ಚಿನವುಗಳಿವೆ. ನಮ್ಮ ಮುಂಬರುವ ಟ್ಯುಟೋರಿಯಲ್ ಗಳಲ್ಲಿ, ಡೇಟಾಬೇಸ್, ಸಂಪುಟಗಳೊಂದಿಗೆ ಹೇಗೆ ಕೆಲಸ ಮಾಡುವುದು ಮತ್ತು ಮೈಕ್ರೊ ಸರ್ವಿಸಸ್ನೊಂದಿಗೆ ನಿರ್ಮಿಸಲಾದ ಅಪ್ಲಿಕೇಶನ್ ಬಳಸುವ ಬಹು ಕಂಟೇನರ್ಗಳೊಂದಿಗೆ ಹೇಗೆ ಕೆಲಸ ಮಾಡುವುದು ಎಂದು ನಾವು ನೋಡುತ್ತೇವೆ.