【Kubernetes专项】K8s 四层代理 Service 从入门到企业实战应用

Cyber4K

776人浏览 · 2026-01-28 10:52:59

Cyber4K · 2026-01-28 10:52:59 发布

十二、K8s 四层代理 Service 从入门到企业实战应用

12.1 四层负载均衡 Service 介绍

12.1.1 为什么要有 Service？

在kubernetes中，Pod是有生命周期的，如果Pod重启它的IP很有可能会发生变化。如果我们的服务都是将Pod的IP地址写死，Pod挂掉或者重启，和刚才重启的pod相关联的其他服务将会找不到它所关联的Pod，为了解决这个问题，在kubernetes中定义了service资源对象，Service 定义了一个服务访问的入口，客户端通过这个入口即可访问服务背后的应用集群实例，service是一组Pod的逻辑集合，这一组Pod能够被Service访问到，通常是通过Label Selector实现的。

pod ip经常变化，service是pod的代理，我们客户端访问，只需要访问service，就会把请求代理到Pod

pod ip在k8s集群之外无法访问，所以需要创建service，这个service可以在k8s集群外访问的。

12.1.2 Service 概述

service是一个固定接入层，客户端可以通过访问service的ip和端口访问到service关联的后端pod，这个service工作依赖于在kubernetes集群之上部署的一个附件，就是kubernetes的dns服务（不同kubernetes版本的dns默认使用的也是不一样的，1.11之前的版本使用的是kubeDNs，较新的版本使用的是coredns），service的名称解析是依赖于dns附件的，因此在部署完k8s之后需要再部署dns附件，kubernetes要想给客户端提供网络功能，需要依赖第三方的网络插件（flannel，calico等）。每个K8s节点上都有一个组件叫做kube-proxy，kube-proxy这个组件将始终监视着apiserver中有关service资源的变动信息，需要跟master之上的apiserver交互，随时连接到apiserver上获取任何一个与service资源相关的资源变动状态，这种是通过kubernetes中固有的一种请求方法watch（监视）来实现的，一旦有service资源的内容发生变动（如创建，删除），kube-proxy都会将它转化成当前节点之上的能够实现service资源调度，把我们请求调度到后端特定的pod资源之上的规则，这个规则可能是iptables，也可能是ipvs，取决于service的实现方式。

12.1.3 Service 工作原理

k8s在创建Service时，会根据标签选择器selector(lable selector)来查找Pod，据此创建与Service同名的endpoint对象，当Pod 地址发生变化时，endpoint也会随之发生变化，service接收前端client请求的时候，就会通过endpoint，找到转发到哪个Pod进行访问的地址。(至于转发到哪个节点的Pod，由负载均衡kube-proxy决定)

12.1.4 K8s 集群中的三类IP地址

以下举例说明：

12.1.4.1 `Node Network`节点网络

物理节点或者虚拟节点的网络

[root@k8s-master1 ~]# ip addr
1: lo: <LOOPBACK,UP,LOWER_UP> mtu 65536 qdisc noqueue state UNKNOWN group default qlen 1000
    link/loopback 00:00:00:00:00:00 brd 00:00:00:00:00:00
    inet 127.0.0.1/8 scope host lo
       valid_lft forever preferred_lft forever
    inet6 ::1/128 scope host
       valid_lft forever preferred_lft forever
2: ens160: <BROADCAST,MULTICAST,UP,LOWER_UP> mtu 1500 qdisc mq state UP group default qlen 1000
    link/ether 00:0c:29:c6:cd:5c brd ff:ff:ff:ff:ff:ff
    altname enp3s0
    inet 172.25.254.10/24 brd 172.25.254.255 scope global noprefixroute ens160
       valid_lft forever preferred_lft forever
    inet6 fe80::20c:29ff:fec6:cd5c/64 scope link noprefixroute
       valid_lft forever preferred_lft forever
3: docker0: <NO-CARRIER,BROADCAST,MULTICAST,UP> mtu 1500 qdisc noqueue state DOWN group default
    link/ether 02:42:79:e1:a4:be brd ff:ff:ff:ff:ff:ff
    inet 172.17.0.1/16 brd 172.17.255.255 scope global docker0
       valid_lft forever preferred_lft forever
4: kube-ipvs0: <BROADCAST,NOARP> mtu 1500 qdisc noop state DOWN group default
    link/ether 7e:3a:70:3d:b6:13 brd ff:ff:ff:ff:ff:ff
    inet 10.96.0.10/32 scope global kube-ipvs0
       valid_lft forever preferred_lft forever
    inet 10.96.0.1/32 scope global kube-ipvs0
       valid_lft forever preferred_lft forever
    inet 10.109.29.31/32 scope global kube-ipvs0
       valid_lft forever preferred_lft forever
