第218集Nginx公网带宽优化架构实战：流量控制、带宽管理、CDN加速的企业级解决方案

前言

在当今互联网高速发展的时代，公网带宽已成为企业网络架构中的关键资源。随着用户访问量的不断增长和业务规模的快速扩张，如何高效利用有限的公网带宽资源，实现流量控制和带宽管理，已成为企业架构师面临的重要挑战。Nginx作为高性能的Web服务器和反向代理服务器，在公网带宽优化方面发挥着至关重要的作用。

本文将深入探讨Nginx公网带宽优化的架构设计与实战应用，从基础配置到高级优化，从单机部署到集群架构，为企业构建高效、稳定、经济的公网带宽管理解决方案提供全面的技术指导。

一、Nginx公网带宽架构概述

1.1 公网带宽架构设计

Nginx公网带宽优化采用多层次、多维度的架构设计，通过流量控制、带宽管理、CDN加速等技术手段实现带宽资源的高效利用。

graph TB
    A[用户请求] --> B[CDN边缘节点]
    B --> C[负载均衡器]
    C --> D[Nginx集群]
    D --> E[后端应用服务器]
    
    F[带宽监控] --> C
    G[流量控制] --> C
    H[缓存系统] --> D
    
    subgraph "带宽优化层"
        I[流量整形]
        J[带宽限制]
        K[优先级调度]
        L[压缩优化]
    end
    
    C --> I
    C --> J
    C --> K
    C --> L

1.2 带宽优化核心机制

1.2.1 流量控制机制

限速控制：基于IP、用户、接口的限速策略
流量整形：平滑流量峰值，避免突发流量
优先级调度：根据业务重要性分配带宽资源

1.2.2 带宽管理策略

动态带宽分配：根据实时负载动态调整带宽
带宽预留：为关键业务预留带宽资源
带宽监控：实时监控带宽使用情况

1.2.3 CDN加速机制

边缘缓存：将内容缓存到离用户更近的节点
智能路由：选择最优路径传输数据
压缩传输：减少传输数据量

1.3 企业级带宽优化优势

带宽优化优势:
  成本控制:
    - 减少带宽费用
    - 提高资源利用率
    - 优化传输效率
  
  性能提升:
    - 降低延迟
    - 提高吞吐量
    - 改善用户体验
  
  稳定性保障:
    - 避免带宽拥塞
    - 防止服务中断
    - 保障服务质量
  
  可扩展性:
    - 支持业务增长
    - 弹性带宽调整
    - 动态资源分配

二、Nginx带宽控制配置

2.1 基础限速配置

2.1.1 连接数限制

# /etc/nginx/nginx.conf
http {
    # 限制连接数
    limit_conn_zone $binary_remote_addr zone=conn_limit_per_ip:10m;
    limit_conn_zone $server_name zone=conn_limit_per_server:10m;
    
    # 限制请求频率
    limit_req_zone $binary_remote_addr zone=req_limit_per_ip:10m rate=10r/s;
    limit_req_zone $server_name zone=req_limit_per_server:10m rate=100r/s;
    
    server {
        listen 80;
        server_name example.com;
        
        # 应用连接数限制
        limit_conn conn_limit_per_ip 10;
        limit_conn conn_limit_per_server 100;
        
        # 应用请求频率限制
        limit_req zone=req_limit_per_ip burst=20 nodelay;
        limit_req zone=req_limit_per_server burst=200 nodelay;
        
        location / {
            root /var/www/html;
            index index.html;
        }
    }
}

2.1.2 带宽限制配置

# 带宽限制配置
server {
    listen 80;
    server_name example.com;
    
    # 限制单个连接带宽
    limit_rate 1m;
    limit_rate_after 10m;
    
    # 限制特定路径带宽
    location /download/ {
        limit_rate 500k;
        limit_rate_after 5m;
        
        # 大文件下载优化
        sendfile on;
        tcp_nopush on;
        tcp_nodelay on;
    }
    
    # 限制API接口带宽
    location /api/ {
        limit_rate 2m;
        limit_rate_after 1m;
        
        # API响应优化
        gzip on;
        gzip_types application/json;
    }
    
    # 静态资源带宽限制
    location ~* \.(jpg|jpeg|png|gif|css|js)$ {
        limit_rate 5m;
        limit_rate_after 2m;
        
        # 静态资源缓存
        expires 1y;
        add_header Cache-Control "public, immutable";
    }
}

2.2 高级流量控制

2.2.1 基于用户组的限速

# 用户组限速配置
http {
    # 定义用户组
    map $remote_addr $user_group {
        default "normal";
        ~^192\.168\.   "internal";
        ~^10\.        "internal";
        ~^172\.16\.   "internal";
    }
    
    # 不同用户组限速策略
    limit_req_zone $user_group zone=normal_users:10m rate=5r/s;
    limit_req_zone $user_group zone=internal_users:10m rate=50r/s;
    
    server {
        listen 80;
        server_name example.com;
        
        # 根据用户组应用不同限速策略
        location / {
            if ($user_group = "internal") {
                limit_req zone=internal_users burst=100 nodelay;
            }
            if ($user_group = "normal") {
                limit_req zone=normal_users burst=20 nodelay;
            }
            
            proxy_pass http://backend;
        }
    }
}

2.2.2 动态带宽调整

# 动态带宽调整配置
http {
    # 定义时间段
    map $time_iso8601 $time_period {
        ~T0[0-6] "night";
        ~T0[7-9] "morning";
        ~T1[0-7] "day";
        ~T1[8-9] "evening";
        default "night";
    }
    
    # 不同时间段带宽策略
    map $time_period $bandwidth_limit {
        "night" "10m";
        "morning" "5m";
        "day" "2m";
        "evening" "3m";
    }
    
    server {
        listen 80;
        server_name example.com;
        
        location / {
            # 动态设置带宽限制
            limit_rate $bandwidth_limit;
            
            proxy_pass http://backend;
        }
    }
}

2.3 流量整形配置

2.3.1 令牌桶算法实现

# 令牌桶流量整形
http {
    # 定义令牌桶
    limit_req_zone $binary_remote_addr zone=token_bucket:10m rate=10r/s;
    
    server {
        listen 80;
        server_name example.com;
        
        location / {
            # 令牌桶限流
            limit_req zone=token_bucket burst=50 nodelay;
            
            # 流量整形
            limit_rate 2m;
            limit_rate_after 1m;
            
            proxy_pass http://backend;
        }
    }
}

2.3.2 优先级队列配置

# 优先级队列配置
http {
    # 定义业务优先级
    map $uri $priority {
        ~^/api/v1/ "high";
        ~^/api/v2/ "medium";
        ~^/static/ "low";
        default "medium";
    }
    
    # 不同优先级限速策略
    limit_req_zone $priority zone=high_priority:10m rate=100r/s;
    limit_req_zone $priority zone=medium_priority:10m rate=50r/s;
    limit_req_zone $priority zone=low_priority:10m rate=10r/s;
    
    server {
        listen 80;
        server_name example.com;
        
        # 高优先级接口
        location /api/v1/ {
            limit_req zone=high_priority burst=200 nodelay;
            limit_rate 10m;
            
            proxy_pass http://backend;
        }
        
        # 中优先级接口
        location /api/v2/ {
            limit_req zone=medium_priority burst=100 nodelay;
            limit_rate 5m;
            
            proxy_pass http://backend;
        }
        
        # 低优先级静态资源
        location /static/ {
            limit_req zone=low_priority burst=50 nodelay;
            limit_rate 2m;
            
            proxy_pass http://backend;
        }
    }
}

