08. Kubernetes基础篇-服务发布

标签和选择器

简介

概述

在 Kubernetes 中，标签（Labels）和标签选择器（Label Selectors）是用于组织和管理资源的关键概念。
标签（Labels）和标签选择器（Label Selectors）的组合可以用于多种应用场景，以提高资源的管理效率和应用程序的可用性。

什么是标签（Labels）

标签是键值对的元数据，可以附加到 Kubernetes 资源上，如 Pod、Deployment、Service 等。
它们用于对资源进行分类和标记，以便于识别和检索。
标签的适用范围：
Labels可以应用与kubernetes中任何资源上。

什么是标签选择器（Label Selectors）

标签选择器是基于标签的查询条件，用于在 Kubernetes API 中过滤资源。
标签选择器可以基于单个标签或多个标签进行匹配。
标签选择器的类型：
单标签选择器、多标签选择器、基于表达式的选择器、基于范围的选择器、复合选择器。

常见应用场景

1. 资源分组：通过给资源添加标签，可以方便地将它们分组。例如，你可以为所有生产环境的 Pod 添加 env: production 标签，为所有开发环境的 Pod 添加 env: development 标签。
2. 服务发现：Service 可以使用标签选择器来选择与之关联的 Pod，从而实现服务发现。例如，一个名为 my-service 的 Service 可以指定一个标签选择器 app: my-app，以选择所有具有 app: my-app 标签的 Pod。
3. 资源绑定：控制器（如 Deployment、ReplicaSet、StatefulSet 等）可以使用标签选择器来选择与之关联的 Pod。例如，一个名为 my-deployment 的 Deployment 可以指定一个标签选择器 app: my-app，以选择所有具有 app: my-app 标签的 Pod。
4. 资源过滤：你可以使用标签选择器来过滤 API 请求中的资源。例如，列出所有具有特定标签的 Pod。
5. 资源管理：标签和标签选择器可以帮助你更好地组织和管理 Kubernetes 资源。例如，你可以使用标签选择器来查找具有特定标签的资源，以便于管理和操作。
6. 资源调度：Kubernetes 调度器可以使用标签和标签选择器来选择合适的节点来运行 Pod。例如，你可以为 Pod 添加 node-selector 字段，以指定 Pod 应该运行在具有特定标签的节点上。
7. 资源监控和告警：Kubernetes 监控工具（如 Prometheus）可以使用标签选择器来选择特定的资源，以便于监控和告警。
8. 资源迁移：在迁移应用程序时，你可以使用标签选择器来选择需要迁移的资源，以便于管理和跟踪迁移过程。

命令

标签命令操作

• 创建标签

#格式
kubectl label 操作对象 资源名称 标签的key=标签的value

#举例
kubectl label nodes k8s-01 type=master

• 查看标签

#格式
kubectl label 操作对象 资源名称 --show-labels
#举例
kubectl get nodes k8s-01 --show-labels

• 修改标签

#格式
kubectl label 操作对象 资源名称 标签的key=标签的value --overwrite

#举例
kubectl label nodes k8s-01 type=test --overwrite

• 删除标签

#格式
kubectl label 操作对象 资源名称 标签的key-

#举例
kubectl label nodes k8s-01 type-

• 解释说明
  • 操作对象：可以是Node、Pod、Deployment等k8s中任何资源。
  • 资源名称：可以是节点名称、Pod名称、Deployment名称等k8s中任何资源。

标签选择器命令操作

• 列出具有特定标签的资源

#格式
kubectl get 操作对象 -l 标签的key=标签的value

#举例
kubectl get nodes -l type=master

• 列出具有多个标签的资源

#格式
kubectl get 操作对象 -l 标签的key=标签的value,标签的key=标签的value,标签的key=标签的value

#举例
kubectl get nodes -l type=master,name=k8s-01

• 列出具有特定标签键的所有资源

#格式
kubectl get 操作对象 -l 标签的key

#举例
kubectl get nodes -l type

• 列出标签key不等于标签value的资源

#格式
kubectl get 操作对象 -l 标签的key!=标签的value

#举例
kubectl get nodes -l type!=ma

• 列出具有特点标签键包含哪些标签值的资源

#格式
kubectl get pod -A -l '标签的key in (标签的value,标签的value)'

#举例
kubectl get pod -A -l 'k8s-app in (kube-dns,metrics-server)'

• 列出标签key不等于标签value，且标签key等于某个标签value的资源

#格式
kubectl get pod -A -l 标签的key!=标签的value,标签的key=标签的value

#举例
kubectl get pod -A -l k8s-app!=metrics-server,k8s-app=kube-dns