5: tunl0@NONE: <NOARP,UP,LOWER_UP> mtu 1480 qdisc noqueue state UNKNOWN group default qlen 1000
    link/ipip 0.0.0.0 brd 0.0.0.0
    inet 10.244.160.64/32 scope global tunl0
       valid_lft forever preferred_lft forever

12.1.4.2 `Pod Networker`pod网络

创建的Pod具有的IP地址

[root@k8s-master1 ~]# kubectl get pods -owide -n blue-green
NAME                        READY   STATUS    RESTARTS   AGE   IP               NODE                  NOMINATED NODE   READINESS GATES
myapp-v1-7f4fdb8844-dk2hp   1/1     Running   0          23s   10.244.147.238   k8s-node1.kaser.org   <none>           <none>
myapp-v1-7f4fdb8844-fsczt   1/1     Running   0          23s   10.244.90.191    k8s-node2.kaser.org   <none>           <none>
myapp-v1-7f4fdb8844-tbqrg   1/1     Running   0          23s   10.244.90.129    k8s-node2.kaser.org   <none>           <none>

12.1.4.3 `Cluster Network`集群地址（`Service Network`）

这个地址是虚拟的地址（virtual ip），没有配置在某个接口上，只是出现在service的规则当中

[root@k8s-master1 ~]# kubectl get svc
NAME              TYPE        CLUSTER-IP     EXTERNAL-IP   PORT(S)                         AGE
kubernetes        ClusterIP   10.96.0.1      <none>        443/TCP                         24d
springboot-live   NodePort    10.109.29.31   <none>        8080:31180/TCP,8081:31181/TCP   4d22h

12.2 Service 资源创建

12.2.1 `service.spec`字段

[root@k8s-master1 ~]# kubectl explain service.spec
  allocateLoadBalancerNodePorts <boolean>
  
  clusterIP     <string>
  # 动态分配地址，也可以自己创建的时候指定，创建之后就改不了了

  clusterIPs    <[]string>
  externalIPs   <[]string>
  externalName  <string>
  externalTrafficPolicy <string>
  healthCheckNodePort   <integer>
  internalTrafficPolicy <string>
  ipFamilies    <[]string>
  ipFamilyPolicy        <string>
  loadBalancerClass     <string>
  loadBalancerIP        <string>
  loadBalancerSourceRanges      <[]string>
  
  ports <[]ServicePort>
  # 定义service端口，用来和后端pod建立联系
  
  publishNotReadyAddresses      <boolean>
  
  selector      <map[string]string>
  # 通过标签选择器选择关联的pod有哪些

  sessionAffinity       <string>
  
  sessionAffinityConfig <SessionAffinityConfig>
  # #service在实现负载均衡的时候还支持sessionAffinity
  # sessionAffinity什么意思？
  # 会话联系，默认是none，随机调度的（基于iptables规则调度的）；如果我们定义sessionAffinity的client ip，那就表示把来自同一客户端的IP请求调度到同一个pod上
  
  trafficDistribution   <string>
  
  type  <string>
  # 定义service的类型

12.2.2 `service.spec.type`字段 Service 四种类型

https://kubernetes.io/docs/concepts/services-networking/service/#publishing-services-service-types

[root@k8s-master1 ~]# kubectl explain service.spec.type
    ClusterIP
    ExternalName
    LoadBalancer
    NodePort

12.2.3 `service.spec.ports`字段 Service 端口

]# kubectl explain service.spec.ports
  appProtocol   <string>
  
  name  		<string>
  # 定义端口的名字
  
  nodePort      <integer>
  # service在物理机映射的端口，默认在`30000-32767`之间
  
  port  		<integer> -required-
  # service的端口，这个是k8s集群内部服务可访问的端口
  
  protocol      <string>
  
  targetPort    <IntOrString>
  # targetPort是pod上的端口
  # 从port和nodePort上来的流量，经过kube-proxy流入到后端pod的targetPort上，最后进入容器。

12.3 示例-创建Service资源

12.3.1 ClusterIP类型

# 资源包中上传所需镜像
n1 && n2 ]# ctr -n k8s.io images import nginx.tar.gz

]# vim pod_test.yaml
apiVersion: apps/v1
kind: Deployment
metadata:
  name: my-nginx
