วิธีตั้งค่าและใช้งาน Temporal.io เพื่อสร้าง Workflow แบบ Server‑less บน Kubernetes อย่างปลอดภัย

ภาพรวม — Overview

Temporal.io เป็นแพลตฟอร์มจัดการ workflow ที่ให้ความสามารถด้าน reliability, scalability และ visibility โดยไม่ต้องเขียนโค้ดสำหรับ retry หรือ timeout เอง บน Kubernetes เราสามารถใช้ Temporal ในรูปแบบ *server‑less* ได้โดยรัน worker เป็น container แยกจากแอปพลิเคชันหลัก ทำให้การจัดการ workflow ง่ายขึ้นและปลอดภัยต่อความผิดพลาดของโค้ด

บทความนี้จะสอนขั้นตอนตั้งค่า Temporal บน Kubernetes, สร้าง workflow เบื้องต้น, และวิธีทำให้ระบบเป็น *server‑less* พร้อมคำแนะนำด้านความปลอดภัย

ความต้องการเบื้องต้น — Prerequisites

เพื่อเริ่มใช้งานได้อย่างรวดเร็ว เราต้องเตรียมสิ่งต่อไปนี้

• Kubernetes cluster (เวอร์ชัน 1.21 ขึ้นไป) พร้อม `kubectl` เชื่อมต่อ
• Helm 3.x สำหรับติดตั้ง Temporal ผ่าน chart
• Docker หรือ Container runtime ที่รองรับ image ของ Temporal
• ภาษาโปรแกรมที่ Temporal สนับสนุน (เช่น Go, Java, TypeScript)

**Tip: ควรใช้ namespace แยกสำหรับ Temporal เพื่อจำกัดการเข้าถึงและทำให้การจัดการสิทธิ์ง่ายขึ้น

การติดตั้ง Temporal Server บน Kubernetes — Install Temporal Server

1. เพิ่ม Helm repository

```bash helm repo add temporal https://charts.temporal.io helm repo update ```

2. ตั้งค่า values เบื้องต้น

สร้างไฟล์ `temporal-values.yaml` ด้วยการกำหนด resource limits, persistence และ network policy

```yaml server: replicaCount: 3 # ทำให้มี 3 pod เพื่อความทนทาน resources: requests: cpu: "500m" memory: "512Mi" limits: cpu: "1" memory: "1Gi"

mysql: enabled: true # ใช้ MySQL เป็น backend storage persistence: size: 20Gi

networkPolicy: enabled: true # ปิดการเข้าถึงจากภายนอกโดยไม่ได้รับอนุญาต ```

3. ติดตั้งด้วย Helm

```bash helm install temporal temporal/temporal -f temporal-values.yaml --namespace temporal-system --create-namespace ```

หลังติดตั้งเสร็จ `kubectl get pods -n temporal-system` ควรเห็น pod ของ frontend, history, matching และ worker กำลังทำงาน

การสร้าง Workflow แบบ Server‑less — Create Server‑less Workflow

1. เตรียมโค้ด Workflow (ตัวอย่าง Go)

```go package workflows

import ( "go.temporal.io/sdk/workflow" )

func SampleWorkflow(ctx workflow.Context, input string) (string, error) { // กำหนด timeout ให้กับ activity ทั้งหมดที่เรียกใช้ ao := workflow.ActivityOptions{ StartToCloseTimeout: time.Minute, } ctx = workflow.WithActivityOptions(ctx, ao)

var result string err := workflow.ExecuteActivity(ctx, SampleActivity, input).Get(ctx, &result) return result, err } ```

2. สร้าง Activity

```go func SampleActivity(ctx context.Context, input string) (string, error) { // ประมวลผลที่นี่ return fmt.Sprintf("Processed: %s", input), nil } ```

3. แพ็กเกจ Worker ให้เป็น Docker image

Dockerfile อย่างง่าย

```dockerfile FROM golang:1.22-alpine AS builder WORKDIR /app COPY . . RUN go build -o worker ./cmd/worker

FROM alpine:latest COPY --from=builder /app/worker /usr/local/bin/ ENTRYPOINT ["worker"] ```

สร้าง image และ push ไปยัง registry ที่ Kubernetes สามารถดึงได้

```bash docker build -t myrepo/temporal-worker:v1 . docker push myrepo/temporal-worker:v1 ```

4. Deploy Worker เป็น Job (Server‑less)

```yaml apiVersion: batch/v1 kind: Job metadata: name: temporal-worker-job namespace: app-namespace spec: template: spec: containers:

• name: worker

image: myrepo/temporal-worker:v1 env:

• name: TEMPORAL_ADDRESS

value: "temporal-frontend.temporal-system.svc.cluster.local:7233"

• name: NAMESPACE

value: "default" restartPolicy: OnFailure ```

