Docker คืออะไร

Docker คือแพลตฟอร์มแบบเปิดสำหรับการพัฒนา ส่งมอบ และรันแอปพลิเคชัน โดยใช้เทคนิค Containerization ซึ่งช่วยแยกแอปพลิเคชันออกจากโครงสร้างพื้นฐาน ทำให้สามารถพัฒนาและ deploy แอปได้อย่างรวดเร็ว มีเสถียรภาพ และสามารถนำไปรันได้ทุกที่ที่มี Docker Engine รองรับ

ประวัติความเป็นมา

Docker ถูกพัฒนาโดยบริษัท DotCloud (ภายหลังเปลี่ยนชื่อเป็น Docker, Inc.) และเปิดตัวครั้งแรกในปี 2013 ตัวซอฟต์แวร์เขียนขึ้นด้วยภาษา Go (Golang) บนพื้นฐานเทคโนโลยี Linux เช่น cgroups และ namespaces เพื่อสร้างระบบ container ที่เบาและรวดเร็ว แตกต่างจาก Virtual Machine ที่ต้องจำลองทั้ง OS การเปิดตัว Docker ได้เปลี่ยนแปลงวิธีการพัฒนาและ deployment แอปพลิเคชันในอุตสาหกรรมไปอย่างมาก

ทำความรู้จักกับส่วนประกอบหลักของ Docker

Dockerfile คืออะไร?

Dockerfile คือ ไฟล์ข้อความ (text file) ที่มีชุดคำสั่ง (instructions) ที่ Docker ใช้ในการสร้าง Docker image ลองนึกภาพตามนี้ Dockerfile เหมือนกับสูตรอาหาร หรือคู่มือการประกอบเฟอร์นิเจอร์ มันบอก Docker ว่าจะต้องทำอะไรบ้าง ตั้งแต่เริ่มต้นจนได้ Docker image ที่สมบูรณ์

ใน Dockerfile คุณจะกำหนดขั้นตอนต่างๆ เช่น

• FROM Image พื้นฐาน (base image) ที่จะใช้เป็นจุดเริ่มต้นในการสร้าง image ของคุณ (เช่น Ubuntu, Node.js, Python)
• RUN คำสั่งที่จะถูกรันภายใน image เพื่อติดตั้งซอฟต์แวร์, ตั้งค่าต่างๆ หรือคัดลอกไฟล์
• COPY หรือ ADD คำสั่งสำหรับคัดลอกไฟล์หรือไดเรกทอรีจากเครื่อง host ไปยัง image
• WORKDIR กำหนด working directory ภายใน image
• EXPOSE ประกาศพอร์ตที่แอปพลิเคชันภายใน container จะใช้งาน
• ENV กำหนด environment variables
• CMD หรือ ENTRYPOINT กำหนดคำสั่งที่จะรันเมื่อ container เริ่มทำงาน

ตัวอย่าง Dockerfile ง่ายๆ สำหรับแอปพลิเคชัน Python

FROM python:3.9-slim-buster
WORKDIR /app
COPY requirements.txt .
RUN pip install -r requirements.txt
COPY . .
CMD ["python", "app.py"]

อธิบาย

1. FROM python:3.9-slim-buster ใช้ image พื้นฐานที่เป็น Python 3.9 รุ่น slim บน Debian Buster
2. WORKDIR /app กำหนด working directory เป็น /app ภายใน image
3. COPY requirements.txt . คัดลอกไฟล์ requirements.txt จาก host ไปยัง /app ใน image
4. RUN pip install -r requirements.txt รันคำสั่งเพื่อติดตั้ง dependencies จากไฟล์ requirements.txt
5. COPY . . คัดลอกทุกไฟล์และโฟลเดอร์จาก host ไปยัง /app ใน image
6. CMD ["python", "app.py"] เมื่อ container เริ่มทำงาน จะรันคำสั่ง python app.py

Docker จะอ่าน Dockerfile ตามลำดับคำสั่ง และสร้างเลเยอร์ของ image ตามแต่ละคำสั่ง ทำให้กระบวนการสร้าง image เป็นแบบอัตโนมัติและทำซ้ำได้

docker-compose.yml คืออะไร?

