使用TrafficPolicy管理Agent网络访问-容器服务 Kubernetes 版 ACK(ACK)-阿里云帮助中心

TrafficPolicy 用于控制ACK集群中 Agent 类应用的网络访问。TrafficPolicy可以基于优先级实现多级网络策略，支持 CIDR、Service、FQDN 等多种匹配方式，精细管理 Pod 出入方向流量。

工作原理

TrafficPolicy 与 GlobalTrafficPolicy

ACK集群提供两种网络策略资源：

资源类型	作用范围	适用场景
TrafficPolicy	命名空间级别，作用于指定命名空间中具有特定标签的 Pod	为特定应用配置精细化网络规则
GlobalTrafficPolicy	集群级别，作用于全集群中具有指定标签的Pod	实现全集群安全基线，如禁止访问元数据服务

重要

TrafficPolicy 通过在网络命名空间内配置 ACL 规则控制网络访问。当容器具备 NET_ADMIN、SYS_ADMIN、CAP_SETUID、CAP_SETGID、privileged 或 root 等高权限时，存在绕过 ACL 策略的风险。因此，在 Agent Sandbox 场景中，必须为沙箱划分独立安全组，提供网络层的兜底隔离。同时，为实现纵深防御，还需结合 GlobalTrafficPolicy Ingress 规则和安全组入方向规则，阻止沙箱访问非沙箱负载。

策略执行规则

TrafficPolicy 的规则匹配遵循以下原则：

按优先级排序：优先级范围为 1-1000，数值越小优先级越高。高优先级策略先执行。
同优先级内按顺序匹配：同一策略内的规则按定义顺序从上到下依次匹配。
命中即止：匹配到第一条规则后立即终止，不再继续匹配后续规则。
默认拒绝：当 Pod 被任一策略选中后，未被显式允许的流量将被拒绝。

重要

规则顺序直接影响匹配结果。必须将具体的允许或拒绝规则放在最前，兜底规则放在最后。

支持的匹配条件

重要

基于 Service / Workload 等 Selector 的策略需动态解析 Pod IP 并下发至 Agent，相比静态 IP/CIDR 规则存在生效延迟，不适用于对实时性要求严格的场景。

方向	匹配条件	说明
Ingress（入方向）	`cidr`	基于源 IP 网段匹配
	`service`	基于来源 Service 匹配
	`ports`	基于目标端口和协议匹配（L4）
	`workload`	基于目标 Pod 匹配
Egress（出方向）	`cidr`	基于目标 IP 网段匹配
	`service`	基于目标 Service 匹配
	`fqdn`	基于目标域名匹配
	`ports`	基于目标端口和协议匹配（L4）
	`workload`	基于目标 Pod 匹配

说明

Ingress 规则不支持 FQDN 匹配。FQDN 规则约束如下：

动态解析机制：控制器通过实时解析 DNS 记录获取 IP 地址，并同步更新至节点。由于 DNS 记录可能随时变更，FQDN 对应的 IP 地址具有动态性。不支持泛域名。
方向控制限制：若多个不同域名解析至同一 IP 地址，系统将无法基于域名区分流量的允许和拒绝规则，系统只按优先级执行。
最佳实践建议：鉴于上述限制，建议仅在对内部服务进行访问控制时使用 FQDN 规则，以确保策略的准确性和稳定性。

与 Kubernetes NetworkPolicy 的对比

相比原生 Kubernetes NetworkPolicy，TrafficPolicy与GlobalTrafficPolicy具有以下优势：

能力	Kubernetes NetworkPolicy	TrafficPolicy与GlobalTrafficPolicy
优先级控制	不支持	支持 1-1000 多级优先级
显式Deny	不支持	支持
FQDN约束	不支持	支持
支持的集群规模	集群节点数量不超过5000
Agent 快速扩缩容场景	管理复杂度高	专为此场景优化

适用范围

集群版本为1.24或更高。仅支持 IPv4 规则，不支持IPv6规则。
仅适用于虚拟节点上的ACS或ECI Pod。
已安装Poseidon组件，组件版本为v0.7.0或更高，已开启TrafficPolicy功能。
安装组件或查看版本
1. 登录容器服务管理控制台，在左侧导航栏选择集群列表。
2. 在集群列表页面，单击目标集群名称，然后在左侧导航栏，单击组件管理。
3. 在组件管理页面查看Poseidon组件版本，确认已开启TrafficPolicy功能。
L4 端口功能组件版本需要 >= v0.7.3，且ACS Pod 不支持热更新，仅对新建实例生效。
Workload 选择功能组件版本需要 >= v0.7.6，且ACS Pod 不支持热更新，仅对新建实例生效。

