API Gateway AI trên Kubernetes: Istio + Định tuyến tùy chỉnh

Bước 2: Tạo VirtualService và DestinationRule

# api-gateway-config.yaml
apiVersion: networking.istio.io/v1beta1
kind: VirtualService
metadata:
  name: holysheep-ai-gateway
  namespace: ai-gateway
spec:
  hosts:
    - "ai-gateway.internal"
  gateways:
    - ai-gateway-gateway
  http:
    # Canary route: 10% traffic sang model mới
    - match:
        - headers:
            x-canary:
              exact: "deepseek-v3"
      route:
        - destination:
            host: deepseek-v3.holysheep.svc.cluster.local
            port:
              number: 8080
          weight: 100
    # Default route: 100% sang stable model
    - route:
        - destination:
            host: holysheep-api.holysheep.svc.cluster.local
            port:
              number: 8080
          weight: 100

---
apiVersion: networking.istio.io/v1beta1
kind: DestinationRule
metadata:
  name: holysheep-api
  namespace: ai-gateway
spec:
  host: holysheep-api.holysheep.svc.cluster.local
  trafficPolicy:
    connectionPool:
      tcp:
        maxConnections: 1000
      http:
        h2UpgradePolicy: UPGRADE
        http1MaxPendingRequests: 1000
        http2MaxRequests: 1000
    loadBalancer:
      simple: LEAST_REQUEST
    outlierDetection:
      consecutive5xxErrors: 5
      interval: 30s
      baseEjectionTime: 30s

Bước 3: Tạo AI Gateway Service với rate limiting

# ai-gateway-service.yaml
apiVersion: v1
kind: Service
metadata:
  name: ai-gateway
  namespace: ai-gateway
spec:
  selector:
    app: ai-gateway
  ports:
    - name: http
      port: 80
      targetPort: 8080
---
apiVersion: apps/v1
kind: Deployment
metadata:
  name: ai-gateway
  namespace: ai-gateway
spec:
  replicas: 3
  selector:
    matchLabels:
      app: ai-gateway
  template:
    metadata:
      labels:
        app: ai-gateway
    spec:
      containers:
        - name: gateway
          image: holysheep/ai-gateway:v2.1.0
          ports:
            - containerPort: 8080
          env:
            - name: HOLYSHEEP_BASE_URL
              value: "https://api.holysheep.ai/v1"
            - name: HOLYSHEEP_API_KEY
              valueFrom:
                secretKeyRef:
                  name: holysheep-credentials
                  key: api-key
            - name: RATE_LIMIT_PER_MINUTE
              value: "1000"
          resources:
            requests:
              memory: "512Mi"
              cpu: "500m"
            limits:
              memory: "1Gi"
              cpu: "2000m"
          livenessProbe:
            httpGet:
              path: /health
              port: 8080
            initialDelaySeconds: 30
            periodSeconds: 10
          readinessProbe:
            httpGet:
              path: /ready
              port: 8080
            initialDelaySeconds: 5
            periodSeconds: 5

Bước 4: Triển khai code ứng dụng

// holysheep_client.go
package main

import (
    "bytes"
    "encoding/json"
    "fmt"
    "net/http"
    "time"
    "context"
    "errors"
)

type HolySheepConfig struct {
    BaseURL string
    APIKey  string
    Timeout time.Duration
}

type ChatRequest struct {
    Model    string  json:"model"
    Messages []Message json:"messages"
    MaxTokens int     json:"max_tokens,omitempty"
    Temperature float64 json:"temperature,omitempty"
}

type Message struct {
    Role    string json:"role"
    Content string json:"content"
}

type ChatResponse struct {
    ID      string   json:"id"
    Model   string   json:"model"
    Choices []Choice json:"choices"
    Usage   Usage    json:"usage"
}

type Choice struct {
    Index        int     json:"index"
    Message      Message json:"message"
    FinishReason string  json:"finish_reason"
}

