📚 Kong性能优化与监控

1. 性能概述

1.1 性能指标

Kong的关键性能指标包括： - 吞吐量(Throughput): 每秒处理的请求数(RPS) - 延迟(Latency): 请求响应时间 - 并发连接数: 同时处理的连接数 - CPU使用率: 处理器资源消耗 - 内存使用率: 内存资源消耗 - 网络I/O: 网络带宽使用情况

1.2 性能基准

典型的Kong性能基准： - 单核性能: 10,000-20,000 RPS - 多核性能: 可线性扩展到100,000+ RPS - 平均延迟: <1ms (无插件) - P99延迟: <10ms (轻量级插件)

2. 系统级优化

2.1 操作系统优化

2.1.1 内核参数调优

# /etc/sysctl.conf
# 网络优化
net.core.somaxconn = 65535
net.core.netdev_max_backlog = 5000
net.ipv4.tcp_max_syn_backlog = 65535
net.ipv4.tcp_fin_timeout = 30
net.ipv4.tcp_keepalive_time = 1200
net.ipv4.tcp_rmem = 4096 65536 16777216
net.ipv4.tcp_wmem = 4096 65536 16777216
net.core.rmem_default = 262144
net.core.rmem_max = 16777216
net.core.wmem_default = 262144
net.core.wmem_max = 16777216

# 文件描述符限制
fs.file-max = 1000000

# 应用设置
sudo sysctl -p

2.1.2 文件描述符限制

# /etc/security/limits.conf
* soft nofile 1000000
* hard nofile 1000000
* soft nproc 1000000
* hard nproc 1000000

# 验证设置
ulimit -n
ulimit -u

2.1.3 CPU亲和性设置

# 绑定Kong进程到特定CPU核心
taskset -c 0-3 kong start

# 或在systemd服务中设置
# /etc/systemd/system/kong.service
[Service]
CPUAffinity=0-3

2.2 Nginx/OpenResty优化

2.2.1 Worker进程配置

# kong.conf
worker_processes auto;  # 自动检测CPU核心数
worker_connections 16384;  # 每个worker的连接数
worker_rlimit_nofile 65535;  # 文件描述符限制

# 高级配置
worker_cpu_affinity auto;  # 自动CPU亲和性
worker_priority -5;  # 提高进程优先级

2.2.2 事件模型优化

# nginx.conf
events {
    use epoll;  # Linux下使用epoll
    worker_connections 16384;
    multi_accept on;  # 一次接受多个连接
    accept_mutex off;  # 关闭accept锁
}

2.2.3 HTTP优化

http {
    # 连接优化
    sendfile on;
    tcp_nopush on;
    tcp_nodelay on;
    keepalive_timeout 65;
    keepalive_requests 1000;
    
    # 缓冲区优化
    client_body_buffer_size 128k;
    client_max_body_size 10m;
    client_header_buffer_size 1k;
    large_client_header_buffers 4 4k;
    output_buffers 1 32k;
    postpone_output 1460;
    
    # 压缩优化
    gzip on;
    gzip_vary on;
    gzip_min_length 1024;
    gzip_proxied any;
    gzip_comp_level 6;
    gzip_types text/plain text/css application/json application/javascript;
}

2.3 数据库优化

2.3.1 PostgreSQL优化

-- postgresql.conf
shared_buffers = 256MB
effective_cache_size = 1GB
work_mem = 4MB
maintenance_work_mem = 64MB
wal_buffers = 16MB
checkpoint_completion_target = 0.9
random_page_cost = 1.1

-- 连接池设置
max_connections = 200

2.3.2 数据库连接池

# kong.conf
pg_max_concurrent_queries = 0  # 无限制
pg_semaphore_timeout = 60000   # 60秒超时

# 使用连接池
pg_host = pgbouncer.example.com
pg_port = 6432

2.3.3 数据库索引优化

