k8s 中的 Service 简介【k8s 系列之二】

〇、前言

k8s 集群中的每一个 Pod 都有自己的 IP 地址，那么是不是有 IP 了，访问起来就简单了呢，其实不然。

因为在 k8s 中 Pod 不是持久性的，摧毁重建将获得新的 IP，客户端通过会变更 IP 来访问显然不合理。另外 Pod 还经常会通过多个副本来实现负载均衡，客户端如何高效的访问哪个副本的问题也显现出来了。

那么本文将要介绍的 Service 对象应运而生。

一、Service 的工作原理

1.1 Service 简介

如下关系图：

当通过 API 创建/修改 Service 对象时，EndpointsController 的 Informer 机制 Listen 到 Service 对象，然后根据 Service 的配置的选择器创建一个 Endpoints 对象，此对象将 Pod 的 IP、容器端口做记录并存储到 etcd，这样 Service 只要看一下自己名下的 Endpoints 就可以知道所对应 Pod 信息了。

当 Pod 发生变更（如新的 Pod 被调度、现有 Pod 的状态变为非 Running 或者 Pod 数量伸缩）时，API Server 会将这些变化以事件的形式通知给 EndpointsController。EndpointsController 随即根据最新的 Pod 状态和 Service 的 Label Selector 重新计算 Endpoints 对象的端点列表，并更新存储在 etcd 中的 Endpoints 资源对象。这样，Service 所关联的 Endpoints  就会动态地反映出当前所有符合 Selector 的 Running 状态 Pod 的 IP 地址和端口信息。

针对 EndpointsController：是负责生成和维护所有 Endpoints 对象的控制器，监听 Service 和对应 Pod 的变化，更新对应 Service 的 Endpoints 对象。当用户创建 Service 后 EndpointsController 会监听 Pod 的状态，当 Pod 处于 Running 且准备就绪时，EndpointsController 会将 Pod IP 记录到 Endpoints 对象中，因此，Service 的容器发现是通过 Endpoints 来实现的。而 kube-proxy 会监听 Service 和 Endpoints 的更新，并调用其代理模块在主机上刷新路由转发规则。

另外，k8s 中的 Informer 是一个核心组件，专门用于监控 API 资源的变化，并在资源发生变化时通知相关的客户端。

 

1.2 配置文件示例

先创建一个 Deployment 部署，用来配置和管理 Pod：

#deployment.yml
apiVersion: apps/v1
# 指定要创建的资源类型为 Deployment
kind: Deployment
# 配置资源的元数据信息，例如：资源的名称（name）
metadata:
  name: deployment-demo
# spec 规约，是必需的
# 用于描述对象的期望状态 Desired State，以及基本信息
spec:
  selector: # 指定如何识别Pod模板创建的Pod实例
    matchLabels: # 选择器将匹配所有带有标签 app: nginx 的 Pod
      app: nginx
  replicas: 3 # 指定需要维持的 Pod 副本数量为 3
  # 定义 Pod 模板，用于创建新的 Pod 实例
  template:
    metadata: # 配置 Pod 板的元数据信息，如标签（labels）
      labels:
        app: nginx
    # 定义 Pod 期望状态和基本信息
    spec:
      containers: # 列出 Pod 中运行的容器信息，名称、镜像、端口
      - name: nginx
        image: mirrorgooglecontainers/serve_hostname
        ports:
        - containerPort: 9376
          protocol: TCP # 指定端口协议为 TCP

其中，serve_hostname 是 k8s 官方提供的 debug 镜像，一个返回 hostname 的 web server。这样我们创建出了标签为【app: nginx】的三个 Pod，当我们访问 Pod 的 9376 时会返回 hostname。

接着是 Service 清单，在 Service 中指定了选择器为【app: nginx】，配置如下：

#service.yaml
apiVersion: v1
kind: Service
# 配置资源的元数据信息，例如资源的名称（name）
metadata:
  name: service-demo
spec:
  selector: # 通过指定的标签内容识别后端 Pod
    app: nginx
  # 定义 Service 暴露的端口
  ports:
  - name: default # 给端口命名，方便后续引用
    protocol: TCP
    # Service Port 对外
    port: 80 # 指定 Service 暴露的端口号为 80
    # Container Port 对内
    targetPort: 9376 # 指定 Service 转发流量到后端 Pod 的目标端口号为 9376