标签和标签选择器yaml文件

在yaml文件中spec.selector.标签key=标签value必须与spec.template.metadata.labels.标签key=标签value保持一致，否则资源类型不知道如何关联Pod。

apiVersion: apps/v1
kind: Deployment
metadata:
  name: deployment-nginx
  namespace: default
  labels:                                                                                   #为Deployment定义了三个标签
    app: nginx
    type: web
    version: v1

spec:
  selector:
    matchLabels:
      app: nginx                                                                            #指定RS选择Pod的标签
  template:
    metadata:
      labels:                                                                               #为Pod定义了一个标签
        app: nginx
    spec:
      containers:
        - name: nginx-web
          image: registry.cn-beijing.aliyuncs.com/publicspaces/nginx:1.22.1
          imagePullPolicy: IfNotPresent
      restartPolicy: Always

Service

简介

什么是Service

Service 是一个核心资源，用于定义一组 Pod 的逻辑集合，并为它们提供一个统一的入口点。
每个 Service 都包含一个或多个标签选择器（Label Selectors），用于匹配具有特定标签的 Pod。
Service 通常与负载均衡器一起使用，以提供对外部客户端的访问。
Service相对Pod而言，Service有一个固定的名称，一旦创建就固定不变，可以根据Service名称对后端服务访问。
注意：在创建Service的时候会自动创建一个同名endpoints，由endpoints管理不断变化地址的Pod。

主要特点和用途

1. 定义逻辑集合：Service 定义了一组 Pod 的逻辑集合，这些 Pod 通常执行相同的任务或提供相同的服务。
2. 统一入口点：Service 为这些 Pod 提供了一个统一的入口点，客户端可以通过 Service 的 IP 地址或 DNS 名称来访问这些 Pod。
3. 负载均衡：Service 可以与 Kubernetes 集群外的负载均衡器集成，以提供外部访问。这使得客户端可以通过一个固定的 IP 地址或 DNS 名称来访问集群内的服务。
4. 服务发现：Service 支持服务发现，允许 Pod 在 Kubernetes 集群内发现和访问其他服务。
5. 多协议支持：Service 支持多种协议，包括 HTTP、HTTPS、TCP 和 UDP。
6. 安全：Service 支持多种安全特性，包括服务账户、网络策略和认证/授权。
7. 支持多种类型的后端：Service 可以与多种类型的后端 Pod 通信，包括无状态和有状态的 Pod。
8. 资源管理：Service 支持资源请求和限制，以确保后端 Pod 有足够的资源运行。
9. 可插拔的客户端库：Kubernetes 提供了多种语言的客户端库，用于与 Service 交互。
10. 与 Ingress 集成：Service 可以与 Ingress 资源集成，以提供更高级的 HTTP/HTTPS 路由和 TLS 终止功能。

Service常用类型

• ClusterIP：
  • 默认网络类型。
  • 为服务分配一个集群内部 IP 地址，并在集群内部进行负载均衡。
  • 服务只能在集群内部访问，无法从集群外部访问。
• ExternalName：
  • 用于将服务映射到外部 DNS 名称。
  • 服务不需要后端 Pod，它只是一个 DNS 记录。
  • 服务可以从集群内部通过 <external-dns-name> 访问。
• NodePort：
  • 为每个节点分配一个端口，且此端口可以代理到后端Pod，并将服务流量转发到这些端口。
  • 服务可以从集群内部通过 <node-ip>:<nodeport端口> 访问，也可以从集群外部通过 <node-ip>:<nodeport端口> 访问。
  • 服务也可以通过 <node-ip>:<service-port端口> 从集群内部访问。
  • NodePort的端口范围默认是：30000-32767。此端口范围可以修改，配置文件为：kube-apiserver.service（二进制安装）或
• LoadBalancer：
  • 注意loadbalancer是收费的。
  • 如果集群运行在支持 LoadBalancer 的云提供商上，服务会分配一个公网 IP 地址，并通过云提供商的负载均衡器进行外部访问。
  • 服务可以从集群内部通过 <node-ip>:<service-port> 访问，也可以从集群外部通过 <external-ip>:<node-port> 或 <external-ip>:<service-port> 访问。
• None：
  • 不分配 IP 地址或端口。
  • 通常用于不需要外部访问的服务，或者在某些情况下，用于在集群内部直接访问服务。

定义一个Service

配置yaml

apiVersion: apps/v1
kind: Deployment
metadata:
  name: deployment-nginx
  namespace: default
  labels:
    app: deployment-nginx

