内容概述

Kubernetes 官网: https://kubernetes.io/zh-cn/ (opens new window)

• 1. Kubernetes 集群组件
  • 1.1 控制平面组件（Control Plane Components）
  • 1.2 Node 组件
  • 1.3 插件（Addons）
• 2. 集群架构
• 3. 集群搭建⭐
  • 3.1 minikube
  • 3.2 裸机安装
• 4. 裸机安装
  • step 1：环境准备
  • step 2：集群规划
  • step 3：设置主机名
  • step 4：同步 hosts 文件
  • step 5：禁用 iptables 和 firewalld 服务
  • step 6：关闭 SELINUX
  • step 7：关闭 swap 分区
  • step 8：同步时间
  • step 9：配置 k8s 网络配置
  • step 10：配置 ipvs 功能
  • step 11：重启服务器
  • step 12：安装 containerd
  • step 13：添加 kubernetes 源
  • step 14：安装 kubernetes 组件
  • step 15：准备集群镜像
  • step 16：集群初始化
  • step 17：加入新节点
  • step 18：配置集群网络插件
  • step 19：查看集群状态

1. Kubernetes 集群组件

• 集群(Cluster)：将同一个软件服务多个节点组织到一起共同为系统提供服务过程称之为该软件的集群。redis 集群、es集群、mongo等。
• Kubernetes 集群：多个节点: 3 个节点，1.master 节点/control plane 控制节点；2.work node: 工作节点(pod 容器: 应用程序容器)

摘取官网 : https://kubernetes.io/zh-cn/docs/concepts/overview/components/ (opens new window)

当部署完 Kubernetes，便拥有了一个完整的集群。Kubernetes 集群由一个控制平面和一组用于运行容器化应用的工作机器组成， 这些工作机器称作节点（Node）， 主要运行容器化应用程序。每个集群至少有一个工作节点。

工作节点托管组成应用负载的 Pod，而 Pod 就是作为应用负载的组件。控制平面管理集群中的工作节点和 Pod。 在生产环境中，控制平面通常跨多台计算机运行，而一个集群通常运行多个节点，以提供容错和高可用。

1.1 控制平面组件（Control Plane Components）

控制平面组件会为集群做出全局决策，比如资源的调度。 以及检测和响应集群事件， 例如当不满足 Deployment 的 replicas (opens new window) 字段时，要启动新的 Pod）。

控制平面组件可以在集群中的任何节点上运行。然而，为了简单起见，设置脚本通常会在同一个计算机上启动所有控制平面组件， 并且不会在此计算机上运行用户容器。

• kube-apiserver

API server是 Kubernetes 控制平面的组件，该组件负责公开了 Kubernetes API，负责处理接受请求的工作。API server 是 Kubernetes 控制平面的前端。

Kubernetes API 服务器的主要实现是 kube-apiserver (opens new window)。 kube-apiserver设计上考虑了水平扩缩，也就是说，它可通过部署多个实例来进行扩缩。你可以运行 kube-apiserver 的多个实例，并在这些实例之间平衡流量。

• etcd

一致且高度可用的键值存储，用作 Kubernetes 的所有集群数据的后台数据库。

• kube-scheduler

kube-scheduler 是控制平面的组件，负责监视新创建的、未指定运行节点 node 的 Pods，并选择节点来让 Pod 在上面运行。

调度决策考虑的因素包括单个 Pod 及 Pods 集合的资源需求、软硬件及策略约束、 亲和性及反亲和性规范、数据位置、工作负载间的干扰及最后时限。

• kube-controller-manager

kube-controller-manager (opens new window) 是控制平面的组件， 负责运行控制器进程。从逻辑上讲， 每个控制器都是一个单独的进程，但是为了降低复杂性，它们都被编译到同一个可执行文件，并在同一个进程中运行。

这些控制器包括：

• 节点控制器（Node Controller）：负责在节点出现故障时进行通知和响应
• 任务控制器（Job Controller）：监测代表一次性任务的 Job 对象，然后创建 Pods 来运行这些任务直至完成
• 端点分片控制器（EndpointSlice controller）：填充端点分片（EndpointSlice）对象（以提供 Service 和 Pod 之间的链接）。
• 服务账号控制器（ServiceAccount controller）：为新的命名空间创建默认的服务账号（ServiceAccount）。

• cloud-controller-manager (optional 可选)