这样就获得不变的 CLUSTER-IP 10.96.148.206 的 Service：

如果 Pod 启动成功，则自动创建和 Service 同名的 Endpoints 记录下了三个 Pod 的数据：

Service 中选择器未指定标签时，Endpoints 需要手动创建映射到 Service 的网络地址，如下：

apiVersion: v1
kind: Endpoints
metadata:
  name: endpoints-demo
# 定义 Endpoints 的子集，每个子集对应一个后端服务实例
subsets:
  - addresses: # 列出后端服务实例的 IP 地址列表
      - ip: 10.96.148.206
    ports: # 定义后端服务实例监听的端口列表
      - port: 9376

此时当我们不断访问 Service 的 CLUSTER-IP 时：

# curl 10.96.148.206:80
deployment-demo-7d94cbb55f-8mmxb
# curl 10.96.148.206:80
deployment-demo-7d94cbb55f-674ns
# curl 10.96.148.206:80
deployment-demo-7d94cbb55f-lfrm8
# curl 10.96.148.206:80
deployment-demo-7d94cbb55f-8mmxb

可以看到此时请求已被路由到后端 Pod ，返回 hostname，并且负载均衡方式是 Round Robin 即轮询模式。

二、Service 的负载均衡

上文已经提到 Service 实际的路由转发都是由 kube-proxy 组件来实现的，service 仅以一种 VIP（ClusterIP） 的形式存在，kube-proxy 主要实现了集群内部从 Pod 到 Service 和集群外部从 nodePort 到 Service 的访问，kube-proxy 的路由转发规则是通过其后端的代理模块实现的。

kube-proxy 的代理模块目前有四种实现方案，userspace（不常用）、iptables（默认）、ipvs（使用于大规模集群）、kernelspace（适用于 Windows 环境），其发展历程如下所示：

kubernetes v1.0：services 仅是一个“4层”代理，代理模块只有 userspace
kubernetes v1.1：Ingress API 出现，其代理“7层”服务，并且增加了 iptables 代理模块
kubernetes v1.2：iptables 成为默认代理模式
kubernetes v1.8：引入 ipvs 代理模块
kubernetes v1.9：ipvs 代理模块成为 beta 版本
kubernetes v1.11：ipvs 代理模式 GA

在每种模式下都有自己的负载均衡策略，下文会详解介绍。

userspace 模式，不常用

在 userspace 模式下，访问服务的请求到达节点后，首先进入内核 iptables，然后回到用户空间，由 kube-proxy 转发到后端的 Pod ，这样流量从用户空间进出内核带来的性能损耗是不可接受的，所以也就有了 iptables 模式。

为什么 userspace 模式要建立 iptables 规则？因为 kube-proxy 监听的端口在用户空间，这个端口不是服务的访问端口也不是服务的 nodePort，因此需要一层 iptables 把访问服务的连接重定向给 kube-proxy 服务。

iptables 模式，默认方式

iptables 模式是目前默认的代理方式，基于 netfilter 实现。当客户端请求 Service 的 ClusterIP 时，根据 iptables 规则路由到各 Pod 上，iptables 使用 DNAT 来完成转发，其采用了随机数实现负载均衡。

Netfilter 是 Linux 内核中的一个框架，用于在网络层处理数据包。它提供了一种机制，允许用户空间程序通过一系列的钩子（hooks）来监控和修改网络流量。这些钩子可以插入到数据包的生命周期的各个阶段，例如在进入、离开或经过网络堆栈时。

DNAT（Destination Network Address Translation）模块：是一种网络功能，用于将到达集群内部服务的流量重定向到正确的目标IP地址和端口。DNAT通常与负载均衡器一起使用，以便在多个后端服务之间分发流量。

iptables 模式与 userspace 模式最大的区别在于，iptables 模块使用 DNAT 模块实现了 Service 入口地址到 Pod 实际地址的转换，免去了一次内核态到用户态的切换；另一个与 userspace 代理模式不同的是，如果 iptables 代理最初选择的那个 Pod 没有响应，它不会自动重试其他 Pod 。

