Kubernetes Service

环境准备

root@master30~/service 15:38:18# kubectl create ns service
root@master30~/service 16:36:52# kubectl config set-context --current --namespace service

Service 介绍

如果你使用 Deployment 来运行你的应用， Deployment 可以动态地创建和销毁 Pod。 在任何时刻，你都不知道有多少个这样的 Pod 正在工作以及它们健康与否； 你甚至不知道如何辨别 Pod是否健康。 Kubernetes Pod 的创建和销毁是为了匹配集群的预期状态。 Pod 是临时资源（你不应该期待单个 Pod 既可靠又耐用）。

每个 Pod 会获得属于自己的 IP 地址（Kubernetes 使用网络插件来保证这一点）。 对于集群中给定的某个 Deployment，这一刻运行的 Pod 集合可能不同于下一刻运行该应用的 Pod 集合。

**这就带来了一个问题：**如果某组 Pod（称为“后端”）为集群内的其他 Pod（称为“前端”） 集合提供功能，前端要如何发现并跟踪要连接的 IP 地址，以便其使用负载的后端组件呢？

答案是 Service。

  • Kubernetes 中 Service ，可以将运行在一个或一组 Pod 上的网络应用程序公开为网络服务。Service有自己的IP和端口，而且这个IP是不变的。Service为Pod提供了负载均衡。客户端只需要访问Service的IP， Kubernetes则负责建立和维护Service与Pod的映射关系。 无论后端Pod如何变化， 对客户端不会有任何影响， 因为Service没有变。

  • Kubernetes 中 Service 的一个关键目标：让你无需修改现有应用以使用某种不熟悉的服务发现机制。 你可以在 Pod 集合中运行代码，无论该代码是为云原生环境设计的， 还是被容器化的老应用。 你可以使用 Service 让一组 Pod 可在网络上访问，这样客户端就能与之交互。

Service 基本管理

环境准备：创建 deployment

# 创建depolyment
root@master30~/service 16:37:14# kubectl create deployment web --image=docker.io/library/httpd --replicas=3

#查看Pod
root@master30~/service 16:42:40# kubectl get pods --show-labels
NAME                   READY   STATUS    RESTARTS   AGE   LABELS
web-6db76cb4fc-brx5q   1/1     Running   0          78s   app=web,pod-template-hash=6db76cb4fc
web-6db76cb4fc-d7dq9   1/1     Running   0          78s   app=web,pod-template-hash=6db76cb4fc
web-6db76cb4fc-w7cdx   1/1     Running   0          78s   app=web,pod-template-hash=6db76cb4fc

创建 Service

root@master30~/service 16:43:04# kubectl create service clusterip web --tcp=8080:80
root@master30~/service 16:43:48# kubectl get svc
NAME   TYPE        CLUSTER-IP       EXTERNAL-IP   PORT(S)    AGE
web    ClusterIP   10.107.201.200   <none>        8080/TCP   5s
## 选项--tcp=8080:80代表访问集群ip的8080/TCP，将转发给pod的80端口
## svc默认标签是：app=<svc-name>

#查看Service详细信息
root@master30~/service 16:46:47# kubectl describe svc web
Name:              web
Namespace:         service
Labels:            app=web
Annotations:       <none>
Selector:          app=web
Type:              ClusterIP
IP Family Policy:  SingleStack
IP Families:       IPv4
IP:                10.107.201.200
IPs:               10.107.201.200
Port:              8080-80  8080/TCP
TargetPort:        80/TCP
Endpoints:         10.224.128.46:80,10.224.96.217:80,10.224.96.218:80
Session Affinity:  None
Events:            <none>

#访问测试
root@master30~/service 16:42:40# curl 10.107.201.200:8080
<html><body><h1>It works!</h1></body></html>

验证 Service

  1. 更改每个pod主页，验证负载均衡功能。

    root@master30~/service 16:53:10# kubectl get pods -o wide | awk '{print$1}'
NAME
web-6db76cb4fc-brx5q
web-6db76cb4fc-d7dq9
web-6db76cb4fc-w7cdx
root@master30~/service 16:48:05# kubectl exec web-6db76cb4fc-brx5q -- bash -c "echo web1 > /usr/local/apache2/htdocs/index.html"
root@master30~/service 16:51:26# kubectl exec web-6db76cb4fc-d7dq9 -- bash -c "echo web2 > /usr/local/apache2/htdocs/index.html"
root@master30~/service 16:51:44# kubectl exec web-6db76cb4fc-w7cdx -- bash -c "echo web3 > /usr/local/apache2/htdocs/index.html"

# 验证效果
root@master30~/service 16:52:56# curl 10.107.201.200:8080
web2
root@master30~/service 16:53:08# curl 10.107.201.200:8080
web3
root@master30~/service 16:53:09# curl 10.107.201.200:8080
web1

#或者
root@master30~/service 16:55:31# for i in {1..60}; do curl -s 10.107.201.200:8080;done |sort | uniq -c
     20 web1
     20 web2
     20 web3
# curl -s：静默访问，不输出请求日志、进度条，只返回页面内容
# |sort：把返回结果全部排序，相同内容放到一起
# uniq -c：统计重复行数量

  2. 此时如果创建一个具有相同标签的pod，service也会将请求转发到该pod

    root@master30~/service 17:01:38# kubectl run web --image=docker.io/library/httpd --labels=app=web
root@master30~/service 17:04:41# for i in {1..60};do curl -s 10.107.201.200:8080;done | sort | uniq -c
     15 web
     15 web1
     15 web2
     15 web3

  3. 此时重启deploy，service仍然能动态发现后端pod

    root@master30~/service 17:04:52# kubectl rollout restart deployment web
root@master30~/service 17:06:07# for pod in $(kubectl get pods -o name | awk -F/  '{print $2}')
do
  kubectl exec -it $pod -- bash -c "echo $pod > htdocs/index.html"
done
# awk -F/ 是指定字段分隔符为斜杠 /

root@master30~/service 17:07:06# for i in {1..60};do curl -s 10.107.201.200:8080;done | sort | uniq -c
     15 web
     15 web-7586c5bd66-l9vnm
     15 web-7586c5bd66-ncqws
     15 web-7586c5bd66-qfxxv

  4. 如果创建的pod具有标签app1=web1和app2=web2，而deploy控制器的selector匹配的标签为app1=web1，service匹配的标签为app2=web2也是可以的。

    root@master30~/service 17:10:52# kubectl delete deployments.apps web
root@master30~/service 17:11:02# kubectl delete svc web
root@master30~/service 17:11:11# vim deploy-web.yaml

    apiVersion: apps/v1
kind: Deployment
metadata:
  creationTimestamp: null
  labels:
    app: web
  name: web
spec:
  replicas: 2
  selector:
    matchLabels:
      app1: web1
  strategy: {}
  template:
    metadata:
      creationTimestamp: null
      labels:
        app1: web1
        app2: web2
    spec:
      containers:
      - image: docker.io/library/httpd
        name: httpd
        imagePullPolicy: IfNotPresent
        resources: {}
status: {}

    root@master30~/service 17:12:10# kubectl apply -f deploy-web.yaml

# 通过expose方式创建service
root@master30~/service 17:13:25# kubectl expose deployment web --port=8080 --target-port=80 --selector=app2=web2
# 选项说明：
# --port=8080，定义service监听的端口
# --target-port=80，定义后端pod鉴定的端口
# --selector=app2=web2，定义service选择器标签

# -e 用来指定多个匹配规则
root@master30~/service 17:14:43# kubectl describe svc web | grep -e IP: -e Endpoints
IP:                10.105.124.156
Endpoints:         10.224.128.50:80,10.224.96.221:80

  5. 无法ping通service ip，但可以ping通pod。service只允许http方式访问80，其他没有做iptables映射。

yaml 文件创建

root@master30~/service 17:26:07# kubectl create svc clusterip web --tcp=8080:80 -o yaml --dry-run=client > svc-web.yaml
  • kubectl create svc clusterip web
    • create svc clusterip：创建类型为 ClusterIP 的 Service
    • web：Service 名称为 web
  • –tcp=8080:80
    • Service 端口：Pod 容器端口
  • –dry-run=client
    • 客户端试运行，仅在本地生成配置，不向 apiserver 提交创建请求，不会真正生成 svc
apiVersion: v1
kind: Service
metadata:
  labels:
    app: web
  name: web
spec:
  ports:
  - name: web-8080-80
    port: 8080
    protocol: TCP
    targetPort: 80
  selector:
    app: web
  type: ClusterIP

Service 发现

所谓发现 Service，是指集群内应用访问 Service。

我们介绍以下三种方式发现 Service：

  1. 通过 IP 访问 Service。
  2. 通过环境变量访问 Service。
  3. 通过 dns 解析的名称访问 Service。

三种方式均是访问 Service，由 Service 转发至后端 Pod，而非直接访问 Pod；

通过 IP 访问 Service

实验准备：mysql+wordpress

准备mysql资源

root@master30~ 09:47:04# kubectl run mysql --image=docker.io/library/mysql \
--image-pull-policy=IfNotPresent \
--env=MYSQL_ROOT_PASSWORD=redhat \
--env=MYSQL_USER=tom \
--env=MYSQL_PASSWORD=redhat \
--env=MYSQL_DATABASE=blog \
--dry-run=client -o yaml > pod-mysql.yaml

root@master30~/service 10:17:24# kubectl apply -f pod-mysql.yaml

#暴露端口，会直接创建一个Service资源，类型默认是 ClusterIP
root@master30~/service 10:17:44# kubectl expose pod mysql --port=3306 --target-port=3306
service/mysql exposed
root@master30~/service 10:17:55# kubectl get service
NAME    TYPE        CLUSTER-IP      EXTERNAL-IP   PORT(S)    AGE
mysql   ClusterIP   10.98.199.115   <none>        3306/TCP   5s

#可通过访问svc的ip,由svc转发访问Pod
root@master30~/service 10:18:00# mysql -utom -predhat -h 10.98.199.115
mysql: [Warning] Using a password on the command line interface can be insecure.
Welcome to the MySQL monitor.  Commands end with ; or \g.
Your MySQL connection id is 9
Server version: 9.6.0 MySQL Community Server - GPL

Copyright (c) 2000, 2026, Oracle and/or its affiliates.

Oracle is a registered trademark of Oracle Corporation and/or its
affiliates. Other names may be trademarks of their respective
owners.

Type 'help;' or '\h' for help. Type '\c' to clear the current input statement.

mysql>

准备WordPress资源

root@master30~/service 10:18:42# kubectl run wordpress \
--image=docker.io/library/wordpress \
--image-pull-policy=IfNotPresent \
--env=WORDPRESS_DB_USER=tom \
--env=WORDPRESS_DB_PASSWORD=redhat \
--env=WORDPRESS_DB_NAME=blog \
--env=WORDPRESS_DB_HOST=10.98.199.115 

