Microservices Architecture ได้เป็นแนวทางมาตรฐานในการพัฒนา Application ที่ซับซ้อน บทความนี้จะแนะนำวิธีสร้างระบบ Auto Deploy สำหรับ Microservices ด้วย Docker Compose และ GitHub Actions เพื่อให้ Deployment ของคุณเป็นไปโดยอัตโนมัติและปลอดภัย

Auto Deploy Microservices คืออะไร?

Auto Deploy Microservices เป็นกระบวนการอัตโนมัติที่ทำให้สามารถ Deploy Application ไปยัง Server ได้ทันทีเมื่อ Code มีการเปลี่ยนแปลง โดยไม่ต้องทำด้วยมือซ้ำ ๆ

ประโยชน์ของ Auto Deploy:

• เร่งความเร็ว Release Cycle: Push Code ไปยัง GitHub ก็ Deploy ไปยัง Server โดยอัตโนมัติ
• ลดข้อผิดพลาดจากมนุษย์: ไม่ต้องใช้คำสั่งทีละขั้นตอน ลดโอกาสผิดพลาด
• ประสิทธิภาพสูงขึ้น: Team สามารถ Focus ไปที่การพัฒนา Feature ใหม่ไม่ต้องกังวล Deployment
• Faster Feedback Loop: ได้รู้เร็วว่า Code ใดใช้ได้ Code ใดมีปัญหา
• Continuous Improvement: ทำให้ Code Quality ดีขึ้นจากการ Test อัตโนมัติก่อน Deploy

สิ่งที่ต้องเตรียมก่อนเริ่มต้น

• Cloud VPS: Server ที่เพียงพอสำหรับรัน Microservices (ตัวอย่าง: VPS 2GB RAM ขึ้นไป)
• Docker: ติดตั้ง Docker Engine บน VPS
• Docker Compose: ต้องติดตั้ง Docker Compose สำหรับ Orchestrate Containers
• GitHub Repository: ที่เก็บ Source Code และ Deployment Scripts
• SSH Access: ต้องมี SSH Key เพื่อให้ GitHub Actions สามารถ Deploy ไปยัง VPS ได้
• Text Editor: สำหรับแก้ไข YAML และ Code Files

สถาปัตยกรรม Microservices ตัวอย่าง

ในบทความนี้ จะสร้าง Microservices ที่ประกอบด้วย 3 Services:

• Frontend Service: React Application ที่แสดงหน้า UI (Port 3000)
• API Service: Node.js Backend API (Port 5000)
• Database Service: PostgreSQL Database (Port 5432)

Architecture นี้ง่ายต่อการสาธารณะและเหมาะสำหรับเริ่มต้นระบบ Auto Deploy

ขั้นตอนที่ 1: สร้าง Docker Compose สำหรับ Microservices

Docker Compose ช่วยให้สามารถสร้าง Multiple Containers โดยใช้ไฟล์ YAML เดียว ตัวอย่าง docker-compose.yml ดังนี้:

version: '3.8'

services:
  frontend:
    build:
      context: ./frontend
      dockerfile: Dockerfile
    ports:
      - "3000:3000"
    environment:
      - REACT_APP_API_URL=http://api:5000
    depends_on:
      - api
    networks:
      - app-network
    restart: always

  api:
    build:
      context: ./api
      dockerfile: Dockerfile
    ports:
      - "5000:5000"
    environment:
      - DATABASE_URL=postgresql://user:password@db:5432/myapp
      - NODE_ENV=production
    depends_on:
      - db
    networks:
      - app-network
    restart: always

  db:
    image: postgres:15-alpine
    volumes:
      - postgres_data:/var/lib/postgresql/data
    environment:
      - POSTGRES_USER=user
      - POSTGRES_PASSWORD=password
      - POSTGRES_DB=myapp
    networks:
      - app-network
    restart: always

volumes:
  postgres_data:

networks:
  app-network:
    driver: bridge

ส่วนประกอบสำคัญของ docker-compose.yml:

• services: ส่วนที่ระบุ Containers ที่ต้องสร้าง
• build: ระบุ Context และ Dockerfile ที่ใช้สร้าง Image
• ports: Mapping Port จาก Container ไปยัง Host
• environment: ตัวแปร Environment สำหรับ Application
• depends_on: ระบุ Service ที่ต้องเรียกใช้ก่อน
• networks: สร้าง Network เพื่อให้ Services สื่อสารกันได้
• volumes: เก็บข้อมูล Persistent โดยไม่หายเมื่อ Container ล้มลง
• restart: Policy การ Restart Container เมื่อมีข้อผิดพลาด

ขั้นตอนที่ 2: สร้าง GitHub Actions Workflow สำหรับ Auto Deploy

GitHub Actions เป็น CI/CD Tool ที่ช่วยให้ Deploy โดยอัตโนมัติเมื่อมี Code Push ไปยัง Repository สร้างไฟล์ .github/workflows/deploy.yml ดังนี้:

name: Auto Deploy Microservices

on:
  push:
    branches:
      - main
      - production

