第2章 云原生应用实战-搭建Kubernetes环境

作者：王珂
邮箱：49186456@qq.com


文章目录

  • 第2章 云原生应用实战-搭建Kubernetes环境
  • 前言
  • 一、安装Kubernetes
  • 1.1 环境准备
  • 1.2 环境配置
  • 1.3 安装K8S组件
  • 1.4 集群初始化
  • 二、安装Ingress
  • 三、安装NFS并配置
  • 四、安装StorageClass
  • 五、安装Helm
  • 总结


前言

本节课程主要给大家介绍如何搭建一个Kubernetes环境。安装Kubernetes涉及到Linux服务器的配置，Kubernetes镜像包下载，Kubernetes自身相关配置等。因环境配置，安装步骤较多，中间涉及到很多的注意点，如果处理不当会费时费力，希望通过本教程使大家避免踩坑，快速大家一个Kubernetes环境，以便方面后面学习。

一、安装Kubernetes

1.1 环境准备

我们准备搭建一个一主三从的Kubernetes集群，服务器规划如下：

主机名

IP地址

操作系统

配置

node21(master)

192.168.1.21

CentOS 7

CPU: 2核，内存: 2G，硬盘：50G

node26(node)

192.168.1.26

CentOS 7

CPU: 2核，内存: 2G，硬盘：50G

node27(node)

192.168.1.27

CentOS 7

CPU: 2核，内存: 2G，硬盘：50G

node28(node)

192.168.1.28

CentOS 7

CPU: 2核，内存: 2G，硬盘：50G

配置信息

配置项

配置值

说明

Service网段

10.96.0.0/12

不要和宿主机在同一个网段

Pod网段

10.244.0.0/16

不要和宿主机在同一个网段

一主三从，需要三台CentOS服务器，需要在每台服务器中分别安装

  • docker-23.0.1
  • kubeadm-1.23.0
  • kubectl-1.23.0
  • kubelet-1.23.0

1.2 环境配置

要求CentOS版本在7.5或以上，使用下面命令查看

cat /etc/redhat-release

查询结果

CentOS Linux release 7.9.2009 (Core)

推荐Linux内核在4.0+

uname -r

查询结果

4.19.12-1.el7.elrepo.x86_64

以下步骤需要在每台服务器上执行

1）主机名解析

在/etc/hosts中配置每台服务器的域名

192.168.1.21 node21

192.168.1.26 node26

192.168.1.27 node27

192.168.1.28 node28

2）时间同步

yum install ntpdate -y
ntpdate time.windows.com

3）关闭firewalld服务

关闭防火墙

systemctl stop firewalld

禁止开机启动

systemctl disable firewalld

4）关闭iptables服务

关闭iptables

systemctl stop iptables

禁止开机启动

systemctl disable iptables

5）禁用selinux

查看selinux状态

# enforcing（执行模式）、permissive（宽容模式）、disabled（禁用模式）
getenforce

设置 SELinux 为 permissive 模式

# 0: permissive（宽容模式）；1：enforcing（执行模式）
setenforce 0

永久停止

vim /etc/selinux/config

# 修改
SELINUX=disabled

6）禁用swap分区

vim /etc/fstab

# 注释掉，修改完需要重启Linux
#/dev/mapper/centos-swap swap swap defaults 0 0

7）重启

reboot

1.3 安装K8S组件

由于kubenetes的镜像在国外，速度比较慢，所以切换成国内的镜像源

以下步骤需要在每台服务器上执行

1）编辑/etc/yum.repos.d/kubernetes.repo，添加内容如下：

cat > /etc/yum.repos.d/kubernetes.repo << EOF
[kubernetes]
name=Kubernetes
baseurl=https://mirrors.aliyun.com/kubernetes/yum/repos/kubernetes-el7-x86_64/
enabled=1
gpgcheck=0
repo_gpgcheck=0
gpgkey=https://mirrors.aliyun.com/kubernetes/yum/doc/yum-key.gpg https://mirrors.aliyun.com/kubernetes/yum/doc/rpm-package-key.gpg
EOF

