Istio服务网格架构深度剖析：控制平面与数据平面的协同设计

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

# istio-init容器执行的关键脚本
/usr/local/bin/istio-iptables.sh \
  -p 15001 \         # Envoy出站流量端口
  -z 15006 \         # Envoy入站流量端口  
  -u 1337 \          # Envoy用户ID
  -m REDIRECT \      # 流量重定向模式
  -i '*' \           # 拦截所有入站接口
  -x "" \            # 排除的CIDR范围
  -b '*' \           # 拦截所有入站端口
  -d 15090,15021,15020  # 排除的出站端口

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18

# === NAT表 PREROUTING链 - 处理入站流量 ===
# 将所有入站TCP流量重定向到15006端口（Envoy入站监听器）
-A PREROUTING -p tcp -j REDIRECT --to-ports 15006

# === NAT表 OUTPUT链 - 处理出站流量 ===
# 排除Envoy进程的出站流量（避免死循环）
-A OUTPUT -m owner --uid-owner 1337 -j RETURN

# 排除回环地址流量
-A OUTPUT -d 127.0.0.0/8 -j RETURN

# 排除Istio控制平面端口
-A OUTPUT -p tcp --dport 15090 -j RETURN  # Envoy admin
-A OUTPUT -p tcp --dport 15021 -j RETURN  # 健康检查
-A OUTPUT -p tcp --dport 15020 -j RETURN  # 合并指标

# 将应用出站流量重定向到15001端口（Envoy出站监听器）
-A OUTPUT -p tcp -j REDIRECT --to-ports 15001

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17

应用发起请求 
    ↓
iptables规则拦截(OUTPUT链)
    ↓  
Envoy出站监听器(0.0.0.0:15001)
    ↓
负载均衡算法选择端点
    ↓
建立到目标Pod的mTLS连接  
    ↓
目标Pod iptables拦截(PREROUTING链)
    ↓
Envoy入站监听器(0.0.0.0:15006)
    ↓
应用安全策略和路由规则
    ↓
转发到目标应用容器

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19