#暴露端口
root@master30~/service 10:19:21# kubectl expose pod wordpress --port=80 --target-port=80 --type NodePort
service/wordpress exposed
root@master30~/service 10:19:41# kubectl get service
NAME        TYPE        CLUSTER-IP      EXTERNAL-IP   PORT(S)        AGE
mysql       ClusterIP   10.98.199.115   <none>        3306/TCP       109s
wordpress   NodePort    10.97.180.227   <none>        80:30840/TCP   3s

# 访问测试，浏览器访问10.1.8.30:30840

⭐️这里创建的svc为NodePort类型
**NodePort的特性：**集群里所有节点（master30、worker31、worker32）都会监听 30840 端口，不管WordPress Pod实际跑在哪个节点上。
流量流程：
任意节点 IP:30840 → 集群 iptables/ipvs → Service ClusterIP → 转发到后端 Pod

在这里插入图片描述

通过环境变量访问 Service

获取环境变量信息

root@master30~ 11:02:39# kubectl run test --rm -it --image=docker.io/library/busybox --image-pull-policy=IfNotPresent sh
If you don't see a command prompt, try pressing enter.
/ # env | grep MYSQL
MYSQL_PORT_3306_TCP_ADDR=10.98.199.115
MYSQL_PORT_3306_TCP_PORT=3306
MYSQL_PORT_3306_TCP_PROTO=tcp
MYSQL_SERVICE_HOST=10.98.199.115
MYSQL_PORT=tcp://10.98.199.115:3306
MYSQL_SERVICE_PORT=3306
MYSQL_PORT_3306_TCP=tcp://10.98.199.115:3306
/ # exit
Session ended, resume using 'kubectl attach test -c test -i -t' command when the pod is running
pod "test" deleted
  • kubectl run test 创建一个名叫 test 的临时 Pod。
  • –rm 退出 shell 后自动删除这个 Pod，用完即销毁，不留垃圾资源。
  • -it
    • -i：保持标准输入打开
    • -t：分配交互式终端 作用：能进入 Pod 内部敲命令、交互。
  • –image=xxx/busybox：用轻量 busybox 镜像，自带 ping、nslookup、env、curl 等工具，专门用来集群网络调试。
  • sh：容器启动后直接运行 sh 命令，进入命令行。

执行 env|grep MYSQL 看到的一堆环境变量是什么？

K8s 内置机制：当前命名空间下所有 Service，都会自动注入对应环境变量到新创建的 Pod。

说明：

  1. 可以通过环境变量MYSQL_SERVICE_HOST访问服务mysql。
  2. service创建后才能使用该环境变量。
  3. service属于namespace，pod只能访问同一个namespace中service。

准备WordPress资源

# 删除 pod-WordPress 资源，重新创建
root@master30~/service 10:44:33# kubectl delete pods wordpress
root@master30~/service 10:44:54# kubectl run wordpress \
--image=docker.io/library/wordpress \
--image-pull-policy=IfNotPresent \
--env=WORDPRESS_DB_USER=tom \
--env=WORDPRESS_DB_PASSWORD=redhat \
--env=WORDPRESS_DB_NAME=blog \
--env=WORDPRESS_DB_HOST='$(MYSQL_SERVICE_HOST)'
pod/wordpress created

# 查看Service变量
root@master30~/service 10:45:04# kubectl exec -it wordpress -- sh -c 'env|grep MYSQL'
MYSQL_PORT_3306_TCP_ADDR=10.98.199.115
MYSQL_PORT_3306_TCP_PORT=3306
MYSQL_SERVICE_HOST=10.98.199.115
MYSQL_PORT_3306_TCP_PROTO=tcp
MYSQL_PORT=tcp://10.98.199.115:3306
MYSQL_SERVICE_PORT=3306
MYSQL_PORT_3306_TCP=tcp://10.98.199.115:3306
root@master30~/service 10:45:09# kubectl get svc
NAME        TYPE        CLUSTER-IP      EXTERNAL-IP   PORT(S)        AGE
mysql       ClusterIP   10.98.199.115   <none>        3306/TCP       27m
wordpress   NodePort    10.97.180.227   <none>        80:30840/TCP   25m

# 访问测试,浏览器访问10.1.8.30:30840

通过 DNS 名称访问 Service

Kubernetes 还提供了更为方便的DNS访问。kubeadm部署时会默认安装coredns组件。

root@master30~/service 10:46:11# kubectl get deployments.apps --namespace=kube-system
NAME                      READY   UP-TO-DATE   AVAILABLE   AGE
calico-kube-controllers   1/1     1            1           5d17h
coredns                   2/2     2            2           5d17h

coredns是一个DNS服务器。 每当有新的Service被创建， coredns会添加该Service的DNS记录。 Cluster中的Pod可以通过<SERVICE_NAME>.<NAMESPACE_NAME>访问Service。

root@master30:~# kubectl run busybox --rm -it --image=docker.io/library/busybox /bin/sh
If you don't see a command prompt, try pressing enter.
/ # cat /etc/resolv.conf 
nameserver 10.96.0.10
search service.svc.cluster.local svc.cluster.local cluster.local laoma.cloud
options ndots:5
/ # wget wordpress.service:80
Connecting to wordpress.service:80 (10.106.106.246:80)
Connecting to wordpress.service:80 (10.106.106.246:80)
saving to 'index.html'
index.html           100% |***************************************| 11607  0:00:00 ETA
'index.html' saved

由于这个Pod与web service同属于laoma namespace， 因此可以省略laoma直接用web访问Service.

/ # rm index.html
/ # wget wordpress:80
Connecting to wordpress:80 (10.106.106.246:80)
Connecting to wordpress:80 (10.106.106.246:80)
saving to 'index.html'
index.html           100% |***************************************| 11571  0:00:00 ETA
'index.html' saved

10.96.0.10是哪个DNS服务器呢？

root@master30:~# kubectl get service --namespace 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   3d2h

接上面的WordPress示例

# 删除 pod-WordPress 资源，重新创建
root@master30~/service 10:48:13# kubectl delete pod wordpress --force
root@master30~/service 10:48:21# kubectl run wordpress \
--image=docker.io/library/wordpress \
--image-pull-policy=IfNotPresent \
--env=WORDPRESS_DB_USER=tom \
--env=WORDPRESS_DB_PASSWORD=redhat \
--env=WORDPRESS_DB_NAME=blog \
--env=WORDPRESS_DB_HOST=mysql
pod/wordpress created

# 访问测试,浏览器访问10.1.8.30:30840

# 清理环境
root@master30~/service 10:49:20# kubectl delete svc mysql wordpress
root@master30~/service 10:49:56# kubectl delete pod mysql wordpress

Service 类型

Kubernetes Service 支持以下四种类型：

  • ClusterIP：只能在集群内部访问。

  • NodePort：通过物理节点的端口来访问，每个物理节点都提供相同的端口。

  • LoadBalancer：负载均衡，来源于物理网段中一个独立的IP。

  • ExternalName：配置集群内部的CName。

  • Headless：只有服务名，不分配IP地址。

我们的应用可能希望将 Service 暴露在一个外部 IP 地址上。 Kubernetes 支持两种实现方式：NodePort 和 LoadBalancer。

环境准备

创建 deployment

root@master30~/service 17:47:18# kubectl create deployment web --image=docker.io/library/httpd --replicas=2

ClusterIP

ClusterIP，是通过集群的内部 IP 公开 Service，选择该值时 Service 只能够在集群内部访问。 这也是服务类型的默认值。

  • ClusterIP 从集群中预留的 IP 地址池中分配一个 IP 地址。其他几种 Service 类型在 ClusterIP 类型的基础上进行构建。

  • 在创建 Service 的请求中，可以通过设置 .spec.clusterIP 字段来指定自己的集群 IP 地址。

    如果将 Service 的 .spec.clusterIP 设置为 "None"，则 Kubernetes 不会为其分配 IP 地址。

  • 所选择的 IP 地址必须是合法的 IPv4 或者 IPv6 地址，并且这个 IP 地址在 API 服务器上所配置的 service-cluster-ip-range CIDR 范围内。 如果你尝试创建一个带有非法 clusterIP 地址值的 Service，API 服务器会返回 HTTP 状态码 422， 表示值不合法。

其他信息参考上面的 发现 Service 章节。

NodePort

  1. 如果将Service 的 type 字段设置为 NodePort，则 Kubernetes 控制平面将在 --service-node-port-range 标志所指定的范围内分配端口（默认值：30000-32767）。 Service 在其 .spec.ports[*].nodePort 字段中报告已分配的端口。

  2. NodePort 类型的 Service 通过每个节点上的 IP 和分配的端口（NodePort）公开 Service。 为了让 Service 可通过节点端口访问，Kubernetes 会为 NodePort 类型的Service 配置 clusterIP 地址。每个节点将该端口（每个节点上的相同端口号）上的流量代理到 Service。

示例：

root@master30~/service 17:48:23# kubectl expose deployment web --type NodePort --port=8080 --target-port=80 -o yaml --dry-run=client > svc-NodePort.yaml

apiVersion: v1
kind: Service
metadata:
  labels:
    app: web
  name: web
spec:
  ports:
  - port: 8080
    protocol: TCP
    targetPort: 80
  selector:
    app: web
  type: NodePort

# 创建NodePort类型Service
root@master30~/service 17:52:49# kubectl apply -f svc-NodePort.yaml

# 查看node节点对应端口为30194
root@master30~/service 17:53:05# kubectl get svc
NAME   TYPE       CLUSTER-IP       EXTERNAL-IP   PORT(S)          AGE
web    NodePort   10.101.107.219   <none>        8080:30194/TCP   11s

# 说明：
# 1-EXTERNAL-IP为nodes， 表示可通过Cluster每个节点自身的IP访问Service。
# 2-PORT(S)为8080:31917。 8080是ClusterIP监听的端口，30194则是节点上监听的端口。
# Kubernetes会从30000～32767中分配一个可用的端口，每个节点都会监听此端口并将请求转发给Service

# 访问集群中任一节点测试
root@master30~/service 17:53:16# curl 10.1.8.30:30194
root@master30~/service 17:55:25# curl 10.1.8.31:30194
root@master30~/service 17:55:30# curl 10.1.8.32:30194

分析防火墙规则：

# 与ClusterIP对比，每个节点的iptables中额外增加了下面两条规则：
root@master30:~# iptables-save | grep 31917
-A KUBE-NODEPORTS -p tcp -m comment --comment "laoma/web:http" -m tcp --dport 31917 -j KUBE-MARK-MASQ
-A KUBE-NODEPORTS -p tcp -m comment --comment "laoma/web:http" -m tcp --dport 31917 -j KUBE-SVC-WE5D4GWSX3MMPCHH
# 规则的含义是：访问当前节点31917端口的请求会应用规则KUBE-SVC-WE5D4GWSX3MMPCHH

