คู่มือการใช้งาน Docker Compose Generator: สร้างไฟล์ docker-compose.yml แบบหลายบริการ

การพัฒนาแอปพลิเคชันสมัยใหม่มักประกอบด้วยหลายบริการ (services) ทำงานร่วมกัน เช่น web server, database, cache และ message queue การจัดการ container ทั้งหมดนี้ด้วย Docker แบบทีละตัวด้วยคำสั่ง docker run นั้นยุ่งยากและเกิดข้อผิดพลาดได้ง่าย โดยเฉพาะเมื่อต้องเชื่อมต่อ network, กำหนด environment variables, และจัดการลำดับการเริ่มทำงานของแต่ละบริการ

Docker Compose คือเครื่องมือที่แก้ปัญหานี้โดยให้คุณกำหนดบริการทั้งหมดในไฟล์ docker-compose.yml เพียงไฟล์เดียว จากนั้นใช้คำสั่ง docker compose up เพื่อสตาร์ททุกอย่างพร้อมกัน อย่างไรก็ตาม การเขียนไฟล์ YAML นี้ด้วยมือก็ยังเป็นงานที่น่าเบื่อและมีโอกาสพิมพ์ผิด โดยเฉพาะสำหรับผู้ที่เพิ่งเริ่มต้นใช้งาน Docker

เครื่องมือ Docker Compose Generator ถูกออกแบบมาเพื่อแก้ปัญหานี้โดยตรง ช่วยให้คุณสร้างไฟล์ docker-compose.yml แบบหลายบริการผ่านฟอร์มที่ใช้งานง่าย เพียงเลือก image ที่ต้องการ กำหนด ports, volumes, และ environment variables แล้วก็จะได้ไฟล์ YAML ที่พร้อมใช้งานในทันที

ในบทความนี้ เราจะแนะนำวิธีใช้งานเครื่องมืออย่างละเอียด พร้อมอธิบายแนวคิดสำคัญของ Docker Compose และแสดงตัวอย่างกรณีการใช้งานจริงที่นักพัฒนามักเจอ เพื่อให้คุณนำไปประยุกต์ใช้กับโปรเจกต์ของคุณได้ทันที ลองใช้งานเครื่องมือได้ที่ Docker Compose Generator

ทำไมต้องใช้ Docker Compose Generator?

การสร้างไฟล์ docker-compose.yml ด้วยเครื่องมือแทนการเขียนด้วยมือให้ประโยชน์หลายด้าน ดังนี้

• ประหยัดเวลา — ไม่ต้องเปิดเอกสารหรือค้นหา syntax ของ YAML ทุกครั้งที่สร้างไฟล์ใหม่ เพียงกรอกข้อมูลในฟอร์มก็ได้ผลลัพธ์ทันที
• ลดข้อผิดพลาด — การพิมพ์ผิดใน YAML เช่น indent ไม่ตรง, ลบ colon หาย หรือใส่ type ผิด เป็นสาเหตุของ error ที่พบบ่อยและ debug ยาก ตัวสร้างช่วยป้องกันปัญหาเหล่านี้
• มาตรฐานเป็นเอกสารอ้างอิง — ไฟล์ที่สร้างขึ้นจะมีโครงสร้างที่สอดคล้องกับ best practices ทำให้ทีมทำงานร่วมกันได้ง่ายขึ้น
• รองรับหลายบริการ — สามารถเพิ่มบริการได้หลายตัวในไฟล์เดียว พร้อมกำหนด dependencies ระหว่างบริการได้อย่างถูกต้อง
• เหมาะสำหรับผู้เริ่มต้น — ฟอร์มที่ใช้งานง่ายช่วยให้ผู้ที่เพิ่งเริ่มใช้ Docker เข้าใจและสร้างไฟล์ได้โดยไม่ต้องเรียนรู้ YAML syntax ทั้งหมดก่อน
• คัดลอกได้ในคลิกเดียว — เมื่อได้ไฟล์ที่พอใจแล้ว กดปุ่ม Copy เพียงครั้งเดียวก็นำไปวางในโปรเจกต์ได้ทันที

คุณสมบัติเด่นของ Docker Compose Generator

เครื่องมือ Docker Compose Generator มาพร้อมกับฟีเจอร์ที่ตอบโจทย์นักพัฒนาและทีม DevOps ทุกระดับ ดังนี้

สร้างได้หลายบริการในไฟล์เดียว

