Portkey AI Gateway 2026: Cổng LLM Quản lý 200+ Mô hình với Khả năng Quan sát — Thiết lập Production

# Sao chép repository
git clone https://github.com/Portkey-AI/gateway.git
cd gateway

# Chạy với Docker
docker run -p 8787:8787 -e PORTKEY_GATEWAY_API_KEY=your-gateway-key portkeyai/gateway:latest

version: '3.8'
services:
  portkey-gateway:
    image: portkeyai/gateway:latest
    ports:
      - "8787:8787"
    environment:
      - PORTKEY_GATEWAY_API_KEY=${GATEWAY_API_KEY}
      - CACHE_ENABLED=true
      - CACHE_TTL=3600
    volumes:
      - ./config:/app/config
    restart: unless-stopped

apiVersion: apps/v1
kind: Deployment
metadata:
  name: portkey-gateway
spec:
  replicas: 3
  selector:
    matchLabels:
      app: portkey-gateway
  template:
    metadata:
      labels:
        app: portkey-gateway
    spec:
      containers:
      - name: gateway
        image: portkeyai/gateway:latest
        ports:
        - containerPort: 8787
        env:
        - name: PORTKEY_GATEWAY_API_KEY
          valueFrom:
            secretKeyRef:
              name: portkey-secrets
              key: gateway-api-key
---
apiVersion: v1
kind: Service
metadata:
  name: portkey-gateway-service
spec:
  selector:
    app: portkey-gateway
  ports:
  - port: 80
    targetPort: 8787
  type: ClusterIP

providers:
  openai-primary:
    type: openai
    api_key: ${OPENAI_API_KEY}
    organization: ${OPENAI_ORG_ID}
    
  anthropic-primary:
    type: anthropic
    api_key: ${ANTHROPIC_API_KEY}
    
  azure-gpt4:
    type: azure-openai
    api_key: ${AZURE_API_KEY}
    resource_name: ${AZURE_RESOURCE_NAME}
    deployment_id: gpt-4
    api_version: 2025-12-01
    
  google-gemini:
    type: google
    api_key: ${GOOGLE_API_KEY}
    
  mistral-local:
    type: mistral
    api_key: ${MISTRAL_API_KEY}
    base_url: http://mistral-service:8000/v1

# Đặt biến môi trường
export OPENAI_API_KEY="sk-..."
export ANTHROPIC_API_KEY="sk-ant-..."
export GATEWAY_API_KEY="pk-..."

# Khởi động cổng với cấu hình
docker run -p 8787:8787 \
  -e PORTKEY_GATEWAY_API_KEY=$GATEWAY_API_KEY \
  -v $(pwd)/providers.yaml:/app/config/providers.yaml \
  portkeyai/gateway:latest

curl -X POST http://localhost:8787/v1/chat/completions \
  -H "Authorization: Bearer ${GATEWAY_API_KEY}" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "gpt-4o",
    "provider": "openai-primary",
    "messages": [
      {"role": "system", "content": "Bạn là một trợ lý hữu ích."},
      {"role": "user", "content": "Giải thích điện toán lượng tử bằng thuật ngữ đơn giản."}
    ]
  }'

# Yêu cầu giống hệt, nhà cung cấp khác — chỉ cần thay đổi trường model/provider
curl -X POST http://localhost:8787/v1/chat/completions \
  -H "Authorization: Bearer ${GATEWAY_API_KEY}" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "claude-sonnet-4",
    "provider": "anthropic-primary",
    "messages": [
      {"role": "user", "content": "Giải thích điện toán lượng tử bằng thuật ngữ đơn giản."}
    ],
    "max_tokens": 1024
  }'

from portkey_ai import Portkey

# Khởi tạo client
portkey = Portkey(
    api_key="your-gateway-api-key",
    virtual_key="openai-primary"  # Tham chiếu nhà cung cấp đã cấu hình
)

# Hoàn thành trò chuyện
response = portkey.chat.completions.create(
    model="gpt-4o",
    messages=[
        {"role": "system", "content": "Bạn là một trợ lý hữu ích."},
        {"role": "user", "content": "Viết hàm Python để tính số fibonacci."}
    ]
)
print(response.choices[0].message.content)

import portkey_ai

portkey = portkey_ai.Portkey(api_key="your-gateway-api-key")

stream = portkey.chat.completions.create(
    model="gpt-4o",
    messages=[{"role": "user", "content": "Viết một bài thơ về AI."}],
    stream=True
)

for chunk in stream:
    if chunk.choices[0].delta.content:
        print(chunk.choices[0].delta.content, end="")

# config/load-balance.yaml
strategies:
  gpt4-pool:
    type: load_balance
    providers:
      - provider: openai-primary
        weight: 1
      - provider: azure-gpt4
        weight: 1
      - provider: openai-backup
        weight: 1

# Sử dụng pool cân bằng tải
response = portkey.chat.completions.create(
    model="gpt-4o",
    config="gpt4-pool",  # Tham chiếu chiến lược
    messages=[{"role": "user", "content": "Xin chào!"}]
)