-- 为常用查询创建索引
CREATE INDEX CONCURRENTLY idx_services_name ON services(name);
CREATE INDEX CONCURRENTLY idx_routes_service_id ON routes(service_id);
CREATE INDEX CONCURRENTLY idx_plugins_service_id ON plugins(service_id);
CREATE INDEX CONCURRENTLY idx_consumers_username ON consumers(username);

-- 分析查询性能
EXPLAIN ANALYZE SELECT * FROM services WHERE name = 'my-service';

3. Kong配置优化

3.1 核心配置优化

3.1.1 基础性能配置

# kong.conf
# 数据库配置
db_update_frequency = 5  # 减少数据库轮询频率
db_update_propagation = 0  # 禁用传播延迟
db_cache_ttl = 3600  # 增加缓存TTL

# 内存配置
lua_shared_dict_size = 5m  # 增加共享字典大小
lua_package_path = ./?.lua;./?/init.lua;  # 优化Lua路径

# 日志配置
log_level = notice  # 减少日志级别
error_default_type = text/plain

3.1.2 代理配置优化

# 上游连接优化
upstream_keepalive_pool_size = 60
upstream_keepalive_max_requests = 100
upstream_keepalive_idle_timeout = 60s

# 客户端连接优化
client_body_buffer_size = 8k
client_header_buffer_size = 1k
client_max_body_size = 0  # 无限制

3.2 缓存优化

3.2.1 启用代理缓存

# 启用代理缓存插件
curl -X POST http://localhost:8001/services/{service}/plugins \
  --data "name=proxy-cache" \
  --data "config.response_code[]=200" \
  --data "config.response_code[]=301" \
  --data "config.response_code[]=404" \
  --data "config.request_method[]=GET" \
  --data "config.request_method[]=HEAD" \
  --data "config.content_type[]=text/plain" \
  --data "config.content_type[]=application/json" \
  --data "config.cache_ttl=300" \
  --data "config.strategy=memory"

3.2.2 Redis缓存配置

# 使用Redis作为缓存后端
curl -X POST http://localhost:8001/services/{service}/plugins \
  --data "name=proxy-cache" \
  --data "config.strategy=redis" \
  --data "config.redis.host=redis.example.com" \
  --data "config.redis.port=6379" \
  --data "config.redis.timeout=2000" \
  --data "config.redis.password=redis_password" \
  --data "config.redis.database=0"

3.2.3 缓存键优化

# 自定义缓存键
curl -X POST http://localhost:8001/services/{service}/plugins \
  --data "name=proxy-cache" \
  --data "config.cache_key[]=$$scheme" \
  --data "config.cache_key[]=$$host" \
  --data "config.cache_key[]=$$request_uri" \
  --data "config.cache_key[]=$$http_authorization"

3.3 负载均衡优化

3.3.1 负载均衡算法

# 创建上游服务
curl -X POST http://localhost:8001/upstreams \
  --data "name=my-upstream" \
  --data "algorithm=least-connections" \
  --data "hash_on=none" \
  --data "hash_fallback=none" \
  --data "healthchecks.active.healthy.interval=5" \
  --data "healthchecks.active.unhealthy.interval=5"

# 一致性哈希
curl -X PATCH http://localhost:8001/upstreams/my-upstream \
  --data "algorithm=consistent-hashing" \
  --data "hash_on=header" \
  --data "hash_on_header=X-User-ID"

3.3.2 健康检查优化

# 主动健康检查
curl -X PATCH http://localhost:8001/upstreams/my-upstream \
  --data "healthchecks.active.type=http" \
  --data "healthchecks.active.http_path=/health" \
  --data "healthchecks.active.healthy.interval=5" \
  --data "healthchecks.active.healthy.successes=2" \
  --data "healthchecks.active.unhealthy.interval=5" \
  --data "healthchecks.active.unhealthy.http_failures=3" \
  --data "healthchecks.active.unhealthy.timeouts=3"

# 被动健康检查
curl -X PATCH http://localhost:8001/upstreams/my-upstream \
  --data "healthchecks.passive.type=http" \
  --data "healthchecks.passive.healthy.successes=3" \
  --data "healthchecks.passive.unhealthy.http_failures=3" \
  --data "healthchecks.passive.unhealthy.timeouts=3"

