Medusa Commerce GitOps Workflow — Deploy E-commerce ด้วย ArgoCD

Medusa Commerce คืออะไรและเหมาะกับธุรกิจแบบไหน

Medusa เป็น Open Source headless commerce platform ที่พัฒนาด้วย Node.js/TypeScript ออกแบบมาให้เป็นทางเลือกแทน Shopify สำหรับธุรกิจที่ต้องการควบคุมระบบ e-commerce ของตัวเองอย่างเต็มที่ Medusa แยก backend (API) ออกจาก frontend ทำให้สามารถใช้ frontend framework อะไรก็ได้เช่น Next.js, Gatsby หรือ Nuxt

Medusa มีฟีเจอร์หลักครบถ้วนสำหรับ e-commerce ได้แก่ Product Management สำหรับจัดการสินค้าและ variants, Order Management สำหรับจัดการคำสั่งซื้อ, Cart และ Checkout flow ที่ปรับแต่งได้, Payment Integration รองรับ Stripe PayPal และอื่นๆ, Shipping Integration รองรับหลาย fulfillment providers, Multi-region support สำหรับขายหลายประเทศ และ Plugin System สำหรับเพิ่มฟังก์ชัน

GitOps เป็นแนวทางการจัดการ infrastructure และ application deployment โดยใช้ Git เป็น single source of truth ทุกการเปลี่ยนแปลงต้องผ่าน Git commit และ Pull Request ทำให้มี audit trail ที่ชัดเจน สามารถ rollback ได้ง่าย และทีมทำงานร่วมกันได้ดี

การรวม Medusa กับ GitOps ช่วยให้การ deploy e-commerce platform เป็นไปอย่างเป็นระบบ ทุก config change ถูกบันทึกใน Git สามารถ review ก่อน apply และ rollback ได้ทันทีถ้ามีปัญหา

ติดตั้ง Medusa Commerce ด้วย Docker Compose

ตั้งค่า Medusa Backend พร้อม PostgreSQL และ Redis

# docker-compose.yml — Medusa Commerce Stack
version: '3.8'

services:
 postgres:
 image: postgres:16-alpine
 environment:
 POSTGRES_USER: medusa
 POSTGRES_PASSWORD: medusa_db_pass
 POSTGRES_DB: medusa_db
 volumes:
 - pgdata:/var/lib/postgresql/data
 ports:
 - "5432:5432"
 healthcheck:
 test: ["CMD-SHELL", "pg_isready -U medusa"]
 interval: 10s
 timeout: 5s
 retries: 5

 redis:
 image: redis:7-alpine
 ports:
 - "6379:6379"
 volumes:
 - redisdata:/data
 healthcheck:
 test: ["CMD", "redis-cli", "ping"]
 interval: 10s
 timeout: 5s
 retries: 5

 medusa-backend:
 build:
 context: ./backend
 dockerfile: Dockerfile
 environment:
 NODE_ENV: production
 DATABASE_URL: postgres://medusa:medusa_db_pass@postgres:5432/medusa_db
 REDIS_URL: redis://redis:6379
 JWT_SECRET: your-jwt-secret-key-here
 COOKIE_SECRET: your-cookie-secret-key-here
 STORE_CORS: "http://localhost:8000, https://store.example.com"
 ADMIN_CORS: "http://localhost:7001, https://admin.example.com"
 MEDUSA_ADMIN_ONBOARDING_TYPE: default
 ports:
 - "9000:9000"
 depends_on:
 postgres:
 condition: service_healthy
 redis:
 condition: service_healthy
 command: sh -c "npx medusa migrations run && npx medusa start"

 medusa-admin:
 image: node:20-alpine
 working_dir: /app
 volumes:
 - ./admin:/app
 ports:
 - "7001:7001"
 command: npm run dev
 depends_on:
 - medusa-backend

volumes:
 pgdata:
 redisdata:

# สร้าง Medusa Backend
# npx create-medusa-app@latest my-store
# cd my-store

# Dockerfile สำหรับ Medusa Backend
cat > backend/Dockerfile << 'DOCKERFILE'
FROM node:20-alpine
WORKDIR /app
COPY package*.json ./
RUN npm ci --only=production
COPY . .
RUN npm run build
EXPOSE 9000
CMD ["npx", "medusa", "start"]
DOCKERFILE

# docker compose up -d
# ทดสอบ: curl http://localhost:9000/health
# Admin: http://localhost:7001

ตั้งค่า GitOps Workflow ด้วย ArgoCD

ตั้งค่า ArgoCD สำหรับ GitOps deployment ของ Medusa Commerce

# ติดตั้ง ArgoCD บน Kubernetes
kubectl create namespace argocd
kubectl apply -n argocd -f https://raw.githubusercontent.com/argoproj/argo-cd/stable/manifests/install.yaml