# 进一步分析，其作用就是负载均衡到每一个Pod。
root@master30:~# iptables-save |grep KUBE-SVC-WE5D4GWSX3MMPCHH
-A KUBE-SERVICES -d 10.110.40.0/32 -p tcp -m comment --comment "laoma/web:http cluster IP" -m tcp --dport 8080 -j KUBE-SVC-WE5D4GWSX3MMPCHH
-A KUBE-SVC-WE5D4GWSX3MMPCHH -m comment --comment "laoma/web:http" -m statistic --mode random --probability 0.50000000000 -j KUBE-SEP-LUIIA2GDKT4VDBA2
-A KUBE-SVC-WE5D4GWSX3MMPCHH -m comment --comment "laoma/web:http" -j KUBE-SEP-Y6B6PNSXFIBR4D2K

NodePort默认的是随机选择， 我们可以使用nodePort指定为特定端口。

apiVersion: v1
kind: Service
metadata:
  creationTimestamp: null
  labels:
    app: web
  name: web
spec:
  ports:
  - port: 8080
    protocol: TCP
    # 指定节点固定端口
    nodePort: 30080
    targetPort: 80
  selector:
    app: web
  type: NodePort
status:
  loadBalancer: {}

端口说明：

  • nodePort是节点上监听的端口。
  • port是ClusterIP上监听的端口。
  • targetPort是Pod监听的端口。

LoadBalancer

LoadBalancer = NodePort 的上层封装，专门用于云厂商环境对外暴露服务。

kubernetes并没有真正实现 LoadBalancer，需要借助第三方工具实现，例如metallb。

每个LoadBalancer类型的service需要关联一个公网IP。创建LoadBalancer类型的service只需要将Service 的 Type 改成 LoadBalancer。

这里我们使用 metallb。

官方地址： https://metallb.universe.tf/

github地址：https://github.com/metallb/metallb

部署

部署 metallb

root@master30~/service 18:04:16# tar -xf metallb-0.14.8.tar.gz
# 查看镜像
root@master30~/service 18:04:36# grep image metallb-0.14.8/config/manifests/metallb-native.yaml
        image: quay.io/metallb/controller:v0.14.8
        image: quay.io/metallb/speaker:v0.14.8
# 按需修改镜像
root@master30~/service 18:05:01# sed -i 's/quay.io/docker.io/g' metallb-0.14.8/config/manifests/metallb-native.yaml

root@master30~/service 18:05:11# kubectl apply -f metallb-0.14.8/config/manifests/metallb-native.yaml
# 等待着所有pod正常运行再进行下一步
root@master30~/service 18:05:27# kubectl get all -n metallb-system
NAME                             READY   STATUS    RESTARTS   AGE
pod/controller-d6499775f-7xkqz   1/1     Running   0          6h26m
pod/speaker-cw2cg                1/1     Running   0          6h26m
pod/speaker-j4c7n                1/1     Running   0          6h26m
pod/speaker-vbc6s                1/1     Running   0          6h26m

NAME                              TYPE        CLUSTER-IP      EXTERNAL-IP   PORT(S)   AGE
service/metallb-webhook-service   ClusterIP   10.108.92.182   <none>        443/TCP   6h26m

NAME                     DESIRED   CURRENT   READY   UP-TO-DATE   AVAILABLE   NODE SELECTOR            AGE
daemonset.apps/speaker   3         3         3       3            3           kubernetes.io/os=linux   6h26m

NAME                         READY   UP-TO-DATE   AVAILABLE   AGE
deployment.apps/controller   1/1     1            1           6h26m

NAME                                   DESIRED   CURRENT   READY   AGE
replicaset.apps/controller-d6499775f   1         1         1       6h26m

配置地址池

root@master30~/service 18:05:39# cat << 'EOF' > ippool.yaml
apiVersion: metallb.io/v1beta1
kind: IPAddressPool
metadata:
  name: first-pool
  namespace: metallb-system
spec:
  addresses:
  - 10.1.8.40-10.1.8.80
EOF
root@master30~/service 18:06:12# kubectl apply -f ippool.yaml

配置 lay2

root@master30~/service 18:06:27# cat << 'EOF' > L2.yaml
apiVersion: metallb.io/v1beta1
kind: L2Advertisement
metadata:
  name: example
  namespace: metallb-system
EOF
root@master30~/service 18:06:55# kubectl apply -f L2.yaml
测试
root@master30~/service 18:07:05# kubectl expose deployment web --type LoadBalancer --port=80 --target-port=80 -o yaml --dry-run=client > service-LoadBalancer.yaml

apiVersion: v1
kind: Service
metadata:
  labels:
    app: web
  name: web
spec:
  ports:
  - port: 80
    protocol: TCP
    targetPort: 80
  selector:
    app: web
  type: LoadBalancer

root@master30~/service 18:07:38# kubectl apply -f service-LoadBalancer.yaml
root@master30~/service 18:07:59# kubectl get service
NAME        TYPE           CLUSTER-IP       EXTERNAL-IP   PORT(S)        AGE
wordpress   LoadBalancer   10.104.207.207   10.1.8.40     80:30164/TCP   6s


# 访问测试，端口号使用service的80，非30164端口
root@master30~/service 18:08:05# curl -s http://10.1.8.40:80
<html><body><h1>It works!</h1></body></html>
总结：LoadBalancer 类型 Service 的核心作用

  • 提供独立固定外部访问 IP：即 EXTERNAL-IP

  • 统一对外入口，屏蔽集群内部节点、Pod 细节：客户端只需要记住一个固定 LB IP，不需要关心后端有多少 Pod、Pod 跑在哪个节点

  • 客户端流量到达pod路径：客户端请求 → MetalLB 虚拟 IP（LB IP） → 节点 kube-proxy → Service 转发 → 后端 Pod。

  • ✅ MetalLB 只做 ARP 宣告 + IP 占坑，转发全靠 kube-proxy + Service。

  • MetalLB + Service 是标准 K8s 负载均衡流程。

详细流程图

访问 LB VIP:10.1.8.40

客户端用户

ARP 寻址 → 流量进入集群任意节点

节点内核拦截 Service IP 流量

kube-proxy 处理 iptables/IPVS 规则

Service 负载均衡：选择一个健康 Pod

通过 CNI 网络转发到 Pod 所在节点

流量进入 Pod 网络命名空间

目标 Pod 接收并响应请求
  1. 客户端发起请求：用户通过浏览器 / 应用访问 MetalLB 分配的 LB VIP（如 10.1.8.200）。
  2. ARP 寻址，流量进入集群节点：MetalLB 使用 Layer2 模式，通过 ARP 广播声明 VIP 归属，流量进入集群任意一个节点。
  3. **节点内核拦截流量：**节点识别目标地址为 Service LB IP，将流量交给内核网络框架处理。
  4. **kube-proxy 执行转发规则：**kube-proxy 匹配 iptables/IPVS 规则，确定流量所属 Service。
  5. **Service 负载均衡选择 Pod：**从 Service 后端 endpoints 中，按策略选择一个健康 Pod。
  6. **CNI 网络跨节点转发：**若 Pod 不在当前节点，流量通过 Calico/Flannel 等 CNI 网络转发到目标节点。
  7. **流量进入 Pod：**目标节点通过 veth-pair 设备，将流量送入 Pod 网络命名空间。
  8. **Pod 响应请求：**业务容器接收请求并返回数据，原路响应给客户端。

ExternalName

ExternalName，将服务映射到 externalName 字段的内容（例如，api.foo.bar.example）。 该映射将集群的 DNS 服务器配置为返回具有该外部主机名值的 CNAME 记录。 集群不会为之创建任何类型代理。

例如，将 prod 命名空间中的 my-service 服务映射到 database.example.com。

apiVersion: v1
kind: Service
metadata:
  name: my-service
  namespace: prod
spec:
  type: ExternalName
  externalName: database.example.com

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

Headless Services

有时并不需要负载均衡，也不需要单独的 Service IP。遇到这种情况，可以通过显式设置ClusterIP的值为 None 来创建无头服务（Headless Service）。

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

取决于 Service 是否定义了选择算符，DNS 会以不同的方式被自动配置。

  • 带选择算符的服务，对定义了选择算符的无头 Service，Kubernetes 控制平面在 Kubernetes API 中创建 EndpointSlice 对象，并且修改 DNS 配置返回 A 或 AAAA 记录（IPv4 或 IPv6 地址）， 这些记录直接指向 Service 的后端 Pod 集合。

  • 无选择算符的服务，对没有定义选择算符的无头 Service，控制平面不会创建 EndpointSlice 对象。 然而 DNS 系统会执行以下操作之一：

    • 对于 type: ExternalName Service，查找和配置其 CNAME 记录；

    • 对所有其他类型的 Service，针对 Service 的就绪端点的所有 IP 地址，查找和配置 DNS A/AAAA 记录：对于 IPv4 端点，DNS 系统创建 A 记录；对于 IPv6 端点，DNS 系统创建 AAAA 记录。

      当你定义无选择算符的无头 Service 时，port 必须与 targetPort 匹配。

Service 会话保持

会话保持介绍

如果要确保来自特定客户端的连接每次都传递给同一个 Pod， 你可以通过设置 Service 的 .spec.sessionAffinity 为 ClientIP 来设置基于客户端 IP 地址的会话亲和性（默认为 None）。

你还可以通过设置 Service 的 .spec.sessionAffinityConfig.clientIP.timeoutSeconds 来设置最大会话粘性时间（默认值为 10800，即 3 小时）。

工作原理：

  1. 客户端首次访问服务，Service将请求转发给某个Pod，Service记录客户端和Pod的对应关系。
  2. 客户端的后续请求继续转发给同一个Pod。

适合有状态服务（如：Java Web、WebSocket、游戏服务）：

  • 登录状态不丢失
  • 购物车不丢失
  • 长连接稳定

准备测试环境

root@master30~/service 18:21:20# kubectl create deployment web --image=docker.io/library/httpd --replicas=2

#不写 --target-port 时，默认和 --port 数值相同
root@master30~/service 18:21:58# kubectl expose deployment web --port=80
root@master30~/service 18:23:39# for pod in $(kubectl get pods -o name | awk -F/ '{print$2}');do kubectl exec $pod -- bash -c "echo $pod > htdocs/index.html";done

root@master30~/service 18:27:45# for pod in $(kubectl get pods -o wide | awk '{print $6}'| grep -v IP); do curl -s $pod;done
web-6db76cb4fc-9h656
web-6db76cb4fc-dh9zc

root@master30~/service 18:25:00# kubectl get svc
NAME   TYPE        CLUSTER-IP      EXTERNAL-IP   PORT(S)   AGE
web    ClusterIP   10.99.187.128   <none>        80/TCP    2m7s

