经验首页 前端设计 程序设计 Java相关 移动开发 数据库/运维 软件/图像 大数据/云计算 其他经验
当前位置：技术经验 » 数据库/运维 » Kubernetes » 查看文章
k8s集群搭建及对一些组件的简单理解（二）
来源：cnblogs　　作者：三国梦回　　时间：2024/6/26 8:52:35　　对本文有异议

背景

前面写了一篇，k8s集群搭建及对一些组件的简单理解（一），主要讲了下背景和对一些组件的理解。

今天讲一下正式的安装，有网环境的，后续再说下无外网环境纯内网的。

k8s集群节点、组件

控制面节点，一般就是部署了如下组件：etcd、apiserver、kube-scheduler、kube-controller-manager，由于这些组件都是面向用户，通过kubectl或者UI来接收用户的请求，并对用户请求做出响应。

这些组件收到请求后，开始处理请求，如用户希望运行pod，则这些组件会寻找某个合适的node来部署pod，因此，实际运行用户pod的节点，一般认为是数据面节点。

这些概念可参考：https://kubernetes.io/docs/concepts/overview/components/

控制面中的组件，理论上是可以分布在任意node，但是安装脚本一般选择将这些组件安装在同一台机器上，并且不在这些机器上运行用户的pod；为了高可用，还会在多台机器上来部署这些控制面组件，因此，我们可以把这些机器叫做控制面节点。

image-20240623115937949

上图可以看出，控制面节点中只包含了api-server/etcd/kube-scheduler等组件，实际上，控制面并没有强制说一定不能运行用户pod，而且，在我们使用kubeadm搭建集群时，一般控制面节点会同时包含控制面组件和数据面节点的组件（kubelet、kube-proxy、容器运行时等）。

下面是我整理的图，利用kubeadm搭建完控制面节点后，里面包含了：

  • 6个pod（4个绿色部分的：etcd、api-server、scheduler、control-manager；2个灰色部分：coredns、kube-proxy），这些pod可以理解为6个后台进程

  • 3个由systemctl管理的service：

    /usr/lib/systemd/system/kubelet.service

    /usr/lib/systemd/system/cri-docker.service

    /usr/lib/systemd/system/docker.service

    这3个service，也可以理解为3个后台进程，只是不是pod容器方式运行的；

    这3个service，也变相地提供了3个二进制文件给我们用：kubelet、cri-docker、dokcer

  • 2个cli：kubectl和kubeadm，这两个不是后台进程，只是单纯的cli客户端

k8s控制面节点组件

第一次装的时候，面对这近10个进程、几个cli，几个cli名字还像，真是有点晕。搞了几次后，稍微清晰点了，下面就正式开始安装的部署。

我们的机器配置：

virtualbox搞了两个干净的虚拟机，里面啥都没安装，但是有外网。

10.0.2.8 node4，准备作为主节点

10.0.2.9 node5，准备作为工作节点

操作系统都是centos 7.9。

容器运行时

参考文档：

https://kubernetes.io/docs/setup/production-environment/container-runtimes/

这里选择docker，这个个人用习惯了，空了再学其他的吧。

前置条件

  • ip转发

文档里提到，linux默认未开启ip转发，而k8s的很多网络插件都需要这个特性，所以需要打开。

By default, the Linux kernel does not allow IPv4 packets to be routed between interfaces. Most Kubernetes cluster networking implementations will change this setting (if needed)

  1. # sysctl params required by setup, params persist across reboots
  2. cat <<EOF | sudo tee /etc/sysctl.d/k8s.conf
  3. net.ipv4.ip_forward = 1
  4. EOF
  6. # Apply sysctl params without reboot
  7. sudo sysctl --system
  9. 检查是否已经设为1：
  10. sysctl net.ipv4.ip_forward
  • cgroup drivers

https://kubernetes.io/docs/setup/production-environment/container-runtimes/

在linux中，control group用于对进程可以使用的资源进行限制。而kubelet和容器运行时，都需要和control group打交道，对pod和容器的资源进行管理、对其可以使用的cpu、内存等资源进行限制。要和control group打交道，也不是直接打交道，而是要通过一个control group driver，感觉可以理解为驱动。很重要的一点是，容器运行时和kubelet，需要保证使用同样的cgroup driver。

目前有两种cgroup driver：cgroupfs、systemd。

cgroupfs是kubelet中默认的driver，fs表示文件系统file system的意思，它是 cgroup 的文件系统接口，用户可以操作对应的文件来进行资源控制。