spec:
  selector:
    matchLabels:
      app: nginx                                                                  #定义RS的标签，用于管理Pod
  template:
    metadata:
      labels:
        app: nginx                                                                #定义Pod的标签，此是标签有两个用途：1. 用于RS匹配Pod；2. 用于Service匹配Pod
    spec:
      containers:
        - name: nginx-web
          imagePullPolicy: IfNotPresent
          image: registry.cn-beijing.aliyuncs.com/publicspaces/nginx:1.22.1
          ports:
            - containerPort: 80                                                   #定义容器的端口，要与Service中的spec.ports.targetPort保持一致
      restartPolicy: Always

---
apiVersion: v1
kind: Service
metadata:
  namespace: default
  name: service-nginx
  labels:
    app: service-nginx

spec:
  selector:                                                                         #标签选择器
    app: nginx                                                                      #Service选择Pod定义的标签，使Service与Pod关联
  ports:                                                                            #定义Service中要开放的端口，需要定义两个：Service自己的端口，Service带来后端的端口
    - port: 8080                                                                    #定义Service自己的端口
      targetPort: 80                                                                #定义Service代理后端应用的端口
      name: nginx-port-tcp                                                          #定义Service端口的名称
      protocol: TCP                                                                 #定义Service自己端口的协议
    - port: 8080
      targetPort: 80
      name: nginx-port-udp
      protocol: UDP

创建Service

kubectl create -f service-deployment-pod-nginx.yaml 

验证Service

• 查看Service

kubectl get service

# NAME            TYPE        CLUSTER-IP     EXTERNAL-IP   PORT(S)             AGE
# kubernetes      ClusterIP   10.96.0.1      <none>        443/TCP             4d17h
# service-nginx   ClusterIP   10.96.133.81   <none>        8080/TCP,8080/UDP   5m22s

• 查看Service的endpoints

kubectl get endpoints

# NAME            ENDPOINTS                                                     AGE
# kubernetes      192.168.23.138:6443                                           4d17h
# service-nginx   83.12.61.210:80,83.12.61.211:80,83.12.61.210:80 + 1 more...   22m

• 地址验证访问

curl -iv 10.96.133.81:8080

• 名称验证访问

kubectl exec -it busybox -- sh
#在同一namespace下访问
# / # wget service-nginx:8080
# Connecting to service-nginx:8080 (10.96.133.81:8080)
# index.html           100% |****************************************************************************************************|   615   0:00:00 ETA

#跨namespace访问
# / # wget service-nginx.default:8080
# Connecting to service-nginx.default:8080 (10.96.133.81:8080)
# index.html           100% |****************************************************************************************************|   615   0:00:00 ETA

• Service返回信息

NAME            TYPE        CLUSTER-IP     EXTERNAL-IP   PORT(S)             AGE
kubernetes      ClusterIP   10.96.0.1      <none>        443/TCP             4d17h
service-nginx   ClusterIP   10.96.133.81   <none>        8080/TCP,8080/UDP   21m

• NAME：Service的名称
• TYPE：Service的网络类型
• CLUSTER-IP：Service的集群IP
• EXTERNAL-IP：Service的对外访问IP
• PORT(S)：Service提供的端口信息
• AGE：Service运行的时长

Service的代理应用

使用Service代理kubernetes外部服务

• 应用场景
  • 希望在生产环境中使用某个固定的名称而非IP地址进行访问外部中间件服务。
  • 希望Service可以指向另一个namespace或其他集群中的服务。
  • 某个项目正在迁移到k8s集群，但一部分服务仍在集群外部，此时可以使用Service代理到k8s集群外部的服务。
• 创建外部redis服务

docker run -d --name redis-test -p 6379:6379 registry.cn-beijing.aliyuncs.com/publicspaces/redis:6.2.6

• 编辑yaml

apiVersion: v1
kind: Service
metadata:
  name: endpoint-external-redis                             #此处定义的Service名称必须与Endpoints的metadata.name保持一致，否则无法建立链接
  namespace: default
  labels:
    app: service-external

spec:
  ports:
    - port: 6379
      name: redis-tcp                                       #此处定义的端口的名称，用于与 Endpoints 中的端口名称保持一致，否则无法建立链接
      protocol: TCP
    - port: 6379
      name: redis-udp
      protocol: UDP

---
apiVersion: v1
kind: Endpoints
metadata:
  name: endpoint-external-redis                             #此处定义的Endpoints名称必须与Service的metadata.name保持一致，否则无法建立链接
  namespace: default
  labels:
    app: endpoint-external