2）刷新yum源

yum clean all && yum makecache

3）安装kubeadm, kubectl, kubelet

yum install kubeadm-1.23.0 kubectl-1.23.0 kubelet-1.23.0 -y

4）配置kubelet

cat > /etc/sysconfig/kubelet << EOF
KUBELET_EXTRA_ARGS="--cgroup-driver=systemd --pod-infra-container-image=registry.cn-hangzhou.aliyuncs.com/google_containers/pause-amd64:3.2"
KUBELET_CGROUP_ARGS="--cgroup-driver=systemd"
KUBE_PROXY_MODE="ipvs"
EOF

配置说明：

  • 配置cgroup

KUBELET_EXTRA_ARGS=“–cgroup-driver=systemd --pod-infra-container-image=registry.cn-hangzhou.aliyuncs.com/google_containers/pause-amd64:3.2”

KUBELET_CGROUP_ARGS=“–cgroup-driver=systemd”

  • 配置Service的代理为ipvs，如果未配置会自动降级为iptables

KUBE_PROXY_MODE=“ipvs”

5）设置开机自启动

systemctl enable kubelet

6）修改Linux内核

将桥接的IPv4流量传递到iptables的链

cat > /etc/sysctl.d/k8s.conf << EOF
net.bridge.bridge-nf-call-ip6tables = 1
net.bridge.bridge-nf-call-iptables = 1
net.ipv4.ip_forward = 1
EOF

重新加载配置

sysctl --system

或

sysctl -p /etc/sysctl.d/k8s.conf

加载网桥过滤模块

modprobe br_netfilter

查看网桥过滤模块是否加载成功

lsmod | grep br_netfilter

结果如下：

结果空

1.4 集群初始化

以下命令只需要在master节点上执行

  1. 初始化集群
kubeadm init \
--image-repository registry.aliyuncs.com/google_containers \
--service-cidr=10.96.0.0/12 \
--pod-network-cidr=10.244.0.0/16 \
--apiserver-advertise-address=192.168.1.21

使用kubeadm初始化kubernetes集群时需要从官网镜像仓库k8s.gcr.io拉取组件的镜像，但k8s.gcr.io在国内无法访问。解决方案是：可以先从阿里云的镜像仓库拉取镜像（只不过镜像名字前缀不一样而已），然后使用打标签的形式，把前缀换成k8s.gcr.io即可。步骤如下：

1）查看需要安装的镜像

kubeadm config images list

这里列出的镜像（包括镜像版本）就是初始化集群时需要拉取的镜像，我们在执行初始化命令之前可以先将镜像拉取下来以减小初始化所用的时间。

2）拉取镜像

images=(
    kube-apiserver:v1.23.17
    kube-controller-manager:v1.23.17
    kube-scheduler:v1.23.17
    kube-proxy:v1.23.17
    pause:3.6
    etcd:3.5.1-0
    coredns:1.8.6
)
for imageName in ${images[@]}; do
    docker pull registry.cn-hangzhou.aliyuncs.com/google_containers/$imageName
    docker tag registry.cn-hangzhou.aliyuncs.com/google_containers/$imageName k8s.gcr.io/$imageName

    docker rmi registry.cn-hangzhou.aliyuncs.com/google_containers/$imageName
done

注意，images变量中定义了要拉取的镜像（即kubeadm config images list命令列出的镜像），镜像的版本要和步骤1）中的一致。

初始化成功之后会在控制台看到如下信息

Your Kubernetes control-plane has initialized successfully!
To start using your cluster, you need to run the following as a regular user:
mkdir -p $HOME/.kube
 sudo cp -i /etc/kubernetes/admin.conf $HOME/.kube/config
 sudo chown (id -g) $HOME/.kube/configAlternatively, if you are the root user, you can run:
export KUBECONFIG=/etc/kubernetes/admin.conf
You should now deploy a pod network to the cluster.
 Run “kubectl apply -f [podnetwork].yaml” with one of the options listed at:
 https://kubernetes.io/docs/concepts/cluster-administration/addons/Then you can join any number of worker nodes by running the following on each as root:
kubeadm join 192.168.1.21:6443 --token ft41l8.wvovoiqiu9mo069y 
 –discovery-token-ca-cert-hash sha256:fd4f7d1f661fa40585eef8370f5f8e947c317ebdd151a5e18ec521854aaa21ce
  1. 创建必要文件
mkdir -p $HOME/.kube
sudo cp -i /etc/kubernetes/admin.conf $HOME/.kube/config
sudo chown $(id -u):$(id -g) $HOME/.kube/config
  1. 安装CNI网络插件

Kubenetes支持多种网络插件，比如flannel, calico, canal等，任选一种即可。

安装Calico

1）下载

下载calico.yaml文件到/opt/kubernetes/network目录

wget https://docs.projectcalico.org/v3.23/manifests/calico.yaml --no-check-certificate

因为国内网络限制可能无法下载。你可以从我的阿里云盘下载：

# 阿里云盘地址（密码 j9h4）
https://www.aliyundrive.com/s/4oNEmViUCsr

2）执行安装

sed -i 's/192.168.0.0/10.244.0.0/g' calico.yaml
kubectl apply -f calico.yaml

注意：calico.yaml中的Pod网段地址 192.168.0.0，需要修改为10.244.0.0，与初始化集群时设置的Pod网段地址一致，否则会无法访问；

  1. 在master节点配置IPVS

在kubernetes中的service既可以做反向代理，又可以做负载均衡。

代理有两种模式，一种是基于iptables的，另一种基于ipvs。ipvs的性能要高一些，使用ipvs需要安装ipvs模块

1）安装ipset和ipvs

yum install -y ipset ipvsadm

2）添加需要加载的模块写入脚本

cat > /etc/sysconfig/modules/ipvs.modules << EOF
#!/bin/bash
modprobe -- ip_vs
modprobe -- ip_vs_rr
modprobe -- ip_vs_wrr
modprobe -- ip_vs_sh
#modprobe -- nf_conntrack_ipv4
modprobe -- nf_conntrack
EOF

3）为脚本添加执行权限

chmod +x /etc/sysconfig/modules/ipvs.modules

4）执行脚本

/bin/bash /etc/sysconfig/modules/ipvs.modules

5）查看模块是否加载成功

# 注意：低内核版本这里是nf_conntrack_ipv4
lsmod | grep -e ip_vs -e nf_conntrack
nf_conntrack_netlink 40960 0
 nfnetlink 16384 4 nf_conntrack_netlink,nf_tables,ip_set
 ip_vs_ftp 16384 0
 nf_nat 32768 4 nf_nat_ipv6,nf_nat_ipv4,xt_nat,ip_vs_ftp
 ip_vs_sed 16384 0
 ip_vs_nq 16384 0
 ip_vs_fo 16384 0
 ip_vs_sh 16384 0
 ip_vs_dh 16384 0
 ip_vs_lblcr 16384 0
 ip_vs_lblc 16384 0
 ip_vs_wrr 16384 0
 ip_vs_rr 16384 0
 ip_vs_wlc 16384 0
 ip_vs_lc 16384 0
 ip_vs 151552 24 ip_vs_wlc,ip_vs_rr,ip_vs_dh,ip_vs_lblcr,ip_vs_sh,ip_vs_fo,ip_vs_nq,ip_vs_lblc,ip_vs_wrr,ip_vs_lc,ip_vs_sed,ip_vs_ftp
 nf_conntrack 143360 9 xt_conntrack,nf_nat,ip6t_MASQUERADE,nf_nat_ipv6,ipt_MASQUERADE,nf_nat_ipv4,xt_nat,nf_conntrack_netlink,ip_vs
 nf_defrag_ipv6 20480 1 nf_conntrack
 nf_defrag_ipv4 16384 1 nf_conntrack
 libcrc32c 16384 4 nf_conntrack,nf_nat,xfs,ip_vs