配置示例

快速开始

以下示例展示如何为 Agent 应用配置基础网络策略，允许访问 DNS 服务和公网。

步骤一：在Agent Pod中启用TrafficPolicy

将下方示例保存到agent-pod.yaml，然后执行kubectl apply -f agent-pod.yaml部署示例Pod。

Pod 需要配置 spec.tolerations 以调度到ACS虚拟节点。

network.alibabacloud.com/enable-network-policy-agent: "true"：启用网络策略 Agent。
network.alibabacloud.com/network-policy-mode: "traffic-policy"：指定使用 TrafficPolicy 模式。

apiVersion: v1
kind: Pod
metadata:
  name: agent-pod
  annotations:
    network.alibabacloud.com/enable-network-policy-agent: "true"
    network.alibabacloud.com/network-policy-mode: "traffic-policy"
  labels:
    app: agent
    alibabacloud.com/acs: "true"
spec:
  tolerations:
  - key: "virtual-kubelet.io/provider"
    operator: "Equal"
    value: "alibabacloud"
    effect: "NoSchedule"
  containers:
  - name: agent
    image: registry.aliyuncs.com/acs/ubuntu:latest
    command: ["sleep", "infinity"]

步骤二：创建 TrafficPolicy

创建以下 YAML 文件 agent-basic-policy.yaml，允许 Agent 访问 DNS 服务和公网。

apiVersion: network.alibabacloud.com/v1alpha1
kind: TrafficPolicy
metadata:
  name: agent-basic-policy
  namespace: default
spec:
  priority: 100
  selector:
    matchLabels:
      app: agent

  egress:
    rules:
      # 允许访问 DNS 服务
      - action: allow
        to:
          - service:
              namespace: kube-system
              name: kube-dns

      # 允许访问公网
      - action: allow
        to:
          - cidr: 0.0.0.0/0

步骤三：应用并验证

应用策略。

kubectl apply -f agent-basic-policy.yaml

查看策略状态。

kubectl get trafficpolicy -n default

预期输出：

NAME                 PRIORITY   AGE
agent-basic-policy   100        10s

验证网络连通性。

# 进入 Pod
kubectl exec -it agent-pod -n default -- /bin/bash

# 安装网络工具
apt-get update && apt-get install -y curl dnsutils

# 测试公网访问（应成功）
curl -I https://www.aliyun.com

# 测试 DNS 解析（应成功）
nslookup www.aliyun.com

仅允许Pod访问指定服务和域名

以下策略允许 Agent 访问 DNS 服务、指定域名和指定网段，同时禁止访问云产品元数据服务和其他所有地址。

请将 rds-xxx.aliyuncs.com 替换为实际的 RDS 实例域名。

apiVersion: network.alibabacloud.com/v1alpha1
kind: TrafficPolicy
metadata:
  name: agent-egress-policy
  namespace: default
spec:
  priority: 100
  selector:
    matchLabels:
      app: agent

  egress:
    rules:
      # 禁止访问云产品元数据服务
      - action: deny
        to:
          - cidr: 100.100.100.200/32

      # 允许访问指定网段
      - action: allow
        to:
          - cidr: 100.96.0.0/10

      # 允许访问指定域名
      - action: allow
        to:
          - fqdn: rds-xxx.aliyuncs.com

      # 允许访问 DNS 服务
      - action: allow
        to:
          - service:
              namespace: kube-system
              name: kube-dns

      # 兜底规则：禁止访问其他所有地址
      - action: deny
        to:
          - cidr: 0.0.0.0/0

禁止Pod访问私有网络

在允许公网访问的同时，显式禁止访问私有网络网段。

apiVersion: network.alibabacloud.com/v1alpha1
kind: TrafficPolicy
metadata:
  name: agent-internet-only-policy
  namespace: default
