Bài 5. Docker Compose: Điều Phối Multi-Container Hiệu Quả

Danh sách bài viết trong series Sử dụng Docker từ cơ bản đến nâng cao

Khi làm việc với microservices hay pipeline CI/CD, bạn không chỉ chạy một container mà là hàng loạt container cùng lúc – web, API, database, v.v. Điều phối chúng thủ công bằng lệnh docker run là ác mộng. Docker Compose trong DevOps ra đời để giải quyết vấn đề này. Trong bài thứ năm của series, chúng ta sẽ đi sâu vào cách dùng Docker Compose để quản lý multi-container, cấu hình file YAML, và thực hành tối ưu điều phối container trong pipeline CI/CD.

Docker Compose Là Gì?

Tổng Quan Docker Compose

Docker Compose là công cụ của Docker để định nghĩa và chạy nhiều container cùng lúc qua file YAML (docker-compose.yml).

Chức năng: Khởi động, kết nối, và dừng container bằng một lệnh.
Khác docker run: Quản lý tập trung, tự động networking.

Ví dụ: Chạy ứng dụng web (Nginx) và API (Flask) cùng DB (Postgres) chỉ với docker-compose up.

Vai Trò trong DevOps

Pipeline CI/CD: Test ứng dụng multi-service trong môi trường nhất quán.
Microservices: Phát triển và debug local trước khi deploy.
Consistency: YAML đảm bảo cấu hình giống nhau từ dev đến prod.

Tình huống thực tế: Một team DevOps mất 30 phút chạy 3 container thủ công để test. Với Compose, thời gian giảm xuống 2 phút, không lỗi cấu hình.

Cấu Hình Docker Compose: File YAML

Cấu Trúc Cơ Bản

File docker-compose.yml định nghĩa service, network, volume.

Version: Phiên bản Compose (VD: 3.8).
Services: Các container.
Networks: Mạng tùy chỉnh.
Volumes: Lưu trữ persistent.

Ví dụ đơn giản:

version: '3.8'
services:
  web:
    image: nginx:latest
    ports:
      - "8080:80"

Các Thành Phần Chính

Image: Dùng image có sẵn hoặc build từ Dockerfile.
```
web:
 build: ./web
```
Ports: Map port host-container.
```
ports:
 - "8080:80"
```

Volumes: Gắn volume/bind mount.

volumes:
 - db-data:/var/lib/postgresql/data

Environment: Biến môi trường.

environment:
 - POSTGRES_PASSWORD=mysecret

Networks: Kết nối service.
```
networks:
 - app-net
```

DevOps: YAML là “blueprint” để tái tạo môi trường nhanh chóng.

Thực Hành: Ứng Dụng Web-API-DB

Chuẩn Bị

Dockerfile API:

FROM python:3.9-slim
WORKDIR /app
COPY requirements.txt .
RUN pip install flask psycopg2-binary
COPY api.py .
CMD ["python", "api.py"]

api.py:

from flask import Flask
import psycopg2

app = Flask(__name__)

@app.route('/')
def hello():
 conn = psycopg2.connect("dbname=postgres user=postgres password=mysecret host=db")
 cur = conn.cursor()
 cur.execute("CREATE TABLE IF NOT EXISTS test (id SERIAL, name TEXT); INSERT INTO test (name) VALUES ('DevOps');")
 cur.execute("SELECT * FROM test;")
 data = cur.fetchall()
 conn.commit()
 cur.close()
 conn.close()
 return str(data)

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

requirements.txt:
```
flask==2.0.1
psycopg2-binary==2.9.1
```

docker-compose.yml:

version: '3.8'
services:
 web:
   image: nginx:latest
   ports:
     - "8080:80"
   volumes:
     - ./nginx.conf:/etc/nginx/nginx.conf
   networks:
     - app-net
 api:
   build: .
   networks:
     - app-net
 db:
   image: postgres:latest
   environment:
     - POSTGRES_PASSWORD=mysecret
   volumes:
     - db-data:/var/lib/postgresql/data
   networks:
     - app-net

networks:
 app-net:
   driver: bridge

volumes:
 db-data:

nginx.conf:

events {}
http {
   server {
       listen 80;
       location / {
           proxy_pass http://api:5000;
       }
   }
}

Chạy và Test

Khởi động:
```
docker-compose up -d
```
Test:
```
curl localhost:8080
```
- Kết quả: Dữ liệu từ DB qua API, proxy bởi Nginx (VD: [(1, 'DevOps')]).
Dừng:
```
docker-compose down
```

Debug Compose

Log:
```
docker-compose logs api
```
Kiểm tra network:
```
docker network inspect app-net
```

Debug tip:

Service không chạy: Xem docker-compose ps, kiểm tra log.
Kết nối lỗi: Đảm bảo service cùng network (app-net).

Ứng Dụng trong DevOps

Pipeline CI/CD

Test multi-container:

test:
image: docker/compose
script:
  - docker-compose up -d
  - docker-compose exec api pytest
  - docker-compose down

Kết quả: Test toàn bộ stack (web-API-DB) trong CI.

Microservices Development

Chạy local: Dev dùng Compose để phát triển web, API, DB cùng lúc.
Ví dụ: Một team dùng Compose để mock môi trường prod, giảm lỗi khi deploy.

Case study: Một hệ thống DevOps chuyển từ chạy thủ công 5 container sang Compose, tăng tốc setup từ 15 phút xuống 3 phút.

Kết Luận

Docker Compose trong DevOps là công cụ mạnh mẽ để điều phối multi-container, từ định nghĩa trong YAML đến chạy toàn bộ stack bằng một lệnh. Thực hành với web-API-DB cho thấy bạn có thể tối ưu pipeline CI/CD và phát triển microservices hiệu quả. Bài tiếp theo, chúng ta sẽ khám phá Docker Swarm – cách orchestrate container trong DevOps.

Điều hướng chuỗi bài viết<< Bài 4. Docker Volume: Quản Lý Dữ Liệu Hiệu Quả cho Container
>> Bài 6. Docker Swarm: Orchestration Cơ Bản để Scale Container