默认的目录为：/sys/fs/cgroup。我们系统下：

  1. [root@node4 ~]# ll /sys/fs/cgroup
  2. total 0
  3. drwxr-xr-x. 2 root root  0 Jun 23 12:53 blkio
  4. lrwxrwxrwx. 1 root root 11 Jun 23 12:53 cpu -> cpu,cpuacct
  5. lrwxrwxrwx. 1 root root 11 Jun 23 12:53 cpuacct -> cpu,cpuacct
  6. drwxr-xr-x. 2 root root  0 Jun 23 12:53 cpu,cpuacct
  7. drwxr-xr-x. 2 root root  0 Jun 23 12:53 cpuset
  8. drwxr-xr-x. 4 root root  0 Jun 23 12:53 devices
  9. drwxr-xr-x. 2 root root  0 Jun 23 12:53 freezer
  10. drwxr-xr-x. 2 root root  0 Jun 23 12:53 hugetlb
  11. drwxr-xr-x. 2 root root  0 Jun 23 12:53 memory
  12. lrwxrwxrwx. 1 root root 16 Jun 23 12:53 net_cls -> net_cls,net_prio
  13. drwxr-xr-x. 2 root root  0 Jun 23 12:53 net_cls,net_prio
  14. lrwxrwxrwx. 1 root root 16 Jun 23 12:53 net_prio -> net_cls,net_prio
  15. drwxr-xr-x. 2 root root  0 Jun 23 12:53 perf_event
  16. drwxr-xr-x. 2 root root  0 Jun 23 12:53 pids
  17. drwxr-xr-x. 4 root root  0 Jun 23 12:53 systemd

总之，简单理解，这种driver是直接操作这个目录下的文件来和内核中的control group交互，比如可以在这边创建一个group，然后把某些进程的pid加入，这样，这些pid就会应用这个group的资源限制配置。

但是，在systemd管理的系统中（比如centos 7基本就是systemd管理的），就不推荐使用这种cgroupfs驱动了。

因为，在这种系统中，systemd会为每一个unit配置一个control group，比如：

https://serverfault.com/questions/683911/use-of-cpuquota-in-systemd

  1. [Unit]
  2. Description=Virtual Distributed Ethernet
  4. [Service]
  5. ExecStart=/usr/bin/ddcommand
  6. CPUQuota=10%
  8. [Install]
  9. WantedBy=multi-user.target

这里面就通过CPUQuota限制了可以使用的cpu为10%。

关于systemd的资源限制这块，可以查看： man systemd.resource-control

因此，在这种systemd系统中，就得统一都使用systemd这种cgroup driver。

后面再说说具体怎么设置。

docker 安装

我们准备采用yum安装，这种安装之后，rpm包就找不到了，由于我们需要把rpm包保存下来供后面搭建内网k8s，所以我们就先把rpm包下载下来再手动安装。

参考文档：https://docs.docker.com/engine/install/centos/

在yum安装前，得先安装docker的yum仓库，否则，你直接yum安装的话，可能版本会非常老。比如，在centos 7.9中：

  1. [root@node4 ~]# yum info docker
  2. Available Packages
  3. Name        : docker
  4. Arch        : x86_64
  5. Epoch       : 2
  6. Version     : 1.13.1
  7. Release     : 210.git7d71120.el7.centos
  8. Size        : 17 M
  9. Repo        : extras/7/x86_64

这个就是1.13.1，该版本是2017年的：https://docs.docker.com/engine/release-notes/prior-releases/

后来改成了17.03这样的格式（一开始说是YY.MM格式，现在也不是很遵从了），最近几年的几个版本是23.0/24.0/25.0/26.0，目前最新是26.1。

所以，要安装新版本，先弄一下docker的yum仓库。

  1. 官方是这个，但是被q了：
  2. sudo yum install -y yum-utils
  3. sudo yum-config-manager --add-repo https://download.docker.com/linux/centos/docker-ce.repo
  5. 那就搞个镜像，如果大家使用云服务器的话，可以找找自己云厂商提供的docker镜像，有的是只给自己的云服务器用的，这种一般速度比较快：
  6. wget -O /etc/yum.repos.d/docker-ce.repo https://mirrors.aliyun.com/docker-ce/linux/centos/docker-ce.repo