spec:
  replicas: 2
  selector:
    matchLabels:
      run: my-nginx
  template:
    metadata:
      labels:
        run: my-nginx
    spec:
      containers:
      - name: my-nginx
        image: docker.io/library/nginx:latest
        imagePullPolicy: IfNotPresent
        ports:
        - containerPort: 80		# pod资源中容器暴露的端口
        startupProbe:
          httpGet:
            scheme: HTTP
            port: 80
            path: /
          initialDelaySeconds: 20
          periodSeconds: 5
          timeoutSeconds: 10
        livenessProbe:
          httpGet:
            scheme: HTTP
            port: 80
            path: /
          initialDelaySeconds: 20
          periodSeconds: 5
          timeoutSeconds: 10
        readinessProbe:
          httpGet:
            scheme: HTTP
            port: 80
            path: /
          initialDelaySeconds: 20
          periodSeconds: 5
          timeoutSeconds: 10
]# kubectl apply -f pod_test.yaml
]# kubectl get pods -owide -w

]# kubectl get pods -l run=my-nginx -owide
]# curl -s 10.244.147.239:80/

]# kubectl exec -it my-nginx-5cdf6f6fc6-bc686 -- /bin/bash
root@my-nginx-5cdf6f6fc6-bc686:/# curl 10.244.90.130
...
root@my-nginx-5cdf6f6fc6-bc686:/# exit

需要注意的是，pod虽然定义了容器端口，但是不会使用调度到该节点上的80端口，也不会使用任何特定的NAT规则去路由流量到Pod上。这意味着可以在同一个节点上运行多个 Pod，使用相同的容器端口，并且可以从集群中任何其他的Pod或节点上使用IP的方式访问到它们。

# 假设，此时误删了一个pod，并同时开启监控
]# kubectl delete pods my-nginx-5cdf6f6fc6-bc686 && kubectl get pods -l run=my-nginx -owide -w

# 查看pod标签
]# kubectl get pods --show-labels
... run=my-nginx
... run=my-nginx

[root@k8s-master1 ~]# vim service_test.yaml
apiVersion: v1
kind: Service
metadata:
  name: my-nginx
  labels:
    run: my-nginx
spec:
  type: ClusterIP
  ports:
  - port: 80
    protocol: TCP
    targetPort: 80
  selector:
    run: my-nginx

# 上述yaml文件将创建一个 Service，具有标签run=my-nginx的Pod，目标TCP端口 80，并且在一个抽象的Service端口（targetPort：容器接收流量的端口；port：抽象的 Service 端口，可以使任何其它 Pod访问该 Service 的端口）上暴露。

[root@k8s-master1 ~]# kubectl apply -f service_test.yaml
[root@k8s-master1 ~]# kubectl describe svc my-nginx | grep -i endpoints
Endpoints:                10.244.90.130:80,10.244.147.240:80

[root@k8s-master1 ~]# kubectl get svc -l run=my-nginx
NAME       TYPE        CLUSTER-IP      EXTERNAL-IP   PORT(S)   AGE
my-nginx   ClusterIP   10.96.166.110   <none>        80/TCP    31s

# 在k8s控制节点访问service的ip:端口就可以把请求代理到后端pod
[root@k8s-master1 ~]# curl 10.96.166.110:80

# 通过上面可以看到请求 service IP:port 跟直接访问pod ip:port看到的结果一样，这就说明service可以把请求代理到它所关联的后端pod

# 注意：上面的 10.96.166.110 地址只能是在k8s集群内部可以访问，在外部无法访问，比方说我们想要通过浏览器访问，那么是访问不通的，如果想要在k8s集群之外访问，是需要把service type类型改成nodePort的

[root@k8s-master1 ~]# kubectl get ep my-nginx
NAME       ENDPOINTS                            AGE
my-nginx   10.244.147.240:80,10.244.90.130:80   39m

service 可以对外提供统一固定的 ip 地址，并将请求重定向至集群中的 pod。其中“将请求重定向至集群中的 pod ”就是通过 endpoint 与 selector 协同工作实现。

selector是用于选择pod，由selector选择出来的pod的ip地址和端口号，将会被记录在endpoint中。endpoint便记录了所有pod的ip地址和端口号。当一个请求访问到service的ip地址时，就会从endpoint中选择出一个ip地址和端口号，然后将请求重定向至pod中。

具体把请求代理到哪个pod，需要的就是kube-proxy的轮询实现的。service不会直接到pod，service是直接到endpoint资源，就是地址加端口，再由endpoint再关联到pod。