一个 Kubernetes 控制平面组件，嵌入了特定于云平台的控制逻辑。 云控制器管理器（Cloud Controller Manager）允许你将你的集群连接到云提供商的API 之上，并将与该云平台交互的组件同与你的集群交互的组件分离开来。

cloud-controller-manager 仅运行特定于云平台的控制器。因此如果你在自己的环境中运行 Kubernetes， 或者在本地计算机中运行学习环境，所部署的集群不需要有云控制器管理器。

与kube-controller-manager 类似，cloud-controller-manager 将若干逻辑上独立的控制回路组合到同一个可执行文件中， 供你以同一进程的方式运行。 你可以对其执行水平扩容（运行不止一个副本）以提升性能或者增强容错能力。

下面的控制器都包含对云平台驱动的依赖：

• 节点控制器（Node Controller）：用于在节点终止响应后检查云提供商以确定节点是否已被删除
• 路由控制器（Route Controller）：用于在底层云基础架构中设置路由
• 服务控制器（Service Controller）：用于创建、更新和删除云提供商负载均衡器

1.2 Node 组件

节点组件会在每个节点上运行，负责维护运行的 Pod 并提供 Kubernetes 运行时环境。

• kubelet

kubelet 会在集群中每个节点（node）上运行。 它保证容器（containers）都运行在 Pods 中。

kubelet (opens new window) 接收一组通过各类机制提供给它的 PodSpecs， 确保这些 PodSpecs 中描述的容器处于运行状态且健康。kubelet 不会管理不是由 Kubernetes 创建的容器。

• kube-proxy

kube-proxy (opens new window) 是集群中每个节点（node）上所运行的网络代理， 实现 Kubernetes 服务（Service）概念的一部分。

kube-proxy 维护节点上的一些网络规则，这些网络规则会允许从集群内部或外部的网络会话与 Pod 进行网络通信。

如果操作系统提供了可用的数据包过滤层，则 kube-proxy 会通过它来实现网络规则。否则，kube-proxy 仅做流量转发。

如果你使用网络插件为 Service 实现本身的数据包转发，并提供与 kube-proxy 等效的行为，那么你不需要在集群中的节点上运行 kube-proxy。

• 容器运行时（Container Runtime）

容器运行环境是负责运行容器的软件。这个基础组件使 Kubernetes 能够有效运行容器。它负责管理 Kubernetes 环境中容器的执行和生命周期。

Kubernetes 支持许多容器运行环境，例如 containerd、 CRI-O、Docker 以及 Kubernetes CRI(容器运行环境接口)的其他任何实现。

1.3 插件（Addons）

插件使用 Kubernetes 资源（DaemonSet、 Deployment 等）实现集群功能。 因为这些插件提供集群级别的功能，插件中命名空间域的资源属于 kube-system 命名空间。

• DNS（重要：必须）

尽管其他插件都并非严格意义上的必需组件，但几乎所有 Kubernetes 集群都应该有集群 DNS (opens new window)因为很多示例都需要 DNS 服务。

• Web 界面（仪表盘）

Dashboard (opens new window)是 Kubernetes 集群的通用的、基于 Web 的用户界面。它使用户可以管理集群中运行的应用程序以及集群本身，并进行故障排除。

• 容器资源监控

容器资源监控 (opens new window) 将关于容器的一些常见的时间序列度量值保存到一个集中的数据库中， 并提供浏览这些数据的界面。

• 集群层面日志

集群层面日志 (opens new window)机制负责将容器的日志数据保存到一个集中的日志存储中， 这种集中日志存储提供搜索和浏览接口。

2. 集群架构

总结

• Kubernetes 集群由多个节点组成，节点分为两类：一类是属于管理平面的主节点/控制节点（Master Node）；一类是属于运行平面的工作节点（Worker Node）。显然，复杂的工作肯定都交给控制节点去做了，工作节点负责提供稳定的操作接口和能力抽象即可。

3. 集群搭建⭐

K8s 集群搭建方式有一下几种：

• minikube

只是一个 K8S 集群模拟器，只有一个节点的集群，只为测试用，master 和 worker 都在一起。

• 裸机安装⭐

至少需要两台机器（主节点、工作节点个一台），需要自己安装 Kubernetes 组件，配置会稍微麻烦点。

缺点：配置麻烦，缺少生态支持，例如负载均衡器、云存储。

• 直接用云平台 Kubernetes

可视化搭建，只需简单几步就可以创建好一个集群。

优点：安装简单，生态齐全，负载均衡器、存储等都给你配套好，简单操作就搞定

