สร้างสแต็กพัฒนาแบบหลายผู้เช่าระบบด้วย Docker: ตั้งค่าเพื่อรองรับลูกค้าที่เพิ่มขึ้น

วิธีสร้างสภาพแวดล้อมพัฒนาแบบหลายผู้เช่าระบบจากเทมเพลตที่มี 16 บริการในคอนเทนเนอร์ ซึ่งทำงานออฟไลน์ได้และยังรองรับการเข้าถึงออนไลน์ผ่านการกำหนดเส้นทางตามซับโดเมน

การจัดการสภาพแวดล้อมพัฒนาให้ลูกค้าหลายรายมักต้องเลือกระหว่างการตั้งค่าด้วยมือที่ซับซ้อนกับบริการคลาวด์ราคาแพง การนำระบบขึ้นใช้งานด้วยมือใช้เวลาและเสี่ยงต่อข้อผิดพลาด ส่วนแพลตฟอร์มคลาวด์สะดวกแต่ผูกติดกับผู้ให้บริการและมีต้นทุนต่อเนื่องที่เพิ่มขึ้นตามปริมาณใช้งาน

วันนี้เราจะอธิบายขั้นตอนการสร้างสแต็กพัฒนาแบบหลายผู้เช่าระบบที่รองรับการขยายตัว โดยแยกสภาพแวดล้อมของลูกค้าแต่ละรายอย่างรัดกุมและนำระบบขึ้นใช้งานได้อัตโนมัติ พร้อมให้คุณควบคุมโครงสร้างพื้นฐานได้ทั้งหมด แนวทางนี้ต่อยอดจากหลักการติดตั้งและดูแลระบบเองของเรา เช่นเดียวกับที่เราเคยแสดงวิธี ติดตั้งและดูแล n8n เองเพื่อทำเวิร์กโฟลว์ให้เป็นอัตโนมัติ และ นำ Windmill ขึ้นใช้งานด้วย Docker เพื่อควบคุมการดำเนินงานได้ทั้งหมด

เครื่องมือที่ใช้

เริ่มจากทำความเข้าใจหน้าที่ของแต่ละส่วนในสถาปัตยกรรมครบชุดที่มี 16 คอนเทนเนอร์:

Docker: รากฐานของการจัดบริการไว้ในคอนเทนเนอร์

Docker ช่วยแยกสภาพแวดล้อมและรักษาค่ากำหนดให้สม่ำเสมอตามที่สภาพแวดล้อมแบบหลายผู้เช่าระบบต้องการ ลูกค้าแต่ละรายมีคอนเทนเนอร์ของตนเองที่ใช้ค่ากำหนดเหมือนกัน ซึ่งช่วยให้สิ่งที่ทำงานได้ในสภาพแวดล้อมพัฒนาทำงานได้ในสภาพแวดล้อมใช้งานจริงด้วย เปรียบเสมือนมีเซิร์ฟเวอร์หลายเครื่องที่แยกจากกันบนฮาร์ดแวร์เดียวกัน แต่ยังใช้ CPU หน่วยความจำ ดิสก์และเคอร์เนลร่วมกัน

ข้อได้เปรียบสำคัญคือการแยกลูกค้าแต่ละรายออกจากกันอย่างรัดกุม ข้อมูล ค่ากำหนดและการปรับแต่งของลูกค้าแต่ละรายอยู่ในคอนเทนเนอร์ เครือข่ายและโวลุ่มที่แยกกัน จึงไม่รบกวนอีกราย เรื่องนี้สำคัญเมื่อดูแลลูกค้าธุรกิจหลายรายที่มีข้อกำหนดและความต้องการด้านความปลอดภัยต่างกัน

Traefik: reverse proxy อัจฉริยะและตัวกระจายโหลด

Traefik ทำหน้าที่ควบคุมการรับส่งคำขออย่างชาญฉลาด โดยกำหนดเส้นทางไปยังสภาพแวดล้อมของลูกค้าที่ถูกต้องตามชื่อโดเมนโดยอัตโนมัติ แทนที่จะต้องตั้งกฎ Apache หรือ Nginx ที่ซับซ้อนด้วยมือ Traefik จะอ่านป้ายกำกับจากคอนเทนเนอร์ Docker และตั้งเส้นทางให้เอง

ลองนึกถึง Traefik เป็นพนักงานต้อนรับที่รู้ว่าผู้มาเยือนแต่ละคน (คำขอ) ต้องไปสำนักงานไหน (คอนเทนเนอร์) โดยคุณไม่ต้องบอกทางทุกครั้ง ในชุดติดตั้งนี้ Traefik จัดการ SSL termination ซึ่งเป็นจุดสิ้นสุดของการเชื่อมต่อ SSL ค้นพบบริการโดยอัตโนมัติ และมีแดชบอร์ดเฝ้าติดตามระบบอย่างละเอียด

Cloudflare Tunnels: การเข้าถึงจากภายนอกอย่างปลอดภัย

Cloudflare Tunnels ช่วยให้เข้าถึงสแต็กพัฒนาในเครื่องได้อย่างปลอดภัยโดยไม่ต้องตั้งค่าไฟร์วอลล์หรือ VPN ที่ซับซ้อน แต่ละโดเมนของลูกค้ามีอุโมงค์ของตนเอง จึงแยกเส้นทางการเข้าถึงจากภายนอกของลูกค้าแต่ละรายออกจากกัน

ข้อดีคือสภาพแวดล้อมพัฒนายังคงอยู่ในเครื่องและปลอดภัย แต่ลูกค้าเข้าถึงบริการของตนได้จากทุกที่เมื่อยืนยันตัวตนอย่างถูกต้อง เช่นเดียวกับการตั้งค่าการเข้าถึงจากภายนอกอย่างปลอดภัยใน คู่มือการติดตั้งและดูแล n8n ของเรา

สแต็กบริการครบชุด: ทุกสิ่งที่ลูกค้าต้องการ

สแต็กแบบหลายผู้เช่าระบบของเรามีบริการหลักสี่หมวดหมู่ รวม 16 คอนเทนเนอร์ต่อลูกค้าหนึ่งราย:

การทำเวิร์กโฟลว์ให้เป็นอัตโนมัติและตรรกะทางธุรกิจ:

n8n: แพลตฟอร์มทำเวิร์กโฟลว์ให้เป็นอัตโนมัติครบชุด สำหรับการทำกระบวนการธุรกิจให้เป็นอัตโนมัติ
Authentik: การลงชื่อเข้าใช้ครั้งเดียวและการจัดการตัวตนระดับองค์กร (3 คอนเทนเนอร์: server, worker และแคช Redis)

ฐานข้อมูลและบริการ backend:

PostgreSQL: ฐานข้อมูล backend ที่รองรับทุกบริการอย่างมั่นคง พร้อมการจัดการพูลการเชื่อมต่อที่ปรับให้มีประสิทธิภาพ
Supabase Stack: บริการ backend-as-a-service ครบชุด ประกอบด้วย 6 คอนเทนเนอร์เฉพาะทาง (Studio, Meta, Auth, REST API, Realtime, Kong Gateway)
NocoDB: ส่วนติดต่อฐานข้อมูลแบบไม่ต้องเขียนโค้ดสำหรับจัดการข้อมูลลูกค้า

AI และความสามารถอัจฉริยะ:

Ollama: โมเดลภาษา AI ในเครื่อง พร้อมการเร่งประสิทธิภาพด้วย GPU สำหรับระบบอัตโนมัติอัจฉริยะ
Qdrant (เลือกใช้ได้): ฐานข้อมูลเวกเตอร์สำหรับเวิร์กโฟลว์ AI ขั้นสูงและการค้นหาความคล้ายคลึง

โครงสร้างพื้นฐานและการเฝ้าติดตามระบบ:

Cloudflare Tunnel: การเชื่อมต่อจากภายนอกอย่างปลอดภัย
Traefik: reverse proxy พร้อมการจัดการ SSL อัตโนมัติและแดชบอร์ดเฝ้าติดตามระบบ

ทุกส่วนทำงานร่วมกันอย่างไร

เมื่อผู้ใช้ของลูกค้าเข้าถึงสภาพแวดล้อมของตน ลำดับการทำงานทั้งหมดเป็นดังนี้:

ผู้ใช้เปิดโดเมนที่กำหนดเอง (เช่น workflows.client-a.com)
Cloudflare Tunnel ส่งคำขอไปยังอินสแตนซ์ Traefik ในเครื่องของคุณ
Traefik อ่านโดเมน ใช้มิดเดิลแวร์ (การยืนยันตัวตน, SSL และการจำกัดอัตราการเรียกใช้) แล้วส่งคำขอไปยังคอนเทนเนอร์ของลูกค้าที่ถูกต้อง
Authentik จัดการการยืนยันตัวตนแบบ SSO ให้ทุกบริการ หากตั้งค่าไว้
ลูกค้าได้สภาพแวดล้อมที่แยกไว้เฉพาะราย พร้อมข้อมูลและค่ากำหนดของตนเอง
ไม่สามารถเข้าถึงสภาพแวดล้อมของลูกค้ารายอื่นผ่านเส้นทางของลูกค้ารายนี้ได้

ทุกส่วนถูกจัดระเบียบและแยกจากกัน โดยลูกค้าแต่ละรายมีโครงสร้างซับโดเมนของตนเอง เช่น auth.client-a.com, database.client-a.com, backend.client-a.com เป็นต้น

การตั้งค่า: ขั้นตอนปฏิบัติ