เพิ่มบริการ (services) ได้ไม่จำกัดจำนวนในไฟล์ docker-compose.yml เดียว ไม่ว่าจะเป็น web server, database, cache หรือ reverse proxy แต่ละบริการสามารถกำหนดค่าได้อิสระ พร้อมรองรับการเชื่อมโยงระหว่างบริการผ่าน depends_on

รองรับ Configuration ครบครัน

ทุกฟิลด์ที่จำเป็นสำหรับการใช้งาน Docker Compose ในชีวิตประจำวัน สามารถกำหนดได้ผ่านฟอร์ม ดังนี้

ตัวอย่าง YAML แบบสด (Live Preview)

ผลลัพธ์ YAML จะปรากฏขึ้นทันทีขณะคุณกรอกข้อมูลในฟอร์ม ทำให้คุณเห็นการเปลี่ยนแปลงแบบ real-time และสามารถตรวจสอบความถูกต้องได้ทันที โดยไม่ต้องรอ

ตัวอย่างผลลัพธ์สำหรับ stack พื้นฐานที่ประกอบด้วย web app และ database

services:
  web:
    image: node:20-alpine
    container_name: myapp-web
    ports:
      - '3000:3000'
    environment:
      - NODE_ENV=production
      - DATABASE_URL=postgresql://user:pass@db:5432/myapp
    depends_on:
      - db
    restart: unless-stopped

  db:
    image: postgres:16-alpine
    container_name: myapp-db
    ports:
      - '5432:5432'
    environment:
      - POSTGRES_USER=user
      - POSTGRES_PASSWORD=pass
      - POSTGRES_DB=myapp
    volumes:
      - db-data:/var/lib/postgresql/data
    restart: unless-stopped

volumes:
  db-data:

ประมวลผลบน Client 100% (Privacy First)

ข้อมูลทั้งหมดจะถูกประมวลผลในเบราว์เซอร์ของคุณ ไม่มีการส่งข้อมูลไปยัง server ใด ๆ ทำให้มั่นใจได้ว่า configuration ของคุณจะไม่รั่วไหล แม้จะเป็นข้อมูลที่ละเอียดอ่อน เช่น database password หรือ API keys ที่ใส่ใน environment variables

คัดลอกได้ในคลิกเดียว (One-Click Copy)

เมื่อได้ผลลัพธ์ที่พอใจแล้ว กดปุ่ม Copy เพียงครั้งเดียวก็นำไฟล์ docker-compose.yml ไปวางในโปรเจกต์ได้ทันที ไม่ต้องลากเลือกข้อความด้วยมือ

วิธีใช้งาน Docker Compose Generator

การใช้งานเครื่องมือทำได้ง่ายเพียงไม่กี่ขั้นตอน

ขั้นตอนที่ 1: เปิดเครื่องมือ

ไปที่หน้า Docker Compose Generator คุณจะเห็นฟอร์มสำหรับกำหนดค่าบริการทางซ้าย และช่อง preview สำหรับแสดงผล YAML ทางขวา

ขั้นตอนที่ 2: เพิ่มบริการแรก

เริ่มจากการเพิ่มบริการแรกของคุณ ตัวอย่างเช่น web application ที่ใช้ Node.js กรอกข้อมูลดังนี้

• Service Name: web
• Image: node:20-alpine
• Ports: 3000:3000
• Environment Variables: NODE_ENV=production

ขั้นตอนที่ 3: เพิ่มบริการเพิ่มเติม

กดปุ่มเพิ่มบริการเพื่อต่อด้วย database, cache หรือบริการอื่น ๆ ที่จำเป็น ตัวอย่างเช่น การเพิ่ม PostgreSQL database

• Service Name: db
• Image: postgres:16-alpine
• Ports: 5432:5432
• Environment Variables: POSTGRES_PASSWORD=mysecretpassword
• Volumes: db-data:/var/lib/postgresql/data
• Depends On: (ไม่ต้องระบุ เพราะ db เป็นบริการพื้นฐาน)

จากนั้นกลับไปที่บริการ web แล้วระบุ depends_on: db เพื่อให้แน่ใจว่า database เริ่มทำงานก่อน web server

ขั้นตอนที่ 4: ตรวจสอบและคัดลอก

ตรวจสอบผลลัพธ์ YAML ในช่อง preview ว่าถูกต้องครบถ้วน เมื่อพอใจแล้วกดปุ่ม Copy แล้วนำไปสร้างไฟล์ docker-compose.yml ในโฟลเดอร์โปรเจกต์ของคุณ

จากนั้นรันคำสั่งต่อไปนี้เพื่อสตาร์ทบริการทั้งหมด

docker compose up -d