subsets:
  - addresses:
      - ip: 192.168.23.138                                  #此处指定的IP地址为要代理的后端服务地址，后端地址可以指定多个，另起一行"- ip:"即可
    ports:
      - port: 6379
        name: redis-tcp                                     #此处定义的端口的名称，用于与 Service 中的端口名称保持一致，否则无法建立链接
        protocol: TCP
      - port: 6379
        name: redis-udp
        protocol: UDP

• 创建服务

kubectl create -f service-external.yaml

• 查看service

kubectl get service
# NAME                TYPE        CLUSTER-IP     EXTERNAL-IP   PORT(S)             AGE
# endpoint-external   ClusterIP   10.96.51.6     <none>        6379/TCP,6379/UDP   16m
# kubernetes          ClusterIP   10.96.0.1      <none>        443/TCP             4d19h
# service-nginx       ClusterIP   10.96.133.81   <none>        8080/TCP,8080/UDP   134m

• 查看endpoints

kubectl get endpoints
# NAME                ENDPOINTS                                                     AGE
# endpoint-external   192.168.23.138:6379,192.168.23.138:6379                       15m
# kubernetes          192.168.23.138:6443                                           4d19h
# service-nginx       83.12.61.210:80,83.12.61.211:80,83.12.61.210:80 + 1 more...   133m

• 地址验证代理

kubectl exec -it busybox -- sh
# / # telnet 10.96.51.6 6379
# set en ne
# +OK
# get en
# $2
# ne

• 名称验证代理

kubectl exec -it busybox -- sh
# / # telnet endpoint-external 6379
# get en
# $2
# ne
# get name
# $10
# wangmingqu

• 注意
  • 如果更改endpoints中代理后端地址，可以直接编译yaml文件；
  • 然后通过命令kubectl replace -f service-external.yaml即可；

使用Service反向代理外部域名

• 应用场景
  • 使用非常少见
  • 注意跨域时可能会被拒绝
• 编译yaml

apiVersion: v1
kind: Service
metadata:
  name: service-externalName
  namespace: default
  labels:
    app: service-externalName

spec:
  type: ExternalName                            #指定网络服务类型为 ExternalName
  externalName: www.baidu.com                   #定义了服务的 DNS 名称，该名称应该解析到外部服务的地址。

• 创建Service

kubectl create -f service-externalName.yaml

• 查看Service

kubectl get service
# NAME                    TYPE           CLUSTER-IP     EXTERNAL-IP     PORT(S)             AGE
# endpoint-external       ClusterIP      10.96.51.6     <none>          6379/TCP,6379/UDP   35m
# kubernetes              ClusterIP      10.96.0.1      <none>          443/TCP             4d19h
# service-external-name   ExternalName   <none>         www.baidu.com   <none>              8s
# service-nginx           ClusterIP      10.96.133.81   <none>          8080/TCP,8080/UDP   153m

• 验证代理

kubectl exec -it busybox -- sh
# / # nslookup service-external-name
# Server:    10.96.0.10
# Address 1: 10.96.0.10 kube-dns.kube-system.svc.cluster.local

# Name:      service-external-name
# Address 1: 240e:83:205:58:0:ff:b09f:36bf
# Address 2: 240e:83:205:5a:0:ff:b05f:346b
# Address 3: 220.181.38.149 www.baidu.com

使外部网络可以直接访问内部服务

• 编译yaml

apiVersion: apps/v1
kind: Deployment
metadata:
  namespace: default
  name: deployment-nginx
  labels:
    app: deployment-nginx

spec:
  selector:
    matchLabels:
      app: nginx
  template:
    metadata:
      labels:
        app: nginx
    spec:
      containers:
        - name: nginx-web
          image: registry.cn-beijing.aliyuncs.com/publicspaces/nginx:1.22.1
          imagePullPolicy: IfNotPresent
      restartPolicy: Always

---
apiVersion: v1
kind: Service
metadata:
  name: service-nginx
  namespace: default
  labels:
    app: service-nginx

spec:
  selector:
    app: nginx
  type: NodePort
  ports:
    - port: 8081                                                                        #定义集群内部访问端口，可以使用ClusterIP+端口号访问
      targetPort: 80                                                                    #指定Pod中容器的访问端口，要与Deployment中定义的Pod端口保持一致
      nodePort: 30080                                                                   #定义对外访问端口，可以使用宿主机地址+端口访问
      protocol: TCP
      name: nginx-tcp
    - port: 8081
      targetPort: 80
      nodePort: 30080
      protocol: UDP
      name: nginx-udp

• 创建服务

kubectl create -f service-nodeport.yaml

• 查看Service