6）修改master节点模式为ipvs

kubectl edit configmap kube-proxy -n kube-system

修改如下mode值为"ipvs"

ipvs:
excludeCIDRs: null
  minSyncPeriod: 0s
  scheduler: ""
  strictARP: false
  syncPeriod: 0s
  tcpFinTimeout: 0s
  tcpTimeout: 0s
  udpTimeout: 0s
kind: KubeProxyConfiguration
metricsBindAddress: ""
mode: "ipvs" # 这里修改为 ipvs

7）删除所有kube-proxy的pod

kubectl get pod -n kube-system | grep kube-proxy | awk '{system(" kubectl delete pod "$1" -n kube-system")}'

8）校验kube-proxy是否ipvs模式（该步骤待确认）

# 检查是否日志出现Using ipvs Proxier
kubectl logs kube-proxy-xxx -n kube-system
[root@node21 ~]# kubectl logs kube-proxy-hvk72 -n kube-system
 I0908 06:03:50.340569 1 node.go:163] Successfully retrieved node IP: 192.168.1.21
 I0908 06:03:50.340688 1 server_others.go:138] “Detected node IP” address=“192.168.1.21”
 I0908 06:03:50.365739 1 server_others.go:269] “Using ipvs Proxier”
  1. 将node节点加入集群

此步骤操作只需要在node节点执行

在node26, node27, node28分别执行一下脚本将其加入集群

kubeadm join 192.168.1.21:6443 --token ft41l8.wvovoiqiu9mo069y \
        --discovery-token-ca-cert-hash sha256:fd4f7d1f661fa40585eef8370f5f8e947c317ebdd151a5e18ec521854aaa21ce

查看集群状态（需要等待一会）

kubectl get nodes
NAME STATUS ROLES AGE VERSION
 node21 Ready control-plane,master 5h26m v1.23.0
 node26 Ready 25m v1.23.0
 node27 Ready 16m v1.23.0
 node28 Ready 14m v1.23.0

二、安装Ingress

我们通过kubectl apply命令安装Ingress。登录Github，搜索ingress-nginx，可以搜索到kubernetes/ingress-nginx，查看其支持的kubernetes版本。

下载deploy.yaml

wget https://raw.githubusercontent.com/kubernetes/ingress-nginx/controller-v1.1.1/deploy/static/provider/cloud/deploy.yaml

因为国内网络限制可能无法下载。你可以从我的阿里云盘下载：

# 阿里云盘地址（密码 j9h4）
https://www.aliyundrive.com/s/4oNEmViUCsr

使用kubectl apply -f deploy.yaml安装时会碰到拉取下面两个镜像失败问题。

  • registry.k8s.io/ingress-nginx/kube-webhook-certgen:v1.1.1
  • registry.k8s.io/ingress-nginx/controller:v1.2.0

作为替代，我们可以下载以下两个镜像

docker pull liangjw/kube-webhook-certgen:v1.1.1
docker pull bitnami/nginx-ingress-controller:1.2.0

然后修改deploy.yaml

  • 注释掉 externalTrafficPolicy: Local
  • 修改controller/deploy/的image

image: bitnami/nginx-ingress-controller:1.2.0

  • 修改ingress-nginx-admission-create的image

image: liangjw/kube-webhook-certgen:v1.1.1

  • 修改ingress-nginx-admission-patch的image

image: liangjw/kube-webhook-certgen:v1.1.1

  • 修改deploy.yaml种Service的类型LoadBalancer为NodePort
  • 自定义Ingress Service的Http和Http端口