iptables 模式最主要的问题是在 Service 数量大的时候会产生太多的 iptables 规则，使用非增量式更新会引入一定的时延，大规模情况下有明显的性能问题。

ipvs 模式，适用于大规模集群

当集群规模比较大时，iptables 规则刷新会非常慢，难以支持大规模集群，因其底层路由表的实现是链表，对路由规则的增删改查都要涉及遍历一次链表，ipvs 的问世正是解决此问题的。

ipvs 是 LVS 的负载均衡模块，与 iptables 比较像的是，ipvs 的实现虽然也基于 netfilter 的钩子函数，但是它却使用哈希表作为底层的数据结构并且工作在内核态，也就是说 ipvs 在重定向流量和同步代理规则有着更好的性能，几乎允许无限的规模扩张。

ipvs 支持三种负载均衡模式：DR 模式（Direct Routing）、NAT 模式（Network Address Translation）、Tunneling（也称 ipip 模式）。三种模式中只有 NAT 支持端口映射，所以 ipvs 使用 NAT 模式。

linux 内核原生的 ipvs 只支持 DNAT，当在数据包过滤，SNAT 和支持 NodePort 类型的服务这几个场景中 ipvs 还是会使用 iptables。

此外，ipvs 也支持更多的负载均衡算法，例如：

rr：round-robin/轮询
lc：least connection/最少连接
dh：destination hashing/目标哈希
sh：source hashing/源哈希
sed：shortest expected delay/预计延迟时间最短
nq：never queue/从不排队

userspace、iptables、ipvs 三种模式中，默认的策略都是 round-robin。

在 Service 中可以通过设置 Service .spec.sessionAffinity 的值实现基于客户端 ip 的会话亲和性，其默认值为"None"，可以设置为 "ClientIP"。此外也可以使用 Service .spec.sessionAffinityConfig.clientIP.timeoutSeconds 设置会话保持时间。

另外，kernelspace 模式 主要是在 windows 下使用的，本文略过。

三、Service 的类型

service 支持的类型也就是 k8s 中服务暴露的方式，默认有四种 ClusterIP、NodePort、LoadBalancer、ExternelName，此外还有 Ingress，下面会详细介绍每种类型 Service 的具体使用场景。

3.1 ClusterIP，默认方式，集群内访问

ClusterIP 类型的 Service 是 kubernetes 集群默认的服务暴露方式，它只能用于集群内部通信，可以被各 Pod 访问，其访问方式为：

pod ---> ClusterIP:ServicePort --> (iptables)DNAT --> PodIP:containePort

配置示例：

apiVersion: v1
kind: Service
metadata:
  name: service-python
spec:
  ports:
  - port: 3000
    protocol: TCP
    targetPort: 443
  selector:
    run: pod-python
  type: ClusterIP # 指定 Service 类型

使用命令 kuebctl get svc :

类型为 ClusterIP 的 Service 有一个 Cluster-IP，其实就一个 VIP。具体实现原理依靠 kube-proxy 组件，通过 iptables 或是 ipvs 实现。

在创建 Service 的请求中，你可以通过设置 spec.clusterIP 字段来指定自己的集群 IP 地址。 比如，希望复用一个已存在的 DNS 条目，或者遗留系统已经配置了一个固定的 IP 且很难重新配置。如果在 Service 中将 .spec.clusterIP 设置为 "None"，则 Kubernetes 不会为其分配 IP 地址。

所配置的 IP 地址必须是合法的 IPv4 或者 IPv6 地址，并且这个 IP 地址在 API 服务器上所配置的 service-cluster-ip-range CIDR 范围内。配置了非法 clusterIP 地址的 Service，API 服务器会返回 HTTP 状态码 422，表示值不合法。

 

3.2 NodePort 集群外访问

若要在集群外访问集群内部的服务，可以使用这种类型的 Service 。

NodePort 类型的 Service 会在集群内部署了 kube-proxy 的节点，打开一个指定的端口，之后所有的流量直接发送到这个端口，然后会被转发到 Service 后端真实的服务进行访问。