下载rpm包：

  1. [root@node4 ~]# mkdir /root/docker-package
  2. [root@node4 ~]# cd /root/docker-package/
  3. [root@node4 docker-package]# yumdownloader --resolve --destdir=. docker-ce docker-ce-cli containerd.io
  5. 我们没安装docker-buildx-plugin docker-compose-plugin，暂时感觉用不上。
  7. 下载完成后，查看：
  8. [root@node4 docker-package]# ll
  9. total 118488
  10. -rw-r--r--. 1 root root    78256 Aug 23  2019 audit-libs-python-2.8.5-4.el7.x86_64.rpm
  11. -rw-r--r--. 1 root root   302068 Nov 12  2018 checkpolicy-2.5-8.el7.x86_64.rpm
  12. -rw-r--r--. 1 root root 37045876 Jun 21 18:38 containerd.io-1.6.33-3.1.el7.x86_64.rpm
  13. ...

使用rpm包安装：

  1. rpm -ivh *.rpm

安装完成后，会有多个systemd管理的unit：

  1. cd /usr/lib/systemd/system
  2. ll 
  3. -rw-r--r--  1 root root 1264 Jun  5 16:36 containerd.service
  4. -rw-r--r--  1 root root  295 Jun  5 19:31 docker.socket
  5. -rw-r--r--  1 root root 1962 Jun  5 19:31 docker.service

然后就是设置下docker的配置文件（没有就新建）：

  1. [root@app1 ~]# vim /etc/docker/daemon.json
  2. {
  3.   "exec-opts": ["native.cgroupdriver=systemd"],
  4.   "log-driver": "json-file",
  5.   "log-opts": {
  6.     "max-size": "100m"
  7.   },
  8.   "debug": true
  9. }

如果需要配私服、镜像的，也基本就是改这个文件，比如增加如下行，我就先不加了：

  1.   "registry-mirrors": ["http://10.0.218.xxx:8083"],
  2.   "insecure-registries": ["http://10.0.218.xxx:8083"]

启动服务：

  1. systemctl start docker
  2. systemctl status docker
  4. 开机启动：
  5. systemctl enable docker
  7. 检查是否cgroup driver为systemd：
  8. [root@app1 cri-docker]# docker info|grep group
  9.  Cgroup Driver: systemd
  10.  Cgroup Version: 1

检查下能拉不：

  1. [root@node4 docker-package]# docker pull hello-world
  2. Using default tag: latest
  3. latest: Pulling from library/hello-world
  4. c1ec31eb5944: Retrying in 1 second 
  5. error pulling image configuration: download failed after attempts=6: dial tcp 103.252.114.61:443: i/o timeout
  7. 拉不下来，也可以查看下日志：
  8. journalctl -u docker 
  9. 实时查看:
  10. journalctl -u docker -f

嗯，不能。。。因为docker pull的时候要去访问一些网站https://production.cloudflare.docker.com，被q了。

那如果不学上网技术，就只能使用docker.io这个官方仓库的国内镜像仓库了。

我一开始看到网上总结的几个镜像站：

docker.io mirror.ccs.tencentyun.com 仅腾讯云vpc内部访问, registry2 proxy
docker.nju.edu.cn 南京大学开源镜像站, nexus3
docker.mirrors.sjtug.sjtu.edu.cn 上海交通大学, registry2 proxy
docker.m.daocloud.io 国内可用, 带宽低
*****.mirror.aliyuncs.com 国内可用，更新慢

除了腾讯是内部用（云服务器上可以用），其他的，除了倒数第二个，其他的几个全用不了了。（当前时间20240623）。

  1. docker pull docker.m.daocloud.io/hello-world
  2.  
  3. [root@node4 docker-package]# docker images
  4. REPOSITORY                         TAG       IMAGE ID       CREATED         SIZE
  5. docker.m.daocloud.io/hello-world   latest    d2c94e258dcb   13 months ago   13.3kB

另外，可以关注下docker对外部提供的接口，为domain unix socket：

  1. [root@node4 docker-package]# netstat -nlp |grep docker
  2. unix  2      [ ACC ]     STREAM     LISTENING     40562    1/systemd            /run/docker.sock

cri-docker 安装

https://mirantis.github.io/cri-dockerd/

cri-docker是docker公司和Mirantis 公司（docker商业化公司）来维护，实现了k8s的CRI接口，将CRI接口进行适配，转换为对docker的调用并响应。

安装的话，最简单就是安装rpm包 ,https://github.com/Mirantis/cri-dockerd/releases这里下载即可。

我这边下载的是cri-dockerd-0.3.14-3.el7.x86_64.rpm。

  1. cd /root/upload
  2. 上传rpm
  3. rpm -ivh cri-dockerd-0.3.14-3.el7.x86_64.rpm

