Kubernetes 中的所有内容都被抽象为“资源”，如 Pod、Service、Node 等都是资源。“对象”就是“资源”的实例，是持久化的实体。Kubernetes 使用这些实体去表示整个集群的状态。它们主要描述了如下信息：

哪些容器化应用正在运行（以及在哪些节点上运行）
可以被应用使用的资源
关于应用运行时表现的策略，比如重启策略、升级策略以及容错策略

Kubernetes 支持多种不同的方式来创建和管理 Kubernetes 对象，比如：

采用kubectl的命令方式
yaml文件方式

Namespace

Namespace的主要作用是，将同一集群中的资源划分为相互隔离的组。

同一Namespace内的资源名称要唯一，不同Namespace
资源名称没有这个要求。
Namespace作用域仅针对带有名字空间的对象，例如 Deployment、Service 等，对于不带Namespace的对象不适用，例如 StorageClass、Node、PersistentVolume 等。
对于所有资源的操作默认会使用default命名空间，这个默认空间可以通过命令指定。

查看哪些资源在名字空间中

查看哪些 Kubernetes 资源在名字空间中，哪些不在名字空间中：

# 位于名字空间中的资源
kubectl api-resources --namespaced=true

# 不在名字空间中的资源
kubectl api-resources --namespaced=false

设置默认操作的命名空间

你可以永久保存名字空间，以用于对应上下文中所有后续 kubectl 命令。

kubectl config set-context --current --namespace=<名字空间名称>
# 验证
kubectl config view --minify | grep namespace:

查看名字空间

kubectl get namespace或者kubectl get ns
输出结果：

[root@k8s-master ~]# kubectl get namespace
NAME              STATUS   AGE
default           Active   179m
kube-node-lease   Active   179m
kube-public       Active   179m
kube-system       Active   179m
kuboard           Active   135m
nginx-ingress     Active   144m

default: Kubernetes 包含这个名字空间，以便于你无需创建新的名字空间即可开始使用新集群。
kube-node-lease: 该名字空间包含用于与各个节点关联的 Lease（租约）对象。节点租约允许 kubelet 发送心跳，由此控制面能够检测到节点故障。
kube-public: 所有的客户端（包括未经身份验证的客户端）都可以读取该名字空间。该名字空间主要预留为集群使用，以便某些资源需要在整个集群中可见可读。该名字空间的公共属性只是一种约定而非要求。
kube-system: 该名字空间用于 Kubernetes 系统创建的对象。

查看命名空间详细信息

kubectl describe namespaces <name>

示例：

[root@k8s-master ~]# kubectl describe namespace test
Name:         test
Labels:       <none>
Annotations:  <none>
Status:       Active

No resource quota.

No LimitRange resource.
[root@k8s-master ~]#

新建命名空间

新建一个名为 my-namespace.yaml 的 YAML 文件，并写入下列内容：

apiVersion: v1
kind: Namespace
metadata:
  name: <insert-namespace-name-here>

然后运行：

kubectl create -f ./my-namespace.yaml

或者，你可以使用下面的命令创建名字空间：

kubectl create ns <insert-namespace-name-here>

# 新建命名空间
kubectl create ns 命名空间名称

示例：

[root@k8s-master ~]# kubectl create ns test
namespace/test created
[root@k8s-master ~]# kubectl get ns
NAME              STATUS   AGE
default           Active   3h4m
kube-node-lease   Active   3h4m
kube-public       Active   3h4m
kube-system       Active   3h4m
kuboard           Active   140m
nginx-ingress     Active   149m
test              Active   8s

删除空间

# 删除现有命名空间， 并且会删除空间下的全部资源
kubectl delete ns 命名空间名称

示例：

[root@k8s-master ~]# kubectl delete ns test
namespace "test" deleted
[root@k8s-master ~]# 
[root@k8s-master ~]# kubectl get ns
NAME              STATUS   AGE
default           Active   3h6m
kube-node-lease   Active   3h6m
kube-public       Active   3h6m
kube-system       Active   3h6m
kuboard           Active   142m
nginx-ingress     Active   151m

