Kubernetes 核心知识与集群部署整理

2201_75701431

220人浏览 · 2026-08-22 20:04:04

2201_75701431 · 2026-08-22 20:04:04 发布

一、Kubernetes 简介

1.1 应用部署方式演变

应用部署方式主要经历了三个阶段：

传统部署：互联网早期直接将应用程序部署在物理机上。优点是简单、不需要其他技术参与；缺点是不能为应用程序定义资源使用边界，很难合理分配计算资源，而且程序之间容易相互影响。
虚拟化部署：可以在一台物理机上运行多个虚拟机，每个虚拟机都是独立的环境。优点是程序环境不会相互影响，提供了一定程度的安全性；缺点是增加了操作系统，浪费了部分资源。
容器化部署：与虚拟化类似，但共享了操作系统。容器化部署带来便利的同时也会出现问题，例如：一个容器故障停机后如何让另一个容器立刻启动替补；并发访问量变大时如何横向扩展容器数量。

1.2 容器编排工具

为了解决容器编排问题，产生了一些容器编排软件：

Swarm：Docker 自己的容器编排工具。
Mesos：Apache 的一个资源统一管控工具，需要和 Marathon 结合使用。
Kubernetes：Google 开源的容器编排工具。

1.3 Kubernetes 是什么

在 Docker 快速发展的同时，Google 内部很早就已应用容器技术，其 Borg 系统运行管理着成千上万的容器应用。Kubernetes 项目来源于 Borg，集结了 Borg 设计思想的精华，并吸收了其中的经验和教训。

Kubernetes 对计算资源进行了更高层次的抽象，通过将容器进行细致的组合，将最终的应用服务交给用户。它的本质是一组服务器集群，可以在集群的每个节点上运行特定的程序，对节点中的容器进行管理，目标是实现资源管理的自动化。

1.4 Kubernetes 核心功能

自我修复：一旦某一个容器崩溃，能够在约 1 秒内迅速启动新的容器。
弹性伸缩：根据需要对集群中正在运行的容器数量自动进行调整。
服务发现：服务可以通过自动发现的形式找到它所依赖的服务。
负载均衡：如果一个服务启动了多个容器，能够自动实现请求的负载均衡。
版本回退：如果发现新发布的程序版本有问题，可以立即回退到原来的版本。
存储编排：可以根据容器自身的需求自动创建存储卷。

二、K8S 设计架构

2.1 Master 控制平面组件

Master 是集群的控制平面，负责集群的决策，主要组件如下：

ApiServer：资源操作的唯一入口，接收用户输入的命令，提供认证、授权、API 注册和发现等机制。
Scheduler：负责集群资源调度，按照预定的调度策略将 Pod 调度到相应的 Node 节点上。
ControllerManager：负责维护集群的状态，比如程序部署安排、故障检测、自动扩展、滚动更新等。
Etcd：负责存储集群中各种资源对象的信息。

2.2 Node 工作节点组件

Node 是集群的数据平面，负责为容器提供运行环境，主要组件如下：

kubelet：负责维护容器的生命周期，同时也负责 Volume（CVI）和网络（CNI）的管理。
Container runtime：负责镜像管理以及 Pod 和容器的真正运行（CRI）。
kube-proxy：负责为 Service 提供集群内部的服务发现和负载均衡。

2.3 各组件之间的调用关系

当要运行一个 Web 服务时，调用流程如下：

Kubernetes 环境启动后，Master 和 Node 都会将自身的信息存储到 etcd 数据库中。
Web 服务的安装请求首先被发送到 Master 节点的 ApiServer 组件。
ApiServer 组件调用 Scheduler 组件决定应该把这个服务安装到哪个 Node 节点上。此时它会从 etcd 中读取各个 Node 节点的信息，按一定算法进行选择，并将结果告知 ApiServer。
ApiServer 调用 controller-manager 调度 Node 节点安装 Web 服务。
kubelet 接收到指令后通知容器运行时，由容器运行时启动一个 Web 服务的 Pod。
如果需要访问 Web 服务，通过 kube-proxy 对 Pod 产生访问代理。