คำสั่ง -d จะรันในโหมด detached (เบื้องหลัง) ส่วนการดู log สามารถใช้ docker compose logs -f

ทำความเข้าใจแนวคิด Docker Compose

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

Version

ในอดีตไฟล์ docker-compose.yml ต้องระบุ version ที่ด้านบน เช่น version: '3.8' แต่ใน Docker Compose สมัยใหม่ (v2 ขึ้นไป) ไม่จำเป็นต้องระบุ version อีกต่อไป เครื่องมือจะใช้ format ล่าสุดโดยอัตโนมัติ ดังนั้นไฟล์สมัยใหม่จึงขึ้นต้นด้วย services: ได้เลย โดยไม่ต้องมีบรรทัด version

Services

services คือส่วนหลักของไฟล์ ที่กำหนดแต่ละ container ที่จะรัน แต่ละ service จะมีชื่อเป็น key และ configuration เป็น value

services:
  web:
    image: nginx:alpine
  api:
    image: my-api:latest

ในตัวอย่างนี้มีสองบริการคือ web และ api แต่ละบริการสามารถเรียกหากันได้ผ่านชื่อ service โดยตรง เช่น web สามารถเรียก api ได้ที่ http://api:3000

Images

image กำหนด Docker image ที่จะใช้สร้าง container สามารถดึงจาก Docker Hub หรือ registry อื่นได้ โดยระบุ tag ที่ต้องการ

services:
  db:
    image: postgres:16-alpine
  cache:
    image: redis:7-alpine

💡 เคล็ดลับ: ควรระบุ version tag ให้ชัดเจนเสมอ เช่น postgres:16 แทนที่ postgres:latest เพื่อให้ environment มีเสถียรภาพและ reproducible

Ports

ports กำหนดการแมป port ระหว่าง host (เครื่องของคุณ) กับ container ในรูปแบบ "HOST:CONTAINER"

services:
  web:
    ports:
      - '8080:80' # host port 8080 → container port 80
      - '443:443'

ในตัวอย่างนี้ เมื่อเข้าถึง localhost:8080 บนเครื่องคุณ จะเชื่อมต่อไปยัง port 80 ใน container

⚠️ ระวัง: ในไฟล์ YAML ค่า 8080:80 อาจถูกตีความเป็นเวลา (time) ในรูปแบบ 80 นาที 8 วิ ดังนั้นควรใส่ quotes เสมอ เช่น '8080:80'

Volumes

volumes กำหนดพื้นที่จัดเก็บข้อมูลที่ persistent คือข้อมูลจะยังอยู่แม้ container ถูกลบแล้ว มีสองรูปแบบหลักคือ named volumes และ bind mounts

services:
  db:
    volumes:
      # Named volume — Docker จัดการสถานที่เก็บ
      - db-data:/var/lib/postgresql/data
      # Bind mount — ผูกกับโฟลเดอร์บน host
      - ./init-scripts:/docker-entrypoint-initdb.d

volumes:
  db-data:

• Named volume (db-data) — Docker จัดการสถานที่เก็บให้ เหมาะสำหรับข้อมูลที่ container เป็นเจ้าของ เช่น database files
• Bind mount (./init-scripts:/...) — ผูกโฟลเดอร์บน host เข้ากับ container เหมาะสำหรับ source code หรือ config files ที่ต้องการแก้ไขจาก host

Environment Variables

environment กำหนดตัวแปรที่จะส่งเข้าไปใน container มีสองรูปแบบคือ list และ map

services:
  db:
    # รูปแบบ list
    environment:
      - POSTGRES_USER=myuser
      - POSTGRES_PASSWORD=secret
    # หรือรูปแบบ map
    # environment:
    #   POSTGRES_USER: myuser
    #   POSTGRES_PASSWORD: secret

🔒 ความปลอดภัย: หลีกเลี่ยงการใส่ password หรือ secret ตรง ๆ ในไฟล์ docker-compose.yml ที่ commit เข้า git ควรใช้ .env file หรือ Docker secrets แทน

Depends On

depends_on กำหนดลำดับการเริ่มต้นของบริการ โดย service ที่ระบุจะเริ่มทำงานก่อน

services:
  web:
    depends_on:
      - db
      - cache
  db:
    image: postgres:16
  cache:
    image: redis:7

⚠️ สำคัญ: depends_on รอให้ container เริ่มต้นเท่านั้น ไม่ได้รอจนกว่าบริการจะ "พร้อมใช้งาน" (ready) เช่น database อาจเริ่ม container แล้วแต่ยัง init ไม่เสร็จ ควรใช้ร่วมกับ healthcheck หรือ retry logic ในแอปของคุณ