Nodeport 构建在 ClusterIP 上，其访问链路如下所示：

client ---> NodeIP:NodePort ---> ClusterIP:ServicePort ---> (iptables)DNAT ---> PodIP:containePort

配置示例：

apiVersion: v1
kind: Service
metadata:
  name: service-python
spec:
  ports:
  - port: 3000
    protocol: TCP
    targetPort: 443
    nodePort: 30080
  selector:
    run: pod-python
  type: NodePort

使用命令 kuebctl get svc :

此时我们可以通过 http://4.4.4.1:30080 或 http://4.4.4.2:30080，对 Pod -python 访问。

该端口有一定的范围，比如默认 k8s 控制平面将在 --service-node-port-range 标志指定的范围内分配端口（默认值：30000-32767）。

为 NodePort 服务分配端口的策略既适用于自动分配的情况，也适用于手动分配的场景。当某个用于希望创建一个使用特定端口的 NodePort 服务时，该目标端口可能与另一个已经被分配的端口冲突。为了避免这个问题，用于 NodePort 服务的端口范围被分为两段。动态端口分配默认使用较高的端口段，并且在较高的端口段耗尽时也可以使用较低的端口段。用户可以从较低端口段中分配端口，降低端口冲突的风险。

 

3.3 LoadBalancer 负载均衡

LoadBalancer 类型的 Service 是可以实现集群外部访问服务的另外一种解决方案。不过并不是所有的 k8s 集群都会支持，大多是在公有云托管集群中会支持该类型。

负载均衡器是异步创建的，关于被提供的负载均衡器的信息将会通过 Service 的 status.loadBalancer 字段被发布出去。

LoadBalancer 配置示例：

apiVersion: v1
kind: Service
metadata:
  name: service-python
spec:
  ports:
  - port: 3000
    protocol: TCP
    targetPort: 443
    nodePort: 30080
  selector:
    run: pod-python
  type: LoadBalancer

使用命令 kuebctl get svc :

可以看到 external-ip，然后就可以通过该 ip 来访问了。

当然各家公有云支持诸多的其他设置。大多是公有云负载均衡器的设置参数，都可以通过 svc 的注解来设置，例如下面的 aws：

    metadata:
      name: my-service
      annotations:
        service.beta.kubernetes.io/aws-load-balancer-access-log-enabled: "true"
        # Specifies whether access logs are enabled for the load balancer
        service.beta.kubernetes.io/aws-load-balancer-access-log-emit-interval: "60"
        # The interval for publishing the access logs. You can specify an interval of either 5 or 60 (minutes).
        service.beta.kubernetes.io/aws-load-balancer-access-log-s3-bucket-name: "my-bucket"
        # The name of the Amazon S3 bucket where the access logs are stored
        service.beta.kubernetes.io/aws-load-balancer-access-log-s3-bucket-prefix: "my-bucket-prefix/prod"
        # The logical hierarchy you created for your Amazon S3 bucket, for example `my-bucket-prefix/prod`

 

3.4 ExternalName 指定外部访问域名

类型为 ExternalName 的 Service 将服务映射到 DNS 名称，而不是典型的选择器，例如 my-service 或者 cassandra。 您可以使用 spec.externalName 参数指定这些服务。

注意：需要 CoreDNS 1.7 或更高版本才能使用ExternalName类型。

ExternalName 配置示例：

kind: Service
apiVersion: v1
metadata:
  name: service-python
spec:
  ports:
  - port: 3000
    protocol: TCP
    targetPort: 443
  type: ExternalName
  externalName: remote.server.url.com

当查找主机 Service -python.default.svc.cluster.local 时，集群 DNS 服务返回 CNAME 记录，其值为 my.database.example.com。 访问 Service -python 的方式与其他服务的方式相同，但主要区别在于重定向发生在 DNS 级别，而不是通过代理或转发。

 

3.5 无头服务（Headless Services）

当遇到不需要负载均衡，也不需要单独的 Service IP 的情况，可以通过显式设置集群 IP（spec.clusterIP）的值为 "None" 来创建无头服务（Headless Service）。

