Docker ແມ່ນອີ່ຫຍັງຫວະ? — DevOps101 Ep1

Docker ເປັນລະບົບໜຶ່ງທີ່ຈະຊ່ວຍທັງ Developer ແລະ System admin ໃຫ້ build, run ແລະ share ບັນດາ application (ໃນທີ່ນີ້ໝາຍເຖິງ Service ຕ່າງໆ ບໍ່ແມ່ນ Mobile Application). ໂດຍ Docker ເອງເປັນເຕັກໂນໂລຊີ Container, ການນຳເອົາແອັບຯມາແລ່ນດ້ວຍ Docker (ຫຼື Container runtime ຕົວອື່ນໆ) ແມ່ນເອີ້ນວ່າ Containerization

ຫຼາຍຄົນອາດຈະເຄີຍໄດ້ເຫັນ Docker ຜ່ານໆ ແຕ່ກໍ່ຍັງບໍ່ຮູ້ວ່າມັນແມ່ນຫຍັງ ເປັນຫຍັງຄົນຈື່ງພາກັນນິຍົມກັນທົ່ວໂລກ ແລະ ບໍ່ຮູ້ວ່າຈະເອົາໄປໃຊ້ແນວໃດ ຂໍບອກເລີຍວ່າ Docker ບໍ່ໄດ້ຍາກຫຼາຍ ເຮົາສາມາດເອົາແອັບຯທີ່ມີຢູ່ມາແລ່ນເທິງ Docker ໄດ້ພຽງບໍ່ເທົ່າໃດຂັ້ນຕອນ ແລະ ກໍ່ສາມາດຕໍ່ຍອດໃຫ້ຮອງລະບົບທີ່ຊັບຊ້ອນໄດ້ນຳ ເຊິ່ງບົດຄວາມນີ້ຈະເລີ່ມຕົ້ນກັນງ່າຍໆຕາມສະຕາຍລ໌ 101 ກັນກ່ອນ

ກ່ອນທີ່ຈະໄປຫາ Container Deployment ເຮົາມາຮູ້ຈັກກັບ Traditional Deployment ແລະ Virtualized Deployment ກັນກ່ອນ ໃຜບໍ່ມັກອ່ານຍາວ ຢາກເລີ່ມລົງມືເລີຍເລື່ອນຂ້າມໄປກ່ອນໄດ້

Traditional Deployment vs Virtualized Deployment vs Container Deployment

ປົກກະຕິໃນເມື່ອກ່ອນຫຼັງຈາກການພັດທະນາແລ້ວ ເຮົາມັກຈະ Deploy ແອັບຯໃສ່ເທິງລະບົບ Hardware ກໍ່ຄືຊື້ເຄື່ອງຄອມ ຫຼື Server ໜຶ່ງມາສຳລັບແລ່ນແອັບຯນັ້ນໆໂດຍສະເພາະ ເຊິ່ງບັນຫາທີ່ພົບຫຼັກໆກໍ່ແມ່ນການໃຊ້ຊັບພະຍາກອນທີ່ສິ້ນເປືອງ ແລະ ມີຂໍ້ຈຳກັດຫຼາຍຢ່າງ ເຖິງເຮົາຈະສາມາດ ເອົາແອັບຯອື່ນມາຕື່ມອີກໄດ້ ແຕ່ຖ້າແອັບເຫຼົ່ານັ້ນບໍ່ສາມາດແລ່ນຢູ່ເທິງລະບົບປະຕິບັດການດຽວກັນ ເວີຊັນດຽວກັນໄດ້ກໍ່ບໍ່ສາມາດແລ່ນຮ່ວມກັນໄດ້ເຊັ່ນ ແອັບຯໜຶ່ງອາດຈະຂຽນໂດຍ php v5 ແຕ່ອີກແອັບຯຜັດໃຊ້ php v7 ເຫັນໄດ້ວ່າສອງແອັບຯບໍ່ສາມາດແລ່ນໃນເຄື່ອງດຽວກັນໄດ້ແລ້ວ

ຕໍ່ມາຈຶ່ງມີການນຳເອົາ Virtual Machine ເຂົ້າມາແກ້ໄຂບັນຫາ ຄົນທີ່ຮຽນ ແລະ ເຮັດວຽກສາຍໄອທີ ແນ່ນອນຕ້ອງເຄີຍໄດ້ຮຽນ ໄດ້ງົມ ຫຼື ຢ່າງໜ້ອຍກໍ່ຕ້ອງເຄີຍໄດ້ຍິນກ່ຽວ Virtural Machine ຢ່າງແນ່ນອນ Virutalization ຄືເປັນການຈຳລອງ Operating System ຂຶ້ນມາເທິງລະບົບ Hardware ແລະ OS ອີກເທື່ອໜຶ່ງເຊິ່ງຊ່ວຍໃຫ້ເຮົາສາມາດມີຫຼາຍລະບົບປະຕິບັດການ ຫຼາຍເວີຊັນ ແລະ ລົງພາສາໃຫ້ກົງຕາມຄວາມຕ້ອງການຂອງແຕ່ລະແອັບຯໄດ້