Pod（容器组）

Pod是kubernetes集群进行管理的最小单元，程序要运行必须部署在容器中，而容器必须存在于Pod中。
Pod可以认为是容器的封装，一个Pod中可以存在一个或者多个容器，这些容器共享存储、网络、以及怎样运行这些容器的声明。
Pod是不能被外网直接访问的，所以Pod 通常不是直接创建的，而是使用工作负载资源创建，比如 Deployment。

命令方式管理Pod

# 查看所有运行的pod
kubectl get pod -A

# 查看指定Namespace下的Pod
kubectl get pod [-n 命名空间]  #（默认default）

# 创建Pod
kubectl run pod名称 --image=镜像名称

# 查看Pod详细信息
kubectl describe pod pod名称

# 删除pod
kubectl delete pod pod名称 [-n 命名空间]  #（默认default）

# 查看pod输出的日志
kubectl logs -f pod名称

# 进去pod容器内部
kubectl exec [-n 命名空间] -it pod名称 [-c 容器名称] -- bash
kubectl exec -n test -it nginx-tomcate-pod -c tomcate -- bash  

# 查看kubernetes给Pod分配的ip信息，并且通过ip和容器的端口，可以直接访问
kubectl get pod -owide

以yml方式管理Pod

新建yml文件：

apiVersion: v1
kind: Pod
metadata:
  labels:
    run: 运行的pod名称
  name: pod名称
  namespace: 命名空间
spec:
  containers:
  - image: 镜像名称
    name: 容器名称
  - image: 镜像名称
    name: 容器名称

执行命令：

# 启动Pod：
kubectl apply -f yaml文件名称
# 删除Pod：
kubectl delete -f yaml文件名称

示例：在一个Pod中运行nginx和tomcate，新建一个nginx-tomcate-pod.yml：

apiVersion: v1
kind: Pod
metadata:
  name: nginx-tomcate-pod
  namespace: test
spec:
  containers:
  - name: nginx
    image: daocloud.io/library/nginx:1.14.2
    ports:
    - containerPort: 80
  - name: tomcate
    image: daocloud.io/library/tomcat:8.0.45
    ports:
    - containerPort: 8080

启动Pod

pod/nginx-tomcate-pod configured
[root@k8s-master ~]# kubectl get pod nginx-tomcate-pod -n test
NAME                READY   STATUS             RESTARTS   AGE
nginx-tomcate-pod   1/2     ImagePullBackOff   0          33m
[root@k8s-master ~]# kubectl get pod nginx-tomcate-pod -n test
NAME                READY   STATUS    RESTARTS   AGE
nginx-tomcate-pod   2/2     Running   1          36m

通过命令查询Pod详细信息kubectl describe pod nginx-tomcate-pod -n test：

[root@k8s-master ~]# kubectl describe pod nginx-tomcate-pod -n test
Name:         nginx-tomcate-pod
Namespace:    test
Priority:     0
Node:         k8s-worker/192.168.232.8
Start Time:   Fri, 21 Apr 2023 23:47:01 +0800
Labels:       <none>
Annotations:  cni.projectcalico.org/podIP: 10.100.254.130/32
              cni.projectcalico.org/podIPs: 10.100.254.130/32
Status:       Running
IP:           10.100.254.130
IPs:
  IP:  10.100.254.130