root@master30~/service 18:25:03# for i in {1..20};do curl -s 10.99.187.128:80 ;done |sort |uniq -c
     14 web-6db76cb4fc-9h656
      6 web-6db76cb4fc-dh9zc

设置会话保持

root@master30~/service 18:30:29#  kubectl patch svc web -p '{"spec":{"sessionAffinity":"ClientIP"}}'
service/web patched

# 再次访问：结果保持一致
root@master30~/service 18:31:28# for i in {1..20};do curl -s 10.99.187.128;done|sort |uniq -c
     20 web-6db76cb4fc-9h656

会话保持与 kube-proxy IPVS 的关系

1. service 里的 sessionAffinity 优先级最高

service 配置 ClientIP → kube-proxy 自动使用 IPVS 的 SH 算法

  • SH = Source Hashing 源地址哈希
  • 保证同一 IP → 同一 Pod
2. 如果 service 不配置 sessionAffinity

kube-proxy 就用ipvs scheduler 里设置的算法：

  • rr（轮询）
  • lc（最少连接）
  • wrr（加权轮询）

金丝雀发布

学习参考：金丝雀部署

环境准备：

root@master30~/service 18:33:42# mkdir web
root@master30~/service 18:35:25# echo hello nginx 1.28 > web/index28.html
root@master30~/service 18:35:48# echo hello nginx 1.29 > web/index29.html
root@master30~/service 18:36:08# kubectl create configmap web --from-file=./web
root@master30~/service 18:36:25# kubectl get configmaps web -o yaml |grep ^data -A4
data:
index28.html: |
hello nginx 1.28
index29.html: |
hello nginx 1.29

使用金丝雀发布部署应用新版本 ，同时保留用旧版本。 这样，新版本在完全发布之前也可以接收实时的生产流量。

例如，你可以使用 track 标签来区分不同的版本。

  1. 主要稳定的发行版将有一个 track 标签，其值为 stable：

    root@master30~/service 14:33:36# vim webapp-1.28.yaml

    apiVersion: apps/v1
kind: Deployment
metadata:
  labels:
    app: web
  name: web-28
spec:
  replicas: 10
  selector:
    matchLabels:
      app: web
      tier: frontend
      track: stable
  template:
    metadata:
      labels:
        app: web
        tier: frontend
        track: stable
    spec:
      containers:
      - image: docker.io/library/nginx:1.28
        name: nginx
        imagePullPolicy: IfNotPresent
        ports:
        - containerPort: 80
        volumeMounts:
        - name: webcontent
          mountPath: "/usr/share/nginx/html"
      volumes:
      - name: webcontent
        configMap:
          name: web
          items:
            - key: index28.html
              path: index.html

    root@master30~/service 14:34:04# kubectl apply -f webapp-1.28.yaml

  2. 创建 service

    root@master30~/service 14:34:21# vim webapp-svc.yaml

    apiVersion: v1
kind: Service
metadata:
  labels:
    app: web
  name: web
spec:
  ports:
  - port: 80
    protocol: TCP
    targetPort: 80
  selector:
    app: web
    tier: frontend

    root@master30~/service 14:34:39# kubectl apply -f webapp-svc.yaml
root@master30~/service 14:34:50# kubectl get all
NAME                          READY   STATUS    RESTARTS   AGE
pod/web-28-7c6ffdbbd7-568hk   1/1     Running   0          33s
pod/web-28-7c6ffdbbd7-5wkf5   1/1     Running   0          33s
pod/web-28-7c6ffdbbd7-6qq8m   1/1     Running   0          33s
pod/web-28-7c6ffdbbd7-6qs7q   1/1     Running   0          33s
pod/web-28-7c6ffdbbd7-cgcn7   1/1     Running   0          33s
pod/web-28-7c6ffdbbd7-kk9q7   1/1     Running   0          33s
pod/web-28-7c6ffdbbd7-p6bfk   1/1     Running   0          33s
pod/web-28-7c6ffdbbd7-qxf8x   1/1     Running   0          33s
pod/web-28-7c6ffdbbd7-tmz5n   1/1     Running   0          33s
pod/web-28-7c6ffdbbd7-vrd2j   1/1     Running   0          33s

NAME          TYPE        CLUSTER-IP    EXTERNAL-IP   PORT(S)   AGE
service/web   ClusterIP   10.96.93.14   <none>        80/TCP    4s

NAME                     READY   UP-TO-DATE   AVAILABLE   AGE
deployment.apps/web-28   10/10   10           10          33s

NAME                                DESIRED   CURRENT   READY   AGE
replicaset.apps/web-28-7c6ffdbbd7   10        10        10      33s

  3. 部署应用新版本。新的发行版将有一个 track 标签，其值为 canary：

    root@master30~/service 14:34:54# vim webapp-1.29.yaml

    apiVersion: apps/v1
kind: Deployment
metadata:
  labels:
    app: web
  name: web-29
spec:
  replicas: 1
  selector:
    matchLabels:
      app: web
      tier: frontend
      track: canary
  template:
    metadata:
      labels:
        app: web
        tier: frontend
        track: canary
    spec:
      containers:
      - image: docker.io/library/nginx:1.29
        name: nginx
        imagePullPolicy: IfNotPresent
        ports:
        - containerPort: 80
        volumeMounts:
        - name: webcontent
          mountPath: "/usr/share/nginx/html"
      volumes:
      - name: webcontent
        configMap:
          name: web
          items:
            - key: index29.html
              path: index.html

    root@master30~/service 14:35:07# kubectl apply -f webapp-1.29.yaml

    验证访问比例：

    root@master30~/service 14:37:58# for i in {1..50};do curl -s 10.96.93.14;done | sort -n | uniq -c
     43 hello nginx 1.28
      7 hello nginx 1.29

  4. 总pod数量不变的情况下，逐步减少旧版本和增加新版本副本数量,。

    root@master30~/service 14:38:09# kubectl scale  deployment web-28 --replicas=6
deployment.apps/web-28 scaled
root@master30~/service 14:38:41# kubectl scale deployment web-29 --replicas=4
deployment.apps/web-29 scaled
root@master30~/service 14:38:47# for i in {1..50};do curl -s 10.96.93.14;done | sort -n | uniq -c
     29 hello nginx 1.28
     21 hello nginx 1.29

kube-proxy

kube-proxy 是 K8s 服务于 Pod 网络的核心组件，负责实现 Service（服务） 到 Endpoint（后端 Pod） 的流量转发与负载均衡。

工作模式类型

kube-proxy 工作模式有以下几种：

模式地位性能适用场景特点
iptables默认模式中（服务数 < 1000）小规模集群、环境稳定依赖内核 netfilter，规则多时有性能损耗
IPVS推荐模式极高（服务数 10w+）中大规模生产环境基于内核 IPVS，哈希表查找，性能碾压 iptables
Userspace老旧/废弃低仅测试、兼容旧版全用户态转发，性能最差，K8s 1.25+ 已移除

✅ 生产环境必选 IPVS 模式，配合 Calico 网络插件，性能与稳定性最佳。

工作模式切换

查看工作模式

root@master30~/proxy 14:43:44# kubectl get cm -n kube-system kube-proxy -o yaml|grep mode
    mode: ""
# mode值为空。

# 查看pod/kube-proxy日志
root@master30~/proxy 14:55:55# kubectl get pods -n kube-system | grep kube-proxy
kube-proxy-bfsjb                             1/1     Running   3 (5h15m ago)    46h
kube-proxy-jqn26                             1/1     Running   2 (5h59m ago)    46h
kube-proxy-r4lzc                             1/1     Running   3 (5h15m ago)    46h

root@master30~/proxy 14:56:21# kubectl logs -n kube-system kube-proxy-bfsjb
......
I0629 01:41:25.081656       1 server_linux.go:165] "Using iptables Proxier"
......
#表明默认使用iptables

修改工作模式

# 步骤 1：编辑 kube-proxy 配置 ConfigMap
root@master30~/proxy 14:56:42# kubectl edit configmaps -n kube-system kube-proxy
# 找到并修改 `mode` 字段为相应的值例如ipvs。
....
    metricsBindAddress: ""
    mode: "ipvs"
....

# 步骤 2：重启 kube-proxy DaemonSet
root@master30~/proxy 14:57:24# kubectl rollout restart daemonset -n kube-system kube-proxy

# 步骤 3：验证模式切换
root@master30~/proxy 14:57:45# kubectl get pods -n kube-system | grep kube-proxy
kube-proxy-k2vtt                             1/1     Running   0                29s
kube-proxy-pmvkh                             1/1     Running   0                23s
kube-proxy-w77dq                             1/1     Running   0                18s

root@master30~/proxy 14:58:15# kubectl logs -n kube-system kube-proxy-k2vtt
......
I0629 06:57:50.280223       1 server_linux.go:233] "Using ipvs Proxier"
......
# 输出内容"Using ipvs Proxier"，表明使用ipvs

IPVS 模式

IPVS 代理模式基于 netfilter 回调函数，类似于 iptables 模式， 但它使用哈希表作为底层数据结构，在内核空间中生效。 这意味着 IPVS 模式下的 kube-proxy 比 iptables 模式下的 kube-proxy 重定向流量的延迟更低，同步代理规则时性能也更好。 与其他代理模式相比，IPVS 模式还支持更高的网络流量吞吐量。

IPVS 为将流量均衡到后端 Pod 提供了更多选择：

  • rr：轮询
  • lc：最少连接（打开连接数最少）
  • dh：目标地址哈希
  • sh：源地址哈希
  • sed：最短预期延迟
  • nq：最少队列

工作原理

kube-proxy 在宿主机内核中创建 IPVS 虚拟服务器，并将后端 Pod 作为 Real Server 注册。IPVS 基于 哈希表 存储转发规则，查找效率为 O(1)。流量到达后，IPVS 根据配置的调度算法直接将流量转发到后端 Pod，绕过了复杂的 iptables 规则链。

通信流程图：

访问 Service IP:Port

哈希查找+调度算法

直接路由/隧道

客户端 Pod

宿主机网卡

内核 IPVS 虚拟服务器

选择最优后端 Pod

后端 Pod IP:Port

响应流量直接返回

核心优势：

  • 支持多种高级调度算法（轮询 rr、加权轮询 wrr、最少连接 lc 等）。
  • 性能与服务数量无关，支持十万级服务规模。
  • 内置健康检查（与 K8s Endpoint 联动）。

验证原理

前置准备
  1. 已安装 IPVS 依赖（ipvsadm、ipset）并加载内核模块。
  2. kube-proxy 已切换为 IPVS 模式。
验证步骤
1. 创建测试资源
# 创建一个 nginx Deployment
root@master30~/proxy 15:00:20# kubectl create deployment web --image=docker.io/library/nginx --replicas=3
root@master30~/proxy 15:00:46# kubectl get pods -o wide | awk '{print$1,$6}'
NAME IP
web-759dfd9847-48vwp 10.224.96.211
web-759dfd9847-4l5xq 10.224.96.210
web-759dfd9847-pmlfg 10.224.128.41