4. 插件性能优化

4.1 插件选择和配置

4.1.1 高性能插件

# 使用高性能的认证插件
# Key Auth (最快)
curl -X POST http://localhost:8001/services/{service}/plugins \
  --data "name=key-auth"

# JWT (中等性能)
curl -X POST http://localhost:8001/services/{service}/plugins \
  --data "name=jwt" \
  --data "config.claims_to_verify[]=exp"

# 避免复杂的OAuth 2.0 (较慢)

4.1.2 插件执行顺序优化

-- 自定义插件优先级
local plugin = {
  PRIORITY = 1000,  -- 高优先级，早执行
  VERSION = "1.0.0",
}

function plugin:access(plugin_conf)
  -- 快速失败逻辑
  if not plugin_conf.enabled then
    return
  end
  
  -- 性能关键的检查
  local cache_key = "plugin:" .. kong.request.get_path()
  local cached_result = kong.cache:get(cache_key)
  
  if cached_result then
    return cached_result
  end
  
  -- 执行插件逻辑
end

4.2 自定义插件优化

4.2.1 缓存使用

-- 使用Kong缓存
local cache = kong.cache

function plugin:access(plugin_conf)
  local cache_key = "my_plugin:" .. kong.request.get_header("user-id")
  
  local result, err = cache:get(cache_key, { ttl = 300 }, function()
    -- 昂贵的计算或外部API调用
    return expensive_operation()
  end)
  
  if err then
    kong.log.err("Cache error: ", err)
    return kong.response.exit(500)
  end
  
  -- 使用缓存结果
end

4.2.2 异步处理

-- 使用ngx.timer进行异步处理
local function async_task(premature, data)
  if premature then
    return
  end
  
  -- 异步处理逻辑
  send_to_analytics(data)
end

function plugin:log(plugin_conf)
  local ok, err = ngx.timer.at(0, async_task, {
    request_id = kong.request.get_header("x-request-id"),
    timestamp = ngx.now(),
    status = kong.response.get_status()
  })
  
  if not ok then
    kong.log.err("Failed to create timer: ", err)
  end
end

4.2.3 内存优化

-- 避免内存泄漏
local _M = {}

-- 使用局部变量
local ngx_var = ngx.var
local kong_request = kong.request
local string_format = string.format

function _M.process_request()
  -- 重用对象
  local headers = kong_request.get_headers()
  
  -- 避免创建大量临时字符串
  local cache_key = string_format("key:%s:%s", 
    headers["user-id"] or "anonymous",
    ngx_var.request_uri)
  
  return cache_key
end

return _M

5. 监控系统

5.1 内置监控

5.1.1 Admin API监控

# 获取基本状态
curl http://localhost:8001/status

# 获取详细信息
curl http://localhost:8001/

# 检查数据库连接
curl http://localhost:8001/status/ready

5.1.2 Nginx状态模块

# 启用状态模块
server {
    listen 8002;
    location /nginx_status {
        stub_status on;
        access_log off;
        allow 127.0.0.1;
        deny all;
    }
}

5.2 Prometheus监控

5.2.1 启用Prometheus插件

# 全局启用Prometheus插件
curl -X POST http://localhost:8001/plugins \
  --data "name=prometheus" \
  --data "config.per_consumer=true" \
  --data "config.status_code_metrics=true" \
  --data "config.latency_metrics=true" \
  --data "config.bandwidth_metrics=true" \
  --data "config.upstream_health_metrics=true"

5.2.2 自定义指标

-- 自定义Prometheus指标
local prometheus = require "kong.plugins.prometheus.exporter"

-- 创建自定义计数器
local custom_counter = prometheus:counter(
  "kong_custom_requests_total",
  "Total number of custom requests",
  {"service", "route", "method"}
)

-- 创建自定义直方图
local custom_histogram = prometheus:histogram(
  "kong_custom_request_duration_seconds",
  "Custom request duration in seconds",
  {"service", "route"},
  {0.1, 0.5, 1, 2, 5, 10}
)

