คาบนี้จะพาไปไหน

คาบที่แล้วจบตรงที่เราสร้าง container ได้แล้ว ต่อเน็ตให้มันคุยกันได้แล้ว และเก็บข้อมูลไม่ให้หายได้แล้ว — แต่ทุกอย่างยังทำด้วยมือทีละคำสั่ง

คาบนี้ตอบสามคำถามที่ตามมาทันที

ท้ายคาบมีแล็บ Raspberry Pi ที่พาเอาเครื่องที่สองเข้ามาจริง ๆ เพื่อให้เห็นด้วยตาว่าปัญหาข้อสามหน้าตาเป็นยังไง

ส่วนที่ 1 — Dockerfile

ปัญหาที่ Dockerfile เกิดมาแก้

Dockerfile (ไฟล์ข้อความที่บอกวิธีสร้าง image) แก้ทั้งสามข้อพร้อมกัน เพราะมันเป็นไฟล์ข้อความธรรมดา ที่บอก Docker engine ว่าจะประกอบ image ขึ้นมายังไง

สิ่งที่เขียนสั่งได้มีสี่แบบ

• รันคำสั่ง (ติดตั้งของ ตั้งค่า)
• ก๊อปไฟล์หรือโฟลเดอร์เข้าไปใน image
• ตั้งตัวแปรสภาพแวดล้อม
• บอกว่าเวลาสตาร์ต container ให้รันอะไร

หน้าตาสั้นที่สุดที่ใช้งานได้จริงมีแค่สี่บรรทัด

FROM python:3.13-slim
WORKDIR /app
COPY hello.py .
CMD ["python", "hello.py"]

Dockerfile ใช้ทำอะไรในงานจริง

ประโยชน์ตัวจริงโผล่ตอนที่เครื่องที่ build กับเครื่องที่รันไม่ใช่เครื่องเดียวกัน

เครื่องปลายทางไม่ต้องมี Python ไม่ต้องมี compiler ไม่ต้องมี source code เลย มันได้ image ที่ประกอบเสร็จแล้วมาทั้งก้อน

คำสั่งใน Dockerfile

สไลด์ไล่คำสั่งไว้ตามลำดับที่ใช้จริง เริ่มจากสามตัวที่แทบทุกไฟล์ต้องมี

FROM, WORKDIR, COPY

FROM <image>
WORKDIR <path>
COPY <host-path> <image-path>

• FROM เริ่มขั้นตอนการ build และบอกว่าใช้ image ไหนเป็นฐาน มักเป็นบรรทัดแรกของไฟล์ ฐานเป็น image ทางการอย่าง ubuntu หรือ alpine ก็ได้ หรือเป็น image ที่เราสร้างเองก็ได้
• WORKDIR ตั้งโฟลเดอร์ทำงานให้คำสั่งที่ตามมาข้างล่าง ถ้าโฟลเดอร์ยังไม่มี Docker สร้างให้
• COPY ก๊อปไฟล์จากเครื่องที่ build เข้าไปวางใน image ที่ตำแหน่งที่ระบุ

FROM python:3.13-slim
WORKDIR /app
COPY hello.py .

USER — เรื่องความปลอดภัยที่คนมองข้าม

USER <username>

ตั้งว่าคำสั่งที่ตามมา (และตัวโปรแกรมตอนรัน) จะรันในนามผู้ใช้คนไหน

วิธีแก้คือสร้างผู้ใช้ธรรมดาขึ้นมาแล้วสลับไปใช้

RUN useradd appuser
USER appuser

RUN — รันตอน build ไม่ใช่ตอนรัน

RUN ["<command>", "<arg1>"]
RUN <command> <arg1>

RUN รันคำสั่ง ตอน build และผลลัพธ์กลายเป็น layer ใหม่ใน image ใช้ติดตั้งแพ็กเกจ ตั้งค่า หรือเตรียมอะไรก็ตามที่ต้องมีอยู่แล้วก่อน container จะสตาร์ต

มันเขียนได้สองรูปแบบ และสองรูปแบบนี้ทำงานไม่เหมือนกัน

shell form ใช้ความสามารถของ shell ได้ครบ — ท่อ |, ต่อคำสั่ง &&, เปลี่ยนทิศทาง >, และแทนค่าตัวแปร $VAR ส่วน exec form ทำไม่ได้เพราะไม่มี shell มาแปลให้

RUN ["echo", "$HOME"]

RUN echo $HOME

ENTRYPOINT กับ CMD — คู่ที่สับสนที่สุด

ทั้งสองตัวบอกว่า "เวลาสตาร์ต container ให้รันอะไร" แต่มันตอบสนองต่อสิ่งที่ผู้ใช้พิมพ์ต่อท้าย docker run คนละแบบ