kubectl get service
# NAME            TYPE        CLUSTER-IP      EXTERNAL-IP   PORT(S)                         AGE
# kubernetes      ClusterIP   10.96.0.1       <none>        443/TCP                         4d20h
# service-nginx   NodePort    10.96.201.107   <none>        8081:30080/TCP,8081:30080/UDP   3m12s

• 验证访问

Host_Computer=$(ip addr | grep dynamic | awk -F ' ' '{print $2}' |awk -F '/' '{print $1}')

curl -iv $Host_Computer:30080

Ingress

简介

什么是Ingress

Ingress 是一个资源，用于定义如何将外部 HTTP(S) 流量路由到集群内的服务。
它为集群提供了一个统一的入口点，用于管理和控制外部访问。
Ingress 资源通常与负载均衡器一起使用，以提供外部访问，并支持路径、TLS 终止和基于名称的虚拟托管等功能。

主要特点和用途

1. 路径映射：Ingress 允许你为不同的 URL 路径定义不同的服务。例如，你可以为 /api 路径定义一个服务，为 /admin 路径定义另一个服务。
2. TLS 终止：Ingress 支持 TLS 证书，可以用于终止外部流量中的 HTTPS 连接，并将流量转发到集群内的服务。
3. 基于名称的虚拟托管：Ingress 允许你为不同的主机名定义不同的服务。例如，你可以为 example.com 和 admin.example.com 定义不同的服务。
4. 负载均衡：Ingress 通常与负载均衡器一起使用，以提供外部访问。这使得客户端可以通过一个固定的 IP 地址或 DNS 名称来访问集群内的服务。
5. 服务发现：Ingress 支持服务发现，允许 Pod 在 Kubernetes 集群内发现和访问其他服务。
6. 资源管理：Ingress 支持资源请求和限制，以确保后端 Pod 有足够的资源运行。
7. 可插拔的客户端库：Kubernetes 提供了多种语言的客户端库，用于与 Ingress 交互。

安装

Yaml部署

• yaml文件

Ingress-nginx.yaml

• 下载阿里云镜像

docker pull registry.cn-hangzhou.aliyuncs.com/google_containers/nginx-ingress-controller:v1.1.2
docker pull registry.cn-hangzhou.aliyuncs.com/google_containers/kube-webhook-certgen:v1.1.1

• 修改Ingress-nginx.yaml的镜像地址

#修改一：
    spec:
      dnsPolicy: ClusterFirst
      containers:
        - name: controller
          # 原镜像
          #image: registry.k8s.io/ingress-nginx/controller:v1.2.1@sha256:5516d103a9c2ecc4f026efbd4b40662ce22dc1f824fb129ed121460aaa5c47f8
          # 阿里云镜像
          image: registry.cn-hangzhou.aliyuncs.com/google_containers/nginx-ingress-controller:v1.1.2
          imagePullPolicy: IfNotPresent

#修改二：
    spec:
      containers:
        - name: create
          # 原镜像
          #image: registry.k8s.io/ingress-nginx/kube-webhook-certgen:v1.1.1@sha256:64d8c73dca984af206adf9d6d7e46aa550362b1d7a01f3a0a91b20cc67868660
          # 阿里云镜像
          image: registry.cn-hangzhou.aliyuncs.com/google_containers/kube-webhook-certgen:v1.1.1
          imagePullPolicy: IfNotPresent

#修改三：
    spec:
      containers:
        - name: patch
          # 原镜像
          #image: registry.k8s.io/ingress-nginx/kube-webhook-certgen:v1.1.1@sha256:64d8c73dca984af206adf9d6d7e46aa550362b1d7a01f3a0a91b20cc67868660
          # 阿里云镜像
          image: registry.cn-hangzhou.aliyuncs.com/google_containers/kube-webhook-certgen:v1.1.1
          imagePullPolicy: IfNotPresent

• 部署Ingress-nginx

kubectl create -f Ingress-nginx.yaml

• 查看Ingress-nginx服务

kubectl get pod -n ingress-nginx -o wide

Helm部署

适用于任何环境

• 下载helm

wget https://get.helm.sh/helm-v3.15.3-linux-amd64.tar.gz

• 安装helm

#解压helm
tar -zxvf helm-v3.15.3-linux-amd64.tar.gz -C /usr/local/

#配置变量
cat >> /etc/profile << EOF
#for helm
export PATH=/usr/local/linux-amd64:$PATH
EOF
source /etc/profile

#命令补全
echo "source <(helm completion bash)" >>  ~/.bash_profile

• 查看版本

helm version

• 配置helm

#添加仓库
helm repo add ingress-nginx https://kubernetes.github.io/ingress-nginx

#查看仓库
helm repo list

• 下载Ingress-nginx