function plugin:access(plugin_conf)
  -- 记录请求开始时间
  ngx.ctx.start_time = ngx.now()
end

function plugin:log(plugin_conf)
  local duration = ngx.now() - ngx.ctx.start_time
  
  -- 更新指标
  custom_counter:inc(1, {
    kong.router.get_service().name,
    kong.router.get_route().name,
    kong.request.get_method()
  })
  
  custom_histogram:observe(duration, {
    kong.router.get_service().name,
    kong.router.get_route().name
  })
end

5.2.3 Prometheus配置

# prometheus.yml
global:
  scrape_interval: 15s

scrape_configs:
  - job_name: 'kong'
    static_configs:
      - targets: ['kong:8001']
    metrics_path: '/metrics'
    scrape_interval: 5s

5.3 日志监控

5.3.1 结构化日志

# 启用JSON格式日志
curl -X POST http://localhost:8001/plugins \
  --data "name=file-log" \
  --data "config.path=/var/log/kong/access.log" \
  --data "config.custom_fields_by_lua.request_id=return kong.request.get_header('x-request-id')" \
  --data "config.custom_fields_by_lua.user_agent=return kong.request.get_header('user-agent')"

5.3.2 ELK Stack集成

# Logstash插件
curl -X POST http://localhost:8001/plugins \
  --data "name=tcp-log" \
  --data "config.host=logstash.example.com" \
  --data "config.port=5000"

# Elasticsearch插件
curl -X POST http://localhost:8001/plugins \
  --data "name=http-log" \
  --data "config.http_endpoint=http://elasticsearch.example.com:9200/kong-logs/_doc" \
  --data "config.method=POST" \
  --data "config.content_type=application/json"

5.3.3 日志分析

// Elasticsearch查询示例
{
  "query": {
    "bool": {
      "must": [
        {"range": {"@timestamp": {"gte": "now-1h"}}},
        {"term": {"response.status": 500}}
      ]
    }
  },
  "aggs": {
    "error_by_service": {
      "terms": {"field": "service.name"}
    }
  }
}

5.4 APM集成

5.4.1 Datadog集成

# 启用Datadog插件
curl -X POST http://localhost:8001/plugins \
  --data "name=datadog" \
  --data "config.host=datadog-agent.example.com" \
  --data "config.port=8125" \
  --data "config.metrics[]=request_count" \
  --data "config.metrics[]=latency" \
  --data "config.metrics[]=request_size" \
  --data "config.metrics[]=status_count" \
  --data "config.metrics[]=response_size"

5.4.2 New Relic集成

# 启用New Relic插件
curl -X POST http://localhost:8001/plugins \
  --data "name=http-log" \
  --data "config.http_endpoint=https://log-api.newrelic.com/log/v1" \
  --data "config.method=POST" \
  --data "config.headers.Content-Type=application/json" \
  --data "config.headers.X-License-Key=YOUR_LICENSE_KEY"

5.4.3 Jaeger分布式追踪

# 启用Zipkin插件（兼容Jaeger）
curl -X POST http://localhost:8001/plugins \
  --data "name=zipkin" \
  --data "config.http_endpoint=http://jaeger-collector:14268/api/traces" \
  --data "config.sample_ratio=0.1" \
  --data "config.include_credential=true"

6. 性能测试

6.1 基准测试工具

6.1.1 wrk测试

# 基本负载测试
wrk -t12 -c400 -d30s http://localhost:8000/api/test

# 带脚本的测试
wrk -t12 -c400 -d30s -s script.lua http://localhost:8000/api/test

# script.lua
wrk.method = "POST"
wrk.body = '{"test": "data"}'
wrk.headers["Content-Type"] = "application/json"
wrk.headers["Authorization"] = "Bearer token"

6.1.2 Apache Bench (ab)

# 简单测试
ab -n 10000 -c 100 http://localhost:8000/api/test

# 带认证的测试
ab -n 10000 -c 100 -H "Authorization: Bearer token" http://localhost:8000/api/test