// pilot/pkg/networking/core/v1alpha3/listener.go
func (configgen *ConfigGeneratorImpl) buildSidecarOutboundListeners(
    node *model.Proxy, push *model.PushContext) []*listener.Listener {
    
    var listeners []*listener.Listener
    
    // 创建虚拟出站监听器(0.0.0.0:15001) 
    virtualOutboundListener := &listener.Listener{
        Name: VirtualOutboundListenerName,
        Address: util.BuildAddress("0.0.0.0", uint32(15001)),
        FilterChains: configgen.buildVirtualOutboundFilterChains(node, push),
        ListenerFilters: buildListenerFilters(),  // 包含original_dst过滤器
        UseOriginalDst: proto.BoolTrue,           // 启用原始目标地址检测
        TrafficDirection: core.TrafficDirection_OUTBOUND,
    }
    
    listeners = append(listeners, virtualOutboundListener)
    return listeners
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19

// pilot/pkg/networking/core/v1alpha3/listener.go  
func (configgen *ConfigGeneratorImpl) buildSidecarInboundListeners(
    node *model.Proxy, push *model.PushContext) []*listener.Listener {
    
    var listeners []*listener.Listener
    
    // 创建虚拟入站监听器(0.0.0.0:15006)
    virtualInboundListener := &listener.Listener{
        Name: VirtualInboundListenerName, 
        Address: util.BuildAddress("0.0.0.0", uint32(15006)),
        FilterChains: configgen.buildVirtualInboundFilterChains(node, push),
        ListenerFilters: buildListenerFilters(),
        UseOriginalDst: proto.BoolTrue,
        TrafficDirection: core.TrafficDirection_INBOUND,
    }
    
    listeners = append(listeners, virtualInboundListener)
    return listeners
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

// Envoy过滤器链架构示例
type FilterChain struct {
    // HTTP连接管理器过滤器
    HttpConnectionManager *http_connection_manager.HttpConnectionManager
    
    // 自定义过滤器链
    CustomFilters []HttpFilter
    
    // 路由配置
    RouteConfig *route.RouteConfiguration
}

// 过滤器接口定义
type HttpFilter interface {
    // 处理请求头
    OnRequestHeaders(headers HeaderMap) FilterHeadersStatus
    
    // 处理请求体
    OnRequestData(data Buffer) FilterDataStatus
    
    // 处理响应头
    OnResponseHeaders(headers HeaderMap) FilterHeadersStatus
    
    // 处理响应体
    OnResponseData(data Buffer) FilterDataStatus
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

// Envoy监听器核心实现逻辑（C++伪代码展示概念）
class ListenerManager {
    // 监听器配置映射
    std::map<std::string, ListenerImpl*> listeners_;
    
    // 动态添加监听器
    void addListener(const envoy::config::listener::v3::Listener& config) {
        auto listener = std::make_unique<ListenerImpl>(config);
        listener->initialize();
        listeners_[config.name()] = std::move(listener);
    }
    
    // 热重载监听器配置
    void updateListener(const std::string& name, 
                       const envoy::config::listener::v3::Listener& config) {
        if (auto it = listeners_.find(name); it != listeners_.end()) {
            it->second->drain();                    // 优雅排空现有连接
            auto new_listener = std::make_unique<ListenerImpl>(config);
            new_listener->initialize();
            listeners_[name] = std::move(new_listener);
        }
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

// 集群管理器实现
class ClusterManager {
    // 集群配置缓存
    std::map<std::string, ClusterImpl*> clusters_;
    
    // 健康检查管理器
    HealthCheckerManager health_checker_manager_;
    
    // 负载均衡器工厂
    LoadBalancerFactory lb_factory_;
    
    // 动态更新集群配置
    void updateCluster(const envoy::config::cluster::v3::Cluster& config) {
        auto cluster = clusters_[config.name()];
        
        // 更新端点配置
        cluster->updateEndpoints(config.load_assignment());
        
        // 更新负载均衡策略
        auto lb = lb_factory_.create(config.lb_policy());
        cluster->setLoadBalancer(std::move(lb));
        
        // 更新健康检查配置
        if (config.has_health_checks()) {
            health_checker_manager_.updateHealthChecker(config.name(), config.health_checks());
        }
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38

# 基于生产环境经验的DestinationRule配置
apiVersion: networking.istio.io/v1beta1
kind: DestinationRule
metadata:
  name: productpage-destination
spec:
  host: productpage
  trafficPolicy:
    # 负载均衡策略 - 根据服务特性选择
    loadBalancer:
      simple: LEAST_CONN          # 长连接服务推荐
      # consistentHash:            # 会话保持场景
      #   httpHeaderName: "user-id"
    
    # 连接池配置 - 防止资源耗尽
    connectionPool:
      tcp:
        maxConnections: 100        # 最大连接数
        connectTimeout: 30s        # 连接超时
        keepAlive:
          time: 7200s             # TCP keepalive
          interval: 75s           # keepalive间隔
      http:
        http1MaxPendingRequests: 100   # HTTP/1.1排队请求
        http2MaxRequests: 1000         # HTTP/2并发请求
        maxRequestsPerConnection: 2    # 连接最大请求数
        maxRetries: 3                  # 最大重试次数
        idleTimeout: 60s               # 空闲超时
        h2UpgradePolicy: UPGRADE       # HTTP/2升级策略
    
    # 熔断配置 - 故障隔离
    outlierDetection:
      consecutiveGatewayErrors: 5      # 连续网关错误
      consecutive5xxErrors: 5          # 连续5xx错误
      interval: 30s                    # 检测间隔
      baseEjectionTime: 30s           # 基础驱逐时间
      maxEjectionPercent: 50          # 最大驱逐百分比
      minHealthPercent: 50            # 最小健康百分比

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

# 生产级VirtualService重试配置
apiVersion: networking.istio.io/v1beta1
kind: VirtualService
metadata:
  name: reviews-retry-policy
spec:
  hosts:
  - reviews
  http:
  - match:
    - uri:
        prefix: "/api/"
    route:
    - destination:
        host: reviews
        subset: v1
    # 智能重试配置
    retries:
      attempts: 3                      # 重试次数
      perTryTimeout: 5s               # 单次重试超时
      retryOn: 5xx,gateway-error,connect-failure,refused-stream  # 重试条件
      retryRemoteLocalities: true     # 跨区域重试
    # 超时配置
    timeout: 15s                      # 总体超时
    # 故障注入（仅测试环境）
    fault:
      delay:
        percentage:
          value: 0.001                # 0.1%延迟注入
        fixedDelay: 100ms