Containers:
  nginx:
    Container ID:   docker://ead4ad64590ede48491281aa1b9fe2390a79ca7746ae3cdd05ea03668bb3544e
    Image:          daocloud.io/library/nginx:1.14.2
    Image ID:       docker-pullable://daocloud.io/library/nginx@sha256:706446e9c6667c0880d5da3f39c09a6c7d2114f5a5d6b74a2fafd24ae30d2078
    Port:           80/TCP
    Host Port:      0/TCP
    State:          Running
      Started:      Sat, 22 Apr 2023 00:19:54 +0800
    Last State:     Terminated
      Reason:       Completed
      Exit Code:    0
      Started:      Fri, 21 Apr 2023 23:50:59 +0800
      Finished:     Sat, 22 Apr 2023 00:19:53 +0800
    Ready:          True
    Restart Count:  1
    Environment:    <none>
    Mounts:
      /var/run/secrets/kubernetes.io/serviceaccount from default-token-lckbp (ro)
  tomcate:
    Container ID:   docker://d773ef81e8ce60e0055357fcccaa92b62ca9718de2bbcd66325aa9998df28eb0
    Image:          daocloud.io/library/tomcat:8.0.45
    Image ID:       docker-pullable://daocloud.io/library/tomcat@sha256:08132ab8b2c606cfb78a0ef9e80e1e724331cab10058135b475f23c032738350
    Port:           8080/TCP
    Host Port:      0/TCP
    State:          Running
      Started:      Sat, 22 Apr 2023 00:21:52 +0800
    Ready:          True
    Restart Count:  0
    Environment:    <none>
    Mounts:
      /var/run/secrets/kubernetes.io/serviceaccount from default-token-lckbp (ro)
Conditions:
  Type              Status
  Initialized       True 
  Ready             True 
  ContainersReady   True 
  PodScheduled      True 
Volumes:
  default-token-lckbp:
    Type:        Secret (a volume populated by a Secret)
    SecretName:  default-token-lckbp
    Optional:    false
QoS Class:       BestEffort
Node-Selectors:  <none>
Tolerations:     node.kubernetes.io/not-ready:NoExecute op=Exists for 300s
                 node.kubernetes.io/unreachable:NoExecute op=Exists for 300s
Events:
  Type     Reason     Age                  From               Message
  ----     ------     ----                 ----               -------
  Warning  Failed     57m                  kubelet            Failed to pull image "nginx:1.14.2": rpc error: code = Unknown desc = Error response from daemon: Get https://registry-1.docker.io/v2/library/nginx/manifests/1.14.2: Get https://auth.docker.io/token?scope=repository%3Alibrary%2Fnginx%3Apull&service=registry.docker.io: net/http: request canceled while waiting for connection (Client.Timeout exceeded while awaiting headers)
  Warning  Failed     56m (x2 over 56m)    kubelet            Failed to pull image "tomcate:8.5.68": rpc error: code = Unknown desc = Error response from daemon: pull access denied for tomcate, repository does not exist or may require 'docker login': denied: requested access to the resource is denied
  Normal   BackOff    55m (x2 over 56m)    kubelet            Back-off pulling image "nginx:1.14.2"
  Warning  Failed     55m (x2 over 56m)    kubelet            Error: ImagePullBackOff
  Normal   Pulling    55m (x3 over 57m)    kubelet            Pulling image "nginx:1.14.2"
  Warning  Failed     55m (x3 over 57m)    kubelet            Error: ErrImagePull
  Normal   Pulling    55m (x3 over 57m)    kubelet            Pulling image "tomcate:8.5.68"
  Warning  Failed     55m (x2 over 56m)    kubelet            Failed to pull image "nginx:1.14.2": rpc error: code = Unknown desc = Error response from daemon: Get https://registry-1.docker.io/v2/: net/http: request canceled while waiting for connection (Client.Timeout exceeded while awaiting headers)
  Warning  Failed     55m (x3 over 56m)    kubelet            Error: ErrImagePull
  Normal   Scheduled  39m                  default-scheduler  Successfully assigned test/nginx-tomcate-pod to k8s-worker
  Normal   BackOff    37m (x73 over 56m)   kubelet            Back-off pulling image "tomcate:8.5.68"
  Warning  Failed     27m (x115 over 56m)  kubelet            Error: ImagePullBackOff

通过图形界面查看：

通过curl命令测试：