三、CDN集成与优化

3.1 CDN架构设计

3.1.1 CDN节点配置

graph TB
    A[用户请求] --> B[CDN边缘节点1]
    A --> C[CDN边缘节点2]
    A --> D[CDN边缘节点3]
    
    B --> E[源站服务器]
    C --> E
    D --> E
    
    F[CDN管理平台] --> B
    F --> C
    F --> D
    
    G[监控系统] --> F
    H[缓存策略] --> F

3.1.2 CDN配置示例

# CDN配置示例
server {
    listen 80;
    server_name cdn.example.com;
    
    # CDN缓存配置
    location / {
        # 缓存控制
        add_header Cache-Control "public, max-age=3600";
        add_header X-Cache-Status $upstream_cache_status;
        
        # 代理到源站
        proxy_pass http://origin.example.com;
        proxy_cache cdn_cache;
        proxy_cache_valid 200 1h;
        proxy_cache_valid 404 1m;
        
        # 缓存键配置
        proxy_cache_key $scheme$proxy_host$request_uri;
        
        # 缓存条件
        proxy_cache_bypass $http_pragma $http_authorization;
        proxy_no_cache $http_pragma $http_authorization;
    }
    
    # 静态资源CDN
    location ~* \.(jpg|jpeg|png|gif|css|js|woff|woff2)$ {
        # 长期缓存
        expires 1y;
        add_header Cache-Control "public, immutable";
        
        # CDN优化
        add_header X-CDN-Cache "HIT";
        
        proxy_pass http://origin.example.com;
        proxy_cache cdn_cache;
        proxy_cache_valid 200 1y;
    }
}

3.2 智能CDN路由

3.2.1 地理位置路由

# 地理位置路由配置
http {
    # 定义地理位置
    geo $geo_country {
        default "unknown";
        ~^1\.   "CN";
        ~^8\.   "US";
        ~^9\.   "US";
        ~^2\.   "EU";
        ~^3\.   "EU";
    }
    
    # 不同地区CDN节点
    map $geo_country $cdn_node {
        "CN" "cdn-cn.example.com";
        "US" "cdn-us.example.com";
        "EU" "cdn-eu.example.com";
        default "cdn-global.example.com";
    }
    
    server {
        listen 80;
        server_name example.com;
        
        location / {
            # 根据地理位置选择CDN节点
            proxy_pass http://$cdn_node;
            proxy_set_header Host $host;
            proxy_set_header X-Real-IP $remote_addr;
            proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
        }
    }
}

3.2.2 负载均衡CDN

# CDN负载均衡配置
upstream cdn_backend {
    # CDN节点列表
    server cdn-node1.example.com:80 weight=3;
    server cdn-node2.example.com:80 weight=2;
    server cdn-node3.example.com:80 weight=1;
    
    # 健康检查
    health_check interval=30s fails=3 passes=2;
}

server {
    listen 80;
    server_name example.com;
    
    location / {
        # CDN负载均衡
        proxy_pass http://cdn_backend;
        proxy_set_header Host $host;
        proxy_set_header X-Real-IP $remote_addr;
        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
        
        # CDN优化
        proxy_connect_timeout 5s;
        proxy_send_timeout 10s;
        proxy_read_timeout 10s;
    }
}

3.3 CDN缓存策略

3.3.1 缓存规则配置

# CDN缓存策略配置
http {
    # 缓存区域定义
    proxy_cache_path /var/cache/nginx/cdn 
                     levels=1:2 
                     keys_zone=cdn_cache:10m 
                     max_size=1g 
                     inactive=60m 
                     use_temp_path=off;
    
    server {
        listen 80;
        server_name example.com;
        
        # 动态内容缓存
        location /api/ {
            proxy_cache cdn_cache;
            proxy_cache_valid 200 5m;
            proxy_cache_valid 404 1m;
            proxy_cache_key $scheme$proxy_host$request_uri$args;
            
            # 缓存控制
            proxy_cache_bypass $http_pragma $http_authorization;
            proxy_no_cache $http_pragma $http_authorization;
            
            proxy_pass http://backend;
        }
        
        # 静态资源缓存
        location ~* \.(jpg|jpeg|png|gif|css|js)$ {
            proxy_cache cdn_cache;
            proxy_cache_valid 200 1d;
            proxy_cache_key $scheme$proxy_host$request_uri;
            
            # 长期缓存
            expires 1y;
            add_header Cache-Control "public, immutable";
            
            proxy_pass http://backend;
        }
        
        # HTML页面缓存
        location / {
            proxy_cache cdn_cache;
            proxy_cache_valid 200 1h;
            proxy_cache_key $scheme$proxy_host$request_uri;
            
            # 缓存控制
            proxy_cache_bypass $http_pragma $http_authorization;
            proxy_no_cache $http_pragma $http_authorization;
            
            proxy_pass http://backend;
        }
    }
}

3.3.2 缓存预热策略

# CDN缓存预热脚本
#!/bin/bash
# /usr/local/bin/cdn-cache-warmup.sh

# 预热URL列表
WARMUP_URLS=(
    "https://example.com/"
    "https://example.com/api/v1/users"
    "https://example.com/api/v1/products"
    "https://example.com/static/css/main.css"
    "https://example.com/static/js/app.js"
    "https://example.com/images/logo.png"
)

# CDN节点列表
CDN_NODES=(
    "cdn-node1.example.com"
    "cdn-node2.example.com"
    "cdn-node3.example.com"
)

# 预热函数
warmup_cache() {
    local url=$1
    local cdn_node=$2
    
    echo "Warming up cache for $url on $cdn_node"
    
    # 发送预热请求
    curl -H "X-Cache-Purge: false" \
         -H "X-Cache-Warmup: true" \
         "$url" > /dev/null 2>&1
    
    if [ $? -eq 0 ]; then
        echo "Cache warmup successful for $url"
    else
        echo "Cache warmup failed for $url"
    fi
}

# 执行预热
for cdn_node in "${CDN_NODES[@]}"; do
    for url in "${WARMUP_URLS[@]}"; do
        warmup_cache $url $cdn_node
        sleep 1
    done
done

echo "CDN cache warmup completed"

四、带宽监控与优化

4.1 实时带宽监控

4.1.1 带宽监控配置

# 带宽监控配置
http {
    # 定义监控变量
    map $request_method $monitor_method {
        GET "read";
        POST "write";
        PUT "write";
        DELETE "write";
        default "other";
    }
    
    # 日志格式定义
    log_format bandwidth_monitor 
        '$remote_addr - $remote_user [$time_local] '
        '"$request" $status $body_bytes_sent '
        '"$http_referer" "$http_user_agent" '
        'rt=$request_time '
        'ua="$upstream_addr" '
        'us="$upstream_status" '
        'ut="$upstream_response_time" '
        'ul="$upstream_response_length" '
        'cs=$upstream_cache_status '
        'method=$monitor_method';
    
    server {
        listen 80;
        server_name example.com;
        
        # 启用监控日志
        access_log /var/log/nginx/bandwidth_monitor.log bandwidth_monitor;
        
        location / {
            proxy_pass http://backend;
        }
    }
}

4.1.2 监控脚本

# 带宽监控脚本
#!/bin/bash
# /usr/local/bin/bandwidth-monitor.sh

LOG_FILE="/var/log/nginx/bandwidth_monitor.log"
ALERT_EMAIL="admin@company.com"
BANDWIDTH_THRESHOLD=1000000  # 1MB/s