#搜索ingress-nginx
helm search repo ingress-nginx

#创建ingress-nginx目录
mkdir -p /data/ingress-nginx

#下载ingress-nginx镜像
helm pull ingress-nginx/ingress-nginx

• 配置Ingress-nginx

#编辑ingress-nginx配置
tar -zxvf ingress-nginx-4.11.0.tgz -C /data/ingress-nginx/

#调整镜像仓库
#如果国外仓库无法拉取或拉取较慢，可以使用阿里云仓库地址
vim /data/ingress-nginx/ingress-nginx/values.yaml
#修改一：
#如果原镜像无法拉取可以使用国内阿里云镜像
controller:
  name: controller
  image:
    ## Keep false as default for now!
    chroot: false
    registry: registry.k8s.io
    #原配置
    #image: ingress-nginx/controller
    #阿里云配置
    image: registry.cn-hangzhou.aliyuncs.com/google_containers/nginx-ingress-controller
    ## for backwards compatibility consider setting the full image url via the repository value below
    ## use *either* current default registry/image or repository format or installing chart by providing the values.yaml will fail
    ## repository:
    #指定版本
    tag: "v1.1.2"
    #注释掉
    #digest: sha256:54f7fe2c6c5a9db9a0ebf1131797109bb7a4d91f56b9b362bde2abd237dd1974
    #注释掉
    #digestChroot: sha256:a8466b19c621bd550b1645e27a004a5cc85009c858a9ab19490216735ac432b1
    pullPolicy: IfNotPresent
    
#修改二：
#如果启用hostNetwork，此处需要使用ClusterFirstWithHostNet
  #dnsPolicy: ClusterFirst
  dnsPolicy: ClusterFirstWithHostNet
  
#修改三：
#推荐Ingress-nginx的部署方式采用hostNetwork部署，直接使用宿主机端口号，性能会相对好一些
#注意，如果使用Deployment部署不能启用hostNetwork
  #hostNetwork: false
  hostNetwork: true
  
#修改四：
#推荐使用DaemonSet，DaemonSet的部署更加容易控制
  # -- Use a `DaemonSet` or `Deployment`
  #kind: Deployment
  kind: DaemonSet
  
#修改五：
#可以指定ingress: "true"的标签部署ingress-nginx服务
  nodeSelector:
    kubernetes.io/os: linux
    ingress: "true"
    
#修改六：
#如果是专有ingress-nginx节点，可以不设置限制
  resources:
  ##  limits:
  ##    cpu: 100m
  ##    memory: 90Mi
    requests:
      cpu: 100m
      memory: 90Mi
      
#修改七：
    ports:
      http: 80
      https: 443

    targetPorts:
      http: http
      https: https
#自建kubernetes集群无需设置LoadBalancer，设置ClusterIP
    #type: LoadBalancer
    type: ClusterIP
    
#修改八：
#如果原镜像无法拉取可以使用国内阿里云镜像
    patch:
      enabled: true
      image:
        registry: registry.k8s.io
        #原镜像
        #image: ingress-nginx/kube-webhook-certgen
        #阿里云镜像
        image: registry.cn-hangzhou.aliyuncs.com/google_containers/kube-webhook-certgen
        #指定版本
        tag: "v1.1.1"
        #注释掉
        #digest: sha256:549e71a6ca248c5abd51cdb73dbc3083df62cf92ed5e6147c780e30f7e007a47

• 安装Ingress-nginx

#进入仓库
cd /data/ingress-nginx/ingress-nginx/

#创建命名空间
kubectl create namespace ingress-nginx

#安装Ingress-nginx
helm install ingress-nginx -n ingress-nginx .

检查

检查ingress-nginx的Pod服务

kubectl get pod -n ingress-nginx 
# NAME                                        READY   STATUS      RESTARTS   AGE
# ingress-nginx-admission-create-fqtcn        0/1     Completed   0          11m
# ingress-nginx-admission-patch-7jzpl         0/1     Completed   1          11m
# ingress-nginx-controller-69bb54cd59-5z764   1/1     Running     0          11m

检查ingress-nginx的Service服务

kubectl get service -n ingress-nginx 
# NAME                                 TYPE        CLUSTER-IP      EXTERNAL-IP   PORT(S)                      AGE
# ingress-nginx-controller             NodePort    10.96.183.214   <none>        80:31213/TCP,443:30759/TCP   13m
# ingress-nginx-controller-admission   ClusterIP   10.96.25.36     <none>        443/TCP                      13m

应用

Ingress简单使用

• 配置yaml