Restart Policies

restart กำหนดว่า container ควร restart อัตโนมัติเมื่อไร มีค่าที่ใช้บ่อยดังนี้

ค่าที่แนะนำสำหรับ production คือ unless-stopped เพราะสมดุลระหว่างความเสถียรและการควบคุม

Networks

networks กำหนด network ที่ container จะเชื่อมต่อ โดยค่าเริ่มต้น Docker Compose จะสร้าง default network ให้ แต่คุณสามารถกำหนดเองได้เพื่อแยกบริการออกจากกัน

services:
  web:
    image: nginx:alpine
    networks:
      - frontend
  api:
    image: my-api
    networks:
      - frontend
      - backend
  db:
    image: postgres:16
    networks:
      - backend

networks:
  frontend:
  backend:

ในตัวอย่างนี้ web และ api อยู่ใน frontend network (สื่อสารกันได้) api และ db อยู่ใน backend network (สื่อสารกันได้) แต่ web กับ db ไม่สามารถเข้าถึงกันได้โดยตรง ซึ่งเพิ่มความปลอดภัยให้กับ architecture

กรณีการใช้งานทั่วไป

Docker Compose Generator เหมาะสำหรับหลายสถานการณ์ ดังนี้

1. Full-Stack Web Application

สร้าง environment สำหรับแอป full-stack ที่ประกอบด้วย frontend, backend API และ database

services:
  frontend:
    image: node:20-alpine
    working_dir: /app
    volumes:
      - ./frontend:/app
    ports:
      - '3000:3000'
    command: npm run dev
    depends_on:
      - backend

  backend:
    image: node:20-alpine
    working_dir: /app
    volumes:
      - ./backend:/app
    ports:
      - '4000:4000'
    environment:
      - DATABASE_URL=postgresql://user:pass@db:5432/myapp
    command: npm run dev
    depends_on:
      - db

  db:
    image: postgres:16-alpine
    ports:
      - '5432:5432'
    environment:
      - POSTGRES_USER=user
      - POSTGRES_PASSWORD=pass
      - POSTGRES_DB=myapp
    volumes:
      - db-data:/var/lib/postgresql/data

volumes:
  db-data:

2. สภาพแวดล้อมสำหรับ Local Development

สร้าง environment ที่ใกล้เคียง production สำหรับพัฒนาบนเครื่อง local โดยไม่ต้องติดตั้ง database หรือ cache ลงบนเครื่อง ใช้กับ hot-reload เพื่อให้แก้โค้ดแล้วเห็นผลทันที

services:
  app:
    image: node:20-alpine
    working_dir: /app
    volumes:
      - .:/app
      - /app/node_modules
    ports:
      - '3000:3000'
    command: npm run dev
    environment:
      - CHOKIDAR_USEPOLLING=true
    depends_on:
      - redis

  redis:
    image: redis:7-alpine
    ports:
      - '6379:6379'

3. CI/CD Pipeline Services

สร้าง services ที่จำเป็นสำหรับการทดสอบ เช่น test database, mail server หรือ mock services ที่จะรันเฉพาะตอนรัน test suite

services:
  test-db:
    image: postgres:16-alpine
    environment:
      - POSTGRES_USER=test
      - POSTGRES_PASSWORD=test
      - POSTGRES_DB=testdb
    ports:
      - '5433:5432'

  mailhog:
    image: mailhog/mailhog
    ports:
      - '1025:1025'
      - '8025:8025'

4. Reverse Proxy และ Load Balancer

ตั้งค่า reverse proxy เช่น Nginx หรือ Traefik เพื่อ route traffic ไปยังบริการต่าง ๆ พร้อม TLS termination

services:
  proxy:
    image: nginx:alpine
    ports:
      - '80:80'
      - '443:443'
    volumes:
      - ./nginx.conf:/etc/nginx/nginx.conf:ro
    depends_on:
      - web
      - api

  web:
    image: my-frontend
    expose:
      - '80'

  api:
    image: my-backend
    expose:
      - '3000'

5. Monitoring และ Logging Stack

ตั้งค่า stack สำหรับ monitoring เช่น Prometheus + Grafana หรือ ELK stack เพื่อเก็บและวิเคราะห์ log จากแอปพลิเคชันของคุณ

services:
  prometheus:
    image: prom/prometheus
    ports:
      - '9090:9090'
    volumes:
      - ./prometheus.yml:/etc/prometheus/prometheus.yml

  grafana:
    image: grafana/grafana
    ports:
      - '3000:3000'
    depends_on:
      - prometheus