# 监控带宽使用
monitor_bandwidth() {
    local current_time=$(date '+%Y-%m-%d %H:%M:%S')
    
    # 计算最近1分钟的带宽使用
    local bandwidth_usage=$(tail -n 1000 $LOG_FILE | \
        awk -v threshold="$BANDWIDTH_THRESHOLD" '
        BEGIN { total_bytes = 0 }
        { total_bytes += $10 }
        END { 
            bandwidth_mbps = (total_bytes * 8) / (60 * 1024 * 1024)
            print bandwidth_mbps
        }')
    
    echo "$current_time: Bandwidth usage: ${bandwidth_usage}Mbps"
    
    # 带宽告警
    if (( $(echo "$bandwidth_usage > 100" | bc -l) )); then
        echo "$current_time: High bandwidth usage detected: ${bandwidth_usage}Mbps" | \
            mail -s "Bandwidth Alert" $ALERT_EMAIL
    fi
}

# 监控连接数
monitor_connections() {
    local current_time=$(date '+%Y-%m-%d %H:%M:%S')
    
    # 获取当前连接数
    local active_connections=$(netstat -an | grep :80 | grep ESTABLISHED | wc -l)
    local total_connections=$(netstat -an | grep :80 | wc -l)
    
    echo "$current_time: Active connections: $active_connections, Total connections: $total_connections"
    
    # 连接数告警
    if [ $active_connections -gt 1000 ]; then
        echo "$current_time: High connection count detected: $active_connections" | \
            mail -s "Connection Alert" $ALERT_EMAIL
    fi
}

# 执行监控
monitor_bandwidth
monitor_connections

4.2 带宽优化策略

4.2.1 压缩优化配置

# 压缩优化配置
http {
    # 启用gzip压缩
    gzip on;
    gzip_vary on;
    gzip_min_length 1024;
    gzip_proxied any;
    gzip_comp_level 6;
    gzip_types
        text/plain
        text/css
        text/xml
        text/javascript
        application/json
        application/javascript
        application/xml+rss
        application/atom+xml
        image/svg+xml;
    
    # 启用brotli压缩
    brotli on;
    brotli_comp_level 6;
    brotli_types
        text/plain
        text/css
        text/xml
        text/javascript
        application/json
        application/javascript
        application/xml+rss
        application/atom+xml
        image/svg+xml;
    
    server {
        listen 80;
        server_name example.com;
        
        location / {
            # 压缩响应
            gzip_static on;
            brotli_static on;
            
            proxy_pass http://backend;
        }
    }
}

4.2.2 传输优化配置

# 传输优化配置
http {
    # TCP优化
    tcp_nopush on;
    tcp_nodelay on;
    
    # 发送文件优化
    sendfile on;
    sendfile_max_chunk 1m;
    
    # 缓冲区优化
    client_body_buffer_size 128k;
    client_header_buffer_size 1k;
    client_max_body_size 8m;
    large_client_header_buffers 4 4k;
    
    # 超时优化
    client_body_timeout 12;
    client_header_timeout 12;
    keepalive_timeout 15;
    send_timeout 10;
    
    server {
        listen 80;
        server_name example.com;
        
        location / {
            # 传输优化
            proxy_buffering on;
            proxy_buffer_size 4k;
            proxy_buffers 8 4k;
            proxy_busy_buffers_size 8k;
            
            # 连接优化
            proxy_http_version 1.1;
            proxy_set_header Connection "";
            
            proxy_pass http://backend;
        }
    }
}

4.3 智能带宽分配

4.3.1 动态带宽分配

# 动态带宽分配配置
http {
    # 定义业务优先级
    map $uri $bandwidth_priority {
        ~^/api/v1/ "high";
        ~^/api/v2/ "medium";
        ~^/static/ "low";
        default "medium";
    }
    
    # 不同优先级带宽限制
    map $bandwidth_priority $bandwidth_limit {
        "high" "10m";
        "medium" "5m";
        "low" "2m";
    }
    
    server {
        listen 80;
        server_name example.com;
        
        location / {
            # 动态带宽分配
            limit_rate $bandwidth_limit;
            
            # 优先级队列
            if ($bandwidth_priority = "high") {
                limit_req zone=high_priority burst=200 nodelay;
            }
            if ($bandwidth_priority = "medium") {
                limit_req zone=medium_priority burst=100 nodelay;
            }
            if ($bandwidth_priority = "low") {
                limit_req zone=low_priority burst=50 nodelay;
            }
            
            proxy_pass http://backend;
        }
    }
}

4.3.2 自适应带宽调整

# 自适应带宽调整脚本
#!/bin/bash
# /usr/local/bin/adaptive-bandwidth.sh

NGINX_CONFIG="/etc/nginx/nginx.conf"
LOG_FILE="/var/log/nginx/bandwidth_monitor.log"
ADJUSTMENT_THRESHOLD=80  # 80%带宽使用率

# 获取当前带宽使用率
get_bandwidth_usage() {
    local usage=$(tail -n 1000 $LOG_FILE | \
        awk '
        BEGIN { total_bytes = 0 }
        { total_bytes += $10 }
        END { 
            bandwidth_mbps = (total_bytes * 8) / (60 * 1024 * 1024)
            print bandwidth_mbps
        }')
    echo $usage
}

# 调整带宽限制
adjust_bandwidth_limit() {
    local current_usage=$1
    local current_limit=$2
    
    # 计算新的带宽限制
    local new_limit=$current_limit
    
    if (( $(echo "$current_usage > $ADJUSTMENT_THRESHOLD" | bc -l) )); then
        # 带宽使用率高，增加限制
        new_limit=$((current_limit * 120 / 100))
    elif (( $(echo "$current_usage < 50" | bc -l) )); then
        # 带宽使用率低，减少限制
        new_limit=$((current_limit * 80 / 100))
    fi
    
    echo $new_limit
}

# 更新Nginx配置
update_nginx_config() {
    local new_limit=$1
    
    # 备份原配置
    cp $NGINX_CONFIG $NGINX_CONFIG.backup
    
    # 更新配置
    sed -i "s/limit_rate [0-9]*m/limit_rate ${new_limit}m/g" $NGINX_CONFIG
    
    # 重载配置
    nginx -t && nginx -s reload
    
    if [ $? -eq 0 ]; then
        echo "$(date): Bandwidth limit updated to ${new_limit}m"
    else
        echo "$(date): Failed to update bandwidth limit"
        # 恢复原配置
        cp $NGINX_CONFIG.backup $NGINX_CONFIG
    fi
}

# 主函数
main() {
    local current_usage=$(get_bandwidth_usage)
    local current_limit=5  # 当前限制5MB/s
    
    echo "$(date): Current bandwidth usage: ${current_usage}Mbps"
    
    local new_limit=$(adjust_bandwidth_limit $current_usage $current_limit)
    
    if [ $new_limit -ne $current_limit ]; then
        update_nginx_config $new_limit
    fi
}

# 执行自适应调整
main

五、高并发带宽优化

5.1 连接池优化

5.1.1 连接池配置

# 连接池优化配置
http {
    # 上游连接池
    upstream backend {
        server 192.168.1.10:8080 max_fails=3 fail_timeout=30s;
        server 192.168.1.11:8080 max_fails=3 fail_timeout=30s;
        server 192.168.1.12:8080 max_fails=3 fail_timeout=30s;
        
        # 连接池配置
        keepalive 32;
        keepalive_requests 100;
        keepalive_timeout 60s;
    }
    
    server {
        listen 80;
        server_name example.com;
        
        location / {
            # 连接池优化
            proxy_http_version 1.1;
            proxy_set_header Connection "";
            proxy_set_header Host $host;
            proxy_set_header X-Real-IP $remote_addr;
            proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
            
            # 连接超时配置
            proxy_connect_timeout 5s;
            proxy_send_timeout 10s;
            proxy_read_timeout 10s;
            
            proxy_pass http://backend;
        }
    }
}

5.1.2 连接复用优化

# 连接复用优化配置
http {
    # 启用keepalive
    keepalive_timeout 65;
    keepalive_requests 100;
    
    # 上游keepalive
    upstream backend {
        server 192.168.1.10:8080;
        server 192.168.1.11:8080;
        server 192.168.1.12:8080;
        
        keepalive 32;
        keepalive_requests 100;
        keepalive_timeout 60s;
    }
    
    server {
        listen 80;
        server_name example.com;
        
        # 客户端keepalive
        location / {
            proxy_http_version 1.1;
            proxy_set_header Connection "";
            
            # 连接复用
            proxy_pass http://backend;
        }
        
        # 静态资源keepalive
        location ~* \.(jpg|jpeg|png|gif|css|js)$ {
            expires 1y;
            add_header Cache-Control "public, immutable";
            
            proxy_pass http://backend;
        }
    }
}

5.2 缓存优化

5.2.1 多级缓存配置

# 多级缓存配置
http {
    # 本地缓存
    proxy_cache_path /var/cache/nginx/levels/1 
                     levels=1:2 
                     keys_zone=level1:10m 
                     max_size=1g 
                     inactive=60m;
    
    proxy_cache_path /var/cache/nginx/levels/2 
                     levels=1:2 
                     keys_zone=level2:10m 
                     max_size=2g 
                     inactive=120m;
    
    server {
        listen 80;
        server_name example.com;
        
        # 第一级缓存 - 热点数据
        location /hot/ {
            proxy_cache level1;
            proxy_cache_valid 200 5m;
            proxy_cache_key $scheme$proxy_host$request_uri;
            
            proxy_pass http://backend;
        }
        
        # 第二级缓存 - 温数据
        location /warm/ {
            proxy_cache level2;
            proxy_cache_valid 200 30m;
            proxy_cache_key $scheme$proxy_host$request_uri;
            
            proxy_pass http://backend;
        }
        
        # 冷数据 - 直接代理
        location /cold/ {
            proxy_pass http://backend;
        }
    }
}

5.2.2 缓存预热策略

# 缓存预热脚本
#!/bin/bash
# /usr/local/bin/cache-warmup.sh

# 预热URL列表
WARMUP_URLS=(
    "http://example.com/hot/api/v1/users"
    "http://example.com/hot/api/v1/products"
    "http://example.com/warm/api/v2/categories"
    "http://example.com/warm/api/v2/orders"
)

# 预热函数
warmup_cache() {
    local url=$1
    local level=$2
    
    echo "Warming up $level cache for $url"
    
    # 发送预热请求
    curl -H "X-Cache-Warmup: true" \
         -H "X-Cache-Level: $level" \
         "$url" > /dev/null 2>&1
    
    if [ $? -eq 0 ]; then
        echo "Cache warmup successful for $url"
    else
        echo "Cache warmup failed for $url"
    fi
}

# 执行预热
for url in "${WARMUP_URLS[@]}"; do
    if [[ $url == *"/hot/"* ]]; then
        warmup_cache $url "level1"
    elif [[ $url == *"/warm/"* ]]; then
        warmup_cache $url "level2"
    fi
    
    sleep 1
done

echo "Cache warmup completed"

5.3 负载均衡优化

5.3.1 智能负载均衡

# 智能负载均衡配置
http {
    # 定义服务器权重
    map $request_uri $server_weight {
        ~^/api/v1/ "high";
        ~^/api/v2/ "medium";
        ~^/static/ "low";
        default "medium";
    }
    
    # 不同权重负载均衡
    upstream high_weight_backend {
        server 192.168.1.10:8080 weight=10;
        server 192.168.1.11:8080 weight=8;
        server 192.168.1.12:8080 weight=6;
    }
    
    upstream medium_weight_backend {
        server 192.168.1.10:8080 weight=5;
        server 192.168.1.11:8080 weight=4;
        server 192.168.1.12:8080 weight=3;
    }
    
    upstream low_weight_backend {
        server 192.168.1.10:8080 weight=2;
        server 192.168.1.11:8080 weight=2;
        server 192.168.1.12:8080 weight=1;
    }
    
    server {
        listen 80;
        server_name example.com;
        
        # 高权重接口
        location /api/v1/ {
            proxy_pass http://high_weight_backend;
            limit_rate 10m;
        }
        
        # 中权重接口
        location /api/v2/ {
            proxy_pass http://medium_weight_backend;
            limit_rate 5m;
        }
        
        # 低权重静态资源
        location /static/ {
            proxy_pass http://low_weight_backend;
            limit_rate 2m;
        }
    }
}

5.3.2 健康检查优化

# 健康检查优化配置
http {
    # 健康检查配置
    upstream backend {
        server 192.168.1.10:8080 max_fails=3 fail_timeout=30s;
        server 192.168.1.11:8080 max_fails=3 fail_timeout=30s;
        server 192.168.1.12:8080 max_fails=3 fail_timeout=30s;
        
        # 健康检查
        health_check interval=10s fails=3 passes=2;
    }
    
    server {
        listen 80;
        server_name example.com;
        
        # 健康检查端点
        location /health {
            access_log off;
            return 200 "healthy\n";
            add_header Content-Type text/plain;
        }
        
        location / {
            proxy_pass http://backend;
            
            # 健康检查头
            proxy_set_header X-Health-Check "true";
        }
    }
}

六、带宽成本优化

6.1 成本分析工具

6.1.1 带宽成本计算

# 带宽成本计算脚本
#!/bin/bash
# /usr/local/bin/bandwidth-cost-calculator.sh

# 成本参数
BANDWIDTH_COST_PER_GB=0.1  # 每GB带宽成本
CDN_COST_PER_GB=0.05       # CDN每GB成本
CACHE_HIT_RATE=0.8         # 缓存命中率

# 获取带宽使用数据
get_bandwidth_usage() {
    local log_file="/var/log/nginx/bandwidth_monitor.log"
    
    # 计算总带宽使用
    local total_bytes=$(tail -n 10000 $log_file | \
        awk '{ total += $10 } END { print total }')
    
    # 转换为GB
    local total_gb=$((total_bytes / 1024 / 1024 / 1024))
    
    echo $total_gb
}

# 计算成本
calculate_costs() {
    local total_bandwidth=$1
    
    # 直接带宽成本
    local direct_cost=$(echo "$total_bandwidth * $BANDWIDTH_COST_PER_GB" | bc)
    
    # CDN带宽成本
    local cdn_bandwidth=$(echo "$total_bandwidth * (1 - $CACHE_HIT_RATE)" | bc)
    local cdn_cost=$(echo "$cdn_bandwidth * $CDN_COST_PER_GB" | bc)
    
    # 总成本
    local total_cost=$(echo "$direct_cost + $cdn_cost" | bc)
    
    echo "Direct bandwidth cost: \$${direct_cost}"
    echo "CDN bandwidth cost: \$${cdn_cost}"
    echo "Total cost: \$${total_cost}"
}

# 优化建议
optimization_suggestions() {
    local total_bandwidth=$1
    
    echo "Optimization suggestions:"
    echo "1. Increase cache hit rate to reduce CDN costs"
    echo "2. Implement compression to reduce bandwidth usage"
    echo "3. Use CDN for static resources"
    echo "4. Implement bandwidth limiting for non-critical traffic"
    echo "5. Monitor and optimize cache policies"
}

# 主函数
main() {
    local total_bandwidth=$(get_bandwidth_usage)
    
    echo "Bandwidth Cost Analysis Report"
    echo "=============================="
    echo "Total bandwidth usage: ${total_bandwidth}GB"
    echo ""
    
    calculate_costs $total_bandwidth
    echo ""
    
    optimization_suggestions $total_bandwidth
}

# 执行成本分析
main

6.1.2 成本优化策略

# 成本优化策略脚本
#!/bin/bash
# /usr/local/bin/cost-optimization.sh

NGINX_CONFIG="/etc/nginx/nginx.conf"
OPTIMIZATION_LOG="/var/log/nginx/optimization.log"

# 启用压缩优化
enable_compression() {
    echo "$(date): Enabling compression optimization" >> $OPTIMIZATION_LOG
    
    # 检查是否已启用压缩
    if ! grep -q "gzip on;" $NGINX_CONFIG; then
        # 添加压缩配置
        sed -i '/http {/a\    gzip on;\n    gzip_vary on;\n    gzip_min_length 1024;\n    gzip_comp_level 6;' $NGINX_CONFIG
        
        # 重载配置
        nginx -t && nginx -s reload
        
        if [ $? -eq 0 ]; then
            echo "$(date): Compression optimization enabled successfully" >> $OPTIMIZATION_LOG
        else
            echo "$(date): Failed to enable compression optimization" >> $OPTIMIZATION_LOG
        fi
    else
        echo "$(date): Compression optimization already enabled" >> $OPTIMIZATION_LOG
    fi
}

# 启用缓存优化
enable_caching() {
    echo "$(date): Enabling caching optimization" >> $OPTIMIZATION_LOG
    
    # 检查是否已启用缓存
    if ! grep -q "proxy_cache" $NGINX_CONFIG; then
        # 添加缓存配置
        cat >> $NGINX_CONFIG << 'EOF'
    proxy_cache_path /var/cache/nginx 
                     levels=1:2 
                     keys_zone=main_cache:10m 
                     max_size=1g 
                     inactive=60m;
EOF
        
        # 重载配置
        nginx -t && nginx -s reload
        
        if [ $? -eq 0 ]; then
            echo "$(date): Caching optimization enabled successfully" >> $OPTIMIZATION_LOG
        else
            echo "$(date): Failed to enable caching optimization" >> $OPTIMIZATION_LOG
        fi
    else
        echo "$(date): Caching optimization already enabled" >> $OPTIMIZATION_LOG
    fi
}

# 启用带宽限制
enable_bandwidth_limiting() {
    echo "$(date): Enabling bandwidth limiting" >> $OPTIMIZATION_LOG
    
    # 检查是否已启用带宽限制
    if ! grep -q "limit_rate" $NGINX_CONFIG; then
        # 添加带宽限制配置
        sed -i '/location \/ {/a\        limit_rate 2m;' $NGINX_CONFIG
        
        # 重载配置
        nginx -t && nginx -s reload
        
        if [ $? -eq 0 ]; then
            echo "$(date): Bandwidth limiting enabled successfully" >> $OPTIMIZATION_LOG
        else
            echo "$(date): Failed to enable bandwidth limiting" >> $OPTIMIZATION_LOG
        fi
    else
        echo "$(date): Bandwidth limiting already enabled" >> $OPTIMIZATION_LOG
    fi
}

# 执行优化
main() {
    echo "$(date): Starting cost optimization" >> $OPTIMIZATION_LOG
    
    enable_compression
    enable_caching
    enable_bandwidth_limiting
    
    echo "$(date): Cost optimization completed" >> $OPTIMIZATION_LOG
}

# 执行优化
main

6.2 智能带宽分配

6.2.1 基于成本的带宽分配

# 基于成本的带宽分配配置
http {
    # 定义成本等级
    map $uri $cost_level {
        ~^/api/v1/ "high";
        ~^/api/v2/ "medium";
        ~^/static/ "low";
        default "medium";
    }
    
    # 不同成本等级带宽限制
    map $cost_level $bandwidth_limit {
        "high" "10m";
        "medium" "5m";
        "low" "1m";
    }
    
    # 不同成本等级缓存策略
    map $cost_level $cache_ttl {
        "high" "5m";
        "medium" "30m";
        "low" "1d";
    }
    
    server {
        listen 80;
        server_name example.com;
        
        location / {
            # 基于成本的带宽分配
            limit_rate $bandwidth_limit;
            
            # 基于成本的缓存策略
            proxy_cache_valid 200 $cache_ttl;
            
            proxy_pass http://backend;
        }
    }
}

6.2.2 动态成本优化

# 动态成本优化脚本
#!/bin/bash
# /usr/local/bin/dynamic-cost-optimization.sh

NGINX_CONFIG="/etc/nginx/nginx.conf"
COST_THRESHOLD=100  # 成本阈值

# 获取当前成本
get_current_cost() {
    local log_file="/var/log/nginx/bandwidth_monitor.log"
    
    # 计算当前小时的成本
    local current_hour=$(date '+%Y-%m-%d %H')
    local bandwidth_usage=$(grep "$current_hour" $log_file | \
        awk '{ total += $10 } END { print total / 1024 / 1024 / 1024 }')
    
    local cost=$(echo "$bandwidth_usage * 0.1" | bc)
    echo $cost
}

# 调整带宽限制
adjust_bandwidth_limits() {
    local current_cost=$1
    
    if (( $(echo "$current_cost > $COST_THRESHOLD" | bc -l) )); then
        echo "$(date): High cost detected, reducing bandwidth limits"
        
        # 减少带宽限制
        sed -i 's/limit_rate [0-9]*m/limit_rate 1m/g' $NGINX_CONFIG
        
        # 重载配置
        nginx -t && nginx -s reload
    else
        echo "$(date): Cost within threshold, maintaining current limits"
    fi
}

# 主函数
main() {
    local current_cost=$(get_current_cost)
    
    echo "$(date): Current cost: \$${current_cost}"
    
    adjust_bandwidth_limits $current_cost
}

# 执行动态优化
main

七、监控与告警系统

7.1 带宽监控系统

7.1.1 实时监控配置

# 实时监控配置
http {
    # 监控日志格式
    log_format bandwidth_monitor 
        '$remote_addr - $remote_user [$time_local] '
        '"$request" $status $body_bytes_sent '
        '"$http_referer" "$http_user_agent" '
        'rt=$request_time '
        'ua="$upstream_addr" '
        'us="$upstream_status" '
        'ut="$upstream_response_time" '
        'ul="$upstream_response_length" '
        'cs=$upstream_cache_status '
        'bandwidth=$body_bytes_sent';
    
    server {
        listen 80;
        server_name example.com;
        
        # 启用监控日志
        access_log /var/log/nginx/bandwidth_monitor.log bandwidth_monitor;
        
        # 监控端点
        location /nginx_status {
            stub_status on;
            access_log off;
            allow 127.0.0.1;
            deny all;
        }
        
        location / {
            proxy_pass http://backend;
        }
    }
}

7.1.2 监控数据收集

# 监控数据收集脚本
#!/bin/bash
# /usr/local/bin/bandwidth-monitor-collector.sh

LOG_FILE="/var/log/nginx/bandwidth_monitor.log"
MONITORING_DB="/var/lib/monitoring/bandwidth.db"

# 创建监控数据库
create_monitoring_db() {
    sqlite3 $MONITORING_DB << 'EOF'
CREATE TABLE IF NOT EXISTS bandwidth_stats (
    id INTEGER PRIMARY KEY AUTOINCREMENT,
    timestamp DATETIME DEFAULT CURRENT_TIMESTAMP,
    total_bytes INTEGER,
    total_requests INTEGER,
    avg_response_time REAL,
    cache_hit_rate REAL
);
EOF
}

# 收集监控数据
collect_monitoring_data() {
    local current_time=$(date '+%Y-%m-%d %H:%M:%S')
    
    # 计算统计数据
    local total_bytes=$(tail -n 1000 $LOG_FILE | \
        awk '{ total += $NF } END { print total }')
    
    local total_requests=$(tail -n 1000 $LOG_FILE | wc -l)
    
    local avg_response_time=$(tail -n 1000 $LOG_FILE | \
        awk '{ total += $4 } END { print total / NR }')
    
    local cache_hits=$(tail -n 1000 $LOG_FILE | grep "HIT" | wc -l)
    local cache_hit_rate=$(echo "scale=2; $cache_hits * 100 / $total_requests" | bc)
    
    # 插入数据库
    sqlite3 $MONITORING_DB << EOF
INSERT INTO bandwidth_stats (timestamp, total_bytes, total_requests, avg_response_time, cache_hit_rate)
VALUES ('$current_time', $total_bytes, $total_requests, $avg_response_time, $cache_hit_rate);
EOF
    
    echo "$current_time: Collected monitoring data"
}

# 主函数
main() {
    create_monitoring_db
    collect_monitoring_data
}

# 执行数据收集
main

7.2 告警系统

7.2.1 告警规则配置

# 告警规则配置脚本
#!/bin/bash
# /usr/local/bin/bandwidth-alert-rules.sh

MONITORING_DB="/var/lib/monitoring/bandwidth.db"
ALERT_EMAIL="admin@company.com"
ALERT_WEBHOOK="https://hooks.slack.com/services/YOUR/SLACK/WEBHOOK"

# 带宽使用率告警
bandwidth_usage_alert() {
    local threshold=80  # 80%阈值
    
    local current_usage=$(sqlite3 $MONITORING_DB \
        "SELECT total_bytes FROM bandwidth_stats ORDER BY timestamp DESC LIMIT 1;")
    
    local max_usage=$(sqlite3 $MONITORING_DB \
        "SELECT MAX(total_bytes) FROM bandwidth_stats WHERE timestamp > datetime('now', '-1 hour');")
    
    local usage_percent=$(echo "scale=2; $current_usage * 100 / $max_usage" | bc)
    
    if (( $(echo "$usage_percent > $threshold" | bc -l) )); then
        local message="High bandwidth usage detected: ${usage_percent}%"
        
        # 发送邮件告警
        echo "$message" | mail -s "Bandwidth Alert" $ALERT_EMAIL
        
        # 发送Slack告警
        curl -X POST $ALERT_WEBHOOK \
          -H 'Content-Type: application/json' \
          -d "{\"text\": \"$message\"}"
        
        echo "$(date): $message"
    fi
}

# 响应时间告警
response_time_alert() {
    local threshold=2.0  # 2秒阈值
    
    local avg_response_time=$(sqlite3 $MONITORING_DB \
        "SELECT avg_response_time FROM bandwidth_stats ORDER BY timestamp DESC LIMIT 1;")
    
    if (( $(echo "$avg_response_time > $threshold" | bc -l) )); then
        local message="High response time detected: ${avg_response_time}s"
        
        # 发送告警
        echo "$message" | mail -s "Response Time Alert" $ALERT_EMAIL
        
        echo "$(date): $message"
    fi
}

# 缓存命中率告警
cache_hit_rate_alert() {
    local threshold=70  # 70%阈值
    
    local cache_hit_rate=$(sqlite3 $MONITORING_DB \
        "SELECT cache_hit_rate FROM bandwidth_stats ORDER BY timestamp DESC LIMIT 1;")
    
    if (( $(echo "$cache_hit_rate < $threshold" | bc -l) )); then
        local message="Low cache hit rate detected: ${cache_hit_rate}%"
        
        # 发送告警
        echo "$message" | mail -s "Cache Hit Rate Alert" $ALERT_EMAIL
        
        echo "$(date): $message"
    fi
}

# 执行告警检查
main() {
    bandwidth_usage_alert
    response_time_alert
    cache_hit_rate_alert
}

# 执行告警检查
main

7.2.2 告警通知配置

# 告警通知配置脚本
#!/bin/bash
# /usr/local/bin/alert-notification.sh

ALERT_EMAIL="admin@company.com"
ALERT_SMS="+1234567890"
ALERT_WEBHOOK="https://hooks.slack.com/services/YOUR/SLACK/WEBHOOK"

# 发送邮件告警
send_email_alert() {
    local subject=$1
    local message=$2
    
    echo "$message" | mail -s "$subject" $ALERT_EMAIL
}

# 发送短信告警
send_sms_alert() {
    local message=$1
    
    # 使用Twilio发送短信
    curl -X POST "https://api.twilio.com/2010-04-01/Accounts/YOUR_ACCOUNT_SID/Messages.json" \
      -u "YOUR_ACCOUNT_SID:YOUR_AUTH_TOKEN" \
      -d "From=+1234567890" \
      -d "To=$ALERT_SMS" \
      -d "Body=$message"
}

# 发送Slack告警
send_slack_alert() {
    local message=$1
    local severity=$2
    
    local color="good"
    if [ "$severity" = "high" ]; then
        color="danger"
    elif [ "$severity" = "medium" ]; then
        color="warning"
    fi
    
    curl -X POST $ALERT_WEBHOOK \
      -H 'Content-Type: application/json' \
      -d "{
        \"attachments\": [{
          \"color\": \"$color\",
          \"title\": \"Bandwidth Alert\",
          \"text\": \"$message\",
          \"timestamp\": $(date +%s)
        }]
      }"
}