spec:
  priority: 100
  selector:
    matchLabels:
      app: agent
      
  egress:
    rules:
      # 允许 DNS
      - action: allow
        to:
          - service:
              namespace: kube-system
              name: kube-dns
  
      # 禁止访问私有网络
      - action: deny
        to:
          - cidr: 10.0.0.0/8
      - action: deny
        to:
          - cidr: 172.16.0.0/12
      - action: deny
        to:
          - cidr: 192.168.0.0/16
  
      # 禁止来自 Gateway 的访问
      - action: deny
        from:
          - service:
              name: sandbox-gateway
              namespace: sandbox-system
  
        - action: deny
        from:
          - service:
              name: sandbox-manager
              namespace: sandbox-system

      # 允许公网
      - action: allow
        to:
          - cidr: 0.0.0.0/0

仅允许指定 Service 访问Pod

以下策略限制 Agent 仅接受来自 Gateway 服务的访问请求。

apiVersion: network.alibabacloud.com/v1alpha1
kind: TrafficPolicy
metadata:
  name: agent-ingress-policy
  namespace: default
spec:
  priority: 100
  selector:
    matchLabels:
      app: agent

  ingress:
    rules:
      # 允许来自 Gateway 的访问
      - action: allow
        from:
          - service:
              name: sandbox-gateway
              namespace: sandbox-system

      # 兜底规则：禁止其他所有来源
      - action: deny
        from:
          - cidr: 0.0.0.0/0

配置 L4 端口与协议过滤

字段	类型	说明
`protocol`	string	协议类型，可选值：`TCP`、`UDP`。留空表示匹配任意协议，端口规则会同时下发到 TCP/UDP。
`port`	integer	端口号；与 `endPort` 配合可表示端口区间。留空表示不限制端口。
`endPort`	integer	端口区间结束端口，需 ≥ `port`。仅指定 `port` 时表示单端口。

使用规则

ports 列表内多个端口为或关系，命中任一即匹配。
同一条规则的 ports 与对端（from/to）为与关系，必须同时满足。
未声明 ports 时，规则仅基于对端匹配，不限制端口（等价于 L3 规则）。

示例：仅放行指定 TCP 端口

以下策略仅允许 Agent 通过 TCP 80 访问目标服务器，其他端口因隐式拒绝而被阻断。

apiVersion: network.alibabacloud.com/v1alpha1
kind: TrafficPolicy
metadata:
  name: agent-l4-tcp-policy
  namespace: default
spec:
  priority: 100
  selector:
    matchLabels:
      app: agent

  egress:
    rules:
      - action: allow
        to:
          - cidr: 10.0.0.10/32
        ports:
          - protocol: TCP
            port: 80

示例：放行 DNS 所需的 UDP/TCP 53

DNS 查询主要走 UDP，部分大响应会回退到 TCP，因此一并放行：

apiVersion: network.alibabacloud.com/v1alpha1
kind: TrafficPolicy
metadata:
  name: agent-dns-l4-policy
  namespace: default
spec:
  priority: 50
  selector:
    matchLabels:
      app: agent

  egress:
    rules:
      - action: allow
        to:
          - service:
              namespace: kube-system
              name: kube-dns
        ports:
          - protocol: UDP
            port: 53
          - protocol: TCP
            port: 53

示例：放行 TCP 端口区间

通过 port + endPort 描述连续端口区间，常见于业务高位端口段。

apiVersion: network.alibabacloud.com/v1alpha1
kind: TrafficPolicy
metadata:
  name: agent-port-range-policy
  namespace: default
spec:
  priority: 100
  selector:
    matchLabels:
      app: agent

  egress:
    rules:
      - action: allow
        to:
          - cidr: 10.0.0.0/8
        ports:
          - protocol: TCP
            port: 8080
            endPort: 8090

示例：仅允许 Ingress 在指定端口被访问

只允许其他 Pod 通过 TCP 80 访问当前 Pod，其余端口的入方向流量被隐式拒绝。

apiVersion: network.alibabacloud.com/v1alpha1
kind: TrafficPolicy
metadata:
  name: agent-ingress-l4-policy
  namespace: default
spec:
  priority: 100
  selector:
    matchLabels:
      app: agent

  ingress:
    rules:
      - action: allow
        from:
          - cidr: 0.0.0.0/0
        ports:
          - protocol: TCP
            port: 80

全集群维度的访问控制