apiVersion: v1
kind: Service
metadata:
  labels:
    app.kubernetes.io/component: controller
    app.kubernetes.io/instance: ingress-nginx
    app.kubernetes.io/name: ingress-nginx
    app.kubernetes.io/part-of: ingress-nginx
    app.kubernetes.io/version: 1.1.1
  name: ingress-nginx-controller
  namespace: ingress-nginx
spec:
  #externalTrafficPolicy: Local
  ports:
  - appProtocol: http
    name: http
    port: 80
    protocol: TCP
    targetPort: http
    nodePort: 30080 # ingress-nginx service对外暴露的http端口自定义为30080
  - appProtocol: https
    name: https
    port: 443
    protocol: TCP
    targetPort: https
    nodePort: 30443 # ingress-nginx service对外暴露的https端口自定义为30443
  selector:
    app.kubernetes.io/component: controller
    app.kubernetes.io/instance: ingress-nginx
    app.kubernetes.io/name: ingress-nginx
  type: NodePort # 类型修改为NodePort

执行

kubectl apply -f deploy.yaml

查看pod

kubectl get pod -n ingress-nginx -o wide
NAME                                        READY   STATUS      RESTARTS   AGE   IP            NODE    NOMINATED NODE   READINESS GATES
ingress-nginx-admission-create-l9592        0/1     Completed   0          10m   10.244.3.44   node6   <none>           <none>
ingress-nginx-admission-patch-4mvfq         0/1     Completed   1          10m   10.244.3.45   node6   <none>           <none>
ingress-nginx-controller-659d798fb6-qn8tl   1/1     Running     0          10m   10.244.3.46   node6   <none>           <none>

持续查看ingress-nginx-controller pod的日志

kubectl logs -f ingress-nginx-controller-659d798fb6-qn8tl -n ingress-nginx

查看Service

kubectl get svc -n ingress-nginx -o wide
NAME                                 TYPE        CLUSTER-IP       EXTERNAL-IP   PORT(S)                      AGE   SELECTOR
ingress-nginx-controller             NodePort    10.101.222.63    <none>        80:30080/TCP,443:30443/TCP   12m   app.kubernetes.io/component=controller,app.kubernetes.io/instance=ingress-nginx,app.kubernetes.io/name=ingress-nginx
ingress-nginx-controller-admission   ClusterIP   10.108.151.163   <none>        443/TCP                      12m   app.kubernetes.io/component=controller,app.kubernetes.io/instance=ingress-nginx,app.kubernetes.io/name=ingress-nginx

三、安装NFS并配置

1）为了简单，只在master节点创建nfs服务器

yum install nfs-utils -y

2）创建共享目录

mkdir -p /opt/nfs/data -pv

3）编写nfs共享

将共享目录以读写权限暴露给所有主机

cat > /etc/exports << EOF
/opt/nfs/data    *(rw,no_root_squash)
EOF

或将共享目录以读写权限只暴露给192.168.1.0/24网段中的所有主机

cat > /etc/exports << EOF
/opt/nfs/data    192.168.1.0/24(rw,no_root_squash)
EOF

4）启动nfs服务

# 开机自启动
systemctl enable nfs
# 启动nfs
systemctl start nfs

5）在三个工作节点(node26, node27, node28)上也安装nfs

yum install nfs-utils -y

安装完之后注意不需要启动，这样的目的是为了node节点可以驱动nfs设备

6）查看共享目录

showmount -e 192.168.1.21

四、安装StorageClass

StorageClass是一个存储类，通过创建StorageClass可以动态生成一个存储卷。使用StorageClass可以根据PVC动态创建PV，减少管理员手工创建PV的工作。

要使用StorageClass，就需要安装对应的配置程序，存储后端以nfs为例，需要使用到NFS-Subdir-External-Provisioner自动配置程序。

  1. 创建ServiceAccount