# รอ ArgoCD พร้อม
kubectl wait --for=condition=available deployment/argocd-server -n argocd --timeout=300s

# ดึง admin password
kubectl -n argocd get secret argocd-initial-admin-secret -o jsonpath="{.data.password}" | base64 -d

# Kubernetes Manifests สำหรับ Medusa
# k8s/base/namespace.yaml
apiVersion: v1
kind: Namespace
metadata:
 name: medusa-commerce

---
# k8s/base/deployment.yaml
apiVersion: apps/v1
kind: Deployment
metadata:
 name: medusa-backend
 namespace: medusa-commerce
spec:
 replicas: 2
 selector:
 matchLabels:
 app: medusa-backend
 template:
 metadata:
 labels:
 app: medusa-backend
 spec:
 containers:
 - name: medusa
 image: myregistry/medusa-backend:v1.0.0
 ports:
 - containerPort: 9000
 envFrom:
 - secretRef:
 name: medusa-secrets
 - configMapRef:
 name: medusa-config
 resources:
 requests:
 cpu: 250m
 memory: 512Mi
 limits:
 cpu: 1000m
 memory: 1Gi
 readinessProbe:
 httpGet:
 path: /health
 port: 9000
 initialDelaySeconds: 30
 periodSeconds: 10
 livenessProbe:
 httpGet:
 path: /health
 port: 9000
 initialDelaySeconds: 60
 periodSeconds: 30

---
# k8s/base/service.yaml
apiVersion: v1
kind: Service
metadata:
 name: medusa-backend
 namespace: medusa-commerce
spec:
 selector:
 app: medusa-backend
 ports:
 - port: 9000
 targetPort: 9000

---
# k8s/base/configmap.yaml
apiVersion: v1
kind: ConfigMap
metadata:
 name: medusa-config
 namespace: medusa-commerce
data:
 NODE_ENV: "production"
 STORE_CORS: "https://store.example.com"
 ADMIN_CORS: "https://admin.example.com"

---
# ArgoCD Application
# k8s/argocd/medusa-app.yaml
apiVersion: argoproj.io/v1alpha1
kind: Application
metadata:
 name: medusa-commerce
 namespace: argocd
spec:
 project: default
 source:
 repoURL: https://github.com/myorg/medusa-k8s.git
 targetRevision: main
 path: k8s/overlays/production
 destination:
 server: https://kubernetes.default.svc
 namespace: medusa-commerce
 syncPolicy:
 automated:
 prune: true
 selfHeal: true
 syncOptions:
 - CreateNamespace=true
 retry:
 limit: 3
 backoff:
 duration: 5s
 maxDuration: 3m

# kubectl apply -f k8s/argocd/medusa-app.yaml

สร้าง CI/CD Pipeline สำหรับ Medusa

GitHub Actions Pipeline สำหรับ build, test และ deploy Medusa

# .github/workflows/medusa-ci-cd.yml
name: Medusa Commerce CI/CD

on:
 push:
 branches: [main, develop]
 pull_request:
 branches: [main]

env:
 REGISTRY: ghcr.io
 IMAGE_NAME: }/medusa-backend

jobs:
 test:
 runs-on: ubuntu-latest
 services:
 postgres:
 image: postgres:16-alpine
 env:
 POSTGRES_USER: test
 POSTGRES_PASSWORD: test
 POSTGRES_DB: medusa_test
 ports: ["5432:5432"]
 options: --health-cmd pg_isready --health-interval 10s --health-timeout 5s --health-retries 5
 redis:
 image: redis:7-alpine
 ports: ["6379:6379"]

 steps:
 - uses: actions/checkout@v4
 - uses: actions/setup-node@v4
 with:
 node-version: '20'
 cache: 'npm'

 - run: npm ci
 - run: npm run build

 - name: Run tests
 env:
 DATABASE_URL: postgres://test:test@localhost:5432/medusa_test
 REDIS_URL: redis://localhost:6379
 JWT_SECRET: test-secret
 COOKIE_SECRET: test-cookie
 run: |
 npx medusa migrations run
 npm test

 build-and-push:
 needs: test
 runs-on: ubuntu-latest
 if: github.ref == 'refs/heads/main'
 outputs:
 image_tag: }

 steps:
 - uses: actions/checkout@v4
 - uses: docker/login-action@v3
 with:
 registry: }
 username: }
 password: }

 - id: meta
 uses: docker/metadata-action@v5
 with:
 images: }/}
 tags: |
 type=sha, prefix=
 type=raw, value=latest

 - uses: docker/build-push-action@v5
 with:
 context: .
 push: true
 tags: }

 update-manifests:
 needs: build-and-push
 runs-on: ubuntu-latest
 steps:
 - uses: actions/checkout@v4
 with:
 repository: myorg/medusa-k8s
 token: }

 - name: Update image tag
 run: |
 SHORT_SHA=$(echo } | cut -c1-7)
 cd k8s/overlays/production
 kustomize edit set image myregistry/medusa-backend=}/}:

 - name: Commit and push
 run: |
 git config user.name "GitHub Actions"
 git config user.email "actions@github.com"
 git add .
 git commit -m "Deploy medusa-backend: }"
 git push