ເຫັນໄດ້ວ່າ Virtualization ແກ້ໄຂບັນຫາຫຼາຍຢ່າງ ແຕ່ຂໍ້ເສຍທີ່ມາກັບມັນກໍ່ຄືການກິນຊັບພະຍາກອນທີ່ເພີ່ມຂຶ້ນຫຼາຍ ຕົວຢ່າງເຊັ່ນ ຄອມພິວເຕີ ຫຼື ເຊີເວີທີ່ໃຊ້ແມ່ນເປັນລະບົບ Windows 10 ແລ້ວ ແລະ VM ທີ່ໃຊ້ deploy ກໍ່ເປັນ Windows 10 ສະແດງວ່າເຮົາຕ້ອງໃຊ້ທັງຊັບພະຍາກອນ CPU, RAM… ແລະ ຄວາມຈຳມາເທົ່າກັບຄອມເຄື່ອງໜຶ່ງທີ່ເປັນ Windows 10 ອີກ​ ເຊິ່ງມີທັງ ໜ້າ GUI, ມີແອັບຯທີ່ຕິດມາກັບລະບົບປະຕິບັດການ ແອັບຯເບິ່ງຮູບພາບ, ວິດີໂອ, ລະບົບ Network, ໆລໆ ເຫັນໄດ້ວ່າຂອງແຖມເຫຼົ່ານີ້ບໍ່ໄດ້ຟຣີ ກິນຊັບພະຍາກອນຂອງເຄື່ອງເຮົາແຕ່ບໍ່ໄດ້ຊ່ວຍຫຍັງໃນການແລ່ນແອັບຯຂອງເຮົາເລີຍ ຖ້າມີອີກ VM ເປັນ Linux CentOS ຫຼື Ubuntu ອີກກໍ່ເຊັ່ນກັນ ເຖິງແມ່ນວ່າຄວາມຕ້ອງການເຮົາພຽງແຕ່ຈະແລ່ນແອັບຯນ້ອຍໆເທົ່ານັ້ນ ແຕ່ກໍ່ຕ້ອງແລກກັບການກິນຊັບພະຍາກອນທີ່ມະຫາສານໂດຍບໍ່ຈຳເປັນ

ສະນັ້ນຈຶ່ງເປັນທີ່ມາຂອງການນຳໃຊ້ເຕັກໂນໂລຊີ Container ເຊິ່ງທີ່ຈິງເຕັກໂນໂລຊີນີ້ມີມາດົນແລ້ວແຕ່ຫາກໍ່ຖືກປັບປຸງ ຈົນສາມາດຕອບໂຈດການນຳໃຊ້ ແລະ ກາຍມາເປັນທີ່ນິຍົມໃນຊ່ວງຫຼັງນີ້ ໂດຍໂຕທີ່ນິຍົມກວ່າໝູ່ໝົດກໍ່ແມ່ນ Docker ປາວານນີ້ນ້ອຍເອງ 🐳

Container ໄດ້ຮັບຄວາມນິຍົມກໍ່ຍ້ອນວ່າ:

• Flexible ມີຄວາມຍືດຍຸ່ນ ສາມາດ Deploy ແອັບຯໄດ້ຫຼາກຫຼາຍ ລວມທັງແອັບຯທີ່ມີຄວາມຊັບຊ້ອນສູງ
• Lightweight ຂະໜາດນ້ອຍກະທັດຮັດ ເນື່ອງຈາກ Container ຈະມີພຽງແຕ່ສ່ວນ Kernel ພື້ນຖານ + OS ແລະ Lib ຕ່າງໆພຽງພໍສຳລັບການແລ່ນແອັບຯໃດໜຶ່ງເທົ່ານັ້ນ (ບໍ່ມີຂອງແຖມຫຼາຍຄື VM) ແລະ ນຳໃຊ້ຊັບພະຍາກອນຮ່ວມກັນກັບ Host ແທນທີ່ຈະຕ້ອງປະຄອງ OS ທັງໝົດຄືກັບ VM
• Portable ໝົດບັນຫາທີ່ວ່າ “It runs on my machine” ໄປ, ພັດທະນາຢູ່ເຄື່ອງເຮົາແລ້ວສາມາດເອົາແອັບຯໄປ deploy ຢູ່ໃສກໍ່ໄດ້ (ສາມາດແລ່ນເທິງ VM ອີກເທື່ອໜຶ່ງໄດ້ນຳ ເຮັດໃຫ້ສາມາດນຳເອົາ Docker Image ໄປແລ່ນເທິງ Cloud ຕ່າງໆໃນສະດວກ ຫຼຸດຂັ້ນຕອນ config ຍ້ອນສາເຫດນີ້ Docker ຈຶ່ງກາຍເປັນທີ່ນິຍົມ)
• Scalable ສາມາດເຮັດລະບົບໃຫ້ເພີ່ມຈຳນວນກັອບປີ້ໂຕເອງ ແລະ ກະຈາຍຕົວຢູ່ໃນວົງ Cluster (ເຊີເວີຫຼາຍໜ່ວຍ) ເພື່ອຮອງຮັບການໃຊ້ງານທີ່ Load ສູງໆໄດ້ ເຊິ່ງທີ່ນິຍົມໃຊ້ກັນກໍ່ແມ່ນ Kubernetes ຫຼື K8s (ຖ້າຜູ້ອ່ານສົນໃຈຈະມາຂຽນບລັອກແນະນຳຕື່ມ ຄອມເມັ້ນ ຫຼື ອິນບອກມາບອກກັນໄດ້ເດີ້)

Image ກັບ Container ຕ່າງກັນແນວໃດ?

ເຮົາໄດ້ຮູ້ຈັກກັບ Container ກັນແລ້ວ, ແລ້ວຖ້າໃຜເຄີຍໄດ້ຍິນຄ້າວໆກ່ຽວກັບເລື່ອງນີ້ອາດຈະໄດ້ຍິນຄຳວ່າ Image ເຊິ່ງ Image ໃນທີ່ນີ້ກໍ່ຄືຕົວແອັບທີ່ເຮົາ ຫຼື ນັກພັດທະນາຄົນອື່ນ build ຈາກ source code ໄວ້ແລ້ວ ຈະໄດ້ເປັນ Image ຄ້າຍໆຄືກັບໄຟລ໌ ISO ຫຼື ແຜ່ນCD/DVD ທີ່ຮວມທຸກຢ່າງໄວ້ໝົດພຽງພໍທີ່ຈະຣັນແອັບຯຂອງເຮົາໄດ້ ຈາກນັ້ນເຮົາກໍ່ສາມາດນຳເອົາ Image ນີ້ໄປແລ່ນຢູ່ເຄື່ອງໃດໜຶ່ງ ໂຕແອັບຯທີ່ສ້າງມາຈາກ Image ແລະ ເຮັດວຽກຢູ່ນັ້ນຈະເອີ້ນວ່າ Container

ການໂອນຍ້າຍ ຫຼື ແບ່ງປັນ Docker Image ເຮົາຈະເຮັດຜ່ານສິ່ງທີ່ເອີ້ນວ່າ Registry ເຊັ່ນຕົວຫຼັກເລີຍກໍ່ແມ່ນ Docker Hub, Github Package, Gitlab Container Registry, Harbor, ໆລໆ ສຳລັບ Gitlab ແລະHarbor ທີ່ສາມາດຕິດຕັ້ງລົງ On-Premise ສຳລັບໃຊ້ພາຍໃນອົງກອນໄດ້ ໃຫ້ຄິດເຖິງ Registry ຄ້າຍໆ git remote server ທີ່ເກັບໂປຣເຈັກ git ແຕ່ເປັນບ່ອນເກັບ Container Image ແທນ

ໃນ Docker Hub ເອງແມ່ນໄດ້ລວມ Image ຕ່າງໆທີ່າສ້າງໂດຍນັກພັດທະນາຂອງລະບົບຕ່າງໆເກັບໄວ້ໃຫ້ເຮົາສາມາດດຶງ (pull) ມາແລ່ນເປັນລະບົບ ຫຼື ເປັນສ່ວນປະກອບສຳລັບແລ່ນແອັບຯເຮົາໄດ້ ເຊິ່ງເຮົາຈະມາລອງເຮັດນຳກັນໃນບົດຄວາມນີ້

hub.docker.com ຫຼື Docker Hub ແມ່ນ Registry ຂອງ Docker ເອງທີ່ລວມ Image ຕ່າງໆໄວ້ໃຫ້ເຮົາດຶງເອົາມາໃຊ້ໄດ້

