点击上方蓝字 👆关注公众号，别让消息溜走

后台回复【加群】，与牛人互动不停

什么是 Kind

Kind（Kubernetes in Docker）是一个 Kubernetes 孵化项目，Kind 是一套开箱即用的 Kubernetes 环境搭建方案。顾名思义，就是将 Kubernetes 所需要的所有组件，全部部署在一个 Docker 容器中，可以很方便的搭建 Kubernetes 集群。

Kind 已经广泛的应用于 Kubernetes 上游及相关项目的 CI 环境中，官方文档中也把 Kind 作为一种本地集群搭建的工具推荐给大家。

简而言之，kind是一个使用 Docker 容器“节点”，运行本地 Kubernetes 集群的工具。

Kind 可以做什么？

1. 快速创建一个或多个 Kubernetes 集群
2. 支持部署高可用的 Kubernetes 集群，支持多节点（含HA）集群
3. 支持从源码构建并部署一个 Kubernetes 集群，除了预先发布的构建之外，还支持 make / bash 或 docker
4. 可以快速低成本体验一个最新的 Kubernetes 集群，并支持 Kubernetes 的绝大部分功能
5. 支持本地离线运行一个多节点集群

Kind适合的场景或需求

Kind是一个简单易用、快速轻量、可配置可扩展的工具，可以在本地或云端快速创建和删除Kubernetes集群，方便开发者进行测试和调试。Kind还支持多种插件和工具，如Helm、Istio、Skaffold等，可以提高开发效率和质量。

• 本地开发和测试：Kind可以在本地快速创建一个Kubernetes集群，让开发者可以在自己的电脑上部署和调试应用，而不需要依赖远程的集群或云服务。这样可以节省时间和成本，提高开发效率和质量。
• 持续集成和交付：Kind可以与各种持续集成和交付工具集成，如Jenkins、Travis CI、GitLab CI等，让开发者可以在每次提交代码后自动构建、测试和部署应用到Kind集群中，实现快速反馈和迭代。
• 学习和教育：Kind可以作为一个学习和教育的工具，让学习者或教师可以轻松地在自己的电脑上体验和探索Kubernetes的特性和功能，而不需要配置复杂的环境或购买昂贵的资源。

Kind 是如何工作的

Kind 使用容器来模拟每一个 Kubernetes 节点，并在容器里面运行 Systemd。容器里的 Systemd 托管了 Kubelet 和 Containerd，然后容器内部的 Kubelet 把其它 Kubernetes 组件：Kube-Apiserver、Etcd、CNI 等等组件运行起来。

Kind 内部使用了 Kubeadm 这个工具来做集群的部署，包括高可用集群也是借助 Kubeadm 提供的特性来完成的。在高用集群下还会额外部署了一个 Nginx 来提供负载均衡 VIP。

安装 Kind 依赖组件

Kind 把部署 Kubernetes 环境的依赖降低到了最小，仅需要机器安装 Docker 即可。

安装 Docker

这里以 Linux 系统为例：

$ curl -sSL https://get.daocloud.io/docker | sh

更多平台的安装方法可参考官方文档：https://docs.docker.com/install/

验证Docker是否安装成功，通过 docker version命令。

安装 Kubectl

如果你需要通过命令行管理集群，则需要安装 Kubectl。

Kubernetes 命令行工具kubectl允许你针对 Kubernetes 集群运行命令。你可以使用 kubectl 部署应用程序、检查和管理集群资源以及查看日志。

注意：kubectl 版本和集群版本之间的差异必须在一个小版本号内。例如：v1.26 版本的客户端能与 v1.25、 v1.26 和 v1.27 版本的控制面通信。

Kubernetes 版本以 x.y.z 表示，其中 x 是主要版本， y 是次要版本，z 是补丁版本，遵循语义版本控制术语。

简而言之，你的kubectl 版本，能够支持的kubenetes集群测次要版本版本为（kubectl 版本-1个次要版本，kubectl 版本，kubectl 版本+1个次要版本）