# service只要创建完成，我们就可以直接解析它的服务名；
# 每一个服务创建完成后都会在集群dns中动态添加一个资源记录，
# 添加完成后我们就可以解析了，资源记录格式是：
	SVC_NAME.NS_NAME.DOMAIN.LTD.
		服务空间.命名空间.域名后缀
		
# 集群默认的域名后缀是 svc.cluster.local.
# 就像我们上面创建的 my-nginx 这个服务，它的完整名称解析就是:
# my-nginx.default.svc.cluster.local

12.3.2 NodePort 类型

[root@k8s-master1 ~]# vim pod_nodeport.yaml
apiVersion: apps/v1
kind: Deployment
metadata:
  name: my-nginx-nodeport
spec:
  replicas: 2
  selector:
    matchLabels:
      run: my-nginx-nodeport
  template:
    metadata:
      labels:
        run: my-nginx-nodeport
    spec:
      containers:
      - name: my-nginx-nodeport-container
        image: docker.io/library/nginx:latest
        imagePullPolicy: IfNotPresent
        ports:
        - containerPort: 80

[root@k8s-master1 ~]# kubectl apply -f pod_nodeport.yaml
[root@k8s-master1 ~]# kubectl get pods -owide

[root@k8s-master1 ~]# vim service_nodeport.yaml
apiVersion: v1
kind: Service
metadata:
  name: my-nginx-nodeport
  labels:
    run: my-nginx-nodeport
spec:
  type: NodePort
  selector:
    run: my-nginx-nodeport
  ports:
  - port: 80
    protocol: TCP
    targetPort: 80
    nodePort: 30380

[root@k8s-master1 ~]# kubectl apply -f service_nodeport.yaml
[root@k8s-master1 ~]# kubectl get pods -owide
[root@k8s-master1 ~]# curl 10.244.90.131:80

[root@k8s-master1 ~]# kubectl get svc -l run=my-nginx-nodeport
my-nginx-nodeport   NodePort   10.108.106.55   <none>        80:30380/TCP

[root@k8s-master1 ~]# curl 10.108.106.55:80

# 此时查看端口，发现没有，但是是这样么？
[root@k8s-master1 ~]# ss -ant | grep 30380


[root@k8s-master1 ~]# ifconfig docker0
docker0: 
        inet 172.17.0.1  netmask 255.255.0.0  broadcast 172.17.255.255

[root@k8s-master1 ~]# kubectl get pods -owide -l run=my-nginx-nodeport
my-nginx-nodeport-f8ff4db48-b564s   1/1     Running   10.244.90.131    k8s-node2.kaser.org
my-nginx-nodeport-f8ff4db48-frxl2   1/1     Running   10.244.147.241   k8s-node1.kaser.org

# 查看
[root@k8s-master1 ~]# ipvsadm -Ln
TCP  172.17.0.1:30380 rr				# docker0
  -> 10.244.90.131:80             Masq    1      0          0	# pod ip
  -> 10.244.147.241:80            Masq    1      0          0	# pod ip
  
# 也可以去浏览器去测试
[root@k8s-master1 ~]# curl 172.25.254.10:30380


1.客户端请求 http://172.25.254.10:30380
2.docker0虚拟网卡 172.17.0.1:30380
3.pod资源 10.244.121.36:80,10.244.102.86:80

12.3.3 ExternalName 类型

应用场景：跨名称空间访问

需求：default名称空间下的client 服务想要访问nginx-ns名称空间下的nginx-svc服务

# 上传实验所需资料
n1 && n2 ]# ctr -n k8s.io images import busybox.tar.gz

[root@k8s-master1 ~]# kubectl create ns nginx-ns

# 编写yaml文件（新nginx-ns命名空间里面建立deploy资源）
[root@k8s-master1 ~]# vim server_nginx.yaml
apiVersion: apps/v1
kind: Deployment
metadata:
  name: nginx
  namespace: nginx-ns
spec:
  replicas: 1
  selector:
    matchLabels:
      app: nginx
  template:
     metadata:
       labels:
         app: nginx
     spec:
       containers:
       - name: nginx
         image: docker.io/library/nginx:latest
         imagePullPolicy: IfNotPresent

[root@k8s-master1 ~]# kubectl apply -f server_nginx.yaml
[root@k8s-master1 ~]# kubectl get pods -n nginx-ns
nginx-5649696fcf-kltfc   1/1     Running   0          10m

