Docker từ gốc - image, container, volume, network và chuyện gì thật sự xảy ra trong máy bạn
Docker không phải máy ảo. Bài này giải thích image, container, volume, network, cách Docker dùng chính kernel Linux để cô lập process, sự khác nhau giữa Dockerfile và docker-compose, biến môi trường, scale nhiều replica và các lệnh hay dùng nhất.
#docker #devops #linux #backend
Docker giải quyết vấn đề gì?
Câu kinh điển: "Trên máy em chạy được mà". Code chạy tốt trên laptop, lên server thì lỗi vì khác phiên bản Node, thiếu thư viện hệ thống, khác cấu hình Postgres.
Docker đóng gói app cùng toàn bộ môi trường của nó: hệ điều hành rút gọn, thư viện, runtime, code và lệnh khởi chạy. Gói đó chạy giống hệt nhau trên laptop, máy đồng nghiệp hay server production.
Docker không phải máy ảo
Đây là điều quan trọng nhất cần hiểu. Máy ảo (VirtualBox, VMware) giả lập cả một máy tính: mỗi VM có kernel riêng, khởi động mất vài phút và ngốn vài GB RAM.
Container thì không có kernel riêng. Container chỉ là một process Linux bình thường, chạy trên chính kernel của máy bạn, nhưng bị kernel "bịt mắt" và "giới hạn".

