Proxy cho kiến trúc microservices: bảo vệ API, cân bằng tải và an ninh

Quan trọng: Trong kiến trúc microservices, proxy hoạt động ở hai cấp độ — như một cổng vào cho khách hàng (API Gateway) và như các proxy nội bộ giữa các dịch vụ (Service Mesh). Cả hai cấp độ đều rất quan trọng cho an ninh và độ tin cậy của hệ thống.

// Ví dụ cấu hình NGINX như API Gateway
upstream auth_service {
    server auth:8001;
}

upstream user_service {
    server user:8002;
}

upstream order_service {
    server order:8003;
}

server {
    listen 80;
    server_name api.example.com;

    # Giới hạn tần suất yêu cầu
    limit_req_zone $binary_remote_addr zone=api_limit:10m rate=10r/s;

    location /api/auth/ {
        limit_req zone=api_limit burst=20;
        proxy_pass http://auth_service/;
        proxy_set_header X-Real-IP $remote_addr;
        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
    }

    location /api/users/ {
        # Kiểm tra token trước khi proxy
        auth_request /auth/verify;
        proxy_pass http://user_service/;
    }

    location /api/orders/ {
        auth_request /auth/verify;
        proxy_pass http://order_service/;
    }

    # Endpoint nội bộ để kiểm tra token
    location = /auth/verify {
        internal;
        proxy_pass http://auth_service/verify;
        proxy_pass_request_body off;
        proxy_set_header Content-Length "";
    }
}

# Ví dụ cấu hình Istio VirtualService cho định tuyến
apiVersion: networking.istio.io/v1beta1
kind: VirtualService
metadata:
  name: user-service
spec:
  hosts:
  - user-service
  http:
  - match:
    - headers:
        version:
          exact: "v2"
    route:
    - destination:
        host: user-service
        subset: v2
  - route:
    - destination:
        host: user-service
        subset: v1
      weight: 90
    - destination:
        host: user-service
        subset: v2
      weight: 10  # Triển khai canary: 10% lưu lượng đến v2

---
# Circuit Breaker để bảo vệ khỏi các lỗi chuỗi
apiVersion: networking.istio.io/v1beta1
kind: DestinationRule
metadata:
  name: user-service
spec:
  host: user-service
  trafficPolicy:
    connectionPool:
      tcp:
        maxConnections: 100
      http:
        http1MaxPendingRequests: 50
        maxRequestsPerConnection: 2
    outlierDetection:
      consecutiveErrors: 5
      interval: 30s
      baseEjectionTime: 30s
      maxEjectionPercent: 50

// Python: cấu hình proxy cho requests đến các API bên ngoài
import requests
from requests.adapters import HTTPAdapter
from urllib3.util.retry import Retry

class ExternalAPIClient:
    def __init__(self, proxy_url, proxy_rotation=False):
        self.session = requests.Session()
        
        # Cấu hình proxy
        self.proxies = {
            'http': proxy_url,
            'https': proxy_url
        }
        
        # Logic thử lại để đảm bảo độ bền
        retry_strategy = Retry(
            total=3,
            backoff_factor=1,
            status_forcelist=[429, 500, 502, 503, 504],
            allowed_methods=["GET", "POST"]
        )
        adapter = HTTPAdapter(max_retries=retry_strategy)
        self.session.mount("http://", adapter)
        self.session.mount("https://", adapter)
    
    def call_payment_api(self, data):
        """Yêu cầu đến API thanh toán thông qua proxy"""
        try:
            response = self.session.post(
                'https://api.payment-provider.com/charge',
                json=data,
                proxies=self.proxies,
                timeout=10,
                headers={'User-Agent': 'MyService/1.0'}
            )
            response.raise_for_status()
            return response.json()
        except requests.exceptions.RequestException as e:
            # Ghi log lỗi
            print(f"Lỗi API thanh toán: {e}")
            raise

# Sử dụng với một nhóm proxy để xoay vòng
class ProxyPool:
    def __init__(self, proxy_list):
        self.proxies = proxy_list
        self.current = 0
    
    def get_next(self):
        proxy = self.proxies[self.current]
        self.current = (self.current + 1) % len(self.proxies)
        return proxy