docker-compose.yml คือ ไฟล์ YAML ที่ใช้สำหรับกำหนดและจัดการ multi-container Docker applications ลองนึกภาพตามนี้ docker-compose.yml เหมือนกับบทละคร หรือแผนผังการทำงานของระบบ มันบอก Docker Compose ว่ามี containers อะไรบ้างที่เกี่ยวข้อง, แต่ละ container สร้างจาก image ไหน, มีการเชื่อมต่อกันอย่างไร, และมีการตั้งค่าอื่นๆ อะไรบ้าง

ใน docker-compose.yml คุณจะกำหนด

• version เวอร์ชั่นของ Docker Compose file format
• service ส่วนที่กำหนดแต่ละ container ที่จะถูกสร้างและจัดการ
• service_name ชื่อของ service (container)
• image image ที่จะใช้ในการสร้าง container
• build กำหนด Dockerfile ที่จะใช้สร้าง image สำหรับ service นี้ (แทนการระบุ image โดยตรง)
• ports กำหนดการ map ports ระหว่าง host และ container (e.g., 80:80)
• volumes กำหนดการ mount volumes สำหรับ persistent storage หรือการแชร์ไฟล์
• environment กำหนด environment variables สำหรับ container
• depends_on กำหนด dependencies ระหว่าง services (container นี้จะเริ่มทำงานหลังจาก container อื่นๆ เริ่มทำงานแล้ว)
• networks กำหนด network ที่ container จะเชื่อมต่อ
• และอื่นๆ อีกมากมาย

ตัวอย่าง docker-compose.yml สำหรับเว็บแอปพลิเคชันที่มีเว็บเซิร์ฟเวอร์และฐานข้อมูล

version: '3.8'
services:
  web:
    build: ./web
    ports:
      - "80:80"
    depends_on:
      - db
    environment:
      DATABASE_URL: "postgresql://user:password@db:5432/mydb"
    networks:
      - mynetwork
 
  db:
    image: postgres:13
    volumes:
      - db_data:/var/lib/postgresql/data
    environment:
      POSTGRES_USER: user
      POSTGRES_PASSWORD: password
    networks:
      - mynetwork
 
volumes:
  db_data:
 
networks:
  mynetwork:

Docker images

images คือ พิมพ์เขียวแบบอ่านอย่างเดียว (read-only template) ที่ใช้สำหรับสร้าง Docker containers ลองนึกภาพตามนี้ Image เหมือนกับแม่พิมพ์ขนม หรือแบบแปลนบ้าน มันเก็บทุกอย่างที่จำเป็นในการสร้าง "อินสแตนซ์" Container เหมือนกับขนมที่อบจากแม่พิมพ์ หรือบ้านที่สร้างจากแบบแปลน คุณสามารถมี container หลายตัวที่สร้างจาก image เดียวกันได้

ในทางเทคนิค Docker image ประกอบด้วย

• ระบบไฟล์ (Filesystem) ซึ่งรวมถึงโค้ดแอปพลิเคชัน ไลบรารี เครื่องมือ และไฟล์การตั้งค่าต่างๆ ที่แอปพลิเคชันต้องการ
• คำสั่ง (Instructions) กำหนดว่า container ที่สร้างจาก image นี้จะทำงานอย่างไร เช่น คำสั่งเริ่มต้น (entry point) และพอร์ตที่เปิด

คุณสมบัติที่สำคัญของ Docker images

• Read-only เมื่อสร้าง image แล้ว จะไม่สามารถแก้ไขได้ หากต้องการเปลี่ยนแปลง จะต้องสร้าง image ใหม่
• Layered image ถูกสร้างขึ้นจากหลายๆ เลเยอร์ แต่ละเลเยอร์แสดงถึงการเปลี่ยนแปลงในระบบไฟล์ เลเยอร์เหล่านี้ถูกนำมาซ้อนกันเพื่อสร้างระบบไฟล์สุดท้ายของ container การออกแบบแบบเลเยอร์นี้ช่วยให้ประหยัดพื้นที่และเวลาในการดาวน์โหลด/อัปโหลด image เนื่องจากเลเยอร์ที่ใช้ร่วมกันระหว่าง image ต่างๆ จะถูกเก็บไว้เพียงครั้งเดียว
• Portable คุณสามารถแชร์และใช้งาน Docker image บนเครื่องหรือสภาพแวดล้อมใดก็ได้ที่มี Docker ติดตั้งอยู่

ความแตกต่างระหว่าง Docker Image และ Container

Docker Container คืออะไร?