apiVersion: apps/v1
kind: Deployment                                                                      #定义一个Deployment类型资源
metadata:
  name: deployment-nginx
  namespace: default
  labels:
    app: nginx

spec:
  selector:
    matchLabels:
      app: nginx                                                                      #定义RS的标签选择器选择的Pod标签
  template:                                                                           #定义了 Pod 的模板，包括容器、标签和端口等信息
    metadata:
      labels:
        app: nginx                                                                    #定义Pod的标签
    spec:
      containers:
        - name: nginx-web
          imagePullPolicy: IfNotPresent
          image: registry.cn-beijing.aliyuncs.com/publicspaces/nginx:1.22.1
          ports:
            - containerPort: 80
      restartPolicy: Always

---
apiVersion: v1
kind: Service                                                                         #定义一个Service类型资源
metadata:
  name: service-nginx
  namespace: default
  labels:
    app: service-nginx

spec:
  selector:
    app: nginx                                                                        #定义Service的标签选择去选择的Pod标签，要与Pod中标签保持一致
  type: ClusterIP
  ports:
    - port: 8081                                                                      #定义Service的端口号，后续Ingress中会使用到
      targetPort: 80
      protocol: TCP
      name: nginx-tcp
    - port: 8081
      targetPort: 80
      protocol: UDP
      name: nginx-udp

---
apiVersion: networking.k8s.io/v1
kind: Ingress                                                                          #定义一个Ingress类型资源
metadata:
  name: ingress-nginx
  namespace: default
  labels:
    app: ingress-nginx
  annotations:
    kubernetes.io/ingress.class: "nginx"                                               #Ingress中有多种工具，此处指定使用 Nginx 作为 Ingress 控制器

spec:
  rules:                                                                               #定义了 Ingress 规则，用于将外部请求映射到集群内的服务。
    - host: www.wangmingqu.com                                                         #定义了请求的主机名，可以使用不填，表示匹配所有域名
      http:                                                                            #定义了 HTTP 规则
        paths:                                                                         #定义了路径规则，用于将请求映射到后端服务。
          - backend:
              service:                                                                 #定义了后端服务
                name: service-nginx                                                    #后端服务的名称，此处是Service的名称
                port:
                  number: 8081                                                         #后端服务的端口号，此处是Service的端口
            path: /                                                                    #定义了请求路径
            pathType: Prefix                                                           #表示路径类型，这里是前缀匹配
          - backend:
              service:
                name: service-nginx
                port:
                  number: 8081
            path: /test
            pathType: Prefix

• 创建服务

kubectl create -f ingress-service-deployment-pod.yaml

• 检查服务

#检查Pod
kubectl get pod -o wide
# NAME                                READY   STATUS    RESTARTS   AGE     IP             NODE     NOMINATED NODE   READINESS GATES
# busybox                             1/1     Running   27         3d15h   83.12.61.252   k8s-01   <none>           <none>
# deployment-nginx-6d956b9564-49jb9   1/1     Running   0          32m     83.12.61.254   k8s-01   <none>           <none>
# deployment-nginx-6d956b9564-62k26   1/1     Running   0          32m     83.12.61.255   k8s-01   <none>           <none>

#检查Deployment
kubectl get deployment -o wide
# NAME               READY   UP-TO-DATE   AVAILABLE   AGE   CONTAINERS   IMAGES                                                       SELECTOR
# deployment-nginx   2/2     2            2           33m   nginx-web    registry.cn-beijing.aliyuncs.com/publicspaces/nginx:1.22.1   app=nginx

#检查Service
kubectl get service -o wide
# NAME            TYPE        CLUSTER-IP      EXTERNAL-IP   PORT(S)             AGE     SELECTOR
# kubernetes      ClusterIP   10.96.0.1       <none>        443/TCP             5d14h   <none>
# service-nginx   ClusterIP   10.96.167.168   <none>        8081/TCP,8081/UDP   33m     app=nginx

#检查Ingress
kubectl get ingress -o wide
# NAME            CLASS    HOSTS                ADDRESS   PORTS   AGE
# ingress-nginx   <none>   www.wangmingqu.com             80      3m19s

• 验证服务

curl -H 'Host:www.wangmingqu.com' http://192.168.23.138

Ingress多域名使用

• 编译yaml

apiVersion: apps/v1
kind: Deployment                                                                      #定义一个Deployment类型资源
metadata:
  name: deployment-nginx
  namespace: default
  labels:
    app: nginx