• k3s

安装简单，脚本自动完成。

优点：轻量级，配置要求低，安装简单，生态齐全。

3.1 minikube

下载 Docker Desktop for Windows。

3.2 裸机安装

(略)

4. 裸机安装

为了方便博客目录展示，我们提到这里来介绍。

step 1：环境准备

• 节点数量: 3 台虚拟机 centos 7
• 硬件配置: 2G内存，2核CPU或更多的CPU，至少30G 以上硬盘
• 网络要求: 多个节点之间网络互通，每个节点能访问外网

step 2：集群规划

• 192.168.21.100 k8s-master
• 192.168.21.101 k8s-node1
• 192.168.21.102 k8s-node2

step 3：设置主机名

• 为了方便后面集群节点间的直接调用，在这配置一下主机名解析，企业中推荐使用内部DNS服务器
• 注意：每个机器只需要执行设置自己的主机名即可。

$ hostnamectl set-hostname k8s-master  # master 机器
$ hostnamectl set-hostname k8s-node1   # node1 机器
$ hostnamectl set-hostname k8s-node1   # node2 机器

step 4：同步 hosts 文件

• 主机名称解析 编辑三台服务器的/etc/hosts文件，添加主机名解析的内容。

cat >> /etc/hosts <<EOF
192.168.21.100 k8s-master
192.168.21.101 k8s-node1
192.168.21.102 k8s-node2
EOF

step 5：禁用 iptables 和 firewalld 服务

• kubernetes 和 docker 在运行中会产生大量的 iptables 规则，为了不让系统规则跟它们混淆，直接关闭系统的规则

$ systemctl stop firewalld && systemctl disable firewalld
$ systemctl stop iptables && systemctl disable iptables

step 6：关闭 SELINUX

• SELINUX 是 Linux 系统下的一个安全服务，如果不关闭它，在安装集群中会产生各种各样的奇葩问题
• 注意: ARM 架构请勿执行，执行会出现 IP 无法获取问题!

# 编辑 /etc/selinux/config 文件，修改 SELINUX 的值为 disabled
# 注意修改完毕之后需要重启linux服务
SELINUX=disabled

# 或者执行下面命令
$ setenforce 0 && sed -i 's/SELINUX=enforcing/SELINUX=disabled/g' /etc/selinux/config

step 7：关闭 swap 分区

• swap 分区指的是虚拟内存分区，它的作用是在物理内存使用完之后，将磁盘空间虚拟成内存来使用
• 启用 swap 设备会对系统的性能产生非常负面的影响，因此 kubernetes 要求每个节点都要禁用 swap 设备
• 但是如果因为某些原因确实不能关闭 swap 分区，就需要在集群安装过程中通过明确的参数进行配置说明

# 编辑分区配置文件 /etc/fstab，注释掉 swap 分区一行
# 注意修改完毕之后需要重启 Linux 服务
UUID=455cc753-7a60-4c17-a424-7741728c44a1 /boot    xfs     defaults        0 0
/dev/mapper/centos-home /home                      xfs     defaults        0 0
# /dev/mapper/centos-swap swap                      swap    defaults        0 0

# 或者执行下面命令
$ swapoff -a && sed -ri 's/.*swap.*/#&/' /etc/fstab

step 8：同步时间

• kubernetes 要求集群中的节点时间必须精确一致，这里直接使用 chronyd 服务从网络同步时间。
• 企业中建议配置内部的时间同步服务器

# step 1：同步时间
# 启动 chronyd 服务
$ systemctl start chronyd
# 设置 chronyd 服务开机自启
$ systemctl enable chronyd

# 或者执行下面命令
$ yum install ntpdate -y
$ ntpdate time.windows.com

# step 2：上述操作完成后就可以使用 date 命令验证时间
$ date

step 9：配置 k8s 网络配置

配置 k8s 网络配置，修改 Linux 的内核参数，添加网桥过滤和地址转发功能

# 编辑 /etc/sysctl.d/k8s.conf 文件，添加如下配置:
$ vim /etc/sysctl.d/k8s.conf

net.bridge.bridge-nf-call-ip6tables = 1
net.bridge.bridge-nf-call-iptables = 1
net.ipv4.ip_forward = 1

# 或者执行下面命令
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 -p
# 加载网桥过滤模块
$ modprobe br_netfilter
# 查看当前配置是否生效
$ sysctl -p /etc/sysctl.d/k8s.conf
# 查看网桥过滤模块是否加载成功
$ lsmod | grep br_netfilter