# POST请求测试
ab -n 1000 -c 10 -p data.json -T application/json http://localhost:8000/api/test

6.1.3 Artillery.js

# artillery-config.yml
config:
  target: 'http://localhost:8000'
  phases:
    - duration: 60
      arrivalRate: 10
    - duration: 120
      arrivalRate: 50
    - duration: 60
      arrivalRate: 100
  defaults:
    headers:
      Authorization: 'Bearer token'

scenarios:
  - name: "API Test"
    weight: 100
    flow:
      - get:
          url: "/api/test"
      - post:
          url: "/api/data"
          json:
            test: "data"

6.2 性能分析

6.2.1 系统资源监控

# CPU使用率
top -p $(pgrep kong)

# 内存使用
ps aux | grep kong
pmap $(pgrep kong)

# 网络连接
netstat -an | grep :8000
ss -tuln | grep :8000

# 文件描述符
lsof -p $(pgrep kong) | wc -l

6.2.2 应用性能分析

# 使用perf分析
perf record -g -p $(pgrep kong) sleep 30
perf report

# 使用strace分析系统调用
strace -p $(pgrep kong) -c

# 使用tcpdump分析网络
tcpdump -i any -w kong-traffic.pcap port 8000

6.2.3 数据库性能分析

-- PostgreSQL慢查询分析
SELECT query, calls, total_time, mean_time
FROM pg_stat_statements
WHERE query LIKE '%kong%'
ORDER BY total_time DESC
LIMIT 10;

-- 连接数监控
SELECT count(*) as connections, state
FROM pg_stat_activity
WHERE datname = 'kong'
GROUP BY state;

7. 告警系统

7.1 Prometheus告警规则

7.1.1 基础告警规则

# kong-alerts.yml
groups:
  - name: kong
    rules:
      # 高错误率告警
      - alert: KongHighErrorRate
        expr: rate(kong_http_status{code=~"5.."}[5m]) > 0.1
        for: 2m
        labels:
          severity: critical
        annotations:
          summary: "Kong high error rate detected"
          description: "Kong error rate is {{ $value }} errors per second"
      
      # 高延迟告警
      - alert: KongHighLatency
        expr: histogram_quantile(0.95, rate(kong_latency_bucket[5m])) > 1000
        for: 5m
        labels:
          severity: warning
        annotations:
          summary: "Kong high latency detected"
          description: "Kong 95th percentile latency is {{ $value }}ms"
      
      # 上游服务不健康
      - alert: KongUpstreamUnhealthy
        expr: kong_upstream_target_health == 0
        for: 1m
        labels:
          severity: critical
        annotations:
          summary: "Kong upstream target unhealthy"
          description: "Upstream {{ $labels.upstream }} target {{ $labels.target }} is unhealthy"

7.1.2 业务指标告警

# 业务告警规则
- alert: KongLowThroughput
  expr: rate(kong_http_status[5m]) < 10
  for: 10m
  labels:
    severity: warning
  annotations:
    summary: "Kong low throughput"
    description: "Kong throughput is {{ $value }} requests per second"

- alert: KongAuthFailureSpike
  expr: rate(kong_http_status{code="401"}[5m]) > 5
  for: 2m
  labels:
    severity: warning
  annotations:
    summary: "Kong authentication failure spike"
    description: "High number of 401 errors: {{ $value }} per second"

7.2 告警通知

7.2.1 Alertmanager配置

# alertmanager.yml
global:
  smtp_smarthost: 'smtp.example.com:587'
  smtp_from: 'alerts@example.com'

route:
  group_by: ['alertname']
  group_wait: 10s
  group_interval: 10s
  repeat_interval: 1h
  receiver: 'web.hook'

receivers:
  - name: 'web.hook'
    email_configs:
      - to: 'admin@example.com'
        subject: 'Kong Alert: {{ .GroupLabels.alertname }}'
        body: |
          {{ range .Alerts }}
          Alert: {{ .Annotations.summary }}
          Description: {{ .Annotations.description }}
          {{ end }}
    
    slack_configs:
      - api_url: 'https://hooks.slack.com/services/YOUR/SLACK/WEBHOOK'
        channel: '#alerts'
        title: 'Kong Alert'
        text: '{{ range .Alerts }}{{ .Annotations.summary }}{{ end }}'