# Khởi tạo
proxy_pool = ProxyPool([
    'http://user:pass@proxy1.example.com:8080',
    'http://user:pass@proxy2.example.com:8080',
    'http://user:pass@proxy3.example.com:8080'
])

# Đối với mỗi yêu cầu, sử dụng proxy tiếp theo
client = ExternalAPIClient(proxy_pool.get_next())

// Node.js: proxy cho các API bên ngoài với xoay vòng tự động
const axios = require('axios');
const HttpsProxyAgent = require('https-proxy-agent');

class ExternalAPIService {
  constructor(proxyList) {
    this.proxyList = proxyList;
    this.currentProxyIndex = 0;
    this.requestCounts = new Map(); // Bộ đếm yêu cầu cho giới hạn tần suất
  }

  getNextProxy() {
    const proxy = this.proxyList[this.currentProxyIndex];
    this.currentProxyIndex = (this.currentProxyIndex + 1) % this.proxyList.length;
    return proxy;
  }

  async callAPI(endpoint, data, options = {}) {
    const proxyUrl = this.getNextProxy();
    const agent = new HttpsProxyAgent(proxyUrl);

    // Giới hạn tần suất: không quá 100 yêu cầu mỗi phút trên proxy
    const proxyKey = proxyUrl;
    const now = Date.now();
    const count = this.requestCounts.get(proxyKey) || { count: 0, resetTime: now + 60000 };
    
    if (count.count >= 100 && now < count.resetTime) {
      // Chuyển sang proxy tiếp theo
      return this.callAPI(endpoint, data, options);
    }

    try {
      const response = await axios({
        method: options.method || 'POST',
        url: endpoint,
        data: data,
        httpsAgent: agent,
        timeout: options.timeout || 10000,
        headers: {
          'User-Agent': 'Mozilla/5.0 (compatible; MyService/1.0)',
          ...options.headers
        }
      });

      // Cập nhật bộ đếm
      if (now >= count.resetTime) {
        this.requestCounts.set(proxyKey, { count: 1, resetTime: now + 60000 });
      } else {
        count.count++;
      }

      return response.data;
    } catch (error) {
      if (error.response?.status === 429) {
        // Vượt quá giới hạn tần suất - chuyển sang proxy khác
        console.log(`Giới hạn tần suất trên ${proxyUrl}, chuyển proxy`);
        return this.callAPI(endpoint, data, options);
      }
      throw error;
    }
  }
}

// Sử dụng
const apiService = new ExternalAPIService([
  'http://user:pass@proxy1.example.com:8080',
  'http://user:pass@proxy2.example.com:8080'
]);

module.exports = apiService;

# Cấu hình HAProxy cho cân bằng tải với kiểm tra tình trạng
global
    maxconn 4096
    log stdout format raw local0

defaults
    mode http
    timeout connect 5s
    timeout client 50s
    timeout server 50s
    option httplog

frontend api_frontend
    bind *:80
    default_backend api_servers

backend api_servers
    balance roundrobin
    
    # Kiểm tra tình trạng: kiểm tra /health mỗi 2 giây
    option httpchk GET /health
    http-check expect status 200
    
    # Logic thử lại
    retries 3
    option redispatch
    
    # Các máy chủ với trọng số (server3 mạnh gấp 2 lần)
    server server1 10.0.1.10:8080 check weight 1 maxconn 500
    server server2 10.0.1.11:8080 check weight 1 maxconn 500
    server server3 10.0.1.12:8080 check weight 2 maxconn 1000
    
    # Máy chủ dự phòng (chỉ sử dụng khi các máy chủ chính không khả dụng)
    server backup1 10.0.2.10:8080 check backup

// Python: triển khai Circuit Breaker cho proxy đến các dịch vụ bên ngoài
from datetime import datetime, timedelta
from enum import Enum

class CircuitState(Enum):
    CLOSED = "closed"      # Hoạt động bình thường
    OPEN = "open"          # Dịch vụ không khả dụng, các yêu cầu bị chặn
    HALF_OPEN = "half_open"  # Chế độ thử nghiệm sau khi phục hồi