# 发送企业微信告警
send_wechat_alert() {
    local message=$1
    
    curl -X POST "https://qyapi.weixin.qq.com/cgi-bin/webhook/send?key=YOUR_KEY" \
      -H 'Content-Type: application/json' \
      -d "{
        \"msgtype\": \"text\",
        \"text\": {
          \"content\": \"$message\"
        }
      }"
}

# 主函数
main() {
    local alert_type=$1
    local message=$2
    local severity=${3:-"medium"}
    
    case $alert_type in
        "email")
            send_email_alert "Bandwidth Alert" "$message"
            ;;
        "sms")
            send_sms_alert "$message"
            ;;
        "slack")
            send_slack_alert "$message" "$severity"
            ;;
        "wechat")
            send_wechat_alert "$message"
            ;;
        "all")
            send_email_alert "Bandwidth Alert" "$message"
            send_slack_alert "$message" "$severity"
            send_wechat_alert "$message"
            ;;
        *)
            echo "Usage: $0 {email|sms|slack|wechat|all} message [severity]"
            exit 1
            ;;
    esac
}

# 执行告警通知
main $1 "$2" $3

八、企业级最佳实践

8.1 架构设计原则

8.1.1 带宽优化架构

graph TB
    A[用户请求] --> B[CDN边缘节点]
    B --> C[负载均衡器]
    C --> D[Nginx集群]
    D --> E[后端应用服务器]
    
    F[带宽监控] --> C
    G[流量控制] --> C
    H[缓存系统] --> D
    
    subgraph "优化层"
        I[压缩优化]
        J[缓存优化]
        K[连接优化]
        L[传输优化]
    end
    
    C --> I
    C --> J
    C --> K
    C --> L

