使用 Source IP

Kubernetes 集群中运行的应用通过抽象的 Service 查找彼此，相互通信和连接外部世界。本文揭示了发送到不同类型 Services 的数据包源 IP 的内幕，你可以根据需求改变这个行为。

教程目标

  • 通过多种类型的 Services 暴露一个简单应用
  • 理解每种 Service 类型如何处理源 IP NAT
  • 理解保留源 IP 的折中

准备开始

你必须拥有一个 Kubernetes 的集群，同时你的 Kubernetes 集群必须带有 kubectl 命令行工具。如果你还没有集群，你可以通过 Minikube 构建一个你自己的集群，或者你可以使用下面任意一个 Kubernetes 工具构建：

要获知版本信息，请输入 kubectl version.

术语表

本文使用了下列术语：

  • NAT: 网络地址转换
  • Source NAT: 替换数据包的源 IP, 通常为节点的 IP
  • Destination NAT: 替换数据包的目的 IP, 通常为 Pod 的 IP
  • VIP: 一个虚拟 IP, 例如分配给每个 Kubernetes Service 的 IP
  • Kube-proxy: 一个网络守护程序，在每个节点上协调 Service VIP 管理

准备工作

你必须拥有一个正常工作的 Kubernetes 1.5 集群，用来运行本文中的示例。该示例使用一个简单的 nginx webserver 回送它接收到的请求的 HTTP 头中的源 IP 地址。你可以像下面这样创建它：

  1. $ kubectl run source-ip-app --image=k8s.gcr.io/echoserver:1.4
  2. deployment "source-ip-app" created

Type=ClusterIP 类型 Services 的 Source IP

如果你的 kube-proxy 运行在 iptables 模式下，从集群内部发送到 ClusterIP 的包永远不会进行源地址 NAT，这从 Kubernetes 1.2 开始是默认选项。Kube-proxy 通过一个 proxyMode endpoint 暴露它的模式。

  1. $ kubectl get nodes
  2. NAME                           STATUS     AGE     VERSION
  3. kubernetes-minion-group-6jst   Ready      2h      v1.6.0+fff5156
  4. kubernetes-minion-group-cx31   Ready      2h      v1.6.0+fff5156
  5. kubernetes-minion-group-jj1t   Ready      2h      v1.6.0+fff5156
  7. kubernetes-minion-group-6jst $ curl localhost:10249/proxyMode
  8. iptables

你可以通过在 source IP 应用上创建一个服务来测试源 IP 保留。

  1. $ kubectl expose deployment source-ip-app --name=clusterip --port=80 --target-port=8080
  2. service "clusterip" exposed
  4. $ kubectl get svc clusterip
  5. NAME         CLUSTER-IP    EXTERNAL-IP   PORT(S)   AGE
  6. clusterip    10.0.170.92   <none>        80/TCP    51s

从相同集群中的一个 pod 访问这个 ClusterIP：

  1. $ kubectl run busybox -it --image=busybox --restart=Never --rm
  2. Waiting for pod default/busybox to be running, status is Pending, pod ready: false
  3. If you don't see a command prompt, try pressing enter.
  5. # ip addr
  6. 1: lo: <LOOPBACK,UP,LOWER_UP> mtu 65536 qdisc noqueue
  7.     link/loopback 00:00:00:00:00:00 brd 00:00:00:00:00:00
  8.     inet 127.0.0.1/8 scope host lo
  9.        valid_lft forever preferred_lft forever
  10.     inet6 ::1/128 scope host
  11.        valid_lft forever preferred_lft forever
  12. 3: eth0: <BROADCAST,MULTICAST,UP,LOWER_UP> mtu 1460 qdisc noqueue
  13.     link/ether 0a:58:0a:f4:03:08 brd ff:ff:ff:ff:ff:ff
  14.     inet 10.244.3.8/24 scope global eth0
  15.        valid_lft forever preferred_lft forever
  16.     inet6 fe80::188a:84ff:feb0:26a5/64 scope link
  17.        valid_lft forever preferred_lft forever
  19. # wget -qO - 10.0.170.92
  20. CLIENT VALUES:
  21. client_address=10.244.3.8
  22. command=GET
  23. ...