class CircuitBreaker:
    def __init__(self, failure_threshold=5, timeout=60, success_threshold=2):
        self.failure_threshold = failure_threshold  # Số lỗi trước khi mở
        self.timeout = timeout  # Giây trước khi thử phục hồi
        self.success_threshold = success_threshold  # Số thành công để đóng lại
        
        self.state = CircuitState.CLOSED
        self.failures = 0
        self.successes = 0
        self.last_failure_time = None
    
    def call(self, func, *args, **kwargs):
        if self.state == CircuitState.OPEN:
            if datetime.now() - self.last_failure_time > timedelta(seconds=self.timeout):
                self.state = CircuitState.HALF_OPEN
                print("Circuit breaker: chuyển sang HALF_OPEN")
            else:
                raise Exception("Circuit breaker OPEN: dịch vụ không khả dụng")
        
        try:
            result = func(*args, **kwargs)
            self._on_success()
            return result
        except Exception as e:
            self._on_failure()
            raise e
    
    def _on_success(self):
        self.failures = 0
        if self.state == CircuitState.HALF_OPEN:
            self.successes += 1
            if self.successes >= self.success_threshold:
                self.state = CircuitState.CLOSED
                self.successes = 0
                print("Circuit breaker: phục hồi, chuyển sang CLOSED")
    
    def _on_failure(self):
        self.failures += 1
        self.last_failure_time = datetime.now()
        if self.failures >= self.failure_threshold:
            self.state = CircuitState.OPEN
            print(f"Circuit breaker OPEN: {self.failures} lỗi liên tiếp")

# Sử dụng
breaker = CircuitBreaker(failure_threshold=3, timeout=30)

def call_external_service():
    # Mã của bạn để yêu cầu đến API bên ngoài thông qua proxy
    pass

try:
    result = breaker.call(call_external_service)
except Exception as e:
    # Logic dự phòng: cache, giá trị mặc định, v.v.
    print(f"Dịch vụ không khả dụng: {e}")

# Cấu hình NGINX với SSL/TLS và an ninh
server {
    listen 443 ssl http2;
    server_name api.internal.example.com;

    # Chứng chỉ SSL
    ssl_certificate /etc/nginx/certs/api.crt;
    ssl_certificate_key /etc/nginx/certs/api.key;
    
    # Các giao thức và mã hóa hiện đại
    ssl_protocols TLSv1.2 TLSv1.3;
    ssl_ciphers HIGH:!aNULL:!MD5;
    ssl_prefer_server_ciphers on;
    
    # Chứng chỉ của khách hàng cho mTLS
    ssl_client_certificate /etc/nginx/certs/ca.crt;
    ssl_verify_client on;
    
    # Tiêu đề an toàn
    add_header Strict-Transport-Security "max-age=31536000" always;
    add_header X-Frame-Options "DENY" always;
    add_header X-Content-Type-Options "nosniff" always;
    
    # Giới hạn tần suất
    limit_req_zone $binary_remote_addr zone=api:10m rate=100r/s;
    limit_req zone=api burst=200 nodelay;
    
    # Giới hạn kết nối
    limit_conn_zone $binary_remote_addr zone=addr:10m;
    limit_conn addr 10;
    
    # IP whitelisting
    allow 10.0.0.0/8;      # Mạng nội bộ
    allow 172.16.0.0/12;   # VPC
    deny all;
    
    location / {
        # Kiểm tra token JWT
        auth_jwt "API bị hạn chế";
        auth_jwt_key_file /etc/nginx/jwt_key.json;
        
        proxy_pass http://backend_service;
        
        # Chuyển tiếp thông tin về chứng chỉ của khách hàng
        proxy_set_header X-Client-DN $ssl_client_s_dn;
        proxy_set_header X-Client-Verify $ssl_client_verify;
    }
}

Quan trọng cho production: Luôn sử dụng mTLS cho giao tiếp nội bộ giữa các dịch vụ, ngay cả khi chúng nằm trong cùng một mạng riêng. Điều này bảo vệ khỏi các cuộc tấn công kiểu man-in-the-middle và đảm bảo xác thực ở cấp độ dịch vụ, không chỉ ở cấp độ mạng.

# Cấu hình NGINX để xuất các chỉ số vào Prometheus
server {
    listen 9113;
    location /metrics {
        stub_status;
        access_log off;
        allow 10.0.0.0/8;  # Chỉ cho máy chủ Prometheus
        deny all;
    }
}