# 编写yaml文件（新nginx-ns命名空间里面建立svc资源）
[root@k8s-master1 ~]# vim nginx_svc.yaml
apiVersion: v1
kind: Service
metadata:
  name: nginx-svc
  namespace: nginx-ns
spec:
  selector:
    app: nginx
  ports:
  - name: http
    protocol: TCP
    port: 80
    targetPort: 80

[root@k8s-master1 ~]# kubectl apply -f nginx_svc.yaml
[root@k8s-master1 ~]# kubectl get svc -n nginx-ns
nginx-svc   ClusterIP   10.108.102.48   <none>        80/TCP    2m17s

# 编写yaml文件（默认命名空间里面建立deploy资源）
[root@k8s-master1 ~]# vim client.yaml
apiVersion: apps/v1
kind: Deployment
metadata:
  name: client
spec:
  replicas: 1
  selector:
     matchLabels:
       app: busybox
  template:
    metadata:
      labels:
        app: busybox
    spec:
      containers:
      - name: busybox
        image: docker.io/library/busybox:latest
        imagePullPolicy: IfNotPresent
        command: ["/bin/sh","-c","sleep 36000"]

[root@k8s-master1 ~]# kubectl apply -f client.yaml

# 编写yaml文件（默认命名空间里面建立svc资源）
[root@k8s-master1 ~]# vim client_svc.yaml
apiVersion: v1
kind: Service
metadata:
  name: client-svc
spec:
  type: ExternalName	# 注意这里！（ExternalName类型）
  externalName: nginx-svc.nginx-ns.svc.cluster.local
  ports:
  - name: http
    port: 80
    targetPort: 80

[root@k8s-master1 ~]# kubectl apply -f client_svc.yaml

# 查看默认空间下的pod资源的ip
[root@k8s-master1 ~]# kubectl get pods -owide
client-5cd47bd894-n4wr7   1/1     Running   10.244.147.242   k8s-node1.kaser.org

# 尝试访问，被拒绝
[root@k8s-master1 ~]# curl 10.244.147.242
curl: (7) Failed to connect to 10.244.147.242 port 80: Connection refused

# 查看nginx-ns的pod资源ip
[root@k8s-master1 ~]# kubectl get pods -n nginx-ns -owide
nginx-5649696fcf-kltfc   1/1     Running   10.244.90.132   k8s-node2.kaser.org

# 尝试访问，输出内容
[root@k8s-master1 ~]# curl 10.244.90.132


# 查看默认空间下的svc资源（ExternalName类型）
[root@k8s-master1 ~]# kubectl get svc
client-svc   ExternalName   <none>       nginx-svc.nginx-ns.svc.cluster.local   80/TCP

# 查看nginx-ns空间下的svc资源
[root@k8s-master1 ~]# kubectl get svc -n nginx-ns
nginx-svc   ClusterIP   10.108.102.48   <none>        80/TCP    39m

# 访问正常
[root@k8s-master1 ~]# curl 10.108.102.48

# 查看nginx-ns下的pod资源ip
[root@k8s-master1 ~]# kubectl get pods -owide -n nginx-ns
nginx-5649696fcf-kltfc   1/1     Running   10.244.90.132   k8s-node2.kaser.org

# 查看nginx-ns下的Endpoints的ip
[root@k8s-master1 ~]# kubectl describe svc -n nginx-ns | grep Endpoints
Endpoints:                10.244.90.132:80

# 查看默认的svc，发现并无ip
[root@k8s-master1 ~]# kubectl describe svc client-svc | grep Endpoints
Endpoints:         <none>

# 此时再次查看svc信息（发现有nginx-svc的软链接，由于是ExternalName样式）
[root@k8s-master1 ~]# kubectl get svc
client-svc   ExternalName   <none>       nginx-svc.nginx-ns.svc.cluster.local   80/TCP

# 进行链接访问
[root@k8s-master1 ~]# kubectl get pods
NAME                      READY   STATUS    RESTARTS   AGE
client-5cd47bd894-n4wr7   1/1     Running   0          15m
[root@k8s-master1 ~]# kubectl exec -it client-5cd47bd894-n4wr7 -- /bin/sh
/ # wget -q -O - client-svc.default.svc.cluster.local
/ # wget -q -O - nginx-svc.nginx-ns.svc.cluster.local
/ # exit

12.3.4 自定义Endpoints资源

# 示例：k8s集群引用外部的mysql数据库

# node2节点安装mariadb
n2]# yum install -y mariadb-server.x86_64
n2]# systemctl enable --now mariadb