# 设置 pod 主页内容为为自己的pod名称
root@master30~/proxy 15:03:33# for pod in $(kubectl get pods -o custom-columns=NAME:.metadata.name --no-headers);do kubectl exec $pod -- bash -c "echo $pod > /usr/share/nginx/html/index.html";done

# 验证主页内容
root@master30~/proxy 15:04:21# curl 10.224.96.211
web-759dfd9847-48vwp
root@master30~/service 15:04:36# curl 10.224.96.210
web-759dfd9847-4l5xq
root@master30~/service 15:04:40# curl 10.224.128.41
web-759dfd9847-pmlfg

# 创建Service
root@master30~/proxy 15:04:45# kubectl expose deployment web --port=80
root@master30~/service 15:05:15# kubectl get svc
NAME   TYPE        CLUSTER-IP     EXTERNAL-IP   PORT(S)   AGE
web    ClusterIP   10.98.45.238   <none>        80/TCP    3s
2. 查看 IPVS 规则

在任意集群节点执行，这里在master30节点执行，查看 kube-proxy 创建的 IPVS 虚拟服务：

# 列出虚拟服务器
root@master30~/proxy 15:05:42# ipvsadm -Lnt 10.98.45.238:80

看到类似如下的记录，其中 10.97.240.1 是 Service IP，80 是 Service Port：

Prot LocalAddress:Port Scheduler Flags
  -> RemoteAddress:Port           Forward Weight ActiveConn InActConn
TCP  10.98.45.238:80 rr
  -> 10.224.96.210:80             Masq    1      0          0
  -> 10.224.96.211:80             Masq    1      0          0
  -> 10.224.128.41:80             Masq    1      0          0

结论：IPVS 已成功为 Service 创建了虚拟服务，并绑定了所有后端 Pod。

3. 验证负载均衡效果

在集群内或外部访问 Service，观察流量是否分发到不同 Pod：

# 连续访问 60 次
root@master30~/proxy 15:05:59# for i in {1..60}; do curl -s 10.98.45.238; done| sort | uniq -c
     20 web-759dfd9847-48vwp
     20 web-759dfd9847-4l5xq
     20 web-759dfd9847-pmlfg

预期输出：会看到不同的 Pod 名称各自出现20次，证明 IPVS 轮询（rr）算法生效。

调度算法选择

  • rr（轮询）：简单均衡，节点配置一致时使用

  • wrr（加权轮询）：最推荐，适合通用业务、Web、API、网关。

    wrr 权重来源：1. 与 Pod 的 resources.requests.cpu/memory 成正比；2. ipvsadm命令临时设置，只适合临时测试。

  • lc（最少连接）：适合长连接、WebSocket、游戏服务

  • sh（源地址哈希）：配合 Service sessionAffinity: ClientIP 使用

更改调度算法：

root@master30~/proxy 18:46:16# kubectl edit configmaps kube-proxy -n kube-system
......
    ipvs:
      excludeCIDRs: null
      minSyncPeriod: 0s
      scheduler: "wrr"
.......
    mode: "ipvs"
.......

# 重启 kube-proxy
root@master30~/proxy 18:48:10# kubectl rollout restart ds kube-proxy -n kube-system

最佳配置

apiVersion: kubeproxy.config.k8s.io/v1alpha1
kind: KubeProxyConfiguration
mode: ipvs

# ========== IPVS 核心调优 ==========
ipvs:
  # 调度算法（生产推荐：rr / wrr / lc 三选一）
  scheduler: "rr"

  # 会话保持时间（秒），0 表示关闭
  tcpTimeout: 900
  tcpFinTimeout: 120
  udpTimeout: 300

  # 排除 127.0.0.1 负载均衡（必须开启）
  excludeCIDRs:
  - "127.0.0.1/32"

  # 严格arp，避免集群访问异常（必须开启）
  strictARP: true

# ========== 性能优化 ==========
# 最大打开文件数（高并发必调）
oomScoreAdj: -999

# Iptables 规则优化
iptables:
  minSyncPeriod: 5s
  syncPeriod: 30s

# 日志级别
logging:
  format: text
  verbosity: 2

iptables 模式

工作原理

kube-proxy 默认工作模式是 iptables 模式。

kube-proxy 监听 Service 和 Endpoint 变化，在宿主机内核中动态生成 iptables 规则链（KUBE-SERVICES、KUBE-SEP-XXX 等）。当流量进入宿主机时，通过 netfilter 框架逐条匹配 iptables 规则，实现 DNAT（目标地址转换）和负载均衡。

通信流程图：

访问 Service IP:Port

匹配 Service 规则

DNAT 转换

客户端 Pod

宿主机网卡

内核 iptables 规则链

随机选择后端 Endpoint IP

后端 Pod IP:Port

响应流量原路返回

核心缺点：

  • 每增加一个 Service 或 Endpoint，都会新增/修改 iptables 规则。
  • 当服务数量超过 1000 时，规则链膨胀，CPU 占用飙升，延迟显著增加。

验证原理

前置准备
  1. kube-proxy 已切换为 iptables 模式。
验证步骤
1. 创建测试资源

使用ipvs实验环境准备的资源。

2. 查看防火墙规则

步骤1：获取防火墙规则。

在任意集群节点执行，这里在master30节点执行，保存防火墙规则：

root@master30~/proxy 18:57:10# iptables-save > iptables.list

步骤2：分析 svc-nginx 规则。

root@master30~/proxy 18:57:20# cat iptables.list | grep 10.100.146.210
-A KUBE-SERVICES -d 10.100.146.210/32 -p tcp -m comment --comment "proxy/web cluster IP" -m tcp --dport 80 -j KUBE-SVC-HYZAVZ3O2MWWAV4H
-A KUBE-SVC-HYZAVZ3O2MWWAV4H ! -s 10.224.0.0/16 -d 10.100.146.210/32 -p tcp -m comment --comment "proxy/web cluster IP" -m tcp --dport 80 -j KUBE-MARK-MASQ

分析防火墙规则：

  • 第一条防火墙规则：在 nat 表 KUBE-SERVICES 服务总入口链中，匹配目的 IP 为 10.100.146.210/32、协议 TCP、目的端口 80 的报文，通过注释标识为 services/web 的 ClusterIP 服务，并跳转至该服务专属调度链 KUBE-SVC-7D76YWGERGEPC4GC。
  • 第二条防火墙规则：则在服务专属链 KUBE-SVC-7D76YWGERGEPC4GC 中，匹配源地址非 Pod 网段 10.224.0.0/16、目的 IP 10.100.146.210/32、协议 TCP、目的端口 80 的报文，注释标识为 services/web cluster IP，并跳转至 KUBE-MARK-MASQ 进行 SNAT 标记。

步骤3：进一步追踪链路KUBE-SVC-7D76YWGERGEPC4GC。

root@master30~/proxy 18:57:28# cat iptables.list | grep KUBE-SVC-HYZAVZ3O2MWWAV4H
:KUBE-SVC-HYZAVZ3O2MWWAV4H - [0:0]
-A KUBE-SERVICES -d 10.100.146.210/32 -p tcp -m comment --comment "proxy/web cluster IP" -m tcp --dport 80 -j KUBE-SVC-HYZAVZ3O2MWWAV4H
-A KUBE-SVC-HYZAVZ3O2MWWAV4H ! -s 10.224.0.0/16 -d 10.100.146.210/32 -p tcp -m comment --comment "proxy/web cluster IP" -m tcp --dport 80 -j KUBE-MARK-MASQ
-A KUBE-SVC-HYZAVZ3O2MWWAV4H -m comment --comment "proxy/web -> 10.224.128.52:80" -m statistic --mode random --probability 0.33333333349 -j KUBE-SEP-3LRBFIGASWDPBT4E
-A KUBE-SVC-HYZAVZ3O2MWWAV4H -m comment --comment "proxy/web -> 10.224.96.224:80" -m statistic --mode random --probability 0.50000000000 -j KUBE-SEP-D4WMI4Y32L4HSAG6
-A KUBE-SVC-HYZAVZ3O2MWWAV4H -m comment --comment "proxy/web -> 10.224.96.227:80" -j KUBE-SEP-SSVXLUUMYIJJ45UF

分析防火墙规则：

  • **第一条防火墙规则：**已分析过。
  • **第二条防火墙规则：**已分析过。
  • **第三条防火墙规则：**在服务调度链 KUBE-SVC-7D76YWGERGEPC4GC 中，对所有协议与地址的访问报文，以 1/3 随机概率 将其跳转至后端端点链 KUBE-SEP-3LRBFIGASWDPBT4E，注释标识该端点对应 services/web 服务后端 10.224.113.164:80。
  • **第四条防火墙规则：**在服务调度链 KUBE-SVC-7D76YWGERGEPC4GC 中，对未被前序规则匹配的报文，以 剩余流量 1/2 随机概率（总概率 1/3）跳转至后端端点链 KUBE-SEP-D4WMI4Y32L4HSAG6，注释标识对应 services/web 后端 10.224.113.165:80。
  • **第五条防火墙规则：**在服务调度链 KUBE-SVC-7D76YWGERGEPC4GC 中，对未被前序概率规则匹配的报文，无条件跳转（总概率 1/3）至后端端点链 KUBE-SEP-SSVXLUUMYIJJ45UF，注释标识对应 services/web 后端 10.224.19.38:80。

步骤4：进一步追踪上面最后三条规则目标链路。

root@master30~/proxy 18:59:02# cat iptables.list | grep -e KUBE-SEP-3LRBFIGASWDPBT4E -e KUBE-SEP-D4WMI4Y32L4HSAG6 -e KUBE-SEP-SSVXLUUMYIJJ45UF | grep DNAT
-A KUBE-SEP-3LRBFIGASWDPBT4E -p tcp -m comment --comment "proxy/web" -m tcp -j DNAT --to-destination 10.224.128.52:80
-A KUBE-SEP-D4WMI4Y32L4HSAG6 -p tcp -m comment --comment "proxy/web" -m tcp -j DNAT --to-destination 10.224.96.224:80
-A KUBE-SEP-SSVXLUUMYIJJ45UF -p tcp -m comment --comment "proxy/web" -m tcp -j DNAT --to-destination 10.224.96.227:80

分析防火墙规则：

  • 第一条防火墙规则：在后端端点链 KUBE-SEP-3LRBFIGASWDPBT4E 中，匹配TCP 协议报文，注释标识为 services/web 服务，执行DNAT 目标地址转换，将报文目的地址修改为 10.224.128.52:80。
  • 第二条防火墙规则：在后端端点链 KUBE-SEP-D4WMI4Y32L4HSAG6 中，匹配TCP 协议报文，注释标识为 services/web 服务，执行DNAT 目标地址转换，将报文目的地址修改为 10.224.96.224:80。
  • 第三条防火墙规则：在后端端点链 KUBE-SEP-SSVXLUUMYIJJ45UF 中，匹配TCP 协议报文，注释标识为 services/web 服务，执行DNAT 目标地址转换，将报文目的地址修改为 10.224.96.227:80。