step 10：配置 ipvs 功能

• 在 kubernetes 中 service 有两种代理模型，一种是基于 iptables 的，一种是基于 ipvs 的
• 两者比较的话，ipvs 的性能明显要高一些，但是如果要使用它，需要手动载入 ipvs 模块

# step 1：安装 ipset 和 ipvsadm
$ yum install ipset ipvsadmin -y

# step 2：添加需要加载的模块写入脚本文件
cat <<EOF >  /etc/sysconfig/modules/ipvs.modules
#!/bin/bash
modprobe -- ip_vs
modprobe -- ip_vs_rr
modprobe -- ip_vs_wrr
modprobe -- ip_vs_sh
modprobe -- nf_conntrack_ipv4
EOF

# step 3：为脚本文件添加执行权限
$ chmod +x /etc/sysconfig/modules/ipvs.modules

# step 4：执行脚本文件
$ /bin/bash /etc/sysconfig/modules/ipvs.modules

# step 5：查看对应的模块是否加载成功
$ lsmod | grep -e ip_vs -e nf_conntrack_ipv4

step 11：重启服务器

上面步骤完成之后，需要重新启动linux系统

$ reboot

step 12：安装 containerd

# step 1：安装 yum-config-manager 相关依赖
$ yum install -y yum-utils device-mapper-persistent-data lvm2

# step 2：添加 containerd yum 源
$ yum-config-manager --add-repo http://mirrors.aliyun.com/docker-ce/linux/centos/docker-ce.repo

# step 3：安装 containerd
$ yum install -y containerd.io cri-tools  

# step 4：配置 containerd
cat >  /etc/containerd/config.toml <<EOF
disabled_plugins = ["restart"]
[plugins.linux]
shim_debug = true
[plugins.cri.registry.mirrors."docker.io"]
endpoint = ["https://frz7i079.mirror.aliyuncs.com"]
[plugins.cri]
sandbox_image = "registry.aliyuncs.com/google_containers/pause:3.2"
EOF

# step 5：启动 containerd 服务 并 开机配置自启动
$ systemctl enable containerd && systemctl start containerd && systemctl status containerd 

# step 6：配置 containerd 配置
cat > /etc/modules-load.d/containerd.conf <<EOF
overlay
br_netfilter
EOF

# step 7：加载 overlay 模块
$ modprobe overlay

step 13：添加 kubernetes 源

由于 kubernetes 的镜像源在国外，速度比较慢，因此需要切换成国内的镜像源。

查看源

# 查看源
$ yum repolist

添加源 x86

# 编辑 /etc/yum.repos.d/kubernetes.repo，添加相关配置
cat > /etc/yum.repos.d/kubernetes.repo <<EOF
[kubernetes]
name=Kubernetes
baseurl=http://mirrors.aliyun.com/kubernetes/yum/repos/kubernetes-el7-x86_64
enabled=1
gpgcheck=0
repo_gpgcheck=0
gpgkey=http://mirrors.aliyun.com/kubernetes/yum/doc/yum-key.gpg
       http://mirrors.aliyun.com/kubernetes/yum/doc/rpm-package-key.gpg
EOF

添加源 ARM

 cat > /etc/yum.repos.d/kubernetes.repo <<EOF
[kubernetes]
name=Kubernetes
baseurl=https://mirrors.aliyun.com/kubernetes/yum/repos/kubernetes-el7-aarch64
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

step 14：安装 kubernetes 组件

# 安装最新版本
$ yum install -y kubelet kubeadm kubectl

# 指定版本安装
# yum install -y --setopt=obsoletes=0 kubelet-1.26.0 kubectl-1.26.0 kubeadm-1.26.0

# 配置 kubelet 的cgroup
# 编辑 /etc/sysconfig/kubelet，添加下面的配置
cat > /etc/sysconfig/kubelet <<EOF
KUBELET_CGROUP_ARGS="--cgroup-driver=systemd"
KUBE_PROXY_MODE="ipvs"
EOF

# 设置 kubelet 开机自启，并启动 kubelet
$ sudo systemctl enable kubelet && sudo systemctl start kubelet && sudo systemctl status kubelet

step 15：准备集群镜像

（略）

step 16：集群初始化

• 下面的操作只需要在 master 节点上执行即可