安装完成后，会有如下service：

  1. /usr/lib/systemd/system/cri-docker.service
  3. 查看内容，主要命令就是：
  4. ExecStart=/usr/bin/cri-dockerd --container-runtime-endpoint fd://

查看帮助：

  1. /usr/bin/cri-dockerd -h
  2. 这个里面选项不少，要多看看。
  4. 比如这里就可以指定docker的socket的地址：
  5. --docker-endpoint string  Use this for the docker endpoint to communicate with. 
  6. (default "unix:///var/run/docker.sock")
  8. 还可以指定pod中的基础容器的镜像坐标：
  9. --pod-infra-container-image string        The image whose network/ipc namespaces containers in each pod will use (default "registry.k8s.io/pause:3.9")

启动：

  1. [root@node4 upload]# systemctl start cri-docker
  2. [root@node4 upload]# systemctl status cri-docker

它监听的端口为/run/cri-dockerd.sock或者/var/run/cri-dockerd.sock，这两个指向同一个文件：

  1. [root@node4 upload]# netstat -nlxp|grep cri
  2. unix  2      [ ACC ]     STREAM     LISTENING     68693    1/systemd            /run/cri-dockerd.sock

日志查看：

  1. journalctl -u cri-docker

kubelet安装

https://kubernetes.io/docs/setup/production-environment/tools/kubeadm/install-kubeadm/

前置

https://kubernetes.io/docs/setup/production-environment/tools/kubeadm/install-kubeadm/#before-you-begin

关闭SeLinux：

  1. sudo setenforce 0
  3. sudo sed -i 's/^SELINUX=enforcing$/SELINUX=permissive/' /etc/selinux/config

关闭swap：

  1. sudo vi /etc/fstab
  2. 注释掉如下行：
  3. # /dev/mapper/centos-swap swap                    swap    defaults        0 0
  5. [root@app1 ~]# sudo swapoff -a
  6. 检查：
  7. [root@app1 ~]# free -h

安装kubelet

  1. cat <<EOF | sudo tee /etc/yum.repos.d/kubernetes.repo
  2. [kubernetes]
  3. name=Kubernetes
  4. baseurl=https://pkgs.k8s.io/core:/stable:/v1.30/rpm/
  5. enabled=1
  6. gpgcheck=1
  7. gpgkey=https://pkgs.k8s.io/core:/stable:/v1.30/rpm/repodata/repomd.xml.key
  8. exclude=kubelet kubeadm kubectl cri-tools kubernetes-cni
  9. EOF

然后，首先安装kubelet：

  1. rpm安装：
  2. mkdir /root/kubelet-kubeadm
  3. cd /root/kubelet-kubeadm
  4. yumdownloader --resolve --destdir=. kubelet --disableexcludes=kubernetes
  5. rpm -ivh *.rpm
  7. 如果直接装就是：
  8. yum install  kubelet --disableexcludes=kubernetes

可以观察到，其依赖于：kubernetes-cni这个包。

  1. /usr/lib/systemd/system/kubelet.service
  3. systemctl status kubelet
  5. cd /usr/lib/systemd/system/
  7. [root@node4 system]# ll kubelet*
  8. -rw-r--r--. 1 root root 278 Jun 12 05:15 kubelet.service

我们如果此时启动，大家看看效果：

  1. systemctl start kubelet
  2. systemctl enable kubelet
  3. systemctl status kubelet
  5. 是启动失败的。
  6. 查看日志：
  7. journalctl -u kubelet

image-20240623152551701

可以发现，此时进入的是standalone模式，这个模式下，kubelet可以独立管理pod，不需要api-server的存在，具体大家可以搜一下。

安装kubeadm

  1. rpm安装：
  2. cd /root/kubelet-kubeadm
  3. yumdownloader --resolve --destdir=. kubeadm --disableexcludes=kubernetes
  4. rpm -ivh *.rpm
  6. 如果直接装就是：
  7. yum install  kubeadm --disableexcludes=kubernetes
  8. 发现其会依赖cri-tools

对kubelet的影响

安装完成后，我们再去看kubelet的service目录下：

  1. cd /usr/lib/systemd/system/
  4. [root@node4 system]# ll kubelet*
  5. -rw-r--r--. 1 root root 278 Jun 12 05:15 kubelet.service
  7. kubelet.service.d:
  8. total 4
  9. -rw-r--r--. 1 root root 900 Jun 12 05:14 10-kubeadm.conf