以下全局策略禁止特定网段访问集群内 Pod，同时允许其他所有流量。

apiVersion: network.alibabacloud.com/v1alpha1
kind: GlobalTrafficPolicy
metadata:
  name: global-security-baseline
spec:
  priority: 1000    # 低优先级，作为兜底策略
  selector: {}      # 作用于全集群 Pod

  ingress:
    rules:
      # 禁止 Sandbox 网段访问
      - action: deny
        from:
          - cidr: 10.8.0.0/16

      # 允许其他所有来源
      - action: allow
        from:
          - cidr: 0.0.0.0/0

  egress:
    rules:
      - action: allow
        to:
          - cidr: 0.0.0.0/0

GlobalTrafficPolicy 的 selector 设置为空 {}，表示作用于全集群所有匹配的 Pod。

组合多级安全策略

多个 TrafficPolicy 可以组合使用，通过不同优先级实现分层控制。以下是推荐的优先级分层方案及配置示例。

优先级范围	用途	示例场景
1-49（高优先级）	基础设施服务	DNS、监控、日志收集
50-499（中优先级）	业务服务	数据库、缓存、消息队列
500-1000（低优先级）	兜底策略	全局安全基线、公网访问控制

基础设施服务（高优先级）

apiVersion: network.alibabacloud.com/v1alpha1
kind: TrafficPolicy
metadata:
  name: infra-policy
  namespace: default
spec:
  priority: 10
  selector:
    matchLabels:
      app: agent
  egress:
    rules:
      - action: allow
        to:
          - service:
              namespace: kube-system
              name: kube-dns
      - action: allow
        to:
          - service:
              namespace: monitoring
              name: prometheus

业务服务（中优先级）

apiVersion: network.alibabacloud.com/v1alpha1
kind: TrafficPolicy
metadata:
  name: business-policy
  namespace: default
spec:
  priority: 100
  selector:
    matchLabels:
      app: agent
  egress:
    rules:
      - action: allow
        to:
          - service:
              namespace: default
              name: redis
      - action: allow
        to:
          - service:
              namespace: default
              name: mysql

公网访问控制（低优先级）

apiVersion: network.alibabacloud.com/v1alpha1
kind: TrafficPolicy
metadata:
  name: internet-policy
  namespace: default
spec:
  priority: 500
  selector:
    matchLabels:
      app: agent
  egress:
    rules:
      - action: allow
        to:
          - cidr: 0.0.0.0/0

为OpenClaw配置完整网络策略

以下是 OpenClaw 应用的完整网络隔离策略，同时包含 Ingress 和 Egress 规则。

重要

基于 Service / Workload 等 Selector 的策略需动态解析 Pod IP 并下发至 Agent，相比静态 IP/CIDR 规则存在生效延迟，不适用于对实时性要求严格的场景。

apiVersion: network.alibabacloud.com/v1alpha1
kind: TrafficPolicy
metadata:
  name: openclaw-policy
  namespace: default
spec:
  priority: 100
  selector:
    matchLabels:
      app: openclaw

  ingress:
    rules:
      # 允许来自管控组件交换机的访问
      - action: allow
        from:
          - cidr: 172.16.10.0/24
      # 允许来自 Gateway 和 Sandbox Manager 的访问 (如果部署网段同上面管控组件交换机，可以省略)
      - action: allow
        from:
          - service:
              name: sandbox-gateway
              namespace: sandbox-system
          - service:
              name: sandbox-manager
              namespace: sandbox-system
          - service:
              name: sandbox-controller-manager-webhook-service
              namespace: sandbox-system
      # 禁止其他所有来源
      - action: deny
        from:
          - cidr: 0.0.0.0/0

  egress:
    rules:
      # 禁止访问云产品元数据服务
      - action: deny
        to:
          - cidr: 100.100.100.200/32

      # 允许 DNS 服务
      - action: allow
        to:
          - service:
              namespace: kube-system
              name: kube-dns

      # 允许访问 LLM 代理服务
      - action: allow
        to:
          - service:
              namespace: llm-proxy
              name: llm-proxy

      # 禁止访问私有网络
      - action: deny
        to:
          - cidr: 10.0.0.0/8
          - cidr: 172.16.0.0/12
          - cidr: 192.168.0.0/16

    # 禁止Sandbox Manager
    - action: deny
      to:
        - service:
            name: sandbox-gateway
            namespace: sandbox-system
        - service:
            name: sandbox-manager
            namespace: sandbox-system

      # 允许访问公网
      - action: allow
        to:
          - cidr: 0.0.0.0/0