ເຊິ່ງບົດຄວາມນີ້ຜູ້ຂຽນຂໍຂ້າມເລື່ອງຂັ້ນຕອນການຕິດຕັ້ງໄປເນາະເພາະການຕິດຕັ້ງບໍ່ໄດ້ຫຍຸ້ງຍາກຫຼາຍ ຫຼື ຖ້າໃຜຍັງບໍ່ຢາກຕິດຕັ້ງ Docker ລົງເຄື່ອງເທື່ອກໍ່ລອງຫຼິ້ນຢູ່ Lab ທີ່ທາງ Dockerມີໄວ້ໃຫ້ໄດ້ຄືກັນ https://labs.play-with-docker.com/

https://www.docker.com/101-tutorial

ລອງ run ເວັບເຊີເວີ ດ້ວຍ Docker Container

ກ່ອນທີ່ຈະສ້າງແອັບເຮົາເອງ ມາເລີ່ມກັບການນຳໃຊ້ Docker ເບື້ອງຕົ້ນກັນກ່ອນ ໂດຍການໃຊ້ຄຳສັ່ງ docker run ເພື່ອສ້າງ container

docker run -p 80:80 nginx

ຈາກນັ້ນກໍ່ຈະເຫັນວ່າເຄື່ອງເຮົາຍັງບໍ່ມີ Image ຂອງ nginx ເທື່ອ Docker ຈະດຶງ Nginx image ຈາກ Docker hub ລົງມາເກັບທີ່ເຄື່ອງເຮົາກ່ອນທີ່ຈະສ້າງເປັນ Container (ເຮົາສາມາດດຶງ image ມາໄວ້ລ່ວງໜ້າກ່ອນຈະສ້າງ docker run ດ້ວຍຄຳສັ່ງ docker pull ຕາມດ້ວຍຊື່ image)

ໃນນີ້ເຮົາໃສ່ -p ເປັນການກຳນົດ port ທີ່ເຮົາຈະສາມາດເຊື່ອມເຂົ້າກັບຕົວ Container ຈາກເຄື່ອງຂອງເຮົາ ແລະ ພາຍນອກໄດ້, ສັງເກດວ່າ nginx ໃຊ້ port default ເປັນ 80, ການນຳໃຊ້ -p ແມ່ນເຮົາຈະຂຽນ port ທີ່ຕ້ອງການ map ໃຫ້ພາຍນອກຢູ່ທາງໜ້າ ແລະ port ຂອງ Container ທາງຫຼັງ​ ເຊັ່ນ ຖ້າເຮົາຕ້ອງການໃຫ້ທາງນອກເຂົ້າຈາກ port 8080 ແທນ ກໍ່ຈະຂຽນເປັນ -p 8080:80 ແລະ ເຮົາກໍ່ສາມາດສ້າງ Container nginx ຫຼື ແອັບຯອື່ນໆໄດ້ອີກໃຫ້ແລ່ນພ້ອມໆກັນໄດ້ໂດຍການແບ່ງ port ເປັນໂຕອື່ນ

ຫຼັງຈາກທີ່ສ້າງ Container ແລະ run ຂຶ້ນໄດ້ແລ້ວເຮົາກໍ່ສາມາດລອງເຂົ້າຜ່ານບຣາວເຊີໄດ້ ໃນທີ່ນີ້ເຮົາໃຊ້ port 80 ທີ່ເປັນ default ຂອງ http ຢູ່ແລ້ວຈຶ່ງຂຽນ url ເປັນ localhost ຫຼື 127.0.0.1 ໄດ້ເລີຍ ແຕ່ກໍ່ລະນີທີ່ເຮົາໃຫ້ port ອື່ນແມ່ນຂຽນ : (colon) ແລະ ຕໍ່ດ້ວຍ port ເຊັ່ນ: localhost:8080

ຄຳສັ່ງສຳລັບເບິ່ງ Container ທີ່ແລ່ນຢູ່ແມ່ນ

docker ps

ຖ້າຕ້ອງການຢຸດ Container ໃຫ້ໃຊ້ຄຳສັ່ງ docker stop ຕາມດ້ວຍຊື່ Container ຫຼື ເລກ Container ID ເຊິ່ງສາມາດຂຽນສັ້ນໆ 3 ໂຕໄດ້ເພາະວ່າປົກກະຕິແລ້ວເລກ ID ຈະບໍ່ຊ້ຳກັນ ຕົວຢ່າງ:

docker stop f9f

*ຈະເຫັນວ່າຊື່ Container ແມ່ນເປັນຊື່ random ທີ່ເຮົາບໍ່ໄດ້ຕັ້ງ ຖ້າຕ້ອງການຕັ້ງຊື່ Container ແມ່ນໃຫ້ຂຽນ — name ຕອນ docker run ແບບນີ້