3. 总结

全链路流程图：

  1. 入口：访问 ClusterIP
  2. 分流：进入 KUBE-SERVICES
  3. 服务调度：进入 KUBE-SVC-XXX（SNAT + 负载均衡）
  4. 端点转发：进入 KUBE-SEP-XXX
  5. 最终到达：后端 Pod

客户端访问
ClusterIP: 10.103.143.120:80

PREROUTING
nat 表

KUBE-SERVICES
服务总入口

KUBE-SVC-7D76YWGERGEPC4GC
services/web 专属调度链

SNAT 标记：非 Pod 网段流量
→ KUBE-MARK-MASQ

概率 1/3 负载均衡

概率 1/3 负载均衡

默认 1/3 负载均衡

KUBE-SEP-HYZM2VM7RCC7M2HX

KUBE-SEP-CHPZVFCOFL4YLCYM

KUBE-SEP-HM7RLUR2RXSQ3D6F

DNAT 转发
→ Pod: 10.224.113.164:80

DNAT 转发
→ Pod: 10.224.113.165:80

DNAT 转发
→ Pod: 10.224.19.38:80

Userspace 模式(下架)

kube-proxy 在用户态监听 Service 端口，接收流量后，通过本地代理转发到后端 Pod。全用户态处理，性能极低。

通信流程图：

访问 Service IP:Port

客户端 Pod

宿主机 kube-proxy 用户态进程

负载均衡选择后端 Pod

建立连接转发流量

后端 Pod

现状：K8s 1.25+ 版本已彻底移除该模式，不再支持。

标地址转换**，将报文目的地址修改为 10.224.96.227:80。

3. 总结

全链路流程图：

  1. 入口：访问 ClusterIP
  2. 分流：进入 KUBE-SERVICES
  3. 服务调度：进入 KUBE-SVC-XXX（SNAT + 负载均衡）
  4. 端点转发：进入 KUBE-SEP-XXX
  5. 最终到达：后端 Pod

客户端访问
ClusterIP: 10.103.143.120:80

PREROUTING
nat 表

KUBE-SERVICES
服务总入口

KUBE-SVC-7D76YWGERGEPC4GC
services/web 专属调度链

SNAT 标记：非 Pod 网段流量
→ KUBE-MARK-MASQ

概率 1/3 负载均衡

概率 1/3 负载均衡

默认 1/3 负载均衡

KUBE-SEP-HYZM2VM7RCC7M2HX

KUBE-SEP-CHPZVFCOFL4YLCYM

KUBE-SEP-HM7RLUR2RXSQ3D6F

DNAT 转发
→ Pod: 10.224.113.164:80

DNAT 转发
→ Pod: 10.224.113.165:80

DNAT 转发
→ Pod: 10.224.19.38:80

Userspace 模式(下架)

kube-proxy 在用户态监听 Service 端口，接收流量后，通过本地代理转发到后端 Pod。全用户态处理，性能极低。

通信流程图：

访问 Service IP:Port

客户端 Pod

宿主机 kube-proxy 用户态进程

负载均衡选择后端 Pod

建立连接转发流量

后端 Pod

现状：K8s 1.25+ 版本已彻底移除该模式，不再支持。

Kubernetes Ingress

环境准备

root@master30~/proxy 19:08:27# kubectl create ns ingress
root@master30~/proxy 19:08:51# kubectl config set-context --current --namespace ingress

Ingress (入口网关)介绍

核心定位：Kubernetes 中用于七层（HTTP/HTTPS）路由的资源，是集群的 “统一入口”。

  • 核心问题：Service 仅支持四层转发，无法实现 “域名 / 路径路由”（如shturl.cc/fDudG转发到 A 服务，shturl.cc/NyXjX转发到 B 服务）；

  • 核心功能：

    • 为多个 Service 提供统一的外部访问入口（域名 / 端口）；

    • 实现七层路由规则（基于域名、URL 路径转发到不同 Service）；

    • 支持 HTTPS、SSL 终止、流量控制、认证等七层能力；

  • 关键依赖：Ingress 是 “规则定义”，必须配合Ingress Controller(Ingress控制器)（如 Nginx Ingress、Traefik）才能生效（Ingress Controller 是运行在集群中的 Pod，实际执行路由规则）, Ingress 控制器 负责完成 Ingress 的工作，通常会使用某个负载均衡器、边缘路由器或其他前端来帮助处理流量。；

  • 局限：仅处理七层流量，底层仍依赖 Service 提供 Pod 的负载均衡能力。

下面是 Ingress 的一个简单示例，可将所有流量都发送到同一 Service：

在这里插入图片描述

Ingress 不会随意公开端口或协议， 将 HTTP 和 HTTPS 以外的服务开放到 Internet 时，通常使用 Service.Type=NodePort 或 Service.Type=LoadBalancer 类型的 Service。

#Ingress、proxy、service三者之间关系
外部请求 → Ingress（七层路由） → Service（四层负载均衡） → kube-proxy（节点转发） → Pod
步骤 1：Ingress 接收外部流量
  • 外部客户端通过域名（如shturl.cc/v）访问集群，流量首先到达Ingress Controller（如 Nginx Pod）；
  • Ingress 根据配置的七层规则（如域名 / 路径），将流量转发到对应的 Service（如 web-service）。
步骤 2：Service 提供固定入口
  • Service 为一组 Web Pod 提供固定的 ClusterIP（如 10.103.19.150:8080）；
  • 屏蔽 Pod 的动态变化（即使 Pod 重建，Service IP / 端口不变）。
步骤 3：kube-proxy 实现流量转发
  • 每个节点的 kube-proxy 已同步 Service 和后端 Pod 的 Endpoints 信息；
  • kube-proxy 通过 iptables/IPVS 规则，将 Service IP 的流量负载均衡转发到后端的 Pod IP（如 10.224.193.67:80）；
  • 最终流量到达具体的 Pod，完成请求。

Ingress 控制器

为了让 Ingress 资源工作，集群必须有一个正在运行的 Ingress 控制器。

与作为 kube-controller-manager 可执行文件的一部分运行的其他类型的控制器不同， Ingress 控制器不是随集群自动启动的。 基于此页面，你可选择最适合你的集群的 ingress 控制器实现。

Kubernetes 作为一个项目，目前支持和维护 AWS、 GCE 和 Nginx Ingress 控制器。

ingress-nginx 工作流程

本次实验使用 ingress-nginx 控制器。

项目地址：ingress-nginx。

ingress-nginx 工作流程：

  1. 先部署 Ingress Controller 实体（相当于前端–Nginx）
  2. 然后再创建 Ingress （k8s 资源–相当于 Nginx 配置）
  3. Ingress Controller 与 kubernetes apiserver交互，动态的获取集群中的ingress规则。解析ingress规则，生成proxy服务的配置，比如nginx配置。
  4. 再写到 ingress proxy 的pod中，如果pod运行的是nginx服务，就生成nginx配置，并放到/etc/nginx/nginx.conf中。
  5. 然后reload服务。

Ingress 本质是7层http/https代理。

ingress-nginx 部署前提

项目地址： kubernetes/ingress-nginx

  1. 本次环境使用负载均衡器处理流量，提前部署好 LoadBalancer，例如 metallb。

  2. 你必须部署一个 Ingress 控制器 才能满足 Ingress 的要求，例如 ingress-nginx。

ingress-nginx 版本

SupportedIngress-NGINX versionk8s supported versionAlpine VersionNginx VersionHelm Chart Version
🔄v1.11.21.30, 1.29, 1.28, 1.27, 1.263.20.01.25.54.11.2
🔄v1.11.11.30, 1.29, 1.28, 1.27, 1.263.20.01.25.54.11.1
🔄v1.11.01.30, 1.29, 1.28, 1.27, 1.263.20.01.25.54.11.0
🔄v1.10.21.30, 1.29, 1.28, 1.27, 1.263.20.01.25.54.10.2
🔄v1.10.11.30, 1.29, 1.28, 1.27, 1.263.19.11.25.34.10.1
🔄v1.10.01.29, 1.28, 1.27, 1.263.19.11.25.34.10.0
…

ingress-nginx 部署

部署方法参考：https://kubernetes.github.io/ingress-nginx/deploy/

root@master30~ 16:50:23# wget http://192.168.42.200/course-materials/softwares/stage03/ingress-nginx-controller-v1.11.2.tar.gz
root@master30~ 16:50:28# tar -xf ingress-nginx-controller-v1.11.2.tar.gz

ingress-nginx 部署文件 deploy.yaml文件包涵4个部分：

  1. 创建一个独立的命名空间 ingress-nginx

  2. 创建 ConfigMap

    ConfigMap是存储通用的配置变量的，类似于配置文件，使用户可以将分布式系统中用于不同模块的环境变量统一到一个对象中管理；而它与配置文件的区别在于它是存在集群的“环境”中的，并且支持K8S集群中所有通用的操作调用方式。

    创建pod时，对configmap进行绑定，pod内的应用可以直接引用ConfigMap的配置。相当于configmap为应用/运行环境封装配置。

    pod使用ConfigMap，通常用于：设置环境变量的值、设置命令行参数、创建配置文件。

  3. Ingress的RBAC授权的控制，其创建了Ingress用到的ServiceAccount、ClusterRole、Role、RoleBinding、ClusterRoleBinding

  4. 创建ingress-controller。前面提到过，ingress-controller的作用是将新加入的Ingress进行转化为httpd的配置

# 查看资源使用的镜像
root@master30~ 16:50:34# grep image: ingress-nginx-controller-v1.11.2/deploy/static/provider/cloud/deploy.yaml|uniq
        image: registry.k8s.io/ingress-nginx/controller:v1.11.2@sha256:d5f8217feeac4887cb1ed21f27c2674e58be06bd8f5184cacea2a69abaf78dce
        image: registry.k8s.io/ingress-nginx/kube-webhook-certgen:v1.4.3@sha256:a320a50cc91bd15fd2d6fa6de58bd98c1bd64b9a6f926ce23a600d87043455a3

# 按需修改镜像
root@master30~ 16:50:50# sed -i 's/registry.k8s.io/hub.laoma.cloud/g' ingress-nginx-controller-v1.11.2/deploy/static/provider/cloud/deploy.yaml
root@master30~ 16:50:58# sed -i 's/@sha256.*//' ingress-nginx-controller-v1.11.2/deploy/static/provider/cloud/deploy.yaml