แนวทางปฏิบัติที่ดีสำหรับ Docker Compose

เพื่อให้ไฟล์ docker-compose.yml ของคุณมีประสิทธิภาพ ปลอดภัย และดูแลรักษาง่าย ควรปฏิบัติตามคำแนะนำต่อไปนี้

1. ใช้ .env File สำหรับ Secrets

หลีกเลี่ยงการใส่ password, API key หรือข้อมูลละเอียดอ่อนอื่น ๆ ตรงในไฟล์ docker-compose.yml ที่ commit เข้า git ให้ใช้ .env file แทน

# docker-compose.yml
services:
  db:
    image: postgres:16
    environment:
      - POSTGRES_PASSWORD=${DB_PASSWORD}

# .env (อย่าลืมเพิ่มเข้า .gitignore)
DB_PASSWORD=mysecretpassword

2. ระบุ Image Tag ให้ชัดเจน

อย่าใช้ latest tag เพราะ image อาจเปลี่ยนแปลงโดยไม่คาดฝัน ทำให้แอปพลิเคชันทำงานผิดปกติได้ ควรระบุ version ที่ชัดเจน

# ❌ ไม่แนะนำ
image: node:latest

# ✅ แนะนำ
image: node:20.11-alpine

3. จำกัดทรัพยากรด้วย Resource Limits

กำหนด deploy.resources เพื่อจำกัด CPU และ memory ที่ container แต่ละตัวใช้ได้ ป้องกันไม่ให้บริการหนึ่งดึงทรัพยากรจนบริการอื่นค้าง

services:
  api:
    image: my-api
    deploy:
      resources:
        limits:
          cpus: '0.5'
          memory: 512M

4. ใช้ Healthchecks เพื่อรอให้บริการพร้อม

ใช้ healthcheck ร่วมกับ depends_on.condition: service_healthy เพื่อรอให้บริการพร้อมใช้งานจริง ไม่ใช่แค่เริ่ม container

services:
  web:
    depends_on:
      db:
        condition: service_healthy

  db:
    image: postgres:16
    healthcheck:
      test: ['CMD-SHELL', 'pg_isready -U user']
      interval: 10s
      timeout: 5s
      retries: 5

5. แยกไฟล์สำหรับ Production และ Development

ใช้ docker-compose.override.yml สำหรับการตั้งค่าเฉพาะการพัฒนา (Docker Compose จะใช้ไฟล์นี้ร่วมกับไฟล์หลักโดยอัตโนมัติ) และเก็บ docker-compose.yml สำหรับ production

# docker-compose.override.yml (development)
services:
  app:
    volumes:
      - .:/app
    command: npm run dev
    environment:
      - NODE_ENV=development

6. ตั้งชื่อ Container และ Service ให้สื่อความหมาย

ตั้งชื่อ service และ container ให้สื่อถึงหน้าที่ เช่น web, api, db, cache แทนที่จะเป็น service1, service2 เพราะชื่อที่ดีช่วยให้ debug และอ่าน log ได้ง่ายขึ้น

7. ใช้ .dockerignore

เช่นเดียวกับ .gitignore การสร้าง .dockerignore ช่วยป้องกันไม่ให้ไฟล์ที่ไม่จำเป็นถูกคัดลอกเข้า image เช่น node_modules, .env, หรือ .git

node_modules
.env
.git
*.log

ลองใช้งาน Docker Compose Generator ได้เลย

พร้อมยกระดับ workflow การพัฒนาด้วย Docker ของคุณหรือยัง? ลองใช้งานเครื่องมือ Docker Compose Generator ได้ฟรีทันทีโดยไม่ต้องสมัครสมาชิก เลือกบริการที่ต้องการ กำหนด ports, volumes และ environment variables แล้วคัดลอกไฟล์ docker-compose.yml ที่พร้อมใช้งานไปใช้ในโปรเจกต์ได้เลย

ไม่ว่าคุณจะเป็นนักพัฒนาที่เพิ่งเริ่มต้นใช้งาน Docker หรือวิศวกร DevOps ที่มีประสบการณ์ Docker Compose Generator จะช่วยประหยัดเวลาและลดข้อผิดพลาดในการสร้างไฟล์ configuration ได้อย่างมีนัยสำคัญ

เครื่องมือที่เกี่ยวข้อง:

• Dockerfile Generator — สร้าง Dockerfile สำหรับสร้าง image ของแอปพลิเคชัน

ขอให้สนุกกับการใช้งาน Docker Compose!