docker run -p 80:80 --name nginx_test nginx

ການ stop ນັ້ນ Container ຍັງຢູ່ບໍ່ໄດ້ຖືກລຶບ ເຮົາສາມາດ Container ທີ່ປິດຢູ່ໄດ້ດ້ວຍຄຳສັ່ງ docker ps -a ແລະ ສາມາດສັ່ງ docker start ໃຫ້ Container ແລ່ນຄືນ ໂດຍທີ່ບໍ່ຈຳເປັນຕ້ອງສັ່ງ docker run ຍາວໆຄືກັບຕອນທຳອິດອີກ

ແຕ່ຖ້າຕ້ອງການລຶບ Container ອອກເລີຍກໍ່ແມ່ນໃຫ້ stop ກ່ອນຈາກນັ້ນກໍ່ພິມ docker rm ຕາມດ້ວຍຊື່ ຫຼື ID ຂອງ Container

docker rm f9f

ຂຽນແອັບຯ Backend ນ້ອຍໆດ້ວຍ NodeJS ກ່ອນ

ຕໍ່ມາກໍ່ຄືການນຳເອົາແອັບຯມາເຮັດເປັນ Container Image ຂອງເຮົາເອງ ກ່ອນອື່ນໝົດແມ່ນໃຫ້ຕິດຕັ້ງ NodeJS ໃນເຄື່ອງຂອງທ່ານກ່ອນ ຈາກນັ້ນກໍ່ສ້າງ Folder ຂຶ້ນມາສຳລັບໂປຣເຈັກກ່ອນ ໃນທີ່ນີ້ເຮົາຈະເຮັດແອັບຯ Backend NodeJS ນ້ອຍໆ

mkdir nodeapp
cd nodeapp
npm init
npm install --save express

ໄຟລ໌ index.js ຂອງເຮົາ

const express = require('express');
const app = express();
    app.get('/', (req, res) => {
    return res.send('<html><body>Sample made with ♥️</body></html>');
});
const port = process.env.port | 8080;
app.listen(port, () => {
    console.log('listing on port:', port);
});

ຈາກນັ້ນກໍ່ເຂົ້າໄປເພີ່ມ start script ໃນໄຟລ໌ package.json

...

"scripts": {
    "start": "node index.js",
    ...
}
...

ຈາກນັ້ນລອງແລ່ນແອັບເຮົາດ້ວຍຄຳສັ່ງ npm run start

npm run start

ແລ້ວເປີດບຣາວເຊີໄປທີ່ໜ້າ localhost:8080 ກໍ່ຈະເຫັນຂໍ້ຄວາມຕອບກັບຈາກ Service ທີ່ເຮົາຂຽນຂຶ້ນແບບນີ້

ສຳເລັດຮຽບຮ້ອຍກັບແອັບຯ Backend ນ້ອຍໆຂອງເຮົາ ຈາກນີ້ນະຕອນນີ້ເນາະ ຖ້າຄອມຂອງເຮົາຕິດຕັ້ງ NodeJS ກໍ່ຈະສາມາດແລ່ນໄດ້ປົກກະຕິ ແລ້ວຈາກນັ້ນຖ້າເຮົາຈະໄປ deploy ເທິງເຊີ ປົກກະຕິແລ້ວເຮົາກໍ່ຕ້ອງທຳການເຊົ່າເຊີເວີ ຫຼື ຖ້າເປັນເຄື່ອງແທ້ກໍ່ຕ້ອງຕິດຕັ້ງ OS ຈາກນັ້ນ ກໍ່ຕິດຕັ້ງເຄື່ອງມືໃນການແລ່ນແອັບຯບໍ່ວ່າຈະເປັນ Web Server, NodeJS, ໆລໆ