เตรียมระบบพื้นฐาน

ขั้นแรกต้องติดตั้ง Docker Desktop และเตรียมระบบจัดการโดเมน เราแนะนำโครงสร้าง wildcard DNS เพื่อให้เพิ่มลูกค้าใหม่ได้ง่าย:

# Install Docker Desktop (macOS)
brew install --cask docker

# Verify installation  
docker --version
docker-compose --version

# Ensure sufficient resources for multi-container environments
# Recommended: 16GB RAM, 8+ CPU cores, 500GB+ SSD storage

สร้างระบบเทมเพลต

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

สร้างโครงสร้างไดเรกทอรีครบชุด:

mkdir -p development-stack/{template,deployments}
cd development-stack/template

# Create service-specific configuration directories
mkdir -p {traefik,authentik,supabase,init}

ตั้งค่าเทมเพลตหลายบริการครบชุด

สร้างเทมเพลต docker-compose.yml ที่มีครบทั้ง 16 บริการ เทมเพลตนี้มีไว้สำหรับการพัฒนา แดชบอร์ดของ Traefik ทำงานโดยไม่มีการยืนยันตัวตน เทมเพลตจึงเผยแพร่แดชบอร์ดและ PostgreSQL บน 127.0.0.1 เท่านั้น ซึ่งเครื่องอื่นเข้าถึงไม่ได้ (ดูหัวข้อการเสริมความปลอดภัยสำหรับสภาพแวดล้อมใช้งานจริงด้านล่าง):

version: '3.8'

networks:
  default:
    name: ${TENANT_NETWORK}
    driver: bridge

services:
  # External Connectivity
  cloudflare-tunnel:
    image: cloudflare/cloudflared:latest
    container_name: ${TENANT_PREFIX}-tunnel
    command: tunnel --no-autoupdate run --token ${CLOUDFLARE_TOKEN}
    networks:
      - default
    restart: unless-stopped
    healthcheck:
      test: ["CMD-SHELL", "cloudflared tunnel info ${TUNNEL_ID} || exit 1"]
      interval: 30s
      timeout: 10s
      retries: 3

  # Reverse Proxy & Load Balancer
  traefik:
    image: traefik:v3.0
    container_name: ${TENANT_PREFIX}-traefik
    command:
      - "--api.dashboard=true"
      - "--api.insecure=true"
      - "--providers.docker=true"
      - "--providers.docker.network=${TENANT_NETWORK}"
      - "--providers.docker.exposedbydefault=false"
      - "--entrypoints.web.address=:80"
      - "--entrypoints.websecure.address=:443"
      - "--certificatesresolvers.letsencrypt.acme.email=${ADMIN_EMAIL}"
      - "--certificatesresolvers.letsencrypt.acme.storage=/acme.json"
      - "--certificatesresolvers.letsencrypt.acme.httpchallenge.entrypoint=web"
    ports:
      - "${TRAEFIK_PORT}:80"
      - "${TRAEFIK_SECURE_PORT}:443" 
      - "127.0.0.1:${TRAEFIK_DASHBOARD_PORT}:8080"
    networks:
      - default
    volumes:
      - /var/run/docker.sock:/var/run/docker.sock:ro
      - ./traefik/acme.json:/acme.json
    healthcheck:
      test: ["CMD", "traefik", "healthcheck"]
      interval: 30s
      timeout: 10s
      retries: 3

  # Database Backend
  postgres:
    image: postgres:15-alpine
    container_name: ${TENANT_PREFIX}-postgres
    environment:
      POSTGRES_DB: ${POSTGRES_DB}
      POSTGRES_USER: ${POSTGRES_USER}
      POSTGRES_PASSWORD: ${POSTGRES_PASSWORD}
      POSTGRES_MULTIPLE_DATABASES: n8n,supabase,authentik,nocodb
    volumes:
      - postgres_data:/var/lib/postgresql/data
      - ./init:/docker-entrypoint-initdb.d
    networks:
      - default
    ports:
      - "127.0.0.1:${POSTGRES_PORT}:5432"
    healthcheck:
      test: ["CMD-SHELL", "pg_isready -U ${POSTGRES_USER} -d ${POSTGRES_DB}"]
      interval: 30s
      timeout: 10s
      retries: 5
    deploy:
      resources:
        limits:
          memory: 2G
        reservations:
          memory: 1G

  # Workflow Automation
  n8n:
    image: n8nio/n8n:latest
    container_name: ${TENANT_PREFIX}-n8n
    environment:
      DB_TYPE: postgresdb
      DB_POSTGRESDB_HOST: postgres
      DB_POSTGRESDB_DATABASE: n8n
      DB_POSTGRESDB_USER: ${POSTGRES_USER}
      DB_POSTGRESDB_PASSWORD: ${POSTGRES_PASSWORD}
      N8N_PROTOCOL: ${N8N_PROTOCOL}
      N8N_HOST: ${N8N_DOMAIN}
      N8N_PORT: 5678
      N8N_SECURE_COOKIE: ${N8N_SECURE_COOKIE}
      WEBHOOK_URL: https://${N8N_DOMAIN}
      N8N_EDITOR_BASE_URL: https://${N8N_DOMAIN}
      EXECUTIONS_DATA_PRUNE: "true"
      EXECUTIONS_DATA_MAX_AGE: 168
    volumes:
      - n8n_data:/home/node/.n8n
    networks:
      - default
    labels:
      - "traefik.enable=true"
      - "traefik.http.routers.n8n.rule=Host(`${N8N_DOMAIN}`)"
      - "traefik.http.routers.n8n.tls.certresolver=letsencrypt"
      - "traefik.http.services.n8n.loadbalancer.server.port=5678"
      - "traefik.http.routers.n8n.middlewares=${AUTH_MIDDLEWARE}"
    depends_on:
      postgres:
        condition: service_healthy

  # No-Code Database Interface  
  nocodb:
    image: nocodb/nocodb:latest
    container_name: ${TENANT_PREFIX}-nocodb
    environment:
      NC_DB: "pg://postgres:${POSTGRES_PASSWORD}@postgres:5432/nocodb"
      NC_PUBLIC_URL: https://${NOCODB_DOMAIN}
      NC_DISABLE_TELE: "true"
      NC_ADMIN_EMAIL: ${ADMIN_EMAIL}
      NC_ADMIN_PASSWORD: ${NOCODB_ADMIN_PASSWORD}
    volumes:
      - nocodb_data:/usr/app/data
    networks:
      - default
    labels:
      - "traefik.enable=true"
      - "traefik.http.routers.nocodb.rule=Host(`${NOCODB_DOMAIN}`)"
      - "traefik.http.routers.nocodb.tls.certresolver=letsencrypt"
      - "traefik.http.services.nocodb.loadbalancer.server.port=8080"
      - "traefik.http.routers.nocodb.middlewares=${AUTH_MIDDLEWARE}"
    depends_on:
      postgres:
        condition: service_healthy

  # Supabase Backend Stack (5 containers)
  supabase-studio:
    image: supabase/studio:latest
    container_name: ${TENANT_PREFIX}-supabase-studio
    environment:
      STUDIO_PG_META_URL: http://supabase-meta:8080
      POSTGRES_PASSWORD: ${POSTGRES_PASSWORD}
      DEFAULT_ORGANIZATION_NAME: ${CLIENT_NAME}
      DEFAULT_PROJECT_NAME: ${CLIENT_NAME} Project
      SUPABASE_PUBLIC_URL: https://${SUPABASE_DOMAIN}
    networks:
      - default
    labels:
      - "traefik.enable=true"
      - "traefik.http.routers.supabase-studio.rule=Host(`${SUPABASE_DOMAIN}`)"
      - "traefik.http.routers.supabase-studio.tls.certresolver=letsencrypt"
      - "traefik.http.services.supabase-studio.loadbalancer.server.port=3000"
      - "traefik.http.routers.supabase-studio.middlewares=${AUTH_MIDDLEWARE}"
    healthcheck:
      disable: true
    depends_on:
      postgres:
        condition: service_healthy

  supabase-meta:
    image: supabase/postgres-meta:latest
    container_name: ${TENANT_PREFIX}-supabase-meta
    environment:
      PG_META_PORT: 8080
      PG_META_DB_HOST: postgres
      PG_META_DB_PORT: 5432
      PG_META_DB_NAME: supabase
      PG_META_DB_USER: ${POSTGRES_USER}
      PG_META_DB_PASSWORD: ${POSTGRES_PASSWORD}
    networks:
      - default
    depends_on:
      postgres:
        condition: service_healthy

  supabase-auth:
    image: supabase/gotrue:latest
    container_name: ${TENANT_PREFIX}-supabase-auth
    environment:
      GOTRUE_API_HOST: 0.0.0.0
      GOTRUE_API_PORT: 9999
      GOTRUE_DB_DRIVER: postgres
      GOTRUE_DB_DATABASE_URL: postgres://${POSTGRES_USER}:${POSTGRES_PASSWORD}@postgres:5432/supabase
      GOTRUE_SITE_URL: https://${SUPABASE_DOMAIN}
      GOTRUE_JWT_SECRET: ${SUPABASE_JWT_SECRET}
      GOTRUE_JWT_EXP: 3600
      GOTRUE_JWT_DEFAULT_GROUP_NAME: authenticated
    networks:
      - default
    depends_on:
      postgres:
        condition: service_healthy

  supabase-rest:
    image: postgrest/postgrest:latest
    container_name: ${TENANT_PREFIX}-supabase-rest
    environment:
      PGRST_DB_URI: postgres://${POSTGRES_USER}:${POSTGRES_PASSWORD}@postgres:5432/supabase
      PGRST_DB_SCHEMAS: public,graphql_public
      PGRST_DB_ANON_ROLE: anon
      PGRST_JWT_SECRET: ${SUPABASE_JWT_SECRET}
      PGRST_DB_USE_LEGACY_GUCS: "false"
    networks:
      - default
    depends_on:
      postgres:
        condition: service_healthy

  supabase-realtime:
    image: supabase/realtime:latest
    container_name: ${TENANT_PREFIX}-supabase-realtime
    environment:
      PORT: 4000
      DB_HOST: postgres
      DB_PORT: 5432
      DB_USER: ${POSTGRES_USER}
      DB_PASSWORD: ${POSTGRES_PASSWORD}
      DB_NAME: supabase
      DB_AFTER_CONNECT_QUERY: 'SET search_path TO _realtime'
      DB_ENC_KEY: supabaserealtime
      API_JWT_SECRET: ${SUPABASE_JWT_SECRET}
      FLY_ALLOC_ID: fly123
      FLY_APP_NAME: realtime
      SECRET_KEY_BASE: ${SUPABASE_JWT_SECRET}
      ERL_AFLAGS: -proto_dist inet_tcp
      ENABLE_TAILSCALE: "false"
      DNS_NODES: "''"
    networks:
      - default
    command: >
      sh -c "/app/bin/migrate && /app/bin/realtime eval 'Realtime.Release.seeds(Realtime.Repo)' && /app/bin/server"
    depends_on:
      postgres:
        condition: service_healthy

  supabase-kong:
    image: kong:3.2-alpine
    container_name: ${TENANT_PREFIX}-supabase-kong
    environment:
      KONG_DATABASE: "off"
      KONG_DECLARATIVE_CONFIG: /var/lib/kong/kong.yml
      KONG_DNS_ORDER: LAST,A,CNAME
      KONG_PLUGINS: request-size-limiting,cors,key-auth,rate-limiting
      KONG_NGINX_PROXY_PROXY_BUFFER_SIZE: 160k
      KONG_NGINX_PROXY_PROXY_BUFFERS: 64 160k
    volumes:
      - ./supabase/kong.yml:/var/lib/kong/kong.yml:ro
    networks:
      - default
    labels:
      - "traefik.enable=true"
      - "traefik.http.routers.kong.rule=Host(`api.${CLIENT_DOMAIN}`)"
      - "traefik.http.routers.kong.tls.certresolver=letsencrypt"
      - "traefik.http.services.kong.loadbalancer.server.port=8000"
      - "traefik.http.routers.kong.middlewares=${AUTH_MIDDLEWARE}"

  # Local AI Language Models
  ollama:
    image: ollama/ollama:latest
    container_name: ${TENANT_PREFIX}-ollama
    environment:
      OLLAMA_HOST: 0.0.0.0:11434
      OLLAMA_ORIGINS: "*"
    volumes:
      - ollama_data:/root/.ollama
    networks:
      - default
    labels:
      - "traefik.enable=true"
      - "traefik.http.routers.ollama.rule=Host(`ai.${CLIENT_DOMAIN}`)"
      - "traefik.http.routers.ollama.tls.certresolver=letsencrypt"
      - "traefik.http.services.ollama.loadbalancer.server.port=11434"
      - "traefik.http.routers.ollama.middlewares=${AUTH_MIDDLEWARE}"
    deploy:
      resources:
        limits:
          memory: 16G
        reservations:
          memory: 8G
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:11434/api/tags"]
      interval: 30s
      timeout: 10s
      retries: 3

  # Enterprise SSO Authentication (3 containers)
  authentik-redis:
    image: redis:alpine
    container_name: ${TENANT_PREFIX}-authentik-redis
    command: --save 60 1 --loglevel warning
    networks:
      - default
    volumes:
      - authentik_redis_data:/data
    healthcheck:
      test: ["CMD-SHELL", "redis-cli ping | grep PONG"]
      interval: 30s
      timeout: 3s
      retries: 3

  authentik-server:
    image: ghcr.io/goauthentik/server:${AUTHENTIK_TAG}
    container_name: ${TENANT_PREFIX}-authentik-server
    command: server
    environment:
      AUTHENTIK_SECRET_KEY: ${AUTHENTIK_SECRET_KEY}
      AUTHENTIK_ERROR_REPORTING__ENABLED: "false"
      AUTHENTIK_POSTGRESQL__HOST: postgres
      AUTHENTIK_POSTGRESQL__USER: ${POSTGRES_USER}
      AUTHENTIK_POSTGRESQL__NAME: authentik
      AUTHENTIK_POSTGRESQL__PASSWORD: ${POSTGRES_PASSWORD}
      AUTHENTIK_REDIS__HOST: authentik-redis
    volumes:
      - authentik_media:/media
      - authentik_templates:/templates
    networks:
      - default
    labels:
      - "traefik.enable=true"
      - "traefik.http.routers.authentik.rule=Host(`auth.${CLIENT_DOMAIN}`)"
      - "traefik.http.routers.authentik.tls.certresolver=letsencrypt"
      - "traefik.http.services.authentik.loadbalancer.server.port=9000"
    depends_on:
      postgres:
        condition: service_healthy
      authentik-redis:
        condition: service_healthy

  authentik-worker:
    image: ghcr.io/goauthentik/server:${AUTHENTIK_TAG}
    container_name: ${TENANT_PREFIX}-authentik-worker
    command: worker
    environment:
      AUTHENTIK_SECRET_KEY: ${AUTHENTIK_SECRET_KEY}
      AUTHENTIK_ERROR_REPORTING__ENABLED: "false"
      AUTHENTIK_POSTGRESQL__HOST: postgres
      AUTHENTIK_POSTGRESQL__USER: ${POSTGRES_USER}
      AUTHENTIK_POSTGRESQL__NAME: authentik
      AUTHENTIK_POSTGRESQL__PASSWORD: ${POSTGRES_PASSWORD}
      AUTHENTIK_REDIS__HOST: authentik-redis
    volumes:
      - authentik_media:/media
      - authentik_templates:/templates
      - /var/run/docker.sock:/var/run/docker.sock
    networks:
      - default
    depends_on:
      postgres:
        condition: service_healthy
      authentik-redis:
        condition: service_healthy

  # Test Service for Health Monitoring
  whoami:
    image: traefik/whoami:latest
    container_name: ${TENANT_PREFIX}-whoami
    networks:
      - default
    labels:
      - "traefik.enable=true"
      - "traefik.http.routers.whoami.rule=Host(`test.${CLIENT_DOMAIN}`)"
      - "traefik.http.routers.whoami.tls.certresolver=letsencrypt"
      - "traefik.http.services.whoami.loadbalancer.server.port=80"