ENTRYPOINT (คำสั่งหลักที่ตายตัว) — สิ่งที่ผู้ใช้พิมพ์ต่อท้าย docker run จะถูกเติมต่อท้าย คำสั่งนี้

CMD (คำสั่งหรืออาร์กิวเมนต์ตั้งต้น) — สิ่งที่ผู้ใช้พิมพ์ต่อท้าย docker run จะแทนที่ ค่านี้ทั้งอัน

สรุปเป็นตารางว่าใช้ตัวไหนเมื่อไร

เมื่อมีทั้งคู่ CMD จะกลายเป็นอาร์กิวเมนต์ตั้งต้นของ ENTRYPOINT

EXPOSE, VOLUME, ENV, LABEL

สี่ตัวนี้ไม่ได้รันอะไร มันแค่บันทึกข้อมูลไว้ใน image

EXPOSE 8080
VOLUME /data
ENV NODE_ENV=production
LABEL maintainer="John Doe <[email protected]>"

• EXPOSE บอกว่า container นี้จะฟังที่พอร์ตไหน — เป็นการประกาศให้คนอ่านและเครื่องมืออื่นรู้เท่านั้น
• VOLUME ทำจุดต่อไว้ที่ path ที่ระบุ ถ้าตอน docker run ไม่ได้ผูก volume หรือ bind mount มาให้ Docker จะสร้าง anonymous volume (volume ไม่มีชื่อ) ให้อัตโนมัติ
• ENV ตั้งตัวแปรสภาพแวดล้อมที่ติดไปกับ image และมีผลตอนรันด้วย
• LABEL แปะข้อมูลกำกับ เช่น เวอร์ชัน ผู้ดูแล วันที่ build

จาก Dockerfile กลายเป็น image

คำสั่งเดียว

docker build -t my-app:1.0 .

• -t my-app:1.0 ตั้งชื่อและ tag ให้ image เอาไว้อ้างถึงทีหลัง
• . บอกว่าให้หา Dockerfile และไฟล์ที่จะ copy จากโฟลเดอร์ปัจจุบัน

แต่ละคำสั่งใน Dockerfile กลายเป็นหนึ่ง layer ใน image

เปิดดูว่า image ถูกสร้างมายังไง

docker image history เล่าย้อนกลับได้ว่า image หนึ่งเกิดจากคำสั่งอะไรบ้าง

docker image history nginx:alpine

บรรทัดที่บอกความจริงคือสองบรรทัดนี้

IMAGE          CREATED     CREATED BY                                 SIZE
c7b4f26a7d93   3 weeks ago RUN /bin/sh -c set -x && apkArch="$(cat …  31.5MB
<missing>      3 weeks ago ENV NJS_RELEASE=1                          0B

บรรทัดแรกคือ RUN ที่ติดตั้งของจริง กินไป 31.5MB ส่วนบรรทัดที่สองเป็นแค่การตั้งตัวแปร จึงมีขนาด 0B

$ docker pull nginx:alpine
$ docker image ls nginx:alpine
REPOSITORY   TAG       IMAGE ID       CREATED       SIZE
nginx        alpine    c7b4f26a7d93   3 weeks ago   43.2MB

$ docker image history nginx:alpine
IMAGE          CREATED       CREATED BY                                      SIZE
c7b4f26a7d93   3 weeks ago   RUN /bin/sh -c set -x     && apkArch="$(cat …   31.5MB
<missing>      3 weeks ago   ENV NJS_RELEASE=1                               0B
<missing>      3 weeks ago   ENV NJS_VERSION=0.8.5                           0B
<missing>      3 weeks ago   CMD ["nginx" "-g" "daemon off;"]                0B
<missing>      3 weeks ago   STOPSIGNAL SIGQUIT                              0B
<missing>      3 weeks ago   EXPOSE map[80/tcp:{}]                           0B
<missing>      3 weeks ago   ENTRYPOINT ["/docker-entrypoint.sh"]            0B
<missing>      3 weeks ago   COPY 30-tune-worker-processes.sh /docker-ent…   4.62kB
<missing>      3 weeks ago   COPY 20-envsubst-on-templates.sh /docker-ent…   3.02kB
<missing>      3 weeks ago   COPY 15-local-resolvers.envsh /docker-entryp…   336B
<missing>      3 weeks ago   COPY 10-listen-on-ipv6-by-default.sh /docker…   2.12kB
<missing>      3 weeks ago   COPY docker-entrypoint.sh / # buildkit          1.62kB
<missing>      3 weeks ago   RUN /bin/sh -c set -x     && addgroup -g 101…   3.97MB
<missing>      3 weeks ago   ENV DYNPKG_RELEASE=2                            0B
<missing>      3 weeks ago   ENV PKG_RELEASE=1                               0B
<missing>      3 weeks ago   ENV NGINX_VERSION=1.27.1                        0B
<missing>      3 weeks ago   LABEL maintainer=NGINX Docker Maintainers <d…   0B
<missing>      3 weeks ago   /bin/sh -c #(nop)  CMD ["/bin/sh"]              0B
<missing>      3 weeks ago   /bin/sh -c #(nop) ADD file:5758b97d8301c84a2…   7.8MB