# Ghi log ở định dạng JSON cho ghi log có cấu trúc
log_format json_combined escape=json
  '{'
    '"time_local":"$time_local",'
    '"remote_addr":"$remote_addr",'
    '"request":"$request",'
    '"status": "$status",'
    '"body_bytes_sent":"$body_bytes_sent",'
    '"request_time":"$request_time",'
    '"upstream_response_time":"$upstream_response_time",'
    '"upstream_addr":"$upstream_addr",'
    '"http_referrer":"$http_referer",'
    '"http_user_agent":"$http_user_agent",'
    '"http_x_forwarded_for":"$http_x_forwarded_for"'
  '}';

access_log /var/log/nginx/access.log json_combined;

// Node.js: thêm tracing vào middleware proxy
const express = require('express');
const { v4: uuidv4 } = require('uuid');
const axios = require('axios');

const app = express();

// Middleware để thêm trace ID
app.use((req, res, next) => {
  // Lấy trace ID từ tiêu đề hoặc tạo mới
  const traceId = req.headers['x-trace-id'] || uuidv4();
  const spanId = uuidv4();
  
  // Thêm vào tiêu đề để chuyển tiếp
  req.traceId = traceId;
  req.spanId = spanId;
  res.setHeader('x-trace-id', traceId);
  
  // Ghi log thời gian bắt đầu xử lý
  const startTime = Date.now();
  
  res.on('finish', () => {
    const duration = Date.now() - startTime;
    
    // Ghi log có cấu trúc để phân tích
    console.log(JSON.stringify({
      timestamp: new Date().toISOString(),
      traceId: traceId,
      spanId: spanId,
      method: req.method,
      path: req.path,
      status: res.statusCode,
      duration: duration,
      userAgent: req.headers['user-agent'],
      ip: req.ip
    }));
  });
  
  next();
});

// Endpoint proxy với việc chuyển tiếp các tiêu đề tracing
app.all('/api/*', async (req, res) => {
  const targetService = determineTargetService(req.path);
  
  try {
    const response = await axios({
      method: req.method,
      url: `http://${targetService}${req.path}`,
      data: req.body,
      headers: {
        ...req.headers,
        'x-trace-id': req.traceId,
        'x-parent-span-id': req.spanId,
        'x-span-id': uuidv4()  // Span mới cho yêu cầu downstream
      }
    });
    
    res.status(response.status).json(response.data);
  } catch (error) {
    console.error(JSON.stringify({
      traceId: req.traceId,
      error: error.message,
      service: targetService
    }));
    res.status(500).json({ error: 'Dịch vụ không khả dụng' });
  }
});

function determineTargetService(path) {
  if (path.startsWith('/api/users')) return 'user-service:8080';
  if (path.startsWith('/api/orders')) return 'order-service:8080';
  return 'default-service:8080';
}

app.listen(3000);

from fastapi import FastAPI, HTTPException
from pydantic import BaseModel
import httpx
import asyncio
from typing import List, Optional
import logging

app = FastAPI()
logging.basicConfig(level=logging.INFO)
logger = logging.getLogger(__name__)

class ProxyConfig(BaseModel):
    url: str
    max_requests_per_minute: int = 60

class ProxyPool:
    def __init__(self, proxies: List[ProxyConfig]):
        self.proxies = proxies
        self.current_index = 0
        self.request_counts = {p.url: 0 for p in proxies}
        self.reset_time = asyncio.get_event_loop().time() + 60
    
    async def get_next_proxy(self) -> str:
        # Đặt lại bộ đếm mỗi phút
        current_time = asyncio.get_event_loop().time()
        if current_time >= self.reset_time:
            self.request_counts = {p.url: 0 for p in self.proxies}
            self.reset_time = current_time + 60
        
        # Tìm proxy với yêu cầu còn lại
        for _ in range(len(self.proxies)):
            proxy = self.proxies[self.current_index]
            self.current_index = (self.current_index + 1) % len(self.proxies)
            
            if self.request_counts[proxy.url] < proxy.max_requests_per_minute:
                self.request_counts[proxy.url] += 1
                return proxy.url
        
        # Tất cả các proxy đã hết giới hạn
        raise HTTPException(status_code=429, detail="Tất cả các proxy đã bị giới hạn")