strategies:
  production-fallback:
    type: fallback
    targets:
      - provider: azure-gpt4
        timeout: 10
        retry: 2
      - provider: openai-primary
        timeout: 15
        retry: 1
      - provider: anthropic-primary
        model: claude-sonnet-4
        timeout: 15
      - provider: google-gemini
        model: gemini-2.5-pro
        timeout: 20

# Cổng thử từng mục tiêu theo thứ tự cho đến khi một cái thành công
curl -X POST http://localhost:8787/v1/chat/completions \
  -H "Authorization: Bearer ${GATEWAY_API_KEY}" \
  -H "Content-Type: application/json" \
  -d '{
    "config": "production-fallback",
    "messages": [{"role": "user", "content": "Truy vấn kinh doanh quan trọng"}]
  }'

strategies:
  smart-router:
    type: conditional
    rules:
      - condition: "request.messages[0].content.length > 4000"
        target: 
          provider: anthropic-primary
          model: claude-sonnet-4  # Xử lý ngữ cảnh dài tốt hơn
      - condition: "request.user == 'code-assistant'"
        target:
          provider: openai-primary
          model: gpt-4o
      - condition: "default"
        target:
          provider: azure-gpt4
          model: gpt-4o-mini

cache:
  enabled: true
  mode: semantic  # hoặc "exact" cho lưu đệm khớp chính xác
  ttl: 3600       # Thờ gian sống của bộ nhớ đệm tính bằng giây
  max_size: 10000 # Số lượng mục được lưu đệm tối đa
  similarity_threshold: 0.95  # Cho lưu đệm ngữ nghĩa

# Lần gọi đầu tiên truy cập nhà cung cấp và lưu đệm kết quả
response1 = portkey.chat.completions.create(
    model="gpt-4o",
    messages=[{"role": "user", "content": "Kubernetes là gì?"}],
    cache=True
)

# Lần gọi tương tự trả về kết quả được lưu đệm ngay lập tức với chi phí thấp hơn
response2 = portkey.chat.completions.create(
    model="gpt-4o",
    messages=[{"role": "user", "content": "Giải thích Kubernetes cho tôi"}],
    cache=True
)

# Kiểm tra chỉ số bộ nhớ đệm
curl http://localhost:8787/v1/admin/cache/stats \
  -H "Authorization: Bearer ${GATEWAY_API_KEY}"

# Làm mất hiệu lực các mục bộ nhớ đệm cụ thể
curl -X POST http://localhost:8787/v1/admin/cache/invalidate \
  -H "Authorization: Bearer ${GATEWAY_API_KEY}" \
  -H "Content-Type: application/json" \
  -d '{
    "pattern": "kubernetes",
    "provider": "openai-primary"
  }'

import portkey_ai

portkey = portkey_ai.Portkey(
    api_key="your-gateway-api-key",
    metadata={
        "user_id": "user-12345",
        "project": "customer-support-bot",
        "environment": "production",
        "team": "ai-platform"
    }
)

response = portkey.chat.completions.create(
    model="gpt-4o",
    messages=[{"role": "user", "content": "Giúp với đơn hàng của tôi"}]
)

# Truy cập thông tin chi phí từ phản hồi
print(f"Token đầu vào: {response.usage.prompt_tokens}")
print(f"Token đầu ra: {response.usage.completion_tokens}")
print(f"Tổng chi phí: ${response.usage.estimated_cost}")

# Nhận báo cáo chi tiêu theo nhà cung cấp
curl "http://localhost:8787/v1/admin/analytics/spend?start_date=2026-05-01&end_date=2026-05-19&group_by=provider" \
  -H "Authorization: Bearer ${GATEWAY_API_KEY}"

# Nhận báo cáo chi tiêu theo ngưởi dùng
curl "http://localhost:8787/v1/admin/analytics/spend?start_date=2026-05-01&end_date=2026-05-19&group_by=user_id" \
  -H "Authorization: Bearer ${GATEWAY_API_KEY}"

alerts:
  daily-budget:
    type: budget
    threshold: 500  # USD
    period: daily
    channels:
      - type: webhook
        url: https://hooks.slack.com/services/YOUR/WEBHOOK/URL
      - type: email
        address: team@company.com
  
  abnormal-spike:
    type: anomaly
    baseline_multiplier: 3
    window: 1h
    channels:
      - type: pagerduty
        integration_key: your-pd-key

from portkey_ai import Portkey

portkey = Portkey(api_key="your-gateway-api-key")

# Triển khai phiên bản prompt
prompt = portkey.prompts.deploy(
    name="customer-support-classifier",
    version="1.2.0",
    prompt=[
        {"role": "system", "content": "Bạn là bộ phân loại phiếu hỗ trợ. Phân loại phiếu vào: Thanh toán, Kỹ thuật, Yêu cầu Tính năng, hoặc Khiếu nại."},
        {"role": "user", "content": "Phiếu: {{ticket_content}}"}
    ],
    model="gpt-4o-mini",
    parameters={
        "temperature": 0.2,
        "max_tokens": 50
    }
)