8.1.2 成本控制策略

成本控制策略:
  带宽优化:
    - 启用压缩传输
    - 实施缓存策略
    - 优化传输协议
    - 使用CDN加速
  
  流量控制:
    - 实施限速策略
    - 优先级队列
    - 动态带宽分配
    - 智能路由选择
  
  监控管理:
    - 实时监控
    - 成本分析
    - 告警通知
    - 优化建议

8.2 性能优化策略

8.2.1 传输优化

# 传输优化配置
http {
    # TCP优化
    tcp_nopush on;
    tcp_nodelay on;
    
    # 发送文件优化
    sendfile on;
    sendfile_max_chunk 1m;
    
    # 缓冲区优化
    client_body_buffer_size 128k;
    client_header_buffer_size 1k;
    client_max_body_size 8m;
    large_client_header_buffers 4 4k;
    
    # 超时优化
    client_body_timeout 12;
    client_header_timeout 12;
    keepalive_timeout 15;
    send_timeout 10;
    
    # 压缩优化
    gzip on;
    gzip_vary on;
    gzip_min_length 1024;
    gzip_comp_level 6;
    gzip_types
        text/plain
        text/css
        text/xml
        text/javascript
        application/json
        application/javascript
        application/xml+rss
        application/atom+xml
        image/svg+xml;
}