จัดการ Database Migration และ Seed Data

สร้าง migration workflow ที่ปลอดภัยสำหรับ production

#!/bin/bash
# scripts/migrate.sh — Safe Database Migration
set -euo pipefail

echo "=== Medusa Database Migration ==="
echo "Environment: "
echo "Database: @***"
echo "Date: $(date -u +%Y-%m-%dT%H:%M:%SZ)"

# 1. Backup ก่อน migrate
echo "[1/4] Creating database backup..."
BACKUP_FILE="/tmp/medusa_backup_$(date +%Y%m%d_%H%M%S).sql"
pg_dump "$DATABASE_URL" > "$BACKUP_FILE"
echo " Backup saved: $BACKUP_FILE ($(du -sh $BACKUP_FILE | cut -f1))"

# 2. รัน migration (dry-run ก่อน)
echo "[2/4] Checking pending migrations..."
npx medusa migrations run --dry-run 2>&1 | tee /tmp/migration_plan.txt
PENDING=$(grep -c "migration" /tmp/migration_plan.txt || true)
echo " Pending migrations: $PENDING"

if [ "$PENDING" -eq 0 ]; then
 echo "No pending migrations. Done."
 exit 0
fi

# 3. รัน migration จริง
echo "[3/4] Running migrations..."
npx medusa migrations run 2>&1 | tee /tmp/migration_result.txt

if [ $? -ne 0 ]; then
 echo "ERROR: Migration failed! Rolling back..."
 psql "$DATABASE_URL" < "$BACKUP_FILE"
 echo "Rollback complete."
 exit 1
fi

# 4. Verify
echo "[4/4] Verifying migration..."
npx medusa migrations run --dry-run 2>&1 | grep -c "migration" && echo " WARNING: Still pending!" || echo " All migrations applied."

echo "=== Migration Complete ==="

# Seed data script
cat > scripts/seed.js << 'SEED'
const { MedusaContainer } = require("@medusajs/medusa");

async function seed() {
 const container = await MedusaContainer.init();
 const productService = container.resolve("productService");
 const regionService = container.resolve("regionService");

 // สร้าง Region
 const region = await regionService.create({
 name: "Thailand",
 currency_code: "thb",
 tax_rate: 7,
 payment_providers: ["manual"],
 fulfillment_providers: ["manual"],
 countries: ["th"],
 });
 console.log(`Region created: `);

 // สร้าง Product
 const product = await productService.create({
 title: "Sample T-Shirt",
 description: "A comfortable cotton t-shirt",
 handle: "sample-tshirt",
 is_giftcard: false,
 options: [{ title: "Size" }],
 variants: [
 { title: "S", prices: [{ amount: 590, currency_code: "thb" }], options: [{ value: "S" }], inventory_quantity: 100 },
 { title: "M", prices: [{ amount: 590, currency_code: "thb" }], options: [{ value: "M" }], inventory_quantity: 100 },
 { title: "L", prices: [{ amount: 590, currency_code: "thb" }], options: [{ value: "L" }], inventory_quantity: 100 },
 ],
 });
 console.log(`Product created: `);
}

seed().then(() => process.exit(0)).catch(e => { console.error(e); process.exit(1); });
SEED

Monitoring และ Rollback Strategy

ตั้งค่า monitoring และ automated rollback สำหรับ Medusa deployment

#!/usr/bin/env python3
# medusa_monitor.py — Medusa Commerce Health Monitor
import requests
import time
import json
from datetime import datetime

MEDUSA_URL = "http://localhost:9000"
ARGOCD_URL = "http://argocd-server.argocd.svc:443"
ARGOCD_TOKEN = "your-argocd-token"
SLACK_WEBHOOK = "https://hooks.slack.com/services/xxx"

def check_health():
 try:
 r = requests.get(f"{MEDUSA_URL}/health", timeout=10)
 return r.status_code == 200
 except Exception:
 return False

def check_api():
 endpoints = [
 "/store/products?limit=1",
 "/store/regions",
 "/store/collections",
 ]
 results = {}
 for ep in endpoints:
 try:
 r = requests.get(f"{MEDUSA_URL}{ep}", timeout=10)
 results[ep] = {
 "status": r.status_code,
 "latency": r.elapsed.total_seconds(),
 "ok": r.status_code == 200
 }
 except Exception as e:
 results[ep] = {"status": 0, "latency": 0, "ok": False, "error": str(e)}
 return results