type Usage struct {
    PromptTokens     int json:"prompt_tokens"
    CompletionTokens int json:"completion_tokens"
    TotalTokens      int json:"total_tokens"
}

func NewHolySheepClient(baseURL, apiKey string) *HolySheepConfig {
    return &HolySheepConfig{
        BaseURL: baseURL,
        APIKey:  apiKey,
        Timeout: 30 * time.Second,
    }
}

func (c *HolySheepConfig) Chat(ctx context.Context, req ChatRequest) (*ChatResponse, error) {
    url := c.BaseURL + "/chat/completions"
    
    jsonData, err := json.Marshal(req)
    if err != nil {
        return nil, fmt.Errorf("failed to marshal request: %w", err)
    }

    httpReq, err := http.NewRequestWithContext(ctx, "POST", url, bytes.NewBuffer(jsonData))
    if err != nil {
        return nil, fmt.Errorf("failed to create request: %w", err)
    }

    httpReq.Header.Set("Content-Type", "application/json")
    httpReq.Header.Set("Authorization", "Bearer "+c.APIKey)

    client := &http.Client{Timeout: c.Timeout}
    resp, err := client.Do(httpReq)
    if err != nil {
        return nil, fmt.Errorf("request failed: %w", err)
    }
    defer resp.Body.Close()

    if resp.StatusCode != http.StatusOK {
        return nil, fmt.Errorf("API returned status %d", resp.StatusCode)
    }

    var chatResp ChatResponse
    if err := json.NewDecoder(resp.Body).Decode(&chatResp); err != nil {
        return nil, fmt.Errorf("failed to decode response: %w", err)
    }

    return &chatResp, nil
}

// Canary deployment: chuyển 10% request sang model mới
func (c *HolySheepConfig) ChatWithCanary(ctx context.Context, req ChatRequest, canaryPercent int) (*ChatResponse, error) {
    // Logic canary: random để distribute traffic
    if time.Now().UnixNano()%100 < int64(canaryPercent) {
        // Canary route: sử dụng DeepSeek V3.2
        req.Model = "deepseek-v3-2"
        
        client := NewHolySheepClient("https://api.holysheep.ai/v1/canary", c.APIKey)
        return client.Chat(ctx, req)
    }
    
    // Stable route
    return c.Chat(ctx, req)
}

func main() {
    // Khởi tạo client với HolySheep
    client := NewHolySheepClient(
        "https://api.holysheep.ai/v1",
        "YOUR_HOLYSHEEP_API_KEY",
    )

    ctx, cancel := context.WithTimeout(context.Background(), 60*time.Second)
    defer cancel()

    req := ChatRequest{
        Model: "gpt-4.1",
        Messages: []Message{
            {Role: "system", Content: "Bạn là trợ lý AI tiếng Việt."},
            {Role: "user", Content: "Giải thích về Kubernetes và Istio"},
        },
        MaxTokens:  500,
        Temperature: 0.7,
    }

    resp, err := client.ChatWithCanary(ctx, req, 10) // 10% canary
    if err != nil {
        fmt.Printf("Lỗi: %v\n", err)
        return
    }

    fmt.Printf("Model: %s\n", resp.Model)
    fmt.Printf("Response: %s\n", resp.Choices[0].Message.Content)
    fmt.Printf("Tokens used: %d\n", resp.Usage.TotalTokens)
}

Bước 5: Cấu hình môi trường và xoay API key an toàn

# Tạo Kubernetes Secret cho API key
kubectl create secret generic holysheep-credentials \
    --from-literal=api-key=YOUR_HOLYSHEEP_API_KEY \
    --namespace=ai-gateway

Triển khai với kubectl
kubectl apply -f api-gateway-config.yaml
kubectl apply -f ai-gateway-service.yaml

Verify deployment
kubectl get pods -n ai-gateway
kubectl get virtualservice -n ai-gateway