# 创建 Ingress
root@master30~ 16:51:06# kubectl apply -f ingress-nginx-controller-v1.11.2/deploy/static/provider/cloud/deploy.yaml

注意：registry.k8s.io 镜像仓库中镜像无法直接下载，需要配置加速。我们也可以从 这里 获取。

查看部署的资源

root@master30~ 17:02:15# kubectl get all -n ingress-nginx
NAME                                            READY   STATUS      RESTARTS   AGE
pod/ingress-nginx-admission-create-w4pjf        0/1     Completed   0          11m
pod/ingress-nginx-admission-patch-tw68k         0/1     Completed   0          11m
pod/ingress-nginx-controller-8659885ffd-9q49h   1/1     Running     0          11m

NAME                                         TYPE           CLUSTER-IP       EXTERNAL-IP   PORT(S)                      AGE
service/ingress-nginx-controller             LoadBalancer   10.102.232.108   10.1.8.40     80:30455/TCP,443:31350/TCP   11m
service/ingress-nginx-controller-admission   ClusterIP      10.105.57.209    <none>        443/TCP                      11m

NAME                                       READY   UP-TO-DATE   AVAILABLE   AGE
deployment.apps/ingress-nginx-controller   1/1     1            1           11m

NAME                                                  DESIRED   CURRENT   READY   AGE
replicaset.apps/ingress-nginx-controller-8659885ffd   1         1         1       11m

NAME                                       STATUS     COMPLETIONS   DURATION   AGE
job.batch/ingress-nginx-admission-create   Complete   1/1           10s        11m
job.batch/ingress-nginx-admission-patch    Complete   1/1           11s        11m

Ingress 规则实践

Ingress 规则说明

规则示例

  • 示例1： 没有rule的Ingress规则

    指定一个没有rule的defaultBackend的方式，所有发送给该IP的流量都被转发到了defaultBackend 所列的Kubernetes service上。

    apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
  name: test-ingress
spec:
  defaultBackend:
    service: 
      name: testsvc
      port: 
        number: 80

  • 示例2： 虚拟主机，一个域名对应一个path

    apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
  name: myingress
spec:
  ingressClassName: nginx
  rules:
  - host: www.hgq.cloud
    http:
      paths:
      - path: /
        pathType: Prefix
        backend:
          service: 
            name: www
            port: 
              number: 80
  - host: web.hgq.cloud
    http:
      paths:
      - path: /
        pathType: Prefix
        backend:
          service: 
            name: web
            port: 
              number: 80

  • 示例3： 一个域名对应对多个path

    apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
  name: myingress
spec:
  ingressClassName: nginx
  rules:
  - host: www.laoma.cloud
    http:
      paths:
      - path: /
        pathType: Prefix
        backend:
          service: 
            name: web
            port: 
              number: 80
      - path: /laoma
        pathType: Prefix
        backend:
          service: 
            name: web
            port: 
              number: 80

  • 示例4： https 透传

    如果后端的svc是https流量，系统ingress直接转发https流量给后端service，则需要配置透传 TLS。

    apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
  name: myingress
  annotations:
    # 关键：透传 TLS，Ingress 不解密
    nginx.ingress.kubernetes.io/ssl-passthrough: "true"
    nginx.ingress.kubernetes.io/backend-protocol: "HTTPS"
spec:
  ingressClassName: nginx
  rules:
  - host: www.laoma.cloud
    http:
      paths:
      - path: /
        pathType: Prefix
        backend:
          service: 
            name: web
            port: 
              number: 443

配置说明

  • 跟Kubernetes的其他配置一样，ingress的配置也需要apiVersion，kind和metadata字段。

  • Ingress spec 中包含配置一个loadbalancer或proxy server的所有信息。最重要的是，它包含了一个匹配所有入站请求的规则列表。目前ingress只支持http规则。

  • 每条http规则包含以下信息：

    • 一个host配置项（比如www.laoma.cloud，默认是*）
    • paths列表（比如：/laoma），每个path都关联一个backend，service:port的组合，比如web:80。在loadbalancer将流量转发到backend之前，所有的入站请求都要先匹配host和path。
IngressClass

Ingressclass是 K8s 集群级 API 资源，用来给控制器打标识、建立绑定关系。

Ingress 可以由不同的控制器实现，通常使用不同的配置。 每个 Ingress 应当指定一个类，也就是一个对 IngressClass 资源的引用。 IngressClass 资源包含额外的配置，其中包括应当实现该类的控制器名称。

你可以将一个特定的 IngressClass 标记为集群默认 Ingress 类。 将某个 IngressClass 资源的 ingressclass.kubernetes.io/is-default-class 注解设置为 true 将确保新的未指定 ingressClassName 字段的 Ingress 能够被赋予这一默认 IngressClass.

路径匹配

Ingress 中的每个路径都需要有对应的路径类型（Path Type）。未明确设置 pathType 的路径无法通过合法性检查。

当前支持的路径类型有三种：

  • Prefix：基于以 / 分隔的 URL 路径前缀匹配。匹配区分大小写， 并且对路径中各个元素逐个执行匹配操作。 路径元素指的是由 / 分隔符分隔的路径中的标签列表。 如果每个 p 都是请求路径 p 的元素前缀，则请求与路径 p 匹配。
  • Exact：精确匹配 URL 路径，且区分大小写。
  • ImplementationSpecific：对于这种路径类型，匹配方法取决于 IngressClass。 具体实现可以将其作为单独的 pathType 处理或者作与 Prefix 或 Exact 类型相同的处理。

示例

类型路径请求路径匹配与否？
Prefix/（所有路径）是
Exact/foo/foo是
Exact/foo/bar否
Exact/foo/foo/否
Exact/foo//foo否
Prefix/foo/foo, /foo/是
Prefix/foo//foo, /foo/是
Prefix/aaa/bb/aaa/bbb否
Prefix/aaa/bbb/aaa/bbb是
Prefix/aaa/bbb//aaa/bbb是，忽略尾部斜线
Prefix/aaa/bbb/aaa/bbb/是，匹配尾部斜线
Prefix/aaa/bbb/aaa/bbb/ccc是，匹配子路径
Prefix/aaa/bbb/aaa/bbbxyz否，字符串前缀不匹配
Prefix/, /aaa/aaa/ccc是，匹配 /aaa 前缀
Prefix/, /aaa, /aaa/bbb/aaa/bbb是，匹配 /aaa/bbb 前缀
Prefix/, /aaa, /aaa/bbb/ccc是，匹配 / 前缀
Prefix/aaa/ccc否，使用默认后端
混合/foo (Prefix), /foo (Exact)/foo是，优选 Exact 类型

多重匹配

在某些情况下，Ingress 中会有多条路径与同一个请求匹配。这时匹配路径最长者优先。 如果仍然有两条同等的匹配路径，则精确路径类型优先于前缀路径类型。

主机名匹配

主机名可以是精确匹配（例如 “foo.bar.com”）或者使用通配符匹配 （例如 “*.foo.com”）。 精确匹配要求 HTTP host 头部字段与 host 字段值完全匹配。 通配符匹配则要求 HTTP host 头部字段与通配符规则中的后缀部分相同。

主机host 头部匹配与否？
*.foo.combar.foo.com基于相同的后缀匹配
*.foo.combaz.bar.foo.com不匹配，通配符仅覆盖了一个 DNS 标签
*.foo.comfoo.com不匹配，通配符仅覆盖了一个 DNS 标签

Ingress 规则实践

以下主要讲解生产环境 Ingress-Nginx 常用规则。

环境准备
站点 webapp01
# 创建Deployment
root@master30~ 17:33:39# kubectl create deployment webapp01 --image=docker.io/library/httpd --replicas=2

# 查看pod标签
root@master30~ 17:59:20# kubectl get pods -L app
NAME                        READY   STATUS    RESTARTS   AGE    APP
webapp01-57b8567f7c-68q4t   1/1     Running   0          3m9s   webapp01
webapp01-57b8567f7c-hhzxp   1/1     Running   0          3m9s   webapp01

# 准备pod主页内容
root@master30~ 17:59:21# kubectl exec webapp01-57b8567f7c-68q4t -- bash -c "echo hello webapp01 pod1 > htdocs/index.html"
root@master30~ 18:00:19# kubectl exec webapp01-57b8567f7c-hhzxp -- bash -c "echo hello webapp01 pod2 > htdocs/index.html"

#创建svc
root@master30~ 18:00:38# kubectl expose deployment webapp01 --port=80 --target-port=80
站点 webapp02
# 创建Deployment
root@master30~ 18:01:06# kubectl create deployment webapp02 --image=docker.io/library/httpd --replicas=2

# 查看pod标签
root@master30~ 18:11:15# kubectl get pods -L app| grep webapp02
webapp02-598c447b5b-d8cbr   1/1     Running   0          20s   webapp02
webapp02-598c447b5b-nmjlp   1/1     Running   0          20s   webapp02

# 准备pod主页内容
root@master30~ 18:25:44# kubectl exec -it webapp02-598c447b5b-d8cbr -- bash -c "
echo hello webapp02 pod1 > htdocs/index.html
mkdir htdocs/games
echo hello webapp02 game1 > htdocs/games/index.html"

root@master30~ 18:26:09# kubectl exec -it webapp02-598c447b5b-nmjlp -- bash -c "
echo hello webapp02 pod2 > htdocs/index.html
mkdir htdocs/games
echo hello webapp02 game2 > htdocs/games/index.html"


root@master30~ 18:27:07# kubectl expose deployment webapp02 --port=80 --target-port=80
一、基础通用规则
1. 多域名虚拟主机（多 host 路由）

场景：多个域名转发不同业务

root@master30~ 18:27:30# vim ingress.yaml

apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
  name: multi-host-ingress
spec:
  # 这里一定要指定ingressClassName为nginx
  ingressClassName: nginx
  rules:
  - host: webapp01.hgq.cloud
    http:
      paths:
      - path: /
        pathType: Prefix
        backend:
          service: 
            name: webapp01
            port: 
              number: 80
  - host: webapp02.hgq.cloud
    http:
      paths:
      - path: /
        pathType: Prefix
        backend:
          service: 
            name: webapp02
            port: 
              number: 80

root@master30~ 18:30:21# kubectl apply -f ingress.yaml
root@master30~ 18:30:44# kubectl describe ingress multi-host-ingress
Name:             multi-host-ingress
Labels:           <none>
Namespace:        scheduler
Address:
Ingress Class:    nginx
Default backend:  <default>
Rules:
  Host                Path  Backends
  ----                ----  --------
  webapp01.hgq.cloud
                      /   webapp01:80 (10.224.128.14:80,10.224.96.242:80)
  webapp02.hgq.cloud
                      /   webapp02:80 (10.224.128.17:80,10.224.96.244:80)
Annotations:          <none>
Events:
  Type    Reason  Age   From                      Message
  ----    ------  ----  ----                      -------
  Normal  Sync    29s   nginx-ingress-controller  Scheduled for sync