最佳实践

遵循最小权限原则

只授予 Pod 必要的网络访问权限。显式列出允许访问的服务和地址，默认拒绝其余流量。

egress:
  rules:
    # 明确允许的服务
    - action: allow
      to:
        - service:
            namespace: kube-system
            name: kube-dns
    - action: allow
      to:
        - fqdn: api.aliyun.com

    # 禁止私有网络
    - action: deny
      to:
        - cidr: 10.0.0.0/8
        - cidr: 172.16.0.0/12
        - cidr: 192.168.0.0/16

    # 禁止Sandbox Manager
    - action: deny
      to:
        - service:
            name: sandbox-gateway
            namespace: sandbox-system
        - service:
            name: sandbox-manager
            namespace: sandbox-system

    # 按需允许公网
    - action: allow
      to:
        - cidr: 0.0.0.0/0

ingress:
  rules:
      # 允许来自 Gateway 和 Sandbox Manager 的访问 (如果部署网段同上面管控组件交换机，可以省略)
      - action: allow
        from:
          - service:
              name: sandbox-gateway
              namespace: sandbox-system
          - service:
              name: sandbox-manager
              namespace: sandbox-system
          - service:
              name: sandbox-controller-manager-webhook-service
              namespace: sandbox-system

设计精确的标签选择器

使用多维度标签精确匹配目标 Pod，避免策略误伤。

# 推荐：多维度标签
selector:
  matchLabels:
    app: agent
    environment: production
    team: ai-platform

# 避免：过于宽泛的标签
selector:
  matchLabels:
    app: agent

标签设计建议：

app：标识应用类型
environment：区分环境（production、staging、development）
team：标识所属团队

结合 GlobalTrafficPolicy 使用

将 GlobalTrafficPolicy 作为全集群安全基线，TrafficPolicy 实现应用级精细控制：

策略层	类型	优先级	职责
应用层	TrafficPolicy	50-200	特定应用的精细网络规则
全局层	GlobalTrafficPolicy	1000	集群安全基线（如禁止 Sandbox 网段）

定期审计策略

建立定期的策略审计机制：

检查 TrafficPolicy 是否符合最新安全要求
审查被拒绝的连接日志，发现潜在问题
清理不再使用的策略
根据业务变化调整策略
验证优先级设置是否合理

审计脚本示例：

#!/bin/bash

echo "=== 所有 TrafficPolicy ==="
kubectl get trafficpolicy --all-namespaces -o wide

echo -e "\n=== 所有 GlobalTrafficPolicy ==="
kubectl get globaltrafficpolicy -o wide

echo -e "\n=== Agent Pod 列表 ==="
kubectl get pods -l app=agent --all-namespaces

使用版本控制管理策略

将 TrafficPolicy 配置纳入 Git 管理，按用途组织目录。

traffic-policies/
├── base/                          # 基础策略
│   ├── global-security-baseline.yaml
│   └── dns-access.yaml
├── applications/                  # 应用策略
│   ├── openclaw-policy.yaml
│   └── agent-policy.yaml
└── environments/                  # 环境差异
    ├── production/
    │   └── overrides.yaml
    └── staging/
        └── overrides.yaml

常见问题

策略不生效

现象：TrafficPolicy 已创建，但网络访问未被限制。

排查步骤：

检查 Poseidon 组件状态：确认已安装、组件版本为v0.7.0或更高、且开启了 TrafficPolicy 功能。
检查 Pod Annotations：确认 Pod 已配置必需的 Annotations。
检查 Pod 标签：确认 Pod 标签与策略的 selector.matchLabels 完全匹配。
```
kubectl get pod <pod-name> --show-labels
```
检查规则顺序：确认具体规则在前，兜底规则在后。
```
kubectl get trafficpolicy <policy-name> -o yaml
```

策略冲突

现象：多个策略作用于同一 Pod，网络行为不符合预期。

排查步骤：

列出所有策略及其优先级：

kubectl get trafficpolicy,globaltrafficpolicy -A -o wide