7.2.2 自定义告警脚本

#!/usr/bin/env python3
# kong-health-check.py
import requests
import time
import smtplib
from email.mime.text import MIMEText

def check_kong_health():
    try:
        # 检查Kong状态
        response = requests.get('http://localhost:8001/status', timeout=5)
        if response.status_code != 200:
            send_alert(f"Kong status check failed: {response.status_code}")
            return False
        
        # 检查数据库连接
        response = requests.get('http://localhost:8001/status/ready', timeout=5)
        if response.status_code != 200:
            send_alert("Kong database connection failed")
            return False
        
        # 检查代理响应
        response = requests.get('http://localhost:8000/health', timeout=5)
        if response.status_code != 200:
            send_alert(f"Kong proxy health check failed: {response.status_code}")
            return False
        
        return True
    
    except Exception as e:
        send_alert(f"Kong health check error: {str(e)}")
        return False

def send_alert(message):
    # 发送邮件告警
    msg = MIMEText(message)
    msg['Subject'] = 'Kong Health Alert'
    msg['From'] = 'monitor@example.com'
    msg['To'] = 'admin@example.com'
    
    server = smtplib.SMTP('smtp.example.com', 587)
    server.starttls()
    server.login('monitor@example.com', 'password')
    server.send_message(msg)
    server.quit()

if __name__ == '__main__':
    while True:
        if not check_kong_health():
            print(f"Health check failed at {time.ctime()}")
        time.sleep(60)  # 每分钟检查一次

8. 性能调优案例

8.1 高并发场景优化

8.1.1 问题分析

# 发现问题：高并发下响应时间增加
# 1. 检查系统资源
top
iostat 1
netstat -an | grep :8000 | wc -l

# 2. 检查Kong指标
curl http://localhost:8001/metrics | grep kong_latency

# 3. 检查数据库连接
psql -h localhost -U kong -c "SELECT count(*) FROM pg_stat_activity;"

8.1.2 优化方案

# 1. 增加worker进程数
echo "worker_processes auto;" >> /etc/kong/kong.conf
echo "worker_connections 16384;" >> /etc/kong/kong.conf

# 2. 优化数据库连接
echo "pg_max_concurrent_queries = 0" >> /etc/kong/kong.conf
echo "db_update_frequency = 10" >> /etc/kong/kong.conf

# 3. 启用缓存
curl -X POST http://localhost:8001/plugins \
  --data "name=proxy-cache" \
  --data "config.cache_ttl=300"

# 4. 重启Kong
kong restart

8.2 内存使用优化

8.2.1 内存泄漏检测

# 监控内存使用
while true; do
  ps aux | grep kong | grep -v grep
  sleep 60
done

# 使用valgrind检测内存泄漏
valgrind --tool=memcheck --leak-check=full kong start

8.2.2 内存优化配置

# kong.conf
lua_shared_dict_size = 5m
lua_package_cpath = /usr/local/lib/lua/5.1/?.so
mem_cache_size = 128m

# 限制请求体大小
client_max_body_size = 10m
client_body_buffer_size = 128k

8.3 数据库性能优化

8.3.1 查询优化

-- 分析慢查询
SELECT query, calls, total_time, mean_time, stddev_time
FROM pg_stat_statements
WHERE mean_time > 100
ORDER BY mean_time DESC;

-- 优化索引
CREATE INDEX CONCURRENTLY idx_routes_updated_at ON routes(updated_at);
CREATE INDEX CONCURRENTLY idx_services_enabled ON services(enabled) WHERE enabled = true;

8.3.2 连接池优化

# 使用PgBouncer
# /etc/pgbouncer/pgbouncer.ini
[databases]
kong = host=localhost port=5432 dbname=kong

[pgbouncer]
listen_port = 6432
listen_addr = *
auth_type = md5
auth_file = /etc/pgbouncer/userlist.txt
pool_mode = transaction
max_client_conn = 200
default_pool_size = 25