8.2.2 缓存优化

# 缓存优化配置
http {
    # 缓存路径配置
    proxy_cache_path /var/cache/nginx 
                     levels=1:2 
                     keys_zone=main_cache:10m 
                     max_size=1g 
                     inactive=60m 
                     use_temp_path=off;
    
    server {
        listen 80;
        server_name example.com;
        
        # 静态资源缓存
        location ~* \.(jpg|jpeg|png|gif|css|js|woff|woff2)$ {
            proxy_cache main_cache;
            proxy_cache_valid 200 1d;
            proxy_cache_key $scheme$proxy_host$request_uri;
            
            expires 1y;
            add_header Cache-Control "public, immutable";
            
            proxy_pass http://backend;
        }
        
        # API接口缓存
        location /api/ {
            proxy_cache main_cache;
            proxy_cache_valid 200 5m;
            proxy_cache_key $scheme$proxy_host$request_uri$args;
            
            proxy_cache_bypass $http_pragma $http_authorization;
            proxy_no_cache $http_pragma $http_authorization;
            
            proxy_pass http://backend;
        }
    }
}

8.3 运维管理策略

8.3.1 监控指标

监控指标:
  带宽指标:
    - 总带宽使用量
    - 带宽使用率
    - 峰值带宽
    - 平均带宽
  
  性能指标:
    - 响应时间
    - 吞吐量
    - 并发连接数
    - 错误率
  
  成本指标:
    - 带宽成本
    - CDN成本
    - 总成本
    - 成本趋势