volumes:
  postgres_data:
  n8n_data:
  nocodb_data:
  ollama_data:
  authentik_redis_data:
  authentik_media:
  authentik_templates:

เทมเพลตตัวแปรสภาพแวดล้อมครบชุด

สร้าง .env.template สำหรับตัวแปรเฉพาะลูกค้าทั้งหมด:

# Client Configuration
CLIENT_NAME=CLIENT_NAME_PLACEHOLDER
CLIENT_DOMAIN=CLIENT_DOMAIN_PLACEHOLDER
TENANT_PREFIX=CLIENT_PREFIX_PLACEHOLDER
TENANT_NETWORK=CLIENT_NETWORK_PLACEHOLDER

# Service Domains (Subdomain-based routing)
N8N_DOMAIN=workflows.CLIENT_DOMAIN_PLACEHOLDER
NOCODB_DOMAIN=database.CLIENT_DOMAIN_PLACEHOLDER
SUPABASE_DOMAIN=backend.CLIENT_DOMAIN_PLACEHOLDER
AUTHENTIK_DOMAIN=auth.CLIENT_DOMAIN_PLACEHOLDER

# Infrastructure Ports
TRAEFIK_PORT=80
TRAEFIK_SECURE_PORT=443
TRAEFIK_DASHBOARD_PORT=8080
POSTGRES_PORT=5432

# Admin Configuration
ADMIN_EMAIL=admin@CLIENT_DOMAIN_PLACEHOLDER

# Database Configuration
POSTGRES_DB=main_db
POSTGRES_USER=postgres
POSTGRES_PASSWORD=SECURE_PASSWORD_PLACEHOLDER

# Service-Specific Passwords
NOCODB_ADMIN_PASSWORD=NOCODB_PASSWORD_PLACEHOLDER
SUPABASE_JWT_SECRET=SUPABASE_JWT_PLACEHOLDER

# Authentik SSO Configuration
AUTHENTIK_SECRET_KEY=AUTHENTIK_SECRET_PLACEHOLDER
AUTHENTIK_TAG=2024.8.3

# n8n Configuration
N8N_PROTOCOL=https
N8N_SECURE_COOKIE=true

# Cloudflare Integration
CLOUDFLARE_TOKEN=CLOUDFLARE_TOKEN_PLACEHOLDER
TUNNEL_ID=TUNNEL_ID_PLACEHOLDER

# Authentication Middleware (set to 'auth-global' for SSO, leave empty for no auth)
AUTH_MIDDLEWARE=

สคริปต์เริ่มต้นฐานข้อมูล

สร้างขั้นตอนเริ่มต้นฐานข้อมูลครบชุดใน init/01-create-multiple-databases.sql:

-- Create databases for all services
CREATE DATABASE n8n;
CREATE DATABASE nocodb;
CREATE DATABASE supabase;
CREATE DATABASE authentik;

-- Grant permissions
GRANT ALL PRIVILEGES ON DATABASE n8n TO postgres;
GRANT ALL PRIVILEGES ON DATABASE nocodb TO postgres;
GRANT ALL PRIVILEGES ON DATABASE supabase TO postgres;
GRANT ALL PRIVILEGES ON DATABASE authentik TO postgres;

-- Enable required extensions for Supabase
\c supabase;
CREATE EXTENSION IF NOT EXISTS "uuid-ossp";
CREATE EXTENSION IF NOT EXISTS "pgcrypto";

-- Enable required extensions for Authentik
\c authentik;
CREATE EXTENSION IF NOT EXISTS "uuid-ossp";
CREATE EXTENSION IF NOT EXISTS "pgcrypto";

\echo 'Multiple databases and extensions created successfully'

ตั้งค่า Supabase Kong Gateway

สร้าง supabase/kong.yml สำหรับกำหนดเส้นทาง API gateway:

_format_version: "3.0"

services:
  - name: auth-v1-open
    url: http://supabase-auth:9999/verify
    plugins:
      - name: cors
    routes:
      - name: auth-v1-open
        strip_path: true
        paths:
          - /auth/v1/verify
        methods:
          - POST
          - OPTIONS

  - name: auth-v1-open-callback
    url: http://supabase-auth:9999/callback
    plugins:
      - name: cors
    routes:
      - name: auth-v1-open-callback
        strip_path: true
        paths:
          - /auth/v1/callback
        methods:
          - GET
          - POST
          - OPTIONS

  - name: auth-v1
    _comment: "GoTrue: /auth/v1/* -> http://supabase-auth:9999/*"
    url: http://supabase-auth:9999/
    plugins:
      - name: cors
      - name: key-auth
        config:
          hide_credentials: false
    routes:
      - name: auth-v1-all
        strip_path: true
        paths:
          - /auth/v1/
        methods:
          - GET
          - POST
          - PUT
          - PATCH
          - DELETE
          - OPTIONS

  - name: rest-v1
    _comment: "PostgREST: /rest/v1/* -> http://supabase-rest:3000/*"
    url: http://supabase-rest:3000/
    plugins:
      - name: cors
      - name: key-auth
        config:
          hide_credentials: true
    routes:
      - name: rest-v1-all
        strip_path: true
        paths:
          - /rest/v1/
        methods:
          - GET
          - POST
          - PUT
          - PATCH
          - DELETE
          - OPTIONS

  - name: realtime-v1
    _comment: "Realtime: /realtime/v1/* -> ws://supabase-realtime:4000/socket/*"
    url: http://supabase-realtime:4000/socket/
    plugins:
      - name: cors
      - name: key-auth
        config:
          hide_credentials: false
    routes:
      - name: realtime-v1-all
        strip_path: true
        paths:
          - /realtime/v1/
        methods:
          - GET
          - POST
          - PUT
          - PATCH
          - DELETE
          - OPTIONS

consumers:
  - username: anon
    keyauth_credentials:
      - key: your-anon-key-here
  - username: service_role
    keyauth_credentials:
      - key: your-service-role-key-here

plugins:
  - name: cors
    config:
      origins:
        - "*"
      methods:
        - GET
        - POST
        - PUT
        - PATCH
        - DELETE
        - OPTIONS
      headers:
        - Accept
        - Accept-Version
        - Content-Length
        - Content-MD5
        - Content-Type
        - Date
        - X-Auth-Token
        - Authorization
        - X-Forwarded-For
        - X-Forwarded-Proto
        - X-Forwarded-Port
      exposed_headers:
        - X-Auth-Token
      credentials: true
      max_age: 3600

สคริปต์นำระบบขึ้นใช้งานอัตโนมัติ

ใช้สคริปต์นำระบบขึ้นใช้งานนี้เพื่อสร้างสภาพแวดล้อมลูกค้าใหม่ภายในไม่กี่นาที สคริปต์คำนวณพอร์ตของโฮสต์ทั้งหมด (HTTP, HTTPS และแดชบอร์ดของ Traefik รวมถึง PostgreSQL) จากเช็กซัมของคำนำหน้าลูกค้า ลูกค้าหลายรายจึงใช้โฮสต์เดียวกันได้ ให้ตรวจสอบว่าออฟเซ็ตของลูกค้าสองรายไม่ชนกัน:

#!/bin/bash
# deploy-client.sh - Complete Multi-Tenant Deployment

CLIENT_DOMAIN=$1
CLIENT_NAME=$2
CLOUDFLARE_TOKEN=$3

if [ -z "$CLIENT_DOMAIN" ] || [ -z "$CLIENT_NAME" ] || [ -z "$CLOUDFLARE_TOKEN" ]; then
    echo "Usage: ./deploy-client.sh example.com 'Client Name' 'cloudflare-token'"
    echo ""
    echo "Example: ./deploy-client.sh client-a.com 'Client A Corporation' 'your-cloudflare-token'"
    exit 1
fi

CLIENT_PREFIX=$(echo $CLIENT_DOMAIN | sed 's/[.-]//g' | tr '[:upper:]' '[:lower:]')
TIMESTAMP=$(date +%Y%m%d_%H%M%S)

echo "🚀 Deploying complete multi-tenant environment..."
echo "📋 Configuration:"
echo "   Domain: $CLIENT_DOMAIN"
echo "   Name: $CLIENT_NAME"
echo "   Prefix: $CLIENT_PREFIX"
echo "   Timestamp: $TIMESTAMP"
echo ""

# Create deployment directory
DEPLOY_DIR="../deployments/$CLIENT_DOMAIN"
mkdir -p "$DEPLOY_DIR"/{traefik,authentik,supabase,init,logs}

echo "📁 Created deployment directory structure"

# Copy template files
cp docker-compose.yml "$DEPLOY_DIR/"
cp -r {traefik,authentik,supabase,init}/ "$DEPLOY_DIR/" 2>/dev/null || true

echo "📋 Copied configuration templates"

# Generate secure passwords and secrets
POSTGRES_PASSWORD=$(openssl rand -base64 32 | tr -d "=+/" | cut -c1-25)
NOCODB_PASSWORD=$(openssl rand -base64 16 | tr -d "=+/" | cut -c1-16)
SUPABASE_JWT_SECRET=$(openssl rand -base64 64 | tr -d "=+/" | cut -c1-64)
AUTHENTIK_SECRET=$(openssl rand -hex 32)

echo "🔐 Generated secure credentials"

# Calculate unique ports to avoid conflicts
PORT_OFFSET=$(($(echo "$CLIENT_PREFIX" | cksum | cut -f1 -d' ') % 1000))
TRAEFIK_DASHBOARD_PORT=$((8080 + PORT_OFFSET))
POSTGRES_PORT=$((5432 + PORT_OFFSET))
TRAEFIK_PORT=$((10000 + PORT_OFFSET))
TRAEFIK_SECURE_PORT=$((11000 + PORT_OFFSET))

# Create comprehensive environment file
cat .env.template | \
    sed "s/CLIENT_NAME_PLACEHOLDER/$CLIENT_NAME/g" | \
    sed "s/CLIENT_DOMAIN_PLACEHOLDER/$CLIENT_DOMAIN/g" | \
    sed "s/CLIENT_PREFIX_PLACEHOLDER/$CLIENT_PREFIX/g" | \
    sed "s/CLIENT_NETWORK_PLACEHOLDER/${CLIENT_PREFIX}-network/g" | \
    sed "s/SECURE_PASSWORD_PLACEHOLDER/$POSTGRES_PASSWORD/g" | \
    sed "s/NOCODB_PASSWORD_PLACEHOLDER/$NOCODB_PASSWORD/g" | \
    sed "s/SUPABASE_JWT_PLACEHOLDER/$SUPABASE_JWT_SECRET/g" | \
    sed "s/AUTHENTIK_SECRET_PLACEHOLDER/$AUTHENTIK_SECRET/g" | \
    sed "s/CLOUDFLARE_TOKEN_PLACEHOLDER/$CLOUDFLARE_TOKEN/g" | \
    sed "s/^TRAEFIK_PORT=80$/TRAEFIK_PORT=$TRAEFIK_PORT/" | \
    sed "s/^TRAEFIK_SECURE_PORT=443$/TRAEFIK_SECURE_PORT=$TRAEFIK_SECURE_PORT/" | \
    sed "s/8080/$TRAEFIK_DASHBOARD_PORT/g" | \
    sed "s/5432/$POSTGRES_PORT/g" \
    > "$DEPLOY_DIR/.env"

echo "⚙️  Generated environment configuration"

# Create ACE file for Traefik SSL
touch "$DEPLOY_DIR/traefik/acme.json"
chmod 600 "$DEPLOY_DIR/traefik/acme.json"

# Initialize deployment
cd "$DEPLOY_DIR"

echo "🐋 Starting Docker containers..."
echo "   This may take several minutes for first-time image downloads"

# Start core infrastructure first
docker-compose up -d cloudflare-tunnel traefik postgres

echo "⏳ Waiting for database to be ready..."
sleep 30

# Start all remaining services
docker-compose up -d