现在的 Kubernetes 集群大部分是基于 RBAC 的权限控制，所以我们需要创建一个拥有一定权限的 ServiceAccount 与后面要部署的 NFS Subdir Externa Provisioner 组件绑定。
注意：ServiceAccount是必须的，否则将不会动态创建PV，PVC状态一直为Pending。

RBAC 资源文件 nfs-rbac.yaml

apiVersion: v1
kind: ServiceAccount
metadata:
  name: nfs-client-provisioner
  namespace: dev
---
kind: ClusterRole
apiVersion: rbac.authorization.k8s.io/v1
metadata:
  name: nfs-client-provisioner-runner
rules:
  - apiGroups: [""]
    resources: ["persistentvolumes"]
    verbs: ["get", "list", "watch", "create", "delete"]
  - apiGroups: [""]
    resources: ["persistentvolumeclaims"]
    verbs: ["get", "list", "watch", "update"]
  - apiGroups: ["storage.k8s.io"]
    resources: ["storageclasses"]
    verbs: ["get", "list", "watch"]
  - apiGroups: [""]
    resources: ["events"]
    verbs: ["create", "update", "patch"]
---
kind: ClusterRoleBinding
apiVersion: rbac.authorization.k8s.io/v1
metadata:
  name: run-nfs-client-provisioner
subjects:
  - kind: ServiceAccount
    name: nfs-client-provisioner
    namespace: dev
roleRef:
  kind: ClusterRole
  name: nfs-client-provisioner-runner
  apiGroup: rbac.authorization.k8s.io
---
kind: Role
apiVersion: rbac.authorization.k8s.io/v1
metadata:
  name: leader-locking-nfs-client-provisioner
  namespace: dev
rules:
  - apiGroups: [""]
    resources: ["endpoints"]
    verbs: ["get", "list", "watch", "create", "update", "patch"]
---
kind: RoleBinding
apiVersion: rbac.authorization.k8s.io/v1
metadata:
  name: leader-locking-nfs-client-provisioner
  namespace: dev
subjects:
  - kind: ServiceAccount
    name: nfs-client-provisioner
    namespace: dev
roleRef:
  kind: Role
  name: leader-locking-nfs-client-provisioner
  apiGroup: rbac.authorization.k8s.io

先创建dev命名空间

kubectl create namespace dev

再创建角色权限

kubectl create -f nfs-rbac.yaml
  1. NFS-Subdir-External-Provisioner

我们以master（192.168.1.21）为nfs服务器，共享目录为/opt/nfs/data，StorageClass名称为storage-nfs 部署NFS-Subdir-External-Provisioner

创建nfs-provisioner-deploy.yaml

kind: Deployment
apiVersion: apps/v1
metadata:
  name: nfs-client-provisioner
  namespace: dev
spec:
  replicas: 1
  selector:
    matchLabels:
      app: nfs-client-provisioner
  strategy:
    type: Recreate # 设置升级策略为删除再创建(默认为滚动更新)
  template:
    metadata:
      labels:
        app: nfs-client-provisioner
    spec:
      serviceAccountName: nfs-client-provisioner  # 上一步创建的ServiceAccount名称
      containers:
        - name: nfs-client-provisioner
          image: registry.cn-beijing.aliyuncs.com/mydlq/nfs-subdir-external-provisioner:v4.0.0
          volumeMounts:
            - name: nfs-client-root
              mountPath: /persistentvolumes
          env:
            - name: PROVISIONER_NAME  # Provisioner的名称，以后设置的storageclass要和这个保持一致
              value: nfs-storage-provisioner
            - name: NFS_SERVER        # NFS服务器地址,需和valumes参数中配置的保持一致
              value: 192.168.1.21
            - name: NFS_PATH          # NFS服务器数据存储目录,需和valumes参数中配置的保持一致
              value: /opt/nfs/data
            - name: ENABLE_LEADER_ELECTION
              value: "true"
      volumes:
        - name: nfs-client-root
          nfs:
            server: 192.168.1.21    # NFS服务器地址
            path: /opt/nfs/data      # NFS共享目录