下载kubectl

curl -LO "https://dl.k8s.io/release/$(curl -L -s https://dl.k8s.io/release/stable.txt)/bin/linux/amd64/kubectl"

如需下载某个指定的版本，请用指定版本号替换该命令的这一部分： $(curl -L -s https://dl.k8s.io/release/stable.txt)。

例如，要在 Linux 中下载 v1.26.0 版本，请输入：

curl -LO https://dl.k8s.io/release/v1.26.0/bin/linux/amd64/kubectl

安装 kubectl

sudo install -o root -g root -m 0755 kubectl /usr/local/bin/kubectl

即使你没有目标系统的 root 权限，你仍然可以将 kubectl 安装到目录 ~/.local/bin 中，操作步骤如下：

chmod +x kubectl
mkdir -p ~/.local/bin
mv ./kubectl ~/.local/bin/kubectl
# 之后将 ~/.local/bin 附加（或前置）到 $PATH

执行测试，以确保你安装成功了：

$ kubectl version --client

WARNING: This version information is deprecated and will be replaced with the output from kubectl version --short.  Use --output=yaml|json to get the full version.
Client Version: version.Info{Major:"1", Minor:"26", GitVersion:"v1.26.0", GitCommit:"b46a3f887ca979b1a5d14fd39cb1af43e7e5d12d", GitTreeState:"clean", BuildDate:"2022-12-08T19:58:30Z", GoVersion:"go1.19.4", Compiler:"gc", Platform:"linux/amd64"}

安装 Kind

Kind 使用 Golang 进行开发，原生支持良好的跨平台特性，通常只需要直接下载构建好的二进制文件就可使用。

Kind发布页面(https://github.com/kubernetes-sigs/kind/releases)上提供了稳定的二进制文件。

通常推荐稳定版本用于 CI 的使用。要安装，请从“Assets”下载适用于你平台的二进制文件并将其放入你的$PATH：

Linux 环境：

curl -Lo ./kind "https://kind.sigs.k8s.io/dl/v0.17.0/kind-$(uname)-amd64"
chmod +x ./kind
sudo mv ./kind /usr/local/bin/kind

使用 Kind 搭建一个单节点集群

搭建单节点集群是 Kind 最基础的功能，当然使用起来也很简单，仅需一条指令kind create cluster即可完成。

kind create cluster --name fly-cluster
Creating cluster "fly-cluster" ...
 ✓ Ensuring node image (kindest/node:v1.25.3) 🖼 
 ✓ Preparing nodes 📦  
 ✓ Writing configuration 📜 
 ✓ Starting control-plane 🕹️️️️️️️️️️️️️️️️️️️️️️️️️️️️️️️️️️️️️️️️️️️️️️️️️️️️️️️️️️️️️️️️️️️️️️️️️️️️️️️️️️️️️️️️️️️️️️️️️️️️️️️️️️️️️️️️️️️️️️️️️️️️️️️️️️️️️️️️️️️️️️️️️️️️️️️️️️️️️️️️️️️️️️️️️️️️️️️️️️️️️️️️️️️️️️️️️️️️️️️️️️️️️️️️️️️ 
 ✓ Installing CNI 🔌 
 ✓ Installing StorageClass 💾 
Set kubectl context to "kind-fly-cluster"
You can now use your cluster with:

kubectl cluster-info --context kind-fly-cluster

Have a nice day! 👋

以上命令中 --name 是可选参数。如果不指定，默认创建出来的集群名字为 kind。

这将使用预先构建的Node Image引导创建部署 Kubernetes 集群。预构建镜像托管在kindest/node(https://hub.docker.com/r/kindest/node/)，但要找到适合当前给定版本的镜像，你应该查看给定kind版本（检查`kind version`）的发行说明，你可以在其中找到为kind发布创建的镜像的完整列表。

使用默认安装的方式时，我们没有指定任何配置文件。从安装过程的输出来看，一共分为 4 步：

• 检查本地环境是否存在一个基础的安装镜像，默认是 kindest/node:v1.25.3，该镜像里面包含了所有需要安装的东西，包括：kubectl、kubeadm、kubelet 的二进制文件，以及安装对应版本 Kubernetes 所需要的镜像。
• 准备 Kubernetes 节点，主要就是启动容器、解压镜像这类的操作。
• Kind 实际使用 Kubeadm 进行集群的创建。所以，需要建立对应的 kubeadm 的配置，完成之后就通过 kubeadm 进行安装。安装完成后还会做一些清理操作，比如：删掉主节点上的污点，否则对于没有容忍的 Pod 无法完成部署。
• 上面所有操作都完成后，就成功启动了一个 Kubernetes 集群并输出一些操作集群的提示信息。

kubeadm 启动后，Kind会导出KUBECONFIG到~/.kube/config，然后应用Overlay网络。

用于配置集群访问的文件有时被称为 kubeconfig 文件。这是一种引用配置文件的通用方式，并不意味着存在一个名为 kubeconfig 的文件。

此时用户可以使用导出的 kubeconfig 来测试 Kubernetes。

使用kubectl 访问Kind集群

为了让 kubectl 能发现并访问 Kubernetes 集群，你需要一个 kubeconfig 文件，该文件在 kube-up.sh 创建集群时，或成功部署一个 Minikube/Kind 集群时，均会自动生成。通常，kubectl 的配置信息存放于文件 ~/.kube/config 中。

通过上文我们知道Kind部署后，默认情况下，如果未设置 $KUBECONFIG 环境变量，则集群访问配置存储在 ~/.kube/config 中。

查看~/.kube/config配置文件

# cat ~/.kube/config
apiVersion: v1
clusters:
- cluster:
    certificate-authority-data: ...
    server: https://127.0.0.1:45709
  name: kind-fly-cluster
contexts:
- context:
    cluster: kind-fly-cluster
    user: kind-fly-cluster
  name: kind-fly-cluster
current-context: kind-fly-cluster
kind: Config
preferences: {}
users:
- name: kind-fly-cluster
  user:
    client-certificate-data: ...
    client-key-data: ...

如果~/.kube/config被删除，或没有被创建，则可以使用kind get kubeconfig获取kind创建的集群的kubeconfig 文件。

# 获取指定集群的配置文件所在的路径
$ export KUBECONFIG="$(kind get kubeconfig --name="fly-cluster")"

通过获取集群状态的方法，检查是否已恰当地配置了 kubectl：

$ kubectl cluster-info
Kubernetes control plane is running at https://127.0.0.1:45709
CoreDNS is running at https://127.0.0.1:45709/api/v1/namespaces/kube-system/services/kube-dns:dns/proxy

To further debug and diagnose cluster problems, use 'kubectl cluster-info dump'.

如果返回一个 URL，则意味着 kubectl 成功地访问到了你的集群。

如果你看到如下所示的消息，则代表 kubectl 配置出了问题，或无法连接到 Kubernetes 集群。

# 访问 <server-name:port> 被拒绝 - 你指定的主机和端口是否有误？
The connection to the server <server-name:port> was refused - did you specify the right host or port?

如果命令 kubectl cluster-info 返回了 URL，但你还不能访问集群，那可以用以下命令来检查配置是否妥当：

kubectl cluster-info dump

接下来，我们根据上面命令执行完后，输出的提示信息进行操作来验证一下集群是否部署成功。

验证集群组件状态

kubectl get cs
Warning: v1 ComponentStatus is deprecated in v1.19+
NAME                 STATUS    MESSAGE                         ERROR
controller-manager   Healthy   ok                              
scheduler            Healthy   ok                              
etcd-0               Healthy   {"health":"true","reason":""}

输出状态是Healthy，表示集群组件是健康的。

验证集群节点状态

kubectl get nodes
NAME                        STATUS   ROLES           AGE    VERSION
fly-cluster-control-plane   Ready    control-plane   166m   v1.25.3

从上面的输出结果，可以看到单节点的 Kubernetes 已经搭建成功。

单节点集群默认方式启动的节点角色是 control-plane，该节点包含了所有的组件。这些组件分别是：Coredns、Etcd、Api-Server、Controller-Manager、Kube-Proxy、Sheduler 和网络插件 kindnet，以及存储local-path。

使用 Kind 创建特定版本的K8S集群

只需要使用--image标志指定另一个镜像，就可以部署一个特定版本的Kubernetes集群。如下：

kind create cluster --image=kindest/node:v1.22.2

使用不同的kindest/node镜像允许你更改创建的集群的 Kubernetes 版本。kindest/node镜像Tag和Kubernetes 版本版本时一一对应的。

用Kind创建高可用 Kubernetes 集群

Kind 也支持搭建高可用的 Kubernetes 集群，创建方式和多节点集群类似，也是通过配置文件来实现。

自定义高可用 Kubernetes 集群配置文件

该自定义配置启动了 6 个容器分别用于模拟 3 个 k8s 控制器节点和 3 个 k8s Worker 节点

cat > ha-kind-config.yaml << EOF
kind: Cluster
apiVersion: kind.x-k8s.io/v1alpha4
networking:
  kubeProxyMode: "ipvs"         # kube-proxy 工作模式
  # podSubnet: "10.15.0.0/16"
  # serviceSubnet: "10.16.0.0/16"
kubeadmConfigPatches:
- |
  apiVersion: kubeadm.k8s.io/v1beta2
  kind: InitConfiguration
  metadata:
    name: config
  imageRepository: registry.aliyuncs.com/google_containers    # 指定镜像仓库
  nodeRegistration:
    kubeletExtraArgs:
      pod-infra-container-image: registry.aliyuncs.com/google_containers/pause:3.7    # 指定 pause 镜像版本  
- |
  apiVersion: kubeadm.k8s.io/v1beta3
  kind: ClusterConfiguration
  metadata:
    name: config
  kubernetesVersion: "1.25.3"
  networking:
    serviceSubnet: 10.15.0.0/16
    podSubnet: 10.16.0.0/16
    dnsDomain: cluster.local  
nodes:
- role: control-plane
  # 通过 kubeadm 配置 kubeletExtraArgs，指定 ingress controller 绑定到当前 kind 节点
  kubeadmConfigPatches:
  - |
    kind: InitConfiguration
    nodeRegistration:
      kubeletExtraArgs:
        node-labels: "ingress-ready=true"    
  extraPortMappings:
  - containerPort: 30443
    hostPort: 31443
    listenAddress: "0.0.0.0"
    protocol: TCP
  - containerPort: 80
    hostPort: 80
  - containerPort: 443
    hostPort: 443
- role: control-plane
- role: control-plane
- role: worker
- role: worker
- role: worker
EOF

这里，我们通过直接在配置文件里使用国内容器镜像源的方式解决了官方容器镜像源不可用的问题，同时也达到了加速集群创建的目的。

设置Ingress Controller

Kind 官方推出的 Ingress 控制器是基于 Nginx 构建的，并且可以使用 Kubernetes 集群本地运行的容器镜像轻松地运行 Ingress 控制器。

我们可以在创建集群时利用 KIND 的配置选项extraPortMapping将端口从主机转发到节点上运行的Ingress Controller。

我们还可以通过在 kubeadm 的InitConfiguration中使用来设置自定义节点标签node-labels ，以供Ingress Controller使用nodeSelector。

• extraPortMappings：允许本地主机通过端口 80/443 向 Ingress 控制器发出请求
• node-labels：只允许Ingress Controller在与标签选择器匹配的特定节点上运行

具体来说，extraPortMappings 将 kind 节点端口(containerPort)映射到本地宿主机端口(hostPort)， containerPort 端口为 k8s 中类型为 NodePort 的 Service 映射到本地 kind 节点的端口。

备注：
‍Ingress 允许您将外部流量路由到 Kubernetes 集群中的服务。它提供了一种灵活的方式来暴露服务，支持负载均衡、TLS 终止和基于主机和路径的路由。Ingress 由一个或多个 Ingress 资源组成，每个资源定义了一个或多个规则，用于将流量路由到指定的后端服务。

在 Kubernetes 中，Ingress 控制器是负责实现 Ingress 的组件。它监听 Kubernetes API 中的 Ingress 资源，并将其转换为底层负载均衡规则。在您的 Kubernetes 集群中安装 Ingress 控制器后，您可以创建 Ingress 资源来配置您的应用程序的外部访问。‍

可以通过以下命令创建一个定制的集群:

$ kind create cluster --config ha-kind-config.yaml

Creating cluster "kind" ...
 ✓ Ensuring node image (kindest/node:v1.25.3) 🖼
 ✓ Preparing nodes 📦 📦 📦 📦 📦 📦  
 ✓ Configuring the external load balancer ⚖️️️️️️️ 
 ✓ Writing configuration 📜 
 ✓ Starting control-plane 🕹️️️️️️️️️️️️️️️️️️️️️️️️️️️️️️️️️️️️️️️️️️️️️️️️️️️️️️️️️️️️️️️️️️️️️️️️️️️️️️️️️️️️️️️️️️️️️️️️️️️️️️️️️️️️️️️️️️️️️️️️️️️️️️️️️️️️️️️️️️️️️️️️️️️️️️️️️️️️️️️️️️️️️️️️️️️️️️️️️️️️️️️️️️️️️️️️️️️️️️️️️️️️️️️️️️️️️️️️️️️️️️️️️️️️️️️️️️️️️️️️️️️️️️️️️️️️️️️️️️️️️️️️️️️️️️️️️️️️️️️️️️️️️️️️️️️️️️️️️️️️️️️️️️️️️️️️️️️️️️️️️️️️️️️️️️ 
 ✓ Installing CNI 🔌 
 ✓ Installing StorageClass 💾 
 ✓ Joining more control-plane nodes 🎮 
 ✓ Joining worker nodes 🚜 
Set kubectl context to "kind-kind"
You can now use your cluster with:

kubectl cluster-info --context kind-kind

Not sure what to do next? 😅  Check out https://kind.sigs.k8s.io/docs/user/quick-start/

和上面创建的单节点集群一样，我们同样根据上面命令执行完后，输出的提示信息进行操作来验证一下集群是否部署成功。

# 集群信息
$ kubectl cluster-info
Kubernetes control plane is running at https://127.0.0.1:36183
CoreDNS is running at https://127.0.0.1:36183/api/v1/namespaces/kube-system/services/kube-dns:dns/proxy

To further debug and diagnose cluster problems, use 'kubectl cluster-info dump'.
# 集群组件状态
$ kubectl get cs
Warning: v1 ComponentStatus is deprecated in v1.19+
NAME                 STATUS    MESSAGE                         ERROR
scheduler            Healthy   ok                              
controller-manager   Healthy   ok                              
etcd-0               Healthy   {"health":"true","reason":""}   

# 集群节点状态
$ kubectl get node
NAME                  STATUS   ROLES           AGE     VERSION
kind-control-plane    Ready    control-plane   8m31s   v1.25.3
kind-control-plane2   Ready    control-plane   8m2s    v1.25.3
kind-control-plane3   Ready    control-plane   7m19s   v1.25.3
kind-worker           Ready    <none>          6m48s   v1.25.3
kind-worker2          Ready    <none>          6m48s   v1.25.3
kind-worker3          Ready    <none>          6m48s   v1.25.3

kind 部署环境中，默认安装 haproxy 组件，实现 kube-apiserver 的负载均衡

查看宿主机的Docker进程

$ docker ps
CONTAINER ID   IMAGE                                COMMAND                  CREATED          STATUS          PORTS                                                                                           NAMES
ec6cf40b9e07   kindest/haproxy:v20220607-9a4d8d2a   "haproxy -sf 7 -W -d…"   14 minutes ago   Up 14 minutes   127.0.0.1:36183->6443/tcp                                                                       kind-external-load-balancer
e708ed9754af   kindest/node:v1.25.3                 "/usr/local/bin/entr…"   15 minutes ago   Up 15 minutes                                                                                                   kind-worker2
6cfc098c5104   kindest/node:v1.25.3                 "/usr/local/bin/entr…"   15 minutes ago   Up 15 minutes   127.0.0.1:34226->6443/tcp                                                                       kind-control-plane3
3a19c92550ba   kindest/node:v1.25.3                 "/usr/local/bin/entr…"   15 minutes ago   Up 15 minutes                                                                                                   kind-worker
e95c85087c9c   kindest/node:v1.25.3                 "/usr/local/bin/entr…"   15 minutes ago   Up 15 minutes   0.0.0.0:80->80/tcp, 0.0.0.0:443->443/tcp, 127.0.0.1:43524->6443/tcp, 0.0.0.0:31443->30443/tcp   kind-control-plane
9f3c62b6e115   kindest/node:v1.25.3                 "/usr/local/bin/entr…"   15 minutes ago   Up 15 minutes   127.0.0.1:42330->6443/tcp                                                                       kind-control-plane2
11049cabf555   kindest/node:v1.25.3                 "/usr/local/bin/entr…"   15 minutes ago   Up 15 minutes                                                                                                   kind-worker3

一共有7个Docker进程: 分别是一个haproxy组件，3个control-plane节点，3个worker节点

其中，经宿主机的36183端口映射到 haproxy frontend bind port, 该 frontend 对应 backend 为三个control-plane节点上部署的 kube-apiserver。

36183端口，也是我们kubectl访问API Server的端口。我们也可以通过kind get kubeconfig命令验证。

$ kind get kubeconfig  | grep server
    server: https://127.0.0.1:36183

haproxy 主要配置

haproxy 配置文件 /usr/local/etc/haproxy/haproxy.cfg

frontend control-plane
  bind *:6443
  default_backend kube-apiservers

backend kube-apiservers
  option httpchk GET /healthz
  server kind-control-plane kind-control-plane:6443 check check-ssl verify none resolvers docker resolve-prefer ipv4
  server kind-control-plane2 kind-control-plane2:6443 check check-ssl verify none resolvers docker resolve-prefer ipv4
  server kind-control-plane3 kind-control-plane3:6443 check check-ssl verify none resolvers docker resolve-prefer ipv4

Kind 部署WEB应用

我们这里通过Deployment部署一个Nginx应用，该应用会在集群上运行两个示例。

然后，我们再通过部署一个NodePort类型的Service资源，使得Nginx应用能被集群内外的服务访问。

导入镜像

$docker pull nginx:1.14.2
$ kind load docker-image nginx:1.14.2

部署 Deployment资源

$ kubectl apply -f - <<EOF
apiVersion: apps/v1
kind: Deployment
metadata:
  name: nginx-deployment
spec:
  selector:
    matchLabels:
      app: nginx
  replicas: 2 # tells deployment to run 2 pods matching the template
  template:
    metadata:
      labels:
        app: nginx
    spec:
      containers:
      - name: nginx
        image: nginx:1.14.2
        ports:
        - containerPort: 80
EOF

部署 Service资源

$ kubectl apply -f - <<EOF
apiVersion: v1
kind: Service
metadata:
  name: my-nginx
spec:
  selector:
    app: nginx
  type: NodePort
  ports:
    - protocol: TCP
      port: 80
EOF

验证应用和服务状态

kubectl get all -owide
NAME                                    READY   STATUS    RESTARTS   AGE     IP          NODE           NOMINATED NODE   READINESS GATES
pod/nginx-deployment-7fb96c846b-w64dh   1/1     Running   0          9m23s   10.16.5.4   kind-worker3   <none>           <none>
pod/nginx-deployment-7fb96c846b-zs5f8   1/1     Running   0          9m23s   10.16.3.4   kind-worker2   <none>           <none>

NAME                 TYPE        CLUSTER-IP     EXTERNAL-IP   PORT(S)        AGE     SELECTOR
service/kubernetes   ClusterIP   10.15.0.1      <none>        443/TCP        4h48m   <none>
service/my-nginx     NodePort    10.15.191.79   <none>        80:30216/TCP   2m9s    app=nginx

NAME                               READY   UP-TO-DATE   AVAILABLE   AGE     CONTAINERS   IMAGES         SELECTOR
deployment.apps/nginx-deployment   2/2     2            2           9m23s   nginx        nginx:1.14.2   app=nginx

NAME                                          DESIRED   CURRENT   READY   AGE     CONTAINERS   IMAGES         SELECTOR
replicaset.apps/nginx-deployment-7fb96c846b   2         2         2       9m23s   nginx        nginx:1.14.2   app=nginx,pod-template-hash=7fb96c846b

访问pod和service

# 进入集群的控制平面
docker exec -it kind-control-plane /bin/bash

# 访问service
root@kind-control-plane:/# curl 10.15.0.1
<html>
<head><title>404 Not Found</title></head>
<body>
<center><h1>404 Not Found</h1></center>
<hr><center>nginx</center>
</body>
</html>

# 访问pod
root@kind-control-plane:/# curl 10.16.5.4
<!DOCTYPE html>
<html>
<head>
<title>Welcome to nginx!</title>
....

部署 Ingress-Nginx Controller

# Ingress-Nginx 控制器，默认 Service 类型为 NodePort
kubectl apply -f https://raw.githubusercontent.com/kubernetes/ingress-nginx/main/deploy/static/provider/kind/deploy.yaml

依赖的镜像版本:

• registry.k8s.io/ingress-nginx/controller:v1.6.4

• registry.k8s.io/ingress-nginx/kube-webhook-certgen:v20220916-gd32f8c343

镜像如果不能下载，可以使用以下方式

# 下载镜像
$ wget https://raw.githubusercontent.com/anjia0532/gcr.io_mirror/master/pull-k8s-image.sh
$ chmod +x pull-k8s-image.sh
$ ./pull-k8s-image.sh registry.k8s.io/ingress-nginx/controller:v1.6.4
$ ./pull-k8s-image.sh registry.k8s.io/ingress-nginx/kube-webhook-certgen:v20220916-gd32f8c343

# 将镜像加载到kind集群中
$ kind load docker-image registry.k8s.io/ingress-nginx/controller:v1.6.4
$ kind load docker-image registry.k8s.io/ingress-nginx/kube-webhook-gd32f8c343

清单包含Kind特定的补丁，用于将主机端口转发到Ingress Controller，设置污点容忍度并将其调度到自定义标记的节点。

现在 Ingress 已全部设置完毕。等到准备好处理运行中的请求：

$ kubectl wait --namespace ingress-nginx \
  --for=condition=ready pod \
  --selector=app.kubernetes.io/component=controller \
  --timeout=90s
  
pod/ingress-nginx-controller-74c4fc549d-g5xj7 condition met

使用 Ingress

以下示例创建简单的 http-echo 服务和一个 Ingress 对象以路由到这些服务。

kind: Pod
apiVersion: v1
metadata:
  name: foo-app
  labels:
    app: foo
spec:
  containers:
  - command:
    - /agnhost
    - netexec
    - --http-port
    - "8080"
    image: registry.k8s.io/e2e-test-images/agnhost:2.39
    name: foo-app
---
kind: Service
apiVersion: v1
metadata:
  name: foo-service
spec:
  selector:
    app: foo
  ports:
  # Default port used by the image
  - port: 8080
---
kind: Pod
apiVersion: v1
metadata:
  name: bar-app
  labels:
    app: bar
spec:
  containers:
  - command:
    - /agnhost
    - netexec
    - --http-port
    - "8080"
    image: registry.k8s.io/e2e-test-images/agnhost:2.39
    name: bar-app
---
kind: Service
apiVersion: v1
metadata:
  name: bar-service
spec:
  selector:
    app: bar
  ports:
  # Default port used by the image
  - port: 8080
---
apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
  name: example-ingress
  annotations:
    nginx.ingress.kubernetes.io/rewrite-target: /$2
spec:
  rules:
  - http:
      paths:
      - pathType: Prefix
        path: /foo(/|$)(.*)
        backend:
          service:
            name: foo-service
            port:
              number: 8080
      - pathType: Prefix
        path: /bar(/|$)(.*)
        backend:
          service:
            name: bar-service
            port:
              number: 8080
---

以上文件信息来自于：https://kind.sigs.k8s.io/examples/ingress/usage.yaml

镜像如果不能下载，可以使用以下方式

# 下载镜像
$ docker pull  lank8s.cn/e2e-test-images/agnhost:2.39
$ docker tag  lank8s.cn/e2e-test-images/agnhost:2.39 registry.k8s.io/e2e-test-images/agnhost:2.39

# 将镜像加载到kind集群中
$ kind load registry.k8s.io/e2e-test-images/agnhost:2.39

应用内容

kubectl apply -f https://kind.sigs.k8s.io/examples/ingress/usage.yaml

验证应用状态

# kubectl get all -owide
NAME                                    READY   STATUS    RESTARTS   AGE   IP          NODE           NOMINATED NODE   READINESS GATES
pod/bar-app                             1/1     Running   0          42s   10.16.5.5   kind-worker3   <none>           <none>
pod/foo-app                             1/1     Running   0          43s   10.16.4.4   kind-worker    <none>           <none>


NAME                  TYPE        CLUSTER-IP     EXTERNAL-IP   PORT(S)        AGE     SELECTOR
service/bar-service   ClusterIP   10.15.219.10   <none>        8080/TCP       42s     app=bar
service/foo-service   ClusterIP   10.15.95.119   <none>        8080/TCP       43s     app=foo
service/kubernetes    ClusterIP   10.15.0.1      <none>        443/TCP        4h58m   <none>

现在验证ingress是否有效

# should output "foo-app"
$ curl localhost/foo/hostname
> foo-app
# should output "bar-app"
curl localhost/bar/hostname
> bar-app

上文中，我们在kind集群中的部署WEB应用(Nginx)，是无法在宿主机通过ClusterIP或者NodePort访问，必须进入集群才可以访问。如下：

# NodePort访问
$  curl 192.168.172.128:30216
curl: (7) Failed connect to 192.168.172.128:30216; Connection refused
# ClusterIP访问
$  curl 10.15.191.79
^C

现在我们有了ingress controller后，我们可以借助ingress来访问

$ kubectl apply -f - <<EOF
apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
  name: example-ingress
  annotations:
    nginx.ingress.kubernetes.io/rewrite-target: /$2
spec:
  rules:
  - http:
      paths:
      - pathType: Prefix
        path: /nginx(/|$)(.*)
        backend:
          service:
            name: my-nginx
            port:
              number: 80
EOF

验证

地址格式：localhost/service名称

# 宿主机访问
$ curl localhost/nginx
<!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>

删除kind集群

如果你不需要本地的集群环境，通过以下命令进行删除：

# 删除一个kind集群
$ kind delete  cluster --name fly-cluster
Deleting cluster "fly-cluster" ...

# 清理KUBECONFIG 文件
rm -rf $HOME/.kube/config

如果你想一次性删除所有集群，请执行：

$ kind delete clusters –all
Deleted clusters: ["–all"]

ITPub博客

还在苦恼快速搭建K8S环境，试试Kind吧