访问验证

# 修改www.hgq.cloud解析，确保客户端能解析该名称
# 如果有多个域名，建议使用配置DNS-wild匹配
root@master30~ 18:30:55# echo '10.1.8.40 webapp01.hgq.cloud' >> /etc/hosts
root@master30~ 18:32:03# echo '10.1.8.40 webapp02.hgq.cloud' >> /etc/hosts

# 注意： 这里我们直接访问域名，没有加端口号
root@master30~ 18:41:34# curl webapp01.hgq.cloud
hello webapp01 pod1
root@master30~ 18:41:40# curl webapp01.hgq.cloud
hello webapp01 pod2
root@master30~ 18:41:57# curl webapp02.hgq.cloud
hello webapp02 pod1
root@master30~ 18:42:01# curl webapp02.hgq.cloud
hello webapp02 pod2

删除 ingress

root@master30~ 18:42:03# kubectl delete ingress multi-host-ingress
2. 同一域名多路径路由（path 分流）

场景：一个域名，不同路径转发给不同微服务

root@master30~ 18:42:57# vim ingress.yaml

apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
  name: multi-path-ingress
spec:
  ingressClassName: nginx
  rules:
  - host: www.hgq.cloud
    http:
      paths:
      - path: /
        pathType: Prefix
        backend:
          service: 
            name: webapp01
            port: 
              number: 80
      - path: /games
        pathType: Prefix
        backend:
          service: 
            name: webapp02
            port: 
              number: 80

root@master30~ 18:43:43# kubectl apply -f ingress.yaml
root@master30~ 18:43:47# kubectl describe ingress
Name:             multi-path-ingress
Labels:           <none>
Namespace:        scheduler
Address:          10.1.8.40
Ingress Class:    nginx
Default backend:  <default>
Rules:
  Host           Path  Backends
  ----           ----  --------
  www.hgq.cloud
                 /        webapp01:80 (10.224.128.14:80,10.224.96.242:80)
                 /games   webapp02:80 (10.224.128.17:80,10.224.96.244:80)
Annotations:     <none>
Events:
  Type    Reason  Age               From                      Message
  ----    ------  ----              ----                      -------
  Normal  Sync    1s (x2 over 19s)  nginx-ingress-controller  Scheduled for sync

访问验证

# 修改www.laoma.cloud解析，确保客户端能解析该名称
# 如果有多个域名，建议使用配置DNS-wild匹配
[root@client ~]# echo '10.1.8.40 www.hgq.cloud' >> /etc/hosts

# 注意： 这里我们直接访问域名，没有加端口号
root@master30~ 18:46:08# curl www.hgq.cloud
hello webapp01 pod1
root@master30~ 18:46:10# curl www.hgq.cloud
hello webapp01 pod2
root@master30~ 18:46:10# curl www.hgq.cloud/games/
hello webapp02 game1
root@master30~ 18:46:28# curl www.hgq.cloud/games/
hello webapp02 game2

删除 ingress

root@master30~ 18:46:29# kubectl delete ingress multi-path-ingress
二、生产核心：路径重写
3. 路径裁剪（等价 Nginx proxy_pass /）

场景：前端访问 /api/xxx，后端实际只识别 /xxx，剥离 /api 前缀

root@master30~ 18:46:39# vim ingress.yaml

apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
  name: multi-path-ingress
  annotations:
    nginx.ingress.kubernetes.io/use-regex: "true"
    nginx.ingress.kubernetes.io/rewrite-target: /$1
spec:
  ingressClassName: nginx
  rules:
  - host: www.hgq.cloud
    http:
      paths:
      - path: /webapp01/(.*)
        pathType: ImplementationSpecific
        backend:
          service: 
            name: webapp01
            port: 
              number: 80
      - path: /webapp02/(.*)
        pathType: ImplementationSpecific
        backend:
          service: 
            name: webapp02
            port: 
              number: 80

root@master30~ 18:47:18# kubectl apply -f ingress.yaml
root@master30~ 18:47:30# kubectl describe ingress
Name:             multi-path-ingress
Labels:           <none>
Namespace:        scheduler
Address:
Ingress Class:    nginx
Default backend:  <default>
Rules:
  Host           Path  Backends
  ----           ----  --------
  www.hgq.cloud
                 /webapp01/(.*)   webapp01:80 (10.224.128.14:80,10.224.96.242:80)
                 /webapp02/(.*)   webapp02:80 (10.224.128.17:80,10.224.96.244:80)
Annotations:     nginx.ingress.kubernetes.io/rewrite-target: /$1
                 nginx.ingress.kubernetes.io/use-regex: true
Events:
  Type    Reason  Age   From                      Message
  ----    ------  ----  ----                      -------
  Normal  Sync    10s   nginx-ingress-controller  Scheduled for sync

访问验证

root@master30~ 18:47:40# root@master30~ 18:47:40#
hello webapp01 pod1
root@master30~ 18:48:22# curl www.hgq.cloud/webapp01/
hello webapp01 pod1
root@master30~ 18:48:25# curl www.hgq.cloud/webapp02/
hello webapp02 pod1
root@master30~ 18:48:50# curl www.hgq.cloud/webapp02/
hello webapp02 pod2

删除 ingress

root@master30~ 18:48:52# kubectl delete ingress multi-path-ingress
三、HTTPS 强制 & TLS 证书
4. 绑定 TLS 证书 + 强制 HTTPS

环境准备

root@master30~ 18:49:10# openssl genrsa -out www.key 2048
root@master30~ 18:49:26# openssl req -new -key www.key -out www.csr -subj "/C=CN/ST=JS/L=NJ/O=LM/OU=DEVOPS/CN=www.hgq.cloud/emailAddress=webadmin@hgq.cloud"
root@master30~ 18:49:46# openssl x509 -req -days 3650 -in www.csr -signkey www.key -out www.crt
root@master30~ 18:49:51# kubectl create secret tls www-tls --cert=./www.crt --key=./www.key

生产标配：80 自动跳转 443，加密访问

root@master30~ 18:49:55# vim ingress.yaml

apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
  name: tls-ingress
  annotations:
    nginx.ingress.kubernetes.io/ssl-redirect: "true"
    nginx.ingress.kubernetes.io/force-ssl-redirect: "true"
spec:
  ingressClassName: nginx
  tls:
  - hosts:
      - www.hgq.cloud
    secretName: www-tls
  rules:
  - host: www.hgq.cloud
    http:
      paths:
      - path: /
        pathType: Prefix
        backend:
          service:
            name: webapp01
            port: 
              number: 80

root@master30~ 18:50:39# kubectl apply -f ingress.yaml
root@master30~ 18:50:50# kubectl describe ingress tls-ingress
Name:             tls-ingress
Labels:           <none>
Namespace:        scheduler
Address:
Ingress Class:    nginx
Default backend:  <default>
TLS:
  www-tls terminates www.hgq.cloud
Rules:
  Host           Path  Backends
  ----           ----  --------
  www.hgq.cloud
                 /   webapp01:80 (10.224.128.14:80,10.224.96.242:80)
Annotations:     nginx.ingress.kubernetes.io/force-ssl-redirect: true
                 nginx.ingress.kubernetes.io/ssl-redirect: true
Events:
  Type    Reason  Age   From                      Message
  ----    ------  ----  ----                      -------
  Normal  Sync    6s    nginx-ingress-controller  Scheduled for sync

访问验证

# 使用 -L 跟随 301/302/307/308 所有重定向
root@master30~ 18:51:36# curl -Lk http://www.hgq.cloud/
hello webapp01 pod1

# 访问https站点
root@master30~ 18:51:48# curl -k https://www.hgq.cloud/
hello webapp01 pod1

删除 ingress

root@master30~ 18:51:49# kubectl delete ingress tls-ingress
四、限流、防刷、超时优化
5. 连接数限流、单IP限速
annotations:
  # 单IP最大并发连接
  nginx.ingress.kubernetes.io/limit-connections: "50"
  # 单IP每秒请求数
  nginx.ingress.kubernetes.io/limit-rps: "20"
6. 自定义超时时间
annotations:
  nginx.ingress.kubernetes.io/proxy-connect-timeout: "10"
  nginx.ingress.kubernetes.io/proxy-read-timeout: "60"
  nginx.ingress.kubernetes.io/proxy-send-timeout: "60"
五、跨域配置（前后端分离必备）
7. 全局跨域放行
annotations:
  nginx.ingress.kubernetes.io/enable-cors: "true"
  nginx.ingress.kubernetes.io/cors-allow-origin: "*"
  nginx.ingress.kubernetes.io/cors-allow-methods: "GET,POST,PUT,DELETE,OPTIONS"
六、白名单访问控制（内网 / 后台系统）
8. 限制指定IP段访问

场景：管理后台、内部系统，只允许公司内网IP

annotations:
  # 只放行 10.1.8.0/24 网段
  nginx.ingress.kubernetes.io/whitelist-source-range: "10.1.8.0/24,127.0.0.1/32"
七、静态资源缓存、请求头透传
9. 透传真实客户端IP
annotations:
  nginx.ingress.kubernetes.io/x-forwarded-for: "true"
  nginx.ingress.kubernetes.io/proxy-real-ip-cidr: "10.0.0.0/8"
10. 静态资源缓存优化
annotations:
  nginx.ingress.kubernetes.io/proxy-cache: "true"
  nginx.ingress.kubernetes.io/proxy-cache-valid: "200 302 10m"
八、灰度 / 权重分流（金丝雀发布）
11. 权重流量拆分

场景：线上灰度，90%流量走稳定版，10%走测试版

annotations:
  nginx.ingress.kubernetes.io/canary: "true"
  nginx.ingress.kubernetes.io/canary-weight: "10"
九、错误页面、自定义配置
12. 自定义后端错误页、关闭目录浏览
annotations:
  nginx.ingress.kubernetes.io/custom-http-errors: "404,500,502,503"
十、生产高频注解 速查表
注解作用
force-ssl-redirect: true80 强制跳转 HTTPS
rewrite-target路径重写、裁剪路由前缀
whitelist-source-rangeIP白名单
limit-rps / limit-connections防CC、限流
enable-cors前后端跨域
proxy-read-timeout解决接口超时断开
x-forwarded-for后端获取真实客户端IP
# kubernetes # 运维
Logo
亚马逊云科技技术品牌专区

更多推荐

cover

基于大数据爬虫+Hadoop+深度学习的个性化音乐推荐系统设计与开发

avatar 亚马逊云科技技术品牌专区
cover

智能物联网场景下，支持多模型的AI平台实际表现解析

avatar 亚马逊云科技技术品牌专区
cover

基于大数据爬虫+Hadoop+深度学习的旅游推荐系统设计与开发

avatar 亚马逊云科技技术品牌专区