检查是否有相同优先级的策略作用于同一 Pod。
调整优先级数值，确保高优先级策略使用更小的数值。
合并冲突的策略以避免重复定义。

网络连接超时

现象：Pod 无法访问预期的地址或服务。

排查步骤：

确认是否有策略遗漏了必要的允许规则（如 DNS 服务）。
检查兜底规则是否过于严格，阻止了必要的网络访问。

在策略中添加必要的允许规则：

egress:
  rules:
    - action: allow
      to:
        - service:
            namespace: <namespace>
            name: <service-name>

确保允许规则的优先级高于拒绝规则，或在同一策略中将允许规则放在拒绝规则之前。

Pod 无法被访问

现象：其他服务无法访问目标 Pod。

排查步骤：

检查 Ingress 规则是否允许了必要的来源服务。

添加来源服务的允许规则：

ingress:
  rules:
    - action: allow
      from:
        - service:
            name: <source-service>
            namespace: <source-namespace>

TrafficPolicy API 参考

资源概览

属性	值
API Group	`network.alibabacloud.com`
API Version	`v1alpha1`
资源类型	`TrafficPolicy`（命名空间级）/ `GlobalTrafficPolicy`（集群级）
简称	`tp` / `gtp`
最低组件版本	v0.7.0

TrafficPolicy 和 GlobalTrafficPolicy 共享相同的 Spec 结构，区别仅在于作用范围：

资源	作用范围	简称	典型场景
TrafficPolicy	命名空间级，仅选择同一命名空间内的 Pod	`tp`	应用级精细化网络规则
GlobalTrafficPolicy	集群级，选择全集群所有命名空间的 Pod	`gtp`	全集群安全基线

版本要求速查

功能	最低版本	说明
TrafficPolicy / GlobalTrafficPolicy	v0.7.0	基本功能：CIDR、Service、FQDN peer，allow/deny action
L4 端口过滤（`ports` 字段）	v0.7.3	支持 protocol、port、endPort
Workload 选择器（`workload` peer）	v0.7.6	按 namespace + label selector 匹配 Pod
Reject 动作（`action: reject`）	v0.8.0	返回 TCP RST 或 ICMP port unreachable

CRD 参考

TrafficPolicy 字段说明

apiVersion: network.alibabacloud.com/v1alpha1
kind: TrafficPolicy
metadata:
  name: <policy-name>              # 策略名称，同一命名空间内唯一
  namespace: <namespace>           # 策略所在命名空间
spec:
  priority: <1-1000>               # 优先级，默认 1000，数值越小优先级越高
  selector:                        # Pod 选择器，决定哪些 Pod 生效
    matchLabels:
      <label-key>: <label-value>
    matchExpressions:              # 可选，支持更复杂的选择逻辑
      - key: <label-key>
        operator: In|NotIn|Exists|DoesNotExist
        values: [<value1>, <value2>]

  ingress:                         # 入方向规则（可选）
    rules:
      - action: allow|deny|reject         # 匹配后执行的动作
        from:                      # 来源匹配条件，多个为或关系
          - cidr: <cidr>           # 源 IP 网段（如 10.0.0.0/8）
          - service:               # 来源 Service
              name: <name>
              namespace: <namespace>   # 可选，省略时与策略同命名空间
          - workload:              # 来源 Workload（按标签选择 Pod）
              namespace: <namespace>
              selector:
                <label-key>: <label-value>
        ports:                     # 端口过滤（可选），与 from 为与关系
          - protocol: TCP|UDP  # 可选，留空匹配 TCP+UDP
            port: <1-65535>        # 可选，留空不限制端口
            endPort: <1-65535>     # 可选，与 port 组合表示端口区间

  egress:                          # 出方向规则（可选）
    rules:
      - action: allow|deny         # 匹配后执行的动作
        to:                        # 目标匹配条件，多个为或关系
          - cidr: <cidr>           # 目标 IP 网段
          - service:               # 目标 Service
              name: <name>
              namespace: <namespace>   # 可选，省略时与策略同命名空间
          - fqdn: <domain>         # 目标域名（仅 Egress 支持，不支持泛域名）
          - workload:              # 目标 Workload（按标签选择 Pod）
              namespace: <namespace>
              selector:
                <label-key>: <label-value>
        ports:                     # 端口过滤（可选），与 to 为与关系