无论客户端 pod 和 服务端 pod 是否在相同的节点上，client_address 始终是客户端 pod 的 IP 地址。

Type=NodePort 类型 Services 的 Source IP

对于 Kubernetes 1.5，发送给类型为 Type=NodePort Services 的数据包默认进行源地址 NAT。你可以创建一个 NodePort Service 来进行测试：

  1. $ kubectl expose deployment source-ip-app --name=nodeport --port=80 --target-port=8080 --type=NodePort
  2. service "nodeport" exposed
  4. $ NODEPORT=$(kubectl get -o jsonpath="{.spec.ports[0].nodePort}" services nodeport)
  5. $ NODES=$(kubectl get nodes -o jsonpath='{ $.items[*].status.addresses[?(@.type=="ExternalIP")].address }')

如果你的集群运行在一个云服务上，你可能需要为上面报告的 nodes:nodeport 开启一条防火墙规则。现在，你可以通过上面分配的节点端口从外部访问这个 Service。

  1. $ for node in $NODES; do curl -s $node:$NODEPORT | grep -i client_address; done
  2. client_address=10.180.1.1
  3. client_address=10.240.0.5
  4. client_address=10.240.0.3

请注意，这些并不是正确的客户端 IP，它们是集群的内部 IP。这是所发生的事情：

  • 客户端发送数据包到 node2:nodePort
  • node2 使用它自己的 IP 地址替换数据包的源 IP 地址（SNAT）
  • node2 使用 pod IP 地址替换数据包的目的 IP 地址
  • 数据包被路由到 node 1，然后交给 endpoint
  • Pod 的回复被路由回 node2
  • Pod 的回复被发送回给客户端

形象的：

  1.           client
  2.              \ ^
  3.               \ \
  4.                v \
  5.    node 1 <--- node 2
  6.     | ^   SNAT
  7.     | |   --->
  8.     v |
  9.  endpoint

为了防止这种情况发生，Kubernetes 提供了一个特性来保留客户端的源 IP 地址(点击此处查看可用特性)。设置 service.spec.externalTrafficPolicy 的值为 Local，请求就只会被代理到本地 endpoints 而不会被转发到其它节点。这样就保留了最初的源 IP 地址。如果没有本地 endpoints，发送到这个节点的数据包将会被丢弃。这样在应用到数据包的任何包处理规则下，你都能依赖这个正确的 source-ip 使数据包通过并到达 endpoint。

设置 service.spec.externalTrafficPolicy 字段如下：

  1. $ kubectl patch svc nodeport -p '{"spec":{"externalTrafficPolicy":"Local"}}'
  2. service "nodeport" patched

现在，重新运行测试：

  1. $ for node in $NODES; do curl --connect-timeout 1 -s $node:$NODEPORT | grep -i client_address; done
  2. client_address=104.132.1.79

请注意，你只从 endpoint pod 运行的那个节点得到了一个回复，这个回复有正确的客户端 IP。

这是发生的事情：

  • 客户端发送数据包到 node2:nodePort，它没有任何 endpoints
  • 数据包被丢弃
  • 客户端发送数据包到 node1:nodePort，它有endpoints
  • node1 使用正确的源 IP 地址将数据包路由到 endpoint

形象的：

  1.         client
  2.        ^ /   \
  3.       / /     \
  4.      / v       X
  5.    node 1     node 2
  6.     ^ |
  7.     | |
  8.     | v
  9.  endpoint

Type=LoadBalancer 类型 Services 的 Source IP

对于 Kubernetes 1.5，发送给类型为 Type=LoadBalancer Services 的数据包默认进行源地址 NAT，这是由于所有处于 Ready 状态的 Kubernetes 节点对于负载均衡的流量都是符合条件的。所以如果数据包到达一个没有 endpoint 的节点，系统将把这个包代理到有 endpoint 的节点，并替换数据包的源 IP 为节点的 IP（如前面章节所述）。