ແຕ່ຖ້າເຮົາທຳການຕິດຕັ້ງ Docker ໄວ້ທີ່ເຊີເວີ ເຮົາສາມາດດຶງໂປຣເຈັກທີ່ຂຽນນີ້ໄປໄວ້ ແລ້ວຂຽນ Dockerfile ຂຶ້ນມາຮວມຮວມ Image ແລະ ຂັ້ນຕອນໃນການແລ່ນແອັບຯ ກໍ່ຈະສາມາດແລ່ນອັບນັ້ນໆໄດ້ໂດຍທີ່ເຊີເວີບໍ່ຈຳເປັນຕ້ອງລົງ NodeJS ເລີຍ​ (ໃນຕົວຢ່າງນີ້ແມ່ນ NodeJS ເຊິ່ງຂັ້ນຕອນການຕິດຕັ້ງບໍ່ໄດ້ຊັບຊ້ອນ ແຕ່ຖ້າເປັນພາສາອື່ນເຊັ່ນ Java ແມ່ນຂັ້ນຕອນການຕິດຕັ້ງຊັບຊ້ອນຂຶ້ນ ການນຳໃຊ້ Docker ຈຶ່ງເໝາະກັບການ Scale ເຮົາສາມາດເພີ່ມເຊີເວີເຮັດເປັນ Cluster ແລ້ວນຳເອົາ Image ຂອງແອັບຯເຮົາໄປແລ່ນໄດ້ເລີຍ ໂດຍບໍ່ຕ້ອງຜ່ານຂັ້ນຕອນການຕິດຕັ້ງເຄື່ອງມືອື່ນໆໃຫ້ຫຍຸ້ງຍາກ)

ຂຽນ Dockerfile ແລະ ສ້າງ Docker Image

FROM node:12

WORKDIR /app

COPY package.json .
RUN npm install

COPY  . .
CMD ["npm", "run", "start"]

FROM node:12 ຄືການກຳນົດ Docker image (ຈາກ Docker hub) ທີ່ລວມ OS ແລະ Libs ສຳລັບແລ່ນແອັບຯ NodeJS ໄດ້

WORKDIR /app ຄືການກຳນົດ Directory ທີ່ເຮົາຈະເກັບໄຟລ໌ແອັບເຮົາໄວ້

COPY package.json . ແມ່ນເຮົາຈະຄັດລອກເອົາໄຟລ໌ package.json ເຂົ້າມາໄວ້ກ່ອນ

RUN npm install ຕໍ່ມາກໍ່ແມ່ນການສັ່ງໃຫ້ຕິດຕັ້ງ packages ທັງໝົດທີ່ມີໄວ້ຢູ່ໃນ package.json

COPY . . ຄັດລອກເອົາທຸກໄຟຢູ່ໃນໂປຣເຈັກເຂົ້າມາເກັບໄວ້ໃນ Container Image

CMD [“npm”, “run”, “start”] ຄຳສັ່ງສຸດທ້າຍເປັນຄຳສັ່ງທີ່ຈະຖືກແລ່ນຕອນທີ່ເຮົາ start container ໂດຍແນະນຳໃຫ້ຂຽນໃນຮູບແບບນີ້ແທນ ການຂຽນແບບທຳມະດາ

ສັງເກດວ່າເຮົາຈະຄັດລອກເອົາ package.json ເຂົ້າມາກ່ອນ ແລ້ວທຳການຕິດຕັ້ງ packages ເຊິ່ງເຮົາບໍ່ຄວນຄັດລອກທຸກຢ່າງມາ ຂັ້ນຕອນນີ້ສຳຄັນເພາະຈະຊ່ວຍເລື່ອງ Cache ຊ່ວຍໃຫ້ປະຢັດເວລາໃນການ build ເນາະ ເອົາເປັນວ່າບົດຄວາມໜ້າອາດຈະມາອະທິບາຍລະອຽດລົງລຶກຕື່ມກ່ຽວກັບການຂຽນ Dockerfile

ຫຼັງຈາກໄດ້ໄຟລ໌ Dockerfile ແລ້ວສິ່ງຕໍ່ມາທີ່ຄວນເຮັດຄືການຂຽນໄຟລ .dockerignore ຄືເປັນການບອກ Docker ວ່າບໍ່ໃຫ້ເຮົາໄຟລ໌ ຫຼື ໂຟເດີໃດເຂົ້າໄປ ຄືກັນກັບໄຟລ໌ .gitignore ນັ້ນເອງ

ໃນນີ້ ແນ່ນອນເຮົາບໍ່ຢາກດຶງໂຟເດີ node_modules ເຂົ້າໄປ ໃຫ້ສ້າງໄຟລ໌ .dockerignore ຂຶ້ນມາ (ຊື່ມີຈ້ຳເມັດຂຶ້ນໜ້າ) ແລ້ວພິມຊື່ໄຟລ໌ ແລະ ໂຟເດີທີ່ບໍ່ຕ້ອງການໃຫ້ Docker ເຫັນໃສ່ເຊັ່ນ:

node_modules

ຈາກນັ້ນເຮົາຈະທຳການສ້າງ Container Image ຂອງເຮົາເອງແລ້ວ ເຢ້! ໃຫ້ໃຊ້ຄຳສັ່ງ docker ຕາມນີ້

docker build -t nodeapp .