spec:
  selector:
    matchLabels:
      app: nginx                                                                      #定义RS的标签选择器选择的Pod标签
  template:                                                                           #定义了 Pod 的模板，包括容器、标签和端口等信息
    metadata:
      labels:
        app: nginx                                                                    #定义Pod的标签
    spec:
      containers:
        - name: nginx-web
          imagePullPolicy: IfNotPresent
          image: registry.cn-beijing.aliyuncs.com/publicspaces/nginx:1.22.1
          ports:
            - containerPort: 80
      restartPolicy: Always

---
apiVersion: v1
kind: Service                                                                         #定义一个Service类型资源
metadata:
  name: service-nginx
  namespace: default
  labels:
    app: service-nginx

spec:
  selector:
    app: nginx                                                                        #定义Service的标签选择去选择的Pod标签，要与Pod中标签保持一致
  type: ClusterIP
  ports:
    - port: 80                                                                      #定义Service的端口号，后续Ingress中会使用到
      targetPort: 80
      protocol: TCP
      name: nginx-tcp
    - port: 80
      targetPort: 80
      protocol: UDP
      name: nginx-udp

---
apiVersion: networking.k8s.io/v1
kind: Ingress                                                                          #定义一个Ingress类型资源
metadata:
  name: ingress-nginx
  namespace: default
  labels:
    app: ingress-nginx
  annotations:
    kubernetes.io/ingress.class: "nginx"                                               #Ingress中有多种工具，此处指定使用 Nginx 作为 Ingress 控制器

spec:
  rules:                                                                               #定义了 Ingress 规则，用于将外部请求映射到集群内的服务。
    - host: www.wangmingqu.com                                                         #定义了请求的主机名，可以使用不填，表示匹配所有域名
      http:                                                                            #定义了 HTTP 规则
        paths:                                                                         #定义了路径规则，用于将请求映射到后端服务。
          - backend:
              service:                                                                 #定义了后端服务
                name: service-nginx                                                    #后端服务的名称，此处是Service的名称
                port:
                  number: 80                                                         #后端服务的端口号，此处是Service的端口
            path: "/"                                                                    #定义了请求路径
            pathType: Prefix                                                           #表示路径类型，这里是前缀匹配
          - backend:
              service:
                name: service-nginx
                port:
                  number: 80
            path: "/test"
            pathType: Prefix
    - host: www.mingqu.com                                                         #定义了请求的主机名，可以使用不填，表示匹配所有域名
      http:                                                                            #定义了 HTTP 规则
        paths:                                                                         #定义了路径规则，用于将请求映射到后端服务。
          - backend:
              service:                                                                 #定义了后端服务
                name: service-nginx                                                    #后端服务的名称，此处是Service的名称
                port:
                  number: 80                                                         #后端服务的端口号，此处是Service的端口
            path: "/"                                                                    #定义了请求路径
            pathType: Prefix                                                           #表示路径类型，这里是前缀匹配
          - backend:
              service:
                name: service-nginx
                port:
                  number: 80
            path: "/test"
            pathType: Prefix

• 创建服务

kubectl create -f ingress-service-depolyment-pod.yaml

• 检查服务

#检查Pod
kubectl get pod -o wide
# NAME                                READY   STATUS    RESTARTS   AGE     IP             NODE     NOMINATED NODE   READINESS GATES
# busybox                             1/1     Running   46         4d22h   83.12.61.206   k8s-01   <none>           <none>
# deployment-nginx-6d956b9564-d8jxc   1/1     Running   0          51s     83.12.61.249   k8s-01   <none>           <none>
# deployment-nginx-6d956b9564-xtj88   1/1     Running   0          38m     83.12.61.252   k8s-01   <none>           <none>

#检查Deployment
# kubectl get deployment -o wide
# NAME               READY   UP-TO-DATE   AVAILABLE   AGE   CONTAINERS   IMAGES                                                       SELECTOR
# deployment-nginx   2/2     2            2           38m   nginx-web    registry.cn-beijing.aliyuncs.com/publicspaces/nginx:1.22.1   app=nginx

#检查Service
kubectl get service -o wide
# NAME            TYPE        CLUSTER-IP     EXTERNAL-IP   PORT(S)         AGE     SELECTOR
# kubernetes      ClusterIP   10.96.0.1      <none>        443/TCP         6d21h   <none>
# service-nginx   ClusterIP   10.96.220.83   <none>        80/TCP,80/UDP   38m     app=nginx

#检查Ingress
kubectl get ingress -o wide
# NAME            CLASS    HOSTS                               ADDRESS   PORTS   AGE
# ingress-nginx   <none>   www.wangmingqu.com,www.mingqu.com             80      39m

• 验证服务

curl -H 'Host:www.wangmingqu.com' http://192.168.23.138
curl -H 'Host:www.mingqu.com' http://192.168.23.138