2.4 常用名词概念

Master：集群控制节点，每个集群需要至少一个 Master 节点负责集群管控。
Node：工作负载节点，Master 把容器分配到这些工作节点上运行。
Pod：Kubernetes 的最小控制单元，容器都运行在 Pod 中，一个 Pod 中可以有 1 个或多个容器。
Controller：控制器，通过它实现对 Pod 的管理，比如启动 Pod、停止 Pod、伸缩 Pod 的数量等。
Service：Pod 对外服务的统一入口，下面可以维护同一类的多个 Pod。
Label：标签，用于对 Pod 进行分类，同一类 Pod 拥有相同的标签。
NameSpace：命名空间，用来隔离 Pod 的运行环境。

2.5 分层架构

Kubernetes 的分层架构大致如下：

Ecosystem（生态层）：周边完整生态系统，并非 K8s 核心组件，但极大扩展了其能力。包括 PaaS/SaaS 平台（如 OpenShift、Rancher）、服务网格（Istio、Linkerd）、监控与日志（Prometheus、ELK、Loki）、无服务器（Knative、OpenFaaS）、数据处理与中间件（Spark、Kafka、MySQL Operator 等）。
Interface Layer（接口层）：提供用户与集群交互的入口与工具，包括客户端库（Go、Python、Java 等语言的 SDK）、命令行工具（kubectl 是最核心的 CLI）、UI 管理平台（Dashboard、Kuboard 等）以及 CI/CD、GitOps 等工具。
Governance Layer（治理层）：负责集群的安全、合规与自动化运维，包括策略执行（RBAC 权限控制、资源配额、网络策略、调度约束 Taints/Tolerations）、自动化（HPA 自动扩缩容、自愈、故障转移、定时任务）和可观测性（指标采集、日志、监控与告警）。
Application Layer（应用层）：负责部署与路由，管理无状态/有状态应用、批处理任务和集群应用等工作负载；核心对象包括 Deployment、StatefulSet、DaemonSet、Service、Ingress 等。
Nucleus（核心层）：对外提供统一的 REST API 接口，是所有操作的唯一入口；对内负责资源建模（Pod、Node、Service 等）、任务调度与执行管理。核心组件包括 kube-apiserver、etcd、kube-scheduler、kube-controller-manager 等。
底层插件支撑层：包括 Container Runtime（如 containerd、CRI-O）、Network Plugin（如 Calico、Flannel）、Volume Plugin（如 CSI）、Image Registry（如 Harbor、Docker Hub）、Cloud Provider 以及 Identity Provider（LDAP、OIDC）。

三、K8S 集群环境搭建

3.1 容器的管理方式

K8S 集群创建方式有 3 种：

containerd：默认情况下 K8S 创建集群时使用的方式。
docker：Docker 使用率很高，虽然 K8S 在 1.24 版本后移除了 kubelet 对 Docker 的支持，但可以借助 cri-docker 方式实现集群创建。
cri-o：Kubernetes 创建容器最直接的一种方式，创建集群时需要借助 cri-o 插件实现。

其中 docker 和 cri-o 这两种方式需要对 kubelet 程序的启动参数进行设置。

3.2 环境部署说明

部署前所有节点需要满足以下准备条件：禁用 SELinux 和防火墙；同步时间和解析；安装 docker-ce；禁用 swap，并注意注释掉 /etc/fstab 文件中的 swap 定义。同时建议提前准备好私有镜像仓库（如 Harbor），用于统一分发 K8S 组件镜像和各节点拉取镜像。K8S 中文官网：Kubernetes。

3.3 构建 Harbor 镜像仓库

在搭建 K8S 集群前，通常先准备一个私有镜像仓库，用于统一分发 K8S 组件镜像和业务镜像。本文以 Harbor 为例，部署在 harbor.timinglee.org 节点。