echo ""
echo "✅ Multi-tenant environment deployed successfully!"
echo ""
echo "🌐 Access URLs:"
echo "   🔧 Traefik Dashboard: http://localhost:$TRAEFIK_DASHBOARD_PORT"
echo "   🔀 Workflows (n8n): https://workflows.$CLIENT_DOMAIN"
echo "   🗄️  Database (NocoDB): https://database.$CLIENT_DOMAIN"
echo "   🔧 Backend (Supabase): https://backend.$CLIENT_DOMAIN"
echo "   🤖 AI (Ollama): https://ai.$CLIENT_DOMAIN"
echo "   🔐 Authentication: https://auth.$CLIENT_DOMAIN"
echo "   🔌 API Gateway: https://api.$CLIENT_DOMAIN"
echo "   🧪 Test Service: https://test.$CLIENT_DOMAIN"
echo ""
echo "📊 Container Status:"
docker-compose ps
echo ""
echo "🔑 Generated Credentials (save these securely):"
echo "   📍 Client: $CLIENT_NAME"
echo "   🔐 PostgreSQL Password: $POSTGRES_PASSWORD"
echo "   🔐 NocoDB Admin Password: $NOCODB_PASSWORD"
echo "   🔐 Supabase JWT Secret: [hidden - check .env file]"
echo ""
echo "📝 Next Steps:"
echo "   1. Configure Cloudflare DNS: *.${CLIENT_DOMAIN} → tunnel"
echo "   2. Wait 2-3 minutes for all services to initialize"
echo "   3. Access services via the URLs above"
echo "   4. Configure SSO via auth.$CLIENT_DOMAIN if needed"
echo ""
echo "📚 Documentation: Visit tva.sg for setup guides and troubleshooting"
echo "💬 Support: Contact us via tva.sg/contact for assistance"

ใช้งานสแต็กแบบหลายผู้เช่าระบบ

นำระบบขึ้นใช้งานให้ลูกค้าใหม่

สคริปต์ครบชุดของเราทำให้การสร้างสภาพแวดล้อมของลูกค้าใหม่เป็นเรื่องง่าย:

# Deploy Client A with full enterprise stack
./deploy-client.sh client-a.com "Client A Corporation" "your-cloudflare-token"

# Deploy Client B with different domain
./deploy-client.sh client-b.org "Client B Industries" "your-cloudflare-token"

# Deploy Startup C
./deploy-client.sh startup-c.io "Startup C" "your-cloudflare-token"

การนำระบบขึ้นใช้งานแต่ละครั้งจะสร้าง:

เครือข่าย Docker เฉพาะรายพร้อม 16 คอนเทนเนอร์
โวลุ่มข้อมูลแยกต่างหากสำหรับจัดเก็บข้อมูลถาวร
คอนเทนเนอร์บริการเฉพาะรายพร้อมการตรวจสอบสถานะการทำงาน
ค่ากำหนด Cloudflare Tunnel แยกแต่ละราย
เส้นทางตามโดเมนที่กำหนดเองพร้อมใบรับรอง SSL
โครงสร้างพื้นฐาน SSO ระดับองค์กรที่พร้อมเปิดใช้งาน

จัดการหลายสภาพแวดล้อม

เฝ้าติดตามสภาพแวดล้อมของลูกค้าทั้งหมดจากจุดกลาง:

# Check all running environments across clients
docker ps --format "table {{.Names}}\t{{.Status}}\t{{.Ports}}" | grep -E "(client|startup)"

# View comprehensive logs for specific client
cd deployments/client-a.com
docker-compose logs -f --tail=50 n8n

# Health check all services for a client
docker-compose ps
docker-compose exec postgres pg_isready

# Restart specific services
docker-compose restart nocodb supabase-studio

# Update all services to latest images
docker-compose pull && docker-compose up -d

เจาะลึกสถาปัตยกรรมคอนเทนเนอร์

สถาปัตยกรรมครบชุด 16 คอนเทนเนอร์ต่อลูกค้าหนึ่งรายประกอบด้วย:

ชั้นโครงสร้างพื้นฐาน (4 คอนเทนเนอร์):

cloudflare-tunnel: การเชื่อมต่อจากภายนอกอย่างปลอดภัย
traefik: reverse proxy พร้อม SSL อัตโนมัติและการค้นพบบริการ
postgres: ฐานข้อมูลกลางพร้อมพูลการเชื่อมต่อ
whoami: การตรวจสอบสถานะการทำงานและตรวจสอบเส้นทาง

ชั้นแอปพลิเคชัน (7 คอนเทนเนอร์):

n8n: การทำเวิร์กโฟลว์ให้เป็นอัตโนมัติ โดยใช้ PostgreSQL เป็น backend
nocodb: ส่วนติดต่อฐานข้อมูลแบบไม่ต้องเขียนโค้ด
supabase-studio: แดชบอร์ดสำหรับพัฒนา backend
supabase-meta: บริการตรวจสอบโครงสร้างและข้อมูลเมตาของฐานข้อมูล
supabase-auth: การยืนยันตัวตนและการจัดการผู้ใช้
supabase-rest: REST API ที่สร้างให้อัตโนมัติ
supabase-realtime: การสมัครรับข้อมูลและการอัปเดตแบบเรียลไทม์

ชั้น AI และเกตเวย์ (2 คอนเทนเนอร์):

ollama: AI ในเครื่องที่รองรับการเร่งประสิทธิภาพด้วย GPU
supabase-kong: API gateway พร้อมการจำกัดอัตราการเรียกใช้และ CORS

ชั้นความปลอดภัยระดับองค์กร (3 คอนเทนเนอร์):

authentik-server: เซิร์ฟเวอร์ยืนยันตัวตนแบบ SSO
authentik-worker: งานเบื้องหลังและการแจ้งเตือน
authentik-redis: การจัดการเซสชันและแคช

ปรับทรัพยากรให้เหมาะกับลูกค้าแต่ละราย

ปรับทรัพยากรตามความต้องการและรูปแบบการใช้งานของลูกค้า:

# High-performance client configuration
services:
  n8n:
    deploy:
      resources:
        limits:
          cpus: '4.0'
          memory: 8G
        reservations:
          cpus: '2.0'
          memory: 4G
  
  postgres:
    deploy:
      resources:
        limits:
          cpus: '2.0'
          memory: 4G
        reservations:
          cpus: '1.0'
          memory: 2G
    environment:
      - POSTGRES_MAX_CONNECTIONS=200
      - POSTGRES_SHARED_BUFFERS=1GB
      - POSTGRES_EFFECTIVE_CACHE_SIZE=3GB

  ollama:
    deploy:
      resources:
        limits:
          memory: 32G
        reservations:
          memory: 16G
        devices:
          - driver: nvidia
            count: 1
            capabilities: [gpu]

ประโยชน์ที่ธุรกิจได้รับจริง

แยกลูกค้าแต่ละรายอย่างสมบูรณ์ พร้อมคุณสมบัติระดับองค์กร

ลูกค้าแต่ละรายได้ระบบครบชุดของตนเอง ทั้ง SSO ระดับองค์กร ความสามารถ AI และโครงสร้างพื้นฐาน backend เต็มรูปแบบ ข้อมูล ค่ากำหนด การปรับแต่งและนโยบายความปลอดภัยยังคงแยกจากกัน ปัญหาระดับแอปพลิเคชันในสภาพแวดล้อมของลูกค้ารายหนึ่งจำกัดอยู่ภายในสภาพแวดล้อมนั้น แต่เนื่องจากลูกค้าทั้งหมดใช้โฮสต์เดียวกัน ปัญหาระดับโฮสต์ เช่น ทรัพยากร CPU หน่วยความจำหรือดิสก์หมด ยังอาจส่งผลต่อทุกคนได้ ลักษณะนี้คล้ายกับการแยกสภาพแวดล้อมที่เราทำได้ด้วย การติดตั้ง n8n แยกแต่ละราย

เพิ่มลูกค้าได้รวดเร็วพร้อมคุณสมบัติครบชุด

ลูกค้าใหม่เริ่มใช้สแต็กพัฒนาและระบบอัตโนมัติครบชุดได้ภายในเวลาไม่ถึง 10 นาที สคริปต์นำระบบขึ้นใช้งานทำให้การตั้งค่า การสร้างข้อมูลรับรองและการเริ่มบริการเป็นอัตโนมัติ ส่วนระเบียน DNS ของ Cloudflare และ SSO แบบเลือกใช้ยังต้องตั้งค่าด้วยตนเองในขั้นตอนสั้น ๆ ตามคำแนะนำท้ายสคริปต์

ต้นทุนระดับองค์กรที่คาดการณ์ได้

หลังการตั้งค่าครั้งแรก ไม่มีค่าโฮสต์ต่อลูกค้ารายเพิ่มเติมนอกเหนือจากโครงสร้างพื้นฐานหลัก ต่างจาก SaaS ที่คิดค่าบริการต่อผู้ใช้ ต่อเวิร์กโฟลว์ หรือต่อการเรียก API คุณจ่ายค่าเซิร์ฟเวอร์เป็นจำนวนคงที่ และสามารถรันสภาพแวดล้อมลูกค้าพร้อมคุณสมบัติระดับองค์กรครบชุดได้เท่าที่ทรัพยากรของเซิร์ฟเวอร์รองรับ

ใช้แบรนด์อย่างสม่ำเสมอและเป็นมืออาชีพ