发现多了个目录，目录下还有配置文件10-kubeadm.conf. 这个配置文件其实就是给kubelet指定了些配置，比如后续怎么去连接api-server（就不在是standalone模式了）、以及指定了一些kubelet自身的配置项

image-20240623153350228

另外，也可以查看下kubelet的选项，非常多：

  1. [root@node4 system]# /usr/bin/kubelet -h

kubeadm的流程

此时，其实就可以准备创建集群了。语法很简单：

  1. kubeadm init    --pod-network-cidr=192.168.0.0/16 --cri-socket unix:///var/run/cri-dockerd.sock --kubernetes-version v1.30.1 --v=5

具体选项可以看：

  1.  kubeadm init -h

我们指定的选项的意思：

  1. --pod-network-cidr，这个是部分cni插件需要指定，我们选的是calico，去calico官网查看文档，发现其默认需要这么指定：192.168.0.0/16，意思就是pod的ip的网段
  3. --cri-socket，这个是因为我们机器上，既有cri-docker，又有containerd，两个cri实现，必须手动指定一个。
  5. --kubernetes-version v1.30.1，联网环境下可以不指定，就是指定k8s的版本；离线环境下指定了就不用去联网发请求
  7. --v，日志级别

但，实际这样还不够，k8s的控制面组件不是有好几个pod吗，pod内容器的镜像，是维护在registry.k8s.io这个仓库下的。

我们直接去拉取镜像会失败：

  1. [root@node4 system]#  docker pull registry.k8s.io/kube-apiserver:v1.30.1
  2. Error response from daemon: Head "https://asia-east1-docker.pkg.dev/v2/k8s-artifacts-prod/images/kube-apiserver/manifests/v1.30.1": dial tcp: lookup asia-east1-docker.pkg.dev on 10.0.2.1:53: no such host

这些网址是由Google团队提供的，被q了。

所以，我们只能找找registry.k8s.io的镜像仓库，我这边用的registry-k8s-io.mirrors.sjtug.sjtu.edu.cn。

因此，最后命令是：

  1. kubeadm init --image-repository registry-k8s-io.mirrors.sjtug.sjtu.edu.cn   --pod-network-cidr=192.168.0.0/16 --cri-socket unix:///var/run/cri-dockerd.sock --kubernetes-version v1.30.1 --v=5

另外，我们加上--dry-run，先试着跑一下，但是，我建议，还是先提前拉取好镜像，再来跑这个好一点：

  1. kubeadm init --image-repository registry-k8s-io.mirrors.sjtug.sjtu.edu.cn   --pod-network-cidr=192.168.0.0/16 --cri-socket unix:///var/run/cri-dockerd.sock --kubernetes-version v1.30.1 --v=5 --dry-run

为啥呢，因为k8s这几个组件的镜像大小有大几百兆，所以界面会一直卡在这里，不知道后台到底怎么样了，是卡死了还是怎么了。

我们如果要提前拉取镜像，先得知道要拉取哪些镜像：

  1. [root@node4 system]# kubeadm config images list
  2. registry.k8s.io/kube-apiserver:v1.30.2
  3. registry.k8s.io/kube-controller-manager:v1.30.2
  4. registry.k8s.io/kube-scheduler:v1.30.2
  5. registry.k8s.io/kube-proxy:v1.30.2
  6. registry.k8s.io/coredns/coredns:v1.11.1
  7. registry.k8s.io/pause:3.9
  8. registry.k8s.io/etcd:3.5.12-0

然后，转换为：

  1. docker pull registry-k8s-io.mirrors.sjtug.sjtu.edu.cn/kube-apiserver:v1.30.2
  2. docker pull registry-k8s-io.mirrors.sjtug.sjtu.edu.cn/kube-controller-manager:v1.30.2
  3. docker pull registry-k8s-io.mirrors.sjtug.sjtu.edu.cn/kube-scheduler:v1.30.2
  4. docker pull registry-k8s-io.mirrors.sjtug.sjtu.edu.cn/kube-proxy:v1.30.2
  5. docker pull registry-k8s-io.mirrors.sjtug.sjtu.edu.cn/coredns/coredns:v1.11.1
  6. docker pull registry-k8s-io.mirrors.sjtug.sjtu.edu.cn/pause:3.9
  7. docker pull registry-k8s-io.mirrors.sjtug.sjtu.edu.cn/etcd:3.5.12-0

docker images，确保镜像都存在了，再次运行：

发现会卡在一个拉取coreDns的地方，

  1. pulling: registry-k8s-io.mirrors.sjtug.sjtu.edu.cn/coredns:v1.11.1