无头 Service 不会获得集群 IP，kube-proxy 不会处理这类 Service，而且平台也不会为它们提供负载均衡或路由支持。

无头 Service 允许客户端直接连接到任一 Pod。它不使用虚拟 IP 地址和代理配置路由和数据包转发；而是通过内部 DNS 记录报告各个 Pod 的端点 IP 地址，这些 DNS 记录是由集群的 DNS 服务所提供的。

Service的定义配置：将 .spec.type 设置为 ClusterIP（这也是 type 的默认值），并进一步将 .spec.clusterIP 设置为 None。字符串值 None 是一种特殊情况，与未设置 .spec.clusterIP 字段不同。

两个应用场景：

• 自主选择权。有时候 Client 想自己来决定使用哪个 Real Server，可以通过查询 DNS 来获取 Real Server 的信息。
• Headless Service 的对应的每一个 Endpoints，即每一个 Pod，都会有对应的 DNS 域名；这样 Pod 之间就能互相访问，集群也能单独访问 Pod。

带简单示例的文章可参考：https://zhuanlan.zhihu.com/p/490900452

四、Service 的服务发现

虽然 Service 的 Endpoints 解决了容器发现问题，但不提前知道 Service 的 Cluster IP，怎么发现 Service 服务呢？

Service 当前支持两种类型的服务发现机制，一种是通过环境变量，另一种是通过 DNS。在这两种方案中，建议使用后者。

环境变量

当 Pod 运行在某 Node 上时，kubelet 会在其中为每个活跃的 Service 添加一组环境变量，例如 {SVCNAME}_SERVICE_HOST 和 {SVCNAME}_SERVICE_PORT。这里 Service 的名称被转为大写字母，横线被转换成下划线。

例如，一个 Service redis-primary 公开了 TCP 端口 6379， 同时被分配了集群 IP 地址 10.0.0.11，这个 Service 生成的环境变量如下：

REDIS_PRIMARY_SERVICE_HOST=10.0.0.11
REDIS_PRIMARY_SERVICE_PORT=6379
REDIS_PRIMARY_PORT=tcp://10.0.0.11:6379
REDIS_PRIMARY_PORT_6379_TCP=tcp://10.0.0.11:6379
REDIS_PRIMARY_PORT_6379_TCP_PROTO=tcp
REDIS_PRIMARY_PORT_6379_TCP_PORT=6379
REDIS_PRIMARY_PORT_6379_TCP_ADDR=10.0.0.11

但是需要注意的是，在 Service 创建之前的所有 Pod 是不会注册该环境变量的，所以在平时使用时，建议通过 DNS 的方式进行 Service 之间的服务发现。

DNS

一般情况下都会使用插件（add-on） 来为 Kubernetes 集群安装 DNS 服务。

DNS 服务器（例如 CoreDNS）能够感知集群，也会监视 Kubernetes API 中的新 Service，并为每个 Service 创建一组 DNS 记录。如果在整个集群中都启用了 DNS，则所有 Pod 都应该能够通过 DNS 名称自动解析 Service。

例如，如果在 k8s 命名空间 my-ns 中有一个名为 my-service 的 Service，则控制平面和 DNS 服务共同为 my-service.my-ns 生成 DNS 记录。命名空间 my-ns 中的 Pod 应该能够通过按名检索 my-service 来找到服务（my-service.my-ns 也可以）。其他命名空间中的 Pod 必须将名称限定为 my-service.my-ns。这些名称将解析为分配给 Service 的集群 IP。

k8s 还支持命名端口的 DNS SRV（Service）记录。如果 Service my-service.my-ns 具有名为 http 的端口，且协议设置为 TCP，则可以用 _http._tcp.my-service.my-ns 执行 DNS SRV 查询以发现 http 的端口号以及 IP 地址。

k8s DNS 服务器是唯一的一种能够访问 ExternalName 类型的 Service 的方式。

参考： https://zhuanlan.zhihu.com/p/454836610    https://zhuanlan.zhihu.com/p/111244353      https://zhuanlan.zhihu.com/p/157565821     https://kubernetes.io/zh-cn/docs/concepts/services-networking/service/