ลูกค้าแต่ละรายมีโดเมนภายใต้แบรนด์ของตนพร้อมซับโดเมนที่ดูเป็นมืออาชีพ (workflows.client.com, auth.client.com เป็นต้น) และปรับแต่งสภาพแวดล้อมได้ทั้งหมด ไม่มีข้อความ “powered by” ที่ส่วนท้ายหรือส่วนติดต่อที่ใช้ร่วมกันจนลดความโดดเด่นของแบรนด์

การเชื่อมต่อ n8n: ระบบเวิร์กโฟลว์อัตโนมัติระดับองค์กรที่ขยายได้

ส่วนนี้ทำให้ระบบมีความสามารถมากขึ้น เช่นเดียวกับที่เราเคยแสดงวิธี ติดตั้งและดูแล n8n เองเพื่อทำเวิร์กโฟลว์ให้เป็นอัตโนมัติ ชุดติดตั้งแบบหลายผู้เช่าระบบนี้ให้ลูกค้าแต่ละรายมีอินสแตนซ์ n8n ครบชุดของตนเอง ซึ่งเชื่อมต่อกับสแต็กระดับองค์กรเต็มรูปแบบ

ลูกค้าแต่ละรายสร้างเวิร์กโฟลว์ที่ซับซ้อนเพื่อ:

เชื่อมต่อฐานข้อมูลของตนเอง (NocoDB, Supabase PostgreSQL)
ใช้โมเดล AI ของตนเอง (Ollama) สำหรับระบบอัตโนมัติอัจฉริยะ
ยืนยันตัวตนผ่าน SSO ระดับองค์กร (Authentik)
เชื่อมต่อเครื่องมือธุรกิจและ API เฉพาะของตน
ประมวลผลข้อมูลภายในสภาพแวดล้อมที่แยกไว้เฉพาะของตน

การรวมความสามารถเหล่านี้ทำให้ได้แพลตฟอร์มให้บริการลูกค้าที่มีประสิทธิภาพ ซึ่งคุณสามารถ:

นำความสามารถระบบอัตโนมัติมาตรฐานขึ้นใช้งานได้รวดเร็ว
ปรับแต่งเวิร์กโฟลว์ให้ลูกค้าแต่ละรายโดยไม่กระทบรายอื่น
ขยายการให้บริการโดยต้นทุนไม่เพิ่มขึ้นเป็นเส้นตรง
รักษาอำนาจควบคุมข้อมูลของลูกค้าแต่ละรายได้ทั้งหมด
ให้บริการควบคุมการเข้าถึงด้วย SSO เพื่อเป็นพื้นฐานของงานด้านความปลอดภัยและการปฏิบัติตามกฎระเบียบ

แนวทางนี้ต่อยอดจากหลักการเดียวกับที่เราใช้ใน คู่มือตั้งค่า Windmill ด้วย Docker แต่ขยายให้เป็นสถาปัตยกรรมหลายผู้เช่าระบบครบชุด

ตัวเลือกการตั้งค่าขั้นสูง

ใช้ SSO ระดับองค์กรด้วย Authentik

เปิดใช้การลงชื่อเข้าใช้ครั้งเดียวสำหรับบริการทั้งหมดของลูกค้า โดยตั้งค่า forward authentication ของ Authentik:

# Add to Traefik middleware configuration
middlewares:
  auth-global:
    forwardAuth:
      address: "http://authentik-server:9000/outpost.goauthentik.io/auth/traefik"
      trustForwardHeader: true
      authResponseHeaders:
        - X-authentik-username
        - X-authentik-groups
        - X-authentik-email
        - X-authentik-name
        - X-authentik-uid

จากนั้นอัปเดตป้ายกำกับบริการให้ใช้มิดเดิลแวร์นี้:

labels:
  - "traefik.http.routers.n8n.middlewares=auth-global"
  - "traefik.http.routers.nocodb.middlewares=auth-global"
  - "traefik.http.routers.supabase-studio.middlewares=auth-global"

เพิ่มฐานข้อมูลเวกเตอร์สำหรับ AI ขั้นสูง

เพิ่มความสามารถ AI ด้วยฐานข้อมูลเวกเตอร์ Qdrant:

qdrant:
  image: qdrant/qdrant:latest
  container_name: ${TENANT_PREFIX}-qdrant
  environment:
    QDRANT__SERVICE__HTTP_PORT: 6333
    QDRANT__SERVICE__GRPC_PORT: 6334
  volumes:
    - qdrant_data:/qdrant/storage
  networks:
    - default
  labels:
    - "traefik.enable=true"
    - "traefik.http.routers.qdrant.rule=Host(`vector.${CLIENT_DOMAIN}`)"
    - "traefik.http.routers.qdrant.tls.certresolver=letsencrypt"
    - "traefik.http.services.qdrant.loadbalancer.server.port=6333"
    - "traefik.http.routers.qdrant.middlewares=${AUTH_MIDDLEWARE}"

ใช้สถาปัตยกรรม AI แบบผสม

เพื่อประสิทธิภาพสูงสุด ลองใช้แนวทางแบบผสมที่รวม AI ในคอนเทนเนอร์กับ AI ที่รันบนเครื่องโดยตรง:

# Install Ollama natively on host for GPU acceleration
brew install ollama

# Configure containers to use native Ollama
# In docker-compose.yml, services can access via host.docker.internal:11434
n8n:
  environment:
    - OLLAMA_HOST=host.docker.internal:11434

บน macOS เรื่องนี้สำคัญเพราะ Docker Desktop ไม่รองรับ GPU ในคอนเทนเนอร์ ขณะที่ Ollama ที่ทำงานแบบเนทีฟใช้การเร่งด้วย GPU ได้โดยตรง ในการตั้งค่าของเรา วิธีนี้เพิ่มประสิทธิภาพได้ประมาณ 5-6 เท่า ขณะที่บริการอื่นยังทำงานในคอนเทนเนอร์

สแต็กเฝ้าติดตามและตรวจสอบสถานะภายในระบบ

เพิ่มการเฝ้าติดตามระบบครบชุดให้ลูกค้าแต่ละราย:

prometheus:
  image: prom/prometheus:latest
  container_name: ${TENANT_PREFIX}-prometheus
  volumes:
    - ./monitoring/prometheus.yml:/etc/prometheus/prometheus.yml
    - prometheus_data:/prometheus
  networks:
    - default
  labels:
    - "traefik.enable=true"
    - "traefik.http.routers.prometheus.rule=Host(`metrics.${CLIENT_DOMAIN}`)"

grafana:
  image: grafana/grafana:latest
  container_name: ${TENANT_PREFIX}-grafana
  environment:
    GF_SECURITY_ADMIN_PASSWORD: ${GRAFANA_PASSWORD}
    GF_USERS_ALLOW_SIGN_UP: "false"
  volumes:
    - grafana_data:/var/lib/grafana
    - ./monitoring/dashboards:/var/lib/grafana/dashboards
  networks:
    - default
  labels:
    - "traefik.enable=true"
    - "traefik.http.routers.grafana.rule=Host(`monitoring.${CLIENT_DOMAIN}`)"
    - "traefik.http.routers.grafana.middlewares=${AUTH_MIDDLEWARE}"

ปัญหาที่พบบ่อยและวิธีแก้

ข้อผิดพลาด “Service Unavailable” หรือ HTTP 502

โดยทั่วไปหมายถึง Traefik เข้าถึงคอนเทนเนอร์ปลายทางไม่ได้ ให้ตรวจสอบดังนี้:

# Verify container is running and healthy
docker-compose ps
docker-compose logs traefik --tail=20

# Check container is on correct network
docker network ls
docker network inspect ${CLIENT_PREFIX}-network

# Verify Traefik labels are correct
docker-compose config --services

ปัญหาการค้นหาที่อยู่จากชื่อ DNS

การตั้งค่า wildcard DNS เป็นหัวใจสำคัญของการกำหนดเส้นทางตามซับโดเมน:

# Correct Cloudflare DNS configuration
*.client-a.com CNAME tunnel-uuid.cfargotunnel.com
*.client-b.org CNAME tunnel-uuid2.cfargotunnel.com

# Test DNS resolution
nslookup workflows.client-a.com
dig workflows.client-a.com

ทรัพยากรหมดเมื่อให้บริการลูกค้าหลายราย

เฝ้าติดตามการใช้ทรัพยากรของสภาพแวดล้อมลูกค้าทั้งหมด:

# Check overall system resource usage
docker stats --no-stream
htop

# Check disk usage per client
du -sh deployments/*/
df -h

# Monitor container memory usage
docker-compose -f deployments/*/docker-compose.yml ps --format "table {{.Name}}\t{{.Size}}"

พูลการเชื่อมต่อฐานข้อมูลเต็ม

เมื่อลูกค้ามีจำนวนมาก การเชื่อมต่อ PostgreSQL อาจถึงขีดจำกัด ให้ตั้งค่าแยกในแต่ละชุดติดตั้ง:

-- Connect to client database
docker-compose exec postgres psql -U postgres

-- Increase connection limit
ALTER SYSTEM SET max_connections = 300;
ALTER SYSTEM SET shared_buffers = '256MB';
ALTER SYSTEM SET effective_cache_size = '1GB';

-- Reload configuration
SELECT pg_reload_conf();

ปัญหาการตั้งค่า SSO ของ Authentik

ปัญหาที่พบบ่อยในการตั้งค่า SSO และวิธีแก้:

# Check Authentik containers are running
docker-compose ps | grep authentik

# Verify database initialization
docker-compose exec postgres psql -U postgres -d authentik -c "\dt"

# Check Authentik logs for startup issues
docker-compose logs authentik-server --tail=50