这个主要是两个仓库的标签打得有点不一样，我们就把我们已经存在的镜像，重新打个tag：

  1. docker tag registry-k8s-io.mirrors.sjtug.sjtu.edu.cn/coredns/coredns:v1.11.1 registry-k8s-io.mirrors.sjtug.sjtu.edu.cn/coredns:v1.11.1

结果再次运行，发现还是卡：

  1. [api-check] Waiting for a healthy API server. This can take up to 4m0s

检查了几个服务的日志，发现docker日志显示还在拉取：

  3. ...
  4. registry.k8s.io/pause from https://registry.k8s.io

后面查了下，是因为就是我们忽略了一句kubeadm打印的提示：

  1. W0623 16:26:12.928077   22235 checks.go:844] detected that the sandbox image "registry.k8s.io/pause:3.9" of the container runtime is inconsistent with that used by kubeadm.It is recommended to use "registry-k8s-io.mirrors.sjtug.sjtu.edu.cn/pause:3.9" as the CRI sandbox image.

我们在cri-docker那里，需要修改下镜像坐标。

  1. ExecStart=/usr/bin/cri-dockerd --container-runtime-endpoint fd:// --pod-infra-container-image registry-k8s-io.mirrors.sjtug.sjtu.edu.cn/pause:3.9
  1. systemctl daemon-reload
  2. systemctl restart cri-docker

再次执行，又说一堆东西已经存在了。我们可以先reset下：

  1.  kubeadm reset -f --cri-socket unix:///var/run/cri-dockerd.sock

这次基本就能成功了，把最下面的命令存下来：

  1. Your Kubernetes control-plane has initialized successfully!
  3. To start using your cluster, you need to run the following as a regular user:
  5.   mkdir -p $HOME/.kube
  6.   sudo cp -i /etc/kubernetes/admin.conf $HOME/.kube/config
  7.   sudo chown $(id -u):$(id -g) $HOME/.kube/config
  9. Alternatively, if you are the root user, you can run:
  11.   export KUBECONFIG=/etc/kubernetes/admin.conf
  13. You should now deploy a pod network to the cluster.
  14. Run "kubectl apply -f [podnetwork].yaml" with one of the options listed at:
  15.   https://kubernetes.io/docs/concepts/cluster-administration/addons/
  17. Then you can join any number of worker nodes by running the following on each as root:
  19. kubeadm join 10.0.2.x:6443 --token k3nmtk.kx1k6cbxbsuaqysd         --discovery-token-ca-cert-hash sha256:9659ceb5bf342b1a9fa1ef1888a3ce26a1f9c881dbbf4bbadcbb62d5dcde37dd

安装kubectl

这个东西是啥呢，只是个cli，客户端工具，给我们用的，就像redis-cli和mysql命令行客户端一样，主要是和控制面组件中的api-server进行交互。

事实上，各个容器厂商都是做一套界面出来给用户用的，也是直接对接api-server。

这里我们安装下。

  1. rpm安装：
  2. cd /root/kubelet-kubeadm
  3. yumdownloader --resolve --destdir=. kubectl --disableexcludes=kubernetes
  4. rpm -ivh *.rpm
  6. 如果直接装就是：
  7. yum install  kubectl --disableexcludes=kubernetes

然后执行下：

  1. [root@node4 system]#  kubectl get pods -A
  2. E0623 16:40:18.035470   25920 memcache.go:265] couldn't get current server API group list: Get "http://localhost:8080/api?timeout=32s": dial tcp [::1]:8080: connect: connection refused

因为还需要指定api-server的地址：

  1.   mkdir -p $HOME/.kube
  2.   sudo cp -i /etc/kubernetes/admin.conf $HOME/.kube/config
  3.   sudo chown $(id -u):$(id -g) $HOME/.kube/config

再来：

  1. [root@node4 system]#  kubectl get pods -A
  2. NAMESPACE     NAME                            READY   STATUS    RESTARTS   AGE
  3. kube-system   coredns-86c4446b65-6sr2p        0/1     Pending   0          7m13s
  4. kube-system   coredns-86c4446b65-n4xcl        0/1     Pending   0          7m13s
  5. kube-system   etcd-node4                      1/1     Running   0          7m28s
  6. kube-system   kube-apiserver-node4            1/1     Running   0          7m28s
  7. kube-system   kube-controller-manager-node4   1/1     Running   0          7m28s
  8. kube-system   kube-proxy-rxxc9                1/1     Running   0          7m13s
  9. kube-system   kube-scheduler-node4            1/1     Running   0          7m28s