# Kết xuất và thực thi prompt được quản lý
response = portkey.prompts.render(
    name="customer-support-classifier",
    variables={
        "ticket_content": "Tôi đã bị tính phí hai lần cho đăng ký tháng này."
    }
)

print(response.choices[0].message.content)
# Kết quả: "Thanh toán"

# Chạy A/B test giữa các phiên bản prompt
response = portkey.prompts.render(
    name="customer-support-classifier",
    version="1.2.0",  # 50% lưu lượng
    test_version="1.3.0-beta",  # 50% lưu lượng
    variables={"ticket_content": "Ứng dụng gặp sự cố khi tải ảnh lên"}
)

guardrails:
  input-validation:
    - type: keyword_filter
      blocklist: ["password", "ssn", "credit_card", "secret_key"]
      action: block
    - type: pii_detector
      entities: ["email", "phone", "ssn"]
      action: mask
    - type: toxicity_check
      threshold: 0.8
      action: block
      
  output-validation:
    - type: content_policy
      categories: ["hate", "violence", "self-harm"]
      action: block
    - type: response_format
      required_schema:
        type: json_object
      action: retry

# Áp dụng rào chắn bảo vệ cho yêu cầu
response = portkey.chat.completions.create(
    model="gpt-4o",
    messages=[{"role": "user", "content": "Nội dung nhập của ngưởi dùng"}],
    guardrails=["input-validation", "output-validation"]
)

from portkey_ai import Portkey
import json

portkey = Portkey(api_key="your-gateway-api-key")

def custom_validator(request, response):
    """Xác thực logic kinh doanh tùy chỉnh."""
    try:
        data = json.loads(response.choices[0].message.content)
        if "confidence" not in data or data["confidence"] < 0.7:
            return False, "Điểm tin cậy quá thấp"
        return True, None
    except json.JSONDecodeError:
        return False, "Phản hồi phải là JSON hợp lệ"

portkey.guardrails.register("confidence-check", custom_validator)

# Truy vấn nhật ký yêu cầu gần đây
curl "http://localhost:8787/v1/admin/logs?limit=100&status=error" \
  -H "Authorization: Bearer ${GATEWAY_API_KEY}"

# Bật ghi log chi tiết cho mỗi yêu cầu
response = portkey.chat.completions.create(
    model="gpt-4o",
    messages=[{"role": "user", "content": "Xin chào"}],
    metadata={
        "trace_id": "trace-abc-123",
        "session_id": "session-xyz-789",
        "user_id": "user-456"
    }
)

observability:
  tracing:
    enabled: true
    exporter: otlp
    endpoint: http://jaeger-collector:4317
  metrics:
    enabled: true
    exporter: prometheus
    port: 9090

# Thu thập số liệu
curl http://localhost:8787/metrics

{
  "dashboard": {
    "title": "Tổng quan Portkey AI Gateway",
    "panels": [
      {
        "title": "Yêu cầu mỗi Giây",
        "targets": [
          {
            "expr": "rate(portkey_requests_total[5m])"
          }
        ]
      },
      {
        "title": "Độ trễ P95",
        "targets": [
          {
            "expr": "histogram_quantile(0.95, portkey_request_duration_seconds_bucket)"
          }
        ]
      },
      {
        "title": "Sử dụng Token",
        "targets": [
          {
            "expr": "sum by (model) (portkey_tokens_total)"
          }
        ]
      }
    ]
  }
}

# docker-compose production với Redis để lưu đệm và PostgreSQL để ghi log
version: '3.8'
services:
  gateway:
    image: portkeyai/gateway:latest
    ports:
      - "8787:8787"
    environment:
      - PORTKEY_GATEWAY_API_KEY=${GATEWAY_API_KEY}
      - REDIS_URL=redis://redis:6379
      - DATABASE_URL=postgres://user:pass@postgres:5432/portkey
    depends_on:
      - redis
      - postgres
    deploy:
      replicas: 3
      resources:
        limits:
          memory: 2G
          cpus: '1.0'
  
  redis:
    image: redis:7-alpine
    volumes:
      - redis-data:/data
  
  postgres:
    image: postgres:16-alpine
    environment:
      POSTGRES_DB: portkey
      POSTGRES_USER: user
      POSTGRES_PASSWORD: ${DB_PASSWORD}
    volumes:
      - postgres-data:/var/lib/postgresql/data

volumes:
  redis-data:
  postgres-data:

# Điểm cuối sức khỏe gateway
curl http://localhost:8787/health

# Phản hồi mong đợi
{"status": "healthy", "version": "2.5.0", "uptime": 86400}

# Probe liveness và readiness Kubernetes
livenessProbe:
  httpGet:
    path: /health
    port: 8787
  initialDelaySeconds: 10
  periodSeconds: 15

readinessProbe:
  httpGet:
    path: /ready
    port: 8787
  initialDelaySeconds: 5
  periodSeconds: 5

import openai

client = openai.OpenAI(
    api_key="your-portkey-gateway-key",
    base_url="http://localhost:8787/v1"
)

# Mã hiện có của bạn hoạt động không thay đổi
response = client.chat.completions.create(...)