9. 监控仪表板

9.1 Grafana仪表板

9.1.1 Kong概览仪表板

{
  "dashboard": {
    "title": "Kong Overview",
    "panels": [
      {
        "title": "Request Rate",
        "type": "graph",
        "targets": [
          {
            "expr": "rate(kong_http_status[5m])",
            "legendFormat": "{{service}}"
          }
        ]
      },
      {
        "title": "Response Time",
        "type": "graph",
        "targets": [
          {
            "expr": "histogram_quantile(0.95, rate(kong_latency_bucket[5m]))",
            "legendFormat": "95th percentile"
          },
          {
            "expr": "histogram_quantile(0.50, rate(kong_latency_bucket[5m]))",
            "legendFormat": "50th percentile"
          }
        ]
      }
    ]
  }
}

9.1.2 错误监控仪表板

{
  "dashboard": {
    "title": "Kong Errors",
    "panels": [
      {
        "title": "Error Rate by Status Code",
        "type": "graph",
        "targets": [
          {
            "expr": "rate(kong_http_status{code=~\"4..|5..\"}[5m])",
            "legendFormat": "{{code}}"
          }
        ]
      },
      {
        "title": "Top Error Services",
        "type": "table",
        "targets": [
          {
            "expr": "topk(10, rate(kong_http_status{code=~\"5..\"}[5m]))",
            "format": "table"
          }
        ]
      }
    ]
  }
}

9.2 自定义监控面板

9.2.1 实时监控脚本

#!/usr/bin/env python3
# kong-monitor.py
import requests
import time
import json
from datetime import datetime

def get_kong_metrics():
    try:
        response = requests.get('http://localhost:8001/metrics')
        return response.text
    except Exception as e:
        print(f"Error fetching metrics: {e}")
        return None

def parse_metrics(metrics_text):
    metrics = {}
    for line in metrics_text.split('\n'):
        if line.startswith('kong_http_status'):
            # 解析HTTP状态码指标
            parts = line.split()
            if len(parts) >= 2:
                value = float(parts[1])
                # 提取标签
                labels = {}
                if '{' in parts[0]:
                    label_part = parts[0].split('{')[1].split('}')[0]
                    for label in label_part.split(','):
                        key, val = label.split('=')
                        labels[key] = val.strip('"')
                
                metrics[parts[0]] = {'value': value, 'labels': labels}
    
    return metrics

def main():
    while True:
        metrics_text = get_kong_metrics()
        if metrics_text:
            metrics = parse_metrics(metrics_text)
            
            # 计算总请求数
            total_requests = sum(m['value'] for m in metrics.values() 
                               if 'kong_http_status' in str(m))
            
            # 计算错误率
            error_requests = sum(m['value'] for m in metrics.values() 
                               if 'kong_http_status' in str(m) and 
                               m.get('labels', {}).get('code', '').startswith(('4', '5')))
            
            error_rate = (error_requests / total_requests * 100) if total_requests > 0 else 0
            
            print(f"[{datetime.now()}] Total: {total_requests}, Errors: {error_requests}, Error Rate: {error_rate:.2f}%")
        
        time.sleep(10)

if __name__ == '__main__':
    main()

10. 总结

Kong的性能优化是一个系统性工程，需要从多个层面进行：

10.1 优化层次

1. 系统层: 操作系统参数、网络配置
2. 应用层: Kong配置、插件优化
3. 数据层: 数据库优化、缓存策略
4. 监控层: 全面监控、及时告警

10.2 关键指标

• 吞吐量: 目标 >10,000 RPS
• 延迟: P95 <100ms, P99 <500ms
• 可用性: >99.9%
• 错误率: <0.1%

10.3 最佳实践

1. 持续监控: 建立完善的监控体系
2. 性能测试: 定期进行压力测试
3. 容量规划: 基于监控数据进行容量规划
4. 故障演练: 定期进行故障演练

在下一章节中，我们将介绍Kong与微服务架构的集成。