可以发现，coreDns这两个pod是pending状态。看一下这个pod的状态：发现是说没有可用的ready的node。

  1. [root@node4 system]# kubectl get nodes -A
  2. NAME    STATUS     ROLES           AGE   VERSION
  3. node4   NotReady   control-plane   13m   v1.30.2

我们的node确实是NotReady。

  1. [root@node4 system]# kubectl describe node node4
  2. ...
  3.   Ready            False   Sun, 23 Jun 2024 16:43:43 +0800   Sun, 23 Jun 2024 16:33:18 +0800   KubeletNotReady              container runtime network not ready: NetworkReady=false reason:NetworkPluginNotReady message:docker: network plugin is not ready: cni config uninitialized

里面可以看到，是因为cni网络插件尚未ready的原因。

安装网络插件calico

网络插件有好多种，主流用的也有好几种，各种的差别后面我们再讲，其中呢，calico算是一款优秀的网络插件。

https://docs.tigera.io/calico/latest/getting-started/kubernetes/quickstart

安装operator

  1. wget https://raw.githubusercontent.com/projectcalico/calico/v3.28.0/manifests/tigera-operator.yaml
  3. 执行：
  4. k create -f tigera-operator.yaml
  5. 执行完后，会新增一个pod：
  6. [root@node4 calico-install]# kubectl get pods -A |grep tigera
  7. tigera-operator   tigera-operator-5ddc799ffd-fqsps   0/1     ContainerCreating   0          49s

这里又涉及到拉取镜像，这次的镜像是在：

  1. [root@node4 calico-install]# grep image tigera-operator.yaml |grep quay
  2.           image: quay.io/tigera/operator:v1.34.0

还好，这个quay.io/tigera/operator:v1.34.0直接网络可以拉取。。不需要镜像

运行网络插件相关pod

https://docs.tigera.io/calico/latest/getting-started/kubernetes/quickstart

  1. wget https://raw.githubusercontent.com/projectcalico/calico/v3.28.0/manifests/custom-resources.yaml
  3. // 这个动作又要拉取镜像，有大几百兆
  4. kubectl create -f custom-resources.yaml

我在我以前成功的机器上看了下，拉取了这些（版本不一定和最新一样）：

  1. [root@app1 ~]# docker images |grep calico
  2. calico/typha                                                        v3.28.0    a9372c0f51b5       71.1MB
  3. calico/kube-controllers                                             v3.28.0    428d92b02253       79.1MB
  4. calico/apiserver                                                    v3.28.0    6c07591fd1cf       97.9MB
  5. calico/cni                                                          v3.28.0    107014d9f4c8       209MB
  6. calico/node-driver-registrar                                        v3.28.0    0f80feca743f       23.5MB
  7. calico/csi                                                          v3.28.0    1a094aeaf152       18.3MB
  8. calico/pod2daemon-flexvol                                           v3.28.0    587b28ecfc62       13.4MB
  9. calico/node                                                         v3.28.0    4e42b6f329bc       353MB

我看了下docker日志，发现又跑去docker.io这个官方仓库拉取calico镜像去了，这尼玛。还是得配个镜像仓库啊。

  1. vim /etc/docker/daemon.json
  2. {
  3.   "exec-opts": ["native.cgroupdriver=systemd"],
  4.   "log-driver": "json-file",
  5.   "log-opts": {
  6.     "max-size": "100m"
  7.   },
  8.   "debug": true,
  9.   "registry-mirrors": ["https://docker.m.daocloud.io"]
  10. }

只要镜像下下来了，就没问题了，等一会，pod就会就绪，coreDns也会就绪：

image-20240623173939648

worker节点安装

10.0.2.9 node5

容器运行时

参照主节点，全都需要执行。

rpm包我们scp拷贝过去。

  1. scp * 10.0.2.9:/root/docker-package
  1. scp  /etc/docker/daemon.json  10.0.2.9:/etc/docker/daemon.json
  1. systemctl start docker
  2. systemctl status docker
  3. systemctl enable docker

cri-docker安装

参照主节点。

记得修改service文件：

  1. /usr/lib/systemd/system/cri-docker.service
  2. 加参数：
  3. --pod-infra-container-image registry-k8s-io.mirrors.sjtug.sjtu.edu.cn/pause:3.9
  5. systemctl start cri-docker
  6. systemctl status cri-docker
  7. systemctl enable cri-docker