สร้าง image แรกจริง ๆ

FROM ubuntu
CMD ["bash"]

docker build -t ubuntu_bash .
docker image ls
docker run -it ubuntu_bash

Successfully tagged ubuntu_bash:latest
root@a002cb5b70b2:/#

$ cat dockerfile
FROM ubuntu
CMD ["bash"]

$ docker build -t ubuntu_bash .
Sending build context to Docker daemon  2.048kB
Step 1/2 : FROM ubuntu
 ---> a2a15febcdf3
Step 2/2 : CMD ["bash"]
 ---> Running in e3bffa3d087c
Removing intermediate container e3bffa3d087c
 ---> c7824c8113f5
Successfully built c7824c8113f5
Successfully tagged ubuntu_bash:latest

$ docker image ls
REPOSITORY    TAG      IMAGE ID       CREATED          SIZE
ubuntu_bash   latest   c7824c8113f5   21 seconds ago   64.2MB
python        latest   780bbecceca6   32 hours ago     919MB
ubuntu        latest   a2a15febcdf3   4 weeks ago      64.2MB
hello-world   latest   fce289e99eb9   8 months ago     1.84kB

$ docker run -it ubuntu_bash
root@a002cb5b70b2:/#

เขียน Dockerfile ให้ image ไม่บวม

เขียนตรง ๆ ได้แบบนี้ — แต่มันไม่ดี

FROM ubuntu
# add tools
RUN apt-get update
RUN apt-get install -y iputils-ping
RUN apt-get install -y net-tools
RUN apt-get install -y iproute2
RUN apt-get install -y curl
CMD ["bash"]