ຄືກັນກັບຕອນເຮົາສັ່ງ docker run nginx ໃນຕອນທຳອິດ ທີ່ເຮົາຍັງບໍ່ທັນມີ image ຕອນນີ້ແມ່ນ node version 12 ດັ່ງນັ້ນ Docker ກໍ່ຈະດຶງ image ຈາກ Docker Hub ລົງມາກ່ອນສະເພາະເທື່ອທຳອິດ ເທື່ອຕໍ່ໆໄປ Docker ຈະສາມາດ build image ໄດ້ໄວຂຶ້ນຫຼາຍເທົ່າ ແລະ ການດຶງ image ເທື່ອນີ້ບໍ່ໄດ້ທຶງມາ run ແຕ່ດຶງ image ມາເປັນສ່ວນໜຶ່ງຂອງ image ທີ່ເຮົາກຳລັງສ້າງ ໃຫ້ສາມາດແລ່ນແອັບຯ NodeJS ໄດ້

ແລ້ວກໍ່ຖ້າໃຫ້ Docker ສ້າງ image ເຊິ່ງຈະເຮັດຕາມແຕ່ລະ Step ທີ່ເຮົາກຳນົດໃນ Dockerfile

ເຮົາສາມາດເບິ່ງ Docker image ທີ່ຢູ່ໃນເຄື່ອງເຮົາ ດ້ວຍຄຳສັ່ງ

docker images

ກໍ່ຈະສະແແດງ image ທັງໝົດທັງໂຕທີ່ເຮົາດຶງມາແລ່ນ ໂຕທີ່ດຶງມາໃຊ້ສ້າງ image ໃໝ່ ແລະ ໂຕ image ທີ່ເຮົາສ້າງຂຶ້ນມາເອງ

ການຈະແລ່ນ image ທີ່ເຮົາສ້າງຂຶ້ນມາເປັນ container ກໍ່ໃຊ້ຄຳສັ່ງ docker run ຄືກັນ ເຊິ່ງເທື່ອນີ້ port ທາງໃນໃຊ້ port 8080 ແລະ ເຮົາຈະໃສ່ — rm ໃຫ້ Docker ລຶບ Container ທັນທີທີ່ເຮົາ stop ບໍ່ຈຳເປັນຕ້ອງໄປນຳລຶບເອງ

docker run --name nodeapp -p 8080:8080 --rm nodeapp

ແລະ ແນ່ນອນເຮົາກໍ່ຈະສາມາດເຂົ້າເຖິງແອັບຯເຮົາໄດ້ຜ່ານ localhost:8080 ເປັນໄປຕາມທີ່ເຮົາຕ້ອງການ

ຕອນນີ້ໃຫ້ປິດ Container ກ່ອນ ໂດຍການກົດ Ctrl + c ແລ້ວ Container ກໍ່ຈະ stop ແລະ ຖືກລຶບໄປທັນທີເລີຍຖ້າເຮົາໃສ່ — rm ໃນຕອນ run

ອີກເຕັກນິກໜຶ່ງທີ່ຈຳເປັນ ຄືເຮົາສາມາດແລ່ນ Container ແບບຢູ່ເບື້ອງຫຼັງ (Daemon mode) ພຽງແຕ່ພິມ -d ເທົ່ານັ້ນ ແລະ ເຮົາຈະລອງປ່ຽນ port mapping ເປັນ port 8000 ນຳ

docker run -d --name nodeapp -p 8000:8080 --rm nodeapp

ເມື່ອກົດ Enter ເຮົາກໍ່ຈະບໍ່ໄດ້ຂຶ້ນໜ້າ console ຄ້າງແລ້ວ ແຕ່ຖ້າ docker ps ເບິ່ງກໍ່ຈະເຫັນວ່າ Container ກຳລັງແລ່ນຢູ່

ແລະ ຖ້າເຂົ້າບຣາວເຊີ localhost:8000 (ບໍ່ແມ່ນ localhost:8080) ກໍ່ຈະສາມາດເຂົ້າເວັບໄດ້

ເພີ່ມຕື່ມ: ກັບມາທີ່ການ build image ເຮົາສາມາດ tag version ຂອງ image ໄດ້ ສັງເກດວ່າ docker images ທີ່ເຮົາດຶງມາໂດຍບໍ່ມີການກຳນົດ version ຄື nginx ແລະ nodeapp ຂອງເຮົາເອງທີ່ບໍ່ກຳນົດຕອນ build ຈະຂຶ້ນ tag ຕໍ່ທ້າຍເປັນ :latest ເຊິ່ງກໍ່ຄືເປັນ default