kubelet安装

  1. 直接装，或者拿主节点的rpm来装：
  2. yum install  kubelet --disableexcludes=kubernetes
  1. systemctl start kubelet
  2. systemctl enable kubelet

kubeadm安装

  1. 直接装，或者拿主节点的rpm来装：
  2. yum install  kubeadm --disableexcludes=kubernetes

拷贝并加载镜像

从主节点中，执行：

  1. [root@node4 docker-package]# docker save -o calico_images.tar $(docker images --format "{{.Repository}}:{{.Tag}}" | grep "^calico")
  2. [root@node4 docker-package]# docker save -o pause.tar $(docker images --format "{{.Repository}}:{{.Tag}}" | grep "pause")
  3. [root@node4 docker-package]# docker save -o kube-proxy.tar $(docker images --format "{{.Repository}}:{{.Tag}}" | grep "kube-proxy")
  4. [root@node4 docker-package]# scp calico_images.tar pause.tar kube-proxy.tar 10.0.2.9:/root/images-for-load

在worker节点上：

  1. cd /root/images-for-load
  3. docker load < kube-proxy.tar 
  4. docker load < calico_images.tar 
  5. docker load < pause.tar 
  6. docker images

join集群

找出之前存下来的join语句：

  1.  kubeadm join 10.0.2.8:6443 --token k3nmtk.kx1k6cbxbsuaqysd         --discovery-token-ca-cert-hash sha256:9659ceb5bf342b1a9fa1ef1888a3ce26a1f9c881dbbf4bbadcbb62d5dcde37dd         --cri-socket unix:///var/run/cri-dockerd.sock --v=5

image-20240623182820091

注意，worker节点不能执行kubectl是正常的，因为一般是在控制节点上执行kubectl。当然，如果有需要，也可以像主节点那样操作，弄一下就行了。

测试

我这边在主节点上：

  1. kubectl create deploy www-nginx-demo --image nginx --replicas=2

如果发现调度到了两台机器上，等nginx镜像拉取完成后（在主、工作节点都要拉取），可以看到pod状态变成正常。

image-20240623183525165

在主节点上，直接访问pod：

image-20240623183608453

在工作节点上，直接访问pod：

image-20240623183644084

容器到容器的网络也是通的，只是容器内太简单了，缺少ping这些基础的工具，以后再说说这块。

总结

后续再讲下完全没有网络的环境中的安装吧，也算是给自己备忘了。

原文链接：https://www.cnblogs.com/grey-wolf/p/18268158

 友情链接：直通硅谷 　点职佳 　北美留学生论坛

Kubernetes热门文章

  • 【Azure K8S | AKS】在AKS集群中创建 PVC(PersistentVolumeClaim)和 PV(PersistentVolume) 示例
  • 无法访问k8s.gcr.io下载镜像问题解决办法
  • Kubernetes(k8s)访问控制：身份认证
  • Prometheus服务发现之kubernetes_sd_config
  • Arthas排查Kubernetes中应用频繁挂掉重启异常
  • Kubernetes客户端认证——基于CA证书的双向认证方式
  • k8s中kubeconfig的配置以及使用详解
  • Centos7 安装部署 Kubernetes(k8s) 高可用集群
  • Kubernetes 证书详解
  • 案例分享-full gc导致k8s pod重启

    • Kubernetes推荐文章

  • 修改kubeadm证书过期时间及更新k8s集群证书
  • 探究kubernetes 探针参数periodSeconds和timeoutSeconds
  • 从 Helm 到 Operator：Kubernetes应用管理的进化
  • 深入理解Prometheus: Kubernetes环境中的监控实践
  • k8s集群搭建及对一些组件的简单理解（二）
  • K8s高可用集群二进制部署-V1.20
  • Kubernetes容器生命周期 —— 钩子函数详解（postStart、preStop）
  • Kubernetes 审计（Auditing）
  • Thanos解码：打造企业级云原生监控解决方案
  • k8s使用rbd作为存储

    • 本站QQ群：前端 618073944 | Java 606181507 | Python 626812652 | C/C++ 612253063 | 微信 634508462 | 苹果 692586424 | C#/.net 182808419 | PHP 305140648 | 运维 608723728

    W3xue 的所有内容仅供测试，对任何法律问题及风险不承担任何责任。通过使用本站内容随之而来的风险与本站无关。
    关于我们  |  意见建议  |  捐助我们  |  报错有奖  |  广告合作、友情链接（目前9元/月）请联系QQ：27243702 沸活量
    皖ICP备17017327号-2　皖公网安备34020702000426号