def rollback_argocd(app_name="medusa-commerce"):
 headers = {"Authorization": f"Bearer {ARGOCD_TOKEN}"}
 
 # Get current sync history
 r = requests.get(
 f"{ARGOCD_URL}/api/v1/applications/{app_name}",
 headers=headers, verify=False
 )
 app = r.json()
 history = app.get("status", {}).get("history", [])
 
 if len(history) < 2:
 print("No previous revision to rollback to")
 return False
 
 prev_revision = history[-2]["revision"]
 print(f"Rolling back to revision: {prev_revision}")
 
 # Rollback
 r = requests.post(
 f"{ARGOCD_URL}/api/v1/applications/{app_name}/rollback",
 headers=headers,
 json={"id": history[-2]["id"]},
 verify=False
 )
 return r.status_code == 200

def notify(message, severity="info"):
 icon = {"critical": "🔴", "warning": "🟡", "info": "🟢"}[severity]
 print(f"[{icon}] {datetime.now()} {message}")
 if SLACK_WEBHOOK and severity != "info":
 requests.post(SLACK_WEBHOOK, json={"text": f"{icon} {message}"})

def monitor_loop():
 consecutive_failures = 0
 max_failures = 3
 
 print(f"Medusa Monitor started: {MEDUSA_URL}")
 
 while True:
 healthy = check_health()
 api_results = check_api()
 all_ok = all(r["ok"] for r in api_results.values())
 
 if healthy and all_ok:
 consecutive_failures = 0
 latencies = [r["latency"] for r in api_results.values() if r["ok"]]
 avg_lat = sum(latencies) / len(latencies) if latencies else 0
 
 if avg_lat > 2.0:
 notify(f"High latency: {avg_lat:.2f}s", "warning")
 else:
 consecutive_failures += 1
 failed = [ep for ep, r in api_results.items() if not r["ok"]]
 notify(f"Health check failed ({consecutive_failures}/{max_failures}): {failed}", "warning")
 
 if consecutive_failures >= max_failures:
 notify("Triggering automatic rollback!", "critical")
 if rollback_argocd():
 notify("Rollback initiated successfully", "warning")
 consecutive_failures = 0
 else:
 notify("Rollback failed! Manual intervention required", "critical")
 
 time.sleep(30)

if __name__ == "__main__":
 monitor_loop()

FAQ คำถามที่พบบ่อย

Q: Medusa กับ Shopify ต่างกันอย่างไร?

A: Medusa เป็น Open Source self-hosted ไม่มีค่าบริการรายเดือน ปรับแต่งได้ 100% เหมาะสำหรับธุรกิจที่ต้องการ full control ส่วน Shopify เป็น SaaS ใช้งานง่ายไม่ต้องจัดการ server แต่มีค่าบริการรายเดือนและ transaction fee ปรับแต่งได้จำกัด สำหรับ startup ที่มีทีม dev แนะนำ Medusa สำหรับธุรกิจที่ไม่มีทีม dev แนะนำ Shopify

Q: GitOps ดีกว่า CI/CD แบบปกติอย่างไร?

A: GitOps ใช้ Git เป็น single source of truth ทำให้ทุกการเปลี่ยนแปลงถูกบันทึกและ review ได้ สามารถ rollback ได้ด้วย git revert มี drift detection ที่ตรวจจับเมื่อ cluster state ไม่ตรงกับ Git ส่วน CI/CD แบบปกติอาจมี manual changes ที่ไม่ถูกบันทึก GitOps เหมาะสำหรับ Kubernetes environments

Q: Database migration กับ GitOps ทำอย่างไร?

A: ควรแยก migration ออกจาก application deployment โดยรัน migration เป็น Kubernetes Job หรือ init container ก่อนที่ application จะ start ต้อง backup database ก่อน migrate เสมอ ใช้ backward-compatible migrations ที่ทำงานได้กับทั้ง code เวอร์ชันเก่าและใหม่ ห้ามลบ column โดยตรงแต่ต้อง deprecate ก่อน

Q: ArgoCD กับ Flux CD ควรเลือกอันไหน?

A: ArgoCD มี Web UI ที่สวยและใช้งานง่าย มี application-centric approach เหมาะสำหรับทีมที่ต้องการ visibility ส่วน Flux CD เป็น lightweight มากกว่า ใช้ CRDs เป็นหลัก เหมาะสำหรับทีมที่ prefer CLI-first approach ทั้งสองตัวเป็น CNCF graduated projects สำหรับผู้เริ่มต้นแนะนำ ArgoCD เพราะ UI ช่วยให้เข้าใจง่าย