你可以通过在一个 loadbalancer 上暴露这个 source-ip-app 来进行测试。

  1. $ kubectl expose deployment source-ip-app --name=loadbalancer --port=80 --target-port=8080 --type=LoadBalancer
  2. service "loadbalancer" exposed
  4. $ kubectl get svc loadbalancer
  5. NAME           CLUSTER-IP    EXTERNAL-IP       PORT(S)   AGE
  6. loadbalancer   10.0.65.118   104.198.149.140   80/TCP    5m
  8. $ curl 104.198.149.140
  9. CLIENT VALUES:
  10. client_address=10.240.0.5
  11. ...

然而，如果你的集群运行在 Google Kubernetes Engine/GCE 上，设置 service.spec.externalTrafficPolicy 字段值为 Local 可以强制使没有 endpoints 的节点把他们自己从负载均衡流量的可选节点名单中删除。这是通过故意使它们健康检查失败达到的。

形象的：

  1.                       client
  2.                         |
  3.                       lb VIP
  4.                      / ^
  5.                     v /
  6. health check --->   node 1   node 2 <--- health check
  7.         200  <---   ^ |             ---> 500
  8.                     | V
  9.                  endpoint

你可以设置 annotation 来进行测试：

  1. $ kubectl patch svc loadbalancer -p '{"spec":{"externalTrafficPolicy":"Local"}}'

你应该能够立即看到 Kubernetes 分配的 service.spec.healthCheckNodePort 字段：

  1. $ kubectl get svc loadbalancer -o yaml | grep -i healthCheckNodePort
  2.   healthCheckNodePort: 32122

service.spec.healthCheckNodePort 字段指向每个节点在 /healthz 路径上提供的用于健康检查的端口。你可以这样测试：

  1. $ kubectl get pod -o wide -l run=source-ip-app
  2. NAME                            READY     STATUS    RESTARTS   AGE       IP             NODE
  3. source-ip-app-826191075-qehz4   1/1       Running   0          20h       10.180.1.136   kubernetes-minion-group-6jst
  5. kubernetes-minion-group-6jst $ curl localhost:32122/healthz
  6. 1 Service Endpoints found
  8. kubernetes-minion-group-jj1t $ curl localhost:32122/healthz
  9. No Service Endpoints Found

主节点运行的 service 控制器负责分配 cloud loadbalancer。在这样做的同时，它也会分配指向每个节点的 HTTP 健康检查的 port/path。等待大约 10 秒钟之后，没有 endpoints 的两个节点的健康检查会失败，然后 curl 负载均衡器的 ip：

  1. $ curl 104.198.149.140
  2. CLIENT VALUES:
  3. client_address=104.132.1.79
  4. ...

跨平台支持

由于 Kubernetes 1.5 在类型为 Type=LoadBalancer 的 Services 中支持源 IP 保存的特性仅在 cloudproviders 的子集中实现（GCP and Azure）。你的集群运行的 cloudprovider 可能以某些不同的方式满足 loadbalancer 的要求：

  • 使用一个代理终止客户端连接并打开一个到你的 nodes/endpoints 的新连接。在这种情况下，源 IP 地址将永远是云负载均衡器的地址而不是客户端的。

  • 使用一个包转发器，因此从客户端发送到负载均衡器 VIP 的请求在拥有客户端源 IP 地址的节点终止，而不被中间代理。

第一类负载均衡器必须使用一种它和后端之间约定的协议来和真实的客户端 IP 通信，例如 HTTP X-FORWARDED-FOR 头，或者 proxy 协议。第二类负载均衡器可以通过简单的在保存于 Service 的 service.spec.healthCheckNodePort 字段上创建一个 HTTP 健康检查点来使用上面描述的特性。

清理现场

删除服务：

  1. $ kubectl delete svc -l run=source-ip-app

删除 Deployment、ReplicaSet 和 Pod：

  1. $ kubectl delete deployment source-ip-app

接下来