Xem logs để debug
kubectl logs -n ai-gateway -l app=ai-gateway --tail=100 -f

Xoay API key (rolling update)
Bước 1: Tạo key mới trên dashboard HolySheep
Bước 2: Update secret
kubectl create secret generic holysheep-credentials-new \
    --from-literal=api-key=YOUR_NEW_HOLYSHEEP_API_KEY \
    --namespace=ai-gateway

Bước 3: Rolling update deployment
kubectl rollout restart deployment/ai-gateway -n ai-gateway

Bước 4: Verify rollout thành công
kubectl rollout status deployment/ai-gateway -n ai-gateway
kubectl rollout history deployment/ai-gateway -n ai-gateway

Kết quả sau 30 ngày go-live

Lỗi thường gặp và cách khắc phục

1. Lỗi "connection timeout" khi gọi HolySheep API

# Triệu chứng: Request bị timeout sau 30s
Nguyên nhân: Firewall block outbound traffic hoặc DNS resolution fail

Cách khắc phục:
1. Kiểm tra Istio sidecar injection
kubectl get pod -n ai-gateway -o jsonpath='{.items[*].spec.containers[*].image}'

2. Verify egress traffic trong Istio
kubectl apply -f - <3. Tăng timeout trong VirtualService
Thêm vào VirtualService:
  http:
    - route:
        - destination:
            host: holysheep-api.holysheep.svc.cluster.local
      timeout: 120s

2. Lỗi "401 Unauthorized" - API key không hợp lệ

# Triệu chứng: HTTP 401 khi gọi API
Nguyên nhân: API key sai, hết hạn, hoặc không được mount đúng

Cách khắc phục:
1. Verify secret tồn tại
kubectl get secret holysheep-credentials -n ai-gateway -o yaml

2. Check secret được mount đúng
kubectl exec -it $(kubectl get pod -n ai-gateway -l app=ai-gateway -o jsonpath='{.items[0].metadata.name}') \
    -n ai-gateway -- env | grep HOLYSHEEP

3. Tái tạo secret nếu cần
kubectl delete secret holysheep-credentials -n ai-gateway
kubectl create secret generic holysheep-credentials \
    --from-literal=api-key=YOUR_HOLYSHEEP_API_KEY \
    --namespace=ai-gateway

4. Restart deployment để apply secret mới
kubectl rollout restart deployment/ai-gateway -n ai-gateway

5. Verify API key hoạt động
curl -X POST https://api.holysheep.ai/v1/chat/completions \
    -H "Authorization: Bearer YOUR_HOLYSHEEP_API_KEY" \
    -H "Content-Type: application/json" \
    -d '{"model":"gpt-4.1","messages":[{"role":"user","content":"test"}]}'

3. Lỗi Canary deployment không hoạt động

# Triệu chứng: Tất cả traffic đều đi vào một model, canary không nhận traffic
Nguyên nhân: Header matching không đúng hoặc VirtualService priority

Cách khắc phục:
1. Verify VirtualService routing order (priority matters!)
kubectl get virtualservice holysheep-ai-gateway -n ai-gateway -o yaml

2. Đảm bảo header được inject đúng cách
Trong code Go, thêm header khi gọi canary:
req.Header.Set("x-canary", "deepseek-v3")

3. Sử dụng weight-based routing thay vì header matching
kubectl apply -f - <4. Verify traffic distribution với Kiali
istioctl dashboard kiali

Tài nguyên liên quan

• 📚 Hướng dẫn AI API
• 💰 Xem giá
• 📖 Tài liệu nhà phát triển
• 🚀 Đăng ký miễn phí

Bài viết liên quan

• Token Counting Toolchain: Di Chuyển từ tiktoken/anthropic-to
• 保险智能核保系统 AI API 接入与合规：Playbook Di Chuyển Hoàn Chỉnh
• Vue.js AI Chat Component Development với API Tích Hợp — Hướn