ໃນການ build image ຕົວຈິງເຮົາຄວນຈະກຳນົດ tag ໃຫ້ກັບ image ໂດຍພຽງແຕ່ຂຽນຕໍ່ທ້າຍດ້ວຍ :<version> ເຊັ່ນ

docker build -t nodeapp:0.0.1 .

ເທົ່ານີ້ກໍ່ຈະແບ່ງ version ໃຫ້ກັບ image ຂອງເຮົາແລ້ວ ແລະ ເວລາ run container ກໍ່ໃຫ້ໃສ່ tag ນຳເຊັ່ນກັນ

docker run -d -p 8000:8080 nodeapp:0.0.1

ແລະ ການດຶງ image ມາໃຊ້ງານ ທັງໃຊ້ແລ່ນໂດຍກົງ ຫຼື ນຳມາເປັນສ່ວນປະກອບຂອງ image ໃໝ່ຄວນຈະກຳນົດ tag (version) ຕາຍໂຕ ແທນການປະຫວ່າງ ຫຼື ໃຊ້ :latest ເຊິ່ງບໍ່ແນະນເພາະ latest ໃນຕອນນີ້ອາດຈະເປັເວີຊັນ 12 ແຕ່ຖ້າອີກ 1 ປີ 2 ປີ ເຮົາກັບມາດ run ໃໝ່ :latest ອາດຈະກາຍເປັນ version ໃໝ່ເຮັດໃຫ້ແອັບຯເຮົາແລ່ນບໍ່ໄດ້

ຖ້າທ່ານຕ້ອງການລຶບ Docker image ກໍ່ພຽງແຕ່ໃຊ້ຄຳສັ່ງ docker rmi ຕາມດ້ວຍຊື່ image ຫຼື image id

ແລະ ນີ້ຄຳສັ່ງສັ້ນໆບາງອັນທີ່ທ່ານອາດຈະໄດ້ໃຊ້

docker stop $(docker ps -q) ສັ່ງ stop container ທຸກໂຕທີ່ແລ່ນຢູ່
docker rm $(docker ps -aq) ສັ່ງ ລຶບ container ທຸກໂຕ (ຕ້ອງ stop ກອ່ນຈຶ່ງຈະລຶບໄດ້)
docker rmi $(docker images -q) ສັ່ງລຶບ Docker image ທັງໝົດໃນເຄື່ອງ ຖ້າດົນໆໄປກໍ່ຄວນຈະນຳລຶບ ເຖິງ Docker ຈະຂຶ້ນຊື່ວ່າເບົາ ແຕ່ການສ້າງ image ຫຼາຍກໍ່ກິນຄວາມຈຸເຄື່ອງເຮົາໄດ້
docker system prune -a ສັ່ງລຶບທັງ container ແລະ image ທີ່ບໍ່ໄດ້ໃຊ້ງານ

ແລະນີ້ກໍ່ຄືພື້ນຖານການໃຊ້ງານ Docker ໃນເບື້ອງຕົ້ນ ສຳລັບຕອນທຳອິດກໍ່ຂໍເອົາຄ້າວໆປະມານນີ້ກ່ອນ ໃນບົດຕໍ່ໆໄປເຮົາຈະມາເບິ່ງວິທີການ Deploy ຂຶ້ນ server ແລະ ຕົວຢ່າງໆສຳລັບການພັດທະນາລະບົບອື່ນໆອີກ ເຊິ່ງຄືທີ່ບອກໄວ້ເຊີເວີພຽງແຕ່ຕ້ອງຕິດຕັ້ງ Docker ກໍ່ສາມາດດຶງເອົາ Image ທີ່ເຮົາສ້າງໄປແລ່ນໄດ້ເລີຍ ໂດຍບໍ່ຈຳເປັນຕ້ອງຕິດຕັ້ງ NodeJS ໃດໆ ແລະ ຖ້າຄົນສົນໃຈຫຼາຍ ອາດຈະຂຽນສືບຕໍ່ໄປຈົນຮອດການນຳໃຊ້ Docker-Compose ແລະ K8s ເຂົ້າມາຊ່ວຍ Automate ໃຫ້ Deployment Workflow ສະດວກຍິ່ງຂຶ້ນ (ຫຼື ຊັບຊ້ອນຂຶ້ນ 🤔)

ຖ້າໃຜສົນໃຈ ຫຼື ມີຂໍ້ສົງໄສອັນໃດສາມາດສອບຖາມ ແລະ Feedback ກັນມາໄດ້

Code ທັງໝົດຂອງບົດຄວາມນີ້:

What is a Container? | Docker

Dockerfile reference