3.3.1 部署 Docker 本地仓库

先在仓库节点配置 Docker 的安装源，并通过 httpd 搭建本地 RPM 仓库，便于其他节点离线或快速安装 Docker：

cat > /etc/yum.repos.d/docker.repo <<EOF
[docker]
name = docker
baseurl = https://mirrors.aliyun.com/docker-ce/linux/rhel/9.6/x86_64/stable/
gpgcheck = 0
EOF
dnf install httpd createrepo -y
mkdir /var/www/html/docker/ -p
vim /etc/httpd/conf/httpd.conf
修改监听端口，例如：Listen 4444
systemctl enable --now httpd
dnf install docker-ce --downloadonly --destdir /mnt/ -y
mv /mnt/*.rpm /var/www/html/docker/
createrepo -v /var/www/html/docker/
cat > /etc/yum.repos.d/docker.repo <<EOF
[docker]
name = docker
baseurl = http://172.25.254.254:4444/docker
gpgcheck = 0
EOF
dnf install docker-ce -y

3.3.2 安装 Docker 并生成证书

安装 Docker 后配置内核桥接参数，并生成 Harbor 使用的自签名证书：

dnf install docker-ce -y
echo br_netfilter > /etc/modules-load.d/docker_mod.conf
modprobe -a br_netfilter
cat > /etc/sysctl.d/docker.conf <<EOF
net.bridge.bridge-nf-call-iptables = 1
net.bridge.bridge-nf-call-ip6tables = 1
net.ipv4.ip_forward = 1
EOF
systemctl restart systemd-modules-load.service
sysctl --system
vim /lib/systemd/system/docker.service
ExecStart=/usr/bin/dockerd -H fd:// --containerd=/run/containerd/containerd.sock --iptables=true
systemctl daemon-reload
systemctl enable --now docker
mkdir /data/certs -p
openssl req -newkey rsa:4096 
-nodes -sha256 -keyout /data/certs/timinglee.org.key
-addext "subjectAltName = DNS:reg.timinglee.org"
-x509 -days 365 -out /data/certs/timinglee.org.crt

3.3.3 配置并启动 Harbor

tar zxf harbor-offline-installer-v2.5.4.tgz -C /opt/
cd /opt/harbor/
cp harbor.yml.tmpl harbor.yml
vim harbor.yml
# hostname: reg.timinglee.org
# certificate: /data/certs/timinglee.org.crt
# private_key: /data/certs/timinglee.org.key
# harbor_admin_password: lee
./install.sh --with-chartmuseum

3.3.4 配置 systemd 启动并验证

vim /lib/systemd/system/harbor.service
[Unit]
Description=harbor with Docker Compose
Documentation=https://reg.timinglee.com/compose/
After=docker.service network-online.target
Requires=docker.service
[Service]
Type=oneshot
WorkingDirectory=/opt/harbor
ExecStart=/usr/bin/docker compose up -d
ExecStop=/usr/bin/docker compose down
RemainAfterExit=yes
[Install]
WantedBy=multi-user.target

systemctl enable --now harbor
docker compose ps

3.3.5 配置证书并登录验证

mkdir /etc/docker/certs.d/reg.timinglee.org/ -p
cp /data/certs/timinglee.org.crt /etc/docker/certs.d/reg.timinglee.org/ca.crt
vim /etc/hosts
# 172.25.254.254     harbor reg.timinglee.org
systemctl restart docker
docker compose up -d
docker login reg.timinglee.org -u admin

3.4 部署 Kubernetes 所需主机

3.4.1 主机规划

主机名	IP	配置	角色
harbor.timinglee.org	172.25.254.254	CPU 1、内存 1G	Harbor 仓库
master-node	172.25.254.100	CPU 4、内存 >4G	master，K8S 集群控制节点
node1	172.25.254.10	CPU 2、内存 2G	worker，K8S 集群工作节点
node2	172.25.254.20	CPU 2、内存 2G	worker，K8S 集群工作节点

3.4.2 所有主机关闭 swap

systemctl disable --now swap.target
systemctl mask swap.target
sed '/swap/s/^/#/g' -i /etc/fstab

3.4.3 安装 Docker 并分发证书

dnf install docker-ce -y
mkdir /etc/docker/certs.d/reg.timinglee.org/ -p
在 Harbor 节点分发证书到所有主机
for i in 100 10 20
do
scp /data/certs/timinglee.org.crt root@172.25.254.$i:/etc/docker/certs.d/reg.timinglee.org/ca.crt
done
systemctl enable docker
systemctl restart docker

3.4.4 配置 Docker 加速器

cat > /etc/docker/daemon.json <<EOF
{
  "registry-mirrors":["https://reg.timinglee.org"]
}
EOF
systemctl restart docker
docker info

执行 docker info 后可以看到 Registry Mirrors 已指向 https://reg.timinglee.org/。

3.4.5 所有主机彼此建立解析

vim /etc/hosts
127.0.0.1   localhost localhost.localdomain localhost4 localhost4.localdomain4
::1         localhost localhost.localdomain localhost6 localhost6.localdomain6
172.25.254.100     master
172.25.254.10      node1
172.25.254.20      node2
172.25.254.254     reg.timinglee.org

3.4.6 所有主机配置 Kubernetes 安装源

vim /etc/yum.repos.d/kubernetes.repo
[kubernetes]
name = kubernetes
baseurl = https://mirrors.aliyun.com/kubernetes-new/core/stable/v1.35/rpm/
gpgcheck = 0
检测
dnf list kubelet

以上操作完成后重启主机，执行 swapon -s 没有任何输出，表示 swap 已关闭。

3.5 集群环境初始化

所有 K8S 节点执行以下步骤。首先禁用 swap：

systemctl mask swap.target
swapoff -a
vim /etc/fstab  # 注释掉 swap 行

然后配置本地解析 /etc/hosts，例如：

127.0.0.1   localhost localhost.localdomain localhost4 localhost4.localdomain4
::1         localhost localhost.localdomain localhost6 localhost6.localdomain6
172.25.254.100  k8s-master.timinglee.org
172.25.254.10   k8s-node1.timinglee.org
172.25.254.20   k8s-node2.timinglee.org
172.25.254.254  reg.timinglee.org

3.6 安装 Docker 并设置资源管理模式

配置 Docker 的 yum 源并安装 docker-ce：

vim /etc/yum.repos.d/docker.repo
# 添加以下内容
[docker]
name=docker
baseurl=https://mirrors.aliyun.com/docker-ce/linux/rhel/9/x86_64/stable/
gpgcheck=0
dnf install docker-ce -y

设置 Docker 资源管理模式为 systemd，并配置镜像仓库：

vim /etc/docker/daemon.json

{
  "registry-mirrors": ["https://reg.timinglee.org"],
  "exec-opts": ["native.cgroupdriver=systemd"],
  "log-driver": "json-file",
  "log-opts": {
    "max-size": "100m"
  },
  "storage-driver": "overlay2"
}

复制 Harbor 仓库证书并启动 Docker：

ls -l /etc/docker/certs.d/reg.timinglee.org/ca.crt
systemctl enable --now docker
docker login reg.timinglee.org

3.7 安装 K8S 部署工具

配置 K8S 软件源，并使用 dnf 安装 kubelet、kubeadm、kubectl：

vim /etc/yum.repos.d/k8s.repo
# 添加以下内容
[k8s]
name=k8s
baseurl=https://mirrors.aliyun.com/kubernetes-new/core/stable/v1.30/rpm
gpgcheck=0
dnf install kubelet-1.30.0 kubeadm-1.30.0 kubectl-1.30.0 -y

设置 kubectl 命令补全功能：

dnf install bash-completion -y
echo "source <(kubectl completion bash)" >> ~/.bashrc
source ~/.bashrc

3.8 安装 cri-docker

K8S 从 1.24 版本开始移除了 dockershim，需要安装 cri-docker 插件才能继续使用 Docker。软件下载地址为 https://github.com/Mirantis/cri-dockerd。

方式一：使用 RPM 包安装（版本相对较老）：

ls
# anaconda-ks.cfg  cri-dockerd-0.3.14-3.el8.x86_64.rpm  libcgroup-0.41-19.el8.x86_64.rpm
rpm -ivh *.rpm
vim /lib/systemd/system/cri-docker.service
ExecStart=/usr/bin/cri-dockerd --container-runtime-endpoint fd:// --network-plugin=cni --pod-infra-container-image=reg.timinglee.org/k8s/pause:3.10.1
ll /var/run/cri-dockerd.sock

方式二：使用二进制包部署 cri-dockerd：

# 下载并解压二进制包
wget https://github.com/Mirantis/cri-dockerd/releases/download/v0.4.4/cri-dockerd-0.4.4.amd64.tgz
tar zxf cri-dockerd-0.4.4.amd64.tgz
cd cri-dockerd/
ls
# cri-dockerd  cri-docker.service  cri-docker.socket
安装命令并生成启动文件
install -o root -g root -m 0755 cri-dockerd /usr/local/bin/cri-dockerd
cp cri-docker.s* /lib/systemd/system
chmod +x /lib/systemd/system/cri-docker.s*
vim /lib/systemd/system/cri-docker.service
[Service]
Type=notify
ExecStart=/usr/local/bin/cri-dockerd --network-plugin=cni --pod-infra-container-image=reg.timinglee.org/k8s/pause:3.10.1 --container-runtime-endpoint fd://
ExecReload=/bin/kill -s HUP $MAINPID
TimeoutSec=0
RestartSec=2
Restart=always

无论使用哪种方式，完成后都需要重载并启动服务：

systemctl daemon-reload
systemctl enable --now cri-docker.service
systemctl status cri-docker.service
ll /var/run/cri-dockerd.sock

3.9 拉取 K8S 所需镜像

在 Master 节点查看集群需要下载的镜像列表：

kubeadm config images list

拉取 K8S 集群所需镜像：

kubeadm config images pull \
--image-repository registry.aliyuncs.com/google_containers \
--kubernetes-version v1.30.0 \
--cri-socket=unix:///var/run/cri-dockerd.sock

核心镜像说明：

k8s/pause：Pod 的“根容器”（infrastructure container），为 Pod 内所有容器提供共享的网络和 PID 命名空间。本身不做业务逻辑，仅占用极少资源，是每个 Pod 都会自动创建的“隐形”容器。
k8s/coredns：集群内部 DNS 服务，负责服务发现与域名解析，将 Service 名称解析为对应的 ClusterIP，让 Pod 之间可以通过服务名相互访问。
k8s/etcd：分布式键值存储，是 K8s 集群的唯一数据源，存储所有集群状态、配置和对象数据，保证数据的一致性和高可用。
k8s/kube-proxy：节点上的网络代理，维护节点的网络规则，实现 Service 的负载均衡、端口转发和网络代理。
k8s/kube-scheduler：调度器，负责将新建的 Pod 分配到合适的 Node 上，根据资源需求、节点亲和性、污点容忍等策略选择最优运行节点。
k8s/kube-controller-manager：控制器管理器，运行各种控制器以维护集群状态，确保集群始终符合期望状态。
k8s/kube-apiserver：K8s API 网关，是集群的唯一入口，处理所有 REST API 请求，负责认证、授权、准入控制，并与 etcd 交互读写数据。

将镜像上传到 Harbor 仓库，便于各节点拉取：

docker login reg.timinglee.org -u admin
docker images --format "{{.Repository}}:{{.Tag}}" | awk -F "/" '/google/{system("docker tag "$0" reg.timinglee.org/k8s/"$3)}'
docker images --format "{{.Repository}}:{{.Tag}}" | awk -F "/" '/timinglee/{system("docker push "$0)}'

3.10 集群初始化

启动 kubelet 服务并执行初始化命令：

systemctl status kubelet.service
kubeadm init --pod-network-cidr=10.244.0.0/16 \
--image-repository reg.timinglee.org/k8s \
--kubernetes-version v1.30.0 \
--cri-socket=unix:///var/run/cri-dockerd.sock

初始化完成后会输出节点加入集群的凭证，不同集群生成的 Token 不同：

kubeadm join 172.25.254.100:6443 --token tdwjoc.8d1yw3wl4r4tm6c4 \
--discovery-token-ca-cert-hash sha256:6b5950ef2cdba85d6dfdb564ee90d4187fa3d341767dc9852cbdd5c9dee4f927

指定集群配置文件变量：

echo "export KUBECONFIG=/etc/kubernetes/admin.conf" > ~/.bash_profile
source ~/.bash_profile
kubectl get nodes

此时节点尚未就绪，因为还没有安装网络插件、容器没有运行。如果集群初始化生成的 Token 找不到了，可以重新生成：

kubeadm token create --print-join-command

如果初始化过程出现问题，可以重置集群设定后重新初始化：

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

3.11 安装 Flannel 网络插件

官方网站为 https://github.com/flannel-io/flannel。下载 Flannel 部署文件和镜像：

wget https://github.com/flannel-io/flannel/releases/latest/download/kube-flannel.yml
docker pull docker.io/flannel/flannel:v0.25.5
docker pull docker.io/flannel/flannel-cni-plugin:v1.5.1-flannel1

上传镜像到仓库并修改 kube-flannel.yml 中的镜像地址：

docker tag flannel/flannel:v0.25.5 reg.timinglee.org/flannel/flannel:v0.25.5
docker push reg.timinglee.org/flannel/flannel:v0.25.5
docker tag flannel/flannel-cni-plugin:v1.5.1-flannel1 reg.timinglee.org/flannel/flannel-cni-plugin:v1.5.1-flannel1
docker push reg.timinglee.org/flannel/flannel-cni-plugin:v1.5.1-flannel1
vim kube-flannel.yml
grep -n image kube-flannel.yml

把镜像地址改为仓库地址后安装网络插件：

kubectl apply -f kube-flannel.yml

3.12 节点加入集群

所有 Worker 节点需要确认完成以下内容：禁用 swap；安装 kubelet、kubeadm、kubectl、docker-ce、cri-dockerd；修改 cri-dockerd 启动文件，添加网络插件和基础容器镜像参数；启动 kubelet.service 和 cri-docker.service。

确认完毕后即可加入集群：

kubeadm join 172.25.254.100:6443 \
--token 5hwptm.zwn7epa6pvatbpwf \
--discovery-token-ca-cert-hash sha256:52f1a83b70ffc8744db5570288ab51987ef2b563bf906ba4244a300f61e9db23 \
--cri-socket=unix:///var/run/cri-dockerd.sock

在 Master 节点查看所有 Node 状态，若所有节点 STATUS 都为 Ready，说明 Kubernetes 集群部署完成：

kubectl get nodes

3.13 集群验证

最后验证集群运行情况，建立一个 Pod 并查看状态：

kubectl run test --image nginx
kubectl get pods
kubectl delete pod test

3.14 Ansible 自动化部署

如果集群节点较多，可以使用 Ansible 统一部署 Docker、cri-dockerd 和 K8S 组件，减少重复操作。

3.14.1 安装 Ansible 并配置运行用户

vim /etc/yum.repos.d/epel.repo
[epel]
name = epel
baseurl = https://mirrors.aliyun.com/epel/9/Everything/x86_64/
gpgcheck = 0
dnf install ansible-core.x86_64 ansible.noarch -y
useradd devops
echo lee | passwd --stdin devops
su - devops
mkdir ansible
cd ansible

3.14.2 配置 inventory 并建立互信

vim inventory
[servers]
172.25.254.100
172.25.254.20
172.25.254.10
vim ansible.cfg
[defaults]
inventory = /home/devops/ansible/inventory
remote_user = root
ask_pass = false
host_key_checking = false
ansible all -m ping
ansible all -m user -a "name=devops state=present"
ansible all -m shell -a 'echo "lee" | passwd --stdin devops'
ansible all -m lineinfile -a 'path=/etc/sudoers line="devops    ALL=(ALL)    NOPASSWD: ALL" insertafter=EOF'

将 remote_user 改为 devops 并启用 sudo 提权后，再执行 whoami 验证：

vim ansible.cfg
[defaults]
inventory = /home/devops/ansible/inventory
remote_user = devops
ask_pass = false
host_key_checking = false
[privilege_escalation]
become = true
become_method = sudo
become_user = root
become_ask_pass = false
ansible all -m shell -a 'whoami'

3.14.3 使用 ansible 部署 Docker 和 cri-dockerd

vim kubernetes-devops.yml
- name: devops k8s from ansible
  hosts: all
  tasks:
  - name: setup docker repo
    yum_repository:
      name: docker
      description: docker
      baseurl: http://172.25.254.254:4444/docker
      file: docker
      gpgcheck: no
name: install docker
dnf:
name: docker-ce
state: present
name: setup docker.service
replace:
path: /lib/systemd/system/docker.service
regexp: "ExecStart=/usr/bin/dockerd -H fd:// --containerd=/run/containerd/containerd.sock"
replace: "ExecStart=/usr/bin/dockerd -H fd:// --containerd=/run/containerd/containerd.sock  --iptables=true"
name: setup docker registry
copy:
content: |
{
"registry-mirrors":["https://reg.timinglee.org"]
}
dest: /etc/docker/daemon.json
name: setup docker certs
file:
path: /etc/docker/certs.d/reg.timinglee.org
state: directory
name: cp certs file
copy:
src: "{{item.src}}"
dest: "{{item.dest}}"
loop:
src: /etc/docker/certs.d/reg.timinglee.org/ca.crt
dest: /etc/docker/certs.d/reg.timinglee.org/ca.crt
src: /etc/docker/certs.d/reg.timinglee.org/ca.crt
dest: /etc/pki/ca-trust/source/anchors/ca.crt
name: load module
copy:
dest: "{{item.dest}}"
content: "{{item.value}}"
loop:
dest: /etc/modules-load.d/docker_mod.conf
value: br_netfilter
dest: /etc/sysctl.d/docker.conf
value: |
net.bridge.bridge-nf-call-iptables = 1
net.bridge.bridge-nf-call-ip6tables = 1
net.ipv4.ip_forward = 1
name: update ca cert
shell: "update-ca-trust extract;sysctl --system"
name: start services
service:
name: "{{item}}"
state: restarted
enabled: yes
loop:
docker
systemd-modules-load.service
ansible-playbook kubernetes-devops.yml
tar zxf cri-dockerd-0.4.4.amd64.tgz
cd cri-dockerd/
vim cri-docker.service
[Service]
Type=notify
ExecStart=/usr/bin/cri-dockerd --container-runtime-endpoint fd:// --network-plugin=cni --pod-infra-container-image=reg.timinglee.org/k8s/pause:3.10.1
ExecReload=/bin/kill -s HUP $MAINPID
TimeoutSec=0
RestartSec=2
Restart=always
vim kubernetes-devops.yml
name: devops k8s from ansible
hosts: all
tasks:
name: setup docker repo
yum_repository:
name: docker
description: docker
baseurl: http://172.25.254.254:4444/docker
file: docker
gpgcheck: no
name: install docker
dnf:
name: docker-ce
state: present
name: setup docker.service
replace:
path: /lib/systemd/system/docker.service
regexp: "ExecStart=/usr/bin/dockerd -H fd:// --containerd=/run/containerd/containerd.sock"
replace: "ExecStart=/usr/bin/dockerd -H fd:// --containerd=/run/containerd/containerd.sock  --iptables=true"
name: setup docker registry
copy:
content: |
{
"registry-mirrors":["https://reg.timinglee.org"]
}
dest: /etc/docker/daemon.json
name: setup docker certs
file:
path: /etc/docker/certs.d/reg.timinglee.org
state: directory
name: cp certs file
copy:
src: "{{item.src}}"
dest: "{{item.dest}}"
loop:
src: /etc/docker/certs.d/reg.timinglee.org/ca.crt
dest: /etc/docker/certs.d/reg.timinglee.org/ca.crt
src: /etc/docker/certs.d/reg.timinglee.org/ca.crt
dest: /etc/pki/ca-trust/source/anchors/ca.crt
name: stup cri-dockerd
copy:
src: "{{item.src}}"
dest: "{{item.dest}}"
mode: '0755'
loop:
src: ./cri-dockerd/cri-dockerd
dest: /usr/bin/cri-dockerd
src: "./cri-dockerd/cri-docker.service"
dest: "/lib/systemd/system/cri-docker.service"
src: "./cri-dockerd/cri-docker.socket"
dest: "/lib/systemd/system/cri-docker.socket"
name: update ca cert
shell: "update-ca-trust extract;sysctl --system;systemctl daemon-reload"
name: start services
service:
name: "{{item}}"
state: restarted
enabled: yes
loop:
docker
systemd-modules-load.service
cri-docker
ansible-playbook kubernetes-devops.yml

3.14.4 使用 ansible 部署 k8s 软件

vim kubernetes-devops.yml
- name: install kubernetes from ansible
  hosts: all
  tasks:
  - name: setup k8s repo
    yum_repository:
      name: kubernetes
      description: kubernetes
      baseurl: https://mirrors.aliyun.com/kubernetes-new/core/stable/v1.35/rpm
      file: kubernetes
      gpgcheck: no
name: install software in master
dnf:
name: "{{item}}"
state: present
loop:
kubeadm-1.35.7-150500.1.1
kubelet-1.35.7-150500.1.1
kubectl-1.35.7-150500.1.1
when: inventory_hostname == "172.25.254.100"
name: install software in work node
dnf:
name: "{{item}}"
state: present
loop:
kubeadm-1.35.7-150500.1.1
kubelet-1.35.7-150500.1.1
when: inventory_hostname == "172.25.254.10" or inventory_hostname == "172.25.254.20"
name: setup kubectl kubeadm completion
lineinfile:
path: /root/.bashrc
line: |
source <(kubectl completion bash)
source <(kubeadm completion bash)
when: inventory_hostname == "172.25.254.100"
name: start kubelet
service:
name: kubelet
state: started
enabled: yes
ansible-playbook kubernetes-devops.yml

四、总结

Kubernetes 是从 Google Borg 演化而来的容器编排系统，通过 Master/Node 架构实现资源管理的自动化，具备自我修复、弹性伸缩、服务发现、负载均衡、版本回退和存储编排等核心能力。集群搭建涉及运行时选择、环境初始化、kubeadm 部署、网络插件安装和节点扩容等关键环节。理解其设计架构与组件职责，是深入使用 Kubernetes 的前提。

openEuler 社区

openEuler 是由开放原子开源基金会孵化的全场景开源操作系统项目，面向数字基础设施四大核心场景（服务器、云计算、边缘计算、嵌入式），全面支持 ARM、x86、RISC-V、loongArch、PowerPC、SW-64 等多样性计算架构

更多推荐

如何升级node.js版本

方法二：使用nvm（Node Version Manager）-------------------------------如果你使用的是Unix系统（如Linux或macOS），可以使用nvm来管理多个Node.js版本。安装完成后，nvm将允许你安装、使用和管理不同版本的Node.js。升级Node.js可以通过多种方式来完成，以下是四种常见的方法：方法一：使用Node.js官方安装程序---