8.3.2 告警策略

告警策略:
  紧急告警:
    - 带宽使用率超过90%
    - 响应时间超过5秒
    - 错误率超过10%
  
  重要告警:
    - 带宽使用率超过80%
    - 响应时间超过2秒
    - 缓存命中率低于70%
  
  一般告警:
    - 带宽使用率超过70%
    - 响应时间超过1秒
    - 连接数异常

九、故障排查与问题解决

9.1 常见问题诊断

9.1.1 带宽问题诊断

# 带宽问题诊断脚本
#!/bin/bash
# /usr/local/bin/bandwidth-troubleshoot.sh

echo "Bandwidth Troubleshooting Report"
echo "================================"
echo "Time: $(date)"
echo ""

# 检查Nginx状态
echo "1. Nginx Status"
if systemctl is-active --quiet nginx; then
    echo "   ✓ Nginx is running"
else
    echo "   ✗ Nginx is not running"
    echo "   Suggestion: systemctl start nginx"
fi
echo ""

# 检查带宽使用
echo "2. Bandwidth Usage"
local bandwidth_usage=$(tail -n 1000 /var/log/nginx/bandwidth_monitor.log | \
    awk '{ total += $NF } END { print total / 1024 / 1024 / 1024 }')
echo "   Current bandwidth usage: ${bandwidth_usage}GB"
echo ""

# 检查连接数
echo "3. Connection Count"
local active_connections=$(netstat -an | grep :80 | grep ESTABLISHED | wc -l)
local total_connections=$(netstat -an | grep :80 | wc -l)
echo "   Active connections: $active_connections"
echo "   Total connections: $total_connections"
echo ""

# 检查响应时间
echo "4. Response Time"
local avg_response_time=$(tail -n 1000 /var/log/nginx/bandwidth_monitor.log | \
    awk '{ total += $4 } END { print total / NR }')
echo "   Average response time: ${avg_response_time}s"
echo ""

# 检查缓存命中率
echo "5. Cache Hit Rate"
local cache_hits=$(tail -n 1000 /var/log/nginx/bandwidth_monitor.log | grep "HIT" | wc -l)
local total_requests=$(tail -n 1000 /var/log/nginx/bandwidth_monitor.log | wc -l)
local cache_hit_rate=$(echo "scale=2; $cache_hits * 100 / $total_requests" | bc)
echo "   Cache hit rate: ${cache_hit_rate}%"
echo ""

echo "Troubleshooting completed"

9.1.2 性能问题诊断

# 性能问题诊断脚本
#!/bin/bash
# /usr/local/bin/performance-troubleshoot.sh

echo "Performance Troubleshooting Report"
echo "=================================="
echo "Time: $(date)"
echo ""

# 检查系统负载
echo "1. System Load"
local load_avg=$(uptime | awk -F'load average:' '{ print $2 }')
echo "   Load average: $load_avg"
echo ""

# 检查内存使用
echo "2. Memory Usage"
local memory_usage=$(free -m | awk 'NR==2{printf "%.2f%%", $3*100/$2 }')
echo "   Memory usage: $memory_usage"
echo ""

# 检查磁盘使用
echo "3. Disk Usage"
local disk_usage=$(df -h / | awk 'NR==2{print $5}')
echo "   Disk usage: $disk_usage"
echo ""

# 检查网络连接
echo "4. Network Connections"
local network_connections=$(netstat -an | grep :80 | wc -l)
echo "   Network connections: $network_connections"
echo ""

# 检查Nginx配置
echo "5. Nginx Configuration"
if nginx -t > /dev/null 2>&1; then
    echo "   ✓ Nginx configuration is valid"
else
    echo "   ✗ Nginx configuration has errors"
    echo "   Suggestion: Check nginx configuration"
fi
echo ""

echo "Performance troubleshooting completed"

9.2 故障恢复

9.2.1 自动故障恢复

# 自动故障恢复脚本
#!/bin/bash
# /usr/local/bin/auto-recovery.sh

LOG_FILE="/var/log/nginx/auto-recovery.log"

# 记录恢复操作
log_recovery() {
    local action=$1
    local status=$2
    echo "$(date): $action - $status" >> $LOG_FILE
}

# 重启Nginx服务
restart_nginx() {
    log_recovery "RESTART" "Starting Nginx restart"
    
    systemctl restart nginx
    
    if [ $? -eq 0 ]; then
        log_recovery "RESTART" "Nginx restarted successfully"
        return 0
    else
        log_recovery "RESTART" "Failed to restart Nginx"
        return 1
    fi
}