curl 10.100.254.130

Deployment（部署）

定义 Pod 的期望状态，实现应用程序的版本控制和滚动更新等功能。

命令方式管理

# 基于Deployment启动容器
kubectl create deployment deployment名称 --image=镜像名称
# 用deployment启动的容器会在被删除后自动再次创建，达到故障漂移的效果
# 需要使用deploy的方式删除deploy
# 查看现在的deployment
kubectl get deployment

# 删除deployment
kubectl delete deployment deployment名称

# 基于Deployment启动容器并设置Pod集群数
kubectl create deployment deployment名称 --image=镜像名称 --replicas 集群个数

命令方式管理

新增nginx-tomcate-deployment.yml文件

apiVersion: apps/v1
kind: Deployment
metadata:                        # metadata字段包含对Deployment的描述信息
  name: nginx-tomcate-deployment
  namespace: test
  labels:
    app: nginx-tomcate-pod      # 标签字段用于识别Pod
spec:
  replicas: 2                   # 定义副本数量
  selector:
    matchLabels:
      app: nginx-tomcate-pod
  template:
    metadata:
      labels:
        app: nginx-tomcate-pod
    spec:
      containers:
      # 定义nginx容器
      - name: nginx
        image: daocloud.io/library/nginx:1.14.2
        ports:
        - containerPort: 80
          protocol: TCP
        resources:
          requests:
            cpu: 1             # 限定CPU资源为1核
            memory: 1Gi        # 限定内存资源为1G
          limits:
            cpu: 1             # 限定CPU资源为1核
            memory: 1Gi        # 限定内存资源为1G
      # 定义tomcat容器
      - name: tomcat
        image: daocloud.io/library/tomcat:8.0.45
        ports:
        - containerPort: 8080
          protocol: TCP
        resources:
          requests:
            cpu: 1             # 限定CPU资源为1核
            memory: 1Gi        # 限定内存资源为1G
          limits:
            cpu: 1             # 限定CPU资源为1核
            memory: 1Gi        # 限定内存资源为1G

通过Kubernetes的Deployment去定义一个Pod：

Deployment名称为nginx-tomcate-deployment、Pod名称为nginx-tomcate-pod，Pod包含nginx和tomcate两个容器。
nginx使用daocloud.io/library/nginx:1.14.2镜像，使用80端口。
tomcate使用daocloud.io/library/tomcat:8.0.45镜像，使用8080端口。
限定硬件资源为CPU1核，内存1G。
命名空间为test。

[root@k8s-master ~]# kubectl describe deployment nginx-tomcate-deployment -n test
Name:                   nginx-tomcate-deployment
Namespace:              test
CreationTimestamp:      Sat, 22 Apr 2023 02:14:02 +0800
Labels:                 app=nginx-tomcate-pod
Annotations:            deployment.kubernetes.io/revision: 1
Selector:               app=nginx-tomcate-pod
Replicas:               2 desired | 2 updated | 2 total | 2 available | 0 unavailable
StrategyType:           RollingUpdate
MinReadySeconds:        0
RollingUpdateStrategy:  25% max unavailable, 25% max surge
Pod Template:
  Labels:  app=nginx-tomcate-pod
  Containers:
   nginx:
    Image:        daocloud.io/library/nginx:1.14.2
    Port:         80/TCP
    Host Port:    0/TCP
    Environment:  <none>
    Mounts:       <none>
   tomcat:
    Image:        daocloud.io/library/tomcat:8.0.45
    Port:         8080/TCP
    Host Port:    0/TCP
    Environment:  <none>
    Mounts:       <none>
  Volumes:        <none>
Conditions:
  Type           Status  Reason
  ----           ------  ------
  Progressing    True    NewReplicaSetAvailable
  Available      True    MinimumReplicasAvailable