jobs:
  deploy:
    runs-on: ubuntu-latest
    steps:
      - name: Checkout Code
        uses: actions/checkout@v3

      - name: Setup SSH Key
        run: |
          mkdir -p ~/.ssh
          echo "${{ secrets.SSH_PRIVATE_KEY }}" > ~/.ssh/id_rsa
          chmod 600 ~/.ssh/id_rsa
          ssh-keyscan -H ${{ secrets.VPS_HOST }} >> ~/.ssh/known_hosts

      - name: Deploy to VPS
        run: |
          ssh -i ~/.ssh/id_rsa ${{ secrets.VPS_USER }}@${{ secrets.VPS_HOST }} << 'EOF'
            cd /app/myproject
            git pull origin main
            docker-compose down
            docker-compose build
            docker-compose up -d
            docker-compose logs -f
          EOF

      - name: Send Slack Notification
        if: always()
        uses: slackapi/slack-github-action@v1
        with:
          webhook-url: ${{ secrets.SLACK_WEBHOOK }}
          payload: |
            {
              "text": "Deployment ${{ job.status }}: ${{ github.repository }}",
              "blocks": [{
                "type": "section",
                "text": {
                  "type": "mrkdwn",
                  "text": "*Deployment Status:* ${{ job.status }}\n*Branch:* ${{ github.ref }}\n*Commit:* <${{ github.server_url }}/${{ github.repository }}/commit/${{ github.sha }}|${{ github.sha }}>"
                }
              }]
            }

ส่วนประกอบของ GitHub Actions Workflow:

• on: Trigger ที่ทำให้ Workflow ทำงาน (เช่น push ไปยัง main branch)
• jobs: ขั้นตอนการทำงานที่ต้องดำเนินการ
• steps: รายละเอียดของแต่ละขั้นตอน
• secrets: ข้อมูลที่ละเอียดอ่อน (SSH Key, VPS Host) ที่เก็บใน GitHub Secrets

ขั้นตอนที่ 3: ตั้งค่า SSH Deploy Key บน VPS

ต้องสร้าง SSH Key เพื่อให้ GitHub Actions สามารถเข้า VPS ได้โดยปลอดภัย:

# 1. สร้าง SSH Key บน VPS
ssh-keygen -t rsa -b 4096 -f ~/.ssh/github_deploy_key -N ""

# 2. เพิ่ม Public Key ไปยัง authorized_keys
cat ~/.ssh/github_deploy_key.pub >> ~/.ssh/authorized_keys
chmod 600 ~/.ssh/authorized_keys

# 3. Copy Private Key เพื่อใส่ใน GitHub Secrets
cat ~/.ssh/github_deploy_key

หลังจาก Copy Private Key แล้ว ให้ไปที่ Repository Settings > Secrets > New repository secret และสร้าง Secret ดังนี้:

• SSH_PRIVATE_KEY: Private Key ที่ได้จากคำสั่งข้างต้น
• VPS_HOST: IP Address ของ VPS
• VPS_USER: Username สำหรับ SSH (เช่น root หรือ ubuntu)
• SLACK_WEBHOOK: (Optional) Webhook URL สำหรับการแจ้งเตือน Slack

ขั้นตอนที่ 4: ทดสอบ Auto Deploy Pipeline

เมื่อ Setup เสร็จแล้ว ให้ทดสอบ Pipeline โดยการ Commit และ Push Code:

# 1. ทำการเปลี่ยนแปลง Code
echo "Deployment Test" > README.md

# 2. Commit และ Push ไปยัง GitHub
git add .
git commit -m "Test auto deployment pipeline"
git push origin main

# 3. ตรวจสอบ GitHub Actions
# ไปที่ Repository > Actions เพื่อดู Status ของ Deployment

ถ้า Workflow ทำงานสำเร็จ GitHub Actions จะแสดง Status เป็น “Success” และ Containers บน VPS จะ Update อัตโนมัติ

การจัดการ Environment Variables ให้ปลอดภัย

ไม่ควร Hardcode Secrets เช่น Database Password ไว้ในไฟล์ Config ควร ใช้วิธีจัดการอย่างปลอดภัยแทน:

วิธี 1: ใช้ .env File (Local Development)

# .env
DATABASE_URL=postgresql://user:password@localhost:5432/myapp
API_SECRET_KEY=your-secret-key-here
REACT_APP_API_URL=http://localhost:5000

วิธี 2: ใช้ GitHub Secrets (Production)

# ในไฟล์ docker-compose.yml
services:
  api:
    environment:
      - DATABASE_URL=${DATABASE_URL}
      - API_SECRET_KEY=${API_SECRET_KEY}

จากนั้นใส่ Secrets ใน GitHub Repository Settings เพื่อให้ GitHub Actions เข้าถึงได้

การ Monitor Microservices หลัง Deploy

หลัง Deploy สำเร็จแล้ว ต้องมีการ Monitor Service เพื่อให้แน่ใจว่าทำงานได้ตามปกติ:

# 1. ดูสถานะ Containers
docker-compose ps

# 2. ดู Logs ของแต่ละ Service
docker-compose logs -f api

# 3. ตรวจสอบ Health Check
docker-compose exec api curl http://localhost:5000/health

# 4. Check Resource Usage
docker stats

ระบบ Monitoring ที่แนะนำ:

• Prometheus: เก็บ Metrics จาก Microservices
• Grafana: สร้าง Dashboard สำหรับดู Metrics
• ELK Stack: รวบรวม Logs ในที่เดียว
• Sentry: Tracking Error ใน Application

สรุป

Auto Deploy Microservices ด้วย Docker Compose และ GitHub Actions เป็นวิธีที่มีประสิทธิภาพในการจัดการ Application ที่มี Multiple Services อย่างอัตโนมัติ ด้วยการตั้งค่า Workflow และ SSH Key อย่างถูกต้อง ทีมพัฒนาสามารถ Focus ไปที่การเขียน Code และไม่ต้องกังวลเรื่อง Deployment ในขณะเดียวกัน System ก็จะ Deploy โดยอัตโนมัติ ทำให้ Release Cycle เร็วขึ้นและ Error ลดลง