# Reset Authentik admin password if needed
docker-compose exec authentik-server ak create_admin_group
docker-compose exec authentik-server ak bootstrap_tasks

ปัญหาการเชื่อมต่อ Cloudflare Tunnel

ตรวจหาสาเหตุของปัญหาการเชื่อมต่ออุโมงค์:

# Check tunnel status
docker-compose logs cloudflare-tunnel --tail=20

# Verify tunnel configuration in Cloudflare dashboard
# Ensure wildcard routing: *.client-domain.com

# Test tunnel connectivity
curl -I https://test.client-domain.com

ข้อควรพิจารณาด้านโครงสร้างพื้นฐาน

กำหนดขนาดโครงสร้างพื้นฐานสำหรับลูกค้าหลายราย

สำหรับชุดติดตั้งทั่วไปที่รองรับลูกค้า 10-15 รายพร้อมกัน โดยแต่ละรายมีสแต็กครบชุด 16 คอนเทนเนอร์:

ข้อกำหนดขั้นต่ำ:

CPU: 16-24 คอร์ (2 คอร์ต่อสภาพแวดล้อมลูกค้าที่ใช้งานอยู่)
RAM: 64-128GB (4-8GB ต่อราย ขึ้นอยู่กับการใช้ AI)
พื้นที่จัดเก็บ: NVMe SSD ขนาด 2TB+ (ฐานข้อมูล โมเดล AI และบันทึกระบบจะมีขนาดเพิ่มขึ้นเรื่อย ๆ)
เครือข่าย: การเชื่อมต่อระดับ Gigabit เพื่อให้ลูกค้าเข้าถึงได้รวดเร็ว

คำแนะนำสำหรับสภาพแวดล้อมใช้งานจริง:

เซิร์ฟเวอร์: Hetzner CCX62 หรือรุ่นใกล้เคียง (48 vCPU, RAM 192GB)
พื้นที่จัดเก็บ: NVMe ขนาด 4TB พร้อมระบบสำรองข้อมูลอัตโนมัติ
เครือข่าย: การเชื่อมต่อหลายเส้นที่รองรับการทำงานทดแทนกัน
การเฝ้าติดตามระบบ: สแต็กตรวจสอบสถานะภายในระบบครบชุด พร้อมการแจ้งเตือน

กลยุทธ์สำรองข้อมูลสำหรับสภาพแวดล้อมลูกค้าหลายราย

ตั้งการสำรองข้อมูลอัตโนมัติแยกให้ลูกค้าแต่ละราย:

#!/bin/bash
# backup-all-clients.sh - Comprehensive backup solution
BACKUP_DIR="/opt/backups"
BACKUP_DATE=$(date +%Y%m%d_%H%M%S)
STACK_DIR=$(pwd)  # run from the development-stack directory
mkdir -p "$BACKUP_DIR"