# 创建svc资源yaml文件
[root@k8s-master1 ~]# vim mysql_service.yaml
apiVersion: v1
kind: Service
metadata:
  name: mysql
spec:
  type: ClusterIP
  ports:
  - port: 3306
  
[root@k8s-master1 ~]# kubectl apply -f mysql_service.yaml
[root@k8s-master1 ~]# kubectl get svc | grep mysql
mysql        ClusterIP      10.98.11.244   <none>                                 3306/TCP   27s

[root@k8s-master1 ~]# kubectl describe svc mysql | grep Endpoints
Endpoints:                <none>

[root@k8s-master1 ~]# vim mysql_ep.yaml
apiVersion: v1
kind: Endpoints
metadata:
  name: mysql
subsets:
- addresses:
  - ip: 172.25.254.60
  ports:
  - port: 3306

[root@k8s-master1 ~]# kubectl apply -f mysql_ep.yaml

[root@k8s-master1 ~]# kubectl get ep | grep mysql
mysql        172.25.254.60:3306   38s

[root@k8s-master1 ~]# kubectl get svc | grep mysql
mysql        ClusterIP   10.98.11.244   <none>        3306/TCP   12m

[root@k8s-master1 ~]# kubectl describe svc mysql | grep Endpoints
Endpoints:                172.25.254.60:3306	 # 这个就是定义的外部数据库


# node1节点测试
n1]# yum install -y mariadb-server.x86_64
n1]# systemctl enable --now mariadb

]# kubectl describe svc mysql | grep Endpoints
Endpoints:                172.25.254.60:3306

[root@k8s-node1 ~]# kubectl get svc | grep mysql
mysql        ClusterIP   10.98.11.244   <none>        3306/TCP   26m

# 外部链接测试成功！
[root@k8s-node1 ~]# mysql -h 10.98.11.244 -P3306 -uroot -p
Enter password:
[root@k8s-node1 ~]# mysql -h 172.25.254.60 -P3306 -uroot -p
Enter password:

12.4 CoreDns 组件

12.4.1 coredns概述

CoreDNS 其实就是一个 DNS 服务，而 DNS 作为一种常见的服务发现手段，所以很多开源项目以及工程师都会使用 CoreDNS 为集群提供服务发现的功能，Kubernetes 就在集群中使用 CoreDNS 解决服务发现的问题。作为一个加入 CNCF（Cloud Native Computing Foundation）的服务， CoreDNS 的实现非常简单。

12.4.2 coreDns验证

# 上传实验资源文件
n1 && n2 ]# ctr -n k8s.io images import dig.tar.gz

[root@k8s-master1 ~]# vim dig.yaml
apiVersion: v1
kind: Pod
metadata:
  name: dig
spec:
  containers:
  - name: dig
    image: docker.io/xianchao/dig:latest
    imagePullPolicy: IfNotPresent
    command: ["sleep","3600"]
  restartPolicy: Always
  
[root@k8s-master1 ~]# kubectl apply -f dig.yaml
[root@k8s-master1 ~]# kubectl get pods
NAME   READY   STATUS    RESTARTS   AGE
dig    1/1     Running   0          4s

[root@k8s-master1 ~]# kubectl exec -it dig -- /bin/sh
/ # nslookup kubernetes
Server:         10.96.0.10
Address:        10.96.0.10#53

Name:   kubernetes.default.svc.cluster.local
Address: 10.96.0.1

/ # nslookup kubernetes.default.svc.cluster.local
Server:         10.96.0.10
Address:        10.96.0.10#53

Non-authoritative answer:
Name:   kubernetes.default.svc.cluster.local.kaser.org
Address: 208.98.35.217

/ # nslookup www.baidu.com
Server:         10.96.0.10
Address:        10.96.0.10#53

Non-authoritative answer:
Name:   www.baidu.com.kaser.org
Address: 208.98.35.217

[root@k8s-master1 ~]# kubectl get svc
NAME         TYPE        CLUSTER-IP     EXTERNAL-IP   PORT(S)    AGE
kubernetes   ClusterIP   10.96.0.1      <none>        443/TCP    8h
mysql        ClusterIP   10.98.11.244   <none>        3306/TCP   56m

[root@k8s-master1 ~]# kubectl get svc -n kube-system
NAME       TYPE        CLUSTER-IP   EXTERNAL-IP   PORT(S)                  AGE
kube-dns   ClusterIP   10.96.0.10   <none>        53/UDP,53/TCP,9153/TCP   24d