FROM ubuntu
# Add tools in one RUN command to minimize the number of layers
# and clean up package manager cache to reduce image size
RUN apt-get update && \
    apt-get install -y \
      iputils-ping \
      net-tools \
      iproute2 \
      curl && \
    apt-get clean && \
    rm -rf /var/lib/apt/lists/*
CMD ["bash"]

RUN apt-get install -y curl
RUN rm -rf /var/lib/apt/lists/*

ตัวอย่างที่ใช้จริง

FROM python:3.13-slim
# Copy current folder which contains python code
# into directory /usr/src/hello of the Docker image
COPY . /usr/src/hello
# Specify working directory
WORKDIR /usr/src/hello
# Run program
CMD ["python", "hello.py"]

cd hello
docker build -t hello .
docker run hello

Multi-stage build — ทิ้งเครื่องมือ เก็บแค่ผลลัพธ์

Multi-stage build (การ build หลายขั้นแล้วเลือกเก็บ) แบ่งการ build เป็นหลายขั้น แล้วประกอบ image สุดท้ายจากบางขั้นเท่านั้น

วิธีคิดมีสองก้าว

1. ใช้ image ฐานที่มีเครื่องมือครบ build โปรแกรมออกมาเป็นไฟล์
2. ใช้ image ฐานตัวเล็กที่มีแค่ของจำเป็นตอนรัน แล้ว copy เฉพาะไฟล์ผลลัพธ์จากขั้นแรกข้ามมา

FROM golang:1.23 AS build
WORKDIR /src
COPY <<EOF /src/main.go
package main

import "fmt"

func main() {
  fmt.Println("hello, world")
}
EOF
RUN go build -o /bin/hello ./main.go

FROM scratch
COPY --from=build /bin/hello /bin/hello
USER 65534:65534
CMD ["/bin/hello"]

เขียน Dockerfile ให้ปลอดภัย

สไลด์ยกไว้สองเรื่อง และทั้งสองเรื่องเป็นความผิดพลาดที่พบบ่อยมาก

เรื่องที่หนึ่ง — อย่ารันเป็น root

FROM python:3.13-slim
WORKDIR /app
COPY . .
RUN pip install -r requirements.txt
# runs as root
CMD ["python", "app.py"]

FROM python:3.13-slim
WORKDIR /app
COPY . .
RUN pip install -r requirements.txt && \
    useradd -m appuser
USER appuser
CMD ["python", "app.py"]

เรื่องที่สอง — อย่าฝังความลับลงใน layer

COPY .env .
ENV API_KEY=sk-123...
ARG DB_PASSWORD

docker history IMAGE
docker image inspect IMAGE

# ส่งตอนรัน
docker run --env-file .env my-app

# หรือส่งตอน build แบบไม่ทิ้งร่องรอย
docker build --secret id=db_pass,env=DB_PASS -t my-image .

RUN --mount=type=secret,id=key ...

ส่วนที่ 2 — Docker Compose

ปัญหาที่ Compose เกิดมาแก้

คำถามคือ สั่งหลาย container เป็นก้อนเดียวได้ไหม?

Docker Compose (เครื่องมือสั่งหลาย container พร้อมกัน) คือคำตอบ มันเป็นเครื่องมือสำหรับนิยามและรันแอปที่ประกอบด้วยหลาย container

หลักการมีสามข้อ

• แอปหนึ่งตัวประกอบขึ้นจาก service (หน่วยบริการหนึ่งอย่าง) หลายตัว
• Compose มีคำสั่งสำหรับจัดการ service เหล่านั้นทั้งชุด
• ทุกอย่างเขียนไว้ในไฟล์ตั้งค่าที่เรียกว่า Compose file (ไฟล์อธิบายทั้งแอป) รูปแบบ YAML ชื่อโดยปริยายคือ compose.yaml หรือ compose.yml

Compose อยู่ตรงไหนของขั้นตอนพัฒนา

สไลด์ยกภาพขั้นตอนพัฒนาแอปแบบ Docker มาเจ็ดขั้น

ติดตั้ง Compose

เช็กก่อนว่ามีอยู่แล้วหรือยัง

docker compose version

• Windows และ Mac — Docker Desktop แถม Compose มาให้แล้ว ไม่ต้องทำอะไร
• Linux — ติดตั้งเพิ่ม

sudo apt-get install docker-compose-plugin

Project — กล่องที่ครอบทุกอย่างไว้

Project (กลุ่มของ container เครือข่าย และที่เก็บข้อมูลที่ถูกจัดการเป็นก้อนเดียว) คือการรวม service, network และ volume ที่เกี่ยวข้องกันไว้เป็นหน่วยเดียว สร้างขึ้นจาก compose file หนึ่งไฟล์

การแยกขาดจากกัน — แต่ละ project สร้างทรัพยากรของตัวเองแยกกัน ต่อให้ใช้ compose file ไฟล์เดียวกันเป๊ะ และโดยปริยาย service คุยกันได้เฉพาะภายใน project เดียวกันเท่านั้น

ชื่อ project มาจากไหน มีสี่ทาง เรียงจากที่ใช้บ่อยที่สุด

ชื่อของแต่ละอย่างถูกประกอบขึ้นตามแบบ

Service — หนึ่งบริการ

project หนึ่งประกอบด้วย service ตั้งแต่หนึ่งตัวขึ้นไป แต่ละ service นิยามด้วย

• image ที่จะใช้
• คำสั่งที่จะรัน
• เครือข่ายที่จะเข้าร่วม
• พอร์ต
• ขีดจำกัด CPU และหน่วยความจำ
• จำนวนสำเนา

หน้าตาของ compose file

องค์ประกอบระดับบนสุดมีห้าอย่าง

YAML เขียนได้สองแบบ และห้ามผสมกัน

นี่คือจุดที่คนเขียน compose file ครั้งแรกพลาดบ่อยที่สุด

กฎที่ใช้ตัดสิน

• ชื่อ service ชื่อ network ชื่อ volume เป็นคู่คีย์-ค่าเสมอ เพราะมันคือคีย์
• ของหลายชิ้นชนิดเดียวกัน ใช้รายการ
• ค่าเดี่ยว ๆ ใช้คู่คีย์-ค่า
• ห้ามผสมสองแบบในหัวข้อเดียวกัน เลือกอย่างใดอย่างหนึ่ง

project ที่เล็กที่สุดที่เป็นไปได้

services:
  node-exporter:
    image: prom/node-exporter
    ports:
      - 9100:9100

docker run --rm -d -p 9100:9100 --network mynet --name node-exporter prom/node-exporter

สั่ง Compose

Compose ทำงานกับ project ทีละอัน และเลือก project ได้สามทาง

# 1. เข้าไปในโฟลเดอร์ที่มี compose file
cd <project_directory>
docker compose COMMAND

# 2. ระบุด้วยชื่อ project
docker compose -p <project_name> COMMAND

# 3. ระบุด้วย path เต็มของ compose file
docker compose -f <compose_file> COMMAND

ดูรายการคำสั่งทั้งหมดได้ด้วย docker compose เปล่า ๆ และดูวิธีใช้ของแต่ละคำสั่งด้วย docker compose COMMAND --help

คำสั่งพื้นฐาน

## สร้าง image ให้ service
docker compose build [SERVICE...]

## สั่งขึ้น
docker compose up -d [SERVICE...]
docker compose up --build -d [SERVICE...]

## สั่งลง
docker compose down    # ลบ container และเครือข่ายด้วย
docker compose stop    # หยุดเฉย ๆ ไม่ลบ

## ดูสถานะ
docker compose ls      # รายการ project ที่รันอยู่
docker compose ps      # รายการ container ของ project นี้
docker compose top     # รายการ process ข้างใน

• -d รันแบบเบื้องหลัง ไม่ยึด terminal
• --build สร้าง image ใหม่ก่อนสตาร์ต

ลองสั่งจริง

$ docker compose up -d
[+] Running 2/2
 ✔ Network node-exporter_default            Created
 ✔ Container node-exporter-node-exporter-1  Started

$ docker compose down
[+] Running 2/2
 ✔ Container node-exporter-node-exporter-1  Removed
 ✔ Network node-exporter_default            Removed

ตัวอย่างใหญ่ที่หนึ่ง — ระบบมอนิเตอร์

นี่คือระบบเดียวกับที่คาบที่แล้วสร้างด้วยมือ คราวนี้เอามาเขียนเป็น compose file

เดิมต้องพิมพ์ห้าคำสั่ง

docker volume create grafana-vol
docker network create mynet
docker run --rm -d -p 9100:9100 --network mynet --name node-exporter prom/node-exporter:v1.12.0
docker run --rm -d -p 9090:9090 --network mynet --name prometheus -v ./prometheus.yml:/etc/prometheus/prometheus.yml prom/prometheus:v3.0.1
docker run --rm -d -p 3000:3000 --network mynet -v grafana-vol:/var/lib/grafana --name grafana grafana/grafana:11.4.0

ห้าบรรทัดนี้ต้องรันตามลำดับ ต้องจำ flag ให้ครบ และไม่มีที่ไหนบันทึกไว้ว่าคุณเคยรันอะไรไป

เขียนใหม่เป็น compose file

networks:
  monitoring:
    driver: bridge

volumes:
  grafana-vol:
    external: true

services:
  node-exporter:
    image: prom/node-exporter:v1.12.0
    container_name: node-exporter
    expose:
      - 9100
    networks:
      - monitoring

  prometheus:
    image: prom/prometheus:v3.0.1
    container_name: prometheus
    volumes:
      - ./prometheus.yml:/etc/prometheus/prometheus.yml
    expose:
      - 9090
    networks:
      - monitoring

  grafana:
    image: grafana/grafana:11.4.0
    container_name: grafana
    volumes:
      - grafana-vol:/var/lib/grafana
    ports:
      - 3000:3000
    networks:
      - monitoring

อ่านทีละจุดที่สไลด์ชี้ไว้

สั่งขึ้นแล้วดูว่าได้อะไรมา

$ docker compose up -d
[+] Running 4/4
 ✔ Network monitoring_monitoring  Created
 ✔ Container prometheus           Started
 ✔ Container grafana              Started
 ✔ Container node-exporter        Started

สามบรรทัดล่างใช้ชื่อสั้น เพราะเราตั้ง container_name ไว้เอง ส่วนเครือข่ายยังใช้แบบมาตรฐาน {project}_{network} = monitoring_monitoring

ไม่มีบรรทัดที่บอกว่าสร้าง volume เพราะเราสั่ง external: true ไว้ มันไปใช้ grafana-vol ตัวที่มีอยู่แล้ว

$ docker compose ls
NAME         STATUS       CONFIG FILES
monitoring   running(3)   /home/veera/docker/monitoring/compose.yml

$ docker compose ps
NAME            IMAGE                     COMMAND                 SERVICE         STATUS   PORTS
grafana         grafana/grafana           "/run.sh"               grafana         Up       0.0.0.0:3000->3000/tcp
node-exporter   prom/node-exporter        "/bin/node_exporter"    node-exporter   Up       9100/tcp
prometheus      prom/prometheus           "/bin/prometheus --c…"  prometheus      Up       9090/tcp

$ docker compose top
grafana
UID    PID    PPID   C   STIME   TTY   TIME       CMD
472    6601   6566   0   01:00   ?     00:00:01   grafana server --homepath=/usr/share/grafana …

node-exporter
UID      PID    PPID   C   STIME   TTY   TIME       CMD
nobody   6550   6531   0   01:00   ?     00:00:00   /bin/node_exporter

prometheus
UID      PID    PPID   C   STIME   TTY   TIME       CMD
nobody   6637   6597   0   01:00   ?     00:00:00   /bin/prometheus --config.file=/etc/prometheus/prometheus.yml …

$ docker network ls
NETWORK ID     NAME                    DRIVER   SCOPE
d2b832013cbc   bridge                  bridge   local
5583bf467cc2   host                    host     local
10287c1b3112   monitoring_monitoring   bridge   local
d03f7c53291d   mynet                   bridge   local
114d0b600a15   none                    null     local

$ docker volume ls
DRIVER   VOLUME NAME
local    e036ac688866b6631b8cb539ee610bc52cfb73eb7c4e8f9e4430c79bf2ac8f08
local    grafana-vol

สั่งลงก็จบทุกอย่างในคำสั่งเดียว

$ docker compose down
[+] Running 4/4
 ✔ Container node-exporter        Removed
 ✔ Container prometheus           Removed
 ✔ Container grafana              Removed
 ✔ Network monitoring_monitoring  Removed

docker compose up สั่งซ้ำได้ไม่พัง

Idempotent (สั่งซ้ำกี่ครั้งผลเท่าเดิม) แปลว่าสั่งหลายครั้งได้ผลเหมือนสั่งครั้งเดียว ปลอดภัยที่จะทำซ้ำ

docker compose up เป็นแบบนั้น

• ครั้งแรก — สร้าง service, network, volume ทั้งหมด
• ครั้งต่อไป (ก่อนสั่ง down) — Compose เทียบ compose file กับของที่รันอยู่จริง
  • ถ้าตรงกันหมด ไม่เกิดอะไรขึ้นเลย
  • ถ้ามีอะไรไม่ตรง เฉพาะส่วนนั้นถูกสร้างใหม่หรือลบทิ้งให้ตรงกับไฟล์

คำสั่งอื่นที่ใช้บ่อย

## ขยายจำนวนสำเนาของ service
docker compose up --scale [SERVICE=NUM] -d

## หยุดโดยไม่ลบ / สตาร์ตกลับ
docker compose stop [SERVICE...]
docker compose start [SERVICE...]

## ลบ container ที่หยุดแล้ว
docker compose rm

## สั่งคำสั่งเข้าไปใน container ที่รันอยู่
docker compose exec [SERVICE] [COMMAND]

## ดู log
docker compose logs [SERVICE...]

ตัวอย่างใหญ่ที่สอง — เว็บนับจำนวนผู้เข้าชม

เว็บง่าย ๆ ที่นับว่ามีคนเข้ามากี่ครั้ง ใช้สอง service คือเว็บกับฐานข้อมูล

โครงไฟล์

.
├── compose.yml
└── web
    ├── Dockerfile
    ├── app.py
    └── requirements.txt

from flask import Flask
from pymongo import MongoClient, ReturnDocument

app = Flask(__name__)

# Connect to MongoDB
client = MongoClient('mongo', 27017)
db = client['mydb']
visitors = db.visitors

@app.route('/')
def hello():
    visitor = visitors.find_one_and_update(
        {"_id": "visit-counter"},
        {"$inc": {"count": 1}},
        upsert=True,
        return_document=ReturnDocument.AFTER,
    )
    return f"Visit count: {visitor['count']}"

if __name__ == "__main__":
    app.run(host="0.0.0.0", port=5000)

services:
  web:
    depends_on:
      mongo:
        condition: service_healthy
  mongo:
    healthcheck:
      test: ["CMD", "mongosh", "--eval", "db.adminCommand('ping')"]
      interval: 5s
      retries: 5

สั่งขึ้น

$ docker compose up
 ✔ web                          Built
 ✔ Network web_counting_default Created
 ✔ Container web_counting-mongo-1 Started
 ✔ Container web_counting-web-1   Started

Compose ทำสี่อย่างตามลำดับ — build image, สร้างเครือข่าย, สตาร์ต mongo, แล้วค่อยสตาร์ต web (ตาม depends_on)

พอร์ตที่ได้มาเป็นแบบสุ่ม

$ docker compose ps
NAME                  IMAGE             SERVICE   PORTS
web_counting-mongo-1  mongo             mongo     27017/tcp
web_counting-web-1    web_counting-web  web       0.0.0.0:65233->5000/tcp

เปิด http://localhost:65233 แล้วรีเฟรชสามครั้ง ได้ Visit count: 1, 2, 3 ตามลำดับ

$ docker network ls
NETWORK ID     NAME                  DRIVER   SCOPE
d2b832013cbc   bridge                bridge   local
5583bf467cc2   host                  host     local
d03f7c53291d   mynet                 bridge   local
114d0b600a15   none                  null     local
65cca95c5723   web_counting_default  bridge   local

$ docker volume ls
DRIVER   VOLUME NAME
local    262714c1cf0136099445c01e552e3fd1e1fa75daf8c118f9d5873bfb334b4f4b
local    grafana-vol
local    web_counting_mongo-data

ขยายเป็นหลายสำเนา

docker compose up --scale web=3 -d

ผลลัพธ์ต่างกันตามว่ามี depends_on หรือไม่

$ docker compose up --scale web=3 -d
[+] Running 6/6
 ✔ Network web_counting_default      Created
 ✔ Volume "web_counting_mongo-data"  Created
 ✔ Container web_counting-web-3      Started
 ✔ Container web_counting-web-1      Started
 ✔ Container web_counting-mongo-1    Started
 ✔ Container web_counting-web-2      Started

$ docker compose up --scale web=3 -d
[+] Running 5/5
 ✔ Network web_counting_default    Created
 ✔ Container web_counting-mongo-1  Started
 ✔ Container web_counting-web-3    Started
 ✔ Container web_counting-web-1    Started
 ✔ Container web_counting-web-2    Started

ดูพอร์ตที่แต่ละสำเนาได้

$ docker compose ps
NAME                   IMAGE              SERVICE  PORTS
web_counting-mongo-1   mongo              mongo    27017/tcp
web_counting-web-1     web_counting-web   web      0.0.0.0:53468->5000/tcp
web_counting-web-2     web_counting-web   web      0.0.0.0:53467->5000/tcp
web_counting-web-3     web_counting-web   web      0.0.0.0:53469->5000/tcp

นี่คือเหตุผลที่ compose file เขียน ports: - "5000" เฉย ๆ ถ้าเขียน "5000:5000" สำเนาที่สองจะสตาร์ตไม่ขึ้น เพราะพอร์ต 5000 บนเครื่อง host ถูกจองไปแล้ว

เข้าเว็บสำเนาไหนก็ได้ ตัวนับเดินต่อจากกัน — 53467 ได้ 1, 53468 ได้ 2, 53469 ได้ 3, กลับมา 53467 ได้ 4 เพราะทั้งสามอ่านเขียน mongo ตัวเดียวกัน

[+] Running 4/4
 ✔ Container web_counting-mongo-1  Running
 ✔ Container web_counting-web-2    Removed
 ✔ Container web_counting-web-1    Removed
 ✔ Container web_counting-web-3    Started

$ docker compose up --scale web=5 -d
[+] Running 6/6
 ✔ Container web_counting-web-3    Running
 ✔ Container web_counting-web-7    Started
 ✔ Container web_counting-web-4    Started
 ✔ Container web_counting-web-5    Started
 ✔ Container web_counting-mongo-1  Running
 ✔ Container web_counting-web-6    Started

กำหนดจำนวนสำเนาและขีดจำกัดทรัพยากรในไฟล์

แทนที่จะใส่ --scale ตอนสั่งทุกครั้ง เขียนไว้ในไฟล์ได้เลย

services:
  web:
    build: ./web
    ports:
      - "5000"
    environment:
      - MONGO_URL=mongodb://mongo:27017/mydb
    restart: always
    depends_on:
      - mongo
    deploy:
      replicas: 3              # Create 3 replicas of web service
      resources:
        limits:
          memory: 512M         # Maximum memory usage
          cpus: '0.5'          # Maximum 50% of one CPU core
        reservations:
          memory: 256M         # Guaranteed minimum memory
          cpus: '0.25'         # Guaranteed minimum 25% of one CPU core

  mongo:
    image: mongo:7
    volumes:
      - mongo-data:/data/db

volumes:
  mongo-data:

ของใหม่สามอย่าง

cpus: '0.5' ไม่ได้แปลว่าครึ่งหนึ่งของทั้งเครื่อง แต่แปลว่า ครึ่งหนึ่งของหนึ่งแกน ถ้าเครื่องมี 8 แกน 1.0 ก็ยังใช้ได้แค่แกนเดียวเต็ม ๆ

หลายเครือข่ายใน project เดียว

networks:
  frontend:          # Public-facing services
    driver: bridge
  backend:           # Internal services only
    driver: bridge
    internal: true   # No external access

services:
  nginx:             # Load balancer
    image: nginx
    networks:
      - frontend
    ports:
      - "80:80"

  web:               # Application server
    image: my-app
    networks:
      - frontend     # Can receive requests from nginx
      - backend      # Can connect to database

  db:                # Database
    image: postgres:16
    networks:
      - backend      # Only accessible from backend network
    # No ports exposed to host

สามจุดที่ทำให้ปลอดภัย

1. db ไม่มี ports: เลย จึงไม่มีพอร์ตไหนบนเครื่อง host ที่ชี้ไปหามัน
2. db อยู่แค่ backend ส่วน nginx อยู่แค่ frontend ทั้งสองไม่มีทางเจอกัน
3. internal: true ตัดทางออกสู่ภายนอกของทั้งเครือข่าย backend ถ้าฐานข้อมูลถูกเจาะ มันก็ส่งข้อมูลออกไปข้างนอกไม่ได้

web เป็นตัวเดียวที่อยู่ทั้งสองเครือข่าย มันจึงเป็นทางผ่านเดียวจากโลกภายนอกไปหาฐานข้อมูล

ส่วนที่ 3 — เมื่อเครื่องเดียวไม่พอ

ปัญหาถัดไป

คำถามคือ จะจัดการ container หลายตัวบนเครื่องหลายเครื่องยังไง?

Container orchestration

Container orchestration (ระบบจัดวางและดูแล container ข้ามเครื่อง) คือแพลตฟอร์มที่ทำให้การ deploy จัดการ และขยายแอปแบบ container บนคลัสเตอร์ใหญ่ ๆ ทำได้ง่ายขึ้น

พูดอีกแบบคือ การทำ cluster computing ด้วย container

Compose กับ Kubernetes ต่างกันตรงไหน

เรื่อง Kubernetes ต่อในคาบถัดไป

ส่วนที่ 4 — แล็บ Raspberry Pi

ขั้นตอนทั้งหมดมีหกก้าว

1. เตรียมฮาร์ดแวร์
2. ลงระบบปฏิบัติการ
3. เลือกวิธีใช้งาน
4. ต่อเครือข่าย
5. ติดตั้ง Docker
6. รัน container

เตรียมฮาร์ดแวร์

ใช้ได้ทั้ง Raspberry Pi 3 Model B+ และ Raspberry Pi 4 Model B เช็กว่ามี SD card มาด้วย เพราะ Pi ไม่มีที่เก็บข้อมูลในตัว ระบบปฏิบัติการทั้งหมดอยู่บน SD card

ลงระบบปฏิบัติการ

ใช้โปรแกรม Raspberry Pi Imager เขียน Raspberry Pi OS ลง SD card ดาวน์โหลดจาก raspberrypi.com/software

ตั้งค่าใน Imager ก่อนเขียนลงการ์ด

เลือกวิธีใช้งาน

มีสองทาง

แบบที่สองเรียกว่า headless (ไม่ต้องต่อจอ) และเป็นวิธีที่แล็บแนะนำ

ต่อด้วย SSH

Raspberry Pi รองรับ multicast DNS (ระบบชื่อในวงแลนที่ไม่ต้องมีเซิร์ฟเวอร์) เครื่องอื่นในวงเดียวกันจึงเรียกมันด้วยชื่อ raspberrypi หรือ raspberrypi.local ได้เลย ไม่ต้องรู้หมายเลข IP

Host key verification failed.

rm ~/.ssh/known_hosts

เปลี่ยนชื่อเครื่อง

ถ้ามี Pi หลายตัวในวงเดียวกัน ชื่อ raspberrypi เหมือนกันหมดจะชนกัน เปลี่ยนได้ทีหลังโดยแก้สองไฟล์

sudo nano /etc/hostname
sudo nano /etc/hosts

เปลี่ยนชื่อเดิมเป็นชื่อใหม่ในทั้งสองไฟล์ แล้ว reboot

ติดตั้ง Docker บน Pi

sudo apt-get update
curl -fsSL https://get.docker.com -o get-docker.sh
sudo sh get-docker.sh

แล้วเพิ่มผู้ใช้ pi เข้ากลุ่ม docker เพื่อจะได้ไม่ต้องพิมพ์ sudo ทุกครั้ง

sudo usermod -aG docker pi

ต้อง ออกจากระบบแล้วเข้าใหม่ สิทธิ์กลุ่มถึงจะมีผล

เช็กว่าใช้ได้

docker version
docker info

ลองรัน container

docker run -d -p 4000:80 --name nginx nginx

เปิด http://raspberrypi:4000 จากเบราว์เซอร์บนคอมพิวเตอร์ ไม่ใช่บน Pi — ถ้าเห็นหน้าต้อนรับของ nginx แปลว่าทุกอย่างครบแล้ว

ปัญหาที่โผล่มาทันทีที่มีสองเครื่อง

ระบบมอนิเตอร์สามตัวจากคาบที่แล้ว อยู่บนเครื่องเดียวแล้วทำงานได้ปกติ เพราะทั้งสามอยู่บนเครือข่าย mynet เดียวกัน เรียกกันด้วยชื่อได้

ทีนี้ลองย้าย node-exporter ไปอยู่บน Raspberry Pi

มันไม่ทำงาน เพราะ user-defined network เป็นของเฉพาะเครื่องนั้น เครือข่ายชื่อ mynet บนคอมพิวเตอร์ กับเครือข่ายชื่อ mynet บน Pi เป็นคนละเครือข่ายกันสนิท ไม่รู้จักกัน

prometheus จึงหาชื่อ node-exporter ไม่เจอ

ทางออกเฉพาะหน้าของแล็บ

สไลด์ให้ทำสามอย่าง

1. เขียน compose.yml ตัวหนึ่งสำหรับคอมพิวเตอร์ ให้รัน Prometheus กับ Grafana
2. เขียน compose.yml อีกตัวสำหรับ Raspberry Pi ให้รัน node-exporter
3. แก้ prometheus.yml ให้ชี้ target (เป้าที่ Prometheus ไปดึงตัวเลข) ไปที่ หมายเลข IP ของ Raspberry Pi

scrape_configs:
  - job_name: 'node'
    static_configs:
      - targets: ['192.168.43.51:9100']