Kernel Linux có sẵn ba tính năng mà Docker tận dụng:
- Namespaces quyết định process nhìn thấy gì. Container có cây process riêng (nó tưởng mình là PID 1), card mạng và IP riêng, hệ thống file riêng, hostname riêng. Nó không thấy các process khác trên máy.
- cgroups quyết định process được dùng bao nhiêu: giới hạn CPU, RAM, I/O. Một container bị rò rỉ bộ nhớ sẽ không kéo sập cả máy.
- OverlayFS xếp chồng nhiều lớp file thành một hệ thống file duy nhất. Đây là nền tảng của image layer, sẽ nói ở phần sau.
Lớp "Debian" hay "Alpine" bên trong image chỉ là một bộ file (thư viện, bash, apt), không phải một hệ điều hành đang chạy. Bạn có thể tự kiểm chứng: chạy một container Postgres rồi gõ ps aux | grep postgres trên máy thật, process đó hiện ngay trong danh sách.
Trên macOS và Windows thì khác. Hai hệ điều hành này không có kernel Linux, nên Docker Desktop phải chạy ngầm một máy ảo Linux nhỏ, và container chạy bên trong máy ảo đó.
Chuyện gì xảy ra khi gõ docker run
Theo các bước đánh số trong sơ đồ:
- Bước 1: CLI
dockerchỉ là client. Nó gửi lệnh qua REST API tới daemondockerdthông qua file socket/var/run/docker.sock. - Bước 2: Nếu máy chưa có image
nginx,dockerdtải nó từ registry (mặc định là Docker Hub) và lưu các layer vào/var/lib/docker/overlay2/. - Bước 3:
dockerdgiao chocontainerdquản lý vòng đời container.containerdgọirunc, vàruncnhờ kernel tạo namespace và cgroup rồi khởi chạy process của container bên trong đó. - Bước 4: Dữ liệu cần giữ lại (ví dụ dữ liệu Postgres) được ghi ra volume nằm ngoài container.
- Bước 5: Request từ trình duyệt vào
localhost:8080được iptables chuyển tiếp (NAT) tới cổng 80 của containerweb.
nginx ở đây chỉ là một image ví dụ, không phải thứ Docker dùng mặc định. Bản thân Docker không có web server nào. Việc chuyển cổng từ máy vào container do kernel (iptables) đảm nhận, còn nginx, Traefik hay Caddy chỉ xuất hiện khi bạn chủ động chạy chúng như một container, thường là để làm reverse proxy đứng trước các service khác.
Image: khuôn mẫu chỉ đọc
Image là khuôn mẫu chỉ đọc chứa mọi thứ app cần để chạy. Nếu so với lập trình hướng đối tượng, image là class.
Image được ghép từ nhiều layer, mỗi lệnh trong Dockerfile tạo ra một layer:
FROM node:20-alpine
WORKDIR /app
COPY package*.json ./
RUN npm ci
COPY . .
CMD ["node", "server.js"]- Layer được cache. Nếu
package.jsonkhông đổi thì lần build sau bỏ quanpm ci. Đó là lý do copypackage.jsontrước rồi mới copy toàn bộ code. - Layer được dùng chung. Mười image cùng dựa trên
node:20thì layernode:20chỉ lưu một lần trên đĩa. - Tag là tên phiên bản, ví dụ
postgres:16vàpostgres:14. Khi bạn build lại image với cùng tag, tag chuyển sang bản mới, còn bản cũ thành image<none>:<none>(dangling). Đây chính là loại image chiếm nhiều chỗ nhất mà không ai để ý.
Container: image đang chạy
Container là một image đang chạy, tương ứng với object được tạo từ class. Từ một image có thể chạy ra nhiều container.
Khi chạy, Docker đặt thêm một lớp ghi (writable layer) lên trên các layer chỉ đọc của image. Mọi file app ghi ra đều nằm ở lớp này.
Điểm cần nhớ: xóa container thì lớp ghi mất theo. Vì vậy dữ liệu database tuyệt đối không được để trong container.
Volume: nơi dữ liệu sống sót
Volume là vùng lưu trữ nằm ngoài container, được gắn (mount) vào một đường dẫn bên trong container. Xóa hay tạo lại container thì dữ liệu trong volume vẫn còn.
Có ba cách gắn dữ liệu vào container:
- Named volume, ví dụ
-v pgdata:/var/lib/postgresql/data. Docker quản lý và lưu ở/var/lib/docker/volumes/pgdata/. Nên dùng cho dữ liệu database. - Anonymous volume: giống named volume nhưng tên là một chuỗi hash. Thường được tạo khi image có khai báo
VOLUME, và hay bị bỏ quên thành rác. - Bind mount, ví dụ
-v ./src:/app/src. Gắn thẳng một thư mục trên máy vào container. Rất tiện khi dev: sửa code là container thấy ngay.
Với Docker Compose, named volume có tên dạng <tên-project>_<tên-volume>, ví dụ chat-app_postgres-data. Nhờ vậy nhìn tên là biết volume thuộc project nào.
Network: container gọi nhau bằng tên
Docker tạo một mạng ảo (mặc định là bridge docker0) và cấp cho mỗi container một IP riêng. Container nằm chung một network có thể gọi nhau bằng tên service: app kết nối database qua postgres://db:5432, không cần biết IP.
Có hai hiểu lầm hay gặp:
- localhost bên trong container là chính container đó, không phải máy của bạn. App trong container mà kết nối
localhost:5432sẽ không tìm thấy Postgres ở container khác. Phải dùng tên service. - Container không tự mở cổng ra ngoài. Muốn truy cập từ máy thì phải map cổng:
-p 8080:80nghĩa là cổng 8080 của máy chuyển tới cổng 80 của container.
Dockerfile và docker-compose.yml khác nhau thế nào?
- Dockerfile là công thức để build ra một image. Dùng với
docker build. - docker-compose.yml mô tả cách chạy nhiều container cùng nhau: service nào, dùng image gì, map cổng nào, gắn volume nào. Dùng với
docker compose up.
Dockerfile là công thức nấu một món, còn compose là thực đơn của cả bữa tiệc. Compose có thể lấy món từ công thức của bạn (build: .) hoặc mua sẵn ngoài chợ (image: postgres:16).
Tên file mặc định là Dockerfile và compose.yaml (hoặc tên cũ docker-compose.yml, vẫn chạy bình thường). Đặt tên khác được, nhưng phải chỉ đường bằng cờ -f:
docker build -f Dockerfile.dev -t myapp:dev .
docker compose -f docker-compose.prod.yml up -dRiêng file docker-compose.override.yml được compose tự động gộp vào file chính. Người ta hay dùng nó cho cấu hình chỉ cần ở môi trường dev.
Các field thường dùng trong docker-compose
services:
app:
build: . # build từ Dockerfile trong thư mục hiện tại
image: myapp:dev # hoặc dùng image có sẵn
command: npm run dev # ghi đè CMD của image
ports:
- "3000:3000" # cổng máy : cổng container
env_file: .env # nạp biến môi trường từ file
environment:
NODE_ENV: development # đặt biến trực tiếp
volumes:
- ./src:/app/src # bind mount
depends_on:
db:
condition: service_healthy # chờ db sẵn sàng hẳn, không chỉ là "đã chạy"
restart: unless-stopped
db:
image: postgres:16
volumes:
- pgdata:/var/lib/postgresql/data
healthcheck:
test: ["CMD-SHELL", "pg_isready -U postgres"]
interval: 10s
retries: 5
volumes:
pgdata:Một vài lưu ý:
depends_onchỉ lo thứ tự khởi động. Muốn chờ database thật sự nhận kết nối thì phải kèmhealthcheckvàcondition: service_healthy.container_namegiúp tên container dễ đọc, nhưng khi đã đặt thì service đó không scale được (--scale), vì hai container không thể trùng tên.restartcó các giá trịno,on-failure,unless-stopped,always. Với Kafka hay các service hay lỗi lúc khởi động,on-failuregiúp tự hồi phục mà không cần gõ lại lệnhup.
Biến môi trường: hai cơ chế dễ nhầm
Compose có hai cơ chế biến môi trường khác nhau, và nhầm hai cái này là nguồn gốc của rất nhiều lỗi.
Cơ chế 1: thay biến vào chính file compose. Compose tự đọc file .env nằm cạnh docker-compose.yml, rồi thay các chỗ ${...} trong file:
ports:
- "${POSTGRES_PORT:-5432}:5432" # không có POSTGRES_PORT thì dùng 5432
environment:
POSTGRES_USER: ${POSTGRES_USER}
API_KEY: ${API_KEY:?Thiếu API_KEY} # không có thì dừng và báo lỗi${VAR}: lấy giá trị, không có thì thành chuỗi rỗng.${VAR:-mặc_định}: không có hoặc rỗng thì dùng giá trị mặc định.${VAR:?thông báo}: không có thì dừng hẳn, nên dùng cho biến bắt buộc.$$: ký tự$thật, để shell bên trong container xử lý thay vì compose.
Cơ chế 2: đưa biến vào bên trong container, để app đọc qua process.env. Dùng env_file để nạp cả file, environment để đặt từng biến. Nếu trùng tên thì environment thắng.
Cái bẫy là cơ chế 1 không tự đưa biến vào container. File .env cạnh compose chỉ dùng để thay ${...}. Muốn app đọc được thì phải khai báo lại trong environment hoặc dùng env_file.
Để xem compose đã thay biến ra sao, chạy lệnh sau. Nó in ra file compose cuối cùng sau khi đã thay hết biến:
docker compose configScale: chạy nhiều bản của cùng một service
Trên server production, bạn có thể gặp danh sách container kiểu này, nhiều container chạy cùng một image:
IMAGE PORTS NAMES
directus/directus:11.0.2 0.0.0.0:8101->8055/tcp prod-directus-directus-8
directus/directus:11.0.2 0.0.0.0:8102->8055/tcp prod-directus-directus-9
directus/directus:11.0.2 0.0.0.0:8103->8055/tcp prod-directus-directus-10
directus/directus:11.0.2 0.0.0.0:8104->8055/tcp prod-directus-directus-11Đây là scale ngang (horizontal scaling): thay vì làm một container mạnh hơn, ta chạy nhiều bản (replica) giống hệt nhau của cùng một service, rồi đặt một reverse proxy / load balancer (nginx, Traefik) phía trước để chia request cho từng bản.
Đọc danh sách trên:
- Tên theo dạng
<project>-<service>-<số thứ tự>. Số chạy từ 8 đến 11 thay vì 1 đến 4 vì compose tăng dần số thứ tự mỗi khi container được tạo lại hoặc scale lên xuống. - Cả bốn cùng lắng nghe cổng 8055 bên trong container. Điều đó không xung đột, vì mỗi container có namespace mạng riêng. Chỉ cổng phía máy (8101 đến 8104) là phải khác nhau.
- Proxy phía trước chuyển request vào một trong bốn cổng đó, hoặc gọi thẳng tên service
directustrong network. DNS nội bộ của Docker trả về IP của cả bốn bản.
Vì sao phải chạy nhiều bản thay vì một?
- Tận dụng nhiều nhân CPU. Directus chạy trên Node.js, mà một process Node.js chỉ chạy JavaScript trên một luồng chính. Một container dù máy có 8 nhân cũng chủ yếu dùng một nhân. Bốn container thì dùng được bốn nhân.
- Chịu lỗi. Một bản bị treo hay crash thì ba bản còn lại vẫn phục vụ, trong lúc Docker khởi động lại bản lỗi.
- Cập nhật không downtime. Có thể thay từng bản một (rolling update) thay vì tắt cả hệ thống.
Mấu chốt để scale được là app phải stateless: bản nào nhận request cũng phải trả lời như nhau. Vì vậy mọi trạng thái phải nằm ở chỗ dùng chung, không nằm trong container:
- Database: cả bốn bản kết nối chung một Postgres.
- File upload: gắn chung một volume vào
/directus/uploads. Người dùng upload ảnh qua bản số 8, lần sau request rơi vào bản số 10 thì bản số 10 vẫn đọc được file, vì thật ra cả hai đang nhìn vào cùng một thư mục trên ổ đĩa máy. - Cache, rate limit, đồng bộ giữa các bản: đưa vào Redis. Nếu để cache trong bộ nhớ của từng container, bản này xóa cache thì bản kia vẫn giữ dữ liệu cũ.
Viết bằng compose sẽ trông như sau:
services:
directus:
image: directus/directus:11.0.2
deploy:
replicas: 4 # hoặc: docker compose up -d --scale directus=4
ports:
- "8101-8104:8055" # mỗi bản lấy một cổng trong dải
environment:
DB_CLIENT: pg
DB_HOST: db
REDIS: redis://redis:6379
CACHE_ENABLED: "true"
CACHE_STORE: redis
RATE_LIMITER_STORE: redis
SYNCHRONIZATION_STORE: redis
volumes:
- uploads:/directus/uploads # bốn bản dùng chung một volume
volumes:
uploads:Có vài giới hạn cần biết:
- Volume chỉ dùng chung được trên cùng một máy. Nếu các bản chạy trên nhiều server khác nhau thì phải chuyển file sang nơi lưu trữ chung như S3 hoặc NFS.
- Database vẫn chỉ có một. Scale app giúp xử lý được nhiều request hơn, nhưng nếu nút thắt nằm ở database thì thêm replica cũng không nhanh hơn.
- Service đã scale thì không đặt được
container_name, vì bốn container không thể trùng tên.
Các lệnh hay dùng
Image:
docker images # liệt kê image
docker pull redis:7 # tải image
docker build -t myapp . # build image từ Dockerfile
docker rmi <image> # xóa imageContainer:
docker run -d -p 8080:80 --name web nginx # tạo và chạy container, -d là chạy nền
docker ps # container đang chạy (thêm -a để xem cả container đã dừng)
docker stop web # dừng (docker start web để chạy lại)
docker rm web # xóa container
docker logs -f web # xem log liên tục
docker exec -it web sh # mở shell bên trong container để debug
docker inspect web # xem toàn bộ cấu hình: IP, mount, env
docker stats # CPU, RAM của từng containerCompose:
docker compose up -d # chạy toàn bộ service
docker compose up -d --build # build lại rồi chạy
docker compose ps # trạng thái các service
docker compose logs -f api # log của một service
docker compose down # xóa container và network, giữ volume
docker compose down -v # xóa luôn cả volume (mất dữ liệu)Tìm nhanh bằng grep
Output của docker inspect là một khối JSON dài vài trăm dòng, còn docker ps trên server có thể liệt kê hàng chục container. Ghép với grep để lọc ra đúng thứ cần tìm:
docker ps | grep directus # chỉ hiện container có chữ "directus"
docker ps -a | grep -i exited # container đã dừng hoặc bị crash
docker images | grep postgres # các image postgres đang có
docker volume ls | grep directus # volume của một projectVới docker inspect, dùng -i để không phân biệt hoa thường, và -A để in thêm các dòng phía sau dòng khớp:
docker inspect web | grep -i ipaddress # IP của container
docker inspect web | grep -A 10 '"Mounts"' # volume đang gắn, kèm 10 dòng sau
docker inspect web | grep -A 3 '"Health"' # trạng thái healthcheck
docker inspect web | grep -i restartcount # container đã tự restart bao nhiêu lầnTìm trong log và biến môi trường:
docker logs web 2>&1 | grep -i error # log lỗi
docker logs --since 30m web 2>&1 | grep -i timeout
docker exec web env | grep DB_ # biến môi trường bắt đầu bằng DB_Có hai điểm cần lưu ý:
- Nhiều app ghi log ra stderr, trong khi
grepchỉ nhận stdout. Phần2>&1gộp stderr vào stdout, thiếu nó thìgrepsẽ không lọc được các dòng lỗi đó. envvàdocker inspectin ra cả mật khẩu và API key. Cẩn thận khi chạy các lệnh này lúc đang chia sẻ màn hình.
Khi đã biết chính xác trường cần lấy, cờ -f (format) của Docker cho kết quả gọn hơn grep:
docker inspect -f '{{.State.Status}}' web
docker inspect -f '{{range .Mounts}}{{.Source}} -> {{.Destination}}{{println}}{{end}}' web
docker ps --filter name=directus --format '{{.Names}} {{.Ports}}'Dọn ổ đĩa mà không xóa nhầm
Bắt đầu bằng việc xem Docker đang chiếm bao nhiêu:
docker system dfRồi dọn theo thứ tự từ an toàn nhất:
docker builder prune # build cache, lần build sau tự tạo lại
docker image prune # chỉ image <none> (dangling)
docker volume prune # chỉ volume ẩn danh không dùngCẩn thận với các lệnh có cờ -a:
docker image prune -axóa mọi image không có container nào dùng, kể cảpostgres:16haymongo:7. Lần sau cần thì phải tải lại.docker volume prune -axóa mọi volume không dùng, kể cả named volume. Nếu trong đó có dữ liệu database cũ thì mất luôn.
Container đang tồn tại (kể cả đã dừng) thì image và volume của nó không bao giờ bị prune xóa.
Tóm tắt
- Image là khuôn mẫu chỉ đọc, gồm nhiều layer được cache và dùng chung.
- Container là image đang chạy: một process Linux bình thường, bị namespaces cô lập và cgroups giới hạn, cộng thêm một lớp ghi sẽ mất khi xóa container.
- Volume là nơi lưu dữ liệu cần sống lâu hơn container.
- Network cho container gọi nhau bằng tên, và
localhosttrong container không phải máy của bạn. - Dockerfile build ra một image, docker-compose chạy cả hệ thống.
- Scale ngang là chạy nhiều bản của một service stateless, còn database, file và cache được dùng chung.
- Docker không phải máy ảo. Hiểu được điều đó thì mọi khái niệm còn lại đều trở nên logic.