# 清理缓存
clear_cache() {
    log_recovery "CACHE" "Starting cache cleanup"
    
    rm -rf /var/cache/nginx/*
    
    if [ $? -eq 0 ]; then
        log_recovery "CACHE" "Cache cleaned successfully"
        return 0
    else
        log_recovery "CACHE" "Failed to clean cache"
        return 1
    fi
}

# 调整带宽限制
adjust_bandwidth_limits() {
    local action=$1
    
    log_recovery "BANDWIDTH" "Starting bandwidth adjustment: $action"
    
    case $action in
        "reduce")
            sed -i 's/limit_rate [0-9]*m/limit_rate 1m/g' /etc/nginx/nginx.conf
            ;;
        "increase")
            sed -i 's/limit_rate [0-9]*m/limit_rate 5m/g' /etc/nginx/nginx.conf
            ;;
        "reset")
            sed -i 's/limit_rate [0-9]*m/limit_rate 2m/g' /etc/nginx/nginx.conf
            ;;
    esac
    
    nginx -t && nginx -s reload
    
    if [ $? -eq 0 ]; then
        log_recovery "BANDWIDTH" "Bandwidth adjustment successful: $action"
        return 0
    else
        log_recovery "BANDWIDTH" "Failed to adjust bandwidth: $action"
        return 1
    fi
}

# 主函数
main() {
    local action=$1
    
    case $action in
        "restart")
            restart_nginx
            ;;
        "clear-cache")
            clear_cache
            ;;
        "reduce-bandwidth")
            adjust_bandwidth_limits "reduce"
            ;;
        "increase-bandwidth")
            adjust_bandwidth_limits "increase"
            ;;
        "reset-bandwidth")
            adjust_bandwidth_limits "reset"
            ;;
        *)
            echo "Usage: $0 {restart|clear-cache|reduce-bandwidth|increase-bandwidth|reset-bandwidth}"
            exit 1
            ;;
    esac
}

# 执行恢复操作
main $1

9.2.2 故障预防

# 故障预防脚本
#!/bin/bash
# /usr/local/bin/fault-prevention.sh

LOG_FILE="/var/log/nginx/fault-prevention.log"

# 预防性检查
preventive_check() {
    local check_type=$1
    
    case $check_type in
        "bandwidth")
            local bandwidth_usage=$(tail -n 1000 /var/log/nginx/bandwidth_monitor.log | \
                awk '{ total += $NF } END { print total / 1024 / 1024 / 1024 }')
            
            if (( $(echo "$bandwidth_usage > 10" | bc -l) )); then
                echo "$(date): High bandwidth usage detected: ${bandwidth_usage}GB" >> $LOG_FILE
                return 1
            fi
            ;;
        "connections")
            local connection_count=$(netstat -an | grep :80 | wc -l)
            
            if [ $connection_count -gt 1000 ]; then
                echo "$(date): High connection count detected: $connection_count" >> $LOG_FILE
                return 1
            fi
            ;;
        "response-time")
            local avg_response_time=$(tail -n 1000 /var/log/nginx/bandwidth_monitor.log | \
                awk '{ total += $4 } END { print total / NR }')
            
            if (( $(echo "$avg_response_time > 2" | bc -l) )); then
                echo "$(date): High response time detected: ${avg_response_time}s" >> $LOG_FILE
                return 1
            fi
            ;;
    esac
    
    return 0
}

# 预防性优化
preventive_optimization() {
    local optimization_type=$1
    
    case $optimization_type in
        "bandwidth")
            # 减少带宽限制
            sed -i 's/limit_rate [0-9]*m/limit_rate 1m/g' /etc/nginx/nginx.conf
            nginx -s reload
            ;;
        "connections")
            # 减少连接数限制
            sed -i 's/limit_conn [0-9]*/limit_conn 50/g' /etc/nginx/nginx.conf
            nginx -s reload
            ;;
        "response-time")
            # 启用压缩
            sed -i '/gzip on;/d' /etc/nginx/nginx.conf
            sed -i '/http {/a\    gzip on;' /etc/nginx/nginx.conf
            nginx -s reload
            ;;
    esac
}

# 主函数
main() {
    # 执行预防性检查
    preventive_check "bandwidth" || preventive_optimization "bandwidth"
    preventive_check "connections" || preventive_optimization "connections"
    preventive_check "response-time" || preventive_optimization "response-time"
}

# 执行预防性检查
main

十、总结与展望

10.1 技术总结

通过本文的深入探讨，我们全面了解了Nginx公网带宽优化的架构设计与实战应用。从基础配置到高级优化，从单机部署到集群架构，Nginx为企业提供了强大的带宽管理和优化能力。

10.1.1 核心价值

成本控制：通过带宽优化降低网络成本
性能提升：提高网络传输效率和用户体验
稳定性保障：避免带宽拥塞和服务中断
可扩展性：支持业务增长和动态调整

10.1.2 技术优势

灵活配置：丰富的配置选项和优化策略
实时监控：全面的监控和告警机制
智能优化：自动化的优化和调整策略
成本效益：显著的成本节约和性能提升

10.2 最佳实践建议

10.2.1 架构设计

分层设计：采用分层、分布式的架构设计
负载均衡：实施智能负载均衡和流量分发
缓存策略：建立多级缓存和智能缓存策略
监控告警：构建完善的监控和告警体系

10.2.2 运维管理

性能监控：实时监控带宽使用和性能指标
成本分析：定期分析成本趋势和优化效果
故障处理：制定详细的故障排查和恢复流程
持续优化：定期评估和优化系统性能

10.3 未来发展趋势

10.3.1 技术发展方向

智能化：AI驱动的带宽优化和预测
边缘计算：边缘环境下的带宽优化
5G网络：5G网络环境下的带宽管理
云原生：容器化和微服务架构的演进

10.3.2 应用场景扩展

IoT设备：物联网设备的带宽优化
视频流媒体：视频传输的带宽优化
实时通信：实时通信的带宽管理
边缘计算：边缘计算节点的带宽优化

10.4 学习建议

10.4.1 技术学习路径

基础掌握：熟悉Nginx配置和网络基础
实践应用：通过实际项目积累经验
高级特性：深入学习高级功能和优化技巧
持续更新：关注技术发展和最佳实践

10.4.2 职业发展建议

技能提升：持续学习相关技术和工具
项目经验：参与大型项目的架构设计
社区参与：积极参与开源社区和技术交流
认证获取：获得相关技术认证和资质

结语

Nginx公网带宽优化作为现代企业网络架构的重要组成部分，为企业提供了强大的带宽管理和优化能力。通过合理的架构设计、完善的配置管理、有效的性能优化和可靠的运维保障，企业可以构建高效、稳定、经济的公网带宽管理解决方案。

在数字化转型的浪潮中，掌握Nginx等网络优化技术已成为技术人员的必备技能。希望本文能够为读者提供全面的技术指导和实践参考，助力企业在网络基础设施的优化中取得更大的成功。

让我们继续探索网络优化的无限可能，用技术的力量推动企业的发展和创新！

关键词：Nginx、公网带宽、流量控制、带宽管理、CDN加速、企业级架构、网络优化、带宽优化、流量管理、高并发

相关技术：负载均衡、缓存优化、压缩传输、连接池、监控告警、成本控制、性能调优、故障排查

适用场景：企业级网络优化、CDN加速、带宽管理、流量控制、成本控制、性能优化、高并发处理、监控告警