GlobalTrafficPolicy 字段说明

apiVersion: network.alibabacloud.com/v1alpha1
kind: GlobalTrafficPolicy
metadata:
  name: <policy-name>              # 策略名称，集群内唯一
spec:
  priority: <1-1000>               # 优先级，默认 1000，数值越小优先级越高
  selector:                        # Pod 选择器（空 {} 表示匹配全集群所有 Pod）
    matchLabels:
      <label-key>: <label-value>

  ingress:                         # 入方向规则（可选），结构同 TrafficPolicy
    rules:
      - action: allow|deny|reject
        from:
          - cidr: <cidr>
          - service:
              name: <name>
              namespace: <namespace>
          - workload:
              namespace: <namespace>
              selector:
                <label-key>: <label-value>
        ports:
          - protocol: TCP|UDP
            port: <1-65535>
            endPort: <1-65535>

  egress:                          # 出方向规则（可选），结构同 TrafficPolicy
    rules:
      - action: allow|deny|reject
        to:
          - cidr: <cidr>
          - service:
              name: <name>
              namespace: <namespace>
          - fqdn: <domain>
          - workload:
              namespace: <namespace>
              selector:
                <label-key>: <label-value>
        ports:
          - protocol: TCP|UDP
            port: <1-65535>
            endPort: <1-65535>

匹配条件参考

Ingress 规则

字段	类型	说明	示例
`cidr`	string	源 IP 网段	`10.0.0.0/8`
`service`	object	来源 Service（包含 `name` 和 `namespace`）	`{"name": "gateway", "namespace": "default"}`
`namespace`	string	来源命名空间	`kube-system`

Egress 规则

字段	类型	说明	示例
`cidr`	string	目标 IP 网段	`192.168.0.0/16`
`service`	object	目标 Service（包含 `name` 和 `namespace`）	`{"name": "redis", "namespace": "default"}`
`fqdn`	string	目标域名	`api.aliyun.com`

Go Type 参考

TrafficPolicy/GlobalTrafficPolicy

package v1alpha1

import (
	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
	"k8s.io/apimachinery/pkg/runtime/schema"
)

type EgressRuleType string

const (
	EgressRuleTypeCIDR     EgressRuleType = "cidr"
	EgressRuleTypeService  EgressRuleType = "service"
	EgressRuleTypeFQDN     EgressRuleType = "fqdn"
	EgressRuleTypeWorkload EgressRuleType = "workload"
)

type EgressRuleAction string

const (
	EgressRuleActionAllow EgressRuleAction = "allow"
	EgressRuleActionDeny  EgressRuleAction = "deny"
	EgressRuleActionReject EgressRuleAction = "reject"
)

type TrafficPolicyServiceRef struct {
	Name string `json:"name"`
	// +optional
	Namespace string `json:"namespace,omitempty"`
}

// TrafficPolicyWorkloadRef selects pods by namespace and label selector.
// The IP addresses of all matching pods are collected into the IPSet.
type TrafficPolicyWorkloadRef struct {
	// Namespace of the target pods.
	Namespace string `json:"namespace"`
	// Selector is a label selector that matches the target pods.
	Selector map[string]string `json:"selector"`
}

type TrafficPolicyPeer struct {
	// +optional
	CIDR string `json:"cidr,omitempty"`
	// +optional
	FQDN string `json:"fqdn,omitempty"`
	// +optional
	Service *TrafficPolicyServiceRef `json:"service,omitempty"`
	// +optional
	Workload *TrafficPolicyWorkloadRef `json:"workload,omitempty"`
}

// TrafficPolicyPort restricts a rule to specific protocol/port combinations.
// If Protocol is empty, matches any protocol:
// with Port nil, there is no L4 match (same as IP-only for that port entry).
// If Protocol is non-empty and Port is nil, matches all ports of that protocol.
type TrafficPolicyPort struct {
	// +optional
	// +kubebuilder:validation:Enum=TCP;UDP
	Protocol string `json:"protocol,omitempty"`
	// +optional
	// +kubebuilder:validation:Minimum=1
	// +kubebuilder:validation:Maximum=65535
	Port *int32 `json:"port,omitempty"`
	// +optional
	// +kubebuilder:validation:Minimum=1
	// +kubebuilder:validation:Maximum=65535
	EndPort *int32 `json:"endPort,omitempty"`
}