# 创建集群
$ kubeadm init \
    --kubernetes-version=v1.26.0 \
    --pod-network-cidr=10.244.0.0/16 \
    --service-cidr=10.96.0.0/12 \
    --apiserver-advertise-address=192.168.21.100 \
    --image-repository registry.aliyuncs.com/google_containers \
    --cri-socket=unix:///var/run/containerd/containerd.sock

# --kubernetes-version：K8s版本，与上面安装的k8s软件一致
# --pod-network-cidr：Pod网段，flannel 网络的固定地址范围
# --service-cidr：service的网段，即Pod统一访问入口
# --apiserver-advertise-address：通告侦听地址，即 master 节点地址
# --image-repository：指定镜像仓库
# --cri-socket：指定容器运行时接口（CRI）的套接字路径，即上面安装的 containerd

注意：初始化完成后，会生成一个加入集群带token 令牌的指令

step 17：加入新节点

该操作只需要在 node 节点上执行即可

$ kubeadm token create --print-join-command --ttl=0

# 执行上述令牌指定，将 node 节点加入集群
$ kubeadm join 192.168.21.100:6443 \ 
    --token 8507uc.o0knircuri8etnw2 \
    --discovery-token-ca-cert-hash \
    sha256:acc37967fb5b0acf39d7598f8a439cc7dc88f439a3f4d0c9cae88e7901b9d3f

# 查看集群状态 此时的集群状态为NotReady，这是因为还没有配置网络插件
$ kubectl get nodes

step 18：配置集群网络插件

• kubernetes支持多种网络插件，比如 flannel、calico、canal 等等，任选一种使用即可，本次选择 flannel
• 该操作依旧只在 master 节点执行即可，插件使用的是 DaemonSet 的控制器，它会在每个节点上都运行

方式一：创建配置: kube-flannel.yml，执行 kubectl apply -f kube-flannel.yml

---
kind: Namespace
apiVersion: v1
metadata:
  name: kube-flannel
  labels:
    pod-security.kubernetes.io/enforce: privileged
---
kind: ClusterRole
apiVersion: rbac.authorization.k8s.io/v1
metadata:
  name: flannel
rules:
- apiGroups:
  - ""
  resources:
  - pods
  verbs:
  - get
- apiGroups:
  - ""
  resources:
  - nodes
  verbs:
  - get
  - list
  - watch
- apiGroups:
  - ""
  resources:
  - nodes/status
  verbs:
  - patch
---
kind: ClusterRoleBinding
apiVersion: rbac.authorization.k8s.io/v1
metadata:
  name: flannel
roleRef:
  apiGroup: rbac.authorization.k8s.io
  kind: ClusterRole
  name: flannel
subjects:
- kind: ServiceAccount
  name: flannel
  namespace: kube-flannel
---
apiVersion: v1
kind: ServiceAccount
metadata:
  name: flannel
  namespace: kube-flannel
---
kind: ConfigMap
apiVersion: v1
metadata:
  name: kube-flannel-cfg
  namespace: kube-flannel
  labels:
    tier: node
    app: flannel
data:
  cni-conf.json: |
    {
      "name": "cbr0",
      "cniVersion": "0.3.1",
      "plugins": [
        {
          "type": "flannel",
          "delegate": {
            "hairpinMode": true,
            "isDefaultGateway": true
          }
        },
        {
          "type": "portmap",
          "capabilities": {
            "portMappings": true
          }
        }
      ]
    }
  net-conf.json: |
    {
      "Network": "10.244.0.0/16",
      "Backend": {
        "Type": "vxlan"
      }
    }
---
apiVersion: apps/v1
kind: DaemonSet
metadata:
  name: kube-flannel-ds
  namespace: kube-flannel
  labels:
    tier: node
    app: flannel
spec:
  selector:
    matchLabels:
      app: flannel
  template:
    metadata:
      labels:
        tier: node
        app: flannel
    spec:
      affinity:
        nodeAffinity:
          requiredDuringSchedulingIgnoredDuringExecution:
            nodeSelectorTerms:
            - matchExpressions:
              - key: kubernetes.io/os
                operator: In
                values:
                - linux
      hostNetwork: true
      priorityClassName: system-node-critical
      tolerations:
      - operator: Exists
        effect: NoSchedule
      serviceAccountName: flannel
      initContainers:
      - name: install-cni-plugin
       #image: flannelcni/flannel-cni-plugin:v1.1.0 for ppc64le and mips64le (dockerhub limitations may apply)
        image: docker.io/rancher/mirrored-flannelcni-flannel-cni-plugin:v1.1.0
        command:
        - cp
        args:
        - -f
        - /flannel
        - /opt/cni/bin/flannel
        volumeMounts:
        - name: cni-plugin
          mountPath: /opt/cni/bin
      - name: install-cni
       #image: flannelcni/flannel:v0.20.2 for ppc64le and mips64le (dockerhub limitations may apply)
        image: docker.io/rancher/mirrored-flannelcni-flannel:v0.20.2
        command:
        - cp
        args:
        - -f
        - /etc/kube-flannel/cni-conf.json
        - /etc/cni/net.d/10-flannel.conflist
        volumeMounts:
        - name: cni
          mountPath: /etc/cni/net.d
        - name: flannel-cfg
          mountPath: /etc/kube-flannel/
      containers:
      - name: kube-flannel
       #image: flannelcni/flannel:v0.20.2 for ppc64le and mips64le (dockerhub limitations may apply)
        image: docker.io/rancher/mirrored-flannelcni-flannel:v0.20.2
        command:
        - /opt/bin/flanneld
        args:
        - --ip-masq
        - --kube-subnet-mgr
        resources:
          requests:
            cpu: "100m"
            memory: "50Mi"
          limits:
            cpu: "100m"
            memory: "50Mi"
        securityContext:
          privileged: false
          capabilities:
            add: ["NET_ADMIN", "NET_RAW"]
        env:
        - name: POD_NAME
          valueFrom:
            fieldRef:
              fieldPath: metadata.name
        - name: POD_NAMESPACE
          valueFrom:
            fieldRef:
              fieldPath: metadata.namespace
        - name: EVENT_QUEUE_DEPTH
          value: "5000"
        volumeMounts:
        - name: run
          mountPath: /run/flannel
        - name: flannel-cfg
          mountPath: /etc/kube-flannel/
        - name: xtables-lock
          mountPath: /run/xtables.lock
      volumes:
      - name: run
        hostPath:
          path: /run/flannel
      - name: cni-plugin
        hostPath:
          path: /opt/cni/bin
      - name: cni
        hostPath:
          path: /etc/cni/net.d
      - name: flannel-cfg
        configMap:
          name: kube-flannel-cfg
      - name: xtables-lock
        hostPath:
          path: /run/xtables.lock
          type: FileOrCreate

方式二：下载获取 fannel 的配置文件，执行 kubectl apply -f kube-flannel.yml

# setp 1：获取fannel的配置文件
$ wget https://raw.githubusercontent.com/coreos/flannel/master/Documentation/kube-flannel.yml

# setp 2：修改文件中 quay.io 仓库为 quay-mirror.qiniu.com

加载配置

# 使用配置文件启动 fannel
$ kubectl apply -f kube-flannel.yml

至此，kubernetes 的集群环境搭建完成

step 19：查看集群状态

# 查看集群节点状态 全部为 Ready 代表集群搭建成功
$ kubectl get nodes
NAME        STATUS   ROLES           AGE   VERSION
k8s-node1   Ready    control-plane   21h   v1.26.0
k8s-node2   Ready    <none>          21h   v1.26.0
k8s-node3   Ready    <none>          21h   v1.26.0

# 查看集群系统 pod 运行情况,下面所有 pod 状态为 Running 代表集群可用
$ kubectl get pod -A
NAMESPACE      NAME                                READY   STATUS    RESTARTS   AGE
default        nginx                               1/1     Running   0          21h
kube-flannel   kube-flannel-ds-gtq49               1/1     Running   0          21h
kube-flannel   kube-flannel-ds-qpdl6               1/1     Running   0          21h
kube-flannel   kube-flannel-ds-ttxjb               1/1     Running   0          21h
kube-system    coredns-5bbd96d687-p7q2x            1/1     Running   0          21h
kube-system    coredns-5bbd96d687-rzcnz            1/1     Running   0          21h
kube-system    etcd-k8s-node1                      1/1     Running   0          21h
kube-system    kube-apiserver-k8s-node1            1/1     Running   0          21h
kube-system    kube-controller-manager-k8s-node1   1/1     Running   0          21h
kube-system    kube-proxy-mtsbp                    1/1     Running   0          21h
kube-system    kube-proxy-v2jfs                    1/1     Running   0          21h
kube-system    kube-proxy-x6vhn                    1/1     Running   0          21h
kube-system    kube-scheduler-k8s-node1            1/1     Running   0          21h