Docker Container คือ อินสแตนซ์ที่กำลังทำงาน (runtime instance) ของ Docker image ลองนึกภาพตามนี้อีกครั้ง Image คือแม่พิมพ์ หรือแบบแปลน Container คือสิ่งที่ถูกสร้างขึ้นมาจากแม่พิมพ์นั้นๆ หรือบ้านที่สร้างจากแบบแปลน

เมื่อคุณมี Docker image แล้ว คุณสามารถนำ image นั้นมา "รัน" เพื่อสร้าง container ได้ Container จะเป็นสภาพแวดล้อมที่แยกจากส่วนอื่นๆ ของระบบปฏิบัติการโฮสต์ (host OS) และมีทุกสิ่งที่แอปพลิเคชันต้องการเพื่อทำงาน ไม่ว่าจะเป็นโค้ด, runtime, libraries, environment variables, และไฟล์การตั้งค่าต่างๆ

คุณสมบัติที่สำคัญของ Docker Containers

• Isolated (แยกส่วน) แต่ละ container จะทำงานในสภาพแวดล้อมที่เป็นอิสระของตัวเอง ไม่สามารถเข้าถึงหรือรบกวน processes หรือไฟล์ของ container อื่นๆ หรือระบบปฏิบัติการโฮสต์โดยตรง สิ่งนี้ช่วยให้มั่นใจได้ว่าแอปพลิเคชันต่างๆ ที่รันอยู่ใน container จะไม่ขัดแย้งกัน
• Portable (พกพาได้) เนื่องจาก container บรรจุทุกสิ่งที่แอปพลิเคชันต้องการ ทำให้คุณสามารถย้ายและรัน container บนเครื่องหรือสภาพแวดล้อมใดก็ได้ที่มี Docker ติดตั้งอยู่ โดยไม่ต้องกังวลเกี่ยวกับความแตกต่างของสภาพแวดล้อม
• Lightweight (น้ำหนักเบา) Containers แชร์ kernel ของระบบปฏิบัติการโฮสต์ ทำให้มีขนาดเล็กและเริ่มต้นทำงานได้รวดเร็วกว่า virtual machines (VMs) ที่ต้องมีระบบปฏิบัติการของตัวเอง
• Resource Efficient (ประหยัดทรัพยากร) Containers ใช้ทรัพยากรของระบบโฮสต์อย่างมีประสิทธิภาพ เพราะไม่ต้องจำลองฮาร์ดแวร์ทั้งหมดเหมือน VMs
• Scalable (ปรับขนาดได้) คุณสามารถสร้างและหยุด containers ได้อย่างรวดเร็ว ทำให้ง่ายต่อการปรับขนาดแอปพลิเคชันตามความต้องการ

Docker

ทดสอบ Build และ Run Go Fiber API ด้วย Docker

สร้างแอป Go Fiber แบบง่าย

สร้างไฟล์ main.go

package main
 
import (
    "github.com/gofiber/fiber/v2"
)
 
func main() {
    app := fiber.New()
 
    app.Get("/", func(c *fiber.Ctx) error {
        return c.SendString("Hello from Go Fiber + Docker!")
    })
 
    app.Listen(":8080")
}

สร้าง Dockerfile

FROM golang:1.22-alpine
WORKDIR /app
COPY go.mod go.sum ./
RUN go mod download
COPY . .
RUN go build -o app
CMD ["./app"]

สร้าง docker-compose.yml

version: '3'
services:
  app:
    build: .
    ports:
      - "8080:8080"

คำสั่ง Build และ Run

docker-compose up --build

เปรียบเทียบ Docker กับ Virtual Machine (VM)

แนวโน้มในอนาคต

Container technology จะยังคงเติบโตโดยเฉพาะในโลกของ cloud-native, edge computing และ microservices Kubernetes ซึ่งเป็นระบบ orchestration container ก็กำลังเป็นมาตรฐานสำหรับการบริหารจัดการ container ขนาดใหญ่

สรุป

Docker ได้ปฏิวัติวงการซอฟต์แวร์ด้วยการทำให้การพัฒนาและ deployment แอปพลิเคชันมีความยืดหยุ่น รวดเร็ว และสม่ำเสมอ การทำงานกับ Docker ช่วยลดความซับซ้อนในการส่งมอบซอฟต์แวร์ และกำลังกลายเป็นทักษะสำคัญสำหรับนักพัฒนาในยุคปัจจุบันและอนาคต