type TrafficPolicyRule struct {
	// +kubebuilder:validation:Enum=allow;deny
	Action EgressRuleAction `json:"action"`
	// +optional
	From []TrafficPolicyPeer `json:"from,omitempty"`
	// +optional
	To []TrafficPolicyPeer `json:"to,omitempty"`
	// +optional
	Ports []TrafficPolicyPort `json:"ports,omitempty"`
}

type TrafficPolicyDirection struct {
	// +optional
	Rules []TrafficPolicyRule `json:"rules,omitempty"`
}

// TrafficPolicySpec defines bidirectional policy state on selected pods.
type TrafficPolicySpec struct {
	// +optional
	// +kubebuilder:default:=1000
	// +kubebuilder:validation:Minimum=0
	Priority int32 `json:"priority,omitempty"`

	Selector metav1.LabelSelector `json:"selector"`

	// +optional
	Ingress *TrafficPolicyDirection `json:"ingress,omitempty"`
	// +optional
	Egress *TrafficPolicyDirection `json:"egress,omitempty"`
}

// IPSetBinding records one SelectorIPSet referenced by a rule in this policy,
// along with the direction, action, rule index, and optional port restrictions.
type IPSetBinding struct {
	// Name of the SelectorIPSet object (e.g. "ipset-a1b2c3d4e5f6").
	IPSetName string `json:"ipsetName"`
	// Content hash (same as SelectorIPSet.Spec.IPSetID).
	IPSetID string `json:"ipsetID"`
	// "egress" or "ingress"
	Direction string `json:"direction"`
	// "allow" or "deny"
	Action EgressRuleAction `json:"action"`
	// Index of the rule within spec.egress.rules or spec.ingress.rules.
	RuleIndex int32 `json:"ruleIndex"`
	// +optional
	Ports []TrafficPolicyPort `json:"ports,omitempty"`
}

// TrafficPolicyStatus defines the observed state of TrafficPolicy.
type TrafficPolicyStatus struct {
	// IPSetBindings lists all SelectorIPSet objects referenced by this policy's rules.
	// +optional
	IPSetBindings []IPSetBinding `json:"ipsetBindings,omitempty"`
	// +optional
	Conditions []metav1.Condition `json:"conditions,omitempty"`
}

// +kubebuilder:object:root=true
// +kubebuilder:subresource:status
// +kubebuilder:resource:scope=Namespaced,shortName=ep

// TrafficPolicy defines bidirectional traffic rules for selected pods.
type TrafficPolicy struct {
	metav1.TypeMeta `json:",inline"`
	// +optional
	metav1.ObjectMeta `json:"metadata,omitempty"`

	// +optional
	Spec TrafficPolicySpec `json:"spec,omitempty"`
	// +optional
	Status TrafficPolicyStatus `json:"status,omitempty"`
}

// +kubebuilder:object:root=true

// TrafficPolicyList contains a list of TrafficPolicy.
type TrafficPolicyList struct {
	metav1.TypeMeta `json:",inline"`
	// +optional
	metav1.ListMeta `json:"metadata,omitempty"`
	Items           []TrafficPolicy `json:"items"`
}

// +kubebuilder:object:root=true
// +kubebuilder:subresource:status
// +kubebuilder:resource:scope=Cluster,shortName=gtp
//
// GlobalTrafficPolicy defines bidirectional traffic rules cluster-wide.
type GlobalTrafficPolicy struct {
	metav1.TypeMeta `json:",inline"`
	// +optional
	metav1.ObjectMeta `json:"metadata,omitempty"`

	// +optional
	Spec TrafficPolicySpec `json:"spec,omitempty"`
	// +optional
	Status TrafficPolicyStatus `json:"status,omitempty"`
}

// +kubebuilder:object:root=true
//
// GlobalTrafficPolicyList contains a list of GlobalTrafficPolicy.
type GlobalTrafficPolicyList struct {
	metav1.TypeMeta `json:",inline"`
	// +optional
	metav1.ListMeta `json:"metadata,omitempty"`
	Items           []GlobalTrafficPolicy `json:"items"`
}

var (
	// GroupVersion is group version used to register these objects.
	GroupVersion = schema.GroupVersion{Group: "network.alibabacloud.com", Version: "v1alpha1"}
)