OldReplicaSets:  <none>
NewReplicaSet:   nginx-tomcate-deployment-5c5d9d9c84 (2/2 replicas created)
Events:
  Type    Reason             Age                  From                   Message
  ----    ------             ----                 ----                   -------
  Normal  ScalingReplicaSet  9m45s                deployment-controller  Scaled up replica set nginx-tomcate-deployment-5c5d9d9c84 to 1
  Normal  ScalingReplicaSet  97s                  deployment-controller  Scaled down replica set nginx-tomcate-deployment-5c5d9d9c84 to 1
  Normal  ScalingReplicaSet  83s (x2 over 2m12s)  deployment-controller  Scaled up replica set nginx-tomcate-deployment-5c5d9d9c84 to 2
[root@k8s-master ~]#

Service（服务）

Service 是将运行在一个或一组 Pod 上的网络应用程序公开为网络服务的方法，它为一组 Pod 提供单一的入口，实现负载均衡、服务发现等功能。

Kubernetes ServiceTypes 允许指定你所需要的 Service 类型，Type 的取值以及行为如下：

ClusterIP：通过集群的内部 IP 暴露服务，选择该值时服务只能够在集群内部访问。这也是你没有为服务显式指定 type 时使用的默认值。你可以使用 Ingress 或者 Gateway API 向公众暴露服务。
NodePort：通过每个节点上的 IP 和静态端口（NodePort）暴露服务。为了让节点端口可用，Kubernetes 设置了集群 IP 地址，这等同于你请求 type: ClusterIP 的服务。
LoadBalancer：使用云提供商的负载均衡器向外部暴露服务。外部负载均衡器可以将流量路由到自动创建的 NodePort 服务和 ClusterIP 服务上。
ExternalName：通过返回 CNAME 记录和对应值，可以将服务映射到 externalName 字段的内容（例如，foo.bar.example.com）。无需创建任何类型代理。

ClusterIP方式

ClusterIP （虚拟 IP 寻址机制）方式是集群内部Pod之间的访问方式。

# 通过生成service映射一个Deployment下的所有pod中的某一个端口的容器
kubectl expose deployment Deployment名称 --port=Service端口号 --target-port=Pod内容器端口

[root@k8s-master ~]# kubectl expose deployment nginx-tomcate-deployment --port=8888 --target-port=80 -n test
service/nginx-tomcate-deployment exposed