# Khởi tạo nhóm proxy
proxy_pool = ProxyPool([
    ProxyConfig(url="http://user:pass@proxy1.example.com:8080", max_requests_per_minute=100),
    ProxyConfig(url="http://user:pass@proxy2.example.com:8080", max_requests_per_minute=100),
    ProxyConfig(url="http://user:pass@proxy3.example.com:8080", max_requests_per_minute=100)
])

class ExternalAPIClient:
    def __init__(self, proxy_pool: ProxyPool):
        self.proxy_pool = proxy_pool
    
    async def fetch_data(self, endpoint: str, params: dict = None) -> dict:
        proxy_url = await self.proxy_pool.get_next_proxy()
        
        async with httpx.AsyncClient(proxies={"http://": proxy_url, "https://": proxy_url}) as client:
            try:
                response = await client.get(
                    endpoint,
                    params=params,
                    timeout=10.0,
                    headers={"User-Agent": "MyMicroservice/1.0"}
                )
                response.raise_for_status()
                
                logger.info(f"Đã lấy thành công từ {endpoint} qua {proxy_url}")
                return response.json()
            
            except httpx.HTTPStatusError as e:
                logger.error(f"Lỗi HTTP {e.response.status_code} từ {endpoint}")
                raise HTTPException(status_code=e.response.status_code, detail=str(e))
            
            except httpx.RequestError as e:
                logger.error(f"Lỗi yêu cầu đến {endpoint}: {e}")
                raise HTTPException(status_code=503, detail="API bên ngoài không khả dụng")

api_client = ExternalAPIClient(proxy_pool)

@app.get("/data/{resource_id}")
async def get_external_data(resource_id: str):
    """Endpoint, nhận dữ liệu từ API bên ngoài qua proxy"""
    external_endpoint = f"https://api.external-service.com/v1/resources/{resource_id}"
    
    try:
        data = await api_client.fetch_data(external_endpoint)
        return {"status": "success", "data": data}
    except HTTPException:
        raise
    except Exception as e:
        logger.error(f"Lỗi không mong muốn: {e}")
        raise HTTPException(status_code=500, detail="Lỗi nội bộ của máy chủ")

@app.get("/health")
async def health_check():
    return {"status": "healthy", "service": "external-api-proxy"}

# Khởi chạy: uvicorn main:app --host 0.0.0.0 --port 8000

const express = require('express');
const axios = require('axios');
const rateLimit = require('express-rate-limit');

const app = express();
app.use(express.json());

// Cấu hình các microservices
const services = {
  users: [
    { url: 'http://user-service-1:8001', healthy: true, activeConnections: 0 },
    { url: 'http://user-service-2:8001', healthy: true, activeConnections: 0 },
    // Thêm các dịch vụ khác ở đây
  ],
  orders: [
    { url: 'http://order-service-1:8002', healthy: true, activeConnections: 0 },
    { url: 'http://order-service-2:8002', healthy: true, activeConnections: 0 },
    // Thêm các dịch vụ khác ở đây
  ],
};

// Middleware để cân bằng tải
app.use('/api/users', (req, res, next) => {
  const service = getNextService(services.users);
  proxyRequest(service.url, req, res);
});

app.use('/api/orders', (req, res, next) => {
  const service = getNextService(services.orders);
  proxyRequest(service.url, req, res);
});

// Hàm để lấy dịch vụ tiếp theo
function getNextService(serviceList) {
  // Logic để lấy dịch vụ tiếp theo (có thể là round-robin hoặc dựa trên tình trạng)
  return serviceList[0]; // Ví dụ đơn giản
}

// Hàm để proxy yêu cầu đến dịch vụ
function proxyRequest(serviceUrl, req, res) {
  axios({
    method: req.method,
    url: `${serviceUrl}${req.path}`,
    data: req.body,
    headers: {
      ...req.headers,
      'X-Forwarded-For': req.ip,
    },
  })
    .then(response => {
      res.status(response.status).json(response.data);
    })
    .catch(error => {
      res.status(error.response?.status || 500).json({ error: 'Dịch vụ không khả dụng' });
    });
}

// Khởi chạy máy chủ
app.listen(3000, () => {
  console.log('API Gateway đang chạy trên cổng 3000');
});