for client_dir in "$STACK_DIR"/deployments/*/; do
    if [ -d "$client_dir" ]; then
        CLIENT_DOMAIN=$(basename "$client_dir")
        echo "📦 Backing up client: $CLIENT_DOMAIN"
        
        cd "$client_dir"
        
        # Backup databases with compression
        docker-compose exec -T postgres pg_dumpall -U postgres | gzip > "${BACKUP_DIR}/${CLIENT_DOMAIN}_db_${BACKUP_DATE}.sql.gz"
        
        # Backup persistent volumes
        docker run --rm \
            -v "${BACKUP_DIR}":/backup \
            -v "${CLIENT_DOMAIN//.}_n8n_data":/data/n8n:ro \
            -v "${CLIENT_DOMAIN//.}_nocodb_data":/data/nocodb:ro \
            -v "${CLIENT_DOMAIN//.}_ollama_data":/data/ollama:ro \
            alpine tar czf "/backup/${CLIENT_DOMAIN}_volumes_${BACKUP_DATE}.tar.gz" -C /data .
        
        # Backup configuration files
        tar czf "${BACKUP_DIR}/${CLIENT_DOMAIN}_config_${BACKUP_DATE}.tar.gz" \
            docker-compose.yml .env traefik/ supabase/ authentik/
        
        echo "✅ Backup completed for $CLIENT_DOMAIN"
    fi
done

# Cleanup old backups (keep 30 days)
find "$BACKUP_DIR" -name "*.gz" -mtime +30 -delete

# Optional: Upload to cloud storage
# rclone sync "$BACKUP_DIR" s3:backup-bucket/multi-tenant/

เสริมความปลอดภัยสำหรับสภาพแวดล้อมใช้งานจริง

ใช้แนวปฏิบัติด้านความปลอดภัยที่ครอบคลุม:

# Enhanced Traefik security configuration
traefik:
  command:
    - "--api.dashboard=true"
    - "--api.debug=false"
    - "--log.level=WARN"
    - "--accesslog=true"
    - "--entrypoints.web.address=:80"
    - "--entrypoints.websecure.address=:443"
    - "--entrypoints.web.http.redirections.entrypoint.to=websecure"
    - "--entrypoints.web.http.redirections.entrypoint.scheme=https"
    - "--certificatesresolvers.letsencrypt.acme.httpchallenge=true"
    - "--certificatesresolvers.letsencrypt.acme.httpchallenge.entrypoint=web"
    - "--providers.docker.exposedbydefault=false"
  labels:
    # Security headers middleware
    - "traefik.http.middlewares.security.headers.customRequestHeaders.X-Forwarded-Proto=https"
    - "traefik.http.middlewares.security.headers.customResponseHeaders.X-Frame-Options=DENY"
    - "traefik.http.middlewares.security.headers.customResponseHeaders.X-Content-Type-Options=nosniff"
    - "traefik.http.middlewares.security.headers.customResponseHeaders.Strict-Transport-Security=max-age=31536000"
    - "traefik.http.middlewares.security.headers.customResponseHeaders.Content-Security-Policy=default-src 'self'"
    
    # Rate limiting middleware
    - "traefik.http.middlewares.ratelimit.ratelimit.burst=100"
    - "traefik.http.middlewares.ratelimit.ratelimit.average=50"

ใช้มิดเดิลแวร์ความปลอดภัยกับบริการทั้งหมดของลูกค้า:

labels:
  - "traefik.http.routers.n8n.middlewares=security,ratelimit,${AUTH_MIDDLEWARE}"

วิเคราะห์ต้นทุน: ตัวเลขที่สำคัญ

ต้นทุน SaaS แบบเดิม (ลูกค้าองค์กร 10 ราย พร้อมคุณสมบัติครบชุด)

ค่าใช้จ่ายรายเดือนต่อลูกค้าหนึ่งราย:

n8n Pro: $50/เดือนต่อราย = $500/เดือน
Supabase Pro: $25/เดือนต่อราย = $250/เดือน
แพลตฟอร์มแบบไม่ต้องเขียนโค้ด (Airtable): $20/เดือนต่อราย = $200/เดือน
SSO ระดับองค์กร (Auth0): $23/เดือนต่อราย = $230/เดือน
ค่าใช้จ่าย API สำหรับ AI (OpenAI): $50/เดือนต่อราย = $500/เดือน
รวม: $1,680/เดือน = $20,160/ปี

ต้นทุนสแต็กระดับองค์กรแบบหลายผู้เช่าระบบที่ติดตั้งและดูแลเอง

ค่าใช้จ่ายโครงสร้างพื้นฐานรายปี:

เซิร์ฟเวอร์คลาวด์ที่มี vCPU เฉพาะ (Hetzner CCX62): $350/เดือน = $4,200/ปี
ค่าโดเมน (ลูกค้า 10 ราย): $120/ปี
Cloudflare Pro (เลือกใช้ได้): $240/ปี
รวม: $4,560/ปี

ประหยัดต่อปี: $15,600 (ลดต้นทุน 77%)

ตัวเลขเหล่านี้สะท้อนราคาเมื่อเผยแพร่คู่มือนี้ในเดือนสิงหาคม 2025 ณ เดือนตุลาคม 2026 แผน B2C Essentials ของ Auth0 เริ่มต้นที่ $35/เดือน และ Hetzner ไม่แสดง CCX62 ในรายการอีกต่อไป โดยรุ่นทดแทน CCX63 ที่มี 48 vCPU และหน่วยความจำ 192 GB มีราคาตามรายการ €853.99/เดือน ไม่รวม VAT โดยรวมที่อยู่ IPv4 หลักหนึ่งรายการ ให้คำนวณต้นทุนทั้งสองฝั่งใหม่ด้วยราคาปัจจุบันก่อนตัดสินใจ

นอกจากนี้คุณยังได้:

อำนาจควบคุมข้อมูลทั้งหมดและความเป็นส่วนตัว
การปรับแต่งและการใช้แบรนด์ของตนเองได้ไม่จำกัด
ไม่มีการผูกติดกับผู้ให้บริการหรือขีดจำกัดอัตราการเรียกใช้ของแผน SaaS
มาตรการควบคุมด้านความปลอดภัยและการปฏิบัติตามกฎระเบียบที่คุณดูแลเอง
ความสามารถในการขายบริการต่อ
การควบคุมการอัปเดตและคุณสมบัติทั้งหมด

แนวทางนี้ยิ่งมีประโยชน์เมื่อพิจารณาว่าชุดติดตั้งของเรามีคุณสมบัติระดับองค์กรที่ปกติต้องจ่ายค่าสมัคร SaaS สูงกว่านี้มาก เช่นเดียวกับประโยชน์ด้านต้นทุนที่เราแสดงใน บทวิเคราะห์การติดตั้งและดูแล n8n เอง

การเชื่อมต่อ WordPress: ทำให้เวิร์กโฟลว์เนื้อหาคล่องตัวขึ้น

สำหรับเอเจนซีและทีมที่ดูแลเว็บไซต์ WordPress ควบคู่กับสภาพแวดล้อมพัฒนา สแต็กแบบหลายผู้เช่าระบบนี้เชื่อมต่อกับเวิร์กโฟลว์อัตโนมัติของ WordPress ได้ดี เช่นเดียวกับที่ ปลั๊กอิน tva Duplicate Pro ของเรา ช่วยให้จัดการเนื้อหาใน WordPress ได้คล่องตัว สภาพแวดล้อมในคอนเทนเนอร์นี้ก็ทำเวิร์กโฟลว์ที่ซับซ้อนระหว่างเว็บไซต์ WordPress กับโครงสร้างพื้นฐานการพัฒนาให้เป็นอัตโนมัติได้

ตัวอย่างการเชื่อมต่อ WordPress:

การเผยแพร่เนื้อหาไปยังระบบอื่น: เวิร์กโฟลว์ n8n ที่ส่งเนื้อหา WordPress ไปยังระบบลูกค้าโดยอัตโนมัติ
การนำระบบขึ้นใช้งานอัตโนมัติ: การเปลี่ยนแปลงเว็บไซต์ WordPress กระตุ้นการนำระบบขึ้นใช้งานในสภาพแวดล้อมลูกค้า
การซิงค์ข้อมูล: การเปลี่ยนแปลงฐานข้อมูลลูกค้า (ผ่าน NocoDB) อัปเดตเนื้อหา WordPress โดยอัตโนมัติ
เนื้อหาที่สร้างด้วย AI: โมเดล Ollama สร้างเนื้อหาแล้วส่งไปยังเว็บไซต์ WordPress
รายงานสำหรับลูกค้า: รายงาน WordPress ที่สร้างอัตโนมัติจากตัวชี้วัดของสภาพแวดล้อมพัฒนา

จึงเกิดระบบนิเวศครบชุดที่การจัดการเนื้อหา WordPress เวิร์กโฟลว์พัฒนาและการให้บริการลูกค้าทำงานร่วมกันได้อย่างราบรื่น

คุ้มค่ากับเวลาที่ใช้ตั้งค่าหรือไม่

หากคุณดูแลสภาพแวดล้อมพัฒนาให้ลูกค้าหลายราย สร้างธุรกิจ SaaS หรือดำเนินงานเอเจนซีที่ให้บริการโซลูชันด้านเทคนิค คำตอบคือคุ้มค่า การตั้งค่าครั้งแรกใช้เวลาประมาณหนึ่งวัน แต่คุณจะได้:

ประโยชน์ที่ได้รับทันที:

การเพิ่มลูกค้าโดยอัตโนมัติ ภายในเวลาไม่ถึง 10 นาที พร้อมสแต็กระดับองค์กรครบชุด
การแยกสภาพแวดล้อมอย่างรัดกุม ระหว่างลูกค้า พร้อมการใช้แบรนด์อย่างมืออาชีพ
การประหยัดต้นทุนอย่างมาก เมื่อเทียบกับบริการที่ผู้ให้บริการดูแลระบบให้ (ลดลง 75%+)
การควบคุมทั้งหมด ทั้งข้อมูล การปรับแต่งและการปฏิบัติตามกฎระเบียบ
สถาปัตยกรรมที่รองรับการขยายตัว ซึ่งเติบโตไปพร้อมธุรกิจ
การควบคุมการเข้าถึงด้วย SSO โดยใช้ Authentik

คุณค่าในระยะยาว:

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

สำหรับเอเจนซีที่ให้บริการลูกค้าหลายรายหรือสตาร์ทอัพ SaaS ที่ต้องการรักษาการควบคุมขณะขยายธุรกิจ ชุดติดตั้งนี้ให้ความสามารถระดับองค์กรโดยไม่มีต้นทุนระดับองค์กร การรวมบริการในคอนเทนเนอร์ การนำระบบขึ้นใช้งานอัตโนมัติ การกำหนดเส้นทางตามโดเมนอย่างถูกต้องและความปลอดภัยระดับองค์กร เป็นรากฐานสำหรับการเติบโตทางธุรกิจอย่างจริงจังที่คุณยังควบคุมได้ทั้งหมด

ชุดติดตั้งนี้ยิ่งมีคุณค่าเมื่อพิจารณาถึงการเชื่อมต่อกับเครื่องมือที่มีอยู่ เช่น ระบบอัตโนมัติของ WordPress และความเสถียรที่พิสูจน์แล้วของ แพลตฟอร์มระบบอัตโนมัติที่ติดตั้งและดูแลเอง

ขั้นต่อไปคืออะไร

เรากำลังพัฒนาสถาปัตยกรรมหลายผู้เช่าระบบนี้อย่างต่อเนื่อง คู่มือในอนาคตจะครอบคลุม:

ตัวเลือกการนำระบบขึ้นใช้งานขั้นสูง:

คู่มือย้ายไป Kubernetes เพื่อรองรับการขยายตัวสูงสุดและการนำระบบขึ้นใช้งานระดับองค์กร
การจัดการใบรับรอง SSL อัตโนมัติ พร้อมเวิร์กโฟลว์ Let’s Encrypt ที่เชื่อมต่อไว้
การเฝ้าติดตามระบบและการแจ้งเตือนขั้นสูง ด้วย Prometheus, Grafana และแดชบอร์ดที่ปรับแต่งเอง
การกู้คืนจากภัยพิบัติอัตโนมัติ พร้อมกลยุทธ์สำรองข้อมูลหลายภูมิภาค

การปรับปรุงประสบการณ์ลูกค้า:

พอร์ทัลบริการตนเองสำหรับลูกค้า เพื่อจัดการสภาพแวดล้อมและการตั้งค่าของตนเอง
เทมเพลตการปรับแต่งภายใต้แบรนด์ของตน สำหรับแบรนด์เอเจนซี
เทมเพลตเวิร์กโฟลว์ขั้นสูง สำหรับกระบวนการธุรกิจที่พบบ่อย
คู่มือการเชื่อมต่อระบบ สำหรับเครื่องมือธุรกิจและ API ยอดนิยม

คุณสมบัติระดับองค์กร:

การเสริมความปลอดภัยขั้นสูง ด้วย WAF และการตรวจจับการบุกรุก
กรอบการปฏิบัติตามกฎระเบียบ สำหรับ GDPR, SOC2 และข้อกำหนดอื่น ๆ
กลยุทธ์นำระบบขึ้นใช้งานหลายภูมิภาค สำหรับฐานลูกค้าทั่วโลก
คู่มือเพิ่มประสิทธิภาพ สำหรับสภาพแวดล้อมที่มีปริมาณการรับส่งข้อมูลสูง

อนาคตของการให้บริการลูกค้าคือการสร้างระบบที่ให้ทั้งการควบคุมและความสะดวก พร้อมขยายได้อย่างมีประสิทธิภาพและรักษามาตรฐานความเป็นมืออาชีพ โดยไม่ต้องเลือกระหว่างสองอย่างนี้

รับความช่วยเหลือจากผู้เชี่ยวชาญ

การตั้งค่าสภาพแวดล้อมหลายผู้เช่าระบบที่มี 16 บริการในคอนเทนเนอร์ มีหลายส่วนที่ต้องประสานกัน แม้เราจะจัดทำเอกสารไว้อย่างครบถ้วน แต่แต่ละธุรกิจมีข้อกำหนดเฉพาะและโครงสร้างพื้นฐานเดิมที่ต้องพิจารณา

หากคุณกำลังนำชุดติดตั้งนี้ไปใช้ในสภาพแวดล้อมใช้งานจริง หรือต้องการปรับแต่งให้ตรงกับความต้องการในการให้บริการลูกค้า ทีมของเราช่วยได้ในด้านต่อไปนี้:

กลยุทธ์นำระบบขึ้นใช้งานที่ปรับให้เหมาะกับโครงสร้างพื้นฐานของคุณ
การเชื่อมต่อกับระบบและเวิร์กโฟลว์ที่มีอยู่
การเพิ่มประสิทธิภาพให้เหมาะกับภาระงานจากลูกค้าของคุณ
การเสริมความปลอดภัยให้ตรงตามข้อกำหนดการปฏิบัติตามกฎระเบียบ
การฝึกอบรมพนักงานด้านการจัดการสภาพแวดล้อมหลายผู้เช่าระบบ
กลยุทธ์การบำรุงรักษาและเฝ้าติดตามระบบอย่างต่อเนื่อง

ติดต่อเราผ่าน tva.sg เพื่อหารือความต้องการด้านสถาปัตยกรรมหลายผู้เช่าระบบ และรับคำแนะนำจากผู้เชี่ยวชาญในการนำระบบขึ้นใช้งาน

ไม่ว่าคุณกำลังขยายเอเจนซีที่มีอยู่ เปิดตัวแพลตฟอร์ม SaaS ใหม่ หรือสร้างขีดความสามารถในการให้บริการลูกค้าระดับองค์กร เราพร้อมช่วยให้คุณประสบความสำเร็จด้วยโซลูชันในคอนเทนเนอร์ที่ติดตั้งและดูแลเอง เพื่อรักษาความเป็นอิสระพร้อมส่งมอบผลลัพธ์อย่างมืออาชีพ