Job จะเริ่มทำงานเมื่อมี workflow ใหม่เข้าคิว และหยุดเมื่องานเสร็จ ทำให้ไม่ต้องคอยรัน worker ตลอดเวลา server‑less

**Tip: ใช้ `restartPolicy: Never` ถ้าต้องการให้ Job รันเพียงครั้งเดียวและไม่มี retry อัตโนมัติจาก Kubernetes

การจัดการความปลอดภัยบน Kubernetes — Security Practices

• NetworkPolicy: จำกัดการเข้าถึงพอร์ต 7233 ของ Temporal frontend ให้เฉพาะ namespace ที่รัน worker เท่านั้น
• RBAC: สร้าง ServiceAccount เฉพาะสำหรับ Worker แล้วผูก Role ที่ให้สิทธิ์ `get`, `list`, `watch` บน resources ของ Temporal CRDs (ถ้าใช้ Operator)
• Secret Management: เก็บค่าเช่น MySQL credentials หรือ TLS certificates ใน Kubernetes Secret และอ้างอิงผ่าน envFrom หรือ volumeMounts
• PodSecurityPolicy / OPA Gatekeeper: ป้องกันการรัน container ด้วย `privileged` mode หรือ mount ไฟล์ระบบที่ไม่จำเป็น

การตรวจสอบและมอนิเตอร์ Workflow — Observability

Temporal มี built‑in visibility ผ่าน UI (`temporal-web`) และ metrics ที่ส่งออกเป็น Prometheus format

• ติดตั้ง Prometheus และ Grafana ในคลัสเตอร์เดียวกัน
• เปิด `metrics.enabled` ใน Helm values เพื่อให้ Temporal ส่ง metric ไปยัง `/metrics` endpoint
• เพิ่ม Dashboard ของ Temporal (มีให้ดาวน์โหลดจาก repo ของ Temporal) เพื่อตรวจสอบ latency, failed activities, และ task queue length

**Tip: ตั้ง alert ที่ `task_queue_pending_tasks > 1000` เพื่อแจ้งเตือนเมื่อคิวเริ่มอัดแน่น

ขั้นตอนสรุปการทำงานทั้งหมด — Step‑by‑Step Summary

• **ขั้นตอนที่ 1: เตรียม Kubernetes, Helm และ namespace สำหรับ Temporal
• **ขั้นตอนที่ 2: ปรับค่า `temporal-values.yaml` เพื่อเปิด NetworkPolicy, กำหนด resource limits, ใช้ MySQL persistence
• **ขั้นตอนที่ 3: ติดตั้ง Temporal Server ด้วย Helm chart
• **ขั้นตอนที่ 4: เขียน Workflow และ Activity ในภาษาที่ต้องการ (Go/Java/TS) แล้วสร้าง Docker image ของ worker
• **ขั้นตอนที่ 5: Deploy worker เป็น Kubernetes Job หรือ CronJob เพื่อให้ทำงานแบบ server‑less
• **ขั้นตอนที่ 6: กำหนด RBAC, Secrets, NetworkPolicy เพื่อความปลอดภัยสูงสุด
• **ขั้นตอนที่ 7: เปิด Prometheus metrics และตั้งค่า Grafana Dashboard เพื่อติดตามการทำงาน

สรุป — Summary

Temporal.io ช่วยให้เราสร้าง workflow ที่มี reliability สูงโดยไม่ต้องจัดการ retry หรือ state เอง การใช้ Temporal บน Kubernetes แบบ server‑less ทำได้โดย:

• ติดตั้ง Temporal Server ผ่าน Helm ด้วย security config พื้นฐาน
• สร้าง worker เป็น Docker image แล้วรันเป็น Job/ CronJob เพื่อให้ทำงานเมื่อมี workflow เข้ามาเท่านั้น
• ใช้ NetworkPolicy, RBAC และ Secrets เพื่อควบคุมการเข้าถึงและปกป้องข้อมูลสำคัญ

สิ่งที่ควรจำ

• ปรับ resource limits ให้เหมาะกับ workload ของคุณ
• อย่าลืมเปิด NetworkPolicy เพื่อตัดการเชื่อมต่อจากภายนอกโดยไม่ได้รับอนุญาต
• ใช้ Prometheus + Grafana ตรวจสอบและตั้ง alert ก่อนที่คิวจะอัดแน่น

ด้วยขั้นตอนเหล่านี้ คุณสามารถสร้างระบบ workflow บน Kubernetes ที่ปลอดภัย, ยืดหยุ่น และทำงานแบบ server‑less ได้ทันที.