执行创建

kubectl apply -f nfs-provisioner-deploy.yaml

查看结果

kubectl get deploy,pod -n dev
  1. 创建NFS StorageClass

在创建 PVC 时经常需要指定 storageClassName 名称，这个参数配置的就是一个 StorageClass 资源名称，PVC 通过指定该参数来选择使用哪个 StorageClass，并与其关联的 Provisioner 组件来动态创建 PV 资源。所以，这里我们需要提前创建一个 Storagelcass 资源。

nfs-storage-class.yaml

apiVersion: storage.k8s.io/v1
kind: StorageClass
metadata:
  namespace: dev
  name: nfs-storage-class
  annotations:
    storageclass.kubernetes.io/is-default-class: "false" # 是否设置为默认的storageclass
provisioner: nfs-storage-provisioner # 动态卷分配者名称，必须和上面创建的deploy中环境变量“PROVISIONER_NAME”变量值一致
parameters:
  archiveOnDelete: "true" # 设置为"false"时删除PVC不会保留数据,"true"则保留数据
mountOptions: 
  - hard # 指定为硬挂载方式
  - nfsvers=4  # 指定NFS版本,这个需要根据NFS Server版本号设置

执行创建storageclass

kubectl apply -f nfs-storage-class.yaml

查看storageclass

kubectl get sc -n dev
  1. 测试PVC使用StorageClass

pvc-storage-test.yaml

kind: PersistentVolumeClaim
apiVersion: v1
metadata:
  name: storage-pvc
  namespace: dev
spec:
  storageClassName: nfs-storage-class # 需要与上面创建的storageclass的名称一致
  accessModes:
    - ReadWriteOnce
  resources:
    requests:
      storage: 10Mi

执行并查看

[root@node1 root]# kubectl get pvc,pv -n dev
NAME                                STATUS   VOLUME                                     CAPACITY   ACCESS MODES   STORAGECLASS   AGE
persistentvolumeclaim/storage-pvc   Bound    pvc-769b6aa7-d8c5-472a-8680-c1a43e0db0a5   1Mi        RWO            nfs-storage    52s

NAME                                                        CAPACITY   ACCESS MODES   RECLAIM POLICY   STATUS   CLAIM             STORAGECLASS   REASON   AGE
persistentvolume/pvc-769b6aa7-d8c5-472a-8680-c1a43e0db0a5   1Mi        RWO            Delete           Bound    dev/storage-pvc   nfs-storage             52s

五、安装Helm

  1. 下载
wget https://get.helm.sh/helm-v3.1.2-linux-amd64.tar.gz

解压

tar -zxvf helm-v3.1.2-linux-amd64.tar.gz

把helm命令行工具到master节点node1的/usr/local/bin下

mv ./linux-amd64/helm /usr/local/bin/

查看helm版本

helm version

version.BuildInfo{Version:“v3.1.2”, GitCommit:“d878d4d45863e42fd5cff6743294a11d28a9abce”, GitTreeState:“clean”, GoVersion:“go1.13.8”}

  1. 配置helm仓库
  • 阿里云仓库
https://kubernetes.oss-cn-hangzhou.aliyuncs.com/charts
  • 微软仓库（推荐，基本上官网有的chart这里都有）
http://mirror.azure.cn/kubernetes/charts
  • 官方仓库
https://hub.kubeapps.com/charts/incubator
  1. 添加仓库
helm repo add stable http://mirror.azure.cn/kubernetes/charts
helm repo add aliyun https://kubernetes.oss-cn-hangzhou.aliyuncs.com/charts
helm repo update

查看配置的仓库

helm repo list

查询mysql的chart

helm search repo mysql

删除存储库

helm repo remove aliyun

总结

以上就是搭建Kubernetes集群的所有步骤，请大家安装版本时最好选择的版本与我保持一致，因为不同的版本可能会碰到一些意想不到的问题，避免踩坑。