通过```kubectl get service````查看映射情况：

[root@k8s-master ~]# kubectl get service -n test
NAME                       TYPE        CLUSTER-IP     EXTERNAL-IP   PORT(S)    AGE
nginx-tomcate-deployment   ClusterIP   10.96.68.183   <none>        8888/TCP   2m31s
[root@k8s-master ~]# curl 10.96.68.183:8888
<!DOCTYPE html>
<html>
<head>
<title>Welcome to nginx!</title>
<style>
    body {
        width: 35em;
        margin: 0 auto;
        font-family: Tahoma, Verdana, Arial, sans-serif;
    }
</style>
</head>
<body>
<h1>Welcome to nginx!</h1>
<p>If you see this page, the nginx web server is successfully installed and
working. Further configuration is required.</p>

<p>For online documentation and support please refer to
<a href="http://nginx.org/">nginx.org</a>.<br/>
Commercial support is available at
<a href="http://nginx.com/">nginx.com</a>.</p>

<p><em>Thank you for using nginx.</em></p>
</body>
</html>

也可以通过 Deployment名称.namespace名称.svc作为域名访问。

NodePort方式

ClusterIP的方式只能在Pod内部实现访问，但是一般需要对外暴露网关，所以需要NodePort的方式Pod外暴露访问

# 通过生成service映射一个Deployment下的所有pod中的某一个端口的容器
kubectl expose deployment Deployment名称 --port=Service端口号 --target-port=Pod内容器端口 --type=NodePort

[root@k8s-master ~]# kubectl get service -n test
NAME                       TYPE        CLUSTER-IP     EXTERNAL-IP   PORT(S)    AGE
nginx-tomcate-deployment   ClusterIP   10.96.68.183   <none>        8888/TCP   20m
[root@k8s-master ~]# kubectl delete service nginx-tomcate-deployment -n test
service "nginx-tomcate-deployment" deleted
[root@k8s-master ~]# kubectl expose deployment nginx-tomcate-deployment --port=8888 --target-port=80 --type=NodePort -n test 
service/nginx-tomcate-deployment exposed
[root@k8s-master ~]# kubectl get service -n test
NAME                       TYPE       CLUSTER-IP     EXTERNAL-IP   PORT(S)          AGE
nginx-tomcate-deployment   NodePort   10.96.20.252   <none>        8888:30169/TCP   13s

然后在外部服务浏览器输入k8s宿主机IP+端口就可以访问应用了，如http://192.168.232.9:30169/。
10.96.20.252:8888是内部容器通信使用的。

使用yml方式声明，新增nginx-tomcate-service.yml文件

apiVersion: apps/v1
kind: Deployment
metadata:                        # metadata字段包含对Deployment的描述信息
  name: nginx-tomcate-deployment
  namespace: test
  labels:
    app: nginx-tomcate-pod      # 标签字段用于识别Pod
spec:
  replicas: 2                   # 定义副本数量
  selector:
    matchLabels:
      app: nginx-tomcate-pod
  template:
    metadata:
      labels:
        app: nginx-tomcate-pod
    spec:
      containers:
      # 定义nginx容器
      - name: nginx
        image: daocloud.io/library/nginx:1.14.2
        ports:
        - containerPort: 80
          protocol: TCP
        resources:
          requests:
            cpu: 1             # 限定CPU资源为1核
            memory: 1Gi        # 限定内存资源为1G
          limits:
            cpu: 1             # 限定CPU资源为1核
            memory: 1Gi        # 限定内存资源为1G
      # 定义tomcat容器
      - name: tomcat
        image: daocloud.io/library/tomcat:8.0.45
        ports:
        - containerPort: 8080
          protocol: TCP
        resources:
          requests:
            cpu: 1             # 限定CPU资源为1核
            memory: 1Gi        # 限定内存资源为1G
          limits:
            cpu: 1             # 限定CPU资源为1核
            memory: 1Gi        # 限定内存资源为1G
---
apiVersion: v1
kind: Service
metadata:
  name: nginx-tomcat-service
  namespace: test
spec:
  selector:
    app: nginx-tomcate-pod
  ports:
    - name: nginx
      port: 8888
      targetPort: 80
    - name: tomcat
      port: 9999
      targetPort: 8080
  type: NodePort

[root@k8s-master ~]# vim nginx-tomcate-deployment.yml 
[root@k8s-master ~]# kubectl apply -f nginx-tomcate-service.yml 
deployment.apps/nginx-tomcate-deployment created
service/nginx-tomcat-service created
[root@k8s-master ~]# kubectl get service -n test
NAME                   TYPE       CLUSTER-IP      EXTERNAL-IP   PORT(S)                         AGE
nginx-tomcat-service   NodePort   10.96.155.195   <none>        8888:30935/TCP,9999:31186/TCP   30s

Ingress（网关）

暴露 Service 给外部网络，实现应用程序的访问控制、路由等功能，Ingress底层其实就是一个Nginx。

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

Ingress 可为 Service 提供外部可访问的 URL、负载均衡流量、终止 SSL/TLS，以及基于名称的虚拟托管。 Ingress 控制器通常负责通过负载均衡器来实现 Ingress，尽管它也可以配置边缘路由器或其他前端来帮助处理流量。

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

在Kuboard直接安装Ingress

基于名称的虚拟托管

基于名称的虚拟主机支持将针对多个主机名的 HTTP 流量路由到同一 IP 地址上。

apiVersion: apps/v1
kind: Deployment
metadata:                        # metadata字段包含对Deployment的描述信息
  name: nginx-deployment
  namespace: test
  labels:
    app: nginx-pod      # 标签字段用于识别Pod
spec:
  replicas: 2                   # 定义副本数量
  selector:
    matchLabels:
      app: nginx-pod
  template:
    metadata:
      labels:
        app: nginx-pod
    spec:
      containers:
      # 定义nginx容器
      - name: nginx
        image: daocloud.io/library/nginx:1.14.2
        ports:
        - containerPort: 80
          protocol: TCP
        resources:
          requests:
            cpu: 1             # 限定CPU资源为1核
            memory: 1Gi        # 限定内存资源为1G
          limits:
            cpu: 1             # 限定CPU资源为1核
            memory: 1Gi        # 限定内存资源为1G
---
apiVersion: apps/v1
kind: Deployment
metadata:                        # metadata字段包含对Deployment的描述信息
  name: tomcate-deployment
  namespace: test
  labels:
    app: tomcate-pod      # 标签字段用于识别Pod
spec:
  replicas: 2                   # 定义副本数量
  selector:
    matchLabels:
      app: tomcate-pod
  template:
    metadata:
      labels:
        app: tomcate-pod
    spec:
      containers:
      # 定义tomcat容器
      - name: tomcat
        image: daocloud.io/library/tomcat:8.0.45
        ports:
        - containerPort: 8080
          protocol: TCP
        resources:
          requests:
            cpu: 1             # 限定CPU资源为1核
            memory: 1Gi        # 限定内存资源为1G
          limits:
            cpu: 1             # 限定CPU资源为1核
            memory: 1Gi        # 限定内存资源为1G
---
apiVersion: v1
kind: Service
metadata:
  name: nginx-service
  namespace: test
spec:
  selector:
    app: nginx-pod
  ports:
    - name: nginx
      port: 8888
      targetPort: 80
---
apiVersion: v1
kind: Service
metadata:
  name: tomcate-service
  namespace: test
spec:
  selector:
    app: tomcate-pod
  ports:
    - name: tomcate
      port: 8888
      targetPort: 8080
--- 
apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
  name: nginx-tomcate-ingress
  namespace: test
spec:
  ingressClassName: nt-ingress
  rules:
  - host: nginx.xiaoyuh.com
    http:
      paths:
      - pathType: Prefix
        path: "/"
        backend:
          service:
            name: nginx-service
            port:
              number: 8888
  - host: tomcate.xiaoyuh.com
    http:
      paths:
      - pathType: Prefix
        path: "/"
        backend:
          service:
            name: tomcate-service
            port:
              number: 8888

[root@k8s-master ~]# kubectl apply -f   nginx-tomcate-ingress.yml 
deployment.apps/nginx-deployment created
deployment.apps/tomcate-deployment created
service/nginx-service created
service/tomcate-service created
ingress.networking.k8s.io/nginx-tomcate-ingress created
[root@k8s-master ~]# kubectl get ingress -n test
Warning: extensions/v1beta1 Ingress is deprecated in v1.14+, unavailable in v1.22+; use networking.k8s.io/v1 Ingress
NAME                    CLASS        HOSTS                                   ADDRESS         PORTS   AGE
nginx-tomcate-ingress   nt-ingress   nginx.xiaoyuh.com,tomcate.xiaoyuh.com   192.168.232.8   80      32s

测试

修改本地host

sudo vim /etc/hosts 
192.168.232.8 nginx.xiaoyuh.com
192.168.232.8 tomcate.xiaoyuh.com
admin@wangyuhao ~ % ping tomcate.xiaoyuh.com
PING tomcate.xiaoyuh.com (192.168.232.8): 56 data bytes
64 bytes from 192.168.232.8: icmp_seq=0 ttl=64 time=0.287 ms
64 bytes from 192.168.232.8: icmp_seq=1 ttl=64 time=0.421 ms

测试访问：
http://tomcate.xiaoyuh.com/
http://nginx.xiaoyuh.com/
都能直接通过域名访问