wylu

FastDFS 安装部署

2023-08-08T13:31:59.000Z

本文介绍了 FastDFS 的安装部署过程。首先，需要准备好设备环境，并安装相关依赖。接着，按照以下步骤进行安装：下载 FastDFS，解压安装，编辑配置文件，创建 system 服务，启动服务，并查看状态。最后，进行 Client 测试，测试上传文件，返回 ID 表示成功。

FastDFS 安装部署

1. 设备环境

Host	IP	Port	OS	Software
cnode1	10.128.170.30	22122	CentOS 7.9.2009	fastfds 6.06 trackerd
cnode1	10.128.170.30	23000	CentOS 7.9.2009	fastfds 6.06 storaged
cnode2	10.128.170.31	22122	CentOS 7.9.2009	fastfds 6.06 trackerd
cnode2	10.128.170.31	23000	CentOS 7.9.2009	fastfds 6.06 storaged

编辑 hosts 文件：

1	vim /etc/hosts

添加如下内容：

1 2	10.128.170.30 cnode1 10.128.170.31 cnode2

2. 安装依赖

yum -y install gcc gcc+ gcc-c++ openssl openssl-devel pcre pcre-deve
yum -y install pcre-devel openssl openssl-develyum -y install zlib zlib-deve
yum -y install perl
yum -y install unzip

3. 安装步骤

3.1 下载 fastfds

fastdfs wiki

根据 wiki 下载以下软件包：

libfastcommon-master.zip
fastdfs-6.06.tar.gz

3.2 解压安装

1 2	mkdir /opt/fastdfs mkdir -p /data/fastdfs/{fastdfs_tracker,fastdfs_storage,fastdfs_storage_data1,fastdfs_storage_data2}

解压

1 2	unzip -d /opt/fastdfs/ /saasdata/soft/libfastcommon-master.zip tar -zxvf /saasdata/soft/fastdfs-6.06.tar.gz -C /opt/fastdfs/

修改安装路径

1
2
3

sed -i '3c TARGET_PREFIX=/opt/fastdfs/fastdfs-6.06' /opt/fastdfs/fastdfs-6.06/make.sh
sed -i '4c TARGET_CONF_PATH=/opt/fastdfs/fastdfs-6.06/conf' /opt/fastdfs/fastdfs-6.06/make.sh
sed -i '5c TARGET_INIT_PATH=/opt/fastdfs/fastdfs-6.06/init.d' /opt/fastdfs/fastdfs-6.06/make.sh

编译安装

1 2	cd /opt/fastdfs/libfastcommon-master && ./make.sh && ./make.sh install > /dev/null cd /opt/fastdfs/fastdfs-6.06 && ./make.sh && ./make.sh install > /dev/null

在 cnode1，cnode2 上进行同样的操作。

3.3 编辑配置文件

sed -i  '23c  base_path=/data/fastdfs/fastdfs_tracker' /opt/fastdfs/fastdfs-6.06/conf/tracker.conf
sed -i  '11c  group_name=group1' /opt/fastdfs/fastdfs-6.06/conf/storage.conf
sed -i  '24c  port = 23000' /opt/fastdfs/fastdfs-6.06/conf/storage.conf
sed -i  '49c  base_path = /data/fastdfs/fastdfs_storage' /opt/fastdfs/fastdfs-6.06/conf/storage.conf
sed -i  '119c  store_path_count = 2' /opt/fastdfs/fastdfs-6.06/conf/storage.conf
sed -i  '129c  store_path0 = /data/fastdfs/fastdfs_storage_data1' /opt/fastdfs/fastdfs-6.06/conf/storage.conf
sed -i  '130c  store_path1 = /data/fastdfs/fastdfs_storage_data2' /opt/fastdfs/fastdfs-6.06/conf/storage.conf
sed -i  '145c  tracker_server = cnode1:22122' /opt/fastdfs/fastdfs-6.06/conf/storage.conf
sed -i  '146c  tracker_server = cnode2:22122' /opt/fastdfs/fastdfs-6.06/conf/storage.conf
sed -i  '180c  file_distribute_path_mode = 0' /opt/fastdfs/fastdfs-6.06/conf/storage.conf
sed -i  '352c  http.server_port = 8888' /opt/fastdfs/fastdfs-6.06/conf/storage.conf

在 cnode1，cnode2 上进行同样的操作。

3.4 创建 system 服务

cat > /usr/lib/systemd/system/fdfs_trackerd.service << EOF
[Unit]
Description=fdfs_trackerd Server
After=network.target

[Service]
Type=forking
ExecStart=/opt/fastdfs/fastdfs-6.06/bin/fdfs_trackerd /opt/fastdfs/fastdfs-6.06/conf/tracker.conf start
ExecStop=/opt/fastdfs/fastdfs-6.06/bin/fdfs_trackerd /opt/fastdfs/fastdfs-6.06/conf/tracker.conf stop
PrivateTmp=true
Restart=always
RestartSec=1
StartLimitInterval=0

[Install]
WantedBy=multi-user.target
EOF

cat > /usr/lib/systemd/system/fdfs_storaged.service << EOF
[Unit]
Description=fdfs_storaged
After=network.target

[Service]
Type=forking
ExecStart=/opt/fastdfs/fastdfs-6.06/bin/fdfs_storaged /opt/fastdfs/fastdfs-6.06/conf/storage.conf start
ExecStop=/opt/fastdfs/fastdfs-6.06/bin/fdfs_storaged /opt/fastdfs/fastdfs-6.06/conf/storage.conf stop
PrivateTmp=true
Restart=always
RestartSec=1
StartLimitInterval=0

[Install]
WantedBy=multi-user.target
EOF

在 cnode1，cnode2 上进行同样的操作。

3.5 启动服务

1
2
3

systemctl daemon-reload
systemctl start fdfs_trackerd.service
systemctl start fdfs_storaged.service

在 cnode1，cnode2 上进行同样的操作。

查看状态

1	/opt/fastdfs/fastdfs-6.06/bin/fdfs_monitor /opt/fastdfs/fastdfs-6.06/conf/storage.conf

4. Client 测试

1	vim /opt/fastdfs/fastdfs-6.06/conf/client.conf

修改如下配置

1
2
3

base_path = /opt/fastdfs/fastdfs-6.06
tracker_server = cnode1:22122
tracker_server = cnode2:22122

测试上传文件，返回 ID 表示成功，如：group1/M00/00/00/xx.tar.gz

[root@cnode1 bin]# ./fdfs_upload_file /opt/fastdfs/fastdfs-6.06/conf/client.conf /root/Downloads/fastdfs-6.06.tar.gz
group1/M00/00/00/CoCqFWIUhZeATgjaAAxZcPR00vw.tar.gz
[root@cnode1 bin]# ./fdfs_upload_file /opt/fastdfs/fastdfs-6.06/conf/client.conf /root/Downloads/libfastcommon-master.zip
group1/M00/00/00/CoCqFmIUhZyAImx7AAPZehNXZm0384.zip

References

https://github.com/happyfish100/fastdfs/wiki/

FastDFS集群部署

FASTDFS

Centos7下FastDFS集群搭建

分布式文件系统（HDFS和FastDFS）

二进制部署 k8s 集群 1.27.3 版本

2023-08-07T16:11:56.000Z

通过本文的指导，读者可以了解如何通过二进制的方式部署 Kubernetes 1.27.3 版本集群。二进制部署可以加深对 Kubernetes 各组件的理解，可以灵活地将各个组件部署到不同的机器，以满足自身的要求。但是需要注意的是，二进制部署需要手动配置各个组件，需要一定的技术水平和经验。

二进制部署 k8s 集群 1.27.3 版本

1. 环境准备

虽然 kubeadm, kops, kubespray 以及 rke, kubesphere 等工具可以快速部署 k8s 集群，但是依然会有很多人热衷与使用二进制部署 k8s 集群。

二进制部署可以加深对 k8s 各组件的理解，可以灵活地将各个组件部署到不同的机器，以满足自身的要求。还可以生成一个超长时间自签证书，比如 99 年，免去忘记更新证书过期带来的生产事故。

1.1 书写约定

命令行输入，均以 ➜ 符号表示
注释使用 # 或 // 表示
执行命令输出结果，以空行分隔
如无特殊说明，命令需要在全部集群节点执行

1.2 机器规划

1.2.1 操作系统

Rocky-8.6-x86_64-minimal.iso

1.2.2 集群节点

角色	主机名	IP	组件
master	master1	10.128.170.21	etcd, kube-apiserver, kube-controller-manager, kubelet, kube-proxy, kube-scheduler
worker	worker1	10.128.170.131	kubelet, kube-proxy
worker	worker2	10.128.170.132	kubelet, kube-proxy
worker	worker3	10.128.170.133	kubelet, kube-proxy

1.2.3 测试节点（可选）

角色	主机名	IP	组件
registry	registry	10.128.170.235	docker

1.3 环境配置

1.3.1 基础设置

设置主机名

# 在 master1 节点执行
➜ hostnamectl set-hostname master1
# 在 worker1 节点执行
➜ hostnamectl set-hostname worker1
# 在 worker2 节点执行
➜ hostnamectl set-hostname worker2
# 在 worker3 节点执行
➜ hostnamectl set-hostname worker3

主机名解析

➜ cat >> /etc/hosts << EOF
10.128.170.21 master1 master1.local
10.128.170.131 worker1 worker1.local
10.128.170.132 worker2 worker2.local
10.128.170.133 worker3 worker3.local
EOF

免密登录

# 在 master1 节点上执行（允许 master1 免密登录其他节点）
➜ ssh-keygen -t rsa
➜ ssh-copy-id worker1
➜ ssh-copy-id worker2
➜ ssh-copy-id worker3

设置 yum 源

https://developer.aliyun.com/mirror/rockylinux

# 执行以下命令替换默认源
➜ sed -e 's|^mirrorlist=|#mirrorlist=|g' \
    -e 's|^#baseurl=http://dl.rockylinux.org/$contentdir|baseurl=https://mirrors.aliyun.com/rockylinux|g' \
    -i.bak \
    /etc/yum.repos.d/Rocky-*.repo

➜ dnf makecache

设置 epel 源

https://developer.aliyun.com/mirror/epel

1
2
3

➜ yum install -y https://mirrors.aliyun.com/epel/epel-release-latest-8.noarch.rpm
➜ sed -i 's|^#baseurl=https://download.example/pub|baseurl=https://mirrors.aliyun.com|' /etc/yum.repos.d/epel*
➜ sed -i 's|^metalink|#metalink|' /etc/yum.repos.d/epel*

安装必要工具
1
➜ yum install -y vim wget htop
创建下载文件存放目录
1
➜ mkdir -p ~/Downloads

1.3.2 k8s 环境设置

关闭防火墙

1 2	➜ systemctl stop firewalld ➜ systemctl disable firewalld

关闭 selinux

# 临时
➜ setenforce 0
# 永久
➜ sed -i 's/enforcing/disabled/' /etc/selinux/config

关闭 swap
1
2
3
4
# 临时
➜ swapoff -a
# 永久
➜ sed -ri 's/.*swap.*/#&/' /etc/fstab
使用 -r 选项可以使用扩展正则表达式，这提供了一种更强大和灵活的方式来匹配文本中的模式。
使用正则表达式 .*swap.* 匹配包含 swap 字符串的行，并在行首添加 # 符号，& 表示匹配到的整个字符串。
设置文件描述符限制
1
2
3
4
# 临时
➜ ulimit -SHn 65535
# 永久
➜ echo "* - nofile 65535" >>/etc/security/limits.conf
用于设置当前用户的最大文件描述符数限制。具体来说，它的作用是将当前用户的软限制和硬限制都设置为 65535。

时间同步

# 设置时区
➜ timedatectl set-timezone Asia/Shanghai
# 安装时间同步服务
➜ yum install -y chrony
➜ systemctl enable --now chronyd

创建 kubernetes 证书存放目录
1
➜ mkdir -p /etc/kubernetes/pki

1.3.3 网络环境设置

转发 IPv4 并让 iptables 看到桥接流量

# 加载 br_netfilter 和 overlay 模块
➜ cat > /etc/modules-load.d/k8s.conf << EOF
overlay
br_netfilter
EOF
➜ modprobe overlay
➜ modprobe br_netfilter
# 设置所需的 sysctl 参数，参数在重新启动后保持不变
➜ 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 参数而不重新启动
➜ sysctl --system

通过以下命令确认 br_netfilter 和 overlay 模块被加载：

1 2	➜ lsmod \| grep overlay ➜ lsmod \| grep br_netfilter

通过以下命令确认 net.bridge.bridge-nf-call-iptables、net.bridge.bridge-nf-call-ip6tables 和 net.ipv4.ip_forward 系统变量在你的 sysctl 配置中被设置为 1：

1	➜ sysctl net.bridge.bridge-nf-call-iptables net.bridge.bridge-nf-call-ip6tables net.ipv4.ip_forward

加载 ipvs 模块

➜ yum install -y ipset ipvsadm
➜ 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
➜ chmod +x /etc/sysconfig/modules/ipvs.modules
➜ /bin/bash /etc/sysconfig/modules/ipvs.modules
#➜ lsmod | grep -e ip_vs -e nf_conntrack_ipv4
➜ lsmod | grep -e ip_vs -e nf_conntrack

modprobe -- ip_vs: 加载 ip_vs 内核模块，该模块提供了 Linux 内核中的 IP 负载均衡功能。
modprobe -- ip_vs_rr: 加载 ip_vs_rr 内核模块，该模块提供了基于轮询算法的 IP 负载均衡策略。
modprobe -- ip_vs_wrr: 加载 ip_vs_wrr 内核模块，该模块提供了基于加权轮询算法的 IP 负载均衡策略。
modprobe -- ip_vs_sh: 加载 ip_vs_sh 内核模块，该模块提供了基于哈希算法的 IP 负载均衡策略。
modprobe -- nf_conntrack/nf_conntrack_ipv4: 加载 nf_conntrack/nf_conntrack_ipv4 内核模块，该模块提供了 Linux 内核中的网络连接跟踪功能，用于跟踪网络连接的状态。

这些命令通常用于配置 Linux 系统中的负载均衡和网络连接跟踪功能。在加载这些内核模块之后，就可以使用相应的工具和命令来配置和管理负载均衡和网络连接跟踪。例如，可以使用 ipvsadm 命令来配置 IP 负载均衡，使用 conntrack 命令来查看和管理网络连接跟踪表。

如果提示如下错误：

1	"modprobe: FATAL: Module nf_conntrack_ipv4 not found in directory /lib/modules/4.18.0-372.9.1.el8.x86_64"

则需要将 nf_conntrack_ipv4 修改为 nf_conntrack，然后重新执行命令，因为在高版本内核中已经把 nf_conntrack_ipv4 替换为 nf_conntrack。

nf_conntrack_ipv4 和 nf_conntrack 都是 Linux 内核中的网络连接跟踪模块，用于跟踪网络连接的状态。它们的区别在于：

nf_conntrack_ipv4 模块只能跟踪 IPv4 协议的网络连接，而 nf_conntrack 模块可以跟踪 IPv4 和 IPv6 协议的网络连接。
nf_conntrack_ipv4 模块是 nf_conntrack 模块的一个子模块，它提供了 IPv4 协议的网络连接跟踪功能。因此，如果要使用 nf_conntrack_ipv4 模块，必须先加载 nf_conntrack 模块。

这两个模块通常用于 Linux 系统中的网络安全和网络性能优化。它们可以被用于防火墙、负载均衡、网络流量分析等场景中，以便对网络连接进行跟踪、监控和控制。例如，可以使用 iptables 命令和 nf_conntrack 模块来实现基于连接状态的防火墙规则，或者使用 ipvsadm 命令和 nf_conntrack 模块来实现 IP 负载均衡。

1.3.4 重启系统

重启
1
➜ reboot

1.4 下载二进制包

https://kubernetes.io/zh-cn/releases/download/

从官方发布地址下载二进制包，下载 Server Binaries 即可，这个包含了所有所需的二进制文件。

https://github.com/kubernetes/kubernetes/blob/master/CHANGELOG/CHANGELOG-1.27.md

解压后，复制二进制 kube-apiserver,kube-controller-manager,kubectl,kubelet,kube-proxy,kube-scheduler 到 master 节点 /usr/local/bin 目录下，复制二进制 kubelet,kube-proxy 到 worker 节点 /usr/local/bin 目录下。

在 master1 节点执行以下命令：

➜ cd ~/Downloads
# 下载
➜ wget -c https://dl.k8s.io/v1.27.3/kubernetes-server-linux-amd64.tar.gz
# 解压
➜ tar -zxf kubernetes-server-linux-amd64.tar.gz
# 复制到 master1 节点 /usr/local/bin 目录
➜ cp kubernetes/server/bin/{kubeadm,kube-apiserver,kube-controller-manager,kubectl,kubelet,kube-proxy,kube-scheduler} /usr/local/bin
# 查看复制结果
➜ ls -lh /usr/local/bin/kube*

-rwxr-xr-x 1 root root  46M Jul 10 14:28 /usr/local/bin/kubeadm
-rwxr-xr-x 1 root root 112M Jul 10 14:28 /usr/local/bin/kube-apiserver
-rwxr-xr-x 1 root root 104M Jul 10 14:28 /usr/local/bin/kube-controller-manager
-rwxr-xr-x 1 root root  47M Jul 10 14:28 /usr/local/bin/kubectl
-rwxr-xr-x 1 root root 102M Jul 10 14:28 /usr/local/bin/kubelet
-rwxr-xr-x 1 root root  51M Jul 10 14:28 /usr/local/bin/kube-proxy
-rwxr-xr-x 1 root root  52M Jul 10 14:28 /usr/local/bin/kube-scheduler
# 复制到 worker1 节点 /usr/local/bin 目录
➜ scp kubernetes/server/bin/{kubelet,kube-proxy} root@worker1:/usr/local/bin
# 复制到 worker2 节点 /usr/local/bin 目录
➜ scp kubernetes/server/bin/{kubelet,kube-proxy} root@worker2:/usr/local/bin
# 复制到 worker3 节点 /usr/local/bin 目录
➜ scp kubernetes/server/bin/{kubelet,kube-proxy} root@worker3:/usr/local/bin

1.5 查看镜像版本

在 master1 节点执行以下命令：

# 查看依赖的镜像版本
➜ kubeadm config images list

registry.k8s.io/kube-apiserver:v1.27.3
registry.k8s.io/kube-controller-manager:v1.27.3
registry.k8s.io/kube-scheduler:v1.27.3
registry.k8s.io/kube-proxy:v1.27.3
registry.k8s.io/pause:3.9
registry.k8s.io/etcd:3.5.7-0
registry.k8s.io/coredns/coredns:v1.10.1

2. 容器运行时

本节概述了使用 containerd 作为 CRI 运行时的必要步骤。

https://blog.51cto.com/lajifeiwomoshu/5428345

2.1 安装 containerd

参考 Getting started with containerd 在各节点安装 containerd。

设置 repository

# 安装 yum-utils
➜ yum install -y yum-utils
# 添加 repository
➜ yum-config-manager --add-repo https://mirrors.aliyun.com/docker-ce/linux/centos/docker-ce.repo

或者

1 2	# 添加 repository ➜ dnf config-manager --add-repo https://mirrors.aliyun.com/docker-ce/linux/centos/docker-ce.repo

查看当前镜像源中支持的 containerd 版本
1
➜ yum list containerd.io --showduplicates

安装特定版本的 containerd

1	➜ yum install -y --setopt=obsoletes=0 containerd.io-1.6.21

添加 containerd 配置

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

https://github.com/containerd/containerd/blob/main/docs/cri/config.md

This document provides the description of the CRI plugin configuration. The CRI plugin config is part of the containerd config (default path: /etc/containerd/config.toml).
See here for more information about containerd config.
Note that the [plugins."io.containerd.grpc.v1.cri"] section is specific to CRI, and not recognized by other containerd clients such as ctr, nerdctl, and Docker/Moby.

# 创建 containerd 配置文件
➜ cat > /etc/containerd/config.toml << EOF
# https://github.com/containerd/containerd/blob/main/docs/cri/config.md
disabled_plugins = []
imports = []
version = 2

[plugins."io.containerd.grpc.v1.cri"]
  sandbox_image = "registry.k8s.io/pause:3.9"
# https://github.com/containerd/containerd/issues/6964
[plugins."io.containerd.grpc.v1.cri".containerd.runtimes.runc]
  runtime_type = "io.containerd.runc.v2"
[plugins."io.containerd.grpc.v1.cri".containerd.runtimes.runc.options]
  SystemdCgroup = true
[plugins."io.containerd.grpc.v1.cri".registry]
  config_path = "/etc/containerd/certs.d"
EOF
# 创建镜像仓库配置目录
➜ mkdir -p /etc/containerd/certs.d

启动 containerd

➜ systemctl daemon-reload
➜ systemctl enable --now containerd
# 查看 containerd 状态
➜ systemctl status containerd

查看当前 containerd 使用的配置
1
➜ containerd config dump

测试 containerd（在任意一个集群节点测试即可）

# 拉取 redis 镜像
➜ ctr images pull docker.io/library/redis:alpine
# 创建 redis 容器并运行
➜ ctr run docker.io/library/redis:alpine redis
# 删除 redis 镜像
➜ ctr images delete docker.io/library/redis:alpine

2.2 安装 containerd cli 工具

There are several command line interface (CLI) projects for interacting with containerd:

Name	Community	API	Target	Web site
`ctr`	containerd	Native	For debugging only	(None, see `ctr --help` to learn the usage)
`nerdctl`	containerd (non-core)	Native	General-purpose	https://github.com/containerd/nerdctl
`crictl`	Kubernetes SIG-node	CRI	For debugging only	https://github.com/kubernetes-sigs/cri-tools/blob/master/docs/crictl.md

2.2.1 ctr

While the ctr tool is bundled together with containerd, it should be noted the ctr tool is solely made for debugging containerd. The nerdctl tool provides stable and human-friendly user experience.

2.2.2 crictl

crictl 是 CRI 兼容的容器运行时命令行接口，可以使用它来检查和调试 k8s 节点上的容器运行时和应用程序。主要是用于 kubernetes，默认操作的命名空间是 k8s.io，而且看到的对象是 pod。

如果是 k8s 环境的话，可以参考下方链接，在每个节点部署 containerd 的时候也部署下 crictl 工具。

kubernetes-sigs/cri-tools: CLI and validation tools for Kubelet Container Runtime Interface (CRI) .

在 master1 节点执行以下命令：

➜ cd ~/Downloads
# 下载
➜ wget -c https://hub.gitmirror.com/https://github.com/kubernetes-sigs/cri-tools/releases/download/v1.27.1/crictl-v1.27.1-linux-amd64.tar.gz
# 解压到 master1 节点 /usr/local/bin 目录
➜ tar -zxvf crictl-v1.27.1-linux-amd64.tar.gz -C /usr/local/bin
# 复制到 worker1 节点 /usr/local/bin 目录
➜ scp /usr/local/bin/crictl root@worker1:/usr/local/bin
# 复制到 worker2 节点 /usr/local/bin 目录
➜ scp /usr/local/bin/crictl root@worker2:/usr/local/bin
# 复制到 worker3 节点 /usr/local/bin 目录
➜ scp /usr/local/bin/crictl root@worker3:/usr/local/bin

创建 crictl 配置文件：

➜ cat > /etc/crictl.yaml << EOF
runtime-endpoint: unix:///var/run/containerd/containerd.sock
image-endpoint: unix:///var/run/containerd/containerd.sock
timeout: 30
debug: false
EOF
➜ scp /etc/crictl.yaml root@worker1:/etc
➜ scp /etc/crictl.yaml root@worker2:/etc
➜ scp /etc/crictl.yaml root@worker3:/etc

测试 crictl 工具：

➜ crictl info --output go-template --template '{{.config.sandboxImage}}'

registry.k8s.io/pause:3.9

➜ crictl inspecti --output go-template --template '{{.status.pinned}}' registry.k8s.io/pause:3.9

FATA[0000] no such image "registry.k8s.io/pause:3.9" present

2.2.3 nerdctl（推荐）

https://github.com/containerd/nerdctl

对于单机节点来说，推荐使用 nerdctl，使用起来和 docker 类似，基本没学习成本，把 docker 换成 nerdctl 即可。对于普通用户来说，这个是比较友好的工具。但是对于 api 那些来说，可以选择其他。

nerdctl 有两种版本：

Minimal (nerdctl-1.4.0-linux-amd64.tar.gz): nerdctl only
Full (nerdctl-full-1.4.0-linux-amd64.tar.gz): Includes dependencies such as containerd, runc, and CNI

这里我选择的是 Minimal 的版本，直接到 https://github.com/containerd/nerdctl/releases 下载。

在 master1 节点执行以下命令：

➜ cd ~/Downloads
# 下载
➜ wget -c https://hub.gitmirror.com/https://github.com/containerd/nerdctl/releases/download/v1.4.0/nerdctl-1.4.0-linux-amd64.tar.gz
# 解压到 master1 节点 /usr/local/bin 目录
➜ tar Cxzvvf /usr/local/bin nerdctl-1.4.0-linux-amd64.tar.gz
# 复制到 worker1 节点 /usr/local/bin 目录
➜ scp /usr/local/bin/{containerd-rootless-setuptool.sh,containerd-rootless.sh,nerdctl} root@worker1:/usr/local/bin
# 复制到 worker2 节点 /usr/local/bin 目录
➜ scp /usr/local/bin/{containerd-rootless-setuptool.sh,containerd-rootless.sh,nerdctl} root@worker2:/usr/local/bin
# 复制到 worker3 节点 /usr/local/bin 目录
➜ scp /usr/local/bin/{containerd-rootless-setuptool.sh,containerd-rootless.sh,nerdctl} root@worker3:/usr/local/bin

测试 nerdctl（在任意一个集群节点测试即可）

# 拉取镜像
➜ nerdctl image pull redis:alpine
# 查看镜像
➜ nerdctl image ls
# 删除镜像
➜ nerdctl image rm redis:alpine
# 运行 nginx 服务（需要 CNI plugin）
#➜ nerdctl run -d --name nginx -p 80:80 nginx:alpine

2.3 设置公共仓库镜像源（可选）

https://github.com/containerd/containerd/blob/main/docs/cri/registry.md

https://github.com/containerd/containerd/blob/main/docs/hosts.md

由于某些因素，在国内拉取公共镜像仓库的速度是极慢的，为了节约拉取时间，需要为 containerd 配置镜像仓库的 mirror。

containerd 的镜像仓库 mirror 与 docker 相比有两个区别：

containerd 只支持通过 CRI 拉取镜像的 mirror，也就是说，只有通过 crictl，nerdctl 或者 kubernetes 调用时 mirror 才会生效，要想使用 ctr 拉取也生效的话需要指定 --hosts-dir。
可以通过 nerdctl --debug pull 来观察
docker 只支持为 Docker Hub 配置 mirror，而 containerd 支持为任意镜像仓库配置 mirror。
registry.aliyuncs.com/google_containers 虽然有 k8s.gcr.io 的镜像，但不是加速站点

拉取镜像时，默认都是从 docker hub 上拉取，如果镜像名前不加 registry 地址的话默认会给你加上 docker.io/library。

需要注意的是：

如果 hosts.toml 文件中的 capabilities 中不加 resolve 的话，无法加速镜像
配置无需重启服务，即可生效
要配保底的加速站点，否则可能会导致下载失败

2.3.1 docker.io

https://yeasy.gitbook.io/docker_practice/install/mirror

# 创建 docker.io 目录
➜ mkdir -p /etc/containerd/certs.d/docker.io
# 创建 docker.io 仓库配置文件
➜ cat > /etc/containerd/certs.d/docker.io/hosts.toml << EOF
# https://blog.csdn.net/qq_44797987/article/details/112681224
server = "https://docker.io"

[host."https://dockerproxy.com"]
  capabilities = ["pull", "resolve"]
[host."https://ccr.ccs.tencentyun.com"]
  capabilities = ["pull", "resolve"]
[host."https://hub-mirror.c.163.com"]
  capabilities = ["pull", "resolve"]
[host."https://mirror.baidubce.com"]
  capabilities = ["pull", "resolve"]
[host."https://registry-1.docker.io"]
  capabilities = ["pull", "resolve", "push"]
EOF

2.3.2 registry.k8s.io

# 创建 registry.k8s.io 目录
➜ mkdir -p /etc/containerd/certs.d/registry.k8s.io
# 创建 registry.k8s.io 仓库配置文件
➜ cat > /etc/containerd/certs.d/registry.k8s.io/hosts.toml << EOF
server = "https://registry.k8s.io"

[host."https://registry.aliyuncs.com/v2/google_containers"]
  capabilities = ["pull", "resolve"]
  override_path = true
EOF

registry.aliyuncs.com/google_containers 这个镜像仓库站点不是 registry.k8s.io 的 mirror，只是有 registry.k8s.io 的镜像，这就是为什么 registry.k8s.io 有些镜像在 registry.aliyuncs.com/google_containers 没有的原因。

通过执行以下命令并观察输出可以知道，从 "registry.aliyuncs.com/google_containers" 拉取 pause 镜像正确的请求是 "https://registry.cn-hangzhou.aliyuncs.com/v2/google_containers/pause/manifests/3.9"。

# 在 master1 节点进行测试
➜ ctr --debug images pull -k registry.cn-hangzhou.aliyuncs.com/google_containers/pause:3.9

...
DEBU[0000] do request                                    host=registry.cn-hangzhou.aliyuncs.com request.header.accept="application/vnd.docker.distribution.manifest.v2+json, application/vnd.docker.distribution.manifest.list.v2+json, application/vnd.oci.image.manifest.v1+json, application/vnd.oci.image.index.v1+json, */*" request.header.user-agent=containerd/1.6.21 request.method=HEAD url="https://registry.cn-hangzhou.aliyuncs.com/v2/google_containers/pause/manifests/3.9"
...

使用 ctr 命令拉取 "registry.k8s.io/pause:3.9" 镜像，如果最终拼接出的请求不是 "https://registry.cn-hangzhou.aliyuncs.com/v2/google_containers/pause/manifests/3.9"，则会导致拉取失败。

根据文档 https://github.com/containerd/containerd/blob/main/docs/hosts.md 可以知道：

1	pull [registry_host_name\|IP address][:port][/v2][/org_path][:tag\|@DIGEST]

拉取请求格式的 /v2 部分指的是分发 api 的版本。如果未包含在拉取请求中，则默认情况下为符合上面链接的分发规范的所有客户端添加 /v2。这可能会导致不合规的 OCI registry 使用有问题。

以拉取 "registry.k8s.io/pause:3.9" 镜像为例，在 master1 节点上进行测试，分析几种配置情况下实际的拉取请求 URL 及拉取结果：

2.3.2.1 配置一（错误）

# 设置 registry.k8s.io 配置
➜ cat > /etc/containerd/certs.d/registry.k8s.io/hosts.toml << EOF
server = "https://registry.k8s.io"

[host."https://registry.aliyuncs.com/google_containers"]
  capabilities = ["pull", "resolve"]
EOF
# 测试镜像拉取
➜ ctr --debug images pull --hosts-dir "/etc/containerd/certs.d" registry.k8s.io/pause:3.9

DEBU[0000] fetching                                      image="registry.k8s.io/pause:3.9"
DEBU[0000] loading host directory                        dir=/etc/containerd/certs.d/registry.k8s.io
DEBU[0000] resolving                                     host=registry.aliyuncs.com
DEBU[0000] do request                                    host=registry.aliyuncs.com request.header.accept="application/vnd.docker.distribution.manifest.v2+json, application/vnd.docker.distribution.manifest.list.v2+json, application/vnd.oci.image.manifest.v1+json, application/vnd.oci.image.index.v1+json, */*" request.header.user-agent=containerd/1.6.21 request.method=HEAD url="https://registry.aliyuncs.com/google_containers/v2/pause/manifests/3.9?ns=registry.k8s.io"
DEBU[0000] fetch response received                       host=registry.aliyuncs.com response.header.content-length=19 response.header.content-type="text/plain; charset=utf-8" response.header.date="Wed, 12 Jul 2023 14:40:38 GMT" response.header.docker-distribution-api-version=registry/2.0 response.header.x-content-type-options=nosniff response.status="404 Not Found" url="https://registry.aliyuncs.com/google_containers/v2/pause/manifests/3.9?ns=registry.k8s.io"
INFO[0000] trying next host - response was http.StatusNotFound  host=registry.aliyuncs.com
...

由输出可知，因为实际请求的 URL "https://registry.aliyuncs.com/google_containers/v2/pause/manifests/3.9?ns=registry.k8s.io" 不正确，所以拉取失败。

2.3.2.2 配置二（错误）

# 设置 registry.k8s.io 配置
➜ cat > /etc/containerd/certs.d/registry.k8s.io/hosts.toml << EOF
server = "https://registry.k8s.io"

[host."https://registry.aliyuncs.com/v2/google_containers"]
  capabilities = ["pull", "resolve"]
EOF
# 测试镜像拉取
➜ ctr --debug images pull --hosts-dir "/etc/containerd/certs.d" registry.k8s.io/pause:3.9

DEBU[0000] fetching                                      image="registry.k8s.io/pause:3.9"
DEBU[0000] loading host directory                        dir=/etc/containerd/certs.d/registry.k8s.io
DEBU[0000] resolving                                     host=registry.aliyuncs.com
DEBU[0000] do request                                    host=registry.aliyuncs.com request.header.accept="application/vnd.docker.distribution.manifest.v2+json, application/vnd.docker.distribution.manifest.list.v2+json, application/vnd.oci.image.manifest.v1+json, application/vnd.oci.image.index.v1+json, */*" request.header.user-agent=containerd/1.6.21 request.method=HEAD url="https://registry.aliyuncs.com/v2/google_containers/v2/pause/manifests/3.9?ns=registry.k8s.io"
DEBU[0000] fetch response received                       host=registry.aliyuncs.com response.header.content-length=169 response.header.content-type="application/json; charset=utf-8" response.header.date="Wed, 12 Jul 2023 15:02:21 GMT" response.header.docker-distribution-api-version=registry/2.0 response.header.www-authenticate="Bearer realm=\"https://dockerauth.cn-hangzhou.aliyuncs.com/auth\",service=\"registry.aliyuncs.com:cn-hangzhou:26842\",scope=\"repository:google_containers/v2/pause:pull\"" response.status="401 Unauthorized" url="https://registry.aliyuncs.com/v2/google_containers/v2/pause/manifests/3.9?ns=registry.k8s.io"
DEBU[0000] Unauthorized                                  header="Bearer realm=\"https://dockerauth.cn-hangzhou.aliyuncs.com/auth\",service=\"registry.aliyuncs.com:cn-hangzhou:26842\",scope=\"repository:google_containers/v2/pause:pull\"" host=registry.aliyuncs.com
DEBU[0000] do request                                    host=registry.aliyuncs.com request.header.accept="application/vnd.docker.distribution.manifest.v2+json, application/vnd.docker.distribution.manifest.list.v2+json, application/vnd.oci.image.manifest.v1+json, application/vnd.oci.image.index.v1+json, */*" request.header.user-agent=containerd/1.6.21 request.method=HEAD url="https://registry.aliyuncs.com/v2/google_containers/v2/pause/manifests/3.9?ns=registry.k8s.io"
DEBU[0000] fetch response received                       host=registry.aliyuncs.com response.header.content-length=169 response.header.content-type="application/json; charset=utf-8" response.header.date="Wed, 12 Jul 2023 15:02:21 GMT" response.header.docker-distribution-api-version=registry/2.0 response.header.www-authenticate="Bearer realm=\"https://dockerauth.cn-hangzhou.aliyuncs.com/auth\",service=\"registry.aliyuncs.com:cn-hangzhou:26842\",scope=\"repository:google_containers/v2/pause:pull\",error=\"insufficient_scope\"" response.status="401 Unauthorized" url="https://registry.aliyuncs.com/v2/google_containers/v2/pause/manifests/3.9?ns=registry.k8s.io"
DEBU[0000] Unauthorized                                  header="Bearer realm=\"https://dockerauth.cn-hangzhou.aliyuncs.com/auth\",service=\"registry.aliyuncs.com:cn-hangzhou:26842\",scope=\"repository:google_containers/v2/pause:pull\",error=\"insufficient_scope\"" host=registry.aliyuncs.com
...

由输出可知，因为实际请求的 URL "https://registry.aliyuncs.com/v2/google_containers/v2/pause/manifests/3.9?ns=registry.k8s.io" 不正确，所以拉取失败。

2.3.2.3 配置三（正确）

# 设置 registry.k8s.io 配置
➜ cat > /etc/containerd/certs.d/registry.k8s.io/hosts.toml << EOF
server = "https://registry.k8s.io"

[host."https://registry.aliyuncs.com/v2/google_containers"]
  capabilities = ["pull", "resolve"]
  override_path = true
EOF
# 测试镜像拉取
➜ ctr --debug images pull --hosts-dir "/etc/containerd/certs.d" registry.k8s.io/pause:3.9

DEBU[0000] fetching                                      image="registry.k8s.io/pause:3.9"
DEBU[0000] loading host directory                        dir=/etc/containerd/certs.d/registry.k8s.io
DEBU[0000] resolving                                     host=registry.aliyuncs.com
DEBU[0000] do request                                    host=registry.aliyuncs.com request.header.accept="application/vnd.docker.distribution.manifest.v2+json, application/vnd.docker.distribution.manifest.list.v2+json, application/vnd.oci.image.manifest.v1+json, application/vnd.oci.image.index.v1+json, */*" request.header.user-agent=containerd/1.6.21 request.method=HEAD url="https://registry.aliyuncs.com/v2/google_containers/pause/manifests/3.9?ns=registry.k8s.io"
DEBU[0000] fetch response received                       host=registry.aliyuncs.com response.header.content-length=166 response.header.content-type="application/json; charset=utf-8" response.header.date="Wed, 12 Jul 2023 15:04:06 GMT" response.header.docker-distribution-api-version=registry/2.0 response.header.www-authenticate="Bearer realm=\"https://dockerauth.cn-hangzhou.aliyuncs.com/auth\",service=\"registry.aliyuncs.com:cn-hangzhou:26842\",scope=\"repository:google_containers/pause:pull\"" response.status="401 Unauthorized" url="https://registry.aliyuncs.com/v2/google_containers/pause/manifests/3.9?ns=registry.k8s.io"
DEBU[0000] Unauthorized                                  header="Bearer realm=\"https://dockerauth.cn-hangzhou.aliyuncs.com/auth\",service=\"registry.aliyuncs.com:cn-hangzhou:26842\",scope=\"repository:google_containers/pause:pull\"" host=registry.aliyuncs.com
DEBU[0000] do request                                    host=registry.aliyuncs.com request.header.accept="application/vnd.docker.distribution.manifest.v2+json, application/vnd.docker.distribution.manifest.list.v2+json, application/vnd.oci.image.manifest.v1+json, application/vnd.oci.image.index.v1+json, */*" request.header.user-agent=containerd/1.6.21 request.method=HEAD url="https://registry.aliyuncs.com/v2/google_containers/pause/manifests/3.9?ns=registry.k8s.io"
DEBU[0000] fetch response received                       host=registry.aliyuncs.com response.header.content-length=2405 response.header.content-type=application/vnd.docker.distribution.manifest.list.v2+json response.header.date="Wed, 12 Jul 2023 15:04:07 GMT" response.header.docker-content-digest="sha256:7031c1b283388d2c2e09b57badb803c05ebed362dc88d84b480cc47f72a21097" response.header.docker-distribution-api-version=registry/2.0 response.header.etag="\"sha256:7031c1b283388d2c2e09b57badb803c05ebed362dc88d84b480cc47f72a21097\"" response.status="200 OK" url="https://registry.aliyuncs.com/v2/google_containers/pause/manifests/3.9?ns=registry.k8s.io"
DEBU[0000] resolved                                      desc.digest="sha256:7031c1b283388d2c2e09b57badb803c05ebed362dc88d84b480cc47f72a21097" host=registry.aliyuncs.com
...

由输出可知，因为实际请求的 URL "https://registry.aliyuncs.com/v2/google_containers/pause/manifests/3.9?ns=registry.k8s.io" 正确，所以拉取成功。

https://github.com/containerd/containerd/blob/main/docs/hosts.md#override_path-field

override_path is used to indicate the host's API root endpoint is defined in the URL path rather than by the API specification. This may be used with non-compliant OCI registries which are missing the /v2 prefix. (Defaults to false)

2.3.3 quay.io

# 创建 quay.io 目录
➜ mkdir -p /etc/containerd/certs.d/quay.io
# 创建 quay.io 仓库配置文件
➜ cat > /etc/containerd/certs.d/quay.io/hosts.toml << EOF
server = "https://quay.io"

[host."https://quay-mirror.qiniu.com"]
  capabilities = ["pull", "resolve"]
EOF

2.4 设置私有仓库（可选）

2.4.1 部署私有仓库

在用于测试的 registry 节点部署私有仓库，以测试 containerd 使用私有仓库的场景。

2.4.1.1 安装 docker

参考文档 Install Docker Engine on CentOS，在 registry 节点安装 docker：

切换镜像源

1	➜ wget https://mirrors.aliyun.com/docker-ce/linux/centos/docker-ce.repo -O /etc/yum.repos.d/docker-ce.repo

或者

1 2	# 添加 repository ➜ dnf config-manager --add-repo https://mirrors.aliyun.com/docker-ce/linux/centos/docker-ce.repo

查看当前镜像源中支持的 docker 版本
1
➜ yum list docker-ce --showduplicates
安装特定版本的 docker
1
➜ yum install -y --setopt=obsoletes=0 docker-ce-20.10.24
--setopt=obsoletes=0 是 yum 包管理器的一个选项，它的作用是禁用软件包依赖关系中的版本升级。

添加配置文件

docker 在默认情况下使用的 cgroup driver 为 cgroupfs，而 kubernetes 推荐使用 systemd 来替代 cgroupfs。

➜ mkdir /etc/docker
➜ cat > /etc/docker/daemon.json << EOF
{
  "exec-opts": ["native.cgroupdriver=systemd"],
  "registry-mirrors": ["https://mirror.baidubce.com", "https://hub-mirror.c.163.com"]
}
EOF

启动 dokcer

1
2
3

➜ systemctl daemon-reload
➜ systemctl enable --now docker
➜ systemctl status docker

2.4.1.2 部署 registry

https://docs.docker.com/registry/deploying/

拉取 registry 镜像
https://hub.docker.com/_/registry
1
➜ docker pull registry:2.8.1
创建 registry 数据目录
1
➜ mkdir /data

运行 registry 服务

https://yeasy.gitbook.io/docker_practice/repository/registry

➜ docker run -d \
    --name registry.local \
    --publish 5000:5000 \
    --restart always \
    --volume /data:/var/lib/registry \
    registry:2.8.1

拉取、推送测试镜像

# 拉取镜像
➜ docker pull redis:alpine
# 标记镜像
➜ docker tag redis:alpine registry.local:5000/redis:alpine
# 推送镜像
➜ docker push registry.local:5000/redis:alpine
# 查看镜像
➜ curl registry.local:5000/v2/_catalog

2.4.2 registry.local

# 创建 registry.local 目录
➜ mkdir -p /etc/containerd/certs.d/registry.local
# 创建 registry.local 仓库配置文件
➜ cat > /etc/containerd/certs.d/registry.local/hosts.toml << EOF
server = "https://registry.local"

[host."http://registry.local:5000"]
  capabilities = ["pull", "resolve", "push"]
  skip_verify = true
EOF
# 追加 /etc/hosts 配置
➜ cat >> /etc/hosts << EOF
10.128.170.235 registry.local
EOF

2.4.3 测试私有仓库

在任意一个集群节点测试即可：

1 2	# 拉取镜像 ➜ ctr --debug images pull --hosts-dir "/etc/containerd/certs.d" registry.local/redis:alpine

需要注意的是：

ctr image pull 的时候需要注意镜像名称需要完整，否则无法拉取，格式如下：
[registry_host_name|IP address][:port][/v2][/org_path][:tag|@DIGEST]
因为 ctr 不使用 CRI，所以默认不会使用 config.toml 中 cri 的配置，如果拉取镜像时希望使用 mirror，则需要指定 --hosts-dir。

3. 创建 ca 证书

证书操作如无特殊说明，只需在 master1 节点执行即可。

3.1 安装 cfssl

cfssl 是一款证书签署工具，使用 cfssl 工具可以很简化证书签署过程，方便颁发自签证书。

CloudFlare's distributes cfssl source code on github page and binaries on cfssl website.

Our documentation assumes that you will run cfssl on your local x86_64 Linux host.

https://github.com/cloudflare/cfssl/releases/tag/v1.6.4

# 下载并重命名
➜ curl -L -o https://download.nuaa.cf/cloudflare/cfssl/releases/download/v1.6.4/cfssl_1.6.4_linux_amd64
➜ curl -L -o /usr/local/bin/cfssljson https://download.nuaa.cf/cloudflare/cfssl/releases/download/v1.6.4/cfssljson_1.6.4_linux_amd64
# 赋予可执行权限
➜ chmod +x /usr/local/bin/{cfssl,cfssljson}

离线安装的情况，直接把两个文件下载下来重命名即可。

3.2 创建 ca 证书

创建的证书统一放到 /etc/kubernetes/ssl 目录，创建后复制到 /etc/kubernetes/pki 目录。

# 创建 /etc/kubernetes/ssl 目录
➜ mkdir -p /etc/kubernetes/ssl

# 进入 /etc/kubernetes/ssl 目录
➜ cd /etc/kubernetes/ssl

# ca 证书创建申请
➜ cat > ca-csr.json << EOF
{
    "CN": "kubernetes",
    "key": {
        "algo": "rsa",
        "size": 2048
    },
    "names": [
        {
            "C": "CN",
            "ST": "GuangDong",
            "L": "ShenZhen",
            "O": "k8s",
            "OU": "system"
        }
    ],
    "ca": {
        "expiry": "87600h"
    }
}
EOF

# 创建 ca 证书
➜ cfssl gencert -initca ca-csr.json | cfssljson -bare ca

# 验证结果，会生成两个证书文件
➜ ls -lh ca*pem

-rw------- 1 root root 1.7K Jul 13 12:38 ca-key.pem
-rw-r--r-- 1 root root 1.4K Jul 13 12:38 ca.pem

# 复制 ca 证书到 /etc/kubernetes/pki
➜ cp ca*pem /etc/kubernetes/pki

ca-csr.json 这个文件是 Kubernetes 集群中使用的根证书的签名请求 (CSR) 配置文件，用于定义 CA 证书的签名请求配置。

在这个配置文件中，CN 字段指定了证书的通用名称为 "kubernetes"，key 字段指定了证书的密钥算法为 RSA，密钥长度为 2048 位。names 字段定义了证书的其他信息，如国家、省份、城市、组织和组织单位等。ca 字段指定了证书的过期时间为 87600 小时（即 10 年）。

这个配置文件用于创建 Kubernetes 集群中的 CA 证书，以便对集群中的其他证书进行签名和认证。

CN(Common Name): kube-apiserver 从证书中提取该字段作为请求的用户名 (User Name)
names[].O(Organization): kube-apiserver 从证书中提取该字段作为请求用户所属的组 (Group)

由于这里是 CA 证书，是签发其它证书的根证书，这个证书密钥不会分发出去作为 client 证书，所有组件使用的 client 证书都是由 CA 证书签发而来，所以 CA 证书的 CN 和 O 的名称并不重要，后续其它签发出来的证书的 CN 和 O 的名称才是有用的。

3.3 创建签发配置文件

由于各个组件都需要配置证书，并且依赖 CA 证书来签发证书，所以我们首先要生成好 CA 证书以及后续的签发配置文件。

创建用于签发其它证书的配置文件：

# 进入 /etc/kubernetes/ssl 目录
➜ cd /etc/kubernetes/ssl

# 证书签发配置文件
➜ cat > ca-config.json << EOF
{
    "signing": {
        "default": {
            "expiry": "87600h"
        },
        "profiles": {
            "kubernetes": {
                "usages": [
                    "signing",
                    "key encipherment",
                    "server auth",
                    "client auth"
                ],
                "expiry": "87600h"
            }
        }
    }
}
EOF

ca-config.json 这个文件是签发其它证书的配置文件，用于定义签名配置和证书配置。其中，signing 字段定义了签名配置，profiles 字段定义了不同场景下的证书配置。

在这个配置文件中，default 配置指定了默认的证书过期时间为 87600 小时（即 10 年），profiles 配置定义了一个名为 "kubernetes" 的证书配置，它指定了证书的用途（签名、密钥加密、服务器认证和客户端认证）和过期时间。

这个配置文件用于创建 Kubernetes 集群中的证书和密钥，以便对集群进行安全认证和加密通信。

signing：定义了签名配置，包括默认的签名过期时间和各个证书配置的签名过期时间。
profiles：定义了不同场景下的证书配置，包括证书的用途、过期时间和其他属性。

在使用 cfssl gencert 命令生成证书时，可以使用 -config 参数指定配置文件，以便根据配置文件中的规则生成符合要求的证书。如果不指定 -config 参数，则 cfssl gencert 命令将使用默认的配置文件。

4. 部署 etcd

根据 kubeadm 获取的信息，在 Kubernetes 1.27.3 版本中 etcd 使用的版本是 3.5.7，只需在 master 节点（也即 master1 节点）部署即可。

https://github.com/etcd-io/etcd/releases/tag/v3.5.7

4.1 颁发证书

# 进入 /etc/kubernetes/ssl 目录
➜ cd /etc/kubernetes/ssl

# etcd 证书签署申请
# hosts 字段中，IP 为所有 etcd 集群节点地址，这里可以做好规划，预留几个 IP，以备后续扩容。
➜ cat > etcd-csr.json << EOF
{
    "CN": "etcd",
    "hosts": [
        "127.0.0.1",
        "10.128.170.21",
        "10.128.170.22",
        "10.128.170.23",
        "localhost",
        "master1",
        "master2",
        "master3",
        "master1.local",
        "master2.local",
        "master3.local"
    ],
    "key": {
        "algo": "rsa",
        "size": 2048
    },
    "names": [
        {
            "C": "CN",
            "ST": "GuangDong",
            "L": "ShenZhen",
            "O": "k8s",
            "OU": "system"
        }
    ]
}
EOF

# 签署 etcd 证书
➜ cfssl gencert -ca=ca.pem -ca-key=ca-key.pem -config=ca-config.json -profile=kubernetes etcd-csr.json | cfssljson -bare etcd

# 验证结果，会生成两个证书文件
➜ ls -lh etcd*pem

-rw------- 1 root root 1.7K Jul 13 23:35 etcd-key.pem
-rw-r--r-- 1 root root 1.6K Jul 13 23:35 etcd.pem

# 复制 etcd 证书到 /etc/kubernetes/pki
➜ cp etcd*pem /etc/kubernetes/pki

4.2 部署 etcd

下载二进制包 https://github.com/etcd-io/etcd/releases/tag/v3.5.7 并解压，将二进制程序 etcd 和 etcdctl 复制到 /usr/local/bin 目录下。

➜ cd ~/Downloads
# 下载
➜ wget -c https://hub.gitmirror.com/https://github.com/etcd-io/etcd/releases/download/v3.5.7/etcd-v3.5.7-linux-amd64.tar.gz
# 解压
➜ tar -zxf etcd-v3.5.7-linux-amd64.tar.gz
# 复制到 master1 节点 /usr/local/bin 目录
➜ cp etcd-v3.5.7-linux-amd64/{etcd,etcdctl} /usr/local/bin
# 查看复制结果
➜ ls -lh /usr/local/bin/etcd*

-rwxr-xr-x 1 root root 22M Jul 13 23:49 /usr/local/bin/etcd
-rwxr-xr-x 1 root root 17M Jul 13 23:49 /usr/local/bin/etcdctl

编写服务配置文件：

➜ mkdir /etc/etcd

➜ cat > /etc/etcd/etcd.conf << EOF
ETCD_NAME="etcd1"
ETCD_DATA_DIR="/var/lib/etcd/default.etcd"
ETCD_LISTEN_PEER_URLS="https://10.128.170.21:2380"
ETCD_LISTEN_CLIENT_URLS="https://10.128.170.21:2379"
ETCD_INITIAL_ADVERTISE_PEER_URLS="https://10.128.170.21:2380"
ETCD_ADVERTISE_CLIENT_URLS="https://10.128.170.21:2379"
ETCD_INITIAL_CLUSTER="etcd1=https://10.128.170.21:2380"
ETCD_INITIAL_CLUSTER_TOKEN="etcd-cluster"
ETCD_INITIAL_CLUSTER_STATE="new"
EOF

配置文件解释：

ETCD_NAME：节点名称，集群中唯一
ETCD_DATA_DIR：数据保存目录
ETCD_LISTEN_PEER_URLS：集群内部通信监听地址
ETCD_LISTEN_CLIENT_URLS：客户端访问监听地址
ETCD_INITIAL_ADVERTISE_PEER_URLS：集群通告地址
ETCD_ADVERTISE_CLIENT_URLS：客户端通告地址
ETCD_INITIAL_CLUSTER：集群节点地址列表
ETCD_INITIAL_CLUSTER_TOKEN：集群通信 token
ETCD_INITIAL_CLUSTER_STATE：加入集群的当前状态，new 是新集群，existing 表示加入已有集群

编写服务启动脚本：

# 创建数据目录
➜ mkdir -p /var/lib/etcd

# 创建系统服务
➜ cat > /lib/systemd/system/etcd.service << "EOF"
[Unit]
Description=etcd server
After=network.target
After=network-online.target
Wants=network-online.target

[Service]
Type=notify
EnvironmentFile=/etc/etcd/etcd.conf
WorkingDirectory=/var/lib/etcd
ExecStart=/usr/local/bin/etcd \
  --cert-file=/etc/kubernetes/pki/etcd.pem \
  --key-file=/etc/kubernetes/pki/etcd-key.pem \
  --trusted-ca-file=/etc/kubernetes/pki/ca.pem \
  --peer-cert-file=/etc/kubernetes/pki/etcd.pem \
  --peer-key-file=/etc/kubernetes/pki/etcd-key.pem \
  --peer-trusted-ca-file=/etc/kubernetes/pki/ca.pem \
  --peer-client-cert-auth \
  --client-cert-auth
Restart=on-failure
RestartSec=5
LimitNOFILE=65535

[Install]
WantedBy=multi-user.target
EOF

启动 etcd 服务：

➜ systemctl daemon-reload

➜ systemctl enable --now etcd

# 验证结果
➜ systemctl status etcd

# 查看日志
➜ journalctl -u etcd

5. 部署 kube-apiserver

只需在 master 节点（也即 master1 节点）部署即可。

5.1 颁发证书

# 进入 /etc/kubernetes/ssl 目录
➜ cd /etc/kubernetes/ssl

# kube-apiserver 证书签署申请
# hosts 字段中，IP 为所有 kube-apiserver 节点地址，这里可以做好规划，预留几个 IP，以备后续扩容。
# 10.96.0.1 是 service 网段的第一个 IP
# kubernetes.default.svc.cluster.local 是 kube-apiserver 的 service 域名
➜ cat > kube-apiserver-csr.json << EOF
{
    "CN": "kubernetes",
    "hosts": [
        "127.0.0.1",
        "10.128.170.21",
        "10.128.170.22",
        "10.128.170.23",
        "10.96.0.1",
        "localhost",
        "master1",
        "master2",
        "master3",
        "master1.local",
        "master2.local",
        "master3.local",
        "kubernetes",
        "kubernetes.default",
        "kubernetes.default.svc",
        "kubernetes.default.svc.cluster",
        "kubernetes.default.svc.cluster.local"
    ],
    "key": {
        "algo": "rsa",
        "size": 2048
    },
    "names": [
        {
            "C": "CN",
            "ST": "GuangDong",
            "L": "ShenZhen",
            "O": "k8s",
            "OU": "system"
        }
    ]
}
EOF

# 签署 kube-apiserver 证书
➜ cfssl gencert -ca=ca.pem -ca-key=ca-key.pem -config=ca-config.json -profile=kubernetes kube-apiserver-csr.json | cfssljson -bare kube-apiserver

# 验证结果，会生成两个证书文件
➜ ls -lh kube-apiserver*pem

-rw------- 1 root root 1.7K Jul 14 00:07 kube-apiserver-key.pem
-rw-r--r-- 1 root root 1.8K Jul 14 00:07 kube-apiserver.pem

# 复制 kube-apiserver 证书到 /etc/kubernetes/pki
➜ cp kube-apiserver*pem /etc/kubernetes/pki

5.2 部署 kube-apiserver

编写服务配置文件：

# 可以使用 kubeadm 生成示例配置文件，然后进行修改
#➜ kubeadm init phase control-plane apiserver --dry-run -v 4

#...
#[control-plane] Creating static Pod manifest for "kube-apiserver"
#...
#I0717 00:13:59.260175    6660 manifests.go:154] [control-plane] wrote static Pod manifest for component "kube-apiserver" to "/etc/kubernetes/tmp/kubeadm-init-dryrun365914376/kube-apiserver.yaml"
#...

➜ cat > /etc/kubernetes/kube-apiserver.conf << EOF
KUBE_APISERVER_OPTS="--enable-admission-plugins=NamespaceLifecycle,NodeRestriction,LimitRanger,ServiceAccount,DefaultStorageClass,ResourceQuota \
  --anonymous-auth=false \
  --bind-address=0.0.0.0 \
  --secure-port=6443 \
  --authorization-mode=Node,RBAC \
  --runtime-config=api/all=true \
  --enable-bootstrap-token-auth \
  --service-cluster-ip-range=10.96.0.0/16 \
  --token-auth-file=/etc/kubernetes/token.csv \
  --service-node-port-range=30000-32767 \
  --tls-cert-file=/etc/kubernetes/pki/kube-apiserver.pem \
  --tls-private-key-file=/etc/kubernetes/pki/kube-apiserver-key.pem \
  --client-ca-file=/etc/kubernetes/pki/ca.pem \
  --kubelet-client-certificate=/etc/kubernetes/pki/kube-apiserver.pem \
  --kubelet-client-key=/etc/kubernetes/pki/kube-apiserver-key.pem \
  --service-account-key-file=/etc/kubernetes/pki/ca-key.pem \
  --service-account-signing-key-file=/etc/kubernetes/pki/ca-key.pem \
  --service-account-issuer=https://kubernetes.default.svc.cluster.local \
  --etcd-cafile=/etc/kubernetes/pki/ca.pem \
  --etcd-certfile=/etc/kubernetes/pki/etcd.pem \
  --etcd-keyfile=/etc/kubernetes/pki/etcd-key.pem \
  --etcd-servers=https://10.128.170.21:2379 \
  --allow-privileged=true \
  --apiserver-count=1 \
  --audit-log-maxage=30 \
  --audit-log-maxbackup=3 \
  --audit-log-maxsize=100 \
  --audit-log-path=/var/log/kube-apiserver-audit.log \
  --event-ttl=1h \
  --v=4"
EOF

如果 etcd 是一个集群，则 --etcd-servers 可以添加多个，例如：--etcd-servers=https://10.128.170.21:2379,https://10.128.170.22:2379,https://10.128.170.23:2379

生成 token 文件：

1
2
3

➜ cat > /etc/kubernetes/token.csv << EOF
$(head -c 16 /dev/urandom | od -An -t x | tr -d ' '),kubelet-bootstrap,10001,"system:node-bootstrapper"
EOF

在这个命令中，head -c 16 /dev/urandom | od -An -t x | tr -d ' ' 生成了一个 16 字节的随机字符串，并将其转换为十六进制格式。这个字符串将作为令牌的值。
kubelet-bootstrap 是令牌的用户名
10001 是令牌的 UID，
system:node-bootstrapper 是令牌的组名。
这些值将用于 kubelet 节点的身份验证和授权。

编写服务启动脚本：

➜ cat > /usr/lib/systemd/system/kube-apiserver.service << "EOF"
[Unit]
Description=Kubernetes API Server
Documentation=https://github.com/kubernetes/kubernetes
After=network.target network-online.target
Wants=network-online.target

[Service]
Type=notify
EnvironmentFile=/etc/kubernetes/kube-apiserver.conf
ExecStart=/usr/local/bin/kube-apiserver $KUBE_APISERVER_OPTS
Restart=on-failure
RestartSec=5
LimitNOFILE=65535

[Install]
WantedBy=multi-user.target
EOF

启动 kube-apiserver 服务：

➜ systemctl daemon-reload

➜ systemctl enable --now kube-apiserver

# 验证结果
➜ systemctl status kube-apiserver

# 查看日志
➜ journalctl -u kube-apiserver

6. 配置 kubectl

部署完 kube-apiserver 后，就可以配置 kubectl 了，因为 kubectl 可以验证 kube-apiserver 是否已经正常工作了。

只需在 master 节点（也即 master1 节点）配置即可。

6.1 颁发证书

# 进入 /etc/kubernetes/ssl 目录
➜ cd /etc/kubernetes/ssl

# kubectl 证书签署申请
# O 参数的值必须为 system:masters，因为这是 kube-apiserver 一个内置好的角色，拥有集群管理的权限
➜ cat > kubectl-csr.json << EOF
{
    "CN": "clusteradmin",
    "key": {
        "algo": "rsa",
        "size": 2048
    },
    "names": [
        {
            "C": "CN",
            "ST": "GuangDong",
            "L": "ShenZhen",
            "O": "system:masters",
            "OU": "system"
        }
    ]
}
EOF

# 签署 kubectl 证书
➜ cfssl gencert -ca=ca.pem -ca-key=ca-key.pem -config=ca-config.json -profile=kubernetes kubectl-csr.json | cfssljson -bare kubectl

# 验证结果，会生成两个证书文件
➜ ls -lh kubectl*pem

-rw------- 1 root root 1.7K Jul 14 00:45 kubectl-key.pem
-rw-r--r-- 1 root root 1.4K Jul 14 00:45 kubectl.pem

6.2 生成配置文件

➜ kubectl config set-cluster kubernetes --certificate-authority=ca.pem --embed-certs=true --server=https://10.128.170.21:6443 --kubeconfig=kube.config

➜ kubectl config set-credentials clusteradmin --client-certificate=kubectl.pem --client-key=kubectl-key.pem --embed-certs=true --kubeconfig=kube.config

➜ kubectl config set-context kubernetes --cluster=kubernetes --user=clusteradmin --kubeconfig=kube.config

➜ kubectl config use-context kubernetes --kubeconfig=kube.config

➜ mkdir ~/.kube

➜ cp kube.config ~/.kube/config

以上命令用于在本地创建一个 Kubernetes 配置文件 kube.config，并将其复制到 ~/.kube/config 文件中，以便使用 kubectl 命令与 Kubernetes 集群进行交互。

kubectl config set-cluster 命令设置了一个名为 kubernetes 的集群，指定了以下参数：
--certificate-authority=ca.pem：指定 CA 证书文件的路径。
--embed-certs=true：将 CA 证书嵌入到配置文件中。
--server=https://10.128.170.21:6443：指定 API Server 的地址和端口。
--kubeconfig=kube.config：指定要写入的配置文件路径。
这些参数将用于创建一个名为 kubernetes 的集群配置，并将其写入到 kube.config 文件中。
kubectl config set-credentials 命令设置了一个名为 clusteradmin 的用户，指定了以下参数：
--client-certificate=kubectl.pem：指定客户端证书文件的路径。
--client-key=kubectl-key.pem：指定客户端私钥文件的路径。
--embed-certs=true：将客户端证书和私钥嵌入到配置文件中。
--kubeconfig=kube.config：指定要写入的配置文件路径。
这些参数将用于创建一个名为 clusteradmin 的用户配置，并将其写入到 kube.config 文件中。
kubectl config set-context 命令设置了一个名为 kubernetes 的上下文，指定了以下参数：
--cluster=kubernetes：指定要使用的集群。
--user=clusteradmin：指定要使用的用户。
--kubeconfig=kube.config：指定要写入的配置文件路径。
这些参数将用于创建一个名为 kubernetes 的上下文配置，并将其写入到 kube.config 文件中。
kubectl config use-context 命令将当前上下文设置为 kubernetes，指定了以下参数：
--kubeconfig=kube.config：指定要使用的配置文件路径。
这个命令将当前上下文设置为 kubernetes，以便 kubectl 命令可以使用 kube.config 文件与 Kubernetes 集群进行交互。

6.3 获取集群信息

➜ kubectl cluster-info

Kubernetes control plane is running at https://10.128.170.21:6443

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

➜ kubectl get all -A

NAMESPACE   NAME                 TYPE        CLUSTER-IP   EXTERNAL-IP   PORT(S)   AGE
default     service/kubernetes   ClusterIP   10.96.0.1            443/TCP   22m

➜ kubectl get cs

Warning: v1 ComponentStatus is deprecated in v1.19+
NAME                 STATUS      MESSAGE                                                                                        ERROR
controller-manager   Unhealthy   Get "https://127.0.0.1:10257/healthz": dial tcp 127.0.0.1:10257: connect: connection refused
scheduler            Unhealthy   Get "https://127.0.0.1:10259/healthz": dial tcp 127.0.0.1:10259: connect: connection refused
etcd-0               Healthy     {"health":"true","reason":""}

6.4 设置 kubectl 自动补全

查看 kubectl 命令自动补全帮助：

➜ kubectl completion --help
````

安装 bash-completion：

```shell
➜ yum install -y bash-completion

设置 kubectl 自动补全配置：

➜ echo "source <(kubectl completion bash)" >> ~/.bashrc
````

使配置生效：

```shell
➜ source ~/.bashrc

7. 部署 kube-controller-manager

只需在 master 节点（也即 master1 节点）部署即可。

7.1 颁发证书

# 进入 /etc/kubernetes/ssl 目录
➜ cd /etc/kubernetes/ssl

# kube-controller-manager 证书签署申请
# hosts 字段中，IP 为所有节点地址，这里可以做好规划，预留几个 IP，以备后续扩容。
➜ cat > kube-controller-manager-csr.json << EOF
{
    "CN": "system:kube-controller-manager",
    "hosts": [
        "127.0.0.1",
        "10.128.170.21",
        "10.128.170.22",
        "10.128.170.23",
        "10.128.170.131",
        "10.128.170.132",
        "10.128.170.133",
        "10.128.170.134",
        "10.128.170.135",
        "localhost",
        "master1",
        "master2",
        "master3",
        "worker1",
        "worker2",
        "worker3",
        "worker4",
        "worker5",
        "master1.local",
        "master2.local",
        "master3.local",
        "worker1.local",
        "worker2.local",
        "worker3.local",
        "worker4.local",
        "worker5.local"
    ],
    "key": {
        "algo": "rsa",
        "size": 2048
    },
    "names": [
        {
            "C": "CN",
            "ST": "GuangDong",
            "L": "ShenZhen",
            "O": "system:kube-controller-manager",
            "OU": "system"
        }
    ]
}
EOF

# 签署 kube-controller-manager 证书
➜ cfssl gencert -ca=ca.pem -ca-key=ca-key.pem -config=ca-config.json -profile=kubernetes kube-controller-manager-csr.json | cfssljson -bare kube-controller-manager

# 验证结果，会生成两个证书文件
➜ ls -lh kube-controller-manager*pem

-rw------- 1 root root 1.7K Jul 14 00:55 kube-controller-manager-key.pem
-rw-r--r-- 1 root root 1.8K Jul 14 00:55 kube-controller-manager.pem

# 复制 kube-controler-manager 证书到 /etc/kubernetes/pki
➜ cp kube-controller-manager*pem /etc/kubernetes/pki

system:kube-controller-manager 是 Kubernetes 中的一个预定义 RBAC 角色，用于授权 kube-controller-manager 组件对 Kubernetes API 的访问。详细介绍请参考官方文档：https://kubernetes.io/zh-cn/docs/reference/access-authn-authz/rbac/#default-roles-and-role-bindings

7.2 部署 kube-controller-manager

编写服务配置文件：

# 可以使用 kubeadm 生成示例配置文件，然后进行修改
#➜ kubeadm init phase control-plane controller-manager --dry-run -v 4

#...
#[control-plane] Creating static Pod manifest for "kube-controller-manager"
#...
#I0717 00:18:23.798277    6694 manifests.go:154] [control-plane] wrote static Pod manifest for component "kube-controller-manager" to "/etc/kubernetes/tmp/kubeadm-init-dryrun963226442/kube-controller-manager.yaml"
#...

➜ cat > /etc/kubernetes/kube-controller-manager.conf << EOF
KUBE_CONTROLLER_MANAGER_OPTS="--secure-port=10257 \
  --kubeconfig=/etc/kubernetes/kube-controller-manager.kubeconfig \
  --service-cluster-ip-range=10.96.0.0/16 \
  --cluster-name=kubernetes \
  --cluster-signing-cert-file=/etc/kubernetes/pki/ca.pem \
  --cluster-signing-key-file=/etc/kubernetes/pki/ca-key.pem \
  --cluster-signing-duration=87600h \
  --tls-cert-file=/etc/kubernetes/pki/kube-controller-manager.pem \
  --tls-private-key-file=/etc/kubernetes/pki/kube-controller-manager-key.pem \
  --service-account-private-key-file=/etc/kubernetes/pki/ca-key.pem \
  --root-ca-file=/etc/kubernetes/pki/ca.pem \
  --leader-elect=true \
  --controllers=*,bootstrapsigner,tokencleaner \
  --use-service-account-credentials=true \
  --horizontal-pod-autoscaler-sync-period=10s \
  --allocate-node-cidrs=true \
  --cluster-cidr=10.240.0.0/12 \
  --v=4"
EOF

生成 kubeconfig：

➜ kubectl config set-cluster kubernetes --certificate-authority=ca.pem --embed-certs=true --server=https://10.128.170.21:6443 --kubeconfig=kube-controller-manager.kubeconfig

➜ kubectl config set-credentials kube-controller-manager --client-certificate=kube-controller-manager.pem --client-key=kube-controller-manager-key.pem --embed-certs=true --kubeconfig=kube-controller-manager.kubeconfig

➜ kubectl config set-context default --cluster=kubernetes --user=kube-controller-manager --kubeconfig=kube-controller-manager.kubeconfig

➜ kubectl config use-context default --kubeconfig=kube-controller-manager.kubeconfig

➜ cp kube-controller-manager.kubeconfig /etc/kubernetes/

编写服务启动脚本：

➜ cat > /usr/lib/systemd/system/kube-controller-manager.service << "EOF"
[Unit]
Description=Kubernetes controller manager
Documentation=https://github.com/kubernetes/kubernetes
After=network.target network-online.target
Wants=network-online.target

[Service]
EnvironmentFile=/etc/kubernetes/kube-controller-manager.conf
ExecStart=/usr/local/bin/kube-controller-manager $KUBE_CONTROLLER_MANAGER_OPTS
Restart=on-failure
RestartSec=5
LimitNOFILE=65535

[Install]
WantedBy=multi-user.target
EOF

启动 kube-controller-manager 服务：

➜ systemctl daemon-reload

➜ systemctl enable --now kube-controller-manager

# 验证结果
➜ systemctl status kube-controller-manager

# 查看日志
➜ journalctl -u kube-controller-manager

查看组件状态：

➜ kubectl get cs

Warning: v1 ComponentStatus is deprecated in v1.19+
NAME                 STATUS      MESSAGE                                                                                        ERROR
scheduler            Unhealthy   Get "https://127.0.0.1:10259/healthz": dial tcp 127.0.0.1:10259: connect: connection refused
controller-manager   Healthy     ok
etcd-0               Healthy     {"health":"true","reason":""}

8. 部署 kube-scheduler

只需在 master 节点（也即 master1 节点）部署即可。

8.1 颁发证书

# 进入 /etc/kubernetes/ssl 目录
➜ cd /etc/kubernetes/ssl

# kube-scheduler 证书签署申请
# hosts 字段中，IP 为所有节点地址，这里可以做好规划，预留几个 IP，以备后续扩容。
➜ cat > kube-scheduler-csr.json << EOF
{
    "CN": "system:kube-scheduler",
    "hosts": [
        "127.0.0.1",
        "10.128.170.21",
        "10.128.170.22",
        "10.128.170.23",
        "10.128.170.131",
        "10.128.170.132",
        "10.128.170.133",
        "10.128.170.134",
        "10.128.170.135",
        "localhost",
        "master1",
        "master2",
        "master3",
        "worker1",
        "worker2",
        "worker3",
        "worker4",
        "worker5",
        "master1.local",
        "master2.local",
        "master3.local",
        "worker1.local",
        "worker2.local",
        "worker3.local",
        "worker4.local",
        "worker5.local"
    ],
    "key": {
        "algo": "rsa",
        "size": 2048
    },
    "names": [
        {
            "C": "CN",
            "ST": "GuangDong",
            "L": "ShenZhen",
            "O": "system:kube-scheduler",
            "OU": "system"
        }
    ]
}
EOF

# 签署 kube-scheduler 证书
➜ cfssl gencert -ca=ca.pem -ca-key=ca-key.pem -config=ca-config.json -profile=kubernetes kube-scheduler-csr.json | cfssljson -bare kube-scheduler

# 验证结果，会生成两个证书文件
➜ ls -lh kube-scheduler*pem

-rw------- 1 root root 1.7K Jul 14 01:06 kube-scheduler-key.pem
-rw-r--r-- 1 root root 1.8K Jul 14 01:06 kube-scheduler.pem

# 复制 kube-scheduler 证书到 /etc/kubernetes/pki
➜ cp kube-scheduler*pem /etc/kubernetes/pki

8.2 部署 kube-scheduler

编写服务配置文件：

# 可以使用 kubeadm 生成示例配置文件，然后进行修改
#➜ kubeadm init phase control-plane scheduler --dry-run -v 4

#...
#[control-plane] Creating static Pod manifest for "kube-scheduler"
#...
#I0717 00:26:08.548412    6903 manifests.go:154] [control-plane] wrote static Pod manifest for component "kube-scheduler" to "/etc/kubernetes/tmp/kubeadm-init-dryrun1609159078/kube-scheduler.yaml"
#...

➜ cat > /etc/kubernetes/kube-scheduler.conf << EOF
KUBE_SCHEDULER_OPTS="--bind-address=127.0.0.1 \
  --kubeconfig=/etc/kubernetes/kube-scheduler.kubeconfig \
  --leader-elect=true \
  --v=4"
EOF

生成 kubeconfig

➜ kubectl config set-cluster kubernetes --certificate-authority=ca.pem --embed-certs=true --server=https://10.128.170.21:6443 --kubeconfig=kube-scheduler.kubeconfig

➜ kubectl config set-credentials kube-scheduler --client-certificate=kube-scheduler.pem --client-key=kube-scheduler-key.pem --embed-certs=true --kubeconfig=kube-scheduler.kubeconfig

➜ kubectl config set-context default --cluster=kubernetes --user=kube-scheduler --kubeconfig=kube-scheduler.kubeconfig

➜ kubectl config use-context default --kubeconfig=kube-scheduler.kubeconfig

➜ cp kube-scheduler.kubeconfig /etc/kubernetes/

编写服务启动脚本：

➜ cat > /usr/lib/systemd/system/kube-scheduler.service << "EOF"
[Unit]
Description=Kubernetes scheduler
Documentation=https://github.com/kubernetes/kubernetes
After=network.target network-online.target
Wants=network-online.target

[Service]
EnvironmentFile=/etc/kubernetes/kube-scheduler.conf
ExecStart=/usr/local/bin/kube-scheduler $KUBE_SCHEDULER_OPTS
Restart=on-failure
RestartSec=5
LimitNOFILE=65535

[Install]
WantedBy=multi-user.target
EOF

启动 kube-scheduler 服务：

➜ systemctl daemon-reload

➜ systemctl enable --now kube-scheduler

# 验证结果
➜ systemctl status kube-scheduler

# 查看日志
➜ journalctl -u kube-scheduler

查看组件状态：

➜ 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":""}

9. 部署 kubelet

先在 master 节点完成部署，后续添加 worker 节点时从 master 节点复制配置并调整即可。

master 节点上部署 kubelet 是可选的，一旦部署 kubelet，master 节点也可以运行 Pod，如果不希望 master 节点上运行 Pod，则可以给 master 节点打上污点。

master 节点部署 kubelet 是有好处的，一是可以通过诸如 kubectl get node 等命令查看节点信息，二是可以在上面部署监控系统，日志采集系统等。

9.1 授权 kubelet 允许请求证书

授权 kubelet-bootstrap 用户允许请求证书：

# 进入 /etc/kubernetes/ssl 目录
➜ cd /etc/kubernetes/ssl

➜ kubectl create clusterrolebinding kubelet-bootstrap \
--clusterrole=system:node-bootstrapper \
--user=kubelet-bootstrap

clusterrolebinding.rbac.authorization.k8s.io/kubelet-bootstrap created

9.2 部署 kubelet

编写服务配置文件：

# 可以使用 kubeadm 生成示例配置文件，然后进行修改
#➜ kubeadm init phase kubelet-start --dry-run

#[kubelet-start] Writing kubelet environment file with flags to file "/etc/kubernetes/tmp/kubeadm-init-dryrun3282605628/kubeadm-flags.env"
#[kubelet-start] Writing kubelet configuration to file "/etc/kubernetes/tmp/kubeadm-init-dryrun3282605628/config.yaml"

# https://github.com/kubernetes-sigs/sig-windows-tools/issues/323
# https://github.com/kubernetes/kubernetes/pull/118544
➜ cat > /etc/kubernetes/kubelet.conf << EOF
KUBELET_OPTS="--bootstrap-kubeconfig=/etc/kubernetes/kubelet-bootstrap.kubeconfig \
  --config=/etc/kubernetes/kubelet.yaml \
  --kubeconfig=/etc/kubernetes/kubelet.kubeconfig \
  --cert-dir=/etc/kubernetes/pki \
  --container-runtime-endpoint=unix:///var/run/containerd/containerd.sock \
  --pod-infra-container-image=registry.k8s.io/pause:3.9 \
  --v=4
EOF

➜ cat > /etc/kubernetes/kubelet.yaml << EOF
kind: KubeletConfiguration
apiVersion: kubelet.config.k8s.io/v1beta1
address: 0.0.0.0
port: 10250
readOnlyPort: 0
authentication:
  anonymous:
    enabled: false
  webhook:
    cacheTTL: 2m0s
    enabled: true
  x509:
    clientCAFile: /etc/kubernetes/pki/ca.pem
authorization:
  mode: Webhook
  webhook:
    cacheAuthorizedTTL: 5m0s
    cacheUnauthorizedTTL: 30s
cgroupDriver: systemd
clusterDNS:
- 10.96.0.10
clusterDomain: cluster.local
healthzBindAddress: 127.0.0.1
healthzPort: 10248
rotateCertificates: true
evictionHard:
  imagefs.available: 15%
  memory.available: 100Mi
  nodefs.available: 10%
  nodefs.inodesFree: 5%
maxOpenFiles: 1000000
maxPods: 110
EOF

生成 kubeconfig：

➜ kubectl config set-cluster kubernetes --certificate-authority=ca.pem --embed-certs=true --server=https://10.128.170.21:6443 --kubeconfig=kubelet-bootstrap.kubeconfig

➜ kubectl config set-credentials kubelet-bootstrap --token=$(awk -F, '{print $1}' /etc/kubernetes/token.csv) --kubeconfig=kubelet-bootstrap.kubeconfig

➜ kubectl config set-context default --cluster=kubernetes --user=kubelet-bootstrap --kubeconfig=kubelet-bootstrap.kubeconfig

➜ kubectl config use-context default --kubeconfig=kubelet-bootstrap.kubeconfig

➜ cp kubelet-bootstrap.kubeconfig /etc/kubernetes/

编写服务启动脚本：

➜ cat > /usr/lib/systemd/system/kubelet.service << "EOF"
[Unit]
Description=Kubernetes kubelet
After=network.target network-online.targer containerd.service
Requires=containerd.service

[Service]
EnvironmentFile=/etc/kubernetes/kubelet.conf
ExecStart=/usr/local/bin/kubelet $KUBELET_OPTS
Restart=on-failure
RestartSec=5
LimitNOFILE=65535

[Install]
WantedBy=multi-user.target
EOF

启动 kubelet 服务：

➜ systemctl daemon-reload

➜ systemctl enable --now kubelet

# 验证结果
➜ systemctl status kubelet

# 查看日志
➜ journalctl -u kubelet

批准节点加入集群：

➜ kubectl get csr

NAME        AGE   SIGNERNAME                                    REQUESTOR           REQUESTEDDURATION   CONDITION
csr-h92vn   59s   kubernetes.io/kube-apiserver-client-kubelet   kubelet-bootstrap                 Pending

➜ kubectl certificate approve csr-h92vn

certificatesigningrequest.certificates.k8s.io/csr-h92vn approved

➜ kubectl get csr

NAME        AGE     SIGNERNAME                                    REQUESTOR           REQUESTEDDURATION   CONDITION
csr-h92vn   2m27s   kubernetes.io/kube-apiserver-client-kubelet   kubelet-bootstrap                 Approved,Issued

查看节点：

➜ kubectl get node

NAME      STATUS     ROLES    AGE   VERSION
master1   NotReady      71s   v1.27.3

# 此时节点状态还是 NotReady，因为还没有安装网络插件，正确安装网络插件后，状态会变为 Ready.

10. 部署 kube-proxy

先在 master 节点完成部署，后续添加 worker 节点时从 master 节点复制配置并调整即可。

10.1 颁发证书

# 进入 /etc/kubernetes/ssl 目录
➜ cd /etc/kubernetes/ssl

# kube-proxy 证书签署申请
➜ cat > kube-proxy-csr.json << EOF
{
    "CN": "system:kube-proxy",
    "key": {
        "algo": "rsa",
        "size": 2048
    },
    "names": [
        {
            "C": "CN",
            "ST": "GuangDong",
            "L": "ShenZhen",
            "O": "k8s",
            "OU": "system"
        }
    ]
}
EOF

# 签署 kube-proxy 证书
➜ cfssl gencert -ca=ca.pem -ca-key=ca-key.pem -config=ca-config.json -profile=kubernetes kube-proxy-csr.json | cfssljson -bare kube-proxy

# 验证结果，会生成两个证书文件
➜ ls -lh kube-proxy*pem

-rw------- 1 root root 1.7K Jul 15 18:36 kube-proxy-key.pem
-rw-r--r-- 1 root root 1.4K Jul 15 18:36 kube-proxy.pem

# 复制 kube-proxy 证书到 /etc/kubernetes/pki
➜ cp kube-proxy*pem /etc/kubernetes/pki

10.2 部署 kube-proxy

编写服务配置文件：

➜ cat > /etc/kubernetes/kube-proxy.conf << EOF
KUBE_PROXY_OPTS="--config=/etc/kubernetes/kube-proxy.yaml \
  --v=4
EOF

➜ cat > /etc/kubernetes/kube-proxy.yaml << EOF
kind: KubeProxyConfiguration
apiVersion: kubeproxy.config.k8s.io/v1alpha1
clientConnection:
  kubeconfig: /etc/kubernetes/kube-proxy.kubeconfig
bindAddress: 0.0.0.0
clusterCIDR: 10.240.0.0/12
healthzBindAddress: 0.0.0.0:10256
metricsBindAddress: 0.0.0.0:10249
mode: ipvs
ipvs:
  scheduler: "rr"
EOF

生成 kubeconfig：

➜ kubectl config set-cluster kubernetes --certificate-authority=ca.pem --embed-certs=true --server=https://10.128.170.21:6443 --kubeconfig=kube-proxy.kubeconfig

➜ kubectl config set-credentials kube-proxy --client-certificate=kube-proxy.pem --client-key=kube-proxy-key.pem --embed-certs=true --kubeconfig=kube-proxy.kubeconfig

➜ kubectl config set-context default --cluster=kubernetes --user=kube-proxy --kubeconfig=kube-proxy.kubeconfig

➜ kubectl config use-context default --kubeconfig=kube-proxy.kubeconfig

➜ cp kube-proxy.kubeconfig /etc/kubernetes/

编写服务启动脚本：

➜ cat > /usr/lib/systemd/system/kube-proxy.service << "EOF"
[Unit]
Description=Kubernetes Proxy
Documentation=https://github.com/kubernetes/kubernetes
After=network.target network-online.target
Wants=network-online.target

[Service]
EnvironmentFile=-/etc/kubernetes/kube-proxy.conf
ExecStart=/usr/local/bin/kube-proxy $KUBE_PROXY_OPTS
Restart=on-failure
RestartSec=5
LimitNOFILE=65535

[Install]
WantedBy=multi-user.target
EOF

启动 kube-proxy 服务：

➜ systemctl daemon-reload

➜ systemctl enable --now kube-proxy

# 验证结果
➜ systemctl status kube-proxy

# 查看日志
➜ journalctl -u kube-proxy

11. 部署集群网络

只需在 master 节点（也即 master1 节点）部署即可。

11.1 部署 calico

参考文档 Install Calico networking and network policy for on-premises deployments

➜ cd ~/Downloads

➜ curl -k https://cdn.jsdelivr.net/gh/projectcalico/calico@v3.26.1/manifests/calico.yaml -O

# 找到 CALICO_IPV4POOL_CIDR 变量，取消注释并修改 Pod IP 地址段
➜ sed -i 's/# \(- name: CALICO_IPV4POOL_CIDR\)/\1/' calico.yaml
➜ sed -i 's/#   value: "192.168.0.0\/16"/  value: "10.240.0.0\/12"/' calico.yaml

➜ kubectl apply -f calico.yaml

poddisruptionbudget.policy/calico-kube-controllers created
serviceaccount/calico-kube-controllers created
serviceaccount/calico-node created
serviceaccount/calico-cni-plugin created
configmap/calico-config created
customresourcedefinition.apiextensions.k8s.io/bgpconfigurations.crd.projectcalico.org created
customresourcedefinition.apiextensions.k8s.io/bgpfilters.crd.projectcalico.org created
customresourcedefinition.apiextensions.k8s.io/bgppeers.crd.projectcalico.org created
customresourcedefinition.apiextensions.k8s.io/blockaffinities.crd.projectcalico.org created
customresourcedefinition.apiextensions.k8s.io/caliconodestatuses.crd.projectcalico.org created
customresourcedefinition.apiextensions.k8s.io/clusterinformations.crd.projectcalico.org created
customresourcedefinition.apiextensions.k8s.io/felixconfigurations.crd.projectcalico.org created
customresourcedefinition.apiextensions.k8s.io/globalnetworkpolicies.crd.projectcalico.org created
customresourcedefinition.apiextensions.k8s.io/globalnetworksets.crd.projectcalico.org created
customresourcedefinition.apiextensions.k8s.io/hostendpoints.crd.projectcalico.org created
customresourcedefinition.apiextensions.k8s.io/ipamblocks.crd.projectcalico.org created
customresourcedefinition.apiextensions.k8s.io/ipamconfigs.crd.projectcalico.org created
customresourcedefinition.apiextensions.k8s.io/ipamhandles.crd.projectcalico.org created
customresourcedefinition.apiextensions.k8s.io/ippools.crd.projectcalico.org created
customresourcedefinition.apiextensions.k8s.io/ipreservations.crd.projectcalico.org created
customresourcedefinition.apiextensions.k8s.io/kubecontrollersconfigurations.crd.projectcalico.org created
customresourcedefinition.apiextensions.k8s.io/networkpolicies.crd.projectcalico.org created
customresourcedefinition.apiextensions.k8s.io/networksets.crd.projectcalico.org created
clusterrole.rbac.authorization.k8s.io/calico-kube-controllers created
clusterrole.rbac.authorization.k8s.io/calico-node created
clusterrole.rbac.authorization.k8s.io/calico-cni-plugin created
clusterrolebinding.rbac.authorization.k8s.io/calico-kube-controllers created
clusterrolebinding.rbac.authorization.k8s.io/calico-node created
clusterrolebinding.rbac.authorization.k8s.io/calico-cni-plugin created
daemonset.apps/calico-node created
deployment.apps/calico-kube-controllers created

# 查看网络 pod
➜ kubectl -n kube-system get pod

NAME                                       READY   STATUS    RESTARTS   AGE
calico-kube-controllers-85578c44bf-7v87p   1/1     Running   0          25m
calico-node-v924z                          1/1     Running   0          25m

# 查看 node 状态
➜ kubectl get node

NAME      STATUS   ROLES    AGE   VERSION
master1   Ready       30m   v1.27.3

# 查看 ipvs 模式
➜ ipvsadm -Ln

IP Virtual Server version 1.2.1 (size=4096)
Prot LocalAddress:Port Scheduler Flags
  -> RemoteAddress:Port           Forward Weight ActiveConn InActConn
TCP  10.96.0.1:443 rr
  -> 10.128.170.21:6443           Masq    1      5          0

如果 node 状态仍然是 NotReady，基本上是镜像未拉取完成或拉取失败导致的，如果一段时间后仍拉取失败，则尝试手动拉取镜像。

11.2 授权 kube-apiserver 访问 kubelet

Using RBAC Authorization

应用场景：例如 kubectl exec/run/logs

➜ cd ~/Downloads

➜ cat > apiserver-to-kubelet-rbac.yaml << EOF
apiVersion: rbac.authorization.k8s.io/v1
kind: ClusterRole
metadata:
  annotations:
    rbac.authorization.kubernetes.io/autoupdate: "true"
  labels:
    kubernetes.io/bootstrapping: rbac-defaults
  name: system:kube-apiserver-to-kubelet
rules:
  - apiGroups:
      - ""
    resources:
      - nodes/proxy
      - nodes/stats
      - nodes/log
      - nodes/spec
      - nodes/metrics
      - pods/log
    verbs:
      - "*"
---
apiVersion: rbac.authorization.k8s.io/v1
kind: ClusterRoleBinding
metadata:
  name: system:kube-apiserver
  namespace: ""
roleRef:
  apiGroup: rbac.authorization.k8s.io
  kind: ClusterRole
  name: system:kube-apiserver-to-kubelet
subjects:
  - apiGroup: rbac.authorization.k8s.io
    kind: User
    name: kubernetes
EOF

➜ kubectl apply -f apiserver-to-kubelet-rbac.yaml

clusterrole.rbac.authorization.k8s.io/system:kube-apiserver-to-kubelet created
clusterrolebinding.rbac.authorization.k8s.io/system:kube-apiserver created

➜ kubectl -n kube-system logs calico-kube-controllers-85578c44bf-7v87p

11.3 部署 coredns

https://github.com/coredns/deployment/blob/master/kubernetes/coredns.yaml.sed

coredns.yaml.sed 原始文件见附录章节 "16.1 coredns.yaml.sed"，该 yaml 指定使用的 coredns 的版本是 1.9.4。

➜ cd ~/Downloads

# 下载 yaml 文件
➜ curl https://raw.kgithub.com/coredns/deployment/master/kubernetes/coredns.yaml.sed -o coredns.yaml

修改配置：

# "coredns/coredns:1.9.4" 替换为 "coredns/coredns:1.10.1"
➜ sed -i 's/coredns\/coredns:1.9.4/coredns\/coredns:1.10.1/g' coredns.yaml
# "CLUSTER_DOMAIN" 替换为 "cluster.local"
➜ sed -i 's/CLUSTER_DOMAIN/cluster.local/g' coredns.yaml
# "REVERSE_CIDRS" 替换为 "in-addr.arpa ip6.arpa"
➜ sed -i 's/REVERSE_CIDRS/in-addr.arpa ip6.arpa/g' coredns.yaml
# "UPSTREAMNAMESERVER" 替换为 "/etc/resolv.conf"（或当前网络所使用的 DNS 地址）
➜ sed -i 's/UPSTREAMNAMESERVER/\/etc\/resolv.conf/g' coredns.yaml
# "STUBDOMAINS" 替换为 ""
➜ sed -i 's/STUBDOMAINS//g' coredns.yaml
# "CLUSTER_DNS_IP" 替换为 "10.96.0.10"（与 kubelet.yaml 配置的 clusterDNS 一致）
➜ sed -i 's/CLUSTER_DNS_IP/10.96.0.10/g' coredns.yaml

安装：

➜ kubectl apply -f coredns.yaml

serviceaccount/coredns created
clusterrole.rbac.authorization.k8s.io/system:coredns created
clusterrolebinding.rbac.authorization.k8s.io/system:coredns created
configmap/coredns created
deployment.apps/coredns created
service/kube-dns created

验证（如果 calico 的 pod 未就绪，请检查是否是镜像拉取未完成或镜像拉取失败）

➜ kubectl -n kube-system get deploy,pod,svc

NAME                                      READY   UP-TO-DATE   AVAILABLE   AGE
deployment.apps/calico-kube-controllers   1/1     1            1           23h
deployment.apps/coredns                   1/1     1            1           43s

NAME                                           READY   STATUS    RESTARTS   AGE
pod/calico-kube-controllers-85578c44bf-7v87p   1/1     Running   0          23h
pod/calico-node-v924z                          1/1     Running   0          23h
pod/coredns-db5667c87-zg9s8                    1/1     Running   0          41s

NAME               TYPE        CLUSTER-IP   EXTERNAL-IP   PORT(S)                  AGE
service/kube-dns   ClusterIP   10.96.0.10           53/UDP,53/TCP,9153/TCP   43s

dig 测试：

➜ yum -y install bind-utils

➜ dig -t A www.baidu.com @10.96.0.10 +short

www.a.shifen.com.
14.119.104.254
14.119.104.189

pod 测试：

➜ kubectl run -it --rm --image=busybox:1.28.3 -- sh

If you don't see a command prompt, try pressing enter.
/ # cat /etc/resolv.conf
search default.svc.cluster.local svc.cluster.local cluster.local
nameserver 10.96.0.10
options ndots:5
/ # nslookup kubernetes.default
Server:    10.96.0.10
Address 1: 10.96.0.10 kube-dns.kube-system.svc.cluster.local

Name:      kubernetes.default
Address 1: 10.96.0.1 kubernetes.default.svc.cluster.local
/ # ping -c 4 www.baidu.com
PING www.baidu.com (14.119.104.254): 56 data bytes
64 bytes from 14.119.104.254: seq=0 ttl=127 time=14.193 ms
64 bytes from 14.119.104.254: seq=1 ttl=127 time=12.848 ms
64 bytes from 14.119.104.254: seq=2 ttl=127 time=18.553 ms
64 bytes from 14.119.104.254: seq=3 ttl=127 time=23.581 ms

--- www.baidu.com ping statistics ---
4 packets transmitted, 4 packets received, 0% packet loss
round-trip min/avg/max = 12.848/17.293/23.581 ms

12. 添加 worker 节点

worker 节点需要部署两个组件 kubelet, kube-proxy。

在 master 节点执行，从 master 节点上复制以下文件到 worker 节点：

➜ scp /etc/kubernetes/pki/ca.pem \
       /etc/kubernetes/pki/kube-proxy.pem \
       /etc/kubernetes/pki/kube-proxy-key.pem \
       root@worker1:/etc/kubernetes/pki/

➜ scp /etc/kubernetes/kubelet.conf \
       /etc/kubernetes/kubelet.yaml \
       /etc/kubernetes/kubelet-bootstrap.kubeconfig \
       /etc/kubernetes/kube-proxy.conf \
       /etc/kubernetes/kube-proxy.yaml \
       /etc/kubernetes/kube-proxy.kubeconfig \
       root@worker1:/etc/kubernetes/

➜ scp /usr/lib/systemd/system/kubelet.service \
       /usr/lib/systemd/system/kube-proxy.service \
       root@worker1:/usr/lib/systemd/system/

➜ scp /usr/local/bin/kubelet \
       /usr/local/bin/kube-proxy \
       root@worker1:/usr/local/bin/

在 worker 节点执行，worker 节点启动 kube-proxy 服务：

➜ systemctl daemon-reload

➜ systemctl enable --now kube-proxy

# 验证结果
➜ systemctl status kube-proxy

# 查看日志
➜ journalctl -u kube-proxy

在 worker 节点执行，worker 节点启动 kubelet 服务：

➜ systemctl daemon-reload

➜ systemctl enable --now kubelet

# 验证结果
➜ systemctl status kubelet

# 查看日志
➜ journalctl -u kubelet

（master 节点执行）批准 worker 节点加入集群

➜ kubectl get csr
NAME        AGE   SIGNERNAME                                    REQUESTOR           REQUESTEDDURATION   CONDITION
csr-9twkl   85s   kubernetes.io/kube-apiserver-client-kubelet   kubelet-bootstrap                 Pending

➜ kubectl certificate approve csr-9twkl

certificatesigningrequest.certificates.k8s.io/csr-9twkl approved

➜ kubectl get csr

NAME        AGE     SIGNERNAME                                    REQUESTOR           REQUESTEDDURATION   CONDITION
csr-9twkl   2m15s   kubernetes.io/kube-apiserver-client-kubelet   kubelet-bootstrap                 Approved,Issued

在 master 节点执行，查看节点：

➜ kubectl get node

NAME      STATUS   ROLES    AGE   VERSION
master1   Ready       47h   v1.27.3
worker1   Ready       26m   v1.27.3

如果 worker1 的状态仍是 NotReady，请检查是否是镜像拉取未完成或镜像拉取失败。

13. 禁止 master 节点运行 pod

至此 1 master 1 worker 的 k8s 二进制集群已搭建完毕。

此外，还可以给节点打上角色标签，使得查看节点信息更加直观：

# 给 master 节点打上 master,etcd 角色标签
➜ kubectl label node master1 node-role.kubernetes.io/master=true node-role.kubernetes.io/etcd=true

# 给 worker 节点打上 worker 角色标签
➜ kubectl label node worker1 node-role.kubernetes.io/worker=true

# 查看标签
➜ kubectl get node --show-labels

# 删除标签
#➜ kubectl label node master1 node-role.kubernetes.io/etcd-

如果不希望 master 节点运行 Pod，则给 master 打上污点：

# 添加污点
➜ kubectl taint node master1 node-role.kubernetes.io/master=true:NoSchedule

# 查看污点
➜ kubectl describe node master1 | grep Taints

Taints:             node-role.kubernetes.io/master=true:NoSchedule

# 查看全部节点的污点
#➜ kubectl get nodes -o jsonpath='{range .items[*]}{.metadata.name}{"\n"}{.spec.taints}{"\n\n"}{end}'

# 删除污点
#➜ kubectl taint node master1 node-role.kubernetes.io/master-

后续可以新增 2 个 etcd 节点组成 etcd 集群，新增 2 个控制平面，避免单点故障。

14. 测试应用服务部署

创建 namespace：

➜ kubectl create namespace dev

namespace/dev created

➜ kubectl get namespace

NAME              STATUS   AGE
default           Active   2d
dev               Active   7m
kube-node-lease   Active   2d
kube-public       Active   2d
kube-system       Active   2d

创建 deployment：

➜ mkdir -p /etc/kubernetes/demo

➜ cat > /etc/kubernetes/demo/nginx-deployment.yaml << EOF
apiVersion: apps/v1
kind: Deployment
metadata:
  name: nginx-deployment
  namespace: dev
spec:
  replicas: 1
  selector:
    matchLabels:
      app: nginx-pod
  template:
    metadata:
      labels:
        app: nginx-pod
    spec:
      containers:
      - name: nginx
        image: nginx:latest
EOF

➜ kubectl apply -f /etc/kubernetes/demo/nginx-deployment.yaml

deployment.apps/nginx-deployment created

➜ kubectl -n dev get pod

NAME                                READY   STATUS    RESTARTS   AGE
nginx-deployment-6d76bcb866-zl52j   1/1     Running   0          23s

创建 service：

➜ cat > /etc/kubernetes/demo/nginx-service.yaml << EOF
apiVersion: v1
kind: Service
metadata:
  name: nginx-service
  namespace: dev
spec:
  selector:
    app: nginx-pod
  type: NodePort
  ports:
  - port: 80
    targetPort: 80
    nodePort: 30001
EOF

➜ kubectl apply -f /etc/kubernetes/demo/nginx-service.yaml

service/nginx-service created

➜ kubectl -n dev get svc

NAME            TYPE       CLUSTER-IP      EXTERNAL-IP   PORT(S)        AGE
nginx-service   NodePort   10.96.195.221           80:30001/TCP   13s

测试服务访问：

➜ curl 10.128.170.21:30001 -I

HTTP/1.1 200 OK
Server: nginx/1.25.1
Date: Tue, 18 Jul 2023 16:56:37 GMT
Content-Type: text/html
Content-Length: 615
Last-Modified: Tue, 13 Jun 2023 15:08:10 GMT
Connection: keep-alive
ETag: "6488865a-267"
Accept-Ranges: bytes

15. 部署 Dashboard

在 Kubernetes 社区中，有一个很受欢迎的 Dashboard 项目，它可以给用户提供一个可视化的 Web 界面来查看当前集群的各种信息。用户可以用 Kubernetes Dashboard 部署容器化的应用、监控应用的状态、执行故障排查任务以及管理 Kubernetes 各种资源。

官方参考文档：

使用 nodeport 方式将 dashboard 服务暴露在集群外，指定使用 30443 端口。

➜ cd ~/Downloads

# 下载相关 yaml 文件
# https://github.com/kubernetes/dashboard/blob/v2.7.0/aio/deploy/recommended.yaml
➜ curl https://fastly.jsdelivr.net/gh/kubernetes/dashboard@v2.7.0/aio/deploy/recommended.yaml -o kubernetes-dashboard.yaml

# 修改 Service 部分
➜ vim kubernetes-dashboard.yaml
kind: Service
apiVersion: v1
metadata:
  labels:
    k8s-app: kubernetes-dashboard
  name: kubernetes-dashboard
  namespace: kubernetes-dashboard
spec:
  type: NodePort  # 新增
  ports:
    - port: 443
      targetPort: 8443
      nodePort: 30443  # 新增
  selector:
    k8s-app: kubernetes-dashboard

# 部署
➜ kubectl apply -f kubernetes-dashboard.yaml

namespace/kubernetes-dashboard created
serviceaccount/kubernetes-dashboard created
service/kubernetes-dashboard created
secret/kubernetes-dashboard-certs created
secret/kubernetes-dashboard-csrf created
secret/kubernetes-dashboard-key-holder created
configmap/kubernetes-dashboard-settings created
role.rbac.authorization.k8s.io/kubernetes-dashboard created
clusterrole.rbac.authorization.k8s.io/kubernetes-dashboard created
rolebinding.rbac.authorization.k8s.io/kubernetes-dashboard created
clusterrolebinding.rbac.authorization.k8s.io/kubernetes-dashboard created
deployment.apps/kubernetes-dashboard created
service/dashboard-metrics-scraper created
deployment.apps/dashboard-metrics-scraper created

# 查看 kubernetes-dashboard 下的资源
➜ kubectl -n kubernetes-dashboard get deploy

NAME                        READY   UP-TO-DATE   AVAILABLE   AGE
dashboard-metrics-scraper   1/1     1            1           5m26s
kubernetes-dashboard        1/1     1            1           5m28s

➜ kubectl -n kubernetes-dashboard get pod

NAME                                         READY   STATUS    RESTARTS   AGE
dashboard-metrics-scraper-5cb4f4bb9c-8qpbc   1/1     Running   0          6m22s
kubernetes-dashboard-6967859bff-fvhkv        1/1     Running   0          6m22s

➜ kubectl get svc -n kubernetes-dashboard

NAME                        TYPE        CLUSTER-IP    EXTERNAL-IP   PORT(S)         AGE
dashboard-metrics-scraper   ClusterIP   10.96.6.178           8000/TCP        6m37s
kubernetes-dashboard        NodePort    10.96.8.70            443:30443/TCP   6m41s

如果 kubernetes-dashboard 下的资源一直未就绪，请检查是否是正在拉取镜像或者镜像一直拉取失败。

例如：

➜ kubectl -n kubernetes-dashboard describe pod kubernetes-dashboard-546cbc58cd-hzvhr

...
Events:
  Type    Reason     Age    From               Message
  ----    ------     ----   ----               -------
  Normal  Scheduled  6m20s  default-scheduler  Successfully assigned kubernetes-dashboard/kubernetes-dashboard-546cbc58cd-hzvhr to worker1
  Normal  Pulling    6m20s  kubelet            Pulling image "kubernetesui/dashboard:v2.5.0"

➜ kubectl -n kubernetes-dashboard describe pod kubernetes-dashboard-546cbc58cd-hzvhr

Events:
  Type     Reason          Age                 From               Message
  ----     ------          ----                ----               -------
  Normal   Scheduled       10m                 default-scheduler  Successfully assigned kubernetes-dashboard/kubernetes-dashboard-546cbc58cd-hzvhr to worker1
  Warning  Failed          2m1s                kubelet            Failed to pull image "kubernetesui/dashboard:v2.5.0": rpc error: code = Unknown desc = dial tcp 104.18.124.25:443: i/o timeout
  Warning  Failed          2m1s                kubelet            Error: ErrImagePull
  Normal   SandboxChanged  2m                  kubelet            Pod sandbox changed, it will be killed and re-created.
  Normal   BackOff         118s (x3 over 2m)   kubelet            Back-off pulling image "kubernetesui/dashboard:v2.5.0"
  Warning  Failed          118s (x3 over 2m)   kubelet            Error: ImagePullBackOff
  Normal   Pulling         106s (x2 over 10m)  kubelet            Pulling image "kubernetesui/dashboard:v2.5.0"
  Normal   Pulled          25s                 kubelet            Successfully pulled image "kubernetesui/dashboard:v2.5.0" in 1m21.608630166s
  Normal   Created         22s                 kubelet            Created container kubernetes-dashboard
  Normal   Started         21s                 kubelet            Started container kubernetes-dashboard

创建 service account 并绑定默认 cluster-admin 管理员集群角色：

# 下面创建了一个叫 admin-user 的服务账号，放在 kubernetes-dashboard 命名空间下，并将 cluster-admin 角色绑定到 admin-user 账户，这样 admin-user 账户就有了管理员的权限。
# 默认情况下，kubeadm 创建集群时已经创建了 cluster-admin 角色，我们直接绑定即可。
➜ cat > dashboard-admin-user.yaml << EOF
apiVersion: v1
kind: ServiceAccount
metadata:
  name: admin-user
  namespace: kubernetes-dashboard

---
apiVersion: rbac.authorization.k8s.io/v1
kind: ClusterRoleBinding
metadata:
  name: admin-user
roleRef:
  apiGroup: rbac.authorization.k8s.io
  kind: ClusterRole
  name: cluster-admin
subjects:
  - kind: ServiceAccount
    name: admin-user
    namespace: kubernetes-dashboard

---
# https://github.com/kubernetes/kubernetes/issues/110113#issuecomment-1130412032
apiVersion: v1
kind: Secret
type: kubernetes.io/service-account-token
metadata:
  name: admin-user
  namespace: kubernetes-dashboard
  annotations:
    kubernetes.io/service-account.name: admin-user
EOF

# 应用资源配置清单
➜ kubectl apply -f dashboard-admin-user.yaml

serviceaccount/admin-user created
clusterrolebinding.rbac.authorization.k8s.io/admin-user created
secret/admin-user created

查看 admin-user 账户的 token：

➜ kubectl -n kubernetes-dashboard describe secret $(kubectl -n kubernetes-dashboard get secret | grep admin-user | awk '{print $1}')

Name:         admin-user
Namespace:    kubernetes-dashboard
Labels:       
Annotations:  kubernetes.io/service-account.name: admin-user
              kubernetes.io/service-account.uid: 630430bb-4ea5-4026-81ef-9d4c39089bca

Type:  kubernetes.io/service-account-token

Data
====
ca.crt:     1318 bytes
namespace:  20 bytes
token:      eyJhbGciOiJSUzI1NiIsImtpZCI6IlRpS0VJZ0pkRW5va3Bsb2lKOUxVRXVtM3l6RFNtaFNzUkFFLW1zcXBHS2sifQ.eyJpc3MiOiJrdWJlcm5ldGVzL3NlcnZpY2VhY2NvdW50Iiwia3ViZXJuZXRlcy5pby9zZXJ2aWNlYWNjb3VudC9uYW1lc3BhY2UiOiJrdWJlcm5ldGVzLWRhc2hib2FyZCIsImt1YmVybmV0ZXMuaW8vc2VydmljZWFjY291bnQvc2VjcmV0Lm5hbWUiOiJhZG1pbi11c2VyIiwia3ViZXJuZXRlcy5pby9zZXJ2aWNlYWNjb3VudC9zZXJ2aWNlLWFjY291bnQubmFtZSI6ImFkbWluLXVzZXIiLCJrdWJlcm5ldGVzLmlvL3NlcnZpY2VhY2NvdW50L3NlcnZpY2UtYWNjb3VudC51aWQiOiI2MzA0MzBiYi00ZWE1LTQwMjYtODFlZi05ZDRjMzkwODliY2EiLCJzdWIiOiJzeXN0ZW06c2VydmljZWFjY291bnQ6a3ViZXJuZXRlcy1kYXNoYm9hcmQ6YWRtaW4tdXNlciJ9.C-HqHea6OsWhQ9-yjPo0DGLhrgvtQ1cdaXOeGBOZqDKbPU4s-8VO31Ihw9Fbxo6vQnLJUyzFvRVB45eKr_95sJUht1lnD4pZOJHqnvSAa9SzkHbt4FcylHHG723wplLJc3fvnyKr1u3g74hHRUfLAE3q_VghMVwHi6hRyOalYN3KiFzQXKLVyovCxxAGwaEwJg9ftiawYMkDSzxLKkI17BBwrU_zt_xAKrLn229f9eEKsTeBMju0QMyhoWKCSVbV0chfw-sbJSUMAj7a8Ff5-uY1tru-QqUGI6RzlSKlI4E5hpsUVEFuU0HIHzrwxElTmNJnLZtcotFTLrsdHIXj2w

使用输出的 token 登录 Dashboard：

https://10.128.170.21:30443

16. 附录

16.1 coredns.yaml.sed

apiVersion: v1
kind: ServiceAccount
metadata:
  name: coredns
  namespace: kube-system
---
apiVersion: rbac.authorization.k8s.io/v1
kind: ClusterRole
metadata:
  labels:
    kubernetes.io/bootstrapping: rbac-defaults
  name: system:coredns
rules:
  - apiGroups:
    - ""
    resources:
    - endpoints
    - services
    - pods
    - namespaces
    verbs:
    - list
    - watch
  - apiGroups:
    - discovery.k8s.io
    resources:
    - endpointslices
    verbs:
    - list
    - watch
---
apiVersion: rbac.authorization.k8s.io/v1
kind: ClusterRoleBinding
metadata:
  annotations:
    rbac.authorization.kubernetes.io/autoupdate: "true"
  labels:
    kubernetes.io/bootstrapping: rbac-defaults
  name: system:coredns
roleRef:
  apiGroup: rbac.authorization.k8s.io
  kind: ClusterRole
  name: system:coredns
subjects:
- kind: ServiceAccount
  name: coredns
  namespace: kube-system
---
apiVersion: v1
kind: ConfigMap
metadata:
  name: coredns
  namespace: kube-system
data:
  Corefile: |
    .:53 {
        errors
        health {
          lameduck 5s
        }
        ready
        kubernetes CLUSTER_DOMAIN REVERSE_CIDRS {
          fallthrough in-addr.arpa ip6.arpa
        }
        prometheus :9153
        forward . UPSTREAMNAMESERVER {
          max_concurrent 1000
        }
        cache 30
        loop
        reload
        loadbalance
    }STUBDOMAINS
---
apiVersion: apps/v1
kind: Deployment
metadata:
  name: coredns
  namespace: kube-system
  labels:
    k8s-app: kube-dns
    kubernetes.io/name: "CoreDNS"
    app.kubernetes.io/name: coredns
spec:
  # replicas: not specified here:
  # 1. Default is 1.
  # 2. Will be tuned in real time if DNS horizontal auto-scaling is turned on.
  strategy:
    type: RollingUpdate
    rollingUpdate:
      maxUnavailable: 1
  selector:
    matchLabels:
      k8s-app: kube-dns
      app.kubernetes.io/name: coredns
  template:
    metadata:
      labels:
        k8s-app: kube-dns
        app.kubernetes.io/name: coredns
    spec:
      priorityClassName: system-cluster-critical
      serviceAccountName: coredns
      tolerations:
        - key: "CriticalAddonsOnly"
          operator: "Exists"
      nodeSelector:
        kubernetes.io/os: linux
      affinity:
         podAntiAffinity:
           requiredDuringSchedulingIgnoredDuringExecution:
           - labelSelector:
               matchExpressions:
               - key: k8s-app
                 operator: In
                 values: ["kube-dns"]
             topologyKey: kubernetes.io/hostname
      containers:
      - name: coredns
        image: coredns/coredns:1.9.4
        imagePullPolicy: IfNotPresent
        resources:
          limits:
            memory: 170Mi
          requests:
            cpu: 100m
            memory: 70Mi
        args: [ "-conf", "/etc/coredns/Corefile" ]
        volumeMounts:
        - name: config-volume
          mountPath: /etc/coredns
          readOnly: true
        ports:
        - containerPort: 53
          name: dns
          protocol: UDP
        - containerPort: 53
          name: dns-tcp
          protocol: TCP
        - containerPort: 9153
          name: metrics
          protocol: TCP
        securityContext:
          allowPrivilegeEscalation: false
          capabilities:
            add:
            - NET_BIND_SERVICE
            drop:
            - all
          readOnlyRootFilesystem: true
        livenessProbe:
          httpGet:
            path: /health
            port: 8080
            scheme: HTTP
          initialDelaySeconds: 60
          timeoutSeconds: 5
          successThreshold: 1
          failureThreshold: 5
        readinessProbe:
          httpGet:
            path: /ready
            port: 8181
            scheme: HTTP
      dnsPolicy: Default
      volumes:
        - name: config-volume
          configMap:
            name: coredns
            items:
            - key: Corefile
              path: Corefile
---
apiVersion: v1
kind: Service
metadata:
  name: kube-dns
  namespace: kube-system
  annotations:
    prometheus.io/port: "9153"
    prometheus.io/scrape: "true"
  labels:
    k8s-app: kube-dns
    kubernetes.io/cluster-service: "true"
    kubernetes.io/name: "CoreDNS"
    app.kubernetes.io/name: coredns
spec:
  selector:
    k8s-app: kube-dns
    app.kubernetes.io/name: coredns
  clusterIP: CLUSTER_DNS_IP
  ports:
  - name: dns
    port: 53
    protocol: UDP
  - name: dns-tcp
    port: 53
    protocol: TCP
  - name: metrics
    port: 9153
    protocol: TCP

16.2 helm 安装 coredns

https://github.com/coredns/helm

安装 helm：

➜ cd ~/Downloads
➜ curl -O https://mirrors.huaweicloud.com/helm/v3.12.2/helm-v3.12.2-linux-amd64.tar.gz
➜ tar -zxvf helm-v3.12.2-linux-amd64.tar.gz
➜ cp linux-amd64/helm /usr/local/bin

添加 chart 仓库：

1	➜ helm repo add coredns https://coredns.github.io/helm

查看可安装的版本：

➜ helm search repo -l

NAME            CHART VERSION   APP VERSION     DESCRIPTION
coredns/coredns 1.24.1          1.10.1          CoreDNS is a DNS server that chains plugins and...
coredns/coredns 1.24.0          1.10.1          CoreDNS is a DNS server that chains plugins and...
coredns/coredns 1.23.0          1.10.1          CoreDNS is a DNS server that chains plugins and...
coredns/coredns 1.22.0          1.10.1          CoreDNS is a DNS server that chains plugins and...
coredns/coredns 1.21.0          1.10.1          CoreDNS is a DNS server that chains plugins and...
coredns/coredns 1.20.2          1.9.4           CoreDNS is a DNS server that chains plugins and...
coredns/coredns 1.20.1          1.9.4           CoreDNS is a DNS server that chains plugins and...
coredns/coredns 1.20.0          1.9.4           CoreDNS is a DNS server that chains plugins and...
...

安装 coredns：

1	➜ helm --namespace=kube-system install coredns coredns/coredns

References

K8s 高可用集群架构（二进制）部署及应用

二进制部署 k8s 集群 1.23.1 版本

部署一套完整的企业级k8s集群

Rocky Linux 部署 etcd 集群

2023-08-03T16:00:50.000Z

本文介绍了在 Rocky Linux 系统上部署 etcd 集群的步骤。首先介绍了环境准备，包括三个节点的操作系统、IP地址和版本等信息。接下来，安装必要软件，包括 etcd、证书工具 cfssl 等，并创建 etcd 所需的证书。然后配置 etcd，包括主节点和启动配置，以及其余节点的配置。启动 etcd 服务并验证其状态，包括检查集群健康状态、查看集群节点列表、验证集群数据存储服务和监测数据变化等。此外，还介绍了数据备份与恢复、节点宕机与恢复、ETCD 故障节点修复和身份验证等内容。最后，介绍了如何安装 etcdkeeper。

Rocky Linux 部署 etcd 集群

1. 环境准备

主机名	操作系统	IP地址	版本
node1	Rocky Linux release 8.6 (Green Obsidian)	10.128.170.131	etcd-v3.5.6
node2	Rocky Linux release 8.6 (Green Obsidian)	10.128.170.132	etcd-v3.5.6
node3	Rocky Linux release 8.6 (Green Obsidian)	10.128.170.133	etcd-v3.5.6

/etc/hosts 配置

1
2
3

10.128.170.131 node1 node1.local
10.128.170.132 node2 node2.local
10.128.170.133 node3 node3.local

2. 安装必要软件

以下必要软件安装操作需要在全部节点执行。

etcd 集群部署过程中需要用到以下组件：

cfssl
cfssljson
cfssl_certinfo
etcd
etcdctl

2.1. 创建数据目录

1	mkdir -p /data/etcd/{default,cfg,ssl}

default 存放 etcd 数据
cfg 存放 etcd 配置文件
ssl 存放证书、私钥

2.2. 下载安装 etcd

到 https://github.com/etcd-io/etcd/releases/tag/v3.5.6 下载以下文件：

etcd-v3.5.6-linux-amd64.tar.gz

解压安装：

1	tar -zxvf etcd-v3.5.6-linux-amd64.tar.gz -C /opt

创建 bin 目录，并将可执行程序移动到 bin 目录下：

1
2
3

cd /opt/etcd-v3.5.6-linux-amd64
mkdir bin
mv etcd etcdctl etcdutl bin

2.3. 下载安装证书工具 cfssl

到 https://github.com/cloudflare/cfssl/releases/tag/v1.6.3 下载以下文件：

cfssl_1.6.3_linux_amd64
cfssljson_1.6.3_linux_amd64
cfssl-certinfo_1.6.3_linux_amd64

下载证书工具 cfssl 后，移动到 /opt/etcd-v3.5.6-linux-amd64/bin 目录下，并授予可执行权限：

chmod +x cfssl_1.6.3_linux_amd64
cp cfssl_1.6.3_linux_amd64 /opt/etcd-v3.5.6-linux-amd64/bin/cfssl

chmod +x cfssljson_1.6.3_linux_amd64
cp cfssljson_1.6.3_linux_amd64 /opt/etcd-v3.5.6-linux-amd64/bin/cfssljson

chmod +x cfssl-certinfo_1.6.3_linux_amd64
cp cfssl-certinfo_1.6.3_linux_amd64 /opt/etcd-v3.5.6-linux-amd64/bin/cfssl-certinfo

方便起见，以上工具分别重命名为：

cfssl
cfssljson
cfssl-certinfo

2.4. 配置环境变量

1	vim ~/.bashrc

添加如下内容：

# Etcd Environment
export ETCD_HOME=/opt/etcd-v3.5.6-linux-amd64

export PATH=$PATH:$ETCD_HOME/bin

使配置立即生效：

1	source ~/.bashrc

3. 创建 TLS 证书

以下创建 TLS 证书操作在任意一个节点执行即可。

3.1. 新建 CA 签名请求文件

创建 CA 签名请求文件 ca-csr.json，存放在 /data/etcd/ssl 中，文件内容如下：

cat > /data/etcd/ssl/ca-csr.json << EOF
{
    "CN": "etcd",
    "key": {
        "algo": "rsa",
        "size": 2048
    },
    "names": [
        {
            "C": "CN",
            "L": "Shenzhen",
            "ST": "GuangDong"
        }
    ]
}
EOF

术语介绍：

C: Country， 国家
L: Locality，地区，城市
O: Organization Name，组织名称，公司名称
OU: Organization Unit Name，组织单位名称，公司部门
ST: State，州，省

3.2. 生成 CA 凭证、私钥和证书签名请求

在 /data/etcd/ssl 目录下执行：

1	cfssl gencert -initca ca-csr.json \| cfssljson -bare ca

生成以下三个文件：

ca-key.pem（CA 私钥）
ca.pem（CA 证书）
ca.csr（CA 证书签名请求）

3.3. CA 配置

创建 CA 配置文件 ca-config.json，存放在 /data/etcd/ssl 中，文件内容如下：

cat > /data/etcd/ssl/ca-config.json << EOF
{
    "signing": {
        "default": {
            "expiry": "87600h"
        },
        "profiles": {
            "etcd": {
                "expiry": "87600h",
                "usages": [
                    "signing",
                    "key encipherment",
                    "server auth",
                    "client auth"
                ]
            }
        }
    }
}
EOF

术语介绍：

profiles：可以设置多个 profile，这里的 profile 是 etcd
expiry：指定了证书的有效期是 10 年(87600h)
signing：表示该证书可用于签名其它证书，生成的 ca.pem 证书中 CA=TRUE
server auth：表示 client 可以用该 CA 对 server 提供的证书进行验证
client auth：表示 server 可以用该 CA 对 client 提供的证书进行验证

3.4. 新建 etcd 证书请求文件

新建 etcd 证书请求文件 server-csr.json，存放在 /data/etcd/ssl 中，文件内容如下：

cat > /data/etcd/ssl/server-csr.json << EOF
{
    "CN": "server",
    "hosts": [
        "127.0.0.1",
        "10.128.170.131",
        "10.128.170.132",
        "10.128.170.133",
        "node1",
        "node2",
        "node3",
        "node1.local",
        "node2.local",
        "node3.local"
    ],
    "key": {
        "algo": "rsa",
        "size": 2048
    },
    "names": [
        {
            "C": "CN",
            "L": "Shenzhen",
            "ST": "GuangDong"
        }
    ]
}
EOF

hosts 字段指定授权使用该证书的 etcd 节点 IP 或域名列表，需要将 etcd 集群的三个节点 IP 都列在其中。

3.5. 生成 server 证书

在 /data/etcd/ssl 目录下执行：

1	cfssl gencert -ca=ca.pem -ca-key=ca-key.pem -config=ca-config.json -profile=etcd server-csr.json \| cfssljson -bare server

生成以下三个文件：

server-key.pem（server 私钥）
server.pem（server 证书）
server.csr（server 证书签名请求）

3.6. 拷贝证书到其它节点

根据需要拷贝 /data/etcd/ssl 目录下的证书文件到其他节点：

1
2
3

cd /data/etcd/ssl
scp ca.pem server.pem server-key.pem root@node2:/data/etcd/ssl
scp ca.pem server.pem server-key.pem root@node3:/data/etcd/ssl

4. etcd 配置

4.1. etcd 主节点配置

创建 etcd 主节点配置文件 etcd.conf，存放在 /data/etcd/cfg 中，文件内容如下：

cat > /data/etcd/cfg/etcd.conf << "EOF"
#[Member]
ETCD_NAME="etcd01"
ETCD_DATA_DIR="/data/etcd/default"
ETCD_LISTEN_PEER_URLS="https://10.128.170.131:2380"
ETCD_LISTEN_CLIENT_URLS="https://10.128.170.131:2379,https://127.0.0.1:2379"

#[Clustering]
ETCD_INITIAL_ADVERTISE_PEER_URLS="https://10.128.170.131:2380"
ETCD_ADVERTISE_CLIENT_URLS="https://10.128.170.131:2379"
ETCD_INITIAL_CLUSTER="etcd01=https://10.128.170.131:2380,etcd02=https://10.128.170.132:2380,etcd03=https://10.128.170.133:2380"
ETCD_INITIAL_CLUSTER_TOKEN="etcd-cluster"
ETCD_INITIAL_CLUSTER_STATE="new"

#[Security]
ETCD_CERT_FILE="/data/etcd/ssl/server.pem"
ETCD_KEY_FILE="/data/etcd/ssl/server-key.pem"
ETCD_TRUSTED_CA_FILE="/data/etcd/ssl/ca.pem"
ETCD_CLIENT_CERT_AUTH="false"
ETCD_PEER_CERT_FILE="/data/etcd/ssl/server.pem"
ETCD_PEER_KEY_FILE="/data/etcd/ssl/server-key.pem"
ETCD_PEER_TRUSTED_CA_FILE="/data/etcd/ssl/ca.pem"
ETCD_PEER_CLIENT_CERT_AUTH="true"
EOF

4.2. etcd 启动配置

创建 etcd 启动配置文件 etcd.service，存放在 /usr/lib/systemd/system 目录下，文件内容如下：

cat > /usr/lib/systemd/system/etcd.service << "EOF"
[Unit]
Description=Etcd Server
After=network.target
After=network-online.target
Wants=network-online.target

[Service]
Type=notify
EnvironmentFile=/data/etcd/cfg/etcd.conf
ExecStart=/opt/etcd-v3.5.6-linux-amd64/bin/etcd
#ExecStart=/opt/etcd-v3.5.6-linux-amd64/bin/etcd \
#--name=${ETCD_NAME} \
#--data-dir=${ETCD_DATA_DIR} \
#--listen-peer-urls=${ETCD_LISTEN_PEER_URLS} \
#--listen-client-urls=${ETCD_LISTEN_CLIENT_URLS} \
#--advertise-client-urls=${ETCD_ADVERTISE_CLIENT_URLS} \
#--initial-advertise-peer-urls=${ETCD_INITIAL_ADVERTISE_PEER_URLS} \
#--initial-cluster=${ETCD_INITIAL_CLUSTER} \
#--initial-cluster-token=${ETCD_INITIAL_CLUSTER_TOKEN} \
#--initial-cluster-state=${ETCD_INITIAL_CLUSTER_STATE} \
#--cert-file=${ETCD_CERT_FILE} \
#--key-file=${ETCD_KEY_FILE} \
#--peer-cert-file=${ETCD_PEER_CERT_FILE} \
#--peer-key-file=${ETCD_PEER_KEY_FILE} \
#--trusted-ca-file=${ETCD_TRUSTED_CA_FILE} \
#--client-cert-auth=${ETCD_CLIENT_CERT_AUTH} \
#--peer-client-cert-auth=${ETCD_PEER_CLIENT_CERT_AUTH} \
#--peer-trusted-ca-file=${ETCD_PEER_TRUSTED_CA_FILE}
Restart=on-failure
LimitNOFILE=65536

[Install]
WantedBy=multi-user.target
EOF

字段解释：

--WorkingDirectory、--data-dir：指定工作目录和数据目录为 ${ETCD_DATA_DIR}，需在启动服务前创建这个目录；
--wal-dir：指定 wal 目录，为了提高性能，一般使用 SSD 或者和 --data-dir 不同的磁盘；
--name：指定节点名称，当 --initial-cluster-state 值为 new 时，--name 的参数值必须位于 --initial-cluster 列表中；
--cert-file、--key-file：etcd server 与 client 通信时使用的证书和私钥；
--trusted-ca-file：签名 client 证书的 CA 证书，用于验证 client 证书；
--peer-cert-file、--peer-key-file：etcd 与 peer 通信使用的证书和私钥；
--peer-trusted-ca-file：签名 peer 证书的 CA 证书，用于验证 peer 证书；

启动异常：conflicting environment variable "ETCD_NAME" is shadowed by corresponding command-line flag (either unset environment variable or disable flag)
原因分析：ETCD3.4 版本会自动读取环境变量的参数，所以 EnvironmentFile 文件中有的参数，不需要再次在 ExecStart 启动参数中添加，二选一，如同时配置，会触发以上报错。
解决方法：剔除 ExecStart 中和配置文件重复的内容即可。

5. 配置其余节点

同样操作配置其余节点，但需要修改 etcd.conf 文件中的节点名字以及服务器 IP 地址。

6. 启动 etcd 服务

1 2	systemctl daemon-reload systemctl start etcd.service

7. 验证 etcd 服务

在此之前，我们需要设置 etcd 的 API 版本，目前有 v2 与 v3 两个版本，两个版本的 API 存储方式不同，命令工具也不同。我们统一约定使用 v3 版本（默认是 v2 版本），把 v3 加入环境变量中：

1 2	echo 'export ETCDCTL_API=3' >> ~/.bashrc source ~/.bashrc

7.1. 检查集群健康状态

/opt/etcd-v3.5.6-linux-amd64/bin/etcdctl --cacert=/data/etcd/ssl/ca.pem --cert=/data/etcd/ssl/server.pem --key=/data/etcd/ssl/server-key.pem --endpoints="https://node1.local:2379,https://node2.local:2379,https://node3.local:2379" endpoint health

集群健康则显示：

1
2
3

https://node3.local:2379 is healthy: successfully committed proposal: took = 23.967506ms
https://node1.local:2379 is healthy: successfully committed proposal: took = 36.438089ms
https://node2.local:2379 is healthy: successfully committed proposal: took = 36.013216ms

7.2. 查看集群节点列表

true 代表 leader，由其负责处理客户端请求信息

/opt/etcd-v3.5.6-linux-amd64/bin/etcdctl --cacert=/data/etcd/ssl/ca.pem --cert=/data/etcd/ssl/server.pem --key=/data/etcd/ssl/server-key.pem --endpoints="https://node1.local:2379,https://node2.local:2379,https://node3.local:2379" endpoint status

服务正常则显示：

1
2
3

https://node1.local:2379, 2cc5cd20ac23bb53, 3.5.6, 20 kB, true, false, 2, 11, 11,
https://node2.local:2379, 60084d96d6d6e98a, 3.5.6, 20 kB, false, false, 2, 11, 11,
https://node3.local:2379, 57107ffa28aa353e, 3.5.6, 20 kB, false, false, 2, 11, 11,

7.3. 验证集群数据存储服务

任选一个节点，客户端 etcdctl 存储一个数据，其他节点查看数据：

etcd01 客户端存储数据:

1
2

[root@node1 ~]# /opt/etcd-v3.5.6-linux-amd64/bin/etcdctl --cacert=/data/etcd/ssl/ca.pem --cert=/data/etcd/ssl/server.pem --key=/data/etcd/ssl/server-key.pem --endpoints="https://node1.local:2379,https://node2.local:2379,https://node3.local:2379" put /hello "world"
OK

etcd02 或 etcd03 查看数据：

1
2
3

[root@node3 ~]# /opt/etcd-v3.5.6-linux-amd64/bin/etcdctl --cacert=/data/etcd/ssl/ca.pem --cert=/data/etcd/ssl/server.pem --key=/data/etcd/ssl/server-key.pem --endpoints="https://node1.local:2379,https://node2.local:2379,https://node3.local:2379" get /hello
/hello
world

7.4. 监测数据变化

使用 watch 命令后，如果一切正常则会进入阻塞，监测一个键值的变化，一旦键值发生更新，就会输出最新的值，直到用户按 CTRL+C 退出。

在 10.128.170.133 上一直监控：

[root@node3 ~]# /opt/etcd-v3.5.6-linux-amd64/bin/etcdctl --cacert=/data/etcd/ssl/ca.pem --cert=/data/etcd/ssl/server.pem --key=/data/etcd/ssl/server-key.pem --endpoints="https://node1.local:2379,https://node2.local:2379,https://node3.local:2379" watch /name

在10.128.170.132 上修改两次 /name 的值：

[root@node2 ~]# /opt/etcd-v3.5.6-linux-amd64/bin/etcdctl --cacert=/data/etcd/ssl/ca.pem --cert=/data/etcd/ssl/server.pem --key=/data/etcd/ssl/server-key.pem --endpoints="https://node1.local:2379,https://node2.local:2379,https://node3.local:2379" put /name "first"
OK
[root@node2 ~]# /opt/etcd-v3.5.6-linux-amd64/bin/etcdctl --cacert=/data/etcd/ssl/ca.pem --cert=/data/etcd/ssl/server.pem --key=/data/etcd/ssl/server-key.pem --endpoints="https://node1.local:2379,https://node2.local:2379,https://node3.local:2379" put /name "second"
OK

10.128.170.133 监控界面便打印出修改记录：

[root@node3 ~]# /opt/etcd-v3.5.6-linux-amd64/bin/etcdctl --cacert=/data/etcd/ssl/ca.pem --cert=/data/etcd/ssl/server.pem --key=/data/etcd/ssl/server-key.pem --endpoints="https://node1.local:2379,https://node2.local:2379,https://node3.local:2379" watch /name
PUT
/name
first
PUT
/name
second

8. 数据备份与恢复

8.1. 数据备份

[root@node1 ~]# /opt/etcd-v3.5.6-linux-amd64/bin/etcdctl --cacert=/data/etcd/ssl/ca.pem --cert=/data/etcd/ssl/server.pem --key=/data/etcd/ssl/server-key.pem --endpoints="https://node1.local:2379" snapshot save mysnapshot.db
{"level":"info","ts":"2023-01-06T01:01:59.039+0800","caller":"snapshot/v3_snapshot.go:65","msg":"created temporary db file","path":"mysnapshot.db.part"}
{"level":"info","ts":"2023-01-06T01:01:59.053+0800","logger":"client","caller":"v3@v3.5.6/maintenance.go:212","msg":"opened snapshot stream; downloading"}
{"level":"info","ts":"2023-01-06T01:01:59.053+0800","caller":"snapshot/v3_snapshot.go:73","msg":"fetching snapshot","endpoint":"https://node1.local:2379"}
{"level":"info","ts":"2023-01-06T01:01:59.082+0800","logger":"client","caller":"v3@v3.5.6/maintenance.go:220","msg":"completed snapshot read; closing"}
{"level":"info","ts":"2023-01-06T01:01:59.146+0800","caller":"snapshot/v3_snapshot.go:88","msg":"fetched snapshot","endpoint":"https://node1.local:2379","size":"20 kB","took":"now"}
{"level":"info","ts":"2023-01-06T01:01:59.146+0800","caller":"snapshot/v3_snapshot.go:97","msg":"saved","path":"mysnapshot.db"}
Snapshot saved at mysnapshot.db

8.2. 数据恢复

https://etcd.io/docs/v3.5/op-guide/recovery/

9. 节点宕机与恢复

9.1. 查看集群各节点状态

[root@node1 ~]# /opt/etcd-v3.5.6-linux-amd64/bin/etcdctl --cacert=/data/etcd/ssl/ca.pem --cert=/data/etcd/ssl/server.pem --key=/data/etcd/ssl/server-key.pem --endpoints="https://node1.local:2379,https://node2.local:2379,https://node3.local:2379" endpoint status --write-out=table
+--------------------------+------------------+---------+---------+-----------+------------+-----------+------------+--------------------+--------+
|         ENDPOINT         |        ID        | VERSION | DB SIZE | IS LEADER | IS LEARNER | RAFT TERM | RAFT INDEX | RAFT APPLIED INDEX | ERRORS |
+--------------------------+------------------+---------+---------+-----------+------------+-----------+------------+--------------------+--------+
| https://node1.local:2379 | 2cc5cd20ac23bb53 |   3.5.6 |   20 kB |      true |      false |         2 |         14 |                 14 |        |
| https://node2.local:2379 | 60084d96d6d6e98a |   3.5.6 |   20 kB |     false |      false |         2 |         14 |                 14 |        |
| https://node3.local:2379 | 57107ffa28aa353e |   3.5.6 |   20 kB |     false |      false |         2 |         14 |                 14 |        |
+--------------------------+------------------+---------+---------+-----------+------------+-----------+------------+--------------------+--------+

9.2. 模拟主节点 node1 宕机

使用命令 systemctl stop etcd 停掉 leader 节点，再次查看集群状况，可见重新选举出了 leader，集群可正常使用：

[root@node1 ~]# systemctl stop etcd.service
[root@node1 ~]# /opt/etcd-v3.5.6-linux-amd64/bin/etcdctl --cacert=/data/etcd/ssl/ca.pem --cert=/data/etcd/ssl/server.pem --key=/data/etcd/ssl/server-key.pem --endpoints="https://node1.local:2379,https://node2.local:2379,https://node3.local:2379" endpoint status --write-out=table
{"level":"warn","ts":"2023-01-06T12:39:07.738+0800","logger":"etcd-client","caller":"v3@v3.5.6/retry_interceptor.go:62","msg":"retrying of unary invoker failed","target":"etcd-endpoints://0xc0000b8c40/node1.local:2379","attempt":0,"error":"rpc error: code = DeadlineExceeded desc = latest balancer error: last connection error: connection error: desc = \"transport: Error while dialing dial tcp 10.128.170.131:2379: connect: connection refused\""}
Failed to get the status of endpoint https://node1.local:2379 (context deadline exceeded)
+--------------------------+------------------+---------+---------+-----------+------------+-----------+------------+--------------------+--------+
|         ENDPOINT         |        ID        | VERSION | DB SIZE | IS LEADER | IS LEARNER | RAFT TERM | RAFT INDEX | RAFT APPLIED INDEX | ERRORS |
+--------------------------+------------------+---------+---------+-----------+------------+-----------+------------+--------------------+--------+
| https://node2.local:2379 | 60084d96d6d6e98a |   3.5.6 |   20 kB |      true |      false |         3 |         15 |                 15 |        |
| https://node3.local:2379 | 57107ffa28aa353e |   3.5.6 |   20 kB |     false |      false |         3 |         15 |                 15 |        |
+--------------------------+------------------+---------+---------+-----------+------------+-----------+------------+--------------------+--------+

9.3. 模拟从节点 node2 宕机

继续使用命令 systemctl stop etcd 停掉节点 node2，查看集群状况，集群已经无法正常使用，说明 3 节点的 etcd 集群容错为 1。根据官方说明，集群可用性为 (N-1)/2，假设集群数量 N 是 3 台设备，可最多可故障 1 台设备，而不影响集群使用。

[root@node2 ~]# systemctl stop etcd.service
[root@node2 ~]# /opt/etcd-v3.5.6-linux-amd64/bin/etcdctl --cacert=/data/etcd/ssl/ca.pem --cert=/data/etcd/ssl/server.pem --key=/data/etcd/ssl/server-key.pem --endpoints="https://node1.local:2379,https://node2.local:2379,https://node3.local:2379" endpoint status --write-out=table
{"level":"warn","ts":"2023-01-06T12:39:58.307+0800","logger":"etcd-client","caller":"v3@v3.5.6/retry_interceptor.go:62","msg":"retrying of unary invoker failed","target":"etcd-endpoints://0xc00035aa80/node1.local:2379","attempt":0,"error":"rpc error: code = DeadlineExceeded desc = latest balancer error: last connection error: connection error: desc = \"transport: Error while dialing dial tcp 10.128.170.131:2379: connect: connection refused\""}
Failed to get the status of endpoint https://node1.local:2379 (context deadline exceeded)
{"level":"warn","ts":"2023-01-06T12:40:03.308+0800","logger":"etcd-client","caller":"v3@v3.5.6/retry_interceptor.go:62","msg":"retrying of unary invoker failed","target":"etcd-endpoints://0xc00035aa80/node1.local:2379","attempt":0,"error":"rpc error: code = DeadlineExceeded desc = latest balancer error: last connection error: connection error: desc = \"transport: Error while dialing dial tcp 10.128.170.132:2379: connect: connection refused\""}
Failed to get the status of endpoint https://node2.local:2379 (context deadline exceeded)
+--------------------------+------------------+---------+---------+-----------+------------+-----------+------------+--------------------+-----------------------+
|         ENDPOINT         |        ID        | VERSION | DB SIZE | IS LEADER | IS LEARNER | RAFT TERM | RAFT INDEX | RAFT APPLIED INDEX |        ERRORS         |
+--------------------------+------------------+---------+---------+-----------+------------+-----------+------------+--------------------+-----------------------+
| https://node3.local:2379 | 57107ffa28aa353e |   3.5.6 |   20 kB |     false |      false |         4 |         16 |                 16 | etcdserver: no leader |
+--------------------------+------------------+---------+---------+-----------+------------+-----------+------------+--------------------+-----------------------+

9.4. 模拟 node2 节点恢复

使用命令 systemctl start etcd.service 启动节点 node2，查看集群状况，可见重新选举出 leader 节点，集群恢复正常使用：

[root@node2 ~]# systemctl start etcd.service
[root@node2 ~]# /opt/etcd-v3.5.6-linux-amd64/bin/etcdctl --cacert=/data/etcd/ssl/ca.pem --cert=/data/etcd/ssl/server.pem --key=/data/etcd/ssl/server-key.pem --endpoints="https://node1.local:2379,https://node2.local:2379,https://node3.local:2379" endpoint status --write-out=table
{"level":"warn","ts":"2023-01-06T12:41:13.714+0800","logger":"etcd-client","caller":"v3@v3.5.6/retry_interceptor.go:62","msg":"retrying of unary invoker failed","target":"etcd-endpoints://0xc000332c40/node1.local:2379","attempt":0,"error":"rpc error: code = DeadlineExceeded desc = latest balancer error: last connection error: connection error: desc = \"transport: Error while dialing dial tcp 10.128.170.131:2379: connect: connection refused\""}
Failed to get the status of endpoint https://node1.local:2379 (context deadline exceeded)
+--------------------------+------------------+---------+---------+-----------+------------+-----------+------------+--------------------+--------+
|         ENDPOINT         |        ID        | VERSION | DB SIZE | IS LEADER | IS LEARNER | RAFT TERM | RAFT INDEX | RAFT APPLIED INDEX | ERRORS |
+--------------------------+------------------+---------+---------+-----------+------------+-----------+------------+--------------------+--------+
| https://node2.local:2379 | 60084d96d6d6e98a |   3.5.6 |   20 kB |     false |      false |         5 |         18 |                 18 |        |
| https://node3.local:2379 | 57107ffa28aa353e |   3.5.6 |   20 kB |      true |      false |         5 |         18 |                 18 |        |
+--------------------------+------------------+---------+---------+-----------+------------+-----------+------------+--------------------+--------+

10. ETCD 故障节点修复

10.1. 从集群中删除故障节点

（正常节点上操作）

查看集群，获取坏掉节点的 ID，比如为 2cc5cd20ac23bb53

[root@node3 ~]# /opt/etcd-v3.5.6-linux-amd64/bin/etcdctl --cacert=/data/etcd/ssl/ca.pem --cert=/data/etcd/ssl/server.pem --key=/data/etcd/ssl/server-key.pem --endpoints="https://node1.local:2379,https://node2.local:2379,https://node3.local:2379" member list
2cc5cd20ac23bb53, started, etcd01, https://10.128.170.131:2380, https://10.128.170.131:2379, false
57107ffa28aa353e, started, etcd03, https://10.128.170.133:2380, https://10.128.170.133:2379, false
60084d96d6d6e98a, started, etcd02, https://10.128.170.132:2380, https://10.128.170.132:2379, false

删除坏掉的节点

1
2

[root@node3 ~]# /opt/etcd-v3.5.6-linux-amd64/bin/etcdctl --cacert=/data/etcd/ssl/ca.pem --cert=/data/etcd/ssl/server.pem --key=/data/etcd/ssl/server-key.pem --endpoints="https://node1.local:2379,https://node2.local:2379,https://node3.local:2379" member remove 2cc5cd20ac23bb53
Member 2cc5cd20ac23bb53 removed from cluster 6fe4c34617a995fa

10.2. 修复故障节点

（故障节点上操作）

修改配置文件

把 ETCD_INITIAL_CLUSTER_STATE="new" 修改为 ETCD_INITIAL_CLUSTER_STATE="existing"

1	[root@node1 ~]# sed -i 's/ETCD_INITIAL_CLUSTER_STATE="new"/ETCD_INITIAL_CLUSTER_STATE="existing"/' /data/etcd/cfg/etcd.conf

清理节点数据

1	[root@node1 ~]# rm -rf /data/etcd/default/member/

10.3. 重新添加节点

（正常节点上操作）

[root@node3 ~]# /opt/etcd-v3.5.6-linux-amd64/bin/etcdctl --cacert=/data/etcd/ssl/ca.pem --cert=/data/etcd/ssl/server.pem --key=/data/etcd/ssl/server-key.pem --endpoints="https://node1.local:2379,https://node2.local:2379,https://node3.local:2379" member add etcd01 --peer-urls=https://10.128.170.131:2380
Member cda884b84bce7043 added to cluster 6fe4c34617a995fa

ETCD_NAME="etcd01"
ETCD_INITIAL_CLUSTER="etcd03=https://10.128.170.133:2380,etcd02=https://10.128.170.132:2380,etcd01=https://10.128.170.131:2380"
ETCD_INITIAL_ADVERTISE_PEER_URLS="https://10.128.170.131:2380"
ETCD_INITIAL_CLUSTER_STATE="existing"

10.4. 重启故障节点

（故障节点上操作）

1	[root@node1 ~]# systemctl start etcd.service

11. 身份验证

11.1. 创建 root 用户

先创建 root 用户，提示输入密码，这里我密码设置为 cluster

[root@node1 ~]# /opt/etcd-v3.5.6-linux-amd64/bin/etcdctl --cacert=/data/etcd/ssl/ca.pem --cert=/data/etcd/ssl/server.pem --key=/data/etcd/ssl/server-key.pem --endpoints="https://node1.local:2379,https://node2.local:2379,https://node3.local:2379" user add root
Password of root:
Type password of root again for confirmation:
User root created

赋予 root 用户 root 角色

1
2

[root@node1 ~]# /opt/etcd-v3.5.6-linux-amd64/bin/etcdctl --cacert=/data/etcd/ssl/ca.pem --cert=/data/etcd/ssl/server.pem --key=/data/etcd/ssl/server-key.pem --endpoints="https://node1.local:2379,https://node2.local:2379,https://node3.local:2379" user grant-role root root
Role root is granted to user root

11.2. 查看 root 用户详情

1
2
3

[root@node1 ~]# /opt/etcd-v3.5.6-linux-amd64/bin/etcdctl --cacert=/data/etcd/ssl/ca.pem --cert=/data/etcd/ssl/server.pem --key=/data/etcd/ssl/server-key.pem --endpoints="https://node1.local:2379,https://node2.local:2379,https://node3.local:2379" user get root
User: root
Roles: root

确定 root 用户具有 root 角色拥有所有权限后再进行下一步

11.3. 开启身份验证

1
2

[root@node1 ~]# /opt/etcd-v3.5.6-linux-amd64/bin/etcdctl --cacert=/data/etcd/ssl/ca.pem --cert=/data/etcd/ssl/server.pem --key=/data/etcd/ssl/server-key.pem --endpoints="https://node1.local:2379,https://node2.local:2379,https://node3.local:2379" auth enable
Authentication Enabled

11.4. 创建新用户

创建新用户 server，密码同样设为 cluster（可任意设置）

[root@node1 ~]# /opt/etcd-v3.5.6-linux-amd64/bin/etcdctl --cacert=/data/etcd/ssl/ca.pem --cert=/data/etcd/ssl/server.pem --key=/data/etcd/ssl/server-key.pem --endpoints="https://node1.local:2379,https://node2.local:2379,https://node3.local:2379" --user=root:cluster user add server
Password of server:
Type password of server again for confirmation:
User server created

查看用户列表和 server 用户详情

[root@node1 ~]# /opt/etcd-v3.5.6-linux-amd64/bin/etcdctl --cacert=/data/etcd/ssl/ca.pem --cert=/data/etcd/ssl/server.pem --key=/data/etcd/ssl/server-key.pem --endpoints="https://node1.local:2379,https://node2.local:2379,https://node3.local:2379" --user=root:cluster user list
root
server
[root@node1 ~]# /opt/etcd-v3.5.6-linux-amd64/bin/etcdctl --cacert=/data/etcd/ssl/ca.pem --cert=/data/etcd/ssl/server.pem --key=/data/etcd/ssl/server-key.pem --endpoints="https://node1.local:2379,https://node2.local:2379,https://node3.local:2379" --user=root:cluster user get server
User: server
Roles:

11.5. 创建角色

（内置的 root 角色无法通过 role list 查看，我们可以创建名字同样为 root 的角色，但是后续为 user 赋予 root 角色时，将使用自定义的 root 角色，而不是内置的 root 角色）

创建 server 角色

1
2

[root@node1 ~]# /opt/etcd-v3.5.6-linux-amd64/bin/etcdctl --cacert=/data/etcd/ssl/ca.pem --cert=/data/etcd/ssl/server.pem --key=/data/etcd/ssl/server-key.pem --endpoints="https://node1.local:2379,https://node2.local:2379,https://node3.local:2379" --user=root:cluster role add server
Role server created

查看角色列表和 server 角色详情（新创建的角色没有任何权限）

[root@node1 ~]# /opt/etcd-v3.5.6-linux-amd64/bin/etcdctl --cacert=/data/etcd/ssl/ca.pem --cert=/data/etcd/ssl/server.pem --key=/data/etcd/ssl/server-key.pem --endpoints="https://node1.local:2379,https://node2.local:2379,https://node3.local:2379" --user=root:cluster role list
server
[root@node1 ~]# /opt/etcd-v3.5.6-linux-amd64/bin/etcdctl --cacert=/data/etcd/ssl/ca.pem --cert=/data/etcd/ssl/server.pem --key=/data/etcd/ssl/server-key.pem --endpoints="https://node1.local:2379,https://node2.local:2379,https://node3.local:2379" --user=root:cluster role get server
Role server
KV Read:
KV Write:

11.6. 角色授权

角色没有密码，仅仅是定义的一组访问权限，角色的访问权限可以被赋予 read（读），write（写），readwrite（读和写）权限。

给 server 角色赋予键 /hello 读写操作权限

1
2

[root@node1 ~]# /opt/etcd-v3.5.6-linux-amd64/bin/etcdctl --cacert=/data/etcd/ssl/ca.pem --cert=/data/etcd/ssl/server.pem --key=/data/etcd/ssl/server-key.pem --endpoints="https://node1.local:2379,https://node2.local:2379,https://node3.local:2379" --user=root:cluster role grant-permission server readwrite /hello --prefix=true
Role server updated

[root@node1 ~]# /opt/etcd-v3.5.6-linux-amd64/bin/etcdctl --cacert=/data/etcd/ssl/ca.pem --cert=/data/etcd/ssl/server.pem --key=/data/etcd/ssl/server-key.pem --endpoints="https://node1.local:2379,https://node2.local:2379,https://node3.local:2379" --user=root:cluster role get server
Role server
KV Read:
        [/hello, /hellp) (prefix /hello)
KV Write:
        [/hello, /hellp) (prefix /hello)

给 server 角色赋予键 /hello 目录读写操作权限

1
2

[root@node1 ~]# /opt/etcd-v3.5.6-linux-amd64/bin/etcdctl --cacert=/data/etcd/ssl/ca.pem --cert=/data/etcd/ssl/server.pem --key=/data/etcd/ssl/server-key.pem --endpoints="https://node1.local:2379,https://node2.local:2379,https://node3.local:2379" --user=root:cluster role grant-permission server readwrite /hello/* --prefix=true
Role server updated

[root@node1 ~]# /opt/etcd-v3.5.6-linux-amd64/bin/etcdctl --cacert=/data/etcd/ssl/ca.pem --cert=/data/etcd/ssl/server.pem --key=/data/etcd/ssl/server-key.pem --endpoints="https://node1.local:2379,https://node2.local:2379,https://node3.local:2379" --user=root:cluster role get server
Role server
KV Read:
        [/hello, /hellp) (prefix /hello)
        [/hello/*, /hello/+) (prefix /hello/*)
KV Write:
        [/hello, /hellp) (prefix /hello)
        [/hello/*, /hello/+) (prefix /hello/*)

11.7. 赋予用户角色

赋予 server 用户 server 角色

1
2

[root@node1 ~]# /opt/etcd-v3.5.6-linux-amd64/bin/etcdctl --cacert=/data/etcd/ssl/ca.pem --cert=/data/etcd/ssl/server.pem --key=/data/etcd/ssl/server-key.pem --endpoints="https://node1.local:2379,https://node2.local:2379,https://node3.local:2379" --user=root:cluster user grant-role server server
Role server is granted to user server

1
2
3

[root@node1 ~]# /opt/etcd-v3.5.6-linux-amd64/bin/etcdctl --cacert=/data/etcd/ssl/ca.pem --cert=/data/etcd/ssl/server.pem --key=/data/etcd/ssl/server-key.pem --endpoints="https://node1.local:2379,https://node2.local:2379,https://node3.local:2379" --user=root:cluster user get server
User: server
Roles: server

11.8. 测试 server 用户权限

[root@node3 ~]# /opt/etcd-v3.5.6-linux-amd64/bin/etcdctl --cacert=/data/etcd/ssl/ca.pem --cert=/data/etcd/ssl/server.pem --key=/data/etcd/ssl/server-key.pem --endpoints="https://node1.local:2379,https://node2.local:2379,https://node3.local:2379" --user=root:cluster put /hello world
OK
[root@node3 ~]# /opt/etcd-v3.5.6-linux-amd64/bin/etcdctl --cacert=/data/etcd/ssl/ca.pem --cert=/data/etcd/ssl/server.pem --key=/data/etcd/ssl/server-key.pem --endpoints="https://node1.local:2379,https://node2.local:2379,https://node3.local:2379" --user=root:cluster put /name wylu
OK
[root@node3 ~]# /opt/etcd-v3.5.6-linux-amd64/bin/etcdctl --cacert=/data/etcd/ssl/ca.pem --cert=/data/etcd/ssl/server.pem --key=/data/etcd/ssl/server-key.pem --endpoints="https://node1.local:2379,https://node2.local:2379,https://node3.local:2379" --user=server:cluster get /hello
/hello
world
[root@node3 ~]# /opt/etcd-v3.5.6-linux-amd64/bin/etcdctl --cacert=/data/etcd/ssl/ca.pem --cert=/data/etcd/ssl/server.pem --key=/data/etcd/ssl/server-key.pem --endpoints="https://node1.local:2379,https://node2.local:2379,https://node3.local:2379" --user=server:cluster get /wylu
{"level":"warn","ts":"2023-01-06T14:31:02.431+0800","logger":"etcd-client","caller":"v3@v3.5.6/retry_interceptor.go:62","msg":"retrying of unary invoker failed","target":"etcd-endpoints://0xc000558540/node1.local:2379","attempt":0,"error":"rpc error: code = PermissionDenied desc = etcdserver: permission denied"}
Error: etcdserver: permission denied

11.8.1. 不添加用户密码参数

提示错误：

1
2
3

[root@node3 ~]# /opt/etcd-v3.5.6-linux-amd64/bin/etcdctl --cacert=/data/etcd/ssl/ca.pem --cert=/data/etcd/ssl/server.pem --key=/data/etcd/ssl/server-key.pem --endpoints="https://node1.local:2379,https://node2.local:2379,https://node3.local:2379" get /hello
{"level":"warn","ts":"2023-01-06T14:32:37.153+0800","logger":"etcd-client","caller":"v3@v3.5.6/retry_interceptor.go:62","msg":"retrying of unary invoker failed","target":"etcd-endpoints://0xc00034a380/node1.local:2379","attempt":0,"error":"rpc error: code = InvalidArgument desc = etcdserver: user name is empty"}
Error: etcdserver: user name is empty

11.8.2. 添加用户密码参数

1
2
3

[root@node3 ~]# /opt/etcd-v3.5.6-linux-amd64/bin/etcdctl --cacert=/data/etcd/ssl/ca.pem --cert=/data/etcd/ssl/server.pem --key=/data/etcd/ssl/server-key.pem --endpoints="https://node1.local:2379,https://node2.local:2379,https://node3.local:2379" --user=server:cluster get /hello
/hello
world

11.9. 常用命令附录

11.9.1. root 用户与 root 角色

root 是 etcd 的超级管理员，拥有 etcd 的所有权限，在开启角色认证之前为们必须要先建立好 root 用户。还需要注意的是 root 用户必须拥有 root 的角色，允许在 etcd 的所有操作。

root 角色可以赋予任何用户，拥有 root 角色的用户有全局读写权限和集群身份验证配置权限，此外，还具有修改集群成员身份，碎片整理，建立快照等权限。

11.9.2. 用户操作

user：可以为 etcd 创建多个用户并设置密码，子命令有：

1）add 添加用户
2）delete 删除用户
3）get 取得用户详情
4）list 列出所有用户
5）passwd 修改用户密码
6）grant-role 给用户分配角色
7）revoke-role 给用户移除角色

11.9.3. 角色操作

role：可以为 etcd 创建多个角色并设置权限，子命令有：

1）add 添加角色
2）delete 删除角色
3）get 取得角色信息
4）list 列出所有角色
5）grant-permission 为角色设置某个key的权限
6）revoke-permission 为角色移除某个key的权限

11.9.4. 身份验证

启动：auth enable

关闭：auth disable

11.9.5. 命令参考链接

https://github.com/etcd-io/etcd/blob/master/Documentation/op-guide/authentication.md

https://juejin.im/post/5b986abff265da0ad947b52f

12. 安装 etcdkeeper

etcdkeeper 可提供 web 页面来管理 etcd 数据库中的数据

12.1. 安装 etcdkeeper

到 https://github.com/evildecay/etcdkeeper/releases/tag/v0.7.6 下载以下文件：

etcdkeeper-v0.7.6-linux_x86_64.zip

解压安装：

1 2	unzip etcdkeeper-v0.7.6-linux_x86_64.zip -d /opt chmod +x /opt/etcdkeeper/etcdkeeper

12.2. 创建 system 服务

cat > /usr/lib/systemd/system/etcdkeeper.service << "EOF"
[Unit]
Description=etcdkeeper service
After=network.target

[Service]
Type=simple
ExecStart=/opt/etcdkeeper/etcdkeeper \
-h 0.0.0.0 \
-p 8800 \
-cacert=/data/etcd/ssl/ca.pem \
-cert=/data/etcd/ssl/server.pem \
-key=/data/etcd/ssl/server-key.pem \
-auth \
-usetls
ExecReload=/bin/kill -HUP $MAINPID
KillMode=process
Restart=on-failure
PrivateTmp=true

[Install]
WantedBy=multi-user.target
EOF

12.3. 修改 index.html

1
2
3

[root@node1 Downloads]# dos2unix /opt/etcdkeeper/assets/etcdkeeper/index.html
dos2unix: converting file /opt/etcdkeeper/assets/etcdkeeper/index.html to Unix format ...
[root@node1 Downloads]# sed -i "154s/etcdBase = '127.0.0.1:2379'/etcdBase = '10.128.170.131:2379'/" /opt/etcdkeeper/assets/etcdkeeper/index.html

12.4. 服务控制

systemctl daemon-reload
systemctl enable etcdkeeper.service # 设置开机自启动
systemctl disable etcdkeeper.service # 停止开机自启动
systemctl start etcdkeeper # 启动 etcdkeeper 服务
systemctl stop etcdkeeper # 停止 etcdkeeper 服务

Windows11 WSL2 深度学习环境配置

2023-08-02T15:27:17.000Z

本文介绍了在 Windows 11 上使用 WSL2 配置深度学习环境的方法。首先需要安装 NVIDIA 显卡驱动程序以获得 GPU 支持，推荐使用官方工具 GeForce Experience 进行安装或更新。然后安装 WSL2，并在其中安装 CUDA 和 cuDNN。在测试中，使用 CPU 运算和 GPU 运算分别运行了小规模和大规模神经网络，并打印了运行时间。结果表明，使用 GPU 运算可以显著提高运行速度。

Windows11 WSL2 深度学习环境配置

CUDA on WSL User Guide

1. 安装 NVIDIA 驱动程序以获得 GPU 支持

1.1 方法一（推荐）

英伟达显卡驱动安装或者更新最好的方法就是利用官方的工具 GeForce Experience 来进行，每一次显卡驱动更新后 CUDA 支持的最高版本会发生变化。

从 https://www.nvidia.cn/geforce/geforce-experience/ 上下载 GeForce Experience 安装后，进入程序安装/更新 GeForce Game Ready 驱动程序。

1.2 方法二

从 https://www.nvidia.com/Download/index.aspx?lang=en-us 获取机器对应显卡版本的驱动程序，然后在系统上安装 NVIDIA GeForce Game Ready 或 NVIDIA RTX Quadro Windows 11 显示驱动程序。

注意：这是您需要安装的唯一驱动程序。不要在 WSL 中安装任何 Linux 显示驱动程序。

2. 安装 WSL2

启动您首选的 Windows Terminal / Command Prompt / Powershell 并安装 WSL：

1	wsl.exe --install

确保您拥有最新的 WSL 内核：

1	wsl.exe --update

查看 WSL 内核版本：

1
2

PS Microsoft.PowerShell.Core\FileSystem::\\wsl$\Ubuntu\root> wsl cat /proc/version
Linux version 5.10.102.1-microsoft-standard-WSL2 (oe-user@oe-host) (x86_64-msft-linux-gcc (GCC) 9.3.0, GNU ld (GNU Binutils) 2.34.0.20200220) #1 SMP Wed Mar 2 00:30:59 UTC 2022

注意：WSL 2 Support Constraints

Ensure you are on the latest WSL Kernel or at least 4.19.121+. We recommend 5.10.16.3 or later for better performance and functional fixes.

3. 安装 CUDA

3.1 确认 NVIDIA 驱动支持的 CUDA 版本

C:\Windows>nvidia-smi
Wed Jul 27 22:57:07 2022
+-----------------------------------------------------------------------------+
| NVIDIA-SMI 516.59       Driver Version: 516.59       CUDA Version: 11.7     |
|-------------------------------+----------------------+----------------------+
| GPU  Name            TCC/WDDM | Bus-Id        Disp.A | Volatile Uncorr. ECC |
| Fan  Temp  Perf  Pwr:Usage/Cap|         Memory-Usage | GPU-Util  Compute M. |
|                               |                      |               MIG M. |
|===============================+======================+======================|
|   0  NVIDIA GeForce ... WDDM  | 00000000:01:00.0 Off |                  N/A |
| N/A   42C    P0    11W /  N/A |      0MiB /  4096MiB |      0%      Default |
|                               |                      |                  N/A |
+-------------------------------+----------------------+----------------------+

+-----------------------------------------------------------------------------+
| Processes:                                                                  |
|  GPU   GI   CI        PID   Type   Process name                  GPU Memory |
|        ID   ID                                                   Usage      |
|=============================================================================|
|  No running processes found                                                 |
+-----------------------------------------------------------------------------+

C:\Windows>nvidia-smi -L
GPU 0: NVIDIA GeForce RTX 3050 Laptop GPU (UUID: GPU-f55a7fb2-0dc9-1d4f-dca9-8f7ea311ec67)

NVIDIA 显卡硬件版本为：NVIDIA GeForce RTX 3050 Laptop GPU
当前显卡驱动程序版本为：516.59
CUDA 版本为：11.7

意味着我笔记本当前的显卡驱动版本 516.59 最高支持的 CUDA 版本是 11.7（11.7 以下都是适配/兼容的）。可以查询 NVIDIA 显卡硬件版本 NVIDIA GeForce RTX 3050 Laptop 所支持的最高显卡驱动版本，通过升级显卡驱动后，来支持更高的 CUDA 版本。

详细的显卡驱动和 CUDA 的版本关系请参考

3.2 下载 CUDA

从 https://developer.nvidia.com/cuda-toolkit-archive 获取合适版本的 CUDA Toolkit，这里以 11.2.2 版本为例进行说明。

进入 CUDA Toolkit 11.2.2 下载页面
选择 Linux 操作系统
选择 x86_64 架构
选择 WSL-Ubuntu 发行版
选择 runfile(local) 安装类型

即可得到安装指示信息：

1 2	$ wget https://developer.download.nvidia.com/compute/cuda/11.2.2/local_installers/cuda_11.2.2_460.32.03_linux.run $ sudo sh cuda_11.2.2_460.32.03_linux.run

3.3 在 WSL2 中安装 CUDA

根据上一步获取的安装指示，下载安装程序：

1	wget -c https://developer.download.nvidia.com/compute/cuda/11.2.2/local_installers/cuda_11.2.2_460.32.03_linux.run

执行安装程序：

1	sh cuda_11.2.2_460.32.03_linux.run

输入 accept 回车确认同意用户使用协议，光标移至 Install，安装全部，安装完成后会打印如下提示：

===========
= Summary =
===========

Driver:   Not Selected
Toolkit:  Installed in /usr/local/cuda-11.2/
Samples:  Installed in /root/, but missing recommended libraries

Please make sure that
 -   PATH includes /usr/local/cuda-11.2/bin
 -   LD_LIBRARY_PATH includes /usr/local/cuda-11.2/lib64, or, add /usr/local/cuda-11.2/lib64 to /etc/ld.so.conf and run ldconfig as root

To uninstall the CUDA Toolkit, run cuda-uninstaller in /usr/local/cuda-11.2/bin
***WARNING: Incomplete installation! This installation did not install the CUDA Driver. A driver of version at least 460.00 is required for CUDA 11.2 functionality to work.
To install the driver using this installer, run the following command, replacing  with the name of this run file:
    sudo .run --silent --driver

Logfile is /var/log/cuda-installer.log

提示中的警告 "WARNING: Incomplete installation! This installation did not install the CUDA Driver." 是正常的，因为我们只需在 Windows 下安装了 NVIDIA 驱动，而非 WSL 下。

3.4 设置环境变量

编辑 /etc/profile 或 ~/.bashrc 文件，以 ~/.bashrc 为例

1	vim ~/.bashrc

在文件末尾添加如下配置：

# Cuda Environment
export CUDA_HOME=/usr/local/cuda-11.2
export LD_LIBRARY_PATH=$CUDA_HOME/lib64:$LD_LIBRARY_PATH

export PATH=$CUDA_HOME/bin:$PATH

使配置生效

1	source ~/.bashrc

3.5 测试 CUDA

进入你的 CUDA Example 所在目录，默认是主目录，找到 "NVIDIA_CUDA-11.2_Samples"。依次打开 "1_Utilities" –> "deviceQuery"，然后重新打开一个终端输入：

root@ubuntu:~# cd ~/NVIDIA_CUDA-11.2_Samples/1_Utilities/deviceQuery
root@ubuntu:~/NVIDIA_CUDA-11.2_Samples/1_Utilities/deviceQuery# make
/usr/local/cuda/bin/nvcc -ccbin g++ -I../../common/inc  -m64    --threads 0 -gencode arch=compute_35,code=sm_35 -gencode arch=compute_37,code=sm_37 -gencode arch=compute_50,code=sm_50 -gencode arch=compute_52,code=sm_52 -gencode arch=compute_60,code=sm_60 -gencode arch=compute_61,code=sm_61 -gencode arch=compute_70,code=sm_70 -gencode arch=compute_75,code=sm_75 -gencode arch=compute_80,code=sm_80 -gencode arch=compute_86,code=sm_86 -gencode arch=compute_86,code=compute_86 -o deviceQuery.o -c deviceQuery.cpp
nvcc warning : The 'compute_35', 'compute_37', 'compute_50', 'sm_35', 'sm_37' and 'sm_50' architectures are deprecated, and may be removed in a future release (Use -Wno-deprecated-gpu-targets to suppress warning).
/usr/local/cuda/bin/nvcc -ccbin g++   -m64      -gencode arch=compute_35,code=sm_35 -gencode arch=compute_37,code=sm_37 -gencode arch=compute_50,code=sm_50 -gencode arch=compute_52,code=sm_52 -gencode arch=compute_60,code=sm_60 -gencode arch=compute_61,code=sm_61 -gencode arch=compute_70,code=sm_70 -gencode arch=compute_75,code=sm_75 -gencode arch=compute_80,code=sm_80 -gencode arch=compute_86,code=sm_86 -gencode arch=compute_86,code=compute_86 -o deviceQuery deviceQuery.o
nvcc warning : The 'compute_35', 'compute_37', 'compute_50', 'sm_35', 'sm_37' and 'sm_50' architectures are deprecated, and may be removed in a future release (Use -Wno-deprecated-gpu-targets to suppress warning).
mkdir -p ../../bin/x86_64/linux/release
cp deviceQuery ../../bin/x86_64/linux/release
root@ubuntu:~/NVIDIA_CUDA-11.2_Samples/1_Utilities/deviceQuery# ./deviceQuery
./deviceQuery Starting...

 CUDA Device Query (Runtime API) version (CUDART static linking)

Detected 1 CUDA Capable device(s)

Device 0: "NVIDIA GeForce RTX 3050 Laptop GPU"
  CUDA Driver Version / Runtime Version          11.7 / 11.2
  CUDA Capability Major/Minor version number:    8.6
  Total amount of global memory:                 4096 MBytes (4294508544 bytes)
  (16) Multiprocessors, (128) CUDA Cores/MP:     2048 CUDA Cores
  GPU Max Clock rate:                            1057 MHz (1.06 GHz)
  Memory Clock rate:                             5501 Mhz
  Memory Bus Width:                              128-bit
  L2 Cache Size:                                 1572864 bytes
  Maximum Texture Dimension Size (x,y,z)         1D=(131072), 2D=(131072, 65536), 3D=(16384, 16384, 16384)
  Maximum Layered 1D Texture Size, (num) layers  1D=(32768), 2048 layers
  Maximum Layered 2D Texture Size, (num) layers  2D=(32768, 32768), 2048 layers
  Total amount of constant memory:               65536 bytes
  Total amount of shared memory per block:       49152 bytes
  Total shared memory per multiprocessor:        102400 bytes
  Total number of registers available per block: 65536
  Warp size:                                     32
  Maximum number of threads per multiprocessor:  1536
  Maximum number of threads per block:           1024
  Max dimension size of a thread block (x,y,z): (1024, 1024, 64)
  Max dimension size of a grid size    (x,y,z): (2147483647, 65535, 65535)
  Maximum memory pitch:                          2147483647 bytes
  Texture alignment:                             512 bytes
  Concurrent copy and kernel execution:          Yes with 1 copy engine(s)
  Run time limit on kernels:                     Yes
  Integrated GPU sharing Host Memory:            No
  Support host page-locked memory mapping:       Yes
  Alignment requirement for Surfaces:            Yes
  Device has ECC support:                        Disabled
  Device supports Unified Addressing (UVA):      Yes
  Device supports Managed Memory:                Yes
  Device supports Compute Preemption:            Yes
  Supports Cooperative Kernel Launch:            Yes
  Supports MultiDevice Co-op Kernel Launch:      No
  Device PCI Domain ID / Bus ID / location ID:   0 / 1 / 0
  Compute Mode:
     < Default (multiple host threads can use ::cudaSetDevice() with device simultaneously) >

deviceQuery, CUDA Driver = CUDART, CUDA Driver Version = 11.7, CUDA Runtime Version = 11.2, NumDevs = 1
Result = PASS

出现 "Result = PASS" 字样时，说明安装成功

4. 安装 cuDNN

4.1 下载 cuDNN

从 https://developer.nvidia.com/rdp/cudnn-archive 获取符合 CUDA 版本的 cuDNN。这里示例 CUDA 是 11.2，所以选择了 Download cuDNN v8.1.1 (Feburary 26th, 2021), for CUDA 11.0,11.1 and 11.2，选择下载 cuDNN Library for Linux (x86_64)

1	wget -c https://developer.nvidia.com/compute/machine-learning/cudnn/secure/8.1.1.33/11.2_20210301/cudnn-11.2-linux-x64-v8.1.1.33.tgz

注意：这里需要注册 NVIDIA 账号。

4.2 在 WSL2 中安装 cuDNN

安装过程实际上是把 cuDNN 的头文件复制到 CUDA 的头文件目录里面去，把 cuDNN 的库复制到 CUDA 的库目录里面去。

解压：

root@ubuntu:~/Downloads# tar -zxvf cudnn-11.2-linux-x64-v8.1.1.33.tgz
cuda/include/cudnn.h
cuda/include/cudnn_adv_infer.h
cuda/include/cudnn_adv_infer_v8.h
cuda/include/cudnn_adv_train.h
cuda/include/cudnn_adv_train_v8.h
cuda/include/cudnn_backend.h
cuda/include/cudnn_backend_v8.h
cuda/include/cudnn_cnn_infer.h
cuda/include/cudnn_cnn_infer_v8.h
cuda/include/cudnn_cnn_train.h
cuda/include/cudnn_cnn_train_v8.h
cuda/include/cudnn_ops_infer.h
cuda/include/cudnn_ops_infer_v8.h
cuda/include/cudnn_ops_train.h
cuda/include/cudnn_ops_train_v8.h
cuda/include/cudnn_v8.h
cuda/include/cudnn_version.h
cuda/include/cudnn_version_v8.h
cuda/NVIDIA_SLA_cuDNN_Support.txt
cuda/lib64/libcudnn.so
cuda/lib64/libcudnn.so.8
cuda/lib64/libcudnn.so.8.1.1
cuda/lib64/libcudnn_adv_infer.so
cuda/lib64/libcudnn_adv_infer.so.8
cuda/lib64/libcudnn_adv_infer.so.8.1.1
cuda/lib64/libcudnn_adv_train.so
cuda/lib64/libcudnn_adv_train.so.8
cuda/lib64/libcudnn_adv_train.so.8.1.1
cuda/lib64/libcudnn_cnn_infer.so
cuda/lib64/libcudnn_cnn_infer.so.8
cuda/lib64/libcudnn_cnn_infer.so.8.1.1
cuda/lib64/libcudnn_cnn_train.so
cuda/lib64/libcudnn_cnn_train.so.8
cuda/lib64/libcudnn_cnn_train.so.8.1.1
cuda/lib64/libcudnn_ops_infer.so
cuda/lib64/libcudnn_ops_infer.so.8
cuda/lib64/libcudnn_ops_infer.so.8.1.1
cuda/lib64/libcudnn_ops_train.so
cuda/lib64/libcudnn_ops_train.so.8
cuda/lib64/libcudnn_ops_train.so.8.1.1
cuda/lib64/libcudnn_static.a
cuda/lib64/libcudnn_static_v8.a

复制 cuDNN 头文件

1	cp cuda/include/* /usr/local/cuda-11.2/include/

复制 cuDNN 库文件

1	cp cuda/lib64/* /usr/local/cuda-11.2/lib64/

添加可执行权限

1 2	chmod +x /usr/local/cuda-11.2/include/cudnn.h chmod +x /usr/local/cuda-11.2/lib64/libcudnn*

4.3 测试 cuDNN

打开一个新的终端：

root@ubuntu:~# conda activate ailab
(ailab) root@ubuntu:~# ipython
Python 3.7.13 (default, Mar 29 2022, 02:18:16)
Type 'copyright', 'credits' or 'license' for more information
IPython 7.34.0 -- An enhanced Interactive Python. Type '?' for help.

In [1]: import tensorflow as tf

In [2]: tf.test.is_gpu_available()
WARNING:tensorflow:From :1: is_gpu_available (from tensorflow.python.framework.test_util) is deprecated and will be removed in a future version.
Instructions for updating:
Use `tf.config.list_physical_devices('GPU')` instead.
2022-07-27 23:46:19.645726: I tensorflow/core/platform/cpu_feature_guard.cc:193] This TensorFlow binary is optimized with oneAPI Deep Neural Network Library (oneDNN) to use the following CPU instructions in performance-critical operations:  AVX2 FMA
To enable them in other operations, rebuild TensorFlow with the appropriate compiler flags.
2022-07-27 23:46:21.108297: I tensorflow/stream_executor/cuda/cuda_gpu_executor.cc:961] could not open file to read NUMA node: /sys/bus/pci/devices/0000:01:00.0/numa_node
Your kernel may have been built without NUMA support.
2022-07-27 23:46:21.136684: I tensorflow/stream_executor/cuda/cuda_gpu_executor.cc:961] could not open file to read NUMA node: /sys/bus/pci/devices/0000:01:00.0/numa_node
Your kernel may have been built without NUMA support.
2022-07-27 23:46:21.137199: I tensorflow/stream_executor/cuda/cuda_gpu_executor.cc:961] could not open file to read NUMA node: /sys/bus/pci/devices/0000:01:00.0/numa_node
Your kernel may have been built without NUMA support.
2022-07-27 23:46:22.147971: I tensorflow/stream_executor/cuda/cuda_gpu_executor.cc:961] could not open file to read NUMA node: /sys/bus/pci/devices/0000:01:00.0/numa_node
Your kernel may have been built without NUMA support.
2022-07-27 23:46:22.148598: I tensorflow/stream_executor/cuda/cuda_gpu_executor.cc:961] could not open file to read NUMA node: /sys/bus/pci/devices/0000:01:00.0/numa_node
Your kernel may have been built without NUMA support.
2022-07-27 23:46:22.148635: I tensorflow/core/common_runtime/gpu/gpu_device.cc:1616] Could not identify NUMA node of platform GPU id 0, defaulting to 0.  Your kernel may not have been built with NUMA support.
2022-07-27 23:46:22.149146: I tensorflow/stream_executor/cuda/cuda_gpu_executor.cc:961] could not open file to read NUMA node: /sys/bus/pci/devices/0000:01:00.0/numa_node
Your kernel may have been built without NUMA support.
2022-07-27 23:46:22.149214: I tensorflow/core/common_runtime/gpu/gpu_device.cc:1532] Created device /device:GPU:0 with 1626 MB memory:  -> device: 0, name: NVIDIA GeForce RTX 3050 Laptop GPU, pci bus id: 0000:01:00.0, compute capability: 8.6
Out[2]: True

In [3]:

输出中提示 "Your kernel may not have been built with NUMA support" ，这是无害告警，可以忽略。

https://stackoverflow.com/questions/51733128/your-kernel-may-have-been-built-without-numa-support

https://forums.developer.nvidia.com/t/numa-error-running-tensorflow-on-jetson-tx2/56119

https://stackoverflow.com/questions/40426502/is-there-a-way-to-suppress-the-messages-tensorflow-prints

5. CPU vs GPU

硬件	型号
CPU	AMD Ryzen 7 5800H with Radeon Graphics
GPU	NVIDIA GeForce RTX 3050 Laptop GPU

5.1 小规模神经网络

#!/usr/bin/env python
# -*- coding: utf-8 -*-
# TensorFlow and tf.keras
import tensorflow as tf
# Helper libraries
from time import time

mnist = tf.keras.datasets.mnist
(x_train, y_train), (x_test, y_test) = mnist.load_data()
x_train, x_test = x_train / 255.0, x_test / 255.0

# 用 CPU 运算
startTime1 = time()

with tf.device('/cpu:0'):
    model = tf.keras.models.Sequential([
        tf.keras.layers.Flatten(input_shape=(28, 28)),
        tf.keras.layers.Dense(128, activation='relu'),
        tf.keras.layers.Dropout(0.2),
        tf.keras.layers.Dense(10, activation='softmax'),
    ])
    model.compile(
        optimizer='adam',
        loss='sparse_categorical_crossentropy',
        metrics=['accuracy'],
    )
    model.fit(x_train, y_train, epochs=10)
    model.evaluate(x_test, y_test)
t1 = time() - startTime1

# 用 GPU 运算
startTime2 = time()

with tf.device('/gpu:0'):
    model = tf.keras.models.Sequential([
        tf.keras.layers.Flatten(input_shape=(28, 28)),
        tf.keras.layers.Dense(128, activation='relu'),
        tf.keras.layers.Dropout(0.2),
        tf.keras.layers.Dense(10, activation='softmax'),
    ])
    model.compile(
        optimizer='adam',
        loss='sparse_categorical_crossentropy',
        metrics=['accuracy'],
    )
    model.fit(x_train, y_train, epochs=10)
    model.evaluate(x_test, y_test)

t2 = time() - startTime2

# 打印运行时间
print('使用cpu花的时间：', t1)
print('使用gpu花的时间：', t2)

运行结果

1 2	使用cpu花的时间： 26.906126737594604 使用gpu花的时间： 54.50972127914429

5.2 大规模神经网络

#!/usr/bin/env python
# -*- coding: utf-8 -*-
# TensorFlow and tf.keras
import tensorflow as tf
# Helper libraries
from time import time

mnist = tf.keras.datasets.mnist
(x_train, y_train), (x_test, y_test) = mnist.load_data()
x_train, x_test = x_train / 255.0, x_test / 255.0

# CPU 运行
startTime1 = time()

with tf.device('/cpu:0'):
    model = tf.keras.models.Sequential([
        tf.keras.layers.Flatten(input_shape=(28, 28)),
        tf.keras.layers.Dense(1000, activation='relu'),
        tf.keras.layers.Dropout(0.2),
        tf.keras.layers.Dense(1000, activation='relu'),
        tf.keras.layers.Dropout(0.2),
        tf.keras.layers.Dense(10, activation='softmax'),
    ])
    model.compile(
        optimizer='adam',
        loss='sparse_categorical_crossentropy',
        metrics=['accuracy'],
    )
    model.fit(x_train, y_train, epochs=10)
    model.evaluate(x_test, y_test)

t1 = time() - startTime1

# GPU 运行
startTime2 = time()

with tf.device('/gpu:0'):
    model = tf.keras.models.Sequential([
        tf.keras.layers.Flatten(input_shape=(28, 28)),
        tf.keras.layers.Dense(1000, activation='relu'),
        tf.keras.layers.Dropout(0.2),
        tf.keras.layers.Dense(1000, activation='relu'),
        tf.keras.layers.Dropout(0.2),
        tf.keras.layers.Dense(10, activation='softmax'),
    ])

    model.compile(
        optimizer='adam',
        loss='sparse_categorical_crossentropy',
        metrics=['accuracy'],
    )
    model.fit(x_train, y_train, epochs=10)
    model.evaluate(x_test, y_test)

t2 = time() - startTime2

# 打印运行时间
print('使用cpu花的时间：', t1)
print('使用gpu花的时间：', t2)

运行结果

1 2	使用 cpu 花的时间：205.31678819656372 使用 gpu 花的时间：74.53320002555847

References

深度学习环境配置 Windows+WSL2

Windows搭建深度学习环境(CUDA)

ubuntu安装cudnn

CUDA on WSL User Guide

linux下查看库是否存在

NVIDIA CUDA Toolkit Release Notes

bitnami etcd 故障成员恢复

2023-08-01T15:52:32.000Z

本文介绍了在使用 bitnami/etcd 部署的集群中，如何恢复故障成员的方法。首先在处理前，往 etcd 集群中添加一些数据，以验证恢复方案不会导致集群数据丢失。然后，通过删除 etcd-1 pv 的数据目录来模拟 etcd-1 成员故障，并查看 etcd-1 pod 日志、etcd 集群成员状态以及 endpoint 健康状态来分析故障原因。接着，本文提供了一套恢复方案，包括将故障成员 etcd-1 从集群中移除、将 etcd statefulsets 缩放为 0、删除故障成员 etcd-1 绑定的 pv 的数据目录、修改 statefulsets 中 ETCD_INITIAL_CLUSTER_STATE 配置的值为 "existing"、将 etcd statefulsets 恢复为原来的副本数以及检查 etcd 集群 endpoint 健康状态等步骤。最后，验证数据是否完整。

bitnami etcd 故障成员恢复

环境准备

准备一个使用 bitnami/etcd 部署的集群。

查看 statefulsets：

1
2
3

[root@cnode1 ~]# kubectl -n etcd get statefulsets.apps
NAME          READY   AGE
etcd          3/3     29d

查看 pod：

[root@cnode1 ~]# kubectl -n etcd get pod
NAME            READY   STATUS      RESTARTS       AGE
etcd-0          1/1     Running     0              19m
etcd-1          1/1     Running     0              21m
etcd-2          1/1     Running     0              22m

查看 ETCD_INITIAL_CLUSTER_STATE 配置：

1
2
3

[root@cnode1 ~]# kubectl -n etcd get statefulsets.apps etcd -o yaml | grep ETCD_INITIAL_CLUSTER_STATE -A 1
        - name: ETCD_INITIAL_CLUSTER_STATE
          value: new

查看 etcd 集群成员状态：

I have no name!@etcd-0:/opt/bitnami/etcd$ bin/etcdctl member list
14105f2e4f2559a9, started, etcd-0, http://etcd-0.etcd-headless.etcd:2380, http://etcd-0.etcd-headless.etcd:2379,http://etcd.etcd:2379, false
432042ce92be9a79, started, etcd-2, http://etcd-2.etcd-headless.etcd:2380, http://etcd-2.etcd-headless.etcd:2379,http://etcd.etcd:2379, false
e3ff14c8562cf8c2, started, etcd-1, http://etcd-1.etcd-headless.etcd:2380, http://etcd-1.etcd-headless.etcd:2379,http://etcd.etcd:2379, false

该集群有 3 个成员：

etcd-0
etcd-1
etcd-2

添加测试数据

在处理前，先往 etcd 集群中添加一些数据，以验证恢复方案不会导致集群数据丢失。

[root@cnode1 ~]# kubectl -n etcd exec -it etcd-0 -- bash
I have no name!@etcd-0:/opt/bitnami/etcd$ bin/etcdctl put /hello world
OK
I have no name!@etcd-0:/opt/bitnami/etcd$ bin/etcdctl get /hello
/hello
world

破坏 etcd-1 成员

获取 etcd-1 的 pv：（所有 pv 均使用 local-storage）

[root@cnode1 ~]# kubectl -n etcd get pvc
NAME                 STATUS   VOLUME                                     CAPACITY   ACCESS MODES   STORAGECLASS    AGE
data-etcd-0          Bound    pvc-2a2f2a25-69b3-41ab-a21d-a5aa3d05277d   10Gi       RWO            local-storage   29d
data-etcd-1          Bound    pvc-4832f8c4-0827-4992-9e39-185f9c0f8e20   10Gi       RWO            local-storage   60m
data-etcd-2          Bound    pvc-6da8bcd7-cd2a-43fc-9849-7e1c2870f193   10Gi       RWO            local-storage   29d

获取 etcd-1 pv 所在的节点：

[root@cnode1 ~]# kubectl get pv pvc-4832f8c4-0827-4992-9e39-185f9c0f8e20 -o yaml | grep nodeAffinity -A 7
  nodeAffinity:
    required:
      nodeSelectorTerms:
      - matchExpressions:
        - key: kubernetes.io/hostname
          operator: In
          values:
          - cnode3

获取 etcd-1 pv 的数据目录：

[root@cnode1 ~]# kubectl get pv pvc-4832f8c4-0827-4992-9e39-185f9c0f8e20 -o yaml | grep hostPath -A 2
  hostPath:
    path: /data/local-path-provisioner/pvc-4832f8c4-0827-4992-9e39-185f9c0f8e20_etcd_data-etcd-1
    type: DirectoryOrCreate

进入节点 cnode3 后台：

1	ssh root@cnode3

删除 etcd-1 pv 的数据目录：

1	[root@cnode3 ~]# rm -rf /data/local-path-provisioner/pvc-4832f8c4-0827-4992-9e39-185f9c0f8e20_etcd_data-etcd-1/data/

删除 etcd-1 pod：

1 2	[root@cnode1 ~]# kubectl -n etcd delete pod etcd-1 pod "etcd-1" deleted

等待 etcd-1 pod 重新被拉起：

[root@cnode1 ~]# kubectl -n etcd get pod
NAME            READY   STATUS             RESTARTS       AGE
etcd-0          1/1     Running            0              46m
etcd-1          0/1     CrashLoopBackOff   5 (114s ago)   5m10s
etcd-2          1/1     Running            0              48m

此状态下，重启 etcd 集群也无法恢复：

[root@cnode1 ~]# kubectl -n etcd rollout restart statefulset etcd
statefulset.apps/etcd restarted
[root@cnode1 ~]# kubectl -n etcd scale statefulset etcd --replicas=0
statefulset.apps/etcd scaled
[root@cnode1 ~]# kubectl -n etcd scale statefulset etcd --replicas=3
statefulset.apps/etcd scaled
[root@cnode1 ~]# kubectl -n etcd get pod
NAME            READY   STATUS             RESTARTS       AGE
etcd-0          1/1     Running            0              67s
etcd-1          0/1     CrashLoopBackOff   1 (12s ago)    67s
etcd-2          1/1     Running            0              67s

分析 etcd-1 故障

查看 etcd-1 pod 日志：

[root@cnode1 ~]# kubectl -n etcd logs -f etcd-1
...
{"level":"info","ts":"2023-07-31T22:47:11.938+0800","caller":"flags/flag.go:113","msg":"recognized and used environment variable","variable-name":"ETCD_INITIAL_ADVERTISE_PEER_URLS","variable-value":"http://etcd-1.etcd-headless.etcd:2380"}
{"level":"info","ts":"2023-07-31T22:47:11.938+0800","caller":"flags/flag.go:113","msg":"recognized and used environment variable","variable-name":"ETCD_INITIAL_CLUSTER","variable-value":"etcd-0=http://etcd-0.etcd-headless.etcd:2380,etcd-1=http://etcd-1.etcd-headless.etcd:2380,etcd-2=http://etcd-2.etcd-headless.etcd:2380"}
{"level":"info","ts":"2023-07-31T22:47:11.938+0800","caller":"flags/flag.go:113","msg":"recognized and used environment variable","variable-name":"ETCD_INITIAL_CLUSTER_STATE","variable-value":"new"}
...
{"level":"info","ts":"2023-07-31T22:47:11.939+0800","caller":"etcdmain/etcd.go:73","msg":"Running: ","args":["etcd"]}
{"level":"warn","ts":"2023-07-31T22:47:11.939+0800","caller":"etcdmain/etcd.go:446","msg":"found invalid file under data directory","filename":"member_id","data-dir":"/bitnami/etcd/data"}
{"level":"info","ts":"2023-07-31T22:47:11.939+0800","caller":"etcdmain/etcd.go:116","msg":"server has been already initialized","data-dir":"/bitnami/etcd/data","dir-type":"member"}
...
{"level":"info","ts":"2023-07-31T22:47:11.957+0800","logger":"raft","caller":"etcdserver/zap_raft.go:77","msg":"af3fef14dc164ad9 [term: 1] received a MsgHeartbeat message with higher term from 14105f2e4f2559a9 [term: 24]"}
{"level":"info","ts":"2023-07-31T22:47:11.957+0800","logger":"raft","caller":"etcdserver/zap_raft.go:77","msg":"af3fef14dc164ad9 became follower at term 24"}
{"level":"info","ts":"2023-07-31T22:47:11.957+0800","logger":"raft","caller":"etcdserver/zap_raft.go:77","msg":"raft.node: af3fef14dc164ad9 elected leader 14105f2e4f2559a9 at term 24"}
{"level":"warn","ts":"2023-07-31T22:47:11.958+0800","caller":"etcdserver/server.go:1150","msg":"server error","error":"the member has been permanently removed from the cluster"}
{"level":"warn","ts":"2023-07-31T22:47:11.958+0800","caller":"etcdserver/server.go:1151","msg":"data-dir used by this member must be removed"}
{"level":"warn","ts":"2023-07-31T22:47:11.959+0800","caller":"etcdserver/server.go:2053","msg":"stopped publish because server is stopped","local-member-id":"af3fef14dc164ad9","local-member-attributes":"{Name:etcd-1 ClientURLs:[http://etcd-1.etcd-headless.etcd:2379 http://etcd.etcd:2379]}","publish-timeout":"25s","error":"etcdserver: server stopped"}
{"level":"info","ts":"2023-07-31T22:47:11.962+0800","caller":"rafthttp/peer.go:330","msg":"stopping remote peer","remote-peer-id":"432042ce92be9a79"}

查看 etcd 集群成员状态：（这个命令无法得知 endpoint 的健康状态）

[root@cnode1 ~]# kubectl -n etcd exec -it etcd-0 -- bash
I have no name!@etcd-0:/opt/bitnami/etcd$ bin/etcdctl member list
14105f2e4f2559a9, started, etcd-0, http://etcd-0.etcd-headless.etcd:2380, http://etcd-0.etcd-headless.etcd:2379,http://etcd.etcd:2379, false
432042ce92be9a79, started, etcd-2, http://etcd-2.etcd-headless.etcd:2380, http://etcd-2.etcd-headless.etcd:2379,http://etcd.etcd:2379, false
e3ff14c8562cf8c2, started, etcd-1, http://etcd-1.etcd-headless.etcd:2380, http://etcd-1.etcd-headless.etcd:2379,http://etcd.etcd:2379, false

查看 etcd 集群 endpoint 健康状态：

I have no name!@etcd-0:/opt/bitnami/etcd$ bin/etcdctl endpoint health --endpoints=etcd-0.etcd-headless.etcd:2380,etcd-1.etcd-headless.etcd:2380,etcd-2.etcd-headless.etcd:2380 -w table
{"level":"warn","ts":"2023-07-31T22:58:52.131+0800","logger":"client","caller":"v3/retry_interceptor.go:62","msg":"retrying of unary invoker failed","target":"etcd-endpoints://0x400044aa80/etcd-1.etcd-headless.etcd:2380","attempt":0,"error":"rpc error: code = DeadlineExceeded desc = latest balancer error: last connection error: connection error: desc = \"transport: Error while dialing dial tcp 192.168.188.20:2380: connect: connection refused\""}
+--------------------------------+--------+-------------+---------------------------+
|            ENDPOINT            | HEALTH |    TOOK     |           ERROR           |
+--------------------------------+--------+-------------+---------------------------+
| etcd-0.etcd-headless.etcd:2380 |   true |   2.97674ms |                           |
| etcd-2.etcd-headless.etcd:2380 |   true |   8.06479ms |                           |
| etcd-1.etcd-headless.etcd:2380 |  false | 5.00261904s | context deadline exceeded |
+--------------------------------+--------+-------------+---------------------------+
Error: unhealthy cluster

恢复方案

（1）将故障成员 etcd-1 从集群中移除

[root@cnode1 ~]# kubectl -n etcd exec -it etcd-0 -- bash
I have no name!@etcd-0:/opt/bitnami/etcd$ bin/etcdctl endpoint health --endpoints=etcd-0.etcd-headless.etcd:2380,etcd-1.etcd-headless.etcd:2380,etcd-2.etcd-headless.etcd:2380
{"level":"warn","ts":"2023-07-31T23:42:37.481+0800","logger":"client","caller":"v3/retry_interceptor.go:62","msg":"retrying of unary invoker failed","target":"etcd-endpoints://0x4000230000/etcd-1.etcd-headless.etcd:2380","attempt":0,"error":"rpc error: code = DeadlineExceeded desc = latest balancer error: last connection error: connection error: desc = \"transport: Error while dialing dial tcp 192.168.188.20:2380: connect: connection refused\""}
etcd-0.etcd-headless.etcd:2380 is healthy: successfully committed proposal: took = 4.34159ms
etcd-2.etcd-headless.etcd:2380 is healthy: successfully committed proposal: took = 5.19394ms
etcd-1.etcd-headless.etcd:2380 is unhealthy: failed to commit proposal: context deadline exceeded
Error: unhealthy cluster
I have no name!@etcd-0:/opt/bitnami/etcd$ bin/etcdctl member list -w table
+------------------+---------+--------+---------------------------------------+-------------------------------------------------------------+------------+
|        ID        | STATUS  |  NAME  |              PEER ADDRS               |                         CLIENT ADDRS                        | IS LEARNER |
+------------------+---------+--------+---------------------------------------+-------------------------------------------------------------+------------+
| 14105f2e4f2559a9 | started | etcd-0 | http://etcd-0.etcd-headless.etcd:2380 | http://etcd-0.etcd-headless.etcd:2379,http://etcd.etcd:2379 |      false |
| 432042ce92be9a79 | started | etcd-2 | http://etcd-2.etcd-headless.etcd:2380 | http://etcd-2.etcd-headless.etcd:2379,http://etcd.etcd:2379 |      false |
| e3ff14c8562cf8c2 | started | etcd-1 | http://etcd-1.etcd-headless.etcd:2380 | http://etcd-1.etcd-headless.etcd:2379,http://etcd.etcd:2379 |      false |
+------------------+---------+--------+---------------------------------------+-------------------------------------------------------------+------------+
I have no name!@etcd-0:/opt/bitnami/etcd$ bin/etcdctl member remove e3ff14c8562cf8c2
Member e3ff14c8562cf8c2 removed from cluster d96b6d5811544d30
I have no name!@etcd-0:/opt/bitnami/etcd$ bin/etcdctl member list -w table
+------------------+---------+--------+---------------------------------------+-------------------------------------------------------------+------------+
|        ID        | STATUS  |  NAME  |              PEER ADDRS               |                         CLIENT ADDRS                        | IS LEARNER |
+------------------+---------+--------+---------------------------------------+-------------------------------------------------------------+------------+
| 14105f2e4f2559a9 | started | etcd-0 | http://etcd-0.etcd-headless.etcd:2380 | http://etcd-0.etcd-headless.etcd:2379,http://etcd.etcd:2379 |      false |
| 432042ce92be9a79 | started | etcd-2 | http://etcd-2.etcd-headless.etcd:2380 | http://etcd-2.etcd-headless.etcd:2379,http://etcd.etcd:2379 |      false |
+------------------+---------+--------+---------------------------------------+-------------------------------------------------------------+------------+

（2）将 etcd statefulsets 缩放为 0

[root@cnode1 ~]# kubectl -n etcd scale statefulset etcd --replicas=0
statefulset.apps/etcd scaled
[root@cnode1 ~]# kubectl -n etcd get statefulsets.apps etcd
NAME   READY   AGE
etcd   0/0     30d

（3）删除故障成员 etcd-1 绑定的 pv 的数据目录

获取 etcd-1 的 pv

[root@cnode1 ~]# kubectl -n etcd get pvc
NAME                 STATUS   VOLUME                                     CAPACITY   ACCESS MODES   STORAGECLASS    AGE
data-etcd-0          Bound    pvc-2a2f2a25-69b3-41ab-a21d-a5aa3d05277d   10Gi       RWO            local-storage   30d
data-etcd-1          Bound    pvc-4832f8c4-0827-4992-9e39-185f9c0f8e20   10Gi       RWO            local-storage   4h10m
data-etcd-2          Bound    pvc-6da8bcd7-cd2a-43fc-9849-7e1c2870f193   10Gi       RWO            local-storage   30d

获取 etcd-1 pv 所在的节点

[root@cnode1 ~]# kubectl get pv pvc-4832f8c4-0827-4992-9e39-185f9c0f8e20 -o yaml | grep nodeAffinity -A 7
  nodeAffinity:
    required:
      nodeSelectorTerms:
      - matchExpressions:
        - key: kubernetes.io/hostname
          operator: In
          values:
          - cnode3

获取 etcd-1 pv 的数据目录

[root@cnode1 ~]# kubectl get pv pvc-4832f8c4-0827-4992-9e39-185f9c0f8e20 -o yaml | grep hostPath -A 2
  hostPath:
    path: /data/local-path-provisioner/pvc-4832f8c4-0827-4992-9e39-185f9c0f8e20_etcd_data-etcd-1
    type: DirectoryOrCreate

进入节点 cnode3 后台
1
ssh root@cnode3

清除 etcd-1 pv 的数据目录

1
2
3

[root@cnode1 ~]# rm -rf /data/local-path-provisioner/pvc-4832f8c4-0827-4992-9e39-185f9c0f8e20_etcd_data-etcd-1/data/
[root@cnode1 ~]# ls /data/local-path-provisioner/pvc-4832f8c4-0827-4992-9e39-185f9c0f8e20_etcd_data-etcd-1/
[root@cnode1 ~]#

（4）修改 statefulsets 中 ETCD_INITIAL_CLUSTER_STATE 配置的值为 "existing"

1 2	[root@cnode1 ~]# kubectl -n etcd edit statefulsets.apps etcd statefulset.apps/etcd edited

修改内容如下：

1 2	- name: ETCD_INITIAL_CLUSTER_STATE value: existing

（5）将 etcd statefulsets 恢复为原来的副本数

1 2	[root@cnode1 ~]# kubectl -n etcd scale statefulset etcd --replicas=3 statefulset.apps/etcd scaled

（6）查看 etcd-1 的日志

[root@cnode1 ~]# kubectl -n etcd logs -f etcd-1
...
{"level":"info","ts":"2023-07-31T23:48:36.065+0800","caller":"flags/flag.go:113","msg":"recognized and used environment variable","variable-name":"ETCD_INITIAL_CLUSTER","variable-value":"etcd-0=http://etcd-0.etcd-headless.etcd:2380,etcd-1=http://etcd-1.etcd-headless.etcd:2380,etcd-2=http://etcd-2.etcd-headless.etcd:2380"}
{"level":"info","ts":"2023-07-31T23:48:36.065+0800","caller":"flags/flag.go:113","msg":"recognized and used environment variable","variable-name":"ETCD_INITIAL_CLUSTER_STATE","variable-value":"existing"}
...
{"level":"info","ts":"2023-07-31T23:48:36.430+0800","caller":"etcdserver/server.go:2042","msg":"published local member to cluster through raft","local-member-id":"1ea060417ff0fbae","local-member-attributes":"{Name:etcd-1 ClientURLs:[http://etcd-1.etcd-headless.etcd:2379 http://etcd.etcd:2379]}","request-path":"/0/members/1ea060417ff0fbae/attributes","cluster-id":"d96b6d5811544d30","publish-timeout":"25s"}
{"level":"info","ts":"2023-07-31T23:48:36.430+0800","caller":"embed/serve.go:98","msg":"ready to serve client requests"}
{"level":"info","ts":"2023-07-31T23:48:36.430+0800","caller":"etcdmain/main.go:44","msg":"notifying init daemon"}
{"level":"info","ts":"2023-07-31T23:48:36.430+0800","caller":"etcdmain/main.go:50","msg":"successfully notified init daemon"}
{"level":"info","ts":"2023-07-31T23:48:36.431+0800","caller":"embed/serve.go:140","msg":"serving client traffic insecurely; this is strongly discouraged!","address":"[::]:2379"}

（7）查看 etcd statefulsets 状态

[root@cnode1 ~]# kubectl -n etcd get statefulsets.apps etcd
NAME   READY   AGE
etcd   3/3     30d
[root@cnode1 ~]# kubectl -n etcd get pod
NAME            READY   STATUS      RESTARTS       AGE
etcd-0          1/1     Running     0              6m39s
etcd-1          1/1     Running     0              6m39s
etcd-2          1/1     Running     0              6m39s

（8）检查 etcd 集群 endpoint 健康状态

[root@cnode1 ~]# kubectl -n etcd exec -it etcd-0 -- bash
I have no name!@etcd-0:/opt/bitnami/etcd$ bin/etcdctl endpoint health --endpoints=etcd-0.etcd-headless.etcd:2380,etcd-1.etcd-headless.etcd:2380,etcd-2.etcd-headless.etcd:2380 -w table
+--------------------------------+--------+-----------+-------+
|            ENDPOINT            | HEALTH |   TOOK    | ERROR |
+--------------------------------+--------+-----------+-------+
| etcd-0.etcd-headless.etcd:2380 |   true | 5.09933ms |       |
| etcd-1.etcd-headless.etcd:2380 |   true | 5.97046ms |       |
| etcd-2.etcd-headless.etcd:2380 |   true | 5.37909ms |       |
+--------------------------------+--------+-----------+-------+

（9）查看 etcd 集群成员状态

[root@cnode1 ~]# kubectl -n etcd exec -it etcd-0 -- bash
I have no name!@etcd-0:/opt/bitnami/etcd$ bin/etcdctl member list -w table
+------------------+---------+--------+---------------------------------------+-------------------------------------------------------------+------------+
|        ID        | STATUS  |  NAME  |              PEER ADDRS               |                         CLIENT ADDRS                        | IS LEARNER |
+------------------+---------+--------+---------------------------------------+-------------------------------------------------------------+------------+
| 14105f2e4f2559a9 | started | etcd-0 | http://etcd-0.etcd-headless.etcd:2380 | http://etcd-0.etcd-headless.etcd:2379,http://etcd.etcd:2379 |      false |
| 1ea060417ff0fbae | started | etcd-1 | http://etcd-1.etcd-headless.etcd:2380 | http://etcd-1.etcd-headless.etcd:2379,http://etcd.etcd:2379 |      false |
| 432042ce92be9a79 | started | etcd-2 | http://etcd-2.etcd-headless.etcd:2380 | http://etcd-2.etcd-headless.etcd:2379,http://etcd.etcd:2379 |      false |
+------------------+---------+--------+---------------------------------------+-------------------------------------------------------------+------------+

（10）修改 statefulsets 中 ETCD_INITIAL_CLUSTER_STATE 配置的值恢复为 "new"（可选）

1 2	[root@cnode1 ~]# kubectl -n etcd edit statefulsets.apps etcd statefulset.apps/etcd edited

修改内容如下：

1 2	- name: ETCD_INITIAL_CLUSTER_STATE value: new

等待 statefulsets 重启完成：

[root@cnode1 ~]# kubectl -n etcd get statefulsets.apps etcd
NAME   READY   AGE
etcd   3/3     30d
[root@cnode1 ~]# kubectl -n etcd get pod
NAME            READY   STATUS      RESTARTS       AGE
etcd-0          1/1     Running     0              2m2s
etcd-1          1/1     Running     0              3m5s
etcd-2          1/1     Running     0              4m8s

（11）验证数据是否完整

[root@cnode1 ~]# kubectl -n etcd exec -it etcd-0 -- bash
I have no name!@etcd-0:/opt/bitnami/etcd$ bin/etcdctl get /hello
/hello
world

nmcli 网络管理工具

2023-07-30T06:42:05.000Z

本文介绍了 nmcli (Network Manager Command Line Interface) 网络管理工具，它是 NetworkManager 的命令行工具，用于在 Linux 系统上管理网络连接。nmcli 允许用户通过命令行界面管理和配置网络连接，包括无线网络、以太网、VPN 等。本文详细介绍了 nmcli 的安装方法和各种命令，包括选项、通用命令、网络控制命令、设备管理命令、连接管理命令、无线传输控制命令和活动监视器。此外，本文还提供了 nmcli 的示例，供用户参考。nmcli 是一个功能强大且灵活的工具，常用于服务器管理和命令行环境下的网络配置。

nmcli 网络管理工具

nmcli 简介

https://networkmanager.dev/

nmcli (Network Manager Command Line Interface) 是 NetworkManager 的命令行工具。NetworkManager 是一个在 Linux 系统上管理网络连接的守护进程。nmcli 允许用户通过命令行界面管理和配置网络连接，包括无线网络、以太网、VPN 等。使用 nmcli，您可以列出可用的网络连接、连接到特定的网络、配置网络设置、查看网络状态等。它是一个功能强大且灵活的工具，常用于服务器管理和命令行环境下的网络配置。

NetworkManager 是 2004 年 RedHat 启动的项目，皆在能够让 Linux 用户更轻松的处理现代网络需求，尤其是无线网络，能够自动发现网卡并配置 IP 地址。
RHEL7 上同时支持 network.service 和 NetworkManager.service（简称 NM）。默认情况下这两个服务都有开启，但是因为 NetworkManager.service 当时的兼容性不好，有时会造成 IP 地址无法生效或网络不通问题，大部分人都会将其关闭 NM。
但是在 RHEL 8/CentOS 8上已废弃 network.service（默认不安装），只能通过 NetworkManager 进行网络配置。
NetworkManager 主要管理两个对象：Connection（网卡连接配置）和 Device（网卡设备）。
在 RHEL 8/CentOS 8有三种方法配置网络：
通过 nmcli connection add 命令配置，会自动生成 ifcfg 文件；
手动配置 ifcfg 文件，通过 nmcli connection reload 来加载生效；
手动配置 ifcfg 文件，通过传统 network.service 来加载生效；

nmcli 安装

nmcli 实用工具是由 NetworkManager 包提供，有关详情，请参阅 NetworkManager(8)。

1	[root@localhost ~]# man 8 NetworkManager

在 CentOS 7 / CentOS 8 中，默认已安装：

[root@localhost ~]# cat /etc/redhat-release
Rocky Linux release 8.6 (Green Obsidian)
[root@localhost ~]# yum install -y NetworkManager
Last metadata expiration check: 0:03:25 ago on Sun 30 Jul 2023 06:28:20 AM CST.
Package NetworkManager-1:1.36.0-4.el8.x86_64 is already installed.
...
[root@localhost ~]# nmcli --version
nmcli tool, version 1.40.16-3.el8_8

nmcli 命令

https://networkmanager.dev/docs/api/latest/nmcli.html

1 2	[root@localhost ~]# nmcli agent connection device general help monitor networking radio

nmcli 有 8 个子命令，这里重点介绍 device、 connection。

选项（Options）

-f | --fields { field1,field2... | all | common }
该选项用于指定应打印哪些字段（列名）。特定命令的有效字段名称有所不同。通过向 --fields 选项提供无效值来列出可用字段。all 用于打印命令的所有有效字段值。common 用于打印命令的公共字段值。
如果省略，则默认为 common。
-g | --get-values { field1,field2... | all | common }
此选项用于打印特定字段中的值。它基本上是 --mode tabular --terse --fields 的快捷方式，是检索特定字段值的便捷方法。每行打印一个值，不带标题。
如果指定了节（section）而不是字段，则将打印节名称，后跟属于该节的字段的冒号分隔值，所有这些都在同一行上。
-m | --mode { tabular | multiline }
在表格和多行输出之间切换：
- tabular：输出是一个表，其中每行描述一个条目。列定义条目的特定属性。
- multiline：每个条目由多行组成，每个属性独占一行。这些值以属性名称为前缀。
如果省略，则大多数命令的默认值是 tabular 形式。对于产生更多结构化信息的命令，无法在单行上显示，默认为 multiline。目前，它们是：
- nmcli connection show ID
- nmcli device show
-p | --pretty
美化输出。这使得 nmcli 产生人类易于阅读的输出，即值对齐、打印标题等。
-t | --terse
简洁输出。该模式是为计算机（脚本）处理而设计的。
-w | --wait seconds
此选项设置 nmcli 将等待 NetworkManager 完成操作的超时时间。它对于可能需要较长时间才能完成的命令特别有用，例如连接激活。
指定值 0 指示 nmcli 不等待而是立即退出并显示成功状态。默认值取决于执行的命令。

通用命令（General Commands）

1	nmcli general { status \| hostname \| permissions \| logging \| reload } [ARGUMENTS...]

使用此命令显示 NetworkManager 状态和权限。您还可以获取和更改系统主机名以及 NetworkManager 日志记录级别和域。

status

显示 NetworkManager 的整体状态。当没有为 nmcli 常规提供其他命令时，这是默认操作。

1
2
3

[root@localhost ~]# nmcli general status
STATE      CONNECTIVITY  WIFI-HW  WIFI     WWAN-HW  WWAN
connected  full          missing  enabled  missing  enabled

hostname

hostname [hostname]

获取和更改系统主机名。如果没有参数，这将打印当前配置的主机名。当您传递主机名时，它将被移交给 NetworkManager 以设置为新的系统主机名。

Note that the term "system" hostname may also be referred to as "persistent" or "static" by other programs or tools. The hostname is stored in /etc/hostname file in most distributions. For example, systemd-hostnamed service uses the term "static" hostname and it only reads the /etc/hostname file when it starts.

# 查看主机名
[root@localhost ~]# nmcli general hostname
localhost.localdomain
# 修改主机名
[root@localhost ~]# nmcli general hostname rocky
[root@localhost ~]# nmcli general hostname
rocky

permissions

显示调用者（当前用户）对 NetworkManager 提供的各种经过身份验证的操作拥有的权限，例如启用和禁用网络、更改 Wi-Fi 和 WWAN 状态、修改连接等。

[root@localhost ~]# nmcli general permissions
PERMISSION                                                        VALUE
org.freedesktop.NetworkManager.checkpoint-rollback                yes
org.freedesktop.NetworkManager.enable-disable-connectivity-check  yes
org.freedesktop.NetworkManager.enable-disable-network             yes
org.freedesktop.NetworkManager.enable-disable-statistics          yes
org.freedesktop.NetworkManager.enable-disable-wifi                yes
org.freedesktop.NetworkManager.enable-disable-wimax               yes
org.freedesktop.NetworkManager.enable-disable-wwan                yes
org.freedesktop.NetworkManager.network-control                    yes
org.freedesktop.NetworkManager.reload                             yes
org.freedesktop.NetworkManager.settings.modify.global-dns         yes
org.freedesktop.NetworkManager.settings.modify.hostname           yes
org.freedesktop.NetworkManager.settings.modify.own                yes
org.freedesktop.NetworkManager.settings.modify.system             yes
org.freedesktop.NetworkManager.sleep-wake                         yes
org.freedesktop.NetworkManager.wifi.scan                          yes
org.freedesktop.NetworkManager.wifi.share.open                    yes
org.freedesktop.NetworkManager.wifi.share.protected               yes

logging

logging [level level] [domains domains...]

获取和更改 NetworkManager 日志记录级别和域。如果没有任何参数，则会显示当前日志记录级别和域。为了更改日志记录状态，请提供 level 和/或 domain 参数。有关可用 level 和 domain 值，请参阅 NetworkManager.conf(5)。

1
2
3

[root@localhost ~]# nmcli general logging
LEVEL  DOMAINS
INFO   PLATFORM,RFKILL,ETHER,WIFI,BT,MB,DHCP4,DHCP6,PPP,IP4,IP6,AUTOIP4,DNS,VPN,SHARING,SUPPLICANT,AGENTS,SETTINGS,SUSPEND,CORE,DEVICE,OLPC,INFINIBAND,FIREWALL,ADSL,BOND,VLAN,BRIDGE,TEAM,CONCHECK,DCB,DISPATCH,AUDIT,SYSTEMD,PROXY

reload

reload [flags...]

重新加载 NetworkManager 的配置并执行某些更新，例如刷新缓存或将外部状态重写到磁盘。这类似于向 NetworkManager 发送 SIGHUP，但它允许通过 flags 参数对重新加载的内容进行更细粒度的控制。它还允许通过 PolicyKit 进行非 root 访问，并且与信号相反，它是同步的。可用的 flags 有：

conf：从磁盘重新加载 NetworkManager.conf 配置。请注意，这不包括连接，可以通过 nmcli connection reload 来重新加载连接。
dns-rc：更新 DNS 配置，这通常涉及重新编写 /etc/resolv.conf。这相当于向 NetworkManager 进程发送 SIGUSR1 信号。
dns-full：重新启动 DNS 插件。例如，当使用 dnsmasq 插件时，这非常有用，该插件使用 /etc/NetworkManager/dnsmasq.d 中的附加配置。如果编辑这些文件，则可以重新启动 DNS 插件。此操作会很快中断名称解析。

如果没有指定 flags，所有支持的内容都会重新加载，这与发送 SIGHUP 相同。有关信号的更多详细信息，请参阅 NetworkManager(8)。

1	[root@localhost ~]# nmcli general reload conf

网络控制命令（Networking Control Commands）

查询 NetworkManager 网络状态，启用和禁用网络。

on, off

通过 NetworkManager 启用或禁用网络控制。当网络被禁用时，由 NetworkManager 管理的所有接口都将被停用。

禁用网络控制：

[root@localhost ~]# nmcli device status
DEVICE  TYPE      STATE      CONNECTION
ens32   ethernet  connected  ens32
ens33   ethernet  connected  ens33
ens34   ethernet  connected  ens34
lo      loopback  unmanaged  --
[root@localhost ~]# nmcli connection show
NAME   UUID                                  TYPE      DEVICE
ens32  e1af3066-1f0e-44a5-a4a3-c0174cf77a7b  ethernet  ens32
ens33  51b34523-8ea7-48f2-84c0-11d3f9aa828f  ethernet  ens33
ens34  84377dc9-3ec0-4573-925e-d3678801da6d  ethernet  ens34
[root@localhost ~]# nmcli networking connectivity check
full
[root@localhost ~]# nmcli networking off
[root@localhost ~]# nmcli connection show
NAME   UUID                                  TYPE      DEVICE
ens32  e1af3066-1f0e-44a5-a4a3-c0174cf77a7b  ethernet  --
ens33  51b34523-8ea7-48f2-84c0-11d3f9aa828f  ethernet  --
ens34  84377dc9-3ec0-4573-925e-d3678801da6d  ethernet  --
[root@localhost ~]# nmcli device status
DEVICE  TYPE      STATE      CONNECTION
ens32   ethernet  unmanaged  --
ens33   ethernet  unmanaged  --
ens34   ethernet  unmanaged  --
lo      loopback  unmanaged  --

启用网络控制：

[root@localhost ~]# nmcli networking on
[root@localhost ~]# nmcli connection show
NAME   UUID                                  TYPE      DEVICE
ens32  e1af3066-1f0e-44a5-a4a3-c0174cf77a7b  ethernet  ens32
ens33  51b34523-8ea7-48f2-84c0-11d3f9aa828f  ethernet  ens33
ens34  84377dc9-3ec0-4573-925e-d3678801da6d  ethernet  ens34
[root@localhost ~]# nmcli device status
DEVICE  TYPE      STATE      CONNECTION
ens32   ethernet  connected  ens32
ens33   ethernet  connected  ens33
ens34   ethernet  connected  ens34
lo      loopback  unmanaged  --

connectivity

connectivity [check]

获取网络连接状态。可选的 check 参数告诉 NetworkManager 重新检查连接，否则将显示最新的已知连接状态而不重新检查。

可能的状态有：

none：主机未连接到任何网络。
portal：主机位于强制门户后面，无法访问完整的互联网。
limited：主机已连接到网络，但无法访问 Internet。
full：主机已连接到网络并具有对 Internet 的完全访问权限。
unknown：无法查到连接状态。

[root@localhost ~]# nmcli networking connectivity
full
[root@localhost ~]# nmcli networking connectivity check
full

设备管理命令（Device Management Commands）

显示和管理网络接口。

nmcli device 按 tab 两下可以获取 device 后面的参数：

1
2
3

[root@localhost ~]# nmcli device
checkpoint  delete      down        lldp        monitor     set         status      wifi
connect     disconnect  help        modify      reapply     show        up

网卡属于物理硬件，NetworkManager 属于软件层面，如何通过软件层面给网卡绑定 IP 地址等信息？中间有一个核心：kernel。Linux 应用层 app 通过 kernel 来驱使底层物理硬件运行，同时必须要明确一点：软件应用没办法改变物理底层信息。

例如我们给 eth0 配置 IP 地址为 192.168.1.1。实质上并不是用刀在 eth0 网卡上刻上 192.168.1.1，实际上是 kernel 获取 eth0 网卡总线，同时将该总线命名（方便人为区分），然后 NetworkManager 告诉 kernel 00:00.0（假设 eth0）的 IP 地址是 192.168.1.1/24，那么以后访问 192.168.1.1 就是在访问 00:00.0，kernel 在中间做了一次转换或者说是绑定。

[root@localhost ~]# lshw -class net -businfo
Bus info          Device      Class      Description
====================================================
pci@0000:02:00.0  ens32       network    82545EM Gigabit Ethernet Controller (Copper)
pci@0000:02:01.0  ens33       network    82545EM Gigabit Ethernet Controller (Copper)
pci@0000:02:02.0  ens34       network    82545EM Gigabit Ethernet Controller (Copper)
[root@localhost ~]# lspci
00:00.0 Host bridge: Intel Corporation 440BX/ZX/DX - 82443BX/ZX/DX Host bridge (rev 01)
00:01.0 PCI bridge: Intel Corporation 440BX/ZX/DX - 82443BX/ZX/DX AGP bridge (rev 01)
00:07.0 ISA bridge: Intel Corporation 82371AB/EB/MB PIIX4 ISA (rev 08)
00:07.1 IDE interface: Intel Corporation 82371AB/EB/MB PIIX4 IDE (rev 01)
00:07.3 Bridge: Intel Corporation 82371AB/EB/MB PIIX4 ACPI (rev 08)
00:07.7 System peripheral: VMware Virtual Machine Communication Interface (rev 10)
...

00:00.0 就是总线。

status

打印设备状态。如果未向 nmcli device 指定子命令，则这是默认操作。

[root@localhost ~]# nmcli device
DEVICE  TYPE      STATE         CONNECTION
ens32   ethernet  connected     ens32
ens33   ethernet  connected     ens33
ens34   ethernet  disconnected  --
lo      loopback  unmanaged     --
[root@localhost ~]# nmcli device status
DEVICE  TYPE      STATE         CONNECTION
ens32   ethernet  connected     ens32
ens33   ethernet  connected     ens33
ens34   ethernet  disconnected  --
lo      loopback  unmanaged     --

DEVICE：表示网卡的名称（kernel 获取的标识）
TYPE：表示网卡的类型
STATE：表示网卡与配置文件的连接状态
- connected：表示 NetworkManager 接管
- disconnected：表示使用 NetworkManager 管理
- unmanaged：表示不使用 NetworkManager 管理

CONNECTION：网卡对应的 connection 配置文件名称

connection 配置文件名可以通过 "nmcli connection modify uuid xxxxxxxxx con-name xxx" 来修改：

[root@localhost ~]# nmcli device status
DEVICE  TYPE      STATE         CONNECTION
ens32   ethernet  connected     ens32
ens33   ethernet  connected     ens33
ens34   ethernet  disconnected  --
lo      loopback  unmanaged     --
[root@localhost ~]# nmcli connection show
NAME   UUID                                  TYPE      DEVICE
ens32  e1af3066-1f0e-44a5-a4a3-c0174cf77a7b  ethernet  ens32
ens33  51b34523-8ea7-48f2-84c0-11d3f9aa828f  ethernet  ens33
# 修改 connection 配置文件名
#[root@localhost ~]# nmcli connection modify ens32 con-name eth0
[root@localhost ~]# nmcli connection modify uuid e1af3066-1f0e-44a5-a4a3-c0174cf77a7b con-name eth0
[root@localhost ~]# nmcli connection show
NAME   UUID                                  TYPE      DEVICE
eth0   e1af3066-1f0e-44a5-a4a3-c0174cf77a7b  ethernet  ens32
ens33  51b34523-8ea7-48f2-84c0-11d3f9aa828f  ethernet  ens33
[root@localhost ~]# nmcli device status
DEVICE  TYPE      STATE         CONNECTION
ens32   ethernet  connected     eth0
ens33   ethernet  connected     ens33
ens34   ethernet  disconnected  --
lo      loopback  unmanaged     --

这里演示的就是将网卡 ens32 的配置文件由 nmcli device status 看到的 "ens32" 名称修改成 "eth0"（网卡的配置文件通过 nmcli connection 来修改的）。

nmcli connection show 可以看到各个配置文件对应的唯一识别 uuid，nmcli connection show 输出中 NAME 是配置文件名，后面的 DEVICE 是配置文件对应的网卡名称，配置文件名 NAME 是可以修改的，而 DEVICE 是 kernel 标识的，但是也可以通过其他手段来修改。

show

show [ifname]

（1）若不加任何参数，则会显示所有的网卡的信息。

[root@localhost ~]# nmcli device status
DEVICE  TYPE      STATE         CONNECTION
ens32   ethernet  connected     ens32
ens33   ethernet  connected     ens33
ens34   ethernet  disconnected  --
lo      loopback  unmanaged     --

（2）若加上 DEVICE 名称，则显示 DEVICE 对应网卡的所有信息。

[root@localhost ~]# nmcli device show ens34
GENERAL.DEVICE:                         ens34
GENERAL.TYPE:                           ethernet
GENERAL.HWADDR:                         00:0C:29:66:3F:D9
GENERAL.MTU:                            1500
GENERAL.STATE:                          30 (disconnected)
GENERAL.CONNECTION:                     --
GENERAL.CON-PATH:                       --
WIRED-PROPERTIES.CARRIER:               on
IP4.GATEWAY:                            --
IP6.GATEWAY:                            --

因为网卡 ens34 没有关联 connection，所以显示的信息相对少。

[root@localhost ~]# nmcli device show ens32
GENERAL.DEVICE:                         ens32
GENERAL.TYPE:                           ethernet
GENERAL.HWADDR:                         00:0C:29:66:3F:C5
GENERAL.MTU:                            1500
GENERAL.STATE:                          100 (connected)
GENERAL.CONNECTION:                     ens32
GENERAL.CON-PATH:                       /org/freedesktop/NetworkManager/ActiveConnection/4
WIRED-PROPERTIES.CARRIER:               on
IP4.ADDRESS[1]:                         192.168.0.25/24
IP4.GATEWAY:                            192.168.0.1
IP4.ROUTE[1]:                           dst = 192.168.0.0/24, nh = 0.0.0.0, mt = 100
IP4.ROUTE[2]:                           dst = 0.0.0.0/0, nh = 192.168.0.1, mt = 100
IP4.DNS[1]:                             114.114.114.114
IP4.DNS[2]:                             8.8.8.8
IP6.ADDRESS[1]:                         fe80::20c:29ff:fe66:3fc5/64
IP6.GATEWAY:                            --
IP6.ROUTE[1]:                           dst = fe80::/64, nh = ::, mt = 1024

因为网卡 ens32 关联了 connection 配置文件，可以看到 DEVICE 网卡名 ens32，TYPE 使用的网络类型为 ethernet， HWADDR 硬件地址 00:0C:29:66:3F:C5，还有 MTU、STATE（连接状态，connected）、CONNECTION ens32，这与 nmcli device status 看到的基本一致，接下来的 IP4.ADDRESS、IP4.GATEWAY 等等都是写到配置文件中的内容。

delete

delete ifname...

删除设备。该命令从系统中删除该接口。需要注意的是这仅适用于软件设备（如网桥、虚拟网卡），物理网卡等硬件设备是无法通过该命令删除的，不可能说 nmcli device delete ens32 就会物理地将网卡在计算机上拿走了。

# 尝试删除硬件设备
[root@localhost ~]# nmcli device delete ens32
Error: Device 'ens32' (/org/freedesktop/NetworkManager/Devices/2) deletion failed: This device is not a software device or is not realized
Error: not all devices deleted.

disconnect

disconnect ifname...

down 命令的别名。1.34.0 版本之前不支持。

断开网卡与 connection 配置文件之间的关联。

[root@localhost ~]# nmcli device status
DEVICE  TYPE      STATE         CONNECTION
ens32   ethernet  connected     ens32
ens33   ethernet  connected     ens33
ens34   ethernet  disconnected  --
lo      loopback  unmanaged     --
[root@localhost ~]# nmcli device disconnect ens33
Device 'ens33' successfully disconnected.
[root@localhost ~]# nmcli device status
DEVICE  TYPE      STATE         CONNECTION
ens32   ethernet  connected     ens32
ens33   ethernet  disconnected  --
ens34   ethernet  disconnected  --
lo      loopback  unmanaged     --

connect

将网卡与 connection 配置文件之间关联起来。

[root@localhost ~]# nmcli device status
DEVICE  TYPE      STATE         CONNECTION
ens32   ethernet  connected     ens32
ens33   ethernet  disconnected  --
ens34   ethernet  disconnected  --
lo      loopback  unmanaged     --
[root@localhost ~]# nmcli device connect ens33
Device 'ens33' successfully activated with '51b34523-8ea7-48f2-84c0-11d3f9aa828f'.
[root@localhost ~]# nmcli device status
DEVICE  TYPE      STATE         CONNECTION
ens32   ethernet  connected     ens32
ens33   ethernet  connected     ens33
ens34   ethernet  disconnected  --
lo      loopback  unmanaged     --

monitor

监控设备活动。每当指定设备更改状态时，此命令都会打印一行。

在未指定接口的情况下将监视所有设备。当所有指定的设备消失时，监视器终止。如果要监视添加的设备，请考虑使用带有 nmcli monitor 命令的全局监视器。

1	[root@localhost ~]# nmcli device monitor ens32

连接管理命令（Connection Management Commands）

NetworkManager 将所有网络配置存储为 "connections"，它们是描述如何创建或连接到网络的数据集合（第 2 层详细信息、IP 寻址等）。当设备使用该连接的配置来创建或连接到网络时，该连接处于 "active" 状态。一个设备可能有多个连接，但在任何给定时间，该设备上只能有一个处于活动状态。其余连接可用于允许在不同网络和配置之间快速切换。

考虑一台通常连接到启用 DHCP 的网络，但有时连接到使用静态 IP 寻址的测试网络的计算机。无需在每次网络更改时手动重新配置 eth0，这些设置可以保存为两个都适用于 eth0 的连接，一个用于 DHCP（称为 default），另一个具有静态寻址详细信息（称为 testing）。当连接到启用 DHCP 的网络时，用户将运行 nmcli con up default，而当连接到静态网络时，用户将运行 nmcli con up testing。

1
2
3

[root@localhost ~]# nmcli connection
add      delete   edit     help     load     modify   reload   up
clone    down     export   import   migrate  monitor  show

nmcli connection 主要用来处理 connection 配置文件信息。

The connection is identified by its name, UUID or D-Bus path. If ID is ambiguous, a keyword id, uuid, path or apath can be used.
id, uuid, path and apath keywords can be used if ID is ambiguous. Optional ID-specifying keywords are:
id the ID denotes a connection name.
uuid the ID denotes a connection UUID.
path the ID denotes a D-Bus static connection path in the format of /org/freedesktop/NetworkManager/Settings/num or just num.
apath the ID denotes a D-Bus active connection path in the format of /org/freedesktop/NetworkManager/ActiveConnection/num or just num.

show

show 有两种用法，分别是：

（1）列出活动的连接，或进行排序（+-为升降序）

show [--active] [ --order [+-]category:... ]

[root@localhost ~]# nmcli connection show
NAME   UUID                                  TYPE      DEVICE
ens32  e1af3066-1f0e-44a5-a4a3-c0174cf77a7b  ethernet  ens32
ens33  51b34523-8ea7-48f2-84c0-11d3f9aa828f  ethernet  ens33
[root@localhost ~]# nmcli connection show --order +active
NAME   UUID                                  TYPE      DEVICE
ens32  e1af3066-1f0e-44a5-a4a3-c0174cf77a7b  ethernet  ens32
ens33  51b34523-8ea7-48f2-84c0-11d3f9aa828f  ethernet  ens33
[root@localhost ~]# nmcli connection show --order -name
NAME   UUID                                  TYPE      DEVICE
ens33  51b34523-8ea7-48f2-84c0-11d3f9aa828f  ethernet  ens33
ens32  e1af3066-1f0e-44a5-a4a3-c0174cf77a7b  ethernet  ens32

NAME：配置文件的名称（可以重复）
UUID：唯一识别
TYPE：网络类型
DEVICE：网卡名称（这里与 nmcli device 保持一致）

（2）查看指定连接的详细信息

show [--active] [ id | uuid | path | apath ] ID...

[root@localhost ~]# nmcli connection show ens32
connection.id:                          ens32
connection.uuid:                        e1af3066-1f0e-44a5-a4a3-c0174cf77a7b
...

add

add [save { yes | no }] { option value | [+|-]setting.property value } ...

添加 connection 配置文件（注意网卡只有一个 connection 配置文件是活动的，但是可以存在多个 connection 配置文件，可以通过connection.autoconnect-priority 设置 connection 配置文件的优先级）。

add 后面必须跟的三个参数：

con-name：配置文件的名称
ifname：网卡的名称
type：网卡类型一般是 ethernet

add 还可以跟很多参数，比如：

ipv4.address
ipv4.gateway
ipv4.dns
ipv4.method（设置自动连接还是手动连接 auto manual 等等）
connection.autoconnect（开机是否自动连接）

[root@localhost ~]# nmcli device status
DEVICE  TYPE      STATE         CONNECTION
ens32   ethernet  connected     ens32
ens33   ethernet  connected     ens33
ens34   ethernet  disconnected  --
lo      loopback  unmanaged     --
[root@localhost ~]# nmcli connection show
NAME   UUID                                  TYPE      DEVICE
ens32  e1af3066-1f0e-44a5-a4a3-c0174cf77a7b  ethernet  ens32
ens33  51b34523-8ea7-48f2-84c0-11d3f9aa828f  ethernet  ens33
[root@localhost ~]# nmcli connection add con-name ens34 ifname ens34 type ethernet ipv4.address 192.168.0.27/24 ipv4.gateway 192.168.0.1 ipv4.dns 114.114.114.114,8.8.8.8 ipv4.method manual connection.autoconnect yes
Connection 'ens34' (b713041f-bfb5-45ce-a8da-21ad02361e81) successfully added.
[root@localhost ~]# nmcli connection show
NAME   UUID                                  TYPE      DEVICE
ens32  e1af3066-1f0e-44a5-a4a3-c0174cf77a7b  ethernet  ens32
ens33  51b34523-8ea7-48f2-84c0-11d3f9aa828f  ethernet  ens33
ens34  b713041f-bfb5-45ce-a8da-21ad02361e81  ethernet  ens34
[root@localhost ~]# nmcli device status
DEVICE  TYPE      STATE      CONNECTION
ens32   ethernet  connected  ens32
ens33   ethernet  connected  ens33
ens34   ethernet  connected  ens34
lo      loopback  unmanaged  --

如果在 add 添加 connection 配置文件时没有指定 ipv4.method 则 Linux 会自动获取 IP 地址，即 DHCP。

[root@localhost ~]# ip address show ens34
4: ens34:  mtu 1500 qdisc fq_codel state UP group default qlen 1000
    link/ether 00:0c:29:66:3f:d9 brd ff:ff:ff:ff:ff:ff
    inet 192.168.0.27/24 brd 192.168.0.255 scope global noprefixroute ens34
       valid_lft forever preferred_lft forever
    inet6 fe80::2b44:f9e6:43f9:6c05/64 scope link noprefixroute
       valid_lft forever preferred_lft forever
[root@localhost ~]# nmcli connection show ens34 | grep "ipv4."
ipv4.method:                            manual
ipv4.dns:                               114.114.114.114,8.8.8.8
ipv4.dns-search:                        --
ipv4.dns-options:                       --
ipv4.dns-priority:                      0
ipv4.addresses:                         192.168.0.27/24
ipv4.gateway:                           192.168.0.1
...

delete

delete [ id | uuid | path ] ID...

删除 connection 配置文件。

[root@localhost ~]# nmcli device status
DEVICE  TYPE      STATE      CONNECTION
ens32   ethernet  connected  ens32
ens33   ethernet  connected  ens33
ens34   ethernet  connected  ens34
lo      loopback  unmanaged  --
[root@localhost ~]# nmcli connection show
NAME   UUID                                  TYPE      DEVICE
ens32  e1af3066-1f0e-44a5-a4a3-c0174cf77a7b  ethernet  ens32
ens33  51b34523-8ea7-48f2-84c0-11d3f9aa828f  ethernet  ens33
ens34  b713041f-bfb5-45ce-a8da-21ad02361e81  ethernet  ens34
#[root@localhost ~]# nmcli connection delete uuid b713041f-bfb5-45ce-a8da-21ad02361e81
[root@localhost ~]# nmcli connection delete ens34
Connection 'ens34' (b713041f-bfb5-45ce-a8da-21ad02361e81) successfully deleted.
[root@localhost ~]# nmcli connection show
NAME   UUID                                  TYPE      DEVICE
ens32  e1af3066-1f0e-44a5-a4a3-c0174cf77a7b  ethernet  ens32
ens33  51b34523-8ea7-48f2-84c0-11d3f9aa828f  ethernet  ens33
[root@localhost ~]# nmcli device status
DEVICE  TYPE      STATE         CONNECTION
ens32   ethernet  connected     ens32
ens33   ethernet  connected     ens33
ens34   ethernet  disconnected  --
lo      loopback  unmanaged     --

down

down [ id | uuid | path | apath ] ID...

down 不同于 delete，delete 是将 connection 配置文件删除，而 down 是将 connection 配置文件与网卡的关联断开，与 nmcli device disconnect 效果相同。

[root@localhost ~]# nmcli device status
DEVICE  TYPE      STATE         CONNECTION
ens32   ethernet  connected     ens32
ens33   ethernet  connected     ens33
ens34   ethernet  disconnected  --
lo      loopback  unmanaged     --
[root@localhost ~]# nmcli connection show
NAME   UUID                                  TYPE      DEVICE
ens32  e1af3066-1f0e-44a5-a4a3-c0174cf77a7b  ethernet  ens32
ens33  51b34523-8ea7-48f2-84c0-11d3f9aa828f  ethernet  ens33
[root@localhost ~]# nmcli connection down ens33
Connection 'ens33' successfully deactivated (D-Bus active path: /org/freedesktop/NetworkManager/ActiveConnection/7)
[root@localhost ~]# nmcli connection show
NAME   UUID                                  TYPE      DEVICE
ens32  e1af3066-1f0e-44a5-a4a3-c0174cf77a7b  ethernet  ens32
ens33  51b34523-8ea7-48f2-84c0-11d3f9aa828f  ethernet  --
[root@localhost ~]# nmcli device status
DEVICE  TYPE      STATE         CONNECTION
ens32   ethernet  connected     ens32
ens33   ethernet  disconnected  --
ens34   ethernet  disconnected  --
lo      loopback  unmanaged     --

modify

modify [--temporary] [ id | uuid | path ] [ID] { option value | [+|-]setting.property value } ...

修改 connection 配置文件信息。

[root@localhost ~]# nmcli connection show
NAME   UUID                                  TYPE      DEVICE
ens32  e1af3066-1f0e-44a5-a4a3-c0174cf77a7b  ethernet  ens32
ens33  51b34523-8ea7-48f2-84c0-11d3f9aa828f  ethernet  --
[root@localhost ~]# nmcli connection add con-name ens34 ifname ens34 type ethernet ipv4.address 192.168.0.27/24 ipv4.gateway 192.168.0.1 ipv4.dns 114.114.114.114,8.8.8.8 ipv4.method manual connection.autoconnect yes
Connection 'ens34' (a0af5eea-3e83-4c13-8104-42857958e050) successfully added.
[root@localhost ~]# nmcli connection show
NAME   UUID                                  TYPE      DEVICE
ens32  e1af3066-1f0e-44a5-a4a3-c0174cf77a7b  ethernet  ens32
ens34  a0af5eea-3e83-4c13-8104-42857958e050  ethernet  ens34
ens33  51b34523-8ea7-48f2-84c0-11d3f9aa828f  ethernet  --
[root@localhost ~]# ip address show ens34
4: ens34:  mtu 1500 qdisc fq_codel state UP group default qlen 1000
    link/ether 00:0c:29:66:3f:d9 brd ff:ff:ff:ff:ff:ff
    inet 192.168.0.27/24 brd 192.168.0.255 scope global noprefixroute ens34
       valid_lft forever preferred_lft forever
    inet6 fe80::1e7c:8628:7c62:c15b/64 scope link noprefixroute
       valid_lft forever preferred_lft forever
[root@localhost ~]# nmcli connection modify ens34 ifname ens34 ipv4.address 192.168.0.28/24
[root@localhost ~]# ip address show ens34
4: ens34:  mtu 1500 qdisc fq_codel state UP group default qlen 1000
    link/ether 00:0c:29:66:3f:d9 brd ff:ff:ff:ff:ff:ff
    inet 192.168.0.27/24 brd 192.168.0.255 scope global noprefixroute ens34
       valid_lft forever preferred_lft forever
    inet6 fe80::1e7c:8628:7c62:c15b/64 scope link noprefixroute
       valid_lft forever preferred_lft forever

这里之所以没有变化是因为我们修改的是硬盘配置文件，加载在内存中 ens34 配置文件的地址还是 192.168.0.27，所以我们需要将修改后的硬盘配置文件 ens34 加载到内存中。

[root@localhost ~]# nmcli connection up ens34
Connection successfully activated (D-Bus active path: /org/freedesktop/NetworkManager/ActiveConnection/12)
[root@localhost ~]# ip address show ens34
4: ens34:  mtu 1500 qdisc fq_codel state UP group default qlen 1000
    link/ether 00:0c:29:66:3f:d9 brd ff:ff:ff:ff:ff:ff
    inet 192.168.0.28/24 brd 192.168.0.255 scope global noprefixroute ens34
       valid_lft forever preferred_lft forever
    inet6 fe80::7505:8bb3:79c2:b265/64 scope link noprefixroute
       valid_lft forever preferred_lft forever

有时候 up 无法改变网卡地址，这时候我们需要 reload 重新连接启动，重新加载到内存中。

up

up [ id | uuid | path ] ID [ifname ifname] [ap BSSID] [passwd-file file]

激活 connection。将网卡与 connection 配置文件关联起来。

[root@localhost ~]# nmcli device status
DEVICE  TYPE      STATE         CONNECTION
ens32   ethernet  connected     ens32
ens34   ethernet  connected     ens34
ens33   ethernet  disconnected  --
lo      loopback  unmanaged     --
[root@localhost ~]# nmcli connection show
NAME   UUID                                  TYPE      DEVICE
ens32  e1af3066-1f0e-44a5-a4a3-c0174cf77a7b  ethernet  ens32
ens34  a0af5eea-3e83-4c13-8104-42857958e050  ethernet  ens34
ens33  51b34523-8ea7-48f2-84c0-11d3f9aa828f  ethernet  --
[root@localhost ~]# nmcli connection up ens33
Connection successfully activated (D-Bus active path: /org/freedesktop/NetworkManager/ActiveConnection/10)
[root@localhost ~]# nmcli connection show
NAME   UUID                                  TYPE      DEVICE
ens32  e1af3066-1f0e-44a5-a4a3-c0174cf77a7b  ethernet  ens32
ens33  51b34523-8ea7-48f2-84c0-11d3f9aa828f  ethernet  ens33
ens34  a0af5eea-3e83-4c13-8104-42857958e050  ethernet  ens34
[root@localhost ~]# nmcli device status
DEVICE  TYPE      STATE      CONNECTION
ens32   ethernet  connected  ens32
ens33   ethernet  connected  ens33
ens34   ethernet  connected  ens34
lo      loopback  unmanaged  --

clone

clone [--temporary] [ id | uuid | path ] ID new_name

克隆 connection 配置文件，除了连接名称和 uuid 是新生成的，其他都是一样的。

[root@localhost ~]# nmcli connection show
NAME   UUID                                  TYPE      DEVICE
ens32  e1af3066-1f0e-44a5-a4a3-c0174cf77a7b  ethernet  ens32
ens33  51b34523-8ea7-48f2-84c0-11d3f9aa828f  ethernet  ens33
ens34  a0af5eea-3e83-4c13-8104-42857958e050  ethernet  ens34
[root@localhost ~]# nmcli connection clone ens34 ens35
ens34 (a0af5eea-3e83-4c13-8104-42857958e050) cloned as ens35 (0ff07cb2-a9a8-4d68-8ad8-46096657cb41).
[root@localhost ~]# nmcli connection show
NAME   UUID                                  TYPE      DEVICE
ens32  e1af3066-1f0e-44a5-a4a3-c0174cf77a7b  ethernet  ens32
ens33  51b34523-8ea7-48f2-84c0-11d3f9aa828f  ethernet  ens33
ens34  a0af5eea-3e83-4c13-8104-42857958e050  ethernet  ens34
ens35  0ff07cb2-a9a8-4d68-8ad8-46096657cb41  ethernet  --

load

load filename...

从磁盘加载/重新加载一个或多个 connection 配置文件。手动编辑连接文件后使用此命令可确保 NetworkManager 了解其最新状态。

[root@localhost ~]# ls /etc/sysconfig/network-scripts/
ifcfg-ens32  ifcfg-ens33
[root@localhost ~]# nmcli connection show
NAME   UUID                                  TYPE      DEVICE
ens32  e1af3066-1f0e-44a5-a4a3-c0174cf77a7b  ethernet  ens32
[root@localhost ~]# nmcli connection load /etc/sysconfig/network-scripts/ifcfg-ens33
[root@localhost ~]# nmcli connection show
NAME   UUID                                  TYPE      DEVICE
ens32  e1af3066-1f0e-44a5-a4a3-c0174cf77a7b  ethernet  ens32
ens33  84f8195b-1a23-44a7-b9a2-2a5a25fd777b  ethernet  --

无线传输控制命令（Radio Transmission Control Commands）

显示无线开关状态，或启用和禁用开关。

nmcli radio { all | wifi | wwan } [ARGUMENTS...]

[root@localhost ~]# nmcli radio all
WIFI-HW  WIFI     WWAN-HW  WWAN
missing  enabled  missing  enabled
[root@localhost ~]# nmcli radio all off
[root@localhost ~]# nmcli radio all
WIFI-HW  WIFI      WWAN-HW  WWAN
missing  disabled  missing  disabled
[root@localhost ~]# nmcli radio wifi on
[root@localhost ~]# nmcli radio all
WIFI-HW  WIFI     WWAN-HW  WWAN
missing  enabled  missing  disabled
[root@localhost ~]# nmcli radio wwan on
[root@localhost ~]# nmcli radio all
WIFI-HW  WIFI     WWAN-HW  WWAN
missing  enabled  missing  enabled

活动监视器（Activity Monitor）

观察 NetworkManager 活动。监视连接状态、设备或连接配置文件的变化。

另请参阅 nmcli connection monitor 和 nmcli device monitor 以监视某些设备或连接的变化。

退出状态码

nmcli 如果成功退出状态值为 0，如果发生错误则返回大于 0 的值。

0: 成功-指示操作已成功
1: 位置或指定的错误
2: 无效的用户输入，错误的nmcli调用
3: 超时了（请参阅 --wait 选项）
4: 连接激活失败
5: 连接停用失败
6: 断开设备失败
7: 连接删除失败
8: 网络管理器没有运行
10: 连接、设备或接入点不存在
65: 当使用 --complete-args 选项，文件名应遵循。

nmcli 示例

本节介绍 nmcli 用法的各种示例。如果您想要更多信息，请参阅 nmcli-examples(7) 手册页。

nmcli -t -f RUNNING general
告诉你 NetworkManager 是否正在运行。
nmcli -t -f STATE general
显示 NetworkManager 的整体状态。
nmcli radio wifi off
关闭 Wi-Fi。
nmcli connection show
列出 NetworkManager 拥有的所有连接。
nmcli -p -m multiline -f all con show
以多行模式显示所有已配置的连接。
nmcli connection show --active
列出所有当前活动的连接。
nmcli -f name,autoconnect c s
显示所有连接配置文件名称及其自动连接属性。
nmcli -p connection show "My default em1"
显示 "My default em1" 连接配置文件的详细信息。
nmcli --show-secrets connection show "My Home Wi-Fi"
显示 "My Home Wi-Fi" 连接配置文件的详细信息以及所有密码。如果没有 --show-secrets 选项，则不会显示 secrets。
nmcli -f active connection show "My default em1"
显示 "My default em1" 活动连接的详细信息，例如 IP、DHCP 信息等。
nmcli -f profile con s "My wired connection"
显示名称为 "My wired connection" 的连接配置文件的静态配置详细信息。
nmcli -p con up "My wired connection" ifname eth0
激活接口 eth0 上名为 "My wired connection" 的连接配置文件。 -p 选项使 nmcli 显示激活进度。
nmcli con up 6b028a27-6dc9-4411-9886-e9ad1dd43761 ap 00:3A:98:7C:42:D3
将 UUID 6b028a27-6dc9-4411-9886-e9ad1dd43761 的 Wi-Fi 连接连接到 BSSID 00:3A:98:7C:42:D3 的 AP。
nmcli device status
显示所有设备的状态。
nmcli dev down em2
断开 em2 接口上的连接并将设备标记为不可自动连接。因此，在设备的 "autoconnect" 设置为 TRUE 或用户手动激活连接之前，设备上不会自动激活任何连接。
nmcli -f GENERAL,WIFI-PROPERTIES dev show wlan0
显示 wlan0 接口的详细信息；仅显示 GENERAL 和 WIFI-PROPERTIES 部分。
nmcli -f CONNECTIONS device show wlp3s0
显示 Wi-Fi 接口 wlp3s0 的所有可用连接配置文件。
nmcli dev wifi
列出 NetworkManager 已知的可用 Wi-Fi 接入点。
nmcli dev wifi con "Cafe Hotspot 1" password caffeine name "My cafe"
创建一个名为 "My cafe" 的新连接，然后使用密码 "caffeine" 将其连接到 "Cafe Hotspot 1" SSID。这主要在第一次连接到 "Cafe Hotspot 1" 时有用。下次，最好使用 nmcli con up id "My cafe"，以便可以使用现有的连接配置文件，而不会创建额外的连接配置文件。
nmcli -s dev wifi hotspot con-name QuickHotspot
创建热点配置文件并连接它。打印用户从其他设备连接到热点时应使用的热点密码。
nmcli dev modify em1 ipv4.method shared
使用 em1 设备启动 IPv4 连接共享。共享将一直有效，直到设备断开连接。
nmcli dev modify em1 ipv6.address 2001:db8::a:bad:c0de
临时向设备添加 IP 地址。当再次激活同一连接时，该地址将被删除。
nmcli connection add type ethernet autoconnect no ifname eth0
以非交互方式添加与具有自动 IP 配置 (DHCP) 的 eth0 接口绑定的以太网连接，并禁用该连接的 "autoconnect" 标志。
nmcli c a ifname Maxipes-fik type vlan dev eth0 id 55
以非交互方式添加 ID 为 55 的 VLAN 连接。该连接将使用 eth0，VLAN 接口将命名为 Maxipes-fik。
nmcli c a ifname eth0 type ethernet ipv4.method disabled ipv6.method link-local
以非交互方式添加将使用 eth0 以太网接口且仅配置了 IPv6 链路本地地址的连接。
nmcli connection edit ethernet-em1-2
在交互式编辑器中编辑现有的 "ethernet-em1-2" 连接。
nmcli connection edit type ethernet con-name "yet another Ethernet connection"
在交互式编辑器中添加新的以太网连接。
nmcli con mod ethernet-2 connection.autoconnect no
修改 "ethernet-2" 连接的 "connection" 设置中的 "autoconnect" 属性。
nmcli con mod "Home Wi-Fi" wifi.mtu 1350
修改 "Home Wi-Fi" 连接 "wifi" 的设置中的 "mtu" 属性。
nmcli con mod em1-1 ipv4.method manual ipv4.addr "192.168.1.23/24 192.168.1.1, 10.10.1.5/8, 10.0.0.11"
设置手动寻址和 em1-1 配置文件中的地址。
nmcli con modify ABC +ipv4.dns 8.8.8.8
将 Google 公共 DNS 服务器附加到 ABC 配置文件中的 DNS 服务器。
nmcli con modify ABC -ipv4.addresses "192.168.100.25/24 192.168.1.1"
从（静态）配置文件 ABC 中删除指定的 IP 地址。
nmcli con import type openvpn file ~/Downloads/frootvpn.ovpn
将 OpenVPN 配置导入 NetworkManager。
nmcli con export corp-vpnc /home/joe/corpvpn.conf
将 NetworkManager VPN 配置文件 corp-vpnc 导出为标准 Cisco (vpnc) 配置。

kafka 安装部署与安全认证

2023-07-29T10:22:39.000Z

本文介绍了如何在 Kafka 中实现身份验证和授权功能，具体使用了 JAAS（Java Authentication and Authorization Service）机制。在安装部署方面，需要先安装 JDK，并准备好一个 Zookeeper 环境。接着，按照下载、解压、编辑配置文件、配置 JAAS、创建服务、启动 Kafka 等步骤进行操作。最后，通过创建、查看、生产、消费、删除 topic 和查看消费群组等测试，验证了集群的正常运行。

kafka 安装部署与安全认证

Kafka JAAS（Java Authentication and Authorization Service）是一种用于 Apache Kafka 的身份验证和授权机制。JAAS 是 Java 平台的标准身份验证和授权框架，它提供了一种可插拔的方式来实现身份验证和授权功能。

Kafka JAAS 可以用于保护 Kafka 集群和客户端之间的通信安全。它允许管理员配置不同的身份验证机制，例如用户名/密码、Kerberos 或 SSL/TLS 证书等。通过 JAAS，Kafka 可以验证客户端的身份，并根据配置的授权策略来决定客户端是否有权访问特定的主题或执行特定的操作。

要使用 Kafka JAAS，您需要在 Kafka 服务器和客户端的配置文件中进行相应的配置。在服务器端，您可以配置 JAAS 模块来指定身份验证和授权的方式。在客户端，您需要提供与服务器端相匹配的 JAAS 配置，并在连接到 Kafka 集群时使用该配置。

总之，Kafka JAAS 提供了一种灵活且可扩展的方式来实现 Kafka 的身份验证和授权，以增强 Kafka 集群的安全性。

1. 安装 jdk

如果未安装 java 环境，请先执行以下命令安装 openjdk-1.8.0

1	yum -y install java-1.8.0-openjdk java-1.8.0-openjdk-devel

2. 设备环境

Kafka 集群环境搭建，需要准备好一个 zookeeper 环境（集群）

Host	IP	Port	OS	Software
saas_kafka_01.com	10.128.170.21	9092	CentOS 7.9.2009	kafka 2.13-2.8.1
saas_kafka_02.com	10.128.170.22	9092	CentOS 7.9.2009	kafka 2.13-2.8.1
saas_kafka_03.com	10.128.170.23	9092	CentOS 7.9.2009	kafka 2.13-2.8.1

说明：kafka 名中的 2.13 是 Scala 语言版本，后面的 2.8.1 是 kafka 版本，端口默认为 9092。

3. 安装步骤

3.1 下载 kafka

官网下载太慢，推荐使用国内镜像进行下载，清华镜像下载地址：

https://mirrors.tuna.tsinghua.edu.cn/apache/kafka

1	wget -c https://mirrors.tuna.tsinghua.edu.cn/apache/kafka/2.8.1/kafka_2.13-2.8.1.tgz

3.2 解压安装

这里解压至 /virus 目录：

1	tar -zxvf kafka_2.13-2.8.1.tgz -C /virus

3.3 编辑配置文件

进入 config 目录：

1	cd /virus/kafka_2.13-2.8.1/config/

备份原配置文件：

1	cp server.properties server.properties.bak

编辑配置文件：

1	vim server.properties

修改配置如下：

# Licensed to the Apache Software Foundation (ASF) under one or more
# contributor license agreements.  See the NOTICE file distributed with
# this work for additional information regarding copyright ownership.
# The ASF licenses this file to You under the Apache License, Version 2.0
# (the "License"); you may not use this file except in compliance with
# the License.  You may obtain a copy of the License at
#
#    http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.

# see kafka.server.KafkaConfig for additional details and defaults

############################# Server Basics #############################

# The id of the broker. This must be set to a unique integer for each broker.
broker.id=1

############################# Socket Server Settings #############################

# The address the socket server listens on. It will get the value returned from
# java.net.InetAddress.getCanonicalHostName() if not configured.
#   FORMAT:
#     listeners = listener_name://host_name:port
#   EXAMPLE:
#     listeners = PLAINTEXT://your.host.name:9092
#listeners=PLAINTEXT://:9092
listeners=SASL_PLAINTEXT://saas_kafka_01.com:9092
security.inter.broker.protocol=SASL_PLAINTEXT
sasl.enabled.mechanisms=PLAIN
sasl.mechanism.inter.broker.protocol=PLAIN
authorizer.class.name=kafka.security.auth.SimpleAclAuthorizer
super.users=User:admin

# Hostname and port the broker will advertise to producers and consumers. If not set,
# it uses the value for "listeners" if configured.  Otherwise, it will use the value
# returned from java.net.InetAddress.getCanonicalHostName().
#advertised.listeners=PLAINTEXT://your.host.name:9092

# Maps listener names to security protocols, the default is for them to be the same. See the config documentation for more details
#listener.security.protocol.map=PLAINTEXT:PLAINTEXT,SSL:SSL,SASL_PLAINTEXT:SASL_PLAINTEXT,SASL_SSL:SASL_SSL

# The number of threads that the server uses for receiving requests from the network and sending responses to the network
num.network.threads=3

# The number of threads that the server uses for processing requests, which may include disk I/O
num.io.threads=8

# The send buffer (SO_SNDBUF) used by the socket server
socket.send.buffer.bytes=102400000

# The receive buffer (SO_RCVBUF) used by the socket server
socket.receive.buffer.bytes=102400000

# The maximum size of a request that the socket server will accept (protection against OOM)
socket.request.max.bytes=104857600

message.max.bytes=200000000
message.fetch.max.bytes=200000000
fetch.message.max.bytes=200000000

############################# Log Basics #############################

# A comma separated list of directories under which to store log files
log.dirs=/saasdata/kafka/data

# The default number of log partitions per topic. More partitions allow greater
# parallelism for consumption, but this will also result in more files across
# the brokers.
num.partitions=1

# The number of threads per data directory to be used for log recovery at startup and flushing at shutdown.
# This value is recommended to be increased for installations with data dirs located in RAID array.
num.recovery.threads.per.data.dir=1

############################# Internal Topic Settings  #############################
# The replication factor for the group metadata internal topics "__consumer_offsets" and "__transaction_state"
# For anything other than development testing, a value greater than 1 is recommended to ensure availability such as 3.
offsets.topic.replication.factor=1
transaction.state.log.replication.factor=1
transaction.state.log.min.isr=1

############################# Log Flush Policy #############################

# Messages are immediately written to the filesystem but by default we only fsync() to sync
# the OS cache lazily. The following configurations control the flush of data to disk.
# There are a few important trade-offs here:
#    1. Durability: Unflushed data may be lost if you are not using replication.
#    2. Latency: Very large flush intervals may lead to latency spikes when the flush does occur as there will be a lot of data to flush.
#    3. Throughput: The flush is generally the most expensive operation, and a small flush interval may lead to excessive seeks.
# The settings below allow one to configure the flush policy to flush data after a period of time or
# every N messages (or both). This can be done globally and overridden on a per-topic basis.

# The number of messages to accept before forcing a flush of data to disk
#log.flush.interval.messages=10000

# The maximum amount of time a message can sit in a log before we force a flush
#log.flush.interval.ms=1000

############################# Log Retention Policy #############################

# The following configurations control the disposal of log segments. The policy can
# be set to delete segments after a period of time, or after a given size has accumulated.
# A segment will be deleted whenever *either* of these criteria are met. Deletion always happens
# from the end of the log.

# The minimum age of a log file to be eligible for deletion due to age
log.retention.hours=168

# A size-based retention policy for logs. Segments are pruned from the log unless the remaining
# segments drop below log.retention.bytes. Functions independently of log.retention.hours.
#log.retention.bytes=1073741824

# The maximum size of a log segment file. When this size is reached a new log segment will be created.
log.segment.bytes=1073741824

# The interval at which log segments are checked to see if they can be deleted according
# to the retention policies
log.retention.check.interval.ms=300000

############################# Zookeeper #############################

# Zookeeper connection string (see zookeeper docs for details).
# This is a comma separated host:port pairs, each corresponding to a zk
# server. e.g. "127.0.0.1:3000,127.0.0.1:3001,127.0.0.1:3002".
# You can also append an optional chroot string to the urls to specify the
# root directory for all kafka znodes.
zookeeper.connect=saas_kafka_01.com:2181,saas_kafka_02.com:2181,saas_kafka_03.com:2181

# Timeout in ms for connecting to zookeeper
zookeeper.connection.timeout.ms=18000


############################# Group Coordinator Settings #############################

# The following configuration specifies the time, in milliseconds, that the GroupCoordinator will delay the initial consumer rebalance.
# The rebalance will be further delayed by the value of group.initial.rebalance.delay.ms as new members join the group, up to a maximum of max.poll.interval.ms.
# The default value for this is 3 seconds.
# We override this to 0 here as it makes for a better out-of-the-box experience for development and testing.
# However, in production environments the default value of 3 seconds is more suitable as this will help to avoid unnecessary, and potentially expensive, rebalances during application startup.
group.initial.rebalance.delay.ms=0

replica.fetch.max.bytes=11240000

在 saas_kafka_02.com 和 saas_kafka_03.com 上进行同样的操作，不再赘述。

需要注意的是，broker.id 和 listeners 需要根据实际情况配置。

saas_kafka_01.com
- broker.id=1
- listeners=SASL_PLAINTEXT://saas_kafka_01.com:9092
saas_kafka_02.com
- broker.id=2
- listeners=SASL_PLAINTEXT://saas_kafka_02.com:9092
saas_kafka_03.com
- broker.id=3
- listeners=SASL_PLAINTEXT://saas_kafka_03.com:9092

3.4 配置 jaas

在 config 目录创建 kafka_jaas.conf 文件：

1	vim /virus/kafka_2.13-2.8.1/config/kafka_jaas.conf

添加如下内容：

KafkaServer {
    org.apache.kafka.common.security.plain.PlainLoginModule required
    username="admin"
    password="saas_kafka_root123"
    user_admin="saas_kafka_root123";
};

KafkaClient {
    org.apache.kafka.common.security.plain.PlainLoginModule required
    username="admin"
    password="saas_kafka_root123";
};

3.5 创建 system 服务

1	vim /usr/lib/systemd/system/kafka.service

添加如下内容：

[Unit]
Description=kafka service
After=network.target

[Service]
Type=forking
User=root
Group=root
Environment="JMX_PORT=9999"
Environment="KAFKA_OPTS=-Djava.security.auth.login.config=/virus/kafka_2.13-2.8.1/config/kafka_jaas.conf"
ExecStart=/virus/kafka_2.13-2.8.1/bin/kafka-server-start.sh -daemon /virus/kafka_2.13-2.8.1/config/server.properties
ExecStop= /virus/kafka_2.13-2.8.1/bin/kafka-server-stop.sh
Restart=always
RestartSec=1
StartLimitIntervalSec=0

[Install]
WantedBy=multi-user.target

3.6 启动 kafka

启动节点 saas_kafka_01.com，同样地启动节点 saas_kafka_02.com，saas_kafka_03.com

1	systemctl start kafka.service

查看 9092 端口状态，确保服务已经启动：

1	netstat -anptl \| grep 9092

3.7 查看集群状态

[root@saas_kafka_01.com bin]# cd /virus/apache-zookeeper-3.6.3-bin/bin/
[root@saas_kafka_01.com bin]# ./zkCli.sh -server saas_kafka_02.com
...
[zk: saas_kafka_02.com(CONNECTED) 0] ls /
[admin, brokers, cluster, config, consumers, controller, controller_epoch, feature, isr_change_notification, latest_producer_id_block, log_dir_event_notification, zookeeper]
[zk: saas_kafka_02.com(CONNECTED) 1] ls /brokers
[ids, seqid, topics]
[zk: saas_kafka_02.com(CONNECTED) 2] ls /brokers/ids
[1, 2, 3]

4. 集群测试

4.1 创建 topic

1	/virus/kafka_2.13-2.8.1/bin/kafka-topics.sh --create --zookeeper saas_kafka_01.com:2181 --replication-factor 3 --partitions 3 --topic google

4.2 查看 topic

1	/virus/kafka_2.13-2.8.1/bin/kafka-topics.sh --describe google --zookeeper saas_kafka_01.com:2181

4.3 生产消息

在 /virus/kafka_2.13-2.8.1/config/producer.properties 添加如下配置：

1 2	security.protocol=SASL_PLAINTEXT sasl.mechanism=PLAIN

生产消息：

[root@localhost ~]# export KAFKA_OPTS='-Djava.security.auth.login.config=/virus/kafka_2.13-2.8.1/config/kafka_jaas.conf'
[root@localhost ~]# /virus/kafka_2.13-2.8.1/bin/kafka-console-producer.sh --broker-list saas_kafka_01.com:9092 --topic google --producer.config /virus/kafka_2.13-2.8.1/config/producer.properties
>Apple
>Banana
>Cat
>Dog

4.4 消费消息

在 /virus/kafka_2.13-2.8.1/config/consumer.properties 添加如下配置：

1 2	security.protocol=SASL_PLAINTEXT sasl.mechanism=PLAIN

消费消息：

[root@localhost ~]# export KAFKA_OPTS='-Djava.security.auth.login.config=/virus/kafka_2.13-2.8.1/config/kafka_jaas.conf'
[root@localhost ~]# /virus/kafka_2.13-2.8.1/bin/kafka-console-consumer.sh --bootstrap-server saas_kafka_02.com:9092 --topic google --from-beginning --consumer.config /virus/kafka_2.13-2.8.1/config/consumer.properties
Banana
Apple
Dog
Cat

4.5 删除 topic

1
2
3

[root@localhost ~]# /virus/kafka_2.13-2.8.1/bin/kafka-topics.sh --list --zookeeper saas_kafka_01.com:2181
__consumer_offsets
google

1	[root@localhost ~]# /virus/kafka_2.13-2.8.1/bin/kafka-topics.sh --delete --zookeeper saas_kafka_01.com:2181 --topic google

4.6 查看消费群组

[root@localhost ~]# export KAFKA_OPTS='-Djava.security.auth.login.config=/virus/kafka_2.13-2.8.1/config/kafka_jaas.conf'
[root@localhost ~]# /virus/kafka_2.13-2.8.1/bin/kafka-consumer-groups.sh --bootstrap-server saas_kafka_01.com:9092 --list --command-config /virus/kafka_2.13-2.8.1/config/consumer.properties
[2022-03-04 01:32:26,611] WARN The configuration 'group.id' was supplied but isn't a known config. (org.apache.kafka.clients.admin.AdminClientConfig)
saasdc_asset_neo4j_group
efak.system.group
saasdc_asset_mongo_group

查看消费组详情：

[root@localhost ~]# /virus/kafka_2.13-2.8.1/bin/kafka-consumer-groups.sh --bootstrap-server saas_kafka_01.com:9092 --command-config /virus/kafka_2.13-2.8.1/config/consumer.properties --describe --group saasdc_asset_neo4j_group
[2022-03-04 01:45:41,039] WARN The configuration 'group.id' was supplied but isn't a known config. (org.apache.kafka.clients.admin.AdminClientConfig)

GROUP                    TOPIC              PARTITION  CURRENT-OFFSET  LOG-END-OFFSET  LAG             CONSUMER-ID                                  HOST            CLIENT-ID
saasdc_asset_neo4j_group saasdc_asset_topic 1          -               0               -               rdkafka-daeaa1cb-e784-42e2-85de-c4a8bece0fd2 /10.128.170.28  rdkafka
saasdc_asset_neo4j_group saasdc_asset_topic 8          -               0               -               rdkafka-daeaa1cb-e784-42e2-85de-c4a8bece0fd2 /10.128.170.28  rdkafka
saasdc_asset_neo4j_group saasdc_asset_topic 19         -               0               -               rdkafka-daeaa1cb-e784-42e2-85de-c4a8bece0fd2 /10.128.170.28  rdkafka
saasdc_asset_neo4j_group saasdc_asset_topic 7          -               0               -               rdkafka-daeaa1cb-e784-42e2-85de-c4a8bece0fd2 /10.128.170.28  rdkafka
saasdc_asset_neo4j_group saasdc_asset_topic 14         -               0               -               rdkafka-daeaa1cb-e784-42e2-85de-c4a8bece0fd2 /10.128.170.28  rdkafka
saasdc_asset_neo4j_group saasdc_asset_topic 17         1               1               0               rdkafka-daeaa1cb-e784-42e2-85de-c4a8bece0fd2 /10.128.170.28  rdkafka
saasdc_asset_neo4j_group saasdc_asset_topic 5          -               0               -               rdkafka-daeaa1cb-e784-42e2-85de-c4a8bece0fd2 /10.128.170.28  rdkafka
saasdc_asset_neo4j_group saasdc_asset_topic 12         -               0               -               rdkafka-daeaa1cb-e784-42e2-85de-c4a8bece0fd2 /10.128.170.28  rdkafka
saasdc_asset_neo4j_group saasdc_asset_topic 0          -               0               -               rdkafka-daeaa1cb-e784-42e2-85de-c4a8bece0fd2 /10.128.170.28  rdkafka
saasdc_asset_neo4j_group saasdc_asset_topic 2          -               0               -               rdkafka-daeaa1cb-e784-42e2-85de-c4a8bece0fd2 /10.128.170.28  rdkafka
saasdc_asset_neo4j_group saasdc_asset_topic 4          -               0               -               rdkafka-daeaa1cb-e784-42e2-85de-c4a8bece0fd2 /10.128.170.28  rdkafka
saasdc_asset_neo4j_group saasdc_asset_topic 15         -               0               -               rdkafka-daeaa1cb-e784-42e2-85de-c4a8bece0fd2 /10.128.170.28  rdkafka
saasdc_asset_neo4j_group saasdc_asset_topic 16         1               1               0               rdkafka-daeaa1cb-e784-42e2-85de-c4a8bece0fd2 /10.128.170.28  rdkafka
saasdc_asset_neo4j_group saasdc_asset_topic 11         -               0               -               rdkafka-daeaa1cb-e784-42e2-85de-c4a8bece0fd2 /10.128.170.28  rdkafka
saasdc_asset_neo4j_group saasdc_asset_topic 9          -               0               -               rdkafka-daeaa1cb-e784-42e2-85de-c4a8bece0fd2 /10.128.170.28  rdkafka
saasdc_asset_neo4j_group saasdc_asset_topic 18         -               0               -               rdkafka-daeaa1cb-e784-42e2-85de-c4a8bece0fd2 /10.128.170.28  rdkafka
saasdc_asset_neo4j_group saasdc_asset_topic 13         -               0               -               rdkafka-daeaa1cb-e784-42e2-85de-c4a8bece0fd2 /10.128.170.28  rdkafka
saasdc_asset_neo4j_group saasdc_asset_topic 6          -               0               -               rdkafka-daeaa1cb-e784-42e2-85de-c4a8bece0fd2 /10.128.170.28  rdkafka
saasdc_asset_neo4j_group saasdc_asset_topic 3          -               0               -               rdkafka-daeaa1cb-e784-42e2-85de-c4a8bece0fd2 /10.128.170.28  rdkafka
saasdc_asset_neo4j_group saasdc_asset_topic 10         -               0               -               rdkafka-daeaa1cb-e784-42e2-85de-c4a8bece0fd2 /10.128.170.28  rdkafka

References

kafka安装配置SASL_PLAINTEXT

kafka集群中jmx端口设置

CentOS7 下 kafka 集群安装部署

2023-07-27T15:25:52.000Z

本文介绍了在 CentOS7 下安装和部署 Kafka 集群的步骤。首先介绍了 Kafka 的简介，包括其作为高吞吐量的分布式发布订阅消息系统的特点。然后说明了搭建 Kafka 集群环境所需的设备环境，包括准备一个 Zookeeper 环境。接下来详细介绍了安装步骤，包括下载 Kafka、解压安装、配置环境变量、编辑配置文件、创建 system 服务、启动和关闭 Kafka 以及查看集群状态。最后，介绍了 Kafka 命令行工具的使用，包括测试流程和测试步骤，涵盖了创建 topic、生产消息、消费消息等操作。

CentOS7 下 kafka 集群安装部署

1. kafka 简介

Apache kafka 是由 Apache 软件基金会开发的一个开源流处理平台，由 Scala 和 Java 编写。Kafka 是一种高吞吐量的分布式发布订阅消息系统，是消息中间件的一种，用于构建实时数据管道和流应用程序，非常流行。

Kafka官网：http://kafka.apache.org

学习推荐：http://orchome.com/kafka/index

官网下载：http://kafka.apache.org/downloads

2. 设备环境

Kafka 集群环境搭建，需要准备好一个 zookeeper 环境（集群）

Host	IP	Port	OS	Software
cnode1	10.128.170.21	9092	CentOS 7.9.2009	kafka 2.13-2.8.1
cnode2	10.128.170.22	9092	CentOS 7.9.2009	kafka 2.13-2.8.1
cnode3	10.128.170.23	9092	CentOS 7.9.2009	kafka 2.13-2.8.1

说明：kafka 名中的 2.13 是 Scala 语言版本，后面的 2.8.1 是 kafka 版本，端口默认为 9092。

3. 安装步骤

3.1 下载 kafka

官网下载太慢，推荐使用国内镜像进行下载，清华镜像下载地址：

https://mirrors.tuna.tsinghua.edu.cn/apache/kafka

这里以下载 2.8.1 版本为例：

1	wget -c https://mirrors.tuna.tsinghua.edu.cn/apache/kafka/2.8.1/kafka_2.13-2.8.1.tgz

3.2 解压安装

这里解压至 /opt 目录：

1	tar -zxvf kafka_2.13-2.8.1.tgz -C /opt

解压后目录：

[root@cnode1 kafka_2.13-2.8.1]# pwd
/opt/kafka_2.13-2.8.1
[root@cnode1 kafka_2.13-2.8.1]# ll
total 40
drwxr-xr-x. 3 root root  4096 Sep 14 21:09 bin
drwxr-xr-x. 3 root root  4096 Sep 14 21:09 config
drwxr-xr-x. 2 root root  8192 Feb 18 10:26 libs
-rw-r--r--. 1 root root 14520 Sep 14 21:03 LICENSE
drwxr-xr-x. 2 root root   262 Sep 14 21:09 licenses
-rw-r--r--. 1 root root   953 Sep 14 21:03 NOTICE
drwxr-xr-x. 2 root root    44 Sep 14 21:09 site-docs

3.3 配置环境变量（可选）

编辑 /etc/profile 文件：

1	vim /etc/profile

在文件末尾添加如下配置：

# Kafka Environment
export KAFKA_HOME=/opt/kafka_2.13-2.8.1

export PATH=${PATH}:${KAFKA_HOME}/bin

使配置生效：

1	source /etc/profile

3.4 编辑配置文件

进入 config 目录：

1	cd /opt/kafka_2.13-2.8.1/config/

备份原配置文件：

1	cp server.properties server.properties.bak

编辑配置文件：

1	vim server.properties

修改配置如下：

############################# Server Basics #############################

# The id of the broker. This must be set to a unique integer for each broker.
broker.id=1  # 默认是 0，这里自定义 cnode1:1 cnode2:2 cnode3:3

# Switch to enable topic deletion or not, default value is false
#delete.topic.enable  # 这里为新增行，默认是 false，为 false 时，删除 topic 时不会立即被删掉

############################# Socket Server Settings #############################

# The address the socket server listens on. It will get the value returned from
# java.net.InetAddress.getCanonicalHostName() if not configured.
#   FORMAT:
#     listeners = listener_name://host_name:port
#   EXAMPLE:
#     listeners = PLAINTEXT://your.host.name:9092
#listeners=PLAINTEXT://:9092  # 根据需要修改端口
host.name=cnode1  # 这里为新增行

############################# Log Basics #############################

# A comma separated list of directories under which to store log files
log.dirs=/data/kafka-logs  # 默认是 /tmp/kafka-logs，这里重新定义了路径

############################# Zookeeper #############################

# Zookeeper connection string (see zookeeper docs for details).
# This is a comma separated host:port pairs, each corresponding to a zk
# server. e.g. "127.0.0.1:3000,127.0.0.1:3001,127.0.0.1:3002".
# You can also append an optional chroot string to the urls to specify the
# root directory for all kafka znodes.
# 这里写上已准备好的 zookeeper 集群环境
zookeeper.connect=cnode1:2181,cnode2:2181,cnode3:2181

其它配置可以保持默认，保存退出。在 cnode2 和 cnode3 上进行同样的操作，不再赘述。

3.5 创建 system 服务（可选）

1	vim /usr/lib/systemd/system/kafka.service

添加如下内容：

[Unit]
Description=kafka service
After=network.target

[Service]
Type=forking
User=root
Group=root
# 启用 jmx
#Environment=JMX_PORT=9988
ExecStart=/opt/kafka_2.13-2.8.1/bin/kafka-server-start.sh -daemon /opt/kafka_2.13-2.8.1/config/server.properties
ExecStop=/opt/kafka_2.13-2.8.1/bin/kafka-server-stop.sh
Restart=always
RestartSec=1
StartLimitIntervalSec=0

[Install]
WantedBy=multi-user.target

https://lists.freedesktop.org/archives/systemd-devel/2017-July/039255.html

3.6 启动 kafka

这里以未配置环境变量为例。

切换到 bin 目录下：

1	cd /opt/kafka_2.13-2.8.1/bin/

启动服务：

1	[root@cnode1 bin]# ./kafka-server-start.sh -daemon ../config/server.properties

查看 9092 端口状态，确保服务已经启动：

[root@cnode1 bin]# netstat -anptl | grep 9092
tcp6       0      0 10.128.170.21:9092      :::*                    LISTEN      29553/java
tcp6       0      0 10.128.170.21:40092     10.128.170.21:9092      ESTABLISHED 29553/java
tcp6       0      0 10.128.170.21:9092      10.128.170.21:40092     ESTABLISHED 29553/java

同样地，启动 cnode2 和 cnode3：

1	[root@cnode2 bin]# ./kafka-server-start.sh -daemon ../config/server.properties

1	[root@cnode3 bin]# ./kafka-server-start.sh -daemon ../config/server.properties

至此，kafka 安装启动完成。

3.7 关闭 kafka

1
2
3

[root@cnode1 bin]# ./kafka-server-stop.sh
[root@cnode2 bin]# ./kafka-server-stop.sh
[root@cnode3 bin]# ./kafka-server-stop.sh

3.8 查看集群状态

[root@cnode1 bin]# cd /opt/apache-zookeeper-3.6.3-bin/bin/
[root@cnode1 bin]# ./zkCli.sh -server cnode2
...
[zk: cnode2(CONNECTED) 0] ls /
[admin, brokers, cluster, config, consumers, controller, controller_epoch, feature, isr_change_notification, latest_producer_id_block, log_dir_event_notification, zookeeper]
[zk: cnode2(CONNECTED) 1] ls /brokers
[ids, seqid, topics]
[zk: cnode2(CONNECTED) 2] ls /brokers/ids
[1, 2, 3]

说明：zookeeper 集群建好之后，通过 ls / 出来的只有 zookeeper，连接 kafka 使用后，/ 下面多了不少东西，其中通过查看 /brokers/ids 可以发现已经检查到了已经安装的三台 kafka 的 broker.id [1,2,3]。

4. kafka 命令行工具使用

4.1 测试流程

主线：创建 topic，生产消息，消费消息。

流程命令会连接不同的节点，可以顺带检测集群消息的同步情况。

（1）在 cnode1 上创建 topic

（2）在 cnode3 查看 topic

（3）在 cnode1 上生成消息

（4）在 cnode2 上消费消息

4.2 测试步骤

（1）先创建一个 topic

在 cnode1 节点执行

1 2	[root@cnode1 bin]# ./kafka-topics.sh --create --zookeeper cnode1:2181 --replication-factor 3 --partitions 2 --topic google Created topic google.

创建一个名叫 "google" 的 topic 成功。

（2）查看一下建好的 topic

在 cnode3 节点执行

1 2	[root@cnode3 bin]# ./kafka-topics.sh --list --zookeeper cnode3:2181 google

（3）在建好的 topic 下生产消息

在 cnode1 节点执行

[root@cnode1 bin]# ./kafka-console-producer.sh --broker-list cnode1:9092 --topic google
>Apple
>Banana
>Cat
>Dog

这里生产了 4 个消息，每行一个。

（4）消费指定 topic 下的消息

在 cnode2 节点执行

[root@cnode2 bin]# ./kafka-console-consumer.sh --bootstrap-server cnode2:9092 --topic google --from-beginning
Banana
Dog
Apple
Cat

（5）删除指定 topic

先 list 一下然后删除

[root@cnode1 bin]# ./kafka-topics.sh --list --zookeeper cnode1:2181
__consumer_offsets
google
[root@cnode1 bin]# ./kafka-topics.sh --delete --zookeeper cnode3:2181 --topic google
Topic google is marked for deletion.
Note: This will have no impact if delete.topic.enable is not set to true.
[root@cnode1 bin]# ./kafka-topics.sh --list --zookeeper cnode1:2181
__consumer_offsets

References

centos7下kafka集群安装部署

kafka命令行脚本使用

CentOS7 下安装 RabbitMQ

2023-07-26T15:13:23.000Z

本文介绍了在 CentOS7 系统下安装 RabbitMQ 的详细步骤。首先需要安装 Erlang 和 RabbitMQ，然后进行 RabbitMQ 的配置，包括设置防火墙和 SELinux。接着介绍了如何启用 RabbitMQ Web 控制台以及如何配置 SSL 证书。最后，文章提供了设置 RabbitMQ 集群的脚本 /usr/local/sbin/rabbitmq-cluster.sh，供读者参考。

CentOS7 下安装 RabbitMQ

1 2	sudo yum -y install epel-release sudo yum -y update

安装 Erlang

下载 erlang repository：

1	wget http://packages.erlang-solutions.com/erlang-solutions-1.0-1.noarch.rpm

添加 erlang repository：

1	sudo rpm -Uvh erlang-solutions-1.0-1.noarch.rpm

安装 erlang 及其依赖：

1	sudo yum -y install erlang socat logrotate

安装 RabbitMQ

下载 RabbitMQ rpm 包：

1	wget https://github.com/rabbitmq/rabbitmq-server/releases/download/v3.8.8/rabbitmq-server-3.8.8-1.el6.noarch.rpm

添加 signing key：

1	sudo rpm --import https://www.rabbitmq.com/rabbitmq-signing-key-public.asc

安装 rabbitmq-server：

1	sudo rpm -Uvh rabbitmq-server-3.8.8-1.el6.noarch.rpm

启动 RabbitMQ：

1	sudo systemctl start rabbitmq-server

设置 RabbitMQ 开机自启：

1	sudo systemctl enable rabbitmq-server

RabbitMQ 配置（可选）

创建 rabbitmq 配置文件 /etc/rabbitmq/rabbitmq.conf：

listeners.ssl.default = 5671

ssl_options.cacertfile = /path/to/cacertfile.pem
ssl_options.certfile   = /path/to/certfile.pem
ssl_options.keyfile    = /path/to/keyfile.pem
ssl_options.verify     = verify_peer
ssl_options.versions.1 = tlsv1.2
ssl_options.versions.2 = tlsv1.1
ssl_options.fail_if_no_peer_cert = false

tcp_listen_options.backlog       = 128
tcp_listen_options.nodelay       = true
tcp_listen_options.exit_on_close = false
tcp_listen_options.keepalive     = false

heartbeat = 580

设置防火墙

设置防火墙规则，放通相关端口：

sudo firewall-cmd --zone=public --permanent --add-port=4369/tcp
sudo firewall-cmd --zone=public --permanent --add-port=25672/tcp
sudo firewall-cmd --zone=public --permanent --add-port=5671-5672/tcp
sudo firewall-cmd --zone=public --permanent --add-port=15672/tcp
sudo firewall-cmd --zone=public --permanent --add-port=61613-61614/tcp
sudo firewall-cmd --zone=public --permanent --add-port=1883/tcp
sudo firewall-cmd --zone=public --permanent --add-port=8883/tcp

重载防火墙，使规则生效：

1	sudo firewall-cmd --reload

SELinux

如果 SELinux 是 enabled，则启用 NIS：

1	sudo setsebool -P nis_enabled 1

-P 参数表示将设置永久生效，nis_enabled 是一个 SELinux 布尔类型的变量，用于控制是否启用 NIS（Network Information Service）服务。将其设置为 1 表示启用 NIS 服务。

RabbitMQ Web 控制台

启用 RabbitMQ web 控制台：

1	sudo rabbitmq-plugins enable rabbitmq_management

修改文件权限：

1	sudo chown -R rabbitmq:rabbitmq /var/lib/rabbitmq/

创建一个 admin 用户（将 password 替换为一个强密码）：

1	sudo rabbitmqctl add_user admin password

给 admin 用户设置 administrator 标签：

1	sudo rabbitmqctl set_user_tags admin administrator

设置 admin 用户权限：

1	sudo rabbitmqctl set_permissions -p / admin "." "." ".*"

使用 admin 用户访问 RabbitMQ web 控制台：

http://Your_Server_IP:15672

RabbitMQ Web 控制台配置 SSL 证书（可选）

编辑 RabbitMQ 配置文件 /etc/rabbitmq/rabbitmq.conf：

management.listener.port = 15672
management.listener.ssl  = true

management.listener.ssl_opts.cacertfile = /path/to/cacertfile.pem
management.listener.ssl_opts.certfile   = /path/to/certfile.pem
management.listener.ssl_opts.keyfile    = /path/to/keyfile.pem

RabbitMQ 集群

设置 RabbitMQ 集群, 拷贝下面的脚本 /usr/local/sbin/rabbitmq-cluster.sh 并运行：

#!/bin/bash
set -e

function getHostname()
{
  local HOST=''

  while test -z "$HOST"
  do
    read -p "$1 : " HOST
  done

  echo $HOST;
}

SETUP_MASTER_SCRIPT='
rabbitmqctl stop_app;
rabbitmqctl reset;
rabbitmqctl start_app;
';

# Step 1 : Setup the Master. Get the erlang cookie

echo "Setup RabbitMQ Master";
echo "=====================";

OUT=/tmp/master.out
MASTER_HOSTNAME=$(getHostname "Enter the master server's hostname");
echo "[$MASTER_HOSTNAME] Setting up master";
ssh -t $MASTER_HOSTNAME "bash -c '$SETUP_MASTER_SCRIPT cat /var/lib/rabbitmq/.erlang.cookie;'" | tee $OUT;
COOKIE=$(cat $OUT | tail -n1)
rm $OUT;
echo "Master's Erlang Cookie : '$COOKIE'"

MASTER_IP=$(getHostname "Enter the master server's IP as seen from the slaves (Use a local IP if available)");


# Step 2 : Setup the slaves

SETUP_SLAVE_SCRIPT="
sed -i \"s/^$/$MASTER_IP    $MASTER_HOSTNAME\n/\" /etc/hosts
bash -c \"echo -n '$COOKIE' > /var/lib/rabbitmq/.erlang.cookie\";
rabbitmqctl stop_app;
rabbitmqctl reset;
rabbitmqctl join_cluster --ram rabbit@$MASTER_HOSTNAME;
rabbitmqctl start_app;
rabbitmqctl cluster_status;
";

echo "Setup RabbitMQ Slaves";
echo "=====================";

SERVER=$(getHostname "Enter slave's hostname or 'q' to quit");
while test "$SERVER" != "q"
do
  echo "Setting up slave";
  echo "ssh '$SERVER'";
  ssh -t $SERVER "bash -c '$SETUP_SLAVE_SCRIPT'";
  SERVER=$(getHostname "Enter another slave's hostname or 'q' to quit");
done

# Step 3 : Create admin user
echo "[$MASTER_HOSTNAME] Setting up admin user";
ssh -t $MASTER_HOSTNAME "bash -c 'rabbitmqctl add_user admin password'";
ssh -t $MASTER_HOSTNAME "bash -c 'rabbitmqctl set_user_tags admin administrator'";
ssh -t $MASTER_HOSTNAME "bash -c 'rabbitmqctl set_permissions -p / admin \".*\" \".*\" \".*\"'";

# Step 3 : Delete guest user
echo "[$MASTER_HOSTNAME] Removing user";
ssh -t $MASTER_HOSTNAME "bash -c 'rabbitmqctl delete_user guest'";

# Step 5 : Create sync policy
echo "[$MASTER_HOSTNAME] Synchronizing cluster";
ssh -t $MASTER_HOSTNAME $"bash -c 'rabbitmqctl set_policy -p / ha-all \"\" '\''{\"ha-mode\":\"all\",\"ha-sync-mode\":\"automatic\"}'\'''";

echo "Done";

常见问题

1. RabbitMQ 异常退出无法重启

问题描述：

机房突然停电，rabbitmq 的主机异常断电，集群服务全部需要重启。但是在执行 systemctl start rabbitmq-server 启动主节点服务的时候，没有反应，服务没有启动，命令执行卡住。只能 Ctrl+C 结束进程。

查看 /var/log/rabbitmq/rabbit@hostname.log 发现有如下报错信息：

2021-04-13 20:15:00.011 [info] <0.317.0> Waiting for Mnesia tables for 30000 ms, 9 retries left
2021-04-13 20:15:00.011 [warning] <0.317.0> Error while waiting for Mnesia tables: {failed_waiting_for_tables,{node_not_running,rabbit@node233}}
...
2021-04-13 20:15:00.012 [info] <0.317.0> Waiting for Mnesia tables for 30000 ms, 0 retries left
2021-04-13 20:15:00.013 [error] <0.316.0> CRASH REPORT Process <0.316.0> with 0 neighbours exited with reason: {{failed_waiting_for_tables,{node_not_running,rabbit@node233}},{rabbit,start,[normal,[]]}} in application_master:init/4 line 138

解决方法：

检查端口是否被占用；
检查 /var/log/rabbitmq 目录权限；
分布式数据库 mnesia 异常，将 /var/lib/rabbitmq/mnesia/rabbit@hostname/ 下的数据库文件清空即可，重新启动服务；或直接清除 /var/lib/rabbitmq/mnesia 目录下所有文件；

References

Install RabbitMQ on CentOS 7

pycharm 远程调试

2023-07-25T15:31:21.000Z

本文介绍了使用 PyCharm 提供的 pydevd 模块进行远程调试的步骤和原理。首先，在远程服务器上安装所需依赖，然后在本地机器上配置监听的 IP 地址和端口号，确保远程计算机可以访问到本地 IP 地址。接下来，在远程计算机的代码中插入特定的代码，其中 IP 地址和端口号需要与 PyCharm 中的监听配置一致。最后，通过 PyCharm 的远程调试模式，将 PyCharm 作为服务端，远程计算机上的应用程序作为客户端，建立连接并进行单步调试。

pycharm 远程调试

https://www.jetbrains.com/help/pycharm/remote-debugging-with-product.html

1. 远程服务器安装依赖

下载依赖包

https://pypi.org/project/pydevd-pycharm

1	pip download -d Downloads pydevd-pycharm==221.5921.27

安装依赖包

1
2
3

tar -zxf pydevd-pycharm-221.5921.27.tar.gz
cd pydevd-pycharm-221.5921.27/
python3 setup.py install

查看依赖是否安装成功

1 2	[root@localhost ~]# pip3 list \| grep pycharm pydevd-pycharm 221.5921.27

2. 本地机器的配置

Run -> Edit Configurations

Edit Configurations" />

Add New Configuration -> Python Remote Debug

Python Remote Debug" />

填写 Local host name 和 Port，其中 Local host name 指的是本机开发环境的 IP 地址，而 Port 则随便填写一个 10000 以上的即可；需要注意的是，由于远程计算机需要连接至本地开发环境，因此本地 IP 地址应该保证远程可以访问得到。

3. 远程计算机的代码配置

在远程需要调试的代码中插入如下代码：

1 2	import pydevd pydevd.settrace('10.214.161.179', port=10000, stdoutToServer=True, stderrToServer=True)

其中，IP 地址和端口号要与 PyCharm 中的监听配置保持一致。

4. pycharm 远程调试的原理

在远程调试的模式下，PyCharm（IDE）扮演服务端（Server）的角色，而运行在远程计算机上的应用程序扮演客户端（Client）的角色。正因如此，进行远程调试时，需要先在本地开发环境中设定端口并启动IDE，IDE会对设定的端口开始监听，等待客户端的连接请求；

针对远程调试功能，PyCharm 提供了 pydevd 模块，该模块以 pycharm-debug.egg 的形式存在于 PyCharm 的安装路径中。远程计算机安装该库文件后，然后就可以调用 pydevd.settrace 方法，该方法会指定 IDE 所在机器的 IP 地址和监听的端口号，用于与 IDE 建立连接；建立连接后，便可在 IDE 中对远程在远程计算机中的程序进行单步调试。

Docker 磁盘清理

2023-07-23T15:47:20.000Z

在使用 docker 的时候，经常需要下载镜像，给镜像打标签，然后又因为没有及时清理无用的镜像，久而久之，docker 就会把宿主机的磁盘空间占满，导致系统异常。对于 docker 磁盘占用的问题，可以通过 docker 自带的 prune 命令清理或者迁移 docker 下的 overlay2 文件夹来解决。

Docker 磁盘清理

通过 prune 清理

查看磁盘使用情况

1	du -sh /var/lib/docker

查看 docker 磁盘占用

1	docker system df

该命令可以用于查看 Docker 环境中的磁盘使用情况，包括镜像、容器、数据卷和网络等资源的使用情况。

1	docker system df -v

与 docker system df 命令不同的是，该命令可以进一步查看空间占用细节，以确定是哪个镜像、容器或本地卷占用过高空间。

清理 docker 磁盘占用

自动清理

如果您只想清理未被使用的容器、数据卷和网络等资源，可以使用以下命令：

1	docker system prune

该命令会清理未被使用的容器、数据卷和网络等资源，但不会删除未被使用的镜像。

该命令所清理的对象如下：
已停止的容器
未被任何容器使用的卷
未被任何容器所关联的网络
所有悬空的镜像
对于上面提到的一些镜像或容器的状态所代表的含义如下：
已使用的镜像：指所有已被容器（包括 stop 的）关联的镜像，也就是 docker ps -a 所看到的所有容器对应的 image
未引用镜像：没有被分配或使用在容器中的镜像
悬空镜像（dangling image）：未配置任何 tag（也就是无法被引用）的镜像。通常是由于镜像编译过程中未指定 -t 参数配置 tag 导致的。

如果想清理所有未被使用的镜像，可以使用 -a 参数：

1	docker system prune -a

该命令会提示您确认是否要清理无用资源，确认后将会删除所有无用资源（包括未被使用的镜像、已停止的容器、未被使用的数据卷和网络等），释放磁盘空间。请注意，该命令会删除所有未被使用的镜像，包括您手动下载的镜像和 Docker 官方镜像，因此请谨慎使用。

删除无用的容器：

1	docker container prune

默认情况下 docker container prune 会清理掉所有处于 stopped 状态的容器
如果不想都删掉，也可以使用 --filter 标志来筛选出不希望被清理掉的容器
例子：清除掉所有停掉的容器，但24内创建的除外。
1
docker container prune --filter "until=24h"

删除无用的卷：

1	docker volume prune

删除无用的网络：

1	docker network prune

手动清理

（1）删除所有悬空镜像，不删除未使用镜像：

1	docker rmi $(docker images -f "dangling=true" -q)

（2）删除所有未使用镜像和悬空镜像

1	docker rmi $(docker images -q)

（3）删除所有未被容器引用的卷

1	docker volume rm $(docker volume ls -qf dangling=true)

如果卷占用空间过高，可以清除一些不使用的卷，包括一些未被任何容器调用的卷（-v 详细信息中若显示 LINKS = 0，则是未被调用）

（4）删除容器

删除所有已退出的容器：

1	docker rm -v $(docker ps -aq -f status=exited)

具体来说，该命令使用了以下参数：

-a：列出所有的容器，包括正在运行的容器和已经停止的容器。
-q：只列出容器的 ID，而不显示容器的详细信息。
-f status=exited：只列出状态为 "exited" 的容器，即已经退出的容器。

删除所有状态为 dead 的容器：

1	docker rm -v $(docker ps -aq -f status=dead)

如果发现是容器占用过高的空间，可以手动删除一些。

迁移 /var/lib/docker

/var/lib/docker/overlay2 占用很大，要想清理 Docker 占用的磁盘空间，可以考虑迁移 /var/lib/docker 目录。

停止 docker 服务

1	systemctl stop docker

创建新的分区目录

创建一个磁盘空间更大的分区目录，例如：/home/lib/docker

迁移 /var/lib/docker

1	rsync -avz /var/lib/docker /home/lib/docker

配置 devicemapper.conf

配置 /etc/systemd/system/docker.service.d/devicemapper.conf（查看 devicemapper.conf 是否存在，如果不存在则创建）

1 2	mkdir -p /etc/systemd/system/docker.service.d/ vim /etc/systemd/system/docker.service.d/devicemapper.conf

配置内容如下：

1 2	[Service] ExecStart=/usr/bin/dockerd --graph=/home/lib/docker/docker

重启 docker

1 2	systemctl daemon-reload systemctl restart docker

验证

1	docker info

命令检查 Docker 的根目录，它将被更改为 /home/lib/docker/docker

...
Docker Root Dir: /home/lib/docker/docker
Debug Mode (client): false
Debug Mode (server): false
Registry: https://index.docker.io/v1/
...

查看之前的镜像是否还在：

[root@localhost ~]# docker images
REPOSITORY                  TAG       IMAGE ID       CREATED         SIZE
demo                        0.0.1     4fa4c5aae26d   4 months ago    378MB
adoptopenjdk/openjdk11      alpine    552165ab2add   4 months ago    343MB
registry                    2.8.1     dcb3d42c1744   5 months ago    24.1MB

确定容器没问题后删除 /var/lib/docker 目录下的文件：

1	rm -rf /var/lib/docker/*

CentOS 搭建 DNS 服务

2023-04-08T02:45:39.000Z

本文介绍了在 CentOS 上使用 BIND (Berkeley Internet Name Domain) 搭建 DNS 服务的步骤。首先需要下载 DNS 服务软件，然后配置主配置文件和区域文件，接着配置正向解析数据文件和反向解析数据文件，设置文件权限，检查配置文件是否配置正确，最后启动 DNS 服务并测试解析。

CentOS 搭建 DNS 服务

可以使用 BIND (Berkeley Internet Name Domain) 来搭建 DNS 服务。以下是在 CentOS 上搭建 BIND 的步骤：

下载 DNS 服务软件

# 服务端需安装 bind-chroot 软件
yun install -y bind-chroot

# 客户端需下载 bind-utils（需要使用 nslookup 命令）
yum install -y bind-utils

配置主配置文件

https://bind9.readthedocs.io/en/v9_18_8/reference.html#configuration-reference

编辑 /etc/named.conf 文件，修改以下内容：

options {
        // 配置 DNS 服务监听的 IP 地址（可以写成 any）和端口（默认 53，确保该端口没有被占用）
        listen-on port 53 { any; };
        // 允许任何网段的主机访问 DNS 服务
        allow-query     { any; };

        dnssec-enable no;
        dnssec-validation no;
};

https://web.mit.edu/rhel-doc/4/RH-DOCS/rhel-rg-en-4/s1-bind-namedconf.html

配置区域文件

编辑 /etc/named.rfc1912.zones 文件，添加以下内容：

zone "wylu.test" IN {
        type master;
        file "wylu.test.localhost";
        allow-update { none; };
};

zone "170.128.10.in-addr.arpa" IN {
        type master;
        file "wylu.test.loopback";
        allow-update { none; };
};

配置正向解析数据文件

拷贝一份正向解析数据文件的模板，然后进行编辑：

1
2
3

cd /var/named
cp -a named.localhost wylu.test.localhost
vim wylu.test.localhost

添加如下内容：

$TTL 1D
@       IN SOA  wylu.test. rname.invalid. (
                                        0       ; serial
                                        1D      ; refresh
                                        1H      ; retry
                                        1W      ; expire
                                        3H )    ; minimum
        NS      www.wylu.test.
www     A       10.128.170.235
email   A       10.128.170.235

配置反向解析数据文件

拷贝一份正向解析数据文件的模板，然后进行编辑：

1
2
3

cd /var/named
cp -a named.loopback wylu.test.loopback
vim wylu.test.loopback

添加如下内容：

$TTL 1D
@       IN SOA  wylu.test. rname.invalid. (
                                        0       ; serial
                                        1D      ; refresh
                                        1H      ; retry
                                        1W      ; expire
                                        3H )    ; minimum
        NS      www.wylu.test.
235     PTR     www.wylu.test.

设置文件权限

1	chown named:named wylu.test.localhost wylu.test.loopback

注意：请确保 wylu.test.localhost 和 wylu.test.loopback 文件的属主和属组为 named。

[root@localhost named]# ls -alh
total 28K
drwxrwx--T.  5 root  named  178 Mar 22 18:52 .
drwxr-xr-x. 22 root  root  4.0K Mar 22 17:34 ..
drwxrwx---.  2 named named   23 Mar 22 17:45 data
drwxrwx---.  2 named named   60 Mar 22 18:52 dynamic
-rw-r-----.  1 root  named 2.3K Nov  8 19:18 named.ca
-rw-r-----.  1 root  named  152 Nov  8 19:18 named.empty
-rw-r-----.  1 root  named  152 Nov  8 19:18 named.localhost
-rw-r-----.  1 root  named  168 Nov  8 19:18 named.loopback
drwxrwx---.  2 named named    6 Nov  8 19:18 slaves
-rw-r--r--.  1 root  root   429 Mar 22 18:51 wylu.test.localhost
-rw-r--r--.  1 root  root   397 Mar 22 17:44 wylu.test.loopback

否则启动服务时会产生如下错误提示：

Mar 22 17:44:08 localhost.localdomain named[15726]: zone 170.128.10.in-addr.arpa/IN: loading from master file wylu.test.loopback failed: permission denied
Mar 22 17:44:08 localhost.localdomain named[15726]: zone 170.128.10.in-addr.arpa/IN: not loaded due to errors.
Mar 22 17:44:08 localhost.localdomain named[15726]: zone wylu.test/IN: loading from master file wylu.test.localhost failed: permission denied
Mar 22 17:44:08 localhost.localdomain named[15726]: zone wylu.test/IN: not loaded due to errors.
Mar 22 17:44:08 localhost.localdomain named[15726]: all zones loaded
Mar 22 17:44:08 localhost.localdomain named[15726]: running

检查配置文件是否配置正确

[root@localhost named]# named-checkconf -z /etc/named.conf
zone localhost.localdomain/IN: loaded serial 0
zone localhost/IN: loaded serial 0
zone 1.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.ip6.arpa/IN: loaded serial 0
zone 1.0.0.127.in-addr.arpa/IN: loaded serial 0
zone 0.in-addr.arpa/IN: loaded serial 0
zone wylu.test/IN: loaded serial 0
zone 170.128.10.in-addr.arpa/IN: loaded serial 0

如上输出表示配置文件没问题。

启动 DNS 服务

# 关闭防火墙服务
systemctl stop firewalld
systemctl disable firewalld

# 临时禁用 SELinux
setenforce 0
# 永久禁用 SELinux
vim /etc/selinux/config
SELINUX=disabled

# 启动 DNS 服务
systemctl start named
systemctl enable named

查看 DNS 服务监听情况：

[root@localhost named]# netstat -anupl | grep 53
udp        0      0 172.17.0.1:53           0.0.0.0:*           2111795/named
udp        0      0 10.128.170.235:53       0.0.0.0:*           2111795/named
udp        0      0 127.0.0.1:53            0.0.0.0:*           2111795/named
udp6       0      0 ::1:53                  :::*                2111795/named

测试解析

正向解析

[root@localhost named]# nslookup email.wylu.test 10.128.170.235
Server:         10.128.170.235
Address:        10.128.170.235#53

Name:   email.wylu.test
Address: 10.128.170.235

反向解析

1 2	[root@localhost named]# nslookup 10.128.170.235 10.128.170.235 235.170.128.10.in-addr.arpa name = www.wylu.test.

References

cp -a 选项作用

cp -a 是 cp 命令的一个选项，用于复制文件和目录，并保留所有的属性和权限。具体来说，-a 选项等价于以下三个选项的组合：

-p 选项：保留文件的权限、所有者和时间戳。
-R 选项：递归复制目录及其内容。
-d 选项：保留符号链接的属性。

使用 cp -a 命令可以在复制文件和目录时保留所有的属性和权限，包括文件的所有者、组、权限、时间戳等。这对于备份和迁移文件和目录非常有用。例如，要将目录 /home/user1 复制到目录 /home/user2，可以使用以下命令：

1	cp -a /home/user1 /home/user2

这将递归地复制 /home/user1 目录及其所有内容到 /home/user2 目录，并保留所有的属性和权限。

禁用 SELinux

SELinux（Security-Enhanced Linux）是一个安全子系统，用于限制进程和用户的访问权限，以提高系统的安全性。但是，在某些情况下，SELinux 可能会导致一些问题，例如阻止某些进程或服务的正常运行。如果你需要关闭 SELinux，可以按照以下步骤操作：

检查 SELinux 的状态

sestatus

如果 SELinux 处于启用状态，将显示以下输出：

[root@localhost named]# sestatus
SELinux status:                 enabled
SELinuxfs mount:                /sys/fs/selinux
SELinux root directory:         /etc/selinux
Loaded policy name:             targeted
Current mode:                   enforcing
Mode from config file:          enforcing
Policy MLS status:              enabled
Policy deny_unknown status:     allowed
Memory protection checking:     actual (secure)
Max kernel policy version:      33

临时禁用 SELinux

1	setenforce 0

这将把 SELinux 的模式从强制模式（enforcing）切换到宽容模式（permissive），并在控制台上显示警告信息。在宽容模式下，SELinux 仍然会记录违规行为，但不会阻止它们。

永久禁用 SELinux

要永久禁用 SELinux，需要编辑 /etc/selinux/config 文件，并将 SELINUX 的值设置为 disabled。可以使用以下命令打开该文件：

1	vim /etc/selinux/config

找到以下行：

1	SELINUX=enforcing

将其改为：

1	SELINUX=disabled

保存并关闭文件。

重启系统

为了使 SELinux 的更改生效，需要重启系统：

reboot

在系统重新启动后，SELinux 将被永久禁用。

二进制部署 k8s 集群 1.23.6 版本

2023-04-06T16:30:31.000Z

通过本文的指导，读者可以了解如何通过二进制的方式部署 Kubernetes 1.23.6 版本集群。二进制部署可以加深对 Kubernetes 各组件的理解，可以灵活地将各个组件部署到不同的机器，以满足自身的要求。但是需要注意的是，二进制部署需要手动配置各个组件，需要一定的技术水平和经验。

二进制部署 k8s 集群 1.23.6 版本

1. 环境介绍

虽然 kubeadm, kops, kubespray 以及 rke, kubesphere 等工具可以快速部署 K8s 集群，但是依然会有很多人热衷与使用二进制部署 K8s 集群。

二进制部署可以加深对 K8s 各组件的理解，可以灵活地将各个组件部署到不同的机器，以满足自身的要求。还可以生成一个超长时间自签证书，比如 99 年，免去忘记更新证书过期带来的生产事故。

1.1 书写约定

命令行输入，均以 ➜ 符号表示
注释使用 # 或 // 表示
执行命令输出结果，以空行分隔

1.2 规划

角色	主机名	IP	组件
master	cnode0	10.128.170.20	etcd, kube-apiserver, kube-controller-manager, kube-scheduler, kube-proxy, kubelet
node1	cnode1	10.128.170.21	kubelet, kube-proxy

1.3 环境配置

关闭防火墙

1 2	➜ systemctl stop firewalld ➜ systemctl disable firewalld

关闭 selinux

# 临时
➜ setenforce 0
# 永久
➜ sed -i 's/enforcing/disabled/' /etc/selinux/config

关闭 swap
1
2
3
4
# 临时
➜ swapoff -a
# 永久
➜ sed -ri 's/.*swap.*/#&/' /etc/fstab
使用 -r 选项可以使用扩展正则表达式，这提供了一种更强大和灵活的方式来匹配文本中的模式。
使用正则表达式 .*swap.* 匹配包含 swap 字符串的行，并在行首添加 # 符号，& 表示匹配到的整个字符串。

设置主机名

# 10.128.170.20 主机
➜ hostnamectl set-hostname cnode0
# 10.128.170.21 主机
➜ hostnamectl set-hostname cnode1

时间同步

# 设置时区
➜ timedatectl set-timezone Asia/Shanghai
# 安装时间同步服务
➜ yum install chrony -y
➜ systemctl enable --now chronyd

主机名解析

➜ cat >> /etc/hosts << EOF
10.128.170.20 cnode0 cnode0.com
10.128.170.21 cnode1 cnode1.com
EOF

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

➜ cat > /etc/sysctl.d/kubernetes.conf << EOF
net.bridge.bridge-nf-call-ip6tables = 1
net.bridge.bridge-nf-call-iptables = 1
net.ipv4.ip_forward = 1
EOF
# 生效
➜ sysctl --system

设置文件描述符限制
1
2
3
4
# 临时
➜ ulimit -SHn 65535
# 永久
➜ echo "* - nofile 65535" >>/etc/security/limits.conf
用于设置当前用户的最大文件描述符数限制。具体来说，它的作用是将当前用户的软限制和硬限制都设置为 65535。
更新 epel 源
1
➜ yum install epel-release -y
如需换源，请参考：https://developer.aliyun.com/mirror/epel

加载 ipvs 模块

➜ yum install ipset ipvsadm -y
➜ 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
EOF
➜ chmod +x /etc/sysconfig/modules/ipvs.modules
➜ /bin/bash /etc/sysconfig/modules/ipvs.modules
➜ lsmod | grep -e ip_vs -e nf_conntrack_ipv4

modprobe -- ip_vs: 加载 ip_vs 内核模块，该模块提供了 Linux 内核中的 IP 负载均衡功能。
modprobe -- ip_vs_rr: 加载 ip_vs_rr 内核模块，该模块提供了基于轮询算法的 IP 负载均衡策略。
modprobe -- ip_vs_wrr: 加载 ip_vs_wrr 内核模块，该模块提供了基于加权轮询算法的 IP 负载均衡策略。
modprobe -- ip_vs_sh: 加载 ip_vs_sh 内核模块，该模块提供了基于哈希算法的 IP 负载均衡策略。
modprobe -- nf_conntrack_ipv4: 加载 nf_conntrack_ipv4 内核模块，该模块提供了 Linux 内核中的网络连接跟踪功能，用于跟踪网络连接的状态。

如果提示如下错误：

1	"modprobe: FATAL: Module nf_conntrack_ipv4 not found in directory /lib/modules/4.18.0-372.9.1.el8.x86_64"

则需要将 nf_conntrack_ipv4 修改为 nf_conntrack，然后重新执行命令，因为在高版本内核中已经把 nf_conntrack_ipv4 替换为 nf_conntrack。

nf_conntrack_ipv4 和 nf_conntrack 都是 Linux 内核中的网络连接跟踪模块，用于跟踪网络连接的状态。它们的区别在于：

nf_conntrack_ipv4 模块只能跟踪 IPv4 协议的网络连接，而 nf_conntrack 模块可以跟踪 IPv4 和 IPv6 协议的网络连接。
nf_conntrack_ipv4 模块是 nf_conntrack 模块的一个子模块，它提供了 IPv4 协议的网络连接跟踪功能。因此，如果要使用 nf_conntrack_ipv4 模块，必须先加载 nf_conntrack 模块。

免密登录

# 为了便捷操作,在 cnode0 上创建免密登录其他节点
➜ ssh-keygen -t rsa
➜ ssh-copy-id cnode1
➜ ssh-copy-id cnode2
➜ ssh-copy-id cnode3

创建 kubernetes 证书存放目录
1
➜ mkdir -p /etc/kubernetes/pki
重启
1
➜ reboot

1.4 下载 k8s 二进制程序

从官方发布地址下载二进制包下载地址

下载 Server Binaries 即可，这个包含了所有所需的二进制文件。解压后，复制二进制 kube-apiserver, kube-scheduler, kube-controller-manager, kube-proxy,kubelet, kubectl 到 master 节点 /usr/local/bin 目录下，复制二进制 kube-proxy,kubelet 到 worker 节点 /usr/local/bin 目录下。

➜ ll /usr/local/bin/kube*

-rwxr-xr-x 1 root root 128516096 Dec 29 14:59 /usr/local/bin/kube-apiserver
-rwxr-xr-x 1 root root 118489088 Dec 29 14:59 /usr/local/bin/kube-controller-manager
-rwxr-xr-x 1 root root  46202880 Dec 29 14:59 /usr/local/bin/kubectl
-rwxr-xr-x 1 root root 122352824 Dec 29 14:59 /usr/local/bin/kubelet
-rwxr-xr-x 1 root root  43581440 Dec 29 14:59 /usr/local/bin/kube-proxy
-rwxr-xr-x 1 root root  49020928 Dec 29 14:59 /usr/local/bin/kube-scheduler

2. 安装 docker

参考地址安装docker，Docker 需要在各个节点上安装

切换镜像源

1	wget https://mirrors.aliyun.com/docker-ce/linux/centos/docker-ce.repo -O /etc/yum.repos.d/docker-ce.repo

查看当前镜像源中支持的 docker 版本
1
yum list docker-ce --showduplicates
安装特定版本的 docker
1
yum install --setopt=obsoletes=0 docker-ce-20.10.14 -y
--setopt=obsoletes=0 是 yum 包管理器的一个选项，它的作用是禁用软件包依赖关系中的版本升级。

添加配置文件

Docker 在默认情况下使用的 Cgroup Driver 为 cgroupfs，而 Kubernetes 推荐使用 systemd 来替代 cgroupfs

mkdir /etc/docker
cat > /etc/docker/daemon.json << EOF
{
  "exec-opts": ["native.cgroupdriver=systemd"],
  "registry-mirrors": ["https://kn0t2bca.mirror.aliyuncs.com"]
}
EOF

启动 dokcer

1
2
3

systemctl daemon-reload
systemctl restart docker
systemctl enable docker

3. 创建 ca 证书

3.1 安装 cfssl

cfssl 是一款证书签署工具，使用 cfssl 工具可以很简化证书签署过程，方便颁发自签证书。

CloudFlare's distributes cfssl source code on github page and binaries on cfssl website.

Our documentation assumes that you will run cfssl on your local x86_64 Linux host.

1
2
3

curl -s -L -o /usr/local/bin/cfssl https://pkg.cfssl.org/R1.2/cfssl_linux-amd64
curl -s -L -o /usr/local/bin/cfssljson https://pkg.cfssl.org/R1.2/cfssljson_linux-amd64
chmod +x /usr/local/bin/{cfssl,cfssljson}

离线安装的情况，直接把两个文件下载下来重命名即可

3.2 创建 ca 证书

# 创建的证书统一放到 /etc/kubernetes/ssl 目录，创建后复制到 /etc/kubernetes/pki 目录
➜ mkdir /etc/kubernetes/ssl

➜ cd /etc/kubernetes/ssl

# ca 证书创建申请
➜ cat > ca-csr.json << EOF
{
    "CN": "kubernetes",
    "key": {
        "algo": "rsa",
        "size": 2048
    },
    "names": [
        {
            "C": "CN",
            "ST": "GuangDong",
            "L": "ShenZhen",
            "O": "k8s",
            "OU": "system"
        }
    ],
    "ca": {
        "expiry": "87600h"
    }
}
EOF

# 创建 ca 证书
➜ cfssl gencert -initca ca-csr.json | cfssljson -bare ca

# 验证结果，会生成两个证书文件
➜ ll ca*pem

-rw------- 1 haxi haxi 1675 Dec 30 11:32 ca-key.pem
-rw-rw-r-- 1 haxi haxi 1314 Dec 30 11:32 ca.pem

# 复制 ca 证书到 /etc/kubernetes/pki
➜ cp ca*pem /etc/kubernetes/pki

ca-csr.json 这个文件是 Kubernetes 集群中使用的证书颁发机构 (CA) 证书签名请求 (CSR) 配置文件，用于定义 CA 的证书签名请求配置。

在这个配置文件中，CN 字段指定了证书的通用名称为 kubernetes，key 字段指定了证书的密钥算法为 RSA，密钥长度为 2048 位。names 字段定义了证书的其他信息，如国家、省份、城市、组织和组织单位等。ca 字段指定了证书的过期时间为 87600 小时（即 10 年）。

这个配置文件用于创建 Kubernetes 集群中的 CA 证书，以便对集群中的其他证书进行签名和认证。

CN(Common Name): kube-apiserver 从证书中提取该字段作为请求的用户名 (User Name)
names[].O(Organization): kube-apiserver 从证书中提取该字段作为请求用户所属的组 (Group)

3.3 创建签发配置文件

由于各个组件都需要配置证书，并且依赖 CA 证书来签发证书，所以我们首先要生成好 CA 证书以及后续的签发配置文件。

创建用于签发其它证书的配置文件：

# 证书签发配置文件
➜ cat > ca-config.json << EOF
{
    "signing": {
        "default": {
            "expiry": "87600h"
        },
        "profiles": {
            "kubernetes": {
                "usages": [
                    "signing",
                    "key encipherment",
                    "server auth",
                    "client auth"
                ],
                "expiry": "87600h"
            }
        }
    }
}
EOF

在这个配置文件中，default 配置指定了默认的证书过期时间为 87600 小时（即 10 年），profiles 配置定义了一个名为 kubernetes 的证书配置，它指定了证书的用途（签名、密钥加密、服务器认证和客户端认证）和过期时间。

这个配置文件用于创建 Kubernetes 集群中的证书和密钥，以便对集群进行安全认证和加密通信。

signing：定义了签名配置，包括默认的签名过期时间和各个证书配置的签名过期时间。
profiles：定义了不同场景下的证书配置，包括证书的用途、过期时间和其他属性。

4. 部署 etcd

etcd 版本选择的是最新版本 3.5.1，下载二进制 etcd下载链接

4.1 颁发证书

# etcd 证书签署申请
# hosts 字段中，IP 为所有 etcd 集群节点地址，这里可以做好规划，预留几个 IP，以备以后扩容。
➜ cat > etcd-csr.json << EOF
{
    "CN": "etcd",
    "hosts": [
        "127.0.0.1",
        "10.128.170.20",
        "10.128.170.21",
        "10.128.170.22",
        "10.128.170.23",
        "10.128.170.24",
        "10.128.170.25",
        "cnode0",
        "cnode1",
        "cnode2",
        "cnode3",
        "cnode4",
        "cnode5",
        "cnode0.com",
        "cnode1.com",
        "cnode2.com",
        "cnode3.com",
        "cnode4.com",
        "cnode5.com"
    ],
    "key": {
        "algo": "rsa",
        "size": 2048
    },
    "names": [
        {
            "C": "CN",
            "ST": "GuangDong",
            "L": "ShenZhen",
            "O": "k8s",
            "OU": "system"
        }
    ]
}
EOF

# 签署 etcd 证书
➜ cfssl gencert -ca=ca.pem -ca-key=ca-key.pem -config=ca-config.json -profile=kubernetes etcd-csr.json | cfssljson -bare etcd

# 验证结果，会生成两个证书文件
➜ ll etcd*pem

-rw------- 1 haxi haxi 1679 Dec 30 11:32 etcd-key.pem
-rw-rw-r-- 1 haxi haxi 1440 Dec 30 11:32 etcd.pem

# 复制 etcd 证书到 /etc/kubernetes/pki
➜ cp etcd*pem /etc/kubernetes/pki

4.2 部署 etcd

下载二进制 etcd下载链接并解压，将二进制程序 etcd etcdctl 复制到 /usr/local/bin 目录下

➜ ll /usr/local/bin/etcd*

-rwxrwxr-x 1 root root 21823488 Dec 29 14:13 /usr/local/bin/etcd
-rwxrwxr-x 1 root root 16711680 Dec 29 14:13 /usr/local/bin/etcdctl

编写服务配置文件

➜ mkdir /etc/etcd

➜ cat > /etc/etcd/etcd.conf << EOF
ETCD_NAME="etcd1"
ETCD_DATA_DIR="/var/lib/etcd/default.etcd"
ETCD_LISTEN_PEER_URLS="https://10.128.170.20:2380"
ETCD_LISTEN_CLIENT_URLS="https://10.128.170.20:2379"
ETCD_INITIAL_ADVERTISE_PEER_URLS="https://10.128.170.20:2380"
ETCD_ADVERTISE_CLIENT_URLS="https://10.128.170.20:2379"
ETCD_INITIAL_CLUSTER="etcd1=https://10.128.170.20:2380"
ETCD_INITIAL_CLUSTER_TOKEN="etcd-cluster"
ETCD_INITIAL_CLUSTER_STATE="new"
EOF

# 配置文件解释
ETCD_NAME：节点名称，集群中唯一
ETCD_DATA_DIR： 数据保存目录
ETCD_LISTEN_PEER_URLS：集群内部通信监听地址
ETCD_LISTEN_CLIENT_URLS：客户端访问监听地址
ETCD_INITIAL_ADVERTISE_PEER_URLS：集群通告地址
ETCD_ADVERTISE_CLIENT_URLS：客户端通告地址
ETCD_INITIAL_CLUSTER：集群节点地址列表
ETCD_INITIAL_CLUSTER_TOKEN：集群通信token
ETCD_INITIAL_CLUSTER_STATE：加入集群的当前状态，new是新集群，existing表示加入已有集群

编写服务启动脚本

# 创建数据目录
➜ mkdir -p /var/lib/etcd

# 创建系统服务
➜ cat > /lib/systemd/system/etcd.service << "EOF"
[Unit]
Description=etcd server
After=network.target
After=network-online.target
Wants=network-online.target

[Service]
Type=notify
EnvironmentFile=/etc/etcd/etcd.conf
WorkingDirectory=/var/lib/etcd
ExecStart=/usr/local/bin/etcd \
  --cert-file=/etc/kubernetes/pki/etcd.pem \
  --key-file=/etc/kubernetes/pki/etcd-key.pem \
  --trusted-ca-file=/etc/kubernetes/pki/ca.pem \
  --peer-cert-file=/etc/kubernetes/pki/etcd.pem \
  --peer-key-file=/etc/kubernetes/pki/etcd-key.pem \
  --peer-trusted-ca-file=/etc/kubernetes/pki/ca.pem \
  --peer-client-cert-auth \
  --client-cert-auth
Restart=on-failure
RestartSec=5
LimitNOFILE=65535

[Install]
WantedBy=multi-user.target
EOF

启动 etcd 服务

➜ systemctl daemon-reload

➜ systemctl enable --now etcd

# 验证结果
➜ systemctl status etcd

# 查看日志
➜ journalctl -u etcd

5. 部署 kube-apiserver

5.1 颁发证书

# kube-apiserver 证书签署申请
# hosts 字段中，IP 为所有 kube-apiserver 节点地址，这里可以做好规划，预留几个 IP，以备以后扩容。我这里写 6 个 IP
# 10.128.170.20 10.128.170.21 10.128.170.22 10.128.170.23 10.128.170.24 10.128.170.25
# 10.96.0.1 是 service 网段的第一个 IP
# kubernetes.default.svc.cluster.local 这一串是 kube-apiserver 的 service 域名
➜ cat > kube-apiserver-csr.json << EOF
{
    "CN": "kubernetes",
    "hosts": [
        "127.0.0.1",
        "10.128.170.20",
        "10.128.170.21",
        "10.128.170.22",
        "10.128.170.23",
        "10.128.170.24",
        "10.128.170.25",
        "cnode0",
        "cnode1",
        "cnode2",
        "cnode3",
        "cnode4",
        "cnode5",
        "cnode0.com",
        "cnode1.com",
        "cnode2.com",
        "cnode3.com",
        "cnode4.com",
        "cnode5.com",
        "10.96.0.1",
        "kubernetes",
        "kubernetes.default",
        "kubernetes.default.svc",
        "kubernetes.default.svc.cluster",
        "kubernetes.default.svc.cluster.local"
    ],
    "key": {
        "algo": "rsa",
        "size": 2048
    },
    "names": [
        {
            "C": "CN",
            "ST": "GuangDong",
            "L": "ShenZhen",
            "O": "k8s",
            "OU": "system"
        }
    ]
}
EOF

# 签署 kube-apiserver 证书
➜ cfssl gencert -ca=ca.pem -ca-key=ca-key.pem -config=ca-config.json -profile=kubernetes kube-apiserver-csr.json | cfssljson -bare kube-apiserver

# 验证结果，会生成两个证书文件
➜ ll kube-apiserver*pem

-rw------- 1 haxi haxi 1675 Dec 30 11:33 kube-apiserver-key.pem
-rw-rw-r-- 1 haxi haxi 1590 Dec 30 11:33 kube-apiserver.pem

# 复制 kube-apiserver 证书到 /etc/kubernetes/pki
➜ cp kube-apiserver*pem /etc/kubernetes/pki

5.2 部署 kube-apiserver

编写服务配置文件

➜ cat > /etc/kubernetes/kube-apiserver.conf << EOF
KUBE_APISERVER_OPTS="--enable-admission-plugins=NamespaceLifecycle,NodeRestriction,LimitRanger,ServiceAccount,DefaultStorageClass,ResourceQuota \
  --anonymous-auth=false \
  --bind-address=0.0.0.0 \
  --secure-port=6443 \
  --insecure-port=0 \
  --authorization-mode=Node,RBAC \
  --runtime-config=api/all=true \
  --enable-bootstrap-token-auth \
  --service-cluster-ip-range=10.96.0.0/16 \
  --token-auth-file=/etc/kubernetes/token.csv \
  --service-node-port-range=30000-32767 \
  --tls-cert-file=/etc/kubernetes/pki/kube-apiserver.pem \
  --tls-private-key-file=/etc/kubernetes/pki/kube-apiserver-key.pem \
  --client-ca-file=/etc/kubernetes/pki/ca.pem \
  --kubelet-client-certificate=/etc/kubernetes/pki/kube-apiserver.pem \
  --kubelet-client-key=/etc/kubernetes/pki/kube-apiserver-key.pem \
  --service-account-key-file=/etc/kubernetes/pki/ca-key.pem \
  --service-account-signing-key-file=/etc/kubernetes/pki/ca-key.pem \
  --service-account-issuer=https://kubernetes.default.svc.cluster.local \
  --etcd-cafile=/etc/kubernetes/pki/ca.pem \
  --etcd-certfile=/etc/kubernetes/pki/etcd.pem \
  --etcd-keyfile=/etc/kubernetes/pki/etcd-key.pem \
  --etcd-servers=https://10.128.170.21:2379 \
  --enable-swagger-ui=true \
  --allow-privileged=true \
  --apiserver-count=1 \
  --audit-log-maxage=30 \
  --audit-log-maxbackup=3 \
  --audit-log-maxsize=100 \
  --audit-log-path=/var/log/kube-apiserver-audit.log \
  --event-ttl=1h \
  --alsologtostderr=false \
  --log-dir=/var/log/kubernetes \
  --v=4"
EOF

如果 etcd 是一个集群，则 --etcd-servers 可以添加多个，例如：--etcd-servers=https://10.128.170.21:2379,https://10.128.170.22:2379,https://10.128.170.23:2379

生成 token 文件

1
2
3

➜ cat > /etc/kubernetes/token.csv << EOF
$(head -c 16 /dev/urandom | od -An -t x | tr -d ' '),kubelet-bootstrap,10001,"system:node-bootstrapper"
EOF

在这个命令中，head -c 16 /dev/urandom | od -An -t x | tr -d ' ' 生成了一个 16 字节的随机字符串，并将其转换为十六进制格式。这个字符串将作为令牌的值。
kubelet-bootstrap 是令牌的用户名
10001 是令牌的 UID，
system:node-bootstrapper 是令牌的组名。
这些值将用于 kubelet 节点的身份验证和授权。

编写服务启动脚本

➜ cat > /usr/lib/systemd/system/kube-apiserver.service << "EOF"
[Unit]
Description=Kubernetes API Server
Documentation=https://github.com/kubernetes/kubernetes
After=network.target network-online.target
Wants=network-online.target

[Service]
Type=notify
EnvironmentFile=/etc/kubernetes/kube-apiserver.conf
ExecStart=/usr/local/bin/kube-apiserver $KUBE_APISERVER_OPTS
Restart=on-failure
RestartSec=5
LimitNOFILE=65535

[Install]
WantedBy=multi-user.target
EOF

启动 kube-apiserver 服务

➜ systemctl daemon-reload

➜ systemctl enable --now kube-apiserver

# 验证结果
➜ systemctl status kube-apiserver

# 查看日志
➜ journalctl -u kube-apiserver

6. 部署 kubectl

部署完 kube-apiserver 后，就可以部署 kubectl 了，因为 kubectl 可以验证 kube-apiserver 是否已经正常工作了。

6.1 颁发证书

# kubectl 证书签署申请
# O 参数的值必须为 system:masters，因为这是 kube-apiserver 一个内置好的角色，拥有集群管理的权限
➜ cat > kubectl-csr.json << EOF
{
    "CN": "clusteradmin",
    "key": {
        "algo": "rsa",
        "size": 2048
    },
    "names": [
        {
            "C": "CN",
            "ST": "GuangDong",
            "L": "ShenZhen",
            "O": "system:masters",
            "OU": "system"
        }
    ]
}
EOF

# 签署 kubectl 证书
➜ cfssl gencert -ca=ca.pem -ca-key=ca-key.pem -config=ca-config.json -profile=kubernetes kubectl-csr.json | cfssljson -bare kubectl

# 验证结果，会生成两个证书文件
➜ ll kubectl*pem

-rw------- 1 haxi haxi 1675 Dec 30 11:34 kubectl-key.pem
-rw-rw-r-- 1 haxi haxi 1415 Dec 30 11:34 kubectl.pem

6.2 生成配置文件

➜ kubectl config set-cluster kubernetes --certificate-authority=ca.pem --embed-certs=true --server=https://10.128.170.20:6443 --kubeconfig=kube.config

➜ kubectl config set-credentials clusteradmin --client-certificate=kubectl.pem --client-key=kubectl-key.pem --embed-certs=true --kubeconfig=kube.config

➜ kubectl config set-context kubernetes --cluster=kubernetes --user=clusteradmin --kubeconfig=kube.config

➜ kubectl config use-context kubernetes --kubeconfig=kube.config

➜ mkdir -p ~/.kube

➜ cp kube.config ~/.kube/config

以上命令用于在本地创建一个 Kubernetes 配置文件 kube.config，并将其复制到 ~/.kube/config 文件中，以便使用 kubectl 命令与 Kubernetes 集群进行交互。

kubectl config set-cluster 命令设置了一个名为 kubernetes 的集群，指定了以下参数：
--certificate-authority=ca.pem：指定 CA 证书文件的路径。
--embed-certs=true：将 CA 证书嵌入到配置文件中。
--server=https://10.128.170.20:6443：指定 API Server 的地址和端口。
--kubeconfig=kube.config：指定要写入的配置文件路径。
这些参数将用于创建一个名为 kubernetes 的集群配置，并将其写入到 kube.config 文件中。
kubectl config set-credentials 命令设置了一个名为 clusteradmin 的用户，指定了以下参数：
--client-certificate=kubectl.pem：指定客户端证书文件的路径。
--client-key=kubectl-key.pem：指定客户端私钥文件的路径。
--embed-certs=true：将客户端证书和私钥嵌入到配置文件中。
--kubeconfig=kube.config：指定要写入的配置文件路径。
这些参数将用于创建一个名为 clusteradmin 的用户配置，并将其写入到 kube.config 文件中。
kubectl config set-context 命令设置了一个名为 kubernetes 的上下文，指定了以下参数：
--cluster=kubernetes：指定要使用的集群。
--user=clusteradmin：指定要使用的用户。
--kubeconfig=kube.config：指定要写入的配置文件路径。
这些参数将用于创建一个名为 kubernetes 的上下文配置，并将其写入到 kube.config 文件中。
kubectl config use-context 命令将当前上下文设置为 kubernetes，指定了以下参数：
--kubeconfig=kube.config：指定要使用的配置文件路径。
这个命令将当前上下文设置为 kubernetes，以便 kubectl 命令可以使用 kube.config 文件与 Kubernetes 集群进行交互。

6.3 获取集群信息

➜ kubectl cluster-info

Kubernetes control plane is running at https://10.128.170.20:6443

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

➜ kubectl get all -A

NAMESPACE   NAME                 TYPE        CLUSTER-IP   EXTERNAL-IP   PORT(S)   AGE
default     service/kubernetes   ClusterIP   10.96.0.1            443/TCP   22m

➜ kubectl get cs

Warning: v1 ComponentStatus is deprecated in v1.19+
NAME                 STATUS      MESSAGE                                                                                        ERROR
scheduler            Unhealthy   Get "https://127.0.0.1:10259/healthz": dial tcp 127.0.0.1:10259: connect: connection refused
controller-manager   Unhealthy   Get "https://127.0.0.1:10257/healthz": dial tcp 127.0.0.1:10257: connect: connection refused
etcd-0               Healthy     {"health": "true"}

6.4 设置 kubectl 自动补全

查看 kubectl 命令自动补全帮助：

kubectl completion --help
````

安装 bash-completion：

```shell
yum install bash-completion -y

设置 kubectl 自动补全配置：

echo "source <(kubectl completion bash)" >> ~/.bashrc
````

## 7. 部署 kube-controller-manager

### 7.1 颁发证书

```shell
# kube-controller-manager 证书签署申请
# hosts 字段中，IP 为所有节点地址，这里可以做好规划，预留几个 IP，以备以后扩容。我这里写 6 个 IP
➜ cat > kube-controller-manager-csr.json << EOF
{
    "CN": "system:kube-controller-manager",
    "hosts": [
        "127.0.0.1",
        "10.128.170.20",
        "10.128.170.21",
        "10.128.170.22",
        "10.128.170.23",
        "10.128.170.24",
        "10.128.170.25",
        "cnode0",
        "cnode1",
        "cnode2",
        "cnode3",
        "cnode4",
        "cnode5",
        "cnode0.com",
        "cnode1.com",
        "cnode2.com",
        "cnode3.com",
        "cnode4.com",
        "cnode5.com"
    ],
    "key": {
        "algo": "rsa",
        "size": 2048
    },
    "names": [
        {
            "C": "CN",
            "ST": "GuangDong",
            "L": "ShenZhen",
            "O": "system:kube-controller-manager",
            "OU": "system"
        }
    ]
}
EOF

# 签署 kube-controller-manager 证书
➜ cfssl gencert -ca=ca.pem -ca-key=ca-key.pem -config=ca-config.json -profile=kubernetes kube-controller-manager-csr.json | cfssljson -bare kube-controller-manager

# 验证结果，会生成两个证书文件
➜ ll kube-controller-manager*pem

-rw------- 1 haxi haxi 1679 Dec 30 12:13 kube-controller-manager-key.pem
-rw-rw-r-- 1 haxi haxi 1513 Dec 30 12:13 kube-controller-manager.pem

# 复制 kube-controler-manager 证书到 /etc/kubernetes/pki
➜ cp kube-controller-manager*pem /etc/kubernetes/pki

7.2 部署 kube-controller-manager

编写服务配置文件

➜ cat > /etc/kubernetes/kube-controller-manager.conf << EOF
KUBE_CONTROLLER_MANAGER_OPTS="--port=0 \
  --secure-port=10257 \
  --kubeconfig=/etc/kubernetes/kube-controller-manager.kubeconfig \
  --service-cluster-ip-range=10.96.0.0/16 \
  --cluster-name=kubernetes \
  --cluster-signing-cert-file=/etc/kubernetes/pki/ca.pem \
  --cluster-signing-key-file=/etc/kubernetes/pki/ca-key.pem \
  --cluster-signing-duration=87600h \
  --tls-cert-file=/etc/kubernetes/pki/kube-controller-manager.pem \
  --tls-private-key-file=/etc/kubernetes/pki/kube-controller-manager-key.pem \
  --service-account-private-key-file=/etc/kubernetes/pki/ca-key.pem \
  --root-ca-file=/etc/kubernetes/pki/ca.pem \
  --leader-elect=true \
  --controllers=*,bootstrapsigner,tokencleaner \
  --use-service-account-credentials=true \
  --horizontal-pod-autoscaler-sync-period=10s \
  --alsologtostderr=true \
  --logtostderr=false \
  --log-dir=/var/log/kubernetes \
  --allocate-node-cidrs=true \
  --cluster-cidr=10.240.0.0/12 \
  --v=4"
EOF

生成 kubeconfig

➜ kubectl config set-cluster kubernetes --certificate-authority=ca.pem --embed-certs=true --server=https://10.128.170.20:6443 --kubeconfig=kube-controller-manager.kubeconfig

➜ kubectl config set-credentials kube-controller-manager --client-certificate=kube-controller-manager.pem --client-key=kube-controller-manager-key.pem --embed-certs=true --kubeconfig=kube-controller-manager.kubeconfig

➜ kubectl config set-context default --cluster=kubernetes --user=kube-controller-manager --kubeconfig=kube-controller-manager.kubeconfig

➜ kubectl config use-context default --kubeconfig=kube-controller-manager.kubeconfig

➜ cp kube-controller-manager.kubeconfig /etc/kubernetes/

编写服务启动脚本

➜ cat > /usr/lib/systemd/system/kube-controller-manager.service << "EOF"
[Unit]
Description=Kubernetes controller manager
Documentation=https://github.com/kubernetes/kubernetes
After=network.target network-online.target
Wants=network-online.target

[Service]
EnvironmentFile=/etc/kubernetes/kube-controller-manager.conf
ExecStart=/usr/local/bin/kube-controller-manager $KUBE_CONTROLLER_MANAGER_OPTS
Restart=on-failure
RestartSec=5
LimitNOFILE=65535

[Install]
WantedBy=multi-user.target
EOF

启动 kube-controller-manager 服务

➜ systemctl daemon-reload

➜ systemctl enable --now kube-controller-manager

# 验证结果
➜ systemctl status kube-controller-manager

# 查看日志
➜ journalctl -u kube-controller-manager

查看组件状态

➜ kubectl get cs

Warning: v1 ComponentStatus is deprecated in v1.19+
NAME                 STATUS      MESSAGE                                                                                        ERROR
scheduler            Unhealthy   Get "https://127.0.0.1:10259/healthz": dial tcp 127.0.0.1:10259: connect: connection refused
controller-manager   Healthy     ok
etcd-0               Healthy     {"health": "true"}

8. 部署 kube-scheduler

8.1 颁发证书

# kube-scheduler 证书签署申请
# hosts 字段中，IP 为所有节点地址，这里可以做好规划，预留几个 IP，以备以后扩容。我这里写 6 个 IP
➜ cat > kube-scheduler-csr.json << EOF
{
    "CN": "system:kube-scheduler",
    "hosts": [
        "127.0.0.1",
        "10.128.170.20",
        "10.128.170.21",
        "10.128.170.22",
        "10.128.170.23",
        "10.128.170.24",
        "10.128.170.25",
        "cnode0",
        "cnode1",
        "cnode2",
        "cnode3",
        "cnode4",
        "cnode5",
        "cnode0.com",
        "cnode1.com",
        "cnode2.com",
        "cnode3.com",
        "cnode4.com",
        "cnode5.com"
    ],
    "key": {
        "algo": "rsa",
        "size": 2048
    },
    "names": [
        {
            "C": "CN",
            "ST": "GuangDong",
            "L": "ShenZhen",
            "O": "system:kube-scheduler",
            "OU": "system"
        }
    ]
}
EOF

# 签署 kube-scheduler 证书
➜ cfssl gencert -ca=ca.pem -ca-key=ca-key.pem -config=ca-config.json -profile=kubernetes kube-scheduler-csr.json | cfssljson -bare kube-scheduler

# 验证结果，会生成两个证书文件
➜ ll kube-scheduler*pem

-rw------- 1 haxi haxi 1679 Dec 30 13:19 kube-scheduler-key.pem
-rw-rw-r-- 1 haxi haxi 1489 Dec 30 13:19 kube-scheduler.pem

# 复制 kube-scheduler 证书到 /etc/kubernetes/pki
➜ cp kube-scheduler*pem /etc/kubernetes/pki

8.2 部署 kube-scheduler

编写服务配置文件

➜ cat > /etc/kubernetes/kube-scheduler.conf << EOF
KUBE_SCHEDULER_OPTS="--address=127.0.0.1 \
  --kubeconfig=/etc/kubernetes/kube-scheduler.kubeconfig \
  --leader-elect=true \
  --alsologtostderr=true \
  --logtostderr=false \
  --log-dir=/var/log/kubernetes \
  --v=4"
EOF

生成 kubeconfig

➜ kubectl config set-cluster kubernetes --certificate-authority=ca.pem --embed-certs=true --server=https://10.128.170.20:6443 --kubeconfig=kube-scheduler.kubeconfig

➜ kubectl config set-credentials kube-scheduler --client-certificate=kube-scheduler.pem --client-key=kube-scheduler-key.pem --embed-certs=true --kubeconfig=kube-scheduler.kubeconfig

➜ kubectl config set-context default --cluster=kubernetes --user=kube-scheduler --kubeconfig=kube-scheduler.kubeconfig

➜ kubectl config use-context default --kubeconfig=kube-scheduler.kubeconfig

➜ cp kube-scheduler.kubeconfig /etc/kubernetes/

编写服务启动脚本

➜ cat > /usr/lib/systemd/system/kube-scheduler.service << "EOF"
[Unit]
Description=Kubernetes scheduler
Documentation=https://github.com/kubernetes/kubernetes
After=network.target network-online.target
Wants=network-online.target

[Service]
EnvironmentFile=/etc/kubernetes/kube-scheduler.conf
ExecStart=/usr/local/bin/kube-scheduler $KUBE_SCHEDULER_OPTS
Restart=on-failure
RestartSec=5
LimitNOFILE=65535

[Install]
WantedBy=multi-user.target
EOF

启动 kube-scheduler 服务

➜ systemctl daemon-reload

➜ systemctl enable --now kube-scheduler

# 验证结果
➜ systemctl status kube-scheduler

# 查看日志
➜ journalctl -u kube-scheduler

查看组件状态

➜ 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"}

9. 部署 kubelet

master 节点上部署 kubelet 是可选的，一旦部署 kubelet，master 节点也可以运行 Pod，如果不希望 master 节点上运行 Pod，则可以给 master 节点打上污点。

master 节点部署 kubelet 是有好处的，一是可以通过诸如 kubectl get node 等命令查看节点信息，二是可以在上面部署监控系统，日志采集系统等。

9.1 授权 kubelet 允许请求证书

授权 kubelet-bootstrap 用户允许请求证书

➜ kubectl create clusterrolebinding kubelet-bootstrap \
--clusterrole=system:node-bootstrapper \
--user=kubelet-bootstrap

clusterrolebinding.rbac.authorization.k8s.io/kubelet-bootstrap created

9.2 部署 kubelet

编写服务配置文件

➜ cat > /etc/kubernetes/kubelet.conf << EOF
KUBELET_OPTS="--bootstrap-kubeconfig=/etc/kubernetes/kubelet-bootstrap.kubeconfig \
  --config=/etc/kubernetes/kubelet.yaml \
  --kubeconfig=/etc/kubernetes/kubelet.kubeconfig \
  --cert-dir=/etc/kubernetes/pki \
  --network-plugin=cni \
  --pod-infra-container-image=registry.cn-hangzhou.aliyuncs.com/google_containers/pause:3.6 \
  --logtostderr=false \
  --v=4 \
  --log-dir=/var/log/kubernetes \
  --fail-swap-on=false"
EOF

➜ cat > /etc/kubernetes/kubelet.yaml << EOF
kind: KubeletConfiguration
apiVersion: kubelet.config.k8s.io/v1beta1
address: 0.0.0.0
port: 10250
readOnlyPort: 0
authentication:
  anonymous:
    enabled: false
  webhook:
    cacheTTL: 2m0s
    enabled: true
  x509:
    clientCAFile: /etc/kubernetes/pki/ca.pem
authorization:
  mode: Webhook
  webhook:
    cacheAuthorizedTTL: 5m0s
    cacheUnauthorizedTTL: 30s
cgroupDriver: systemd
clusterDNS:
- 10.96.0.10
clusterDomain: cluster.local
healthzBindAddress: 127.0.0.1
healthzPort: 10248
rotateCertificates: true
evictionHard:
  imagefs.available: 15%
  memory.available: 100Mi
  nodefs.available: 10%
  nodefs.inodesFree: 5%
maxOpenFiles: 1000000
maxPods: 110
EOF

生成 kubeconfig

➜ kubectl config set-cluster kubernetes --certificate-authority=ca.pem --embed-certs=true --server=https://10.128.170.20:6443 --kubeconfig=kubelet-bootstrap.kubeconfig

➜ kubectl config set-credentials kubelet-bootstrap --token=$(awk -F, '{print $1}' /etc/kubernetes/token.csv) --kubeconfig=kubelet-bootstrap.kubeconfig

➜ kubectl config set-context default --cluster=kubernetes --user=kubelet-bootstrap --kubeconfig=kubelet-bootstrap.kubeconfig

➜ kubectl config use-context default --kubeconfig=kubelet-bootstrap.kubeconfig

➜ cp kubelet-bootstrap.kubeconfig /etc/kubernetes/

编写服务启动脚本

➜ cat > /usr/lib/systemd/system/kubelet.service << "EOF"
[Unit]
Description=Kubernetes kubelet
After=network.target network-online.targer docker.service
Wants=docker.service

[Service]
EnvironmentFile=/etc/kubernetes/kubelet.conf
ExecStart=/usr/local/bin/kubelet $KUBELET_OPTS
Restart=on-failure
RestartSec=5
LimitNOFILE=65535

[Install]
WantedBy=multi-user.target
EOF

启动 kubelet 服务

➜ systemctl daemon-reload

➜ systemctl enable --now kubelet

# 验证结果
➜ systemctl status kubelet

# 查看日志
➜ journalctl -u kubelet

批准节点加入集群

➜ kubectl get csr

NAME        AGE   SIGNERNAME                                    REQUESTOR           REQUESTEDDURATION   CONDITION
csr-dtprn   11s   kubernetes.io/kube-apiserver-client-kubelet   kubelet-bootstrap                 Pending

➜ kubectl certificate approve csr-dtprn

certificatesigningrequest.certificates.k8s.io/csr-dtprn approved

➜ kubectl get csr

NAME        AGE    SIGNERNAME                                    REQUESTOR           REQUESTEDDURATION   CONDITION
csr-dtprn   113s   kubernetes.io/kube-apiserver-client-kubelet   kubelet-bootstrap                 Approved,Issued

查看节点

➜ kubectl get node

NAME     STATUS     ROLES    AGE   VERSION
cnode0   NotReady      57s   v1.23.6

# 此时节点状态还是 NotReady，因为还没有安装网络插件，正确安装网络插件后，状态会变为 Ready.

10. 部署 kube-proxy

10.1 颁发证书

# kube-proxy 证书签署申请
➜ cat > kube-proxy-csr.json << EOF
{
    "CN": "system:kube-proxy",
    "key": {
        "algo": "rsa",
        "size": 2048
    },
    "names": [
        {
            "C": "CN",
            "ST": "GuangDong",
            "L": "ShenZhen",
            "O": "k8s",
            "OU": "system"
        }
    ]
}
EOF

# 签署 kube-proxy 证书
➜ cfssl gencert -ca=ca.pem -ca-key=ca-key.pem -config=ca-config.json -profile=kubernetes kube-proxy-csr.json | cfssljson -bare kube-proxy

# 验证结果，会生成两个证书文件
➜ ll kube-proxy*pem

-rw------- 1 haxi haxi 1679 Dec 31 10:26 kube-proxy-key.pem
-rw-rw-r-- 1 haxi haxi 1407 Dec 31 10:26 kube-proxy.pem

# 复制 kube-proxy 证书到 /etc/kubernetes/pki
➜ cp kube-proxy*pem /etc/kubernetes/pki

10.2 部署 kube-proxy

编写服务配置文件

➜ cat > /etc/kubernetes/kube-proxy.conf << EOF
KUBE_PROXY_OPTS="--config=/etc/kubernetes/kube-proxy.yaml \
  --logtostderr=false \
  --v=4 \
  --log-dir=/var/log/kubernetes"
EOF

➜ cat > /etc/kubernetes/kube-proxy.yaml << EOF
kind: KubeProxyConfiguration
apiVersion: kubeproxy.config.k8s.io/v1alpha1
clientConnection:
  kubeconfig: /etc/kubernetes/kube-proxy.kubeconfig
bindAddress: 0.0.0.0
clusterCIDR: 10.240.0.0/12
healthzBindAddress: 0.0.0.0:10256
metricsBindAddress: 0.0.0.0:10249
mode: ipvs
ipvs:
  scheduler: "rr"
EOF

生成 kubeconfig

➜ kubectl config set-cluster kubernetes --certificate-authority=ca.pem --embed-certs=true --server=https://10.128.170.20:6443 --kubeconfig=kube-proxy.kubeconfig

➜ kubectl config set-credentials kube-proxy --client-certificate=kube-proxy.pem --client-key=kube-proxy-key.pem --embed-certs=true --kubeconfig=kube-proxy.kubeconfig

➜ kubectl config set-context default --cluster=kubernetes --user=kube-proxy --kubeconfig=kube-proxy.kubeconfig

➜ kubectl config use-context default --kubeconfig=kube-proxy.kubeconfig

➜ cp kube-proxy.kubeconfig /etc/kubernetes/

编写服务启动脚本

➜ cat > /usr/lib/systemd/system/kube-proxy.service << "EOF"
[Unit]
Description=Kubernetes Proxy
Documentation=https://github.com/kubernetes/kubernetes
After=network.target network-online.target
Wants=network-online.target

[Service]
EnvironmentFile=-/etc/kubernetes/kube-proxy.conf
ExecStart=/usr/local/bin/kube-proxy $KUBE_PROXY_OPTS
Restart=on-failure
RestartSec=5
LimitNOFILE=65535

[Install]
WantedBy=multi-user.target
EOF

启动 kube-proxy 服务

➜ systemctl daemon-reload

➜ systemctl enable --now kube-proxy

# 验证结果
➜ systemctl status kube-proxy

# 查看日志
➜ journalctl -u kube-proxy

11. 部署网络

11.1 部署 calico

参考地址 calico

➜ curl https://projectcalico.docs.tigera.io/v3.23/manifests/calico.yaml -O
# 修改 Pod IP 地址段，找到 CALICO_IPV4POOL_CIDR 变量，取消注释并修改如下
            - name: CALICO_IPV4POOL_CIDR
              value: "10.240.0.0/12"

➜ kubectl apply -f calico.yaml

configmap/calico-config created
customresourcedefinition.apiextensions.k8s.io/bgpconfigurations.crd.projectcalico.org created
customresourcedefinition.apiextensions.k8s.io/bgppeers.crd.projectcalico.org created
customresourcedefinition.apiextensions.k8s.io/blockaffinities.crd.projectcalico.org created
customresourcedefinition.apiextensions.k8s.io/caliconodestatuses.crd.projectcalico.org created
customresourcedefinition.apiextensions.k8s.io/clusterinformations.crd.projectcalico.org created
customresourcedefinition.apiextensions.k8s.io/felixconfigurations.crd.projectcalico.org created
customresourcedefinition.apiextensions.k8s.io/globalnetworkpolicies.crd.projectcalico.org created
customresourcedefinition.apiextensions.k8s.io/globalnetworksets.crd.projectcalico.org created
customresourcedefinition.apiextensions.k8s.io/hostendpoints.crd.projectcalico.org created
customresourcedefinition.apiextensions.k8s.io/ipamblocks.crd.projectcalico.org created
customresourcedefinition.apiextensions.k8s.io/ipamconfigs.crd.projectcalico.org created
customresourcedefinition.apiextensions.k8s.io/ipamhandles.crd.projectcalico.org created
customresourcedefinition.apiextensions.k8s.io/ippools.crd.projectcalico.org created
customresourcedefinition.apiextensions.k8s.io/ipreservations.crd.projectcalico.org created
customresourcedefinition.apiextensions.k8s.io/kubecontrollersconfigurations.crd.projectcalico.org created
customresourcedefinition.apiextensions.k8s.io/networkpolicies.crd.projectcalico.org created
customresourcedefinition.apiextensions.k8s.io/networksets.crd.projectcalico.org created
clusterrole.rbac.authorization.k8s.io/calico-kube-controllers created
clusterrolebinding.rbac.authorization.k8s.io/calico-kube-controllers created
clusterrole.rbac.authorization.k8s.io/calico-node created
clusterrolebinding.rbac.authorization.k8s.io/calico-node created
daemonset.apps/calico-node created
serviceaccount/calico-node created
deployment.apps/calico-kube-controllers created
serviceaccount/calico-kube-controllers created
poddisruptionbudget.policy/calico-kube-controllers created

# 查看网络 pod
➜ kubectl get deploy,pod -n kube-system

NAME                                      READY   UP-TO-DATE   AVAILABLE   AGE
deployment.apps/calico-kube-controllers   1/1     1            1           24m

NAME                                          READY   STATUS    RESTARTS   AGE
pod/calico-kube-controllers-6b77fff45-mxxkg   1/1     Running   0          24m
pod/calico-node-ld4sg                         1/1     Running   0          24m

# 查看 node 状态
➜ kubectl get node

NAME     STATUS   ROLES    AGE   VERSION
cnode0   Ready       38m   v1.23.6

# 查看 ipvs 模式
➜ ipvsadm -Ln

IP Virtual Server version 1.2.1 (size=4096)
Prot LocalAddress:Port Scheduler Flags
  -> RemoteAddress:Port           Forward Weight ActiveConn InActConn
TCP  10.96.0.1:443 rr
  -> 10.128.170.20:6443           Masq    1      5          0

如果 node 状态仍然是 NotReady，基本上是镜像未拉取完成或拉取失败导致的，如果一段时间后仍拉取失败，则尝试手动拉取镜像。

11.2 授权 kube-apiserver 访问 kubelet

Using RBAC Authorization

应用场景：例如 kubectl exec/run/logs

➜ cat > apiserver-to-kubelet-rbac.yaml << EOF
apiVersion: rbac.authorization.k8s.io/v1
kind: ClusterRole
metadata:
  annotations:
    rbac.authorization.kubernetes.io/autoupdate: "true"
  labels:
    kubernetes.io/bootstrapping: rbac-defaults
  name: system:kube-apiserver-to-kubelet
rules:
  - apiGroups:
      - ""
    resources:
      - nodes/proxy
      - nodes/stats
      - nodes/log
      - nodes/spec
      - nodes/metrics
      - pods/log
    verbs:
      - "*"
---
apiVersion: rbac.authorization.k8s.io/v1
kind: ClusterRoleBinding
metadata:
  name: system:kube-apiserver
  namespace: ""
roleRef:
  apiGroup: rbac.authorization.k8s.io
  kind: ClusterRole
  name: system:kube-apiserver-to-kubelet
subjects:
  - apiGroup: rbac.authorization.k8s.io
    kind: User
    name: kubernetes
EOF

➜ kubectl apply -f apiserver-to-kubelet-rbac.yaml

clusterrole.rbac.authorization.k8s.io/system:kube-apiserver-to-kubelet created
clusterrolebinding.rbac.authorization.k8s.io/system:kube-apiserver created

➜ kubectl logs calico-kube-controllers-6b77fff45-mxxkg -n kube-system

11.3 部署 coredns

参考地址 coredns

coredns.yaml.sed 原始文件见附录章节 "16.1 coredns.yaml.sed"，该 yaml 指定使用的 coredns 的版本是 1.9.2。

下载 yaml 文件

1	➜ curl https://raw.githubusercontent.com/coredns/deployment/master/kubernetes/coredns.yaml.sed -o coredns.yaml

对 yaml 文件做如下修改：

CLUSTER_DOMAIN 改为 cluster.local
REVERSE_CIDRS 改为 in-addr.arpa ip6.arpa
UPSTREAMNAMESERVER 改为 /etc/resolv.conf，如果报错，则改成当前网络所使用的 DNS 地址
删除 STUBDOMAINS
CLUSTER_DNS_IP 改为 10.96.0.10（应与 /etc/kubernetes/kubelet.yaml 中配置的 clusterDNS 保持一致）

1	➜ kubectl apply -f coredns.yaml

验证（如果 calico 的 pod 未就绪，请检查是否是镜像拉取未完成或镜像拉取失败）

➜ kubectl get deploy,pod,svc -n kube-system
NAME                                      READY   UP-TO-DATE   AVAILABLE   AGE
deployment.apps/calico-kube-controllers   1/1     1            1           43m
deployment.apps/coredns                   1/1     1            1           3m8s

NAME                                          READY   STATUS    RESTARTS   AGE
pod/calico-kube-controllers-6b77fff45-mxxkg   1/1     Running   0          43m
pod/calico-node-ld4sg                         1/1     Running   0          43m
pod/coredns-799bc9dbc6-qqh7h                  1/1     Running   0          3m8s

NAME               TYPE        CLUSTER-IP   EXTERNAL-IP   PORT(S)                  AGE
service/kube-dns   ClusterIP   10.96.0.10           53/UDP,53/TCP,9153/TCP   3m8s

dig 测试

➜ yum install bind-utils -y

➜ dig -t A www.baidu.com @10.96.0.10 +short

www.a.shifen.com.
182.61.200.6
182.61.200.7

pod 测试

Kubernetes busybox nslookup问题

➜ kubectl run -it --rm --image=busybox:1.28.3 -- sh

If you don't see a command prompt, try pressing enter.
/ # cat /etc/resolv.conf
nameserver 10.96.0.10
search default.svc.cluster.local svc.cluster.local cluster.local
options ndots:5
/ # nslookup kubernetes.default
Server:    10.96.0.10
Address 1: 10.96.0.10 kube-dns.kube-system.svc.cluster.local

Name:      kubernetes.default
Address 1: 10.96.0.1 kubernetes.default.svc.cluster.local
/ # ping -c 4 www.baidu.com
PING www.baidu.com (182.61.200.6): 56 data bytes
64 bytes from 182.61.200.6: seq=0 ttl=52 time=6.860 ms
64 bytes from 182.61.200.6: seq=1 ttl=52 time=6.592 ms
64 bytes from 182.61.200.6: seq=2 ttl=52 time=6.488 ms
64 bytes from 182.61.200.6: seq=3 ttl=52 time=7.288 ms

--- www.baidu.com ping statistics ---
4 packets transmitted, 4 packets received, 0% packet loss
round-trip min/avg/max = 6.488/6.807/7.288 ms

12. 添加 worker 节点

worker 节点需要部署两个组件 kubelet, kube-proxy.

（master 节点执行）从 master 节点上复制以下文件到 worker 节点

➜ scp /etc/kubernetes/pki/ca.pem \
       /etc/kubernetes/pki/kube-proxy.pem \
       /etc/kubernetes/pki/kube-proxy-key.pem \
       root@cnode1:/etc/kubernetes/pki/

➜ scp /etc/kubernetes/kubelet.conf \
       /etc/kubernetes/kubelet.yaml \
       /etc/kubernetes/kubelet-bootstrap.kubeconfig \
       /etc/kubernetes/kube-proxy.conf \
       /etc/kubernetes/kube-proxy.yaml \
       /etc/kubernetes/kube-proxy.kubeconfig \
       root@cnode1:/etc/kubernetes/

➜ scp /usr/lib/systemd/system/kubelet.service \
       /usr/lib/systemd/system/kube-proxy.service \
       root@cnode1:/usr/lib/systemd/system/

（master 节点执行）复制 kubelet, kube-proxy 二进制程序到 /usr/local/bin

1
2
3

➜ scp /usr/local/bin/kubelet \
       /usr/local/bin/kube-proxy \
       root@cnode1:/usr/local/bin/

（worker 节点执行）worker 节点启动 kube-proxy 服务

➜ systemctl daemon-reload

➜ systemctl enable --now kube-proxy

# 验证结果
➜ systemctl status kube-proxy

# 查看日志
➜ journalctl -u kube-proxy

（worker 节点执行）worker 节点启动 kubelet 服务

➜ systemctl daemon-reload

➜ systemctl enable --now kubelet

# 验证结果
➜ systemctl status kubelet

# 查看日志
➜ journalctl -u kubelet

（master 节点执行）批准 worker 节点加入集群

➜ kubectl get csr

NAME        AGE   SIGNERNAME                                    REQUESTOR           REQUESTEDDURATION   CONDITION
csr-9mvtn   23s   kubernetes.io/kube-apiserver-client-kubelet   kubelet-bootstrap                 Pending

➜ kubectl certificate approve csr-9mvtn

certificatesigningrequest.certificates.k8s.io/csr-9mvtn approved

➜ kubectl get csr

NAME        AGE     SIGNERNAME                                    REQUESTOR           REQUESTEDDURATION   CONDITION
csr-9mvtn   3m16s   kubernetes.io/kube-apiserver-client-kubelet   kubelet-bootstrap                 Approved,Issued

（master 节点执行）查看节点

➜ kubectl get node

NAME     STATUS   ROLES    AGE     VERSION
cnode0   Ready       4h31m   v1.23.6
cnode1   Ready       105m    v1.23.6

如果 cnode1 的状态仍是 NotReady，请检查是否是镜像拉取未完成或镜像拉取失败。

13. 禁止 master 节点运行 pod

至此 1 master 1 worker 的 k8s 二进制集群已搭建完毕。

此外，还可以给节点打上角色标签，使得查看节点信息更加直观

# 给 master 节点打上 controlplane,etcd 角色标签
➜ kubectl label node cnode0 node-role.kubernetes.io/controlplane=true node-role.kubernetes.io/etcd=true

# 给 worker 节点打上 worker 角色标签
➜ kubectl label node cnode1 node-role.kubernetes.io/worker=true

# 查看节点标签
➜ kubectl get node --show-labels

如果不希望 master 节点运行 Pod，则给 master 打上污点

1	➜ kubectl taint node cnode0 node-role.kubernetes.io/controlplane=true:NoSchedule

后续可以新增 2 个 etcd 节点组成 etcd 集群，新增 2 个控制平面，避免单点故障。

14. 测试应用服务部署

创建 namespace

➜ kubectl create namespace dev

namespace/dev created

➜ kubectl get namespace

NAME              STATUS   AGE
default           Active   15h
dev               Active   15s
kube-node-lease   Active   15h
kube-public       Active   15h
kube-system       Active   15h

创建 deployment

➜ mkdir -p /etc/kubernetes/resources

➜ cat > /etc/kubernetes/resources/nginx-deployment.yaml << EOF
apiVersion: apps/v1
kind: Deployment
metadata:
  name: nginx-deployment
  namespace: dev
spec:
  replicas: 1
  selector:
    matchLabels:
      app: nginx-pod
  template:
    metadata:
      labels:
        app: nginx-pod
    spec:
      containers:
      - name: nginx
        image: nginx:latest
EOF

➜ kubectl apply -f /etc/kubernetes/resources/nginx-deployment.yaml

deployment.apps/nginx-deployment created

➜ kubectl get pod -n dev

NAME                                READY   STATUS    RESTARTS   AGE
nginx-deployment-7d4578b56c-cndrb   1/1     Running   0          48s

创建 service

➜ cat > /etc/kubernetes/resources/nginx-service.yaml << EOF
apiVersion: v1
kind: Service
metadata:
  name: nginx-service
  namespace: dev
spec:
  selector:
    app: nginx-pod
  type: NodePort
  ports:
  - port: 80
    targetPort: 80
    nodePort: 30001
EOF

➜ kubectl apply -f /etc/kubernetes/resources/nginx-service.yaml

service/nginx-service created

➜ kubectl get svc -n dev

NAME            TYPE       CLUSTER-IP      EXTERNAL-IP   PORT(S)        AGE
nginx-service   NodePort   10.96.221.226           80:30001/TCP   17s

测试服务访问

➜ curl 10.128.170.20:30001 -I

HTTP/1.1 200 OK
Server: nginx/1.21.5
Date: Sat, 21 May 2022 08:06:25 GMT
Content-Type: text/html
Content-Length: 615
Last-Modified: Tue, 28 Dec 2021 15:28:38 GMT
Connection: keep-alive
ETag: "61cb2d26-267"
Accept-Ranges: bytes

15. 部署 Dashboard

官方参考文档：https://kubernetes.io/docs/tasks/access-application-cluster/web-ui-dashboard/

使用 nodeport 方式将 dashboard 服务暴露在集群外，指定使用 30443 端口。

# 下载相关 yaml 文件
➜ curl https://raw.githubusercontent.com/kubernetes/dashboard/v2.5.0/aio/deploy/recommended.yaml -O

# 修改 Service 部分
➜ vim recommended.yaml
kind: Service
apiVersion: v1
metadata:
  labels:
    k8s-app: kubernetes-dashboard
  name: kubernetes-dashboard
  namespace: kubernetes-dashboard
spec:
  type: NodePort  # 新增
  ports:
    - port: 443
      targetPort: 8443
      nodePort: 30443  # 新增
  selector:
    k8s-app: kubernetes-dashboard

# 部署
➜ kubectl apply -f recommended.yaml

namespace/kubernetes-dashboard created
serviceaccount/kubernetes-dashboard created
service/kubernetes-dashboard created
secret/kubernetes-dashboard-certs created
secret/kubernetes-dashboard-csrf created
secret/kubernetes-dashboard-key-holder created
configmap/kubernetes-dashboard-settings created
role.rbac.authorization.k8s.io/kubernetes-dashboard created
clusterrole.rbac.authorization.k8s.io/kubernetes-dashboard created
rolebinding.rbac.authorization.k8s.io/kubernetes-dashboard created
clusterrolebinding.rbac.authorization.k8s.io/kubernetes-dashboard created
deployment.apps/kubernetes-dashboard created
service/dashboard-metrics-scraper created
deployment.apps/dashboard-metrics-scraper created

# 查看 kubernetes-dashboard 下的资源
➜ kubectl get deploy -n kubernetes-dashboard

NAME                        READY   UP-TO-DATE   AVAILABLE   AGE
dashboard-metrics-scraper   1/1     1            1           12m
kubernetes-dashboard        1/1     1            1           12m

➜ kubectl get pod -n kubernetes-dashboard

NAME                                         READY   STATUS    RESTARTS   AGE
dashboard-metrics-scraper-799d786dbf-xpvcc   1/1     Running   0          13m
kubernetes-dashboard-546cbc58cd-hzvhr        1/1     Running   0          13m

➜ kubectl get svc -n kubernetes-dashboard

NAME                        TYPE        CLUSTER-IP      EXTERNAL-IP   PORT(S)         AGE
dashboard-metrics-scraper   ClusterIP   10.96.73.62             8000/TCP        13m
kubernetes-dashboard        NodePort    10.96.148.106           443:30443/TCP   13m

如果 kubernetes-dashboard 下的资源一直未就绪，请检查是否是正在拉取镜像或者镜像一直拉取失败。

➜ kubectl describe pod kubernetes-dashboard-546cbc58cd-hzvhr -n kubernetes-dashboard

...
Events:
  Type    Reason     Age    From               Message
  ----    ------     ----   ----               -------
  Normal  Scheduled  6m20s  default-scheduler  Successfully assigned kubernetes-dashboard/kubernetes-dashboard-546cbc58cd-hzvhr to cnode1
  Normal  Pulling    6m20s  kubelet            Pulling image "kubernetesui/dashboard:v2.5.0"

➜ kubectl describe pod kubernetes-dashboard-546cbc58cd-hzvhr -n kubernetes-dashboard

Events:
  Type     Reason          Age                 From               Message
  ----     ------          ----                ----               -------
  Normal   Scheduled       10m                 default-scheduler  Successfully assigned kubernetes-dashboard/kubernetes-dashboard-546cbc58cd-hzvhr to cnode1
  Warning  Failed          2m1s                kubelet            Failed to pull image "kubernetesui/dashboard:v2.5.0": rpc error: code = Unknown desc = dial tcp 104.18.124.25:443: i/o timeout
  Warning  Failed          2m1s                kubelet            Error: ErrImagePull
  Normal   SandboxChanged  2m                  kubelet            Pod sandbox changed, it will be killed and re-created.
  Normal   BackOff         118s (x3 over 2m)   kubelet            Back-off pulling image "kubernetesui/dashboard:v2.5.0"
  Warning  Failed          118s (x3 over 2m)   kubelet            Error: ImagePullBackOff
  Normal   Pulling         106s (x2 over 10m)  kubelet            Pulling image "kubernetesui/dashboard:v2.5.0"
  Normal   Pulled          25s                 kubelet            Successfully pulled image "kubernetesui/dashboard:v2.5.0" in 1m21.608630166s
  Normal   Created         22s                 kubelet            Created container kubernetes-dashboard
  Normal   Started         21s                 kubelet            Started container kubernetes-dashboard

创建 service account 并绑定默认 cluster-admin 管理员集群角色

# 下面创建了一个叫 admin-user 的服务账号，放在 kubernetes-dashboard 命名空间下，并将 cluster-admin 角色绑定到 admin-user 账户，这样 admin-user 账户就有了管理员的权限。
# 默认情况下，kubeadm 创建集群时已经创建了 cluster-admin 角色，我们直接绑定即可。
➜ cat > dashboard-admin-user.yaml << EOF
apiVersion: v1
kind: ServiceAccount
metadata:
  name: admin-user
  namespace: kubernetes-dashboard

---
apiVersion: rbac.authorization.k8s.io/v1
kind: ClusterRoleBinding
metadata:
  name: admin-user
roleRef:
  apiGroup: rbac.authorization.k8s.io
  kind: ClusterRole
  name: cluster-admin
subjects:
- kind: ServiceAccount
  name: admin-user
  namespace: kubernetes-dashboard
EOF

# 应用资源配置清单
➜ kubectl apply -f dashboard-admin-user.yaml

serviceaccount/admin-user created
clusterrolebinding.rbac.authorization.k8s.io/admin-user created

查看 admin-user 账户的 token

➜ kubectl -n kubernetes-dashboard describe secret $(kubectl -n kubernetes-dashboard get secret | grep admin-user | awk '{print $1}')

Name:         admin-user-token-vmbfm
Namespace:    kubernetes-dashboard
Labels:       
Annotations:  kubernetes.io/service-account.name: admin-user
              kubernetes.io/service-account.uid: bc3c111d-947e-4444-8fc0-2ff69abada00

Type:  kubernetes.io/service-account-token

Data
====
ca.crt:     1367 bytes
namespace:  20 bytes
token:      eyJhbGciOiJSUzI1NiIsImtpZCI6Ikd6alY4Rm1QWFRiRk9VUDlta1U1QnFVM2VyUXpXSkUwRzRKek9QX2pxbUkifQ.eyJpc3MiOiJrdWJlcm5ldGVzL3NlcnZpY2VhY2NvdW50Iiwia3ViZXJuZXRlcy5pby9zZXJ2aWNlYWNjb3VudC9uYW1lc3BhY2UiOiJrdWJlcm5ldGVzLWRhc2hib2FyZCIsImt1YmVybmV0ZXMuaW8vc2VydmljZWFjY291bnQvc2VjcmV0Lm5hbWUiOiJhZG1pbi11c2VyLXRva2VuLXZtYmZtIiwia3ViZXJuZXRlcy5pby9zZXJ2aWNlYWNjb3VudC9zZXJ2aWNlLWFjY291bnQubmFtZSI6ImFkbWluLXVzZXIiLCJrdWJlcm5ldGVzLmlvL3NlcnZpY2VhY2NvdW50L3NlcnZpY2UtYWNjb3VudC51aWQiOiJiYzNjMTExZC05NDdlLTQ0NDQtOGZjMC0yZmY2OWFiYWRhMDAiLCJzdWIiOiJzeXN0ZW06c2VydmljZWFjY291bnQ6a3ViZXJuZXRlcy1kYXNoYm9hcmQ6YWRtaW4tdXNlciJ9.e-fkl4gBppWnwMy5b1PvHNf5RiBL_uAT0o_QFTy4YWwkcBSnn9JqlCBJzy6Vblw2mIekkMwuOGux-vU8V9nPuAHczsKr1Kq2leZKR0rnNrFwqge-IO-U4pkY8sfWYWPo7j5Oop1dNAKt9q33WyenjpA6T_IF-TmdtsX4AhLeZp67RrDotq80dpSjmSBzDU2rZ6gwknCfCwum_Crn1uruNiGGP4dkFifIK78RfDyCIMdMvYuwoa9hYPTFVNPZQcTRecmdtOmfXyVHpS7FfKf3YTCm9vbyqrBLyzHinYf-dBBr5ivktJKOepuqbKSoQ68Q1KnxjeG9ouWaYa3jiukArw

使用输出的 token 登录 Dashboard

16. 附录

16.1 coredns.yaml.sed

apiVersion: v1
kind: ServiceAccount
metadata:
  name: coredns
  namespace: kube-system
---
apiVersion: rbac.authorization.k8s.io/v1
kind: ClusterRole
metadata:
  labels:
    kubernetes.io/bootstrapping: rbac-defaults
  name: system:coredns
rules:
  - apiGroups:
    - ""
    resources:
    - endpoints
    - services
    - pods
    - namespaces
    verbs:
    - list
    - watch
  - apiGroups:
    - discovery.k8s.io
    resources:
    - endpointslices
    verbs:
    - list
    - watch
---
apiVersion: rbac.authorization.k8s.io/v1
kind: ClusterRoleBinding
metadata:
  annotations:
    rbac.authorization.kubernetes.io/autoupdate: "true"
  labels:
    kubernetes.io/bootstrapping: rbac-defaults
  name: system:coredns
roleRef:
  apiGroup: rbac.authorization.k8s.io
  kind: ClusterRole
  name: system:coredns
subjects:
- kind: ServiceAccount
  name: coredns
  namespace: kube-system
---
apiVersion: v1
kind: ConfigMap
metadata:
  name: coredns
  namespace: kube-system
data:
  Corefile: |
    .:53 {
        errors
        health {
          lameduck 5s
        }
        ready
        kubernetes CLUSTER_DOMAIN REVERSE_CIDRS {
          fallthrough in-addr.arpa ip6.arpa
        }
        prometheus :9153
        forward . UPSTREAMNAMESERVER {
          max_concurrent 1000
        }
        cache 30
        loop
        reload
        loadbalance
    }STUBDOMAINS
---
apiVersion: apps/v1
kind: Deployment
metadata:
  name: coredns
  namespace: kube-system
  labels:
    k8s-app: kube-dns
    kubernetes.io/name: "CoreDNS"
spec:
  # replicas: not specified here:
  # 1. Default is 1.
  # 2. Will be tuned in real time if DNS horizontal auto-scaling is turned on.
  strategy:
    type: RollingUpdate
    rollingUpdate:
      maxUnavailable: 1
  selector:
    matchLabels:
      k8s-app: kube-dns
  template:
    metadata:
      labels:
        k8s-app: kube-dns
    spec:
      priorityClassName: system-cluster-critical
      serviceAccountName: coredns
      tolerations:
        - key: "CriticalAddonsOnly"
          operator: "Exists"
      nodeSelector:
        kubernetes.io/os: linux
      affinity:
         podAntiAffinity:
           requiredDuringSchedulingIgnoredDuringExecution:
           - labelSelector:
               matchExpressions:
               - key: k8s-app
                 operator: In
                 values: ["kube-dns"]
             topologyKey: kubernetes.io/hostname
      containers:
      - name: coredns
        image: coredns/coredns:1.9.2
        imagePullPolicy: IfNotPresent
        resources:
          limits:
            memory: 170Mi
          requests:
            cpu: 100m
            memory: 70Mi
        args: [ "-conf", "/etc/coredns/Corefile" ]
        volumeMounts:
        - name: config-volume
          mountPath: /etc/coredns
          readOnly: true
        ports:
        - containerPort: 53
          name: dns
          protocol: UDP
        - containerPort: 53
          name: dns-tcp
          protocol: TCP
        - containerPort: 9153
          name: metrics
          protocol: TCP
        securityContext:
          allowPrivilegeEscalation: false
          capabilities:
            add:
            - NET_BIND_SERVICE
            drop:
            - all
          readOnlyRootFilesystem: true
        livenessProbe:
          httpGet:
            path: /health
            port: 8080
            scheme: HTTP
          initialDelaySeconds: 60
          timeoutSeconds: 5
          successThreshold: 1
          failureThreshold: 5
        readinessProbe:
          httpGet:
            path: /ready
            port: 8181
            scheme: HTTP
      dnsPolicy: Default
      volumes:
        - name: config-volume
          configMap:
            name: coredns
            items:
            - key: Corefile
              path: Corefile
---
apiVersion: v1
kind: Service
metadata:
  name: kube-dns
  namespace: kube-system
  annotations:
    prometheus.io/port: "9153"
    prometheus.io/scrape: "true"
  labels:
    k8s-app: kube-dns
    kubernetes.io/cluster-service: "true"
    kubernetes.io/name: "CoreDNS"
spec:
  selector:
    k8s-app: kube-dns
  clusterIP: CLUSTER_DNS_IP
  ports:
  - name: dns
    port: 53
    protocol: UDP
  - name: dns-tcp
    port: 53
    protocol: TCP
  - name: metrics
    port: 9153
    protocol: TCP

References

二进制部署 K8s 集群 1.23.1 版本

部署一套完整的企业级K8s集群

使用GNU-make管理项目

2020-10-25T09:40:46.000Z

在本文中读者会看到有关 make 的介绍，make 是一种控制编译或者重复编译软件的工具。make 可以自动管理软件编译的内容、方式和时机，从而使程序员能够把精力集中在编写代码上。

使用 GNU make 管理项目

第 4 章使用 GNU make 管理项目 原文出处：《GNU/Linux编程指南》第二版原文作者： Kurt Wall 等著

1 为何使用 make

除了最简单的软件项目，make 对于其他所有项目而言都很必要。首先，包含多个源代码文件的项月在编译时都有长而且复杂的命令行。而且，编程项目经常需要使用那些很少用到且难以记忆的特殊编译选项。make 可以通过把这些复杂而难记的命令行保存在 makefle 文件中来解决上述两个问题，makefile 将在下一小节讨论。

make 还能减少重复编译所需要的时间，因为它很聪明，能够判断哪些文件被修改过。进而只重新编译程序被修改过的部分。makefile 为项目构建了一个依赖信息数据库，因而可以让 make 在每次编译前检查是否可以找到所有需要的文件。make 还可以让你建立一个稳定的编译环境。最后，make 可以让编译过程自动执行，因为从 shell 脚本或者 cron (定时)作业调用 make 非常容易。

2 编写 makefile

make 是怎样完成这些神奇工作的呢？是通过使用 makefile 文件做到的。

makefile 是一个文本形式的数据库文件，其中包含一些规则告诉 make 编译哪些文件、怎样编译以及在什么条件下去编译。每条规则包含以下内容：

一个 "目标体" (target)，即 make 最终需要创建的东西。
包含一个或多个 "依赖体" (dependency)的列表，依赖体通常是编泽目标体需要的其他文件。
为了从指定的依赖体创建出目标体所需执行的 "命令" (command) 的列表。

虽然目标体通常都是程序，但它们可以是诸如文本文件、手册页面等任何东西。目标体甚至能测试和设置环境变量。类似地，也可以定义依赖体以确保编译开始前存在某个特殊的环境变量。最后，makefile 中的命令可以是编译器的命令或 shell 命令，它们能设置环境变量、删除文件,或者任何俞令行所能完成的功能,如从 FTP 站点下载文件等。GNU make 被调用后会顺序查找名为 GNUmakefile、makefile 或 Makefile 的文件。出于某种原因，可能只是习惯和长期形成的约定吧，大多数 Linux 程序员使用最后一种形式 Makefile。

Makefile 规则有下列通用形式：

target: dependency [dependency [...]
command
command
[...]

警告:

每一个命令的第一个字符必须是制表符，仗使用 8 个空格是不够的。这一点经常不被人们注意，并且当所使用的编辑器友好的将制表符转换成 8 个空格时，会产生问题；因为如果用空格代替制表符，make 会在执行过程中显示 Missing Separator (缺少分隔符)并停止。

target 是需要创建的二进制文件或目标文件。dependency 是在创建 target 时需要输入的一个或多个文件的列表。命令序列是创建 target 文件所需要的步骤，如编译命令。此外，除非特别指定，否则 make 的工作目录就是当前目录。

3 编写 makefile 的规则

如果上一节的内容对你来说太抽象，那么本节使用程序清单 4.1 再具体讨论。这是用于编译第 3 章中出现的程序 howdy 和 hello 的 makefile 文件。

程序清单 4.1 演示目标体、依赖体和命令的简单 makefile 文件

howdy: howdy.o helper.o helper.h
gcc howdy.o helper.o -o howdy

helper.o: helper.c helper.h
gcc -c helper.c

howdy.o: howdy.c
gcc -c howdy.c

hello: hello.c
gcc hello.c -o hello

all: howdy hello

clean:
rm howdy hello *.o

要编译 howdy，只需在 makefile 所在目录下输入 make 即可。就这么简单。

这个 makefile 文件包含 6 条规则。第一个目标体 howdy 称为默认(default) 目标体，这是 make 要创建的文件。howdy 有 3 个依赖体，分别为 howdy.o、helper.o 和 helper.h，要编译生成 howdy，必须要有这 3 个文件。第二行调用编译器的命令供 make 执行来创建 howdy。由对第 3 章内容的回忆可知，这条命令从两个目标文件创建名为 howdy 的可执行文件。把头文件 helper.h 作为一个依赖体列入是为了避免编译器调用未声明的函数产生出错信息。接下来的两条规则告诉 make 怎样生成单个目标文件，helper.o 和 howdy.o。这些规则使用了 gcc 的 -c 选项，只创建目标文件但跳过链接。如果只想生成两个目标文件而不生成 howdy 本身，可以使用下面两条命令:

1 2	$ make helper.o $ make howdy.o

更简洁一点，只需使用

1	$ make helper.o howdy.o

正如你所看到的那样，make 允许把多个目标作为参数。这两种方法都能使用相应的规则和命令生成目标文件。图 4.1 给出了这个过程的图示。

图4.1 把生成 howdy 的步骤归结到第 3 章讨论的一般性的预处理/编译/链接过程上。howdy.c 和 helper.c 这两个源代码文件经预处理后编译成目标文件。然后链接器把来自文件 howdy.o 和 helper.o 的目标代码和标准库以及 C 启动代码链接到一起生成二进制文件 hello。

现在，make 的价值就体现出来了：通常情况下，如果试图在依赖体 helper.o 和 howdy.o 不存在的情况下使用所示的命令编译 howdy，则 gcc 会报错井退出。另一方面，在看到 howdy 需要这两个文件（和 helper.c）后，make 先确认它们是否存在，如果不存在则首先执行命令生成它们，然后再返回到第一条规则创建可执行文件 howdy。当然，如果 helper.h 不存在，make 也会放弃执行，因为它没有创建 helper.h 的规则。

"一切都很好"，也许你会这么想，"但是 make 怎样知道什么时候需要重新编译一个文件呢？" 答案极其简单：如果指定的目标文件 make 找不到，make 就会生成它。如果目标体存在，make 会对目标体文件和依赖体文件的时间戳进行比较。如果有一个或多个依赖体比目标体新，make 就重新编译生成目标体，因为 make 认为新的依赖体意味着对代码做过修改，必须把改动融入到目标体中去。

第四条规则相当简单。它定义了如何编译生成第 3 章介绍的简单程序 hello。第五条是创建 hello 和 howdy 的笼统规则，它还表明甚至二进制文件都能作依赖体。下一小节将讨论第六条规则，即伪目标。

3.1 伪目标

除了一般的文件目标体，比如 howdy 和 hello 之外，make 也允许指定伪目标。称其为伪目标是因为它们并不对应于实际的文件。程序清单 4.1 中最后一个目标体 clean 就是伪目标。伪目标体规定了 make 应该执行的命令。但是，因为 clean 没有依赖体，所以它的命令不会被自动执行。下面解释 make 是如何工作的：当遇到目标体 clean 时，make 先查看其是否有依赖体，因为 clean 没有依赖体，所以 make 认为目标体是最新的而不执行任何操作。为了编译这个目标体，必须输入make clean。在本例中，clean 删除了可执行文件 hello 和 howdy 以及构成 howdy 的目标文件。在创建和发行仅包含源代码的压缩包或者需要彻底重新编译时可能会用到这样一个目标体。

然而，如果恰巧有一个名为 clean 的文件存在，make 就会发现它。然后和前面一样，因为 clean 没有依赖体文件，make 就认为这个文件是最新的而不会执行相关命令。为了处理这类情况，需要使用特殊的 make 目标体 .PH0NY。 .PHONY 的依赖体文件的含义和通常一样，但是 make 不检查是否存在有文件名和依赖体中的一个名字相匹配的文件，而是直接执行与之相关的命令。在使用了 .PHONY 之后，前面的例子如下：

程序清单 4.2 带有 PHONY 目标的 Makefile 文件

howdy: howdy.o helper.o helper.h
gcc howdy.o helper.o -o howdy

helper.o: helper.c helper.h
gcc -c helper.c

howdy.o: howdy.c
gcc -c howdy.c

hello: hello.c
gcc hello.c -o hello

all: howdy hello

.PHONY: clean

clean:
rm howdy hello *.o

3.2 变量

为了简化编辑和维护 makefile，make 允许在 makefile 中创建和使用变量。所谓的变量其实是用指定文本串在 makefile 中定义的一个名字，这个文本串就是变量的值。下面是定义变量的一般方法:

1	VARNAME=some_text [...]

把变量用括号括起来，井在前面加上 "$" 符号，就可以引用变量的值：

1	$(VARNAME)

此时，VARNAME 在等式右端展开为它所代表的文本。变量一般都在 makefle 的头部定义，并且，按照惯例，所有的 makefle 变量都应该是大写( 虽然这不是必须的)。这样，如果变量的值发生变化，就只需要在一个地方修改，从而简化了 makefile 的维护。现在，继续现在修改程序清单 4.1，加入两个变量，结果如程序清单 4.3 所示。

程序清单 4.3 在 makefle 中使用变量

OBJS = howdy.o helper.o
HDRS = helper.h

howdy: $(OBJS) $(HDRS)
gcc $(OBJS) -o howdy

helper.o: helper.c $(HDRS)
gcc -c helper.c

howdy.o: howdy.c
gcc -c howdy.c

hello: hello.c
gcc hello.c -o hello

all: howdy hello

clean:
rm howdy hello *.o

OBJS 和 HDRS 在被引用的每个地方都展开成它的取值。编译时也是如此。

实际上，make 使用两种变量：递归展开变量和简单展开变量。递归展开变量在引用时逐层展开，即如果在展开式中包含了对其他变量的引用，则这些变量也将被展开，直到没有需要展开的变量为止，这就是所谓的递归展开。下面的例子有助于弄清这个概念。

假设变量 TOPDIR 和 SRCDIR 如下定义:

1 2	TOPDIR = /home/kwall/myproject SRCDIR = $(TOPDIR)/src

这样，SRCDIR 的值是 /home/kwall/myproject/src，则工作正常。但是，考虑下面的变量定义:

1 2	CC = gcc CC = $(CC) -o

很清楚，定义者想要得到的结果是 "CC=gcc -o"。但是实际并非如此；CC 在被引用时递归展开，从而陷入一个无限循环中；CC 将扩展为 $(CC) 的值，从而永远也读不到 -o 选项。幸运的是，make 能够检测到这个问题并报告错误：

1	*** Recursive variable 'CC' references itself (eventually). Stop

为了避免这个问题，可以使用简单展开变量。与递归展开变量在引用时展开不同，简单展开变量在定义处展开，并且只展开一次，从而消除了变量的嵌套引用。在定义时,其语法与递归展开变量有细微的不同：

1 2	CC := gcc -o CC += -O2

第一个定义使用 := 设置 CC 的值为 gcc -o，第二个定义使用 "+=" 在前面定义的 CC 后附加了 -O2，从而 CC 最终的值是 gcc -o -O2。如果在使用 make 变量时遇到 "VARNAME references itself" 这类错误信息，就可以使用简单展开变量来解决。一些程序员仅使用简单展开变量，以避免出现意想不到的问题；但既然现在是在 Linux 上，你可以自由选择使用的方式。

除用户定义变量外, make 也允许使用环境变量、自动变量和预定义变量。使用环境变量非常简单。在启动时，make 读取己定义的环境变量，并且创建与之同名同值的变量。但是，如果 makefile 中有同名的变量，则这个变量将取代与之相应的环境变量，所以应当注意这一点。

此外，make 也提供一长串预定义变量和自动变量，但是它们看起来有些神秘。之所以称为自动变量是因为 make 自动用特定的、熟知的值替换它们。表 4.1 给出了部分自动变量。

表 4.1 自动变量

变量	说明
$@	规则的目标所对应的文件名
$<	规则中的第一个相关文件名
$^	规则中所有相关文件的列表，以空格为分隔符
$?	规则中日期新于目标的所有相关文件的列表，以空格为分隔符
$(@D)	目标文件的目录部分(如果目标在子目录中)
$(@F)	目标文件的文件名部分(如果目标在子目录中)

除了表 4.1 列出的自动变量外，make 还预定义了许多其他变量，用于定义程序名或给这些程序传递标志和参数。这些预定义的变量看上去更像常规的 make 变量而不是像字符名称的自动变量。表 4.2 给出了一些有用的预定义变量。

表4.2 用于程序名和标志的预定义变量

变量	说明
AR	归档维护程序，默认值=ar
AS	汇编程序，默认值=as
CC	C 编译程序，默认值=cc
CPP	C 预处理程序，默认值=cpp
RM	文件删除程序，默认值="rm -f"
ARFLAGS	传给归档维护程序的标志，默认值=rv
ASFLAGS	传给汇编程序的标志，没有默认值
CFLAGS	传给 C 编译器的标志，没有默认值
CPPFLAGS	传给 C 预处理程序的标志，没有默认值
LDFLAGS	传给链接程序（Id）的标志，没有默认值

如果需要，可以在 makefile 中重新定义这些变量，但是在大多数情况下，这些默认值都是合理的。

3.3 隐式规则

除了在 makefile 文件中显式指定的规则（称为显式规则）外，make 还有一整套隐式规则，或称为预定义规则。这些规则多数有特殊目的而且用途有限，所以在这里只介绍几种最常用的隐式规则。隐式规则简化了 makefile 的编写和维护。

假设有下面这样的一个 makefile：

OBJS = editor.o screen.o keyboard.o

editor: $(OBJS)
cc -o editor $(OBJS)

.PHONY: clean

clean:
rm editor $(OBJS)

默认目标 editor 所对应的命令提及了 editor.o，screen.o 和 keyboard.o，但是 makefile 中没有怎样编译生成这些目标的规则。此时，make 就使用所谓的隐式规则，实际上，对每一个名为 somefile.o 的目标（object）文件，make 首先找到与之相应的源代码 somefile.c，并且用 gcc -c somefile.c -o somefile.o 编译生成这个目标文件。所以，在本例中 make 先查找名为 editor.c，screen.c 和 keyboard.c 的文件并将它们编译为目标文件（editor.o，screen.o 和 keyboard.o），然后，编译生成默认目标 editor。

实际的机制比这里所描述的要全面。目标文件（.o）可以从 C、Pascal 和 Fortran 等源代码中生成，所以 make 也应去查找符合实际情况的相关文件。所以，如果在工作目录下有 editor.p，screen.p 和 keyboard.p 三个 Pascal 文件（p 通常被认为是 Pascal 源代码的扩展名），make 就会激活 Pascal 编译器来编译它们，而不用 C 编译器。因此，如果出于某种原因而在项目中需要使用多种语言时，就不能依靠隐式规则，因为此时使用该规则所得到的结果可能会与期望的有所不同。

3.4 模式规则

通过定义用户自己的隐式规则，模式规则提供了扩展 make 的隐式规则的一种方法。模式规则类似于普通规则，但是它的目标必定含有符号 "%"，这个符号可以与任何非空字符串匹配；为与目标中的 "%" 匹配，这个规则的相关文件部分也必须使用 "%"。例如，下面的规则：

%.o: %.c

告诉 make 所有形为 somename.o 的目标（object）文件都应从源文件 somename.c 编译而来。

与隐式规则一样， make 预定义了一些模式规则：

1 2	%.o: %.c $(CC) -c $(CFLAGS) $(CPPFLAGS) $< -o $@

与前面的例子相同，make 定义了一条规则，即任何 x.o 的文件都从 x.c 编译而来。每次使用该规则时，该规则用自动变量 $< 和 $@ 来代替第一个依赖体和目标体。此外，变量 $(CC)，$(CFLAGS) 和 $(CPPFLAGS) 的默认值如表 4.2 所示。

3.5 注释

在 makefile 中插入注释时，必须在注释前加上符号 "#"。make 读到 "#" 后，它忽略该符号以及这一行余下的字母。注释可以出现在 makefile 的所有地方。但是，因为多数 shell 把 "#" 看作是元符号（通常也是注释符），所以在命令中加入注释时要特别小心。此外，实际上就 make 本身而言，一个只含注释的行就是一个空行。

4 命令行选项和参数

同多数 GNU 程序一样，make 也有丰富的命令行选项。表 4.3 列出了最常用的部分。

表 4.3 常用的 make 俞令行选项

选项	说明
`-f file`	指定 makefile 的文件名
`-n`	打印将需要执行的命令，但实际上并不执行这些命令
`-Idirname`	指定被包含的 makefile 所在的目录
`-s`	在执行时不打印命令名
`-w`	如果 make 在执行时改变目录，打印当前目录名
`-Wfile`	如果文件己修改，则使用 `-n` 来显示 make 将要执行的命令
`-r`	禁止使用所有 make 的内置规则
`-d`	打印调试信息
`-i`	忽略 makefile 规则中的命令执行后返回的非零错误码。此时，即使某个命令返回非零的退出状态值，make 仍将继续执行
`-k`	如果某个目标编译失败，继续编译其他目标。通常，make 在一个目标编译失败后终止
`jN`	每次运行 N 条命令，这里 N 是非零整数

5 调试 make

如果在使用 make 时遇到问题，-d 选项能够使 make 在执行命令时打印大量的额外调试信息。此时，因为需要显示 make 内部所做的每一件事以及为什么做这些事的调试信息，将会产生大量的输出。其中包括如下信息：

在重新编译时 make 需要检查的文件
被比较的文件以及比较的结果
需要被重新生成的文件
make 想要使用的隐式规则
make 实际使用的隐式规则以及所执行的命令

6 常见的 make 出错信息

这里列出使用 make 时可能遇到的最常用的出错信息，完整文档诮参见 make 使用手册或其信息页。

No rule to make target 'target'. Stop makefile 中没有包含创建指定的 target 所需要的规则，而且也没有合适的默认规则可用。
'target' is up to date 指定 target 的相关文件没有变化。
Target 'target' not remade because of errors 在编译 target 时出错，这一消息仅在使用make的 -k 选项时才会出现。
command: Command not found make 找不到命令。递常是因为命令被拼写错误或者不在路径 $PATH 下。
Illegal option -option 在调用 make 时包含了不能被 make 识别的选项。

7 有用的 makefile 目标

除了前面提及的 clean，编写 makefile 时还有一些常用的目标。名为 install 的目标把最终的二进制文件，所支持的库文件或 shell 脚本，以及相关的文档移动到文件系统中与之相应的最终位置，并适当设置文件的权限和属主。此外，install 通常也编译程序，以及运行简单的测试以确认程序已正确编译。uninstall 目标则删除由 install 目标所安装的那些文件。如果需要，在设置 install 目标前存储系统当前的设置。

dist 目标可以用来生成准备发布的软件包。最低限度，dist 目标将删除编译工作目录中旧的二进制文件和目标文件并创建一个归档文件（如普通的压缩包），以便上传到万维网页或FTP站点。

为了方便其他开发者，可以用一个 tags 目标来创建或更新程序的标记表。如果程序的验证过程比较复杂，也可以创建一个单独的 test 或 check 目标来执行这一过程并显示适当的诊断信息。与之类似，installtest 或 installcheck 目标，通常被用来验证安装过程。当然，在此之前，install 目标必须已经成功地编译和安装了所需的程序。

差分序列

2020-09-20T14:02:20.000Z

本文将介绍差分序列的定义及其应用。

差分序列（数组）

差分序列的定义

给定一个序列 a, a[i] 表示序列的第 i 个元素（编号从 0 开始），则其差分序列为：

1 2	d[0] = a[0] (i == 0) d[i] = a[i] - a[i-1] (i > 0)

差分序列示例

索引 i	0	1	2	3	4	5	6	7
原始序列 a[i]	0	2	5	4	9	7	10	0
差分序列 d[i]	0	2	3	-1	5	-2	3	-10

现在假设将区间 a[1, 4] 所有的数都加上 3，则：

索引 i	0	1	2	3	4	5	6	7
原始序列 a[i]	0	2+3=5	5+3=8	4+3=7	9+3=12	7	10	0
差分序列 d[i]	0	2+3=5	3	-1	5	-2-3=-5	3	-10

然后将区间 a[3, 5] 所有的数都减去 5，则：

索引 i	0	1	2	3	4	5	6	7
原始序列 a[i]	0	2+3=5	5+3=8	4+3=7-5=2	9+3=12-5=7	7-5=2	10	0
差分序列 d[i]	0	2+3=5	3	-1-5=-6	5	-2-3=-5	3+5=8	-10

差分序列的性质

仔细观察上面的示例，可以发现：

1
2
3

a[2] = d[2] + a[1]
     = d[2] + d[1] + a[0]
     = d[2] + d[1] + d[0]

根据定义，对原序列区间操作后，原序列最终各项值为：

1 2	a[0] = d[0] (i == 0) a[i] = d[i] + a[i-1] (i > 0)

也即 a[i] 为 d[i] 的前缀和：

1	a[i] = d[0] + ... + d[i]

差分序列的应用

基于差分序列的性质，它主要用于快速处理区间加减操作和单点查询

快速处理区间加减操作

假如现在对 a[L, R] 区间上所有的数加上 delta，由以上的性质可知，第一个受影响的差分数组中的元素为 d[L]，即令 d[L] += delta，那么后面数列元素在计算过程中都会加上 delta；最后一个受影响的差分数组中的元素为d[R]，所以令 d[R+1] -= delta，即可保证不会影响到 R 以后数列元素的计算。这样我们不必对区间内每一个数进行处理，只需处理两个差分后的数即可。

简单来说，当对 a[L, R] 区间所有数进行加 delta 操作时，只需:

1 2	d[L] += delta d[R+1] -= delta

那么此时计算 a[L] ... a[R] 都会加上 delta，这里用 (d[L] + delta) 表示归约后的 d[L]，则有：

a[L] = (d[L] + delta) + a[L-1]
a[L+1] = d[L+1] + a[L] = d[L+1] + (d[L] + delta) + a[L-1]
...
a[R] = d[R] + a[R-1] = d[R] + ... + (d[L] + delta) + a[L-1]

单点查询（求差分序列前缀和）

改变 d 数组

1 2	for i in range(1, n): d[i] += d[i-1]

改变 a 数组

1
2
3

a[0] = d[0]
for i in range(1, n):
    a[i] = d[i] + a[i-1]

References

https://www.cnblogs.com/COLIN-LIGHTNING/p/8436624.html

并查集

2020-09-20T08:22:34.000Z

在计算机科学中，并查集是一种树型的数据结构，用于处理一些不交集（Disjoint Sets）的合并及查询问题。有一个联合-查找算法（union-find algorithm）定义了两个用于此数据结构的操作：

Find：确定元素属于哪一个子集。它可以被用来确定两个元素是否属于同一子集。
Union：将两个子集合并成同一个集合。

由于支持这两种操作，一个不相交集也常被称为联合-查找数据结构（union-find data structure）或合并-查找集合（merge-find set）。其他的重要方法，MakeSet，用于建立单元素集合。有了这些方法，许多经典的划分问题可以被解决。

并查集

并查集是什么

并查集是一种用来管理元素分组情况的数据结构。并查集可以高效地进行如下操作。不过需要注意并查集虽然可以进行合并操作，但是却无法进行分割操作。

查询元素 a 和元素 b 是否属于同一组。
合并元素 a 和元素 b 所在的组。

并查集的结构

并查集也是树形结构实现的。不过，不是二叉树。

每个元素对应一个节点，每个组对应一棵树。在并查集中，哪个节点是哪个节点的父亲以及树的形状等信息无需多加关注，整体组成一个树形结构才是重要的。

（1）初始化

我们准备 n 个节点来表示 n 个元素。最开始时没有边。

（2）合并

像下图一样，从一个组的根向另一个组的根连边，这样两棵树就变成了一棵树，也就把两个组合并为一个组了。

（3）查询

为了查询两个节点是否属于同一组，我们需要沿着树向上走，来查询包含这个元素的树的根是谁。如果两个节点走到了同一个根，那么就可以知道它们属于同一组。

在下图中，元素 2 和元素 5 都走到了元素 1，因此它们属于同一组。另一方面，由于元素 7 走到的是元素 6，因此同元素 2 或元素 5 属于不同组。

并查集实现中的注意点

在树形数据结构里，如果发生了退化的情况，那么复杂度就会变得很高。因此，有必要想办法避免退化的发生。在并查集中，只需按照如下方法就可以避免退化。

对于每棵树，记录这棵树的高度(rank)。
合并时如果两棵树的 rank 不同，那么从 rank 小的向 rank 大的连边。

此外，通过路径压缩，可以使得并查集更加高效。对于每个节点，一旦向上走到了一次根节点，就把这个点到父亲的边改为直接连向根。

在此之上，不仅仅是所查询的节点，在查询过程中向上经过的所有的节点，都改为直接连到根上。这样再次查询这些节点时，就可以很快知道根是谁了。

在使用这种简化的方法时，为了简单起见，即使树的高度发生了变化，我们也不修改 rank 的值。

并查集的复杂度

加入了这两个优化之后的并查集效率非常高。对 n 个元素的并查集进行一次操作的复杂度是 $O(\alpha(n))$。在这里，$\alpha(n)$ 是阿克曼( Ackermann )函数的反函数。这比 $O(log(n))$ 还要快。

不过，这是“均摊复杂度”。也就是说，并不是每一次操作都满足这个复杂度，而是多次操作之后平均每一次操作的复杂度是 $O(\alpha(n))$ 的意思。

并查集的实现

下面是并查集的实现的例子。在例子中，我们用编号代表每个元素。数组 par 表示的是父亲的编号，par[x] = x 时, x 是所在的树的根。

路径压缩

class UnionFind:
    def __init__(self, n: int):
        self.par = list(range(n))

    def find(self, x: int) -> int:
        if self.par[x] != x:
            self.par[x] = self.find(self.par[x])
        return self.par[x]

    def union(self, x: int, y: int) -> None:
        self.par[self.find(x)] = self.find(y)

路径压缩 + 按秩（rank）合并

class UnionFind:
    # 初始化 n 个元素
    def __init__(self, n: int):
        self.par = list(range(n))  # 祖先结点
        self.rank = [0] * n  # 树的高度

    # 查询树的根
    def find(self, x: int) -> int:
        if self.par[x] != x:
            self.par[x] = self.find(self.par[x])
        return self.par[x]

    # 合并 x 和 y 所属的集合
    def union(self, x: int, y: int) -> None:
        x = self.find(x)
        y = self.find(y)
        if x == y:
            return

        if self.rank[x] < self.rank[y]:
            self.par[x] = y
        else:
            self.par[y] = x
            if self.rank[x] == self.rank[y]:
                self.rank[x] += 1

References

https://en.wikipedia.org/wiki/Disjoint-set_data_structure

<<挑战程序设计竞赛(第2版)>> 巫泽俊 2.4 并查集 p84-88

RabbitMQ高可用集群搭建

2020-07-16T14:28:26.000Z

RabbitMQ + HAProxy 高可用镜像模式集群部署

本文介绍了如何搭建 RabbitMQ 高可用集群。首先介绍了部署说明和前提条件，然后详细介绍了集群模式和节点类型。接着介绍了环境准备和集群搭建的步骤，包括普通模式和镜像模式的配置。然后介绍了集群节点管理和故障处理的方法。最后介绍了使用 HAProxy 负载均衡的方法，并提供了安装、配置和验证的步骤。最后列举了一些常见问题。

RabbitMQ 高可用集群搭建

部署说明

下面将以一个示例说明多机部署一个高可用 RabbitMQ 集群的流程。

前提

在部署集群前，必须在将成为集群成员的每个节点上安装 RabbitMQ，并确保每个节点之间能相互访问。

RabbitMQ 集群模式

普通模式（默认的集群模式）
以两个节点 node1、node2 为例来进行说明。
对于 queue 来说，消息实体只存在于其中一个节点（node1 或 node2），node1 和 node2 两个节点仅有相同的元数据，即队列的结构。当消息进入 node1 节点的 queue 后，consumer 从 node2 节点消费时，RabbitMQ 会临时在 node1、node2 间进行消息传输，把 node1 中的消息实体取出并经过 node2 发送给 consumer。所以 consumer 应尽量连接每一个节点，从中取消息。即对于同一个逻辑队列，要在多个节点建立物理 queue。否则无论 consumer 连接 node1 或 node2，出口总在 node1，会产生瓶颈。
当 node1 节点故障后，node2 节点无法取到 node1 节点中还未消费的消息实体。如果做了消息持久化，那么得等 node1 节点恢复，然后才可被消费；如果没有持久化的话，就会产生消息丢失的现象。
镜像模式
把需要的队列做成镜像队列，存在于多个节点，属于 RabbiMQ 的 HA 方案，在对业务可靠性要求较高的场合中比较适用。
该模式解决了普通模式中的问题，其实质和普通模式不同之处在于，消息实体会主动在镜像节点间同步，而不是在客户端取数据时临时拉取。该模式带来的副作用也很明显，除了降低系统性能外，如果镜像队列数量过多，加之大量的消息进入，集群内部的网络带宽将会被这种同步通讯大大消耗掉。所以在对可靠性要求较高的场合中适用。
要实现镜像模式，需要先搭建一个普通集群模式，在这个模式的基础上再配置策略以实现高可用。

集群节点类型

内存（ram）节点
磁盘（disk）节点

RAM 节点仅将内部数据库表存储在 RAM 中。这不包括消息，消息存储索引，队列索引和其他节点状态。

在大多数情况下，您希望所有节点都是磁盘节点。 RAM 节点是一种特殊情况，可用于提高 queue、exchange 或 binding 流失率较高的群集的性能。 RAM 节点不提供更高的消息速率。如有疑问，请仅使用磁盘节点。

由于 RAM 节点仅将内部数据库表存储在RAM中，因此它们必须在启动时从对等节点同步它们。这意味着一个群集必须至少包含一个磁盘节点。因此，不可能手动删除集群中最后剩余的磁盘节点。

在 RabbitMQ 集群中，当磁盘节点宕掉且集群中无其他可用的磁盘节点时，集群将无法写入新的队列元数据信息。

环境准备

系统系统：CentOS7 64位
三台服务器：192.168.0.231/232/233

服务器规划

服务器	用途	主机名	节点类型
192.168.0.231	RabbitMQ 集群节点 1	node231	磁盘节点
192.168.0.232	RabbitMQ 集群节点 2	node232	磁盘节点
192.168.0.233	RabbitMQ 集群节点 3	node233	磁盘节点

集群搭建

普通模式

配置 hosts

vim /etc/hosts 编辑三个节点的 hosts 文件，在文件末尾添加如下内容：

1
2
3

192.168.0.231 node231
192.168.0.232 node232
192.168.0.233 node233

配置 hostname

node231
vim /etc/hostname 编辑主机名如下：
1
node231
vim /etc/sysconfig/network 编辑网络配置文件，添加如下内容：
1
2
NETWORKING=yes
HOSTNAME=node231
重启 network
1
systemctl restart network
node232
vim /etc/hostname 编辑主机名如下：
1
node232
vim /etc/sysconfig/network 编辑网络配置文件，添加如下内容：
1
2
NETWORKING=yes
HOSTNAME=node232
重启 network
1
systemctl restart network
node233
vim /etc/hostname 编辑主机名如下：
1
node233
vim /etc/sysconfig/network 编辑网络配置文件，添加如下内容：
1
2
NETWORKING=yes
HOSTNAME=node233
重启 network
1
systemctl restart network

RabbitMQ 集群是基于 erlang 进行同步的，在 erlang 的集群中各节点同步需要一个相同的 cookie，所以必须保证各节点 cookie 一致，不然节点之间就无法通信。这个 cookie 默认存放在 /var/lib/rabbitmq/.erlang.cookie 中。

在任意一个节点中 copy .erlang.cookie 文件到其它所有节点，如在 node1 上进行 copy :

1 2	[root@node231 ~]# scp /var/lib/rabbitmq/.erlang.cookie root@192.168.0.232:/var/lib/rabbitmq/ [root@node231 ~]# scp /var/lib/rabbitmq/.erlang.cookie root@192.168.0.233:/var/lib/rabbitmq/

重启节点

如果后面执行 rabbitmqctl stop_app 失败，需要重启 node231、node232、node233 使配置生效。

启动 rabbitmq-server

分别启动 node231、node232、node233 的 rabbitmq-server：

1
2
3

[root@node231 ~]# systemctl start rabbitmq-server
[root@node232 ~]# systemctl start rabbitmq-server
[root@node233 ~]# systemctl start rabbitmq-server

将节点加入集群

将 node232、node233 节点加入 node231 节点集群中，在 node232、node233 中分别执行以下命令：

1
2
3

# rabbitmqctl stop_app
# rabbitmqctl join_cluster rabbit@node231
# rabbitmqctl start_app

默认 RabbitMQ 启动后是磁盘节点，在这个 cluster 下，node231、node232 和 node233 都是是磁盘节点。
如果要使 node232、node233 都是内存节点，加上 --ram 参数即可，如 rabbitmqctl join_cluster --ram rabbit@node232。
如果想要更改节点类型，可以使用命令 rabbitmqctl change_cluster_node_type disc(ram)，修改节点类型前需要先 rabbitmqctl stop_app。
(Note: disk and disc are used interchangeably)

查看集群状态

任意节点执行：

1	# rabbitmqctl cluster_status

创建管理用户

如果在主机名变更前就已经创建过用户的，仍需要重新重新创建，因为主机名的变更，之前创建的用户无法登录 web 管理系统。

以下操作在 node231 下执行：

创建 vhost（可选，默认使用 "/" vhost）
这里创建一个 vhost 用于测试：
1
[root@node231 ~]# rabbitmqctl add_vhost testvhost

创建用户

1	[root@node231 ~]# add_user admin password

设置用户角色

1	[root@node231 ~]# set_user_tags admin administrator

设置用户权限

1	[root@node231 ~]# set_permissions -p testvhost admin "." "." ".*"

启用 rabbitmq management

在 node231 上启用 rabbitmq management

1	[root@node231 ~]# rabbitmq-plugins enable rabbitmq_management

在浏览器中访问 http://192.168.0.231:15672，使用 "admin/password" 即可登录。

镜像模式

上面已经完成 RabbitMQ 默认集群模式，但并不保证队列的高可用性，尽管 Exchanges、Bindings 这些可以复制到集群里的任何一个节点，但是队列内容不会复制。所以集群中的节点宕机后将直接导致队列无法应用或消息丢失，要想队列在节点宕机或故障时也能正常应用，需要复制队列内容到集群中的每个节点，这就要使用镜像队列了。

为了确认队列内容默认不会复制，我们需要做些实验。

首先我们在 node231 节点上创建一个名为 demo_task 的持久化队列（相关的 exchange 也是持久化的），这事可以看到队列的元信息会立即同步到 node232 和 node233 上。
然后我们连接到 node231 节点上发布一个消息，发布成功后，你可以在所有节点上获取到该消息。
然后我们使用 systemctl stop rabbitmq-server 命令将 node231 节点关闭，此时发现 node232 和 node233 虽然还保留了 demo_task 的元信息，但却无法从中获取消息了。
当我们使用 systemctl start rabbitmq-server 命令再次将 node231 节点启动后，node232 和 node233 依然能看到 node231 关闭前已经持久化的消息。

镜像队列

默认情况下，RabbitMQ 集群中 queue 的内容位于单个节点（声明该 queue 的节点）上。这与 exchanges 和 bindings 相反，exchanges 和 bindings 始终可以被视为在所有节点上。可以选择使 queue 跨多个节点进行镜像。

每个镜像队列由一个 master 和一个或多个镜像（mirrors）组成。master 托管在一个通常称为主节点的节点上。每个队列都有其自己的主节点。给定队列的所有操作都首先应用于队列的主节点，然后传播到镜像节点。这涉及排队发布，向消费者传递消息，跟踪来自消费者的确认等。

队列镜像意味着节点的集群。发布到队列的消息将复制到所有镜像。无论消费者连接到哪个节点，最终都会被连接到主节点，镜像节点都会丢弃已在主节点上确认的消息。因此，队列镜像可提高可用性，但不会在节点之间分配负载（所有参与的节点均完成所有工作）。

如果承载队列主节点发生故障，则最早的镜像将在同步后提升为新的主节点。根据队列镜像参数，也可以升级不同步的镜像。

配置镜像策略

使用策略（policiy）配置镜像参数。一个策略按名称（使用正则表达式模式）匹配一个或多个队列，并且包含一个定义（可选参数的映射），该定义被添加到匹配队列的全部属性中。

通过控制台添加策略

如果其他节点也启用了 rabbitmq_management，此时其他节点的控制台，可以看到上面添加的这个策略，如图所示：

参数说明：

Virtual host：策略应用的 vhost。
Name：为策略名称，可以是任何东西，但建议使用不带空格的基于ASCII的名称。
Pattern：与一个或多个 queue（exchange）名称匹配的正则表达式，可以使用任何正则表达式。只有一个 ^ 代表匹配所有，^test 为匹配名称为 "test" 的 exchanges 或者 queue。
Apply to：Pattern 应用对象。
Priority：配置了多个策略时候的优先级，值越大，优先级越高。
（没有指定优先级的消息会以0优先级对待。对于超过队列所定最大优先级的消息，优先级以最大优先级对待）
Definition：一组键/值对（例如 JSON 文档），将被插入匹配 queues and exchanges 的可选参数映射中
ha-mode：策略键，分为3种模式
- all - 所有（所有的 queue）
- exctly - 部分（需配置 ha-params 参数，此参数为 int 类型。比如 3，众多集群中的随机 3 台机器）
- nodes - 指定（需配置 ha-params 参数，此参数为数组类型。比如 ["rabbit@node2", "rabbit@node3"] 这样指定为 node2 与 node3 这两台机器）
ha-sync-mode：队列同步
- manual：手动（默认模式）。新的队列镜像将不会收到现有的消息，它只会接收新的消息
- automatic：自动同步。当一个新镜像加入时，队列会自动同步。队列同步是一个阻塞操作。

通过命令行添加策略

设置

1	rabbitmqctl set_policy [-p ] [--priority ] [--apply-to ]

清除
1
rabbitmqctl clear_policy [-p ]
查看
1
rabbitmqctl list_policies [-p ]

例如：

1
2

# rabbitmqctl set_policy -p testvhost testha "^" '{"ha-mode":"all","ha-sync-mode":"automatic"}'
Setting policy "testha" for pattern "^" to "{"ha-mode":"all","ha-sync-mode":"automatic"}" with priority "0" for vhost "testvhost" ...

# rabbitmqctl list_policies -p testvhost
Listing policies for vhost "testvhost" ...
vhost   name    pattern apply-to        definition      priority
testvhost       testha  ^       all     {"ha-mode":"all","ha-sync-mode":"automatic"}    0

1 2	# rabbitmqctl clear_policy -p testvhost testha Clearing policy "testha" on vhost "testvhost" ...

测试策略是否生效

在控制台的队列页面上，镜像队列将展示策略名称和其他副本（镜像）数量。以下是一个名为 three_replicas 的队列的示例，该队列具有一个 master（主节点）和两个镜像节点。

添加队列：

查看队列：

集群节点管理

故障节点重新加入集群

删除 /var/lib/rabbitmq/mnesia/ 下的数据，重新启动 rabbitmq-server，正常执行节点增加操作。

1 2	rm -rf /var/lib/rabbitmq/mnesia/ systemctl restart rabbitmq-server.service

节点增加

注：需要同步 .erlang.cooike 内容（.erlang.cooike 的权限为 400，所属者为 rabbitmq）

在需要加入的节点机器上执行：

rabbitmqctl stop_app
rabbitmqctl join_cluster --ram rabbit@node231
rabbitmqctl start_app
rabbitmqctl cluster_status

节点删除

正常删除

在需要删除的节点（rabbitmq-server 正常运行）机器上执行：

1
2
3

rabbitmqctl stop_app
rabbitmqctl reset
rabbitmqctl start_app

硬删除

在集群正常节点将故障节点踢出，在其它正常的节点上执行（故障节点 rabbitmq-server 服务不可用）：

1	rabbitmqctl forget_cluster_node rabbit@node232

改变节点类型

disc -> ram

rabbitmqctl stop_app
rabbitmqctl reset
rabbitmqctl join_cluster --ram rabbit@node231
rabbitmqctl start_app

ram -> disc

rabbitmqctl stop_app
rabbitmqctl reset
rabbitmqctl join_cluster rabbit@node231
rabbitmqctl start_app

HAProxy 负载均衡

HAProxy 是由 C 语言编写的免费的开源软件，它快速而高效，可为基于TCP和HTTP的应用程序提供高可用、高性能的负载平衡器和代理服务器。

环境准备

服务器	用途	系统	版本
192.168.0.235	负载均衡服务器	Ubuntu 20.04	haproxy 2.0

安装

Ubuntu

1	$ sudo apt install haproxy

CentOS 7

1
2
3

wget http://www.haproxy.org/download/1.7/src/haproxy-1.7.12.tar.gz
tar -zxvf haproxy-1.7.12.tar.gz
cd haproxy-1.7.12

根据内核版本，选择编译参数

查看内核版本：

1 2	[root@dev235 haproxy-1.7.12]# uname -r 3.10.0-1127.19.1.el7.x86_64

如：3.10.0-1127.19.1.el7.x86_64，此时该参数就为 linux310；kernel 大于 2.6.28 的可以用： TARGET=linux2628；

查看编译参数：

1	[root@dev235 haproxy-1.7.12]# less README

编译安装：

1 2	make TARGET=linux310 ARCH=x86_64 PREFIX=/usr/local/haproxy make install PREFIX=/usr/local/haproxy

TARGET=linux310，内核版本，如：3.10.0-1127.19.1.el7.x86_64，此时该参数就为 linux310；kernel 大于 2.6.28 的可以用： TARGET=linux2628；
ARCH=x86_64，系统位数；
PREFIX=/usr/local/haprpxy ，haproxy 安装路径；

使用 systemclt 管理 haproxy

在 haproxy-1.7.12 中有 systemd 脚本可以使用：

[root@dev235 haproxy-1.7.12]# cat contrib/systemd/haproxy.service.in
[Unit]
Description=HAProxy Load Balancer
After=network.target

[Service]
Environment="CONFIG=/etc/haproxy/haproxy.cfg" "PIDFILE=/run/haproxy.pid"
ExecStartPre=@SBINDIR@/haproxy -f $CONFIG -c -q
ExecStart=@SBINDIR@/haproxy-systemd-wrapper -f $CONFIG -p $PIDFILE
ExecReload=@SBINDIR@/haproxy -f $CONFIG -c -q
ExecReload=/bin/kill -USR2 $MAINPID
KillMode=mixed
Restart=always

[Install]
WantedBy=multi-user.target

copy 到 /lib/systemd/system 下，并修改 @SBINDIR@ 为 /usr/local/haproxy/sbin，将 haproxy-systemd-wrapper 替换为 haproxy：

1
2
3

cp contrib/systemd/haproxy.service.in /lib/systemd/system/haproxy.service
systemctl daemon-reload
systemctl restart haproxy.service

配置

vim /etc/haproxy/haproxy.cfg 编辑 haproxy 配置文件，修改如下：

global
    maxconn 512
    stats socket /tmp/haproxy

defaults
    log global
    mode http
    option abortonclose
    compression algo gzip
    compression type text/html text/plain application/json
    timeout connect 5000ms
    # timeout connect 3600s

listen stats
    bind *:8888
    mode http
    log 127.0.0.1 local3 err
    stats refresh 60s
    stats uri /stats
    stats realm Haproxy\ Manager
    stats auth admin:password
    stats hide-version
    stats admin if TRUE

listen rabbitmq_cluster
    bind *:5672
    mode tcp
    option tcpka
    balance roundrobin
    server rabbit1 192.168.0.231:5672 check inter 1000 rise 2 fall 3 weight 1
    server rabbit2 192.168.0.232:5672 check inter 1000 rise 2 fall 3 weight 1
    server rabbit3 192.168.0.233:5672 check inter 1000 rise 2 fall 3 weight 1

验证 HAProxy 配置

修改配置后，在启动 HAProxy 前，应先运行以下命令验证配置文件语法：

1 2	$ haproxy -f /etc/haproxy/haproxy.cfg -c -V Configuration file is valid

如果收到错误消息，请务必先修复，然后再继续。

运行 HAProxy

1	$ systemctl restart haproxy

查看状态：

1	$ systemctl status haproxy

HAProxy Statistics

浏览器访问 http://192.168.0.235:8888/stats，输入配置中的用户名和密码登录：

常见问题

1. 新节点 join_cluster 失败

问题描述：

新创建的 RabbitMQ 节点，在 join_cluster 时失败，提示如下信息：

[root@node232 ~]# rabbitmqctl join_cluster rabbit@node231.com
Clustering node rabbit@node232 with rabbit@node231.com
Error:
{:badrpc_multi, {:EXIT, {{:function_clause, [{:gen, :do_for_proc, [{:rex, {:error, {:node_name, :short}}}, #Function<0.9801092/1 in :gen.call/4>], [file: 'gen.erl', line: 220]}, {:gen_server, :call, 3, [file: 'gen_server.erl', line: 219]}, {:rpc, :do_call, 3, [file: 'rpc.erl', line: 327]}, {:lists, :foldl, 3, [file: 'lists.erl', line: 1263]}, {:rabbit_mnesia, :discover_cluster, 1, [file: 'src/rabbit_mnesia.erl', line: 779]}, {:rabbit_mnesia, :join_cluster, 2, [file: 'src/rabbit_mnesia.erl', line: 212]}, {:rpc, :"-handle_call_call/6-fun-0-", 5, [file: 'rpc.erl', line: 197]}]}, {:gen_server, :call, [{:rex, {:error, {:node_name, :short}}}, {:call, :rabbit_mnesia, :cluster_status_from_mnesia, [], #PID<0.62.0>}, :infinity]}}}, [error: {:node_name, :short}]}

问题原因：

rabbit@hostname ，hostname 不允许包含 . 字符，如果主机名是 node231.com，则应该在 /etc/hosts 同时指定 node231 映射的 IP。

解决方法：

编辑 /etc/hosts 文件，添加 192.168.0.231 node231。

使用 rabbit@node231 而不是 rabbit@node231.com。

[root@node232 ~]# rabbitmqctl join_cluster rabbit@node231
Clustering node rabbit@node232 with rabbit@node231
[root@node232 ~]# rabbitmqctl start_app
Starting node rabbit@node232 ...
 completed with 3 plugins.

查看集群状态。

[root@node232 ~]# rabbitmqctl cluster_status
Cluster status of node rabbit@node232 ...
Basics

Cluster name: rabbit@node231

Disk Nodes

rabbit@node231
rabbit@node232
rabbit@node233

Running Nodes

rabbit@node231
rabbit@node232
rabbit@node233

Versions

rabbit@node231: RabbitMQ 3.8.1 on Erlang 22.2.1
rabbit@node232: RabbitMQ 3.8.1 on Erlang 22.2.1
rabbit@node233: RabbitMQ 3.8.1 on Erlang 23.2.3

Alarms

(none)

Network Partitions

(none)

Listeners

Node: rabbit@node231, interface: [::], port: 25672, protocol: clustering, purpose: inter-node and CLI tool communication
Node: rabbit@node231, interface: [::], port: 5672, protocol: amqp, purpose: AMQP 0-9-1 and AMQP 1.0
Node: rabbit@node231, interface: [::], port: 15672, protocol: http, purpose: HTTP API
Node: rabbit@node232, interface: [::], port: 25672, protocol: clustering, purpose: inter-node and CLI tool communication
Node: rabbit@node232, interface: [::], port: 5672, protocol: amqp, purpose: AMQP 0-9-1 and AMQP 1.0
Node: rabbit@node232, interface: [::], port: 15672, protocol: http, purpose: HTTP API
Node: rabbit@node233, interface: [::], port: 25672, protocol: clustering, purpose: inter-node and CLI tool communication
Node: rabbit@node233, interface: [::], port: 5672, protocol: amqp, purpose: AMQP 0-9-1 and AMQP 1.0
Node: rabbit@node233, interface: [::], port: 15672, protocol: http, purpose: HTTP API

Feature flags

Flag: drop_unroutable_metric, state: enabled
Flag: empty_basic_get_metric, state: enabled
Flag: implicit_default_bindings, state: enabled
Flag: quorum_queue, state: enabled
Flag: virtual_host_metadata, state: enabled

2. 'gzip' is not a supported algorithm

问题描述：

[root@dev235 ~]# haproxy -f /etc/haproxy/haproxy.cfg
[ALERT] 103/185121 (15714) : parsing [/etc/haproxy/haproxy.cfg:9] : 'compression' : 'gzip' is not a supported algorithm.

[ALERT] 103/185121 (15714) : Error(s) found in configuration file : /etc/haproxy/haproxy.cfg
[ALERT] 103/185121 (15714) : Fatal errors found in configuration.

问题原因：

Add zlib support in haproxy for compression offloading

解决方法：

This lies in script build-haproxy.sh, where adding USE_ZLIB=1 in the make stanza would do it.

重新编译安装

1 2	make TARGET=linux310 ARCH=x86_64 PREFIX=/usr/local/haproxy USE_ZLIB=1 make install PREFIX=/usr/local/haproxy

References

https://www.rabbitmq.com/clustering.html

https://www.rabbitmq.com/ha.html

https://www.rabbitmq.com/parameters.html#policies

http://www.haproxy.org/

rabbitmq无法重新加入集群，启动失败的问题

算法设计与分析

2020-05-17T10:18:26.000Z

本文主要介绍了算法的一些特性和常见算法的实现方法。其中，时间复杂度是算法效率的重要指标，递归是一种常见的算法实现方式，分治法、动态规划、贪心算法和回溯法是常见的算法设计思想。此外，还介绍了哈夫曼编码、单源最短路径、最小生成树、并查集和优先队列等常见算法的实现方法和应用场景。这些算法在计算机科学和工程领域中都有广泛的应用，对于提高算法效率和解决实际问题具有重要意义。

算法设计与分析

算法的特性

定义

为了解决某类问题而规定的一个有限长的操作序列。

算法的特性

有穷性，确定性，可行性，输入，输出

算法的性能标准

正确性、可读性、健壮性、高效率和低存储需求

时间复杂度

常见算法时间复杂度

$O(1)$: 表示算法的运行时间为常量
$O(n)$: 表示该算法是线性算法
$O(logn)$: 二分查找算法
$O(n^2)$: 对数组进行排序的简单算法，如直接插入排序。
$O(n^3)$: 做两个n阶矩阵的乘法运算
$O(2^n)$: 求具有n个元素集合的所有子集的算法
$O(n!)$: 求具有n个元素的全排列的算法

算法复杂性分析

\[f(n)=O(g(n)) \qquad f(n)的阶≤g(n)的阶\\f(n)=Ω(g(n)) \qquad f(n)的阶≥g(n)的阶\\f(n)=θ(g(n)) \qquad f(n)的阶＝g(n)的阶\\f(n)=o(g(n)) \qquad f(n)的阶＜g(n)的阶\\\]

递归

二分查找（递归）

int binary_search(int* a, int left, int right, int target){
    if(left > right) return -1;
    int mid = (left + right) / 2;
    if(a[mid] == target) return mid;
    if(a[mid] < target) return binary_search(a, mid + 1, right, target);
    else return binary_search(a, left, mid - 1, target);
}

二分查找（非递归）

int binary_search(int* a, int left, int right, int target){
    while(left <= right){
        int mid = (left + right) / 2;
        if(a[mid] == target) return mid;
        if(a[mid] < target) left = mid + 1;
        else right = mid - 1;
    }
    return -1;
}

快速排序

选择划分基准 a(p)
将数组 a 划分成两个子数组，使得 a[l...p-1] <= a(p)，a[p+1...r] >= a(p)
递归调用快速排序算法，对 a[l...p-1] 和 a[p+1...r] 进行排序

递归

C参考实现

void quickSort(int* a, int left, int right){
    int i = left, j = right, base = a[left], tmp;
    if(left >= right) return;
    while(i != j){
        while(a[j] >= base && i < j) j--;
        while(a[i] <= base && i < j) i++;
        if(i < j) tmp = a[i], a[i] = a[j], a[j] = tmp;
    }
    a[left] = a[i], a[i] = base;
    quickSort(a, left, i - 1);
    quickSort(a, i + 1, right);
}

Java参考实现

public class QuickSort {
    private static void swap(int[] arr, int i, int j){
        int tmp = arr[i];
        arr[i] = arr[j];
        arr[j] = tmp;
    }

    private static int partition(int[] arr, int left, int right){
        int j = left - 1;
        for(int i = left; i < right; i++)
            if (arr[i] < arr[right]) swap(arr, i, ++j);
        swap(arr, right, ++j);
        return j;
    }

    public static void sort(int[] arr, int left, int right){
        if(left < right){
            int index = partition(arr, left, right);
            sort(arr, left, index - 1);
            sort(arr, index + 1, right);
        }
    }

    public static void main(String[] args){
        int[] arr = {4, 8, 2, 1, 5, 6, 7, 9, 3};
        sort(arr, 0, arr.length - 1);
        for (int x: arr) System.out.print(x + " ");
    }
}

非递归

import java.util.LinkedList;

public class QuickSort2 {
    private static void swap(int[] arr, int i, int j){
        int tmp = arr[i];
        arr[i] = arr[j];
        arr[j] = tmp;
    }

    private static int partition(int[] arr, int left, int right){
        int j = left - 1;
        for(int i = left; i < right; i++)
            if(arr[i] < arr[right]) swap(arr, i, ++j);
        swap(arr, right, ++j);
        return j;
    }

    public static void sort(int[] arr, int left, int right){
        if (left >= right) return;
        LinkedList stack = new LinkedList<>();
        stack.push(left);
        stack.push(right);
        while (!stack.isEmpty()){
            int end = stack.pop();
            int begin = stack.pop();
            if (begin < end){
                int index = partition(arr, begin, end);
                stack.push(begin);
                stack.push(index - 1);
                stack.push(index + 1);
                stack.push(end);
            }
        }
    }

    public static void main(String[] args){
        int[] arr = new int[]{3, 1, 4, 9, 6, 0, 7, 2, 5, 8};
        sort(arr, 0, arr.length - 1);
        for (int e: arr) System.out.print(e + " ");
    }
}

分治法

基本思想

将求解的较大规模的问题分割成 k 个更小规模的子问题。对这 k 个子问题分别求解。如果子问题的规模仍然不够小，则再划分为 k 个子问题，如此递归的进行下去，直到问题规模足够小，很容易求出其解为止。将求出的小规模的问题的解合并为一个更大规模的问题的解，自底向上逐步求出原来问题的解。

适用条件

分治法所能解决的问题一般具有以下几个特征：

该问题的规模缩小到一定的程度就可以容易地解决；
该问题可以分解为若干个规模较小的相同问题，即该问题具有最优子结构性质
利用该问题分解出的子问题的解可以合并为该问题的解；
该问题所分解出的各个子问题是相互独立的，即子问题之间不包含公共的子问题。

归并排序

其基本思想是：将待排序元素分成大小大致相同的 2 个子集合，分别对 2 个子集合进行排序，最终将排好序的子集合合并成为所要求的排好序的集合。

void merge(int* a, int x, int mid, int y, int* tmp){
    int i = x, j = mid + 1, t = 0;
    while(i <= mid && j <= y) tmp[t++] = a[i] <= a[j] ? a[i++] : a[j++];
    while(i <= mid) tmp[t++] = a[i++];
    while(j <= y) tmp[t++] = a[j++];
    t = 0;
    while(x <= y) a[x++] = tmp[t++];
}

void sort(int* a, int x, int y, int* tmp){
    if(x < y){
        int mid = (x + y) / 2;
        sort(a, x, mid, tmp);
        sort(a, mid + 1, y, tmp);
        merge(a, x, mid, y, tmp);
    }
}

求逆序对数

考虑 $1,2,…,n$ 的排列 $i1，i2，…，in$，如果其中存在 $j,k$，满足 $j < k$ 且 $i_j > i_k$，那么就称 $(i_j,i_k)$ 是这个排列的一个逆序。

一个排列含有逆序的个数称为这个排列的逆序数。例如排列 263451 含有8个逆序 (2,1),(6,3),(6,4),(6,5),(6,1),(3,1),(4,1),(5,1)，因此该排列的逆序数就是 8。显然，由 1,2,…,n 构成的所有 n! 个排列中，最小的逆序数是 0，对应的排列就是 1,2,…,n；最大的逆序数是 n(n-1)/2，对应的排列就是 n,(n-1),…,2,1。逆序数越大的排列与原始排列的差异度就越大。

基本思路：

1.使用二分归并（分治法）进行求解； 2.将序列依此划分为两两相等的子序列； 3.对每个子序列进行排序（比较 a[i] > a[j]，如果满足条件，则求该子序列的逆序数 count = mid - i + 1，其中 mid = (left + right) / 2） 4.接着合并子序列即可。

void merge(int* a, int left, int mid, int right, int* tmp){
    int i = left, j = mid + 1, t = 0;
    while(i <= mid && j <= right){
        if(a[i] <= a[j]) tmp[t++] = a[i++];
        else{
            tmp[t++] = a[j++];
            count += mid - i + 1;
        }
    }
    while(i <= mid) tmp[t++] = a[i++];
    while(j <= right) tmp[t++] = a[j++];
    t = 0;
    while(left <= right) a[left++] = tmp[t++];
}

void mergeSort(int* a, int left, int right, int* tmp){
    if(left < right){
        int mid = (left + right) / 2;
        mergeSort(a, left, mid, tmp);
        mergeSort(a, mid + 1, right, tmp);
        merge(a, left, mid, right, tmp);
    }
}

快速选择算法

基本思想：

快速选择的总体思路与快速排序一致，选择一个元素作为基准来对元素进行分区，将小于和大于基准的元素分在基准左边和右边的两个区域。不同的是，快速选择并不递归访问双边，而是只递归进入一边的元素中继续寻找。这降低了平均时间复杂度，从 $O(nlogn)$ 至 $O(n)$，不过最坏情况仍然是 $O(n^2)$。

int partition(int* a, int left, int right){
    int j = left - 1, tmp;  // 选择a[right]作为划分基准
    for(int i = left; i < right; i++){
        if(a[i] <= a[right]) tmp = a[i], a[i] = a[++j], a[j] = tmp;
    }
    tmp = a[right], a[right] = a[++j], a[j] = tmp;
    return j;
}

int quick_select(int* a, int left, int right, int k){
    if(left == right) return a[left];
    int idx = partition(a, left, right), cur = idx - left + 1;
    if(k == cur) return a[idx];
    else if(k < cur) return quick_select(a, left, idx - 1, k);
    else return quick_select(a, idx + 1, right, k - cur);
}

线性时间选择（BFPRT）

基本思路：

首先把数组按 5 个数为一组进行分组，最后不足 5 个的忽略。对每组数进行排序（如插入排序）求取其中位数。
把上一步的所有中位数移到数组的前面，对这些中位数递归调用 BFPRT 算法求得他们的中位数。
将上一步得到的中位数作为划分的主元进行整个数组的划分。
判断第k个数在划分结果的左边、右边还是恰好是划分结果本身，前两者递归处理，后者直接返回答案。

void bubble_sort(int* a, int left, int right){
    int tmp;
    for(int i = left; i < right; i++){
        for(int j = right; j > i; j--){
            if(a[j] < a[j-1]) tmp = a[j], a[j] = a[j-1], a[j-1] = tmp;
        }
    }
}

int partition(int* a, int left, int right, int baseIdx){
    int j = left - 1, tmp;
    // 将基准放于数组尾部
    tmp = a[right], a[right] = a[baseIdx], a[baseIdx] = tmp;
    for(int i = left; i < right; i++){
        if(a[i] <= a[right]) tmp = a[i], a[i] = a[++j], a[j] = tmp;
    }
    tmp = a[right], a[right] = a[++j], a[j] = tmp;
    return j;
}

int bfprt(int* a, int left, int right, int k){
    if(right - left + 1 <= 5){  // 小于等于5个数，直接排序得到结果
        bubble_sort(a, left, right);
        return a[left + k - 1];
    }
    int t = left - 1, tmp;  // t:当前替换到前面的中位数的下标
    for(int st = left, ed; (ed = st + 4) <= right; st += 5){
        bubble_sort(a, st, ed);
        // 将中位数替换到数组前面，便于递归求取中位数的中位数
        tmp = a[++t], a[t] = a[st+2], a[st+2] = tmp;
    }
    int baseIdx = (left + t) >> 1; // left到t的中位数的下标，作为主元的下标
    bfprt(a, left, t, baseIdx - left + 1); // 不关心中位数的值，保证中位数在正确的位置
    int idx = partition(a, left, right, baseIdx), cur = idx - left + 1;
    if(k == cur) return a[idx];
    else if(k < cur) return bfprt(a, left, idx - 1, k);
    else return bfprt(a, idx + 1, right, k - cur);
}

动态规划

基本步骤

找出最优解的性质，并刻划其结构特征。
递归地定义最优值。
以自底向上的方式计算出最优值。
根据计算最优值时得到的信息，构造最优解。

矩阵连乘

public static void matrixChain(int[] p, int[][] m, int[][] s) {
    int n = p.length - 1;
    for (int i = 1; i <= n; i++) m[i][i] = 0;
    for (int r = 2; r <= n; r++)
        for (int i = 1; i <= n - r + 1; i++) {
            int j = i + r - 1;
            m[i][j] = m[i + 1][j] + p[i - 1] * p[i] * p[j];
            s[i][j] = i;
            for (int k = i + 1; k < j; k++) {
                int t = m[i][k] + m[k + 1][j] + p[i - 1] * p[k] * p[j];
                if (t < m[i][j]) {
                    m[i][j] = t;
                    s[i][j] = k;
                }
            }
        }
    }
}

最优子结构

当问题的最优解包含了其子问题的最优解时，称该问题具有最优子结构性质。

例如，矩阵连乘计算次序问题的最优解包含着其子问题的最优解，这种性质称为最优子结构性质。

利用问题的最优子结构性质，以自底向上的方式递归地从子问题的最优解逐步构造出整个问题的最优解。最优子结构是问题能用动态规划算法求解的前提。

重叠子问题

在递归算法自顶向下求解问题时，每次产生的子问题并不总是新问题，有些子问题被反复计算多次。这种性质称为子问题的重叠性质。

动态规划算法，对每一个子问题只解一次，而后将其解保存在一个表格中，当再次需要解此子问题时，只是简单地用常数时间查看一下结果。

LIS最长单调递增子序列

设序列为 a[0:n-1]，记 b[i]：以 a[i] 为结尾元素的最长递增子序列的长度。

则序列 a 的最长递增子序列长度为：max{b[i]}, 0<=i

如何求 b[i] ?

b[0] = 1，b[i] = max{b[k]} + 1, (0<=k

public static int LIS() {
    for(int i = 1, b[0] = 1; i < n; i++){
        for(int j = 0, k = 0; j < i; j++) {
            if(a[j] <= a[i] && k < b[j]) k = b[j];
        }
        b[i] = k + 1;
    }
}

`LCS最长公共子序列`

给定 2 个序列，$X={x_1,x_2,…,x_m}$ 和 $Y={y_1,y_2,…,y_n}$，找出 X 和 Y 的最长公共子序列。

设序列 $X={x_1,x_2,…,x_m}$ 和 $Y={y_1,y_2,…,y_n}$ 的最长公共子序列为 $Z={z_1,z_2,…,z_k}$，则

1)若 $x_m=y_n$，则 $z_k=x_m=y_n$，且 $Z_{k-1}$ 是 $X_{m-1}$ 和 $Y_{n-1}$ 的最长公共子序列。

2)若 $x_m≠y_n$，则 $Z$ 是 $X_{m-1}$ 和 $Y$ 的最长公共子序列，$X$ 和 $Y_{n-1}$ 的最长公共子序列，中较长的序列。

2 个序列的最长公共子序列包含了这 2 个序列的前缀的最长公共子序列。因此，最长公共子序列问题具有最优子结构性质。

由最长公共子序列问题的最优子结构性质建立子问题最优值的递归关系。用 $c[i][j]$ 记录序列的最长公共子序列的长度。其中，$X_i={x_1,x_2,…,x_i}$；$Y_j={y_1,y_2,…,y_j}$。当 $i=0$ 或 $j=0$ 时，空序列是 $X_i$ 和 $Y_j$ 的最长公共子序列。故此时 $c[i][j]=0$。其他情况下，由最优子结构性质可建立递归关系如下：

i=0,j=0：c[i][j]=0
i,j>0; x[i]==y[i]：c[i][j]=c[i-1][j-1]+1
i,j>0; x[i]!=y[i]：c[i][j]=max{c[i][j-1],c[i-1][j]}

memset(dp, 0, sizeof(dp));
for (int i = 0; i < strlen(a); ++i) {
    for (int j = 0; j < strlen(b); ++j) {
        if(a[i] == b[j]) dp[i+1][j+1] = dp[i][j] + 1;
        else dp[i+1][j+1] = max(dp[i+1][j], dp[i][j+1]);
    }
}

Algorithm lcsLength(x, y){
    m = x.length - 1;
    n = y.length - 1;
    c[i][0] = 0; c[0][i] = 0;
    for (int i = 1; i <= m; i++)
        for (int j = 1; j <= n; j++)
            if (x[i] == y[j]) {
                c[i][j] = c[i-1][j-1] + 1;
            }else if (c[i-1][j] >= c[i][j-1]) {
                c[i][j] = c[i-1][j];
            }else{
                c[i][j] = c[i][j-1];
            }
}

Algorithm lcs(int i, int j, char [] x){
    if (i == 0 || j == 0) return;
    if (x[i] == y[i]){
        lcs(i-1, j-1, x);
        print(x[i]);
    }else if (c[i-1][j] >= c[i][j-1]) lcs(i-1, j, x);
    else lcs(i, j-1, x);
}

`分治法与动态规划的区别`

分治法与动态规划有何共同点？提示：从所适用问题的特点，解决问题的方式上阐述两者所解决的问题，都能划分为若干个规模较小的子问题这些子问题具有最优子结构性质能通过子问题的最优解自底向上地得到问题的最优解
分治法与动态规划又有何不同？提示：从子问题的角度阐述分治法适用于子问题相互独立的情况，即子问题之间不存在公共子问题动态规划适用于子问题存在重叠的情况，对每一个子问题只解一次，而后将其解保存在一个表格中，当再次需要解此子问题时，只是简单地用常数时间查看一下结果

`贪心算法`

`基本思想`

贪心算法总是做出在当前看来最好的选择。也就是说贪心算法并不从整体最优考虑，它所作出的选择只是在某种意义上的局部最优选择。在一些情况下，即使贪心算法不能得到整体最优解，其最终结果却是最优解的很好近似。

`活动安排问题`

/*
 * 各活动的起始时间和结束时间存储于数组s和f中且按结束时间的非减序排列
 * a数组记录是否安排相应活动
 */
public static int greedySelector(int [] s, int [] f, boolean a[]){
    int n = s.length-1;
    a[1] = true;
    int j = 1;
    int count = 1;
    for (int i = 2; i <= n; i++) {
        if (s[i] >= f[j]) {
            a[i] = true;
            j = i;
            count++;
        }else a[i] = false;
    }
    return count;
}

`最优子结构性质`

当一个问题的最优解包含其子问题的最优解时，称此问题具有最优子结构性质。问题的最优子结构性质是该问题可用动态规划算法或贪心算法求解的关键特征。

`贪心选择性质`

所谓贪心选择性质是指所求问题的整体最优解可以通过一系列局部最优的选择，即贪心选择来达到。这是贪心算法可行的第一个基本要素，也是贪心算法与动态规划算法的主要区别。

在动态规划算法中，每步所做出的选择往往依赖于相关子问题的解。因而只有在解出相关子问题后，才能做出选择。而在贪心算法中，仅在当前状态下做出最好选择，即局部最优选择。然后再去解做出这个选择后产生的相应的子问题。

贪心算法和动态规划算法都要求问题具有最优子结构性质，这是两类算法的一个共同点。

对于一个具体问题，要确定它是否具有贪心选择性质，必须证明每一步所作的贪心选择最终导致问题的整体最优解。（即证明有解必有贪心解）

`贪心算法求解背包问题`

基本步骤：

首先计算每种物品单位重量的价值 $V_i/W_i$
然后，依贪心选择策略，将尽可能多的单位重量价值最高的物品装入背包
若将这种物品全部装入背包后，背包内的物品总重量未超过 C，则选择单位重量价值次高的物品并尽可能多地装入背包。
依此策略一直地进行下去，直到背包装满为止。

public static float knapsack(float c, float[] w, float[] v,float[] x){
    int n = v.length;
    Element [] d = new Element [n];
    for (int i = 0; i < n; i++) d[i] = new Element(w[i], v[i], i);
    MergeSort.mergeSort(d);
    int i;
    float opt = 0;
    for (i = 0; i < n; i++) x[i] = 0;
    for (i = 0; i < n; i++) {
        if (d[i].w > c) break;
        x[d[i].i] = 1;
        opt += d[i].v;
        c -= d[i].w;
    }
    if (i < n){
        x[d[i].i] = c / d[i].w;
        opt += x[d[i].i] * d[i].v;
    }
    return opt;
}

对于 0-1 背包问题，贪心选择之所以不能得到最优解是因为在这种情况下，它无法保证最终能将背包装满，部分闲置的背包空间使每公斤背包空间的价值降低了。

事实上，在考虑 0-1 背包问题时，应比较选择该物品和不选择该物品所导致的最终方案，然后再作出最好选择。

`最优装载问题`

public static float loading(float c, float[] w, int[] x){
    int n = w.length;
    Element [] d = new Element [n];
    for (int i = 0; i < n; i++) d[i] = new Element(w[i], i);
    MergeSort.mergeSort(d);
    float opt = 0;
    for (int i = 0; i < n; i++) x[i] = 0;
    for (int i = 0; i < n && d[i].w <= c; i++) {
        x[d[i].i] = 1;
        opt += d[i].w;
        c -= d[i].w;
    }
    return opt;
}

`哈夫曼编码`

`应用`

哈夫曼编码是广泛地用于数据文件压缩的十分有效的编码方法。给出现频率高的字符较短的编码，出现频率较低的字符以较长的编码，可以大大缩短总码长。

`构造哈夫曼编码`

哈夫曼算法以自底向上的方式构造表示最优前缀码的二叉树 T。
算法以 C 个叶结点开始，执行 C-1 次的“合并”运算后产生最终所要求的树 T。

`单源最短路径`

`单源最短路问题`

给定带权有向图 G=(V,E)，其中每条边的权是非负实数。另外，还给定 V 中的一个顶点，称为源。现在要计算从源到所有其他各顶点的最短路长度。这里路的长度是指路上各边权之和。

`Dijkstra 算法`

Dijkstra 算法是解单源最短路径问题的贪心算法。其基本思想是，设置顶点集合 S 并不断地作贪心选择来扩充这个集合。一个顶点属于集合 S 当且仅当从源到该顶点的最短路径长度已知。

基本步骤：

初始时，S 中仅含有源。
设 u 是 G 的某一个顶点，把从源到 u 且中间只经过 S 中顶点的路称为从源到 u 的特殊路径，并用数组 dist 记录当前每个顶点所对应的最短特殊路径长度。
Dijkstra 算法每次从 V-S 中取出具有最短特殊路长度的顶点 u，将 u 添加到 S 中，同时对数组 dist 作必要的修改。
一旦 S 包含了所有 V 中顶点，dist 就记录了从源到所有其他顶点之间的最短路径长度。

int cost[MAX_V][MAX_V];  // cost[u][v]表示边e=(u,v)的权值（不存在这条边时设为INF）
int dist[MAX_V];  // 顶点s出发的最短距离
bool used[MAX_V];  // 已经使用过的图
int V;  // 顶点数

// 求从起点s出发到各个顶点的最短距离
void dijkstra(int s){
    fill(dist, dist + V, INF);
    fill(used, used + V, false);
    dist[s] = 0;
    while(true){
        int v = -1;
        // 从尚未使用过的顶点中选择一个距离最小的顶点
        for(int u = 0; u < V; u++){
            if(!used[u] && (v == -1 || dist[u] < dist[v])) v = u;
        }
        if(v == -1) break;
        used[v] = true;
        for(int u = 0; u < V; u++){
            dist[u] = min(dist[u], dist[v] + cost[v][u]);
        }
    }
}

`最小生成树`

`定义`

设 $G =(V,E)$ 是无向连通带权图，即一个网络。$E$ 中每条边 $(v,w)$ 的权为 $c[v][w]$。如果 $G$ 的子图 $G’$ 是一棵包含 $G$ 的所有顶点的树，则称 $G’$ 为 $G$ 的生成树。生成树上各边权的总和称为该生成树的耗费。在 $G$ 的所有生成树中，耗费最小的生成树称为 $G$ 的最小生成树。

`最小生成树性质`

设 $G=(V,E)$ 是连通带权图，$U$ 是 $V$ 的真子集。如果 $(u,v) \in E$，且 $u \in U$，$v \in V-U$，且在所有这样的边中，$(u,v)$ 的权 $c[u][v]$ 最小，那么一定存在 $G$ 的一棵最小生成树，它以 $(u,v)$ 为其中一条边。这个性质有时也称为 MST 性质。

`Prim算法`

设 $G=(V,E)$ 是连通带权图，$V={1,2,…,n}$。构造 $G$ 的最小生成树的 Prim 算法的基本思想是：

首先置 $S=\{1\}$，
然后，只要 $S$ 是 $V$ 的真子集，就作如下的贪心选择
选取满足条件 $i \in S$，$j \in V-S$，且 $c[i][j]$ 最小的边，将顶点j添加到 $S$ 中。
这个过程一直进行到 $S=V$ 时为止。在这个过程中选取到的所有边恰好构成 G 的一棵最小生成树。

int cost[MAX_V][MAX_V];  // cost[u][v]表示边e=(u,v)的权值（不存在这条边时设为INF）
int mistcost[MAX_V];  // 从集合X出发的边到每个顶点的最小权值
bool used[MAX_V];  // 顶点i是否包含在集合X中
int V;  // 顶点数

int prim(){
    for(int i = 0; i < V; i++){
        mincost[i] = INF;
        used[i] = false;
    }
    mincost[0] = 0;
    int res = 0;
    while(true) {
        int v = -1;
        // 从不属于X的顶点中选取从X到其权值最小的顶点
        for(int u = 0; u < V; u++){
            if(!used[u] && (v == -1 || mincost[u] < mincost[v])) v = u;
        }
        if(v == -1) break;
        used[v] = true;  // 把顶点v加入X
        res += mincost[v];  // 把边的长度加到结果里
        for(int u = 0; u < V; u++){
            mincost[u] = min(mincost[u], cost[v][u]);
        }
    }
    return res;
}

`Kruskal 算法`

Kruskal 算法构造 $G$ 的最小生成树的基本思想是：

首先将 $G$ 的 $n$ 个顶点看成 $n$ 个孤立的连通分支。
将所有的边按权从小到大排序。
然后从第一条边开始，依边权递增的顺序查看每一条边，并按下述方法连接 2 个不同的连通分支
当查看到第 $k$ 条边 $(v,w)$ 时，如果端点 $v$ 和 $w$ 分别是当前 2 个不同的连通分支 $T1$ 和 $T2$ 中的顶点时，就用边 $(v,w)$ 将 $T1$ 和 $T2$ 连接成一个连通分支，然后继续查看第 $k+1$ 条边；
如果端点 $v$ 和 $w$ 在当前的同一个连通分支中，就直接再查看第 $k+1$ 条边。
这个过程一直进行到只剩下一个连通分支时为止。

struct edge {
    int u;
    int v;
    int cost;
};

bool cmp(const edge &e1, const edge &e2) {
    return e1.cost < e2.cost;
}

edge es[MAX_E];
int V, E;  // 顶点数和边数

int krustral() {
    sort(es, es + E, comp);  // 按照edge.cost的顺序从小到大排列
    init_union_find(V);  // 并查集初始化
    int res = 0;
    for(int i = 0; i < E; i++){
        edge e = es[i];
        if(!same(e.u, e.v)){
            unite(e.u, e.v);
            res += e.cost;
        }
    }
    return res;
}

`并查集`

`主要操作`

初始化集合中每个元素单独作为一个子集。
查找查找元素 x 所在的子集序号。常用来判断元素 x 和 y 是否在同一子集中。
合并将元素 x 和 y 分别所在的子集合并为一个子集。

`算法实现`

// 用编号代表每个元素，数组par表示父亲的编号，当par[x]=x时，x是所在树的树根
int par[MAX_N];  // 父亲
int rank[MAX_N];  // 树的高度

// 初始化n个元素
void init(int n) {
    for(int i = 0; i < n; i++) {
        par[i] = i;
        rank[i] = 0;
    }
}

// 查询树的根
int find(int x) {
    if(par[x] == x) {
        return x;
    } else {
        return par[x] = find(par[x]);
    }
}

// 合并x和y所属的集合
void unite(int x, int y) {
    x = find(x);
    y = find(y);
    if(x == y) return;
    if(rank[x] < rank[y]) {
        par[x] = y;
    } else {
        par[y] = x;
        if(rank[x] == rank[y]) rank[x]++;
    }
}

`优先队列`

`主要操作`

初始化将给定多个元素初始化为优先队列。
出队将优先权最大的元素x出队，并调整结构为优先队列。
入队加入元素x，并调整结构为优先队列。

`算法实现`

// 节点从0开始编号
int heap[MAX_N], sz = 0;
void push(int x) {
    // 自己节点的编号
    int i = sz++;
    while(i > 0) {
        // 父亲节点的编号
        int p = (i-1) / 2;
        // 如果已经没有大小颠倒则退出
        if(heap[p] <= x) break;
        // 把父亲节点的数组放下来，而把自己提上去
        heap[i] = heap[p];
        i = p;
    }
    heap[i] = x;
}

int pop() {
    // 最小值
    int ret = heap[0];
    // 要提到根的数值
    int x = heap[--sz];
    // 从根开始向下交换
    int i = 0;
    while(i * 2 + 1 < sz) {
        // 比较儿子的值
        int a = i * 2 + 1, b = i * 2 + 2;
        if(b < sz && heap[b] < heap[a]) a = b;
        // 如果已经没有大小颠倒则退出
        if(heap[a] >= x) break;
        // 把儿子的数值提上来
        heap[i] = heap[a];
        i = a;
    }
    heap[i] = x;
    return ret;
}

`回溯法`

`定义`

为了避免生成那些不可能产生最佳解的问题状态，要不断地利用限界函数(bounding function)来处死那些实际上不可能产生所需解的活结点，以减少问题的计算量。具有限界函数的深度优先生成法称为回溯法。

`基本思想`

针对所给问题，定义问题的解空间；
确定易于搜索的解空间结构；
以深度优先方式搜索解空间，并在搜索过程中用剪枝函数避免无效搜索。

常用剪枝函数：用约束函数在扩展结点处剪去不满足约束的子树；用限界函数剪去得不到最优解的子树。这种方法适用于解一些组合数相当大的问题。

`回溯法的特征`

用回溯法解题的一个显著特征是在搜索过程中动态产生问题的解空间。在任何时刻，算法只保存从根结点到当前扩展结点的路径。如果解空间树中从根结点到叶结点的最长路径的长度为 $h(n)$，则回溯法所需的计算空间通常为 $O(h(n))$。

`递归回溯`

void backtrack(int t) {
    if (t > n) output(x);
    else
        for (int i = f(n,t); i <= g(n,t); i++) {
            x[t] = h(i);
            if (constraint(t) && bound(t)) backtrack(t + 1);
        }
}

`迭代回溯`

void iterativeBacktrack() {
    int t = 1;
    while (t > 0) {
        if (f(n,t) <= g(n,t))
            for (int i = f(n,t); i <= g(n,t); i++) {
                x[t] = h(i);
                if (constraint(t) && bound(t)) {
                    if (solution(t)) output(x);
                    else t++;
                }
            }
        else t--;
    }
}

`求S的所有元素个数小于4的子集`

已知集合 $S=\{a,b,c,d,e,f,g\}$，请编程输出 $S$ 的所有元素个数小于 4 的子集。

#define n 7
char s[n] = {a,b,c,d,e,f,g};
int x[n+1];
void output(int* x) {
}
void all_subset() {
    backtrack(0);
}
void backtrack (int t) {
    if (t >= n) output(x);
    else
        for (int i = 0; i <= 1; i++) {
            x[t] = i;
            if(count(x, t) < 4) backtrack(t + 1);
        }
}

`求S的所有元素和小于8的子集`

已知集合 $S=\{1,2,3,4,5,6,7\}$，请编程输出 $S$ 的所有元素和小于 8 的子集。

#define n 7
char s[n] = {1,2,3,4,5,6,7};
int x[n+1];
void output(int* x) {
}
void all_subset() {
    backtrack(0);
}
void backtrack (int t) {
    if (t >= n) output(x);
    else
        for (int i = 0; i <= 1; i++) {
            x[t] = i;
            if(sum(x, t) < 8) backtrack(t + 1);
        }
}

`求S满足元素奇偶性相同且和小于8的子集`

已知集合 $S=\{1,2,3,4,5,6,7\}$，请编程输出 $S$ 的所有满足下列条件的子集：元素奇偶性相同，且和小于 8。

#define n 7
char s[n] = {1,2,3,4,5,6,7};
int x[n+1];
void output(int* x) {
}
void all_subset() {
    backtrack(0, 0, -1);
}
void backtrack (int t, int sum, int prior) {
    if (t >= n) output(x);
    else {
        x[t] = 0, backtrack(t + 1, sum, prior);
        x[t] = 1;
        sum += s[t];
        if(sum < 8 && (prior == -1 || (s[t] - s[prior]) % 2 == 0) {
            backtrack(t + 1, sum, t);
        }
    }
}

`求S的所有排列`

已知集合 $S=\{1,2,3,4,5,6,7\}$，请编程输出 S 的所有排列。

#define n 7
char s[n+1] = {1,2,3,4,5,6,7};
void output(char* s) {
}
void all_permutation() {
    backtrack(0);
}
void backtrack (int t) {
    if (t >= n) output(s);
    else
        for (int i = t; i < n; i++) {
            swap(s[t], s[i]);
            backtrack(t + 1);
            swap(s[t], s[i]);
        }
}

`求S的所有满足奇偶数相间出现的排列`

已知集合 $S=\{1,2,3,4,5,6,7,8\}$，请编程输出 S 的所有满足下列条件的排列：奇偶数相间出现。

#define n 7
char s[n+1] = {1,2,3,4,5,6,7};
void output(char* s) {
}
void all_permutation() {
    backtrack(0);
}
void backtrack (int t) {
    if (t >= n) output(s);
    else
        for (int i = t; i < n; i++) {
            swap(s[t], s[i]);
            if(legal(t)) backtrack(t + 1);
            swap(s[t], s[i]);
        }
}
bool legal(int t){
    bool bRet = true;
    if(t > 0) bRet &&= ((s[t - 1] - s[t]) % 2 == 1);
    return bRet;
}

`0-1 背包问题`

重量 $w=\{2,2,3,4,5,5,6\}$，价值 $v=\{3,4,3,4,5,8,7\}$，$C=16$，求背包的最大价值。

#define n 7
int C = 16;
int w[n] = {2,2,3,4,5,5,6};
int v[n] = {3,4,3,4,5,8,7};
int x[n+1], Max = 0;
void output(int* x);
void main() {
    backtrack(0);
}
void backtrack (int t) {
    if (t >= n) process(x);
    else
        for (int i = 0; i <= 1; i++) {
            x[t] = i;
            if(legal(t)) backtrack(t + 1);
        }
}
bool legal(int t){
    int sum = 0;
    for(int i = 0; i <= t; i++){
        sum += x[i] * w[i];
    }
    return sum <= C;
}
void process(x) {
    for(int i = 0; i < n; i++){
        sum += x[i] * v[i];
    }
    if(Max < sum) Max = sum;
}

`装载问题`

void backtrack (int i) {  // 搜索第i层结点
    if (i > n) {  //到达叶结点更新最优解bestx
        return;
    }
    r -= w[i];
    if (cw + w[i] <= c) {  // 搜索左子树
        x[i] = 1;
        cw += w[i];
        backtrack(i + 1);
        cw -= w[i];
    }
    if (cw + r > bestw)  {  // 搜索右子树
        x[i] = 0;
        backtrack(i + 1);
    }
    r += w[i];
}

`n皇后问题`

boolean place(int k) {
    for (int j = 1; j < k; j++)
        if (abs(k - j) == abs(x[j] - x[k])) return false;
    return true;
}
void backtrack(int t) {
    if (t > n) output(x);
    else
        for (int i = t; i <= n; i++) {
            swap(x[t], x[i]);
            if (place(t)) backtrack(t + 1);
            swap(x[t], x[i]);
        }
}



CentOS7下Firewall的设置与使用
2020-05-16T10:53:39.000Z
防火墙 firewalld 守护服务引入了一个信任级别的概念来管理与之相关联的连接与接口。它支持 ipv4 与 ipv6，并支持网桥，采用 firewall-cmd (command) 或 firewall-config (gui) 来动态的管理 kernel netfilter 的临时或永久的接口规则，并实时生效而无需重启服务。
[译]CentOS7下Firewall的设置与使用 原文出处：How To Set Up a Firewall Using FirewallD on CentOS 7 原本作者：Justin Ellingwood 译者：wylu
如何在CentOS7上使用FirewallD设置防火墙
简介
Firewalld 是可用于许多 Linux 发行版的防火墙管理解决方案，它充当 Linux 内核提供的 iptables 数据包过滤系统的前端。在本指南中，我们将介绍如何为服务器设置防火墙，并向您展示使用 firewall-cmd 管理工具管理防火墙的基本知识（如果您希望在 CentOS中 使用 iptables，请遵循本指南）。
注意：有可能您正在使用比撰写本文时可用的新版本的 firewalld，或者您的服务器设置与本指南中使用的示例服务器略有不同。因此，本指南中说明的某些命令的行为可能会因您的特定配置而异。
Firewalld中的基本概念
在开始讨论如何实际使用 firewall-cmd 实用程序来管理防火墙配置之前，我们应该熟悉该工具引入的一些基本概念。
Zones
firewalld 守护程序使用称为 "zones" 的实体管理规则组。区域基本上是一组规则，它们决定了允许哪些流量，具体取决于您对计算机所连接的网络的信任程度。为网络接口分配了一个区域，以指示防火墙应允许的行为。
对于可能经常在网络之间移动的计算机（例如笔记本电脑），这种灵活性提供了一种根据环境更改规则的好方法。在公共WiFi网络上运行时，您可能有严格的规则禁止大多数流量，而在连接到家庭网络时允许放宽限制。对于服务器来说，这些区域并不是那么重要，因为网络环境很少更改（如果有的话）。
无论您的网络环境有多动态，熟悉防火墙的每个预定义区域背后的一般概念仍然很有用。按从 最不信任 到 最受信任 的顺序，firewalld 中的预定义区域为：
drop：最低级别的信任。所有传入的连接都将被丢弃而不会回复，并且只能进行传出连接。
block：与上述类似，但不仅仅是丢弃连接，而是使用 icmp-host-prohibited 或 icmp6-adm-prohibited 消息拒绝传入的请求。
public：代表公共的，不受信任的网络。您不信任其他计算机，但可能会视情况允许选择的传入连接。
external：如果您使用防火墙作为网关，则为外部网络。将其配置为伪装NAT，以便您的内部网络保持私有但可访问。
internal：外部区域的另一侧，用于网关的内部。这些计算机相当值得信赖，并且可以使用一些其他服务。
dmz：用于DMZ中的计算机（将无法访问网络其余部分的隔离计算机）。仅允许某些传入连接。
work：用于工作机。信任网络中的大多数计算机。可能还允许其他一些服务。
home：家庭环境。通常，这意味着您信任其他大多数计算机，并且将接受其他一些服务。
trusted：信任网络中的所有计算机。可用选项中最开放的，应谨慎使用。
要使用防火墙，我们可以创建规则并更改区域的属性，然后将网络接口分配给最合适的区域。
规则永久性
在 firewalld 中，可以将规则指定为 永久规则 或 立即规则。如果添加或修改规则，则默认情况下，将修改当前运行的防火墙的行为。在下次启动时，旧规则将恢复。
大多数 firewall-cmd 操作都可以使用 --permanent 标志来指示应将非临时防火墙作为目标。这将影响在引导时重新加载的规则集。这种分离意味着您可以在活动的防火墙实例中测试规则，然后在出现问题时重新加载。您还可以使用 --permanent 标志随着时间的推移建立一套完整的规则，这些规则将在发出 reload 命令时立即应用。
安装并启用防火墙以在启动时启动
默认情况下，firewalld 是在某些 Linux 发行版上安装的，包括许多 CentOS 7 映像。但是，您可能需要自己安装 firewalld：
1
$ sudo yum install firewalld
安装 firewalld 之后，您可以启用该服务并重新启动服务器。请记住，启用 firewalld 将导致该服务在服务器启动时启动。最佳实践是在配置此行为之前创建防火墙规则并借此机会对其进行测试，以避免潜在的问题。
1
2
$ sudo systemctl enable firewalld
$ sudo reboot
服务器重新启动时，防火墙会随之启动，然后将网络接口放入配置的区域（或退回到配置的默认区域），并且与该区域关联的所有规则都将应用于关联的接口。
我们可以通过键入以下内容来验证该服务正在运行并且可以访问：
1
2
$ sudo firewall-cmd --state
running
这表明我们的防火墙已启动并以默认配置运行。
熟悉当前的防火墙规则
在开始进行修改之前，我们应该熟悉守护程序提供的默认环境和规则。
探索默认值
通过键入以下内容，可以看到当前选择哪个区域作为默认区域：
1
2
$ firewall-cmd --get-default-zone
public
由于我们没有给 firewalld 提供任何偏离默认区域的命令，并且我们的接口都没有配置为绑定到另一个区域，因此该区域（public 区域）也将是唯一的“活动”（active）区域（该区域正在控制我们接口的流量）。我们可以通过输入以下内容进行验证：
1
2
3
$ firewall-cmd --get-active-zones
public
  interfaces: eth0 eth1
在这里，我们可以看到示例服务器具有两个受防火墙控制的网络接口（ eth0 和 eth1 ）。目前，它们都根据为 public 区域定义的规则进行管理。
我们如何知道与 public 区域相关的规则？ 我们可以通过输入以下内容来打印默认区域的配置：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
$ sudo firewall-cmd --list-all
public (default, active)
  target: default
  icmp-block-inversion: no
  interfaces: eth0 eth1
  sources:
  services: ssh dhcpv6-client
  ports:
  protocols:
  masquerade: no
  forward-ports:
  source-ports:
  icmp-blocks:
  rich rules:
从输出中可以看出，该区域既是默认区域（default zone）又是活动区域（active zone），并且 eth0 和 eth1 接口与此区域相关联（我们已经从之前的查询中了解了所有这些信息）。但是，我们还可以看到，该区域允许与 DHCP 客户端（用于 IP 地址分配）和 SSH（用于远程管理）相关的正常操作。
探索可选区域
现在，我们对默认区域和活动区域的配置有了一个好主意。我们还可以找到有关其他区域的信息。
要获取可用区域的列表，请输入：
1
2
$ firewall-cmd --get-zones
block dmz drop external home internal public trusted work
通过在 --list-all 命令中指定 --zone 参数，可以看到与指定区域关联的特定配置：
1
2
3
4
5
6
7
8
9
10
$ sudo firewall-cmd --zone=home --list-all
home
  interfaces:
  sources:
  services: dhcpv6-client ipp-client mdns samba-client ssh
  ports:
  masquerade: no
  forward-ports:
  icmp-blocks:
  rich rules:
您可以使用 --list-all-zones 选项输出所有区域定义。您可能希望将输出通过管道传到 pager 中以便于查看：
1
$ sudo firewall-cmd --list-all-zones | less
为接口选定区域
除非另外配置了网络接口，否则在启动防火墙时，每个接口都将置于默认区域中。
更改接口区域
通过将 --zone 参数与 --change-interface 参数结合使用，可以在会话期间在区域之间转换接口。与所有修改防火墙的命令一样，您将需要使用 sudo。
例如，我们可以通过输入以下命令将 eth0 接口转换为 "home" 区域：
1
2
$ sudo firewall-cmd --zone=home --change-interface=eth0
success
注意：每当将接口转换到新区域时，请注意您可能正在修改将要运行的服务。例如，在这里，我们将移至具有 SSH 可用的 "home" 区域。这意味着我们的连接不应断开。其他一些区域默认情况下未启用 SSH，如果在使用这些区域之一时断开连接，您可能会发现自己无法重新登录。
我们可以通过再次请求活动区域来验证此操作是否成功：
1
2
3
4
5
$ firewall-cmd --get-active-zones
home
  interfaces: eth0
public
  interfaces: eth1
调整默认区域
您最好用一个区域来处理所有接口，这样选择最佳的默认区域然后将其用于配置可能会更容易。
您可以使用 --set-default-zone 参数更改默认区域。这将立即将所有使用默认值的接口更改为新区域：
1
2
$ sudo firewall-cmd --set-default-zone=home
success
为您的应用程序设置规则
为希望提供的服务定义防火墙例外的基本方法很容易。我们将在此处介绍基本概念。
将服务添加到您的区域
最简单的方法是将所需的服务或端口添加到正在使用的区域。同样，您可以使用 --get-services 选项获取可用服务的列表：
1
2
$ firewall-cmd --get-services
RH-Satellite-6 amanda-client amanda-k5-client bacula bacula-client bitcoin bitcoin-rpc bitcoin-testnet bitcoin-testnet-rpc ceph ceph-mon cfengine condor-collector ctdb dhcp dhcpv6 dhcpv6-client dns docker-registry dropbox-lansync elasticsearch freeipa-ldap freeipa-ldaps freeipa-replication freeipa-trust ftp ganglia-client ganglia-master high-availability http https imap imaps ipp ipp-client ipsec iscsi-target kadmin kerberos kibana klogin kpasswd kshell ldap ldaps libvirt libvirt-tls managesieve mdns mosh mountd ms-wbt mssql mysql nfs nrpe ntp openvpn ovirt-imageio ovirt-storageconsole ovirt-vmconsole pmcd pmproxy pmwebapi pmwebapis pop3 pop3s postgresql privoxy proxy-dhcp ptp pulseaudio puppetmaster quassel radius rpc-bind rsh rsyncd samba samba-client sane sip sips smtp smtp-submission smtps snmp snmptrap spideroak-lansync squid ssh synergy syslog syslog-tls telnet tftp tftp-client tinc tor-socks transmission-client vdsm vnc-server wbem-https xmpp-bosh xmpp-client xmpp-local xmpp-server
注意：您可以通过查看 /usr/lib/firewalld/services 目录中与它们相关的 .xml 文件来获得有关每个服务的更多详细信息。例如，SSH 服务（/usr/lib/firewalld/services/ssh.xml）的定义如下：
1
2
3
4
5
6
"1.0" encoding="utf-8"?>
<service>
  <short>SSHshort>
  <description>Secure Shell (SSH) is a protocol for logging into and executing commands on remote machines. It provides secure encrypted communications. If you plan on accessing your machine remotely via SSH over a firewalled interface, enable this option. You need the openssh-server package installed for this option to be useful.description>
  <port protocol="tcp" port="22"/>
service>
您可以使用 --add-service 参数为区域启用服务。该操作将针对默认区域或 --zone 参数指定的任何区域。默认情况下，这只会调整当前的防火墙会话。您可以通过包括 --permanent 标志来调整永久防火墙配置。
例如，如果我们运行的是提供常规 HTTP 流量的 Web 服务器，则可以通过键入以下内容在此会话的 "public" 区域中为接口允许此流量：
1
$ sudo firewall-cmd --zone=public --add-service=http
如果要修改默认区域，可以省略 --zone。我们可以使用 --list-all 或 --list-services 操作来验证操作是否成功：
1
2
$ sudo firewall-cmd --zone=public --list-services
dhcpv6-client http ssh
测试完所有功能后，您可能需要修改永久防火墙规则，以便重新启动后您的服务仍然可用。我们可以通过输入以下内容使 "public" 区域更改永久生效：
1
2
$ sudo firewall-cmd --zone=public --permanent --add-service=http
success
您可以通过在 --list-services 操作中添加 --permanent 标志来验证此操作是否成功。您需要对任何 --permanent 操作使用sudo：
1
2
$ sudo firewall-cmd --zone=public --permanent --list-services
dhcpv6-client http ssh
您的 "public" 区域现在将允许端口 80 上的 HTTP Web 通信。如果您的 Web 服务器配置为使用 SSL/TLS，则还需要添加 https 服务。我们可以通过输入以下内容将其添加到当前会话和永久规则集中：
1
2
$ sudo firewall-cmd --zone=public --add-service=https
$ sudo firewall-cmd --zone=public --permanent --add-service=https
如果没有适当的服务可用怎么办
防火墙安装中包含的防火墙服务代表了您可能希望允许访问的应用程序的许多最常见要求。但是，在某些情况下，这些服务可能无法满足您的要求。
在这种情况下，您有两个选择。
为您的区域打开端口
为您的特定应用程序添加支持的最简单方法是打开它在相应区域中使用的端口。这就像指定端口或端口范围以及需要打开的端口的关联协议一样容易。
例如，如果我们的应用程序在端口 5000 上运行并使用 TCP，则可以使用 --add-port 参数将其添加到此会话的 "public" 区域中。协议可以是 tcp 或 udp：
1
2
$ sudo firewall-cmd --zone=public --add-port=5000/tcp
success
我们可以使用 --list-ports 操作验证此操作是否成功：
1
2
$ sudo firewall-cmd --zone=public --list-ports
5000/tcp
也可以通过用 - 分隔范围内的开始和结束端口来指定顺序的端口范围。例如，如果我们的应用程序使用 UDP 端口 4990 至 4999，则可以通过键入以下内容在 "public" 端口上打开这些端口：
1
$ sudo firewall-cmd --zone=public --add-port=4990-4999/udp
经过测试后，我们可能希望将它们添加到永久防火墙中。您可以通过键入以下内容进行操作：
1
2
3
4
5
6
$ sudo firewall-cmd --zone=public --permanent --add-port=5000/tcp
success
$ sudo firewall-cmd --zone=public --permanent --add-port=4990-4999/udp
success
$ sudo firewall-cmd --zone=public --permanent --list-ports
5000/tcp 4990-4999/udp
定义服务
为您的区域打开端口很容易，但是很难跟踪每个区域的用途。如果您曾经停用服务器上的服务，则可能很难记住仍需要打开哪些端口。为了避免这种情况，可以定义服务。
服务只是带有相关名称和描述的端口的简单集合。使用服务比端口更易于管理，但是需要一些前期工作。最简单的开始方法是将现有脚本（在 /usr/lib/firewalld/services 中找到）复制到 /etc/firewalld/services 目录中，防火墙在该目录中查找非标准定义。
例如，我们可以复制 SSH 服务定义以用于我们的 "example" 服务定义，如下所示。文件名减去 .xml 后缀将指示防火墙服务列表中的服务名称：
1
$ sudo cp /usr/lib/firewalld/services/ssh.xml /etc/firewalld/services/example.xml
现在，您可以调整在复制的文件中找到的定义：
1
$ sudo vi /etc/firewalld/services/example.xml
首先，文件将包含您复制的 SSH 定义：
1
2
3
4
5
6
"1.0" encoding="utf-8"?>
<service>
  <short>SSHshort>
  <description>Secure Shell (SSH) is a protocol for logging into and executing commands on remote machines. It provides secure encrypted communications. If you plan on accessing your machine remotely via SSH over a firewalled interface, enable this option. You need the openssh-server package installed for this option to be useful.description>
  <port protocol="tcp" port="22"/>
service>
该定义的大部分实际上是元数据。您将要在  标记内更改服务的简称。这是您的服务的易读名称。您还应该添加描述，以便在需要审核服务时获得更多信息。您需要进行的实际上会影响服务功能的唯一配置可能是端口定义，您可以在其中定义要打开的端口号和协议。可以多次指定。
对于我们的 "example" 服务，假设我们需要为 TCP 打开端口 7777，为 UDP 打开端口 8888。通过按 i 进入 INSERT 模式，我们可以使用以下内容修改现有定义：
1
2
3
4
5
6
7
"1.0" encoding="utf-8"?>
<service>
  <short>Example Serviceshort>
  <description>This is just an example service.  It probably shouldn't be used on a real system.description>
  <port protocol="tcp" port="7777"/>
  <port protocol="udp" port="8888"/>
service>
按 ESC，然后输入 :x 保存并关闭文件。
重新加载防火墙以访问新服务：
1
$ sudo firewall-cmd --reload
您可以看到它现在在可用服务列表中：
1
2
$ firewall-cmd --get-services
RH-Satellite-6 amanda-client amanda-k5-client bacula bacula-client bitcoin bitcoin-rpc bitcoin-testnet bitcoin-testnet-rpc ceph ceph-mon cfengine condor-collector ctdb dhcp dhcpv6 dhcpv6-client dns docker-registry dropbox-lansync elasticsearch example freeipa-ldap freeipa-ldaps freeipa-replication freeipa-trust ftp ganglia-client ganglia-master high-availability http https imap imaps ipp ipp-client ipsec iscsi-target kadmin kerberos kibana klogin kpasswd kshell ldap ldaps libvirt libvirt-tls managesieve mdns mosh mountd ms-wbt mssql mysql nfs nrpe ntp openvpn ovirt-imageio ovirt-storageconsole ovirt-vmconsole pmcd pmproxy pmwebapi pmwebapis pop3 pop3s postgresql privoxy proxy-dhcp ptp pulseaudio puppetmaster quassel radius rpc-bind rsh rsyncd samba samba-client sane sip sips smtp smtp-submission smtps snmp snmptrap spideroak-lansync squid ssh synergy syslog syslog-tls telnet tftp tftp-client tinc tor-socks transmission-client vdsm vnc-server wbem-https xmpp-bosh xmpp-client xmpp-local xmpp-server
现在，您可以像往常一样在您的区域中使用此服务。
创建自己的区域
尽管预定义的区域对于大多数用户来说可能绰绰有余，但是定义自己的区域来描述其功能可能会有所帮助。
例如，您可能要为 Web 服务器创建一个名为 "publicweb" 的区域。或者，您可能希望为您在专用网络上提供的 DNS 服务配置另一个区域，您可能需要一个名为 "privateDNS" 的区域。
添加区域时，必须将其添加到永久防火墙配置中。然后，您可以重新加载以将配置带入正在运行的会话。例如，我们可以通过键入以下内容来创建我们上面讨论的两个区域：
1
2
$ sudo firewall-cmd --permanent --new-zone=publicweb
$ sudo firewall-cmd --permanent --new-zone=privateDNS
您可以通过键入以下内容来验证这些内容是否存在于您的永久配置中：
1
2
$ sudo firewall-cmd --permanent --get-zones
block dmz drop external home internal privateDNS public publicweb trusted work
如前所述，这些功能在当前的防火墙实例中尚不可用：
1
2
$ firewall-cmd --get-zones
block dmz drop external home internal public trusted work
重新加载防火墙以使这些新区域进入活动配置：
1
2
3
$ sudo firewall-cmd --reload
$ firewall-cmd --get-zones
block dmz drop external home internal privateDNS public publicweb trusted work
现在，您可以开始为您的区域分配适当的服务和端口。通常，最好先调整活动实例，然后在测试后将这些更改转移到永久配置中。例如，对于 "publicweb" 区域，您可能想要添加 SSH，HTTP 和 HTTPS 服务：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
$ sudo firewall-cmd --zone=publicweb --add-service=ssh
$ sudo firewall-cmd --zone=publicweb --add-service=http
$ sudo firewall-cmd --zone=publicweb --add-service=https
$ sudo firewall-cmd --zone=publicweb --list-all
publicweb
  target: default
  icmp-block-inversion: no
  interfaces:
  sources:
  services: ssh http https
  ports:
  protocols:
  masquerade: no
  forward-ports:
  source-ports:
  icmp-blocks:
  rich rules:
同样地，我们可以将 DNS 服务添加到我们的 "privateDNS" 区域：
1
2
3
4
5
6
7
8
9
10
11
$ sudo firewall-cmd --zone=privateDNS --add-service=dns
$ sudo firewall-cmd --zone=privateDNS --list-all
privateDNS
  interfaces:
  sources:
  services: dns
  ports:
  masquerade: no
  forward-ports:
  icmp-blocks:
  rich rules:
然后，我们可以将网络接口更改为这些新区域以对其进行测试：
1
2
$ sudo firewall-cmd --zone=publicweb --change-interface=eth0
$ sudo firewall-cmd --zone=privateDNS --change-interface=eth1
此时，您将有机会测试您的配置。如果这些值对您有用，您将要向永久配置添加相同的规则。您可以通过使用 --permanent 标志重新应用规则来做到这一点：
1
2
3
4
$ sudo firewall-cmd --zone=publicweb --permanent --add-service=ssh
$ sudo firewall-cmd --zone=publicweb --permanent --add-service=http
$ sudo firewall-cmd --zone=publicweb --permanent --add-service=https
$ sudo firewall-cmd --zone=privateDNS --permanent --add-service=dns
在永久应用了这些规则之后，您可以重新启动网络并重新加载防火墙服务：
1
2
$ sudo systemctl restart network
$ sudo systemctl reload firewalld
验证是否分配了正确的区域：
1
2
3
4
5
$ firewall-cmd --get-active-zones
privateDNS
  interfaces: eth1
publicweb
  interfaces: eth0
并验证相应的服务可用于两个区域：
1
2
3
4
$ sudo firewall-cmd --zone=publicweb --list-services
http https ssh
$ sudo firewall-cmd --zone=privateDNS --list-services
dns
您已经成功设置了自己的区域！ 如果要将这些区域之一设为其他接口的默认区域，请记住使用 --set-default-zone 参数配置该行为：
1
$ sudo firewall-cmd --set-default-zone=publicweb
总结
您现在应该对如何在 CentOS 系统上日常使用的防火墙服务进行充分的了解。
Firewalld 服务允许您配置考虑网络环境的可维护规则和规则集。它使您可以通过使用区域在不同的防火墙策略之间无缝过渡，并使管理员能够将端口管理抽象为更友好的服务定义。掌握该系统的使用知识将使您能够利用此工具提供的灵活性和强大功能。


进程间通信机制
2020-05-10T14:51:26.000Z
进程通信（Inter-Process Communication, IPC）是指进程之间的信息交换。其所交换的信息量，少则是一个状态或数值，多则是成千上万个字节。多个进程为了协调完成一项工作，相互之间必须能够进行通信。进程的互斥和同步可归结为低级通信。进程的高级通信是指用户可直接利用系统所提供的一组通信命令，高效地传送大量数据的一种通信方式。操作系统隐藏了进程通信的实现细节，即对用户来说是透明的。这样就大大简化了通信程序编程上的复杂性。
进程间通信机制
Linux 操作系统支持以下几种进程间通信机制：
Unix IPC 机制信号（signal）
管道（pipe）和命名管道（named pipe）
System V 的 IPC 机制信号量（semaphore）
消息队列（message queue）
共享内存（shared memory）
网络通信的套接字机制套接字（socket）
全双工管道机制
以上各种通信机制都提供了相应的接口，IPC 结构图如下所示：
信号
信号是用来向一个或多个进程发送异步事件的软件机制，它类似于硬件中断，所以也叫软中断。信号不仅可以从键盘中断中产生，进程对虚拟内存的非法存取等系统错误环境下也会有信号产生，此外信号还被 shell 程序用来向其子进程发送任务控制命令。
系统中有一组被详细定义的信号类型，使用 man 7 signal 可以看到详细介绍。除了 SIGSTOP（进程终止执行）和 SIGKILL（进程退出）两个信号外，进程可以忽略其余信号。信号没有相对优先级，如果在同一时刻对于一个进程产生了两个信号，则它们将可能以任意顺序到达进程并进行处理。同时 Linux 并不提供处理多个相同类型信号的方式。
信号个数受到处理器字长的限制。32 位字长的处理器最多可以有 32 个信号，而 64 位处理器可以有最多 64 个信号。Linux 通过存储在进程 task_struct 中的信息来实现信号。当前未处理的信号保存在 signal 域中，并带有保存在 blocked 中的被阻塞信号的屏蔽码。除了 SIGSTOP 和 SIGKILL 外，所有的信号都能被阻塞。
系统中只有核心和超级用户进程可以向其他所有进程发送信号，普通进程只能向具有相同 uid 和 gid 的进程或者在同一进程组中的进程发送信号。信号是通过设置 task_struct 结构中 signal 域里的某一位来产生的。如果进程没有阻塞信号并且处于可中断的等待状态，则可以将其状态改成 Running，同时如确认进程还处在运行队列中，就可以通过信号唤醒它。这样系统下次发生调度时，调度管理器将选择它运行。信号必须等待到进程再次运行时才交给它，每次进程从系统调用中退出前，它都会检查 signal 和 blocked 域，看是否有可以立刻发送的非阻塞信号。对当前不可阻塞信号的处理代码放置在 sigaction 结构中。
管道
管道是一个先进先出、大小固定的缓冲区，容量为 1 页（4KB），用于两个进程之间的单向数据传递。当管道有空间时，写者进程把数据送入管道，否则将被阻塞；如果管道中没有数据或读者进程需要的数据多于其中的数据，读者进程会被阻塞，否则执行读者进程的请求。整个过程由操作系统监控完成，互斥地访问管道。当传送的数据量大于管道的容量时，可以通过同步机制分次传送数据。
无名管道
例如：Linux shell 程序中的重定向操作：
1
$ ls -l | more
在这个管道应用中，ls 列出当前目录的输出被作为标准输入送到 more 程序中按格式显示处理。无名管道是将两个相关联的进程联系在一起。shell 程序负责在进程间建立临时的管道。
在 Linux 中，管道是通过指向同一个临时 VFS（Virtual File System，虚拟文件系统）inode 的两个 file 数据结构来实现的，此 VFS inode 指向内存中的一个物理块。当写者进程向管道中写入数据时，字节被复制到共享数据页面中，当读者进程从管道中读时，字节从共享数据页面中复制出来。
Linux 必须同步对管道的访问。它必须保证读者和写者进程以确定的步骤执行，为此需要使用锁、等待队列和信号等同步机制。以写数据为例，如果没有足够的空间容纳对所有写入管道的数据，或者管道被读者进程加锁时，当前进程将在管道 inode 的等待队列中睡眠，同时调度管理器开始执行以选择其他进程来执行。当有足够的空间或者管道被解锁时，它将被读者唤醒，然后执行写操作。当两个进程对管道的使用结束时，管道 inode 和共享数据页面将同时被释放。
命名管道
Linux 还支持命名管道（named pipe），即 FIFO 管道，为两个不相关的进程提供通信手动。命名管道不是临时对象，它们是文件系统中的实体并且可以通过 mknod 命令来创建。进程只要拥有适当的权限就可以自由使用 FIFO 管道。在写者进程使用之前，Linux 必须让读者进程先打开此 FIFO 管道；任何读者进程从中读取之前必须有写者进程向其写入数据。
消息队列
Linux 系统也支持 System V 的进程间通信机制，包括消息序列、信号量和共享内存。所有的 IPC 对象在 Linux 中有一个公共的 ipc_perm 结构，它含有进程拥有者、创建者和组标志符，对此对象（拥有者，组及其他）的存取模式以及 IPC 对象键。
消息是按一定格式封装起来的消息。每个进程都有一个与之关联的消息队列，接收进程按时间顺序或消息类型从消息队列取走消息。如果进程向一个满队列发送消息或从一个空队列取走消息都会被阻塞。
Linux 系统维护着一个 msgque 消息队列链表，其中每个元素指向一个描述消息队列 msqid_ds 结构，该结构完整地描述一个消息队列。每个 msqid_ds 结构包含一个 ipc_perm 结构和指向已经进入此队列消息的指针。另外，Linux 保留有关队列修改时间信息，如上次系统向队列中写入的时间等。msqid_ds 包含两个等待队列：一个为队列写入进程使用而另一个由队列读取进程使用。
每次进程试图向写入队列写入消息时，系统将把其有效用户和组标志符与此队列的 ipc_perm 结构中的模式进行比较。如果允许写入操作，则把此消息从该进程的地址空间复制到 msg 数据结构中，并放置到此消息队列尾部。如果消息队列的长度已满，则该写入进程将被阻塞，并调度新进程运行。若有消息被取走时，该进程将被唤醒。读进程执行时将选择队列中第一个消息或者某特定类型的消息。如果没有消息可以满足此要求，读进程将被阻塞，并运行调度程序。当有新消息写入队列时，进程将被唤醒。
信号量
信号量是用一个整数表示系统当前资源的使用情况，当信号量大于或等于 0 时，其值表示可用资源的数量，当它小于 0 时，其值表示等待该资源的进程数。信号量是 wait 和 signal 原语的推广，可以通过它实现进程的同步与互斥。例如用信号量实现临界区（critical region）的互斥，即在某一时刻在此区域内的代码只能被一个进程执行。
数据结构
信号量在 Linux 中使用以下几个数据结构来表示：
sem：表示系统中的每个信号量
semid_ds：表示信号量的集合
sem_queue：表示由每个信号量集合所构成的队列
semid_ds 结构的 sem_base 指向一个 sem 数组，进程可以使用系统调用来操作这些信号量数组。
实现过程
在执行信号量操作时，Linux 首先将检查是否所有操作已经成功。如果操作值与信号量当前数组相加大于 0，或者操作值与信号量当前值都是 0，操作将会成功。如果所有信号量操作失败，Linux 仅仅会把那些操作标志没有要求系统调用为非阻塞类型的进程挂起。进程挂起后，Linux 必须保存信号量操作的执行状态并将当前进程放入等待队列。系统还堆栈上建立 sem_queue 结构并填充各个域。 这个 sem_queue 结构将被放到信号量对象等待队列的尾部。系统把当前进程置入 sem_queue 结构中的等待队列中，然后执行调度程序。
如果所有这些信号量操作都成功则无须挂起当前进程，Linux 将对信号量数组中的其他成员进行相同操作，然后检查那些处于等待或挂起状态的进程。首先，Linux 将依次检查挂起队列（sem_pending）中的每个成员，看信号量操作能否继续。如果可以则将其 sem_queue 结构从挂起链表中删除并对信号量数组发出信号灯操作。Linux 还将唤醒处于睡眠状态的进程并使之成为下一个运行的进程。如果在对挂起队列的遍历过程中有的信号量操作不能完成则 Linux 将一直重复此过程，直到所有信号量操作完成且没有进程需要继续睡眠。
与信号量有关的系统调用
semget()：创建新的信号量集合或存取一个已有的信号量集合。
semop()： 当操作数和信号量的值相加大于或等于 0 时，即进程请求的资源能够满足，操作成功，返回 0；若相加后其中某个值小于 0，资源不能满足，将进程阻塞，操作不成功。
semctl()：在信号量集合上完成指定的命令操作。
死锁
死锁是信号量使用过程中可能产生的一个最严重的问题。当一个进程进入临界区时它修改了信号量的值，然后在离开临界区时由于运行失败或者被 kill 而没有改回信号量时，死锁将会发生。
Linux 为了避免死锁的发生，为每个进程维护至少一个对应于信号量数组的 sem_undo 结构，它保存了完成信号量操作之前的状态。当对信号量进行操作时，信号量变化的数值被放入进程的 sem_undo 结构的该信号的入口中。当进程被删除时，Linux 将遍历该进程的 sem_undo 集合对信号量数组使用调整值。如果信号量集合被删除而 sem_undo 数据结构还在进程的 task_struct 结构中，则此信号灯数组标志符将被置为无效。此时信号量清除代码只需丢弃 sem_undo 即可。
共享存储区
共享存储区是指被多个进程共享的虚存中的一个数据块，进程利用它来实现通信。此虚拟内存的页面出现在每个共享进程页表中，但位置可以不同。每个进程有相应的读或读写权限，对共享存储区的互斥访问必须依赖于其他机制，如信号量。
每个新创建的共享存储区由一个 shmid_ds 数据结构来表示，它描述共享存储区的大小，进程如何使用以及共享存储区映射到各自地址空间的方式。由共享存储区创建者控制对此内存的存取权限。
每个使用此共享内存的进程必须它能通过系统调用将其连接到虚拟内存上，但在连接时并没有创建共享存储区，只有进程访问它时才创建。当进程首次访问共享虚拟内存中的页面时将产生缺页中断。当取回此页面后，Linux 找到了描述此页面的数据结构。它包含指向使用此种类型虚拟内存的处理函数地址指针。当发生共享内存页面缺页错误时，错误处理代码将在此 shmid_ds 对应的页表入口链表中寻找此页面是否在内存。如果不在，则为其分配物理页面并创建页表入口。同时还将它放入当前进程的页表中，此入口被保存在 shmid_ds 结构中。下个访问此内存的进程就会连接到此页面上。这样，第一个访问虚拟内存页面的进程创建这块内存，随后的进程把此页面加入到各自的虚拟地址空间中。
不再使用共享存储区的进程将断开与之的连接，其对应的页面结构将从 shmid_ds 结构中删除并回收。当前进程对应此共享内存地址的页表入口也将被更新并置为无效。当最后一个进程断开与共享内存的连接时，当前位于物理内存中的共享内存页面将被释放，同时删除 shmid_ds 结构。

`id`	the `ID` denotes a connection name.
`uuid`	the `ID` denotes a connection UUID.
`path`	the `ID` denotes a D-Bus static connection path in the format of /org/freedesktop/NetworkManager/Settings/`num` or just `num`.
`apath`	the `ID` denotes a D-Bus active connection path in the format of /org/freedesktop/NetworkManager/ActiveConnection/`num` or just `num`.