Offends/Kubernetes
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

synchronization

Browse Source
This commit is contained in:
offends
2025-08-25 17:53:08 +08:00
commit c201eb5ef9
318 changed files with 23092 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

128
部署文档/KubeSphere/基于KubeKey快速部署单机Kubernetes.md Normal file
View File

@@ -0,0 +1,128 @@
> 本文作者：丁辉
# 基于KubeKey快速部署单机Kubernetes
| 节点名称 | IP | Kubernetes角色 |
| :----------------------: | :----------: | :-----------------------: |
| k8s-master-0,KubeKey管理 | 192.168.1.10 | control-plane,etcd,worker |
## 基础准备
[官方主页](https://kubesphere.io/zh/)
1. 更改主机名
```bash
hostnamectl set-hostname k8s-master-0 && bash
```
2. 编辑 /etc/hosts 文件
```bash
echo "192.168.1.10 k8s-master-0" >> /etc/hosts
```
3. 安装依赖
- Centos
```bash
yum install conntrack-tools socat -y
```
- Ubuntu
```bash
apt install conntrack socat -y
```
## 开始安装 KubeKey
[KubeKey-Github-Releases](https://github.com/kubesphere/kubekey/releases)
1. 下载最新版 KubeKey
> 配置国内加速
>
> ```bash
> export KKZONE=cn
> ```
```bash
curl -sfL https://get-kk.kubesphere.io | sh -
```
> 指定版本
>
> ```bash
> curl -sfL https://get-kk.kubesphere.io | VERSION=v3.0.13 sh -
> ```
2. 为 `kk` 添加可执行权限
```bash
chmod +x kk && mv kk /usr/local/bin/
```
## 开始安装 Kubernetes
**执行命令**
```bash
kk create cluster -y
```
> 默认 Kubernetes 版本为 v1.23.10
>
> 容器运行时为 Docker
### 指定版本
- 安装 Kubernetes
```bash
--with-kubernetes v1.22.12
```
> 查看 KubeKey 支持的 Kubernetes 版本列表
>
> ```bash
> kk version --show-supported-k8s
> ```
- 安装 Kubesphere
[Kubesphere-Github-Releases](https://github.com/kubesphere/kubesphere/releases)
```bash
--with-kubesphere v3.4.1
```
### 命令参数
| 标志 | 说明 |
| :-------------------------: | :----------------------------------------------------------: |
| -a, --artifact | 指定 KubeKey artifact（工件）的路径。artifact 是一个包含了所需二进制文件和其他资源的 tarball 文件，用于在离线环境中部署 Kubernetes。 |
| --container-manager | 指定容器运行时：docker、crio、containerd 或 isula。默认为 "docker"。 |
| --debug | 打印详细信息。 |
| --download-cmd string | 用户定义的下载所需二进制文件的命令。第一个参数 '%s' 是输出路径，第二个参数 '%s' 是 URL。默认为 "curl -L -o %s %s"。 |
| -f, --filename | 指定配置文件的路径。 |
| --ignore-err | 忽略错误信息，删除报告错误的主机，并强制继续执行。 |
| --namespace | 指定 KubeKey 使用的命名空间。默认为 "kubekey-system"。 |
| --skip-pull-images | 跳过预拉取镜像。 |
| --skip-push-images | 跳过预推送镜像。 |
| --with-kubernetes | 指定支持的 Kubernetes 版本。 |
| --with-kubesphere | 部署指定版本的 KubeSphere。默认为 v3.4.1。 |
| --with-local-storage | 部署本地 PV provisioner（本地存储）。 |
| --with-packages | 通过 artifact 安装操作系统软件包。 |
| --with-security-enhancement | 安全增强。 |
| -y, --yes | 跳过确认检查。 |
## 卸载集群
```bash
kk delete cluster
```

225
部署文档/KubeSphere/基于KubeKey部署高可用Kubernetes集群.md Normal file
View File

@@ -0,0 +1,225 @@
> 本文作者：丁辉
# 基于KubeKey部署Kubernetes
| 节点名称 | IP | Kubernetes角色 |
| :----------------------: | :----------: | :-----------------------: |
| k8s-master-1,KubeKey管理 | 192.168.1.10 | control-plane,etcd,worker |
| k8s-master-2 | 192.168.1.20 | control-plane,etcd,worker |
| k8s-master-3 | 192.168.1.30 | control-plane,etcd,worker |
## 基础准备
[官方主页](https://kubesphere.io/zh/)
### 所有节点执行
1. 创建用户
```bash
useradd -m -s /bin/bash kubekey
```
2. 配置用户密码
> 根据自己的密码修改 "123456"
```bash
echo "kubekey:123456" | chpasswd
```
3. 配置 kubekey 免密使用 sudo 权限
```bash
cat <<EOF | sudo tee /etc/sudoers.d/kubekey
# User rules for kubekey
kubekey ALL=(ALL) NOPASSWD: ALL
EOF
```
4. 更改主机名
- 192.168.1.10
```bash
hostnamectl set-hostname k8s-master-1 && bash
```
- 192.168.1.20
```bash
hostnamectl set-hostname k8s-master-2 && bash
```
- 192.168.1.30
```bash
hostnamectl set-hostname k8s-master-3 && bash
```
5. 编辑 /etc/hosts 文件
```bash
vi /etc/hosts
```
添加如下内容
```bash
192.168.1.10 k8s-master-1
192.168.1.20 k8s-master-2
192.168.1.30 k8s-master-3
```
6. 安装依赖
- Centos
```bash
yum install conntrack-tools socat -y
```
- Ubuntu
```bash
apt install conntrack socat -y
```
### KubeKey管理节点执行
1. 切换用户
```bash
su - kubekey
```
2. 创建密钥
```bash
sudo ssh-keygen -t rsa -N "" -f /root/.ssh/id_rsa -q
```
3. 配置免密登录
```bash
sudo ssh-copy-id kubekey@192.168.1.10
sudo ssh-copy-id kubekey@192.168.1.20
sudo ssh-copy-id kubekey@192.168.1.30
```
## 开始安装 KubeKey
[KubeKey-Github-Releases](https://github.com/kubesphere/kubekey/releases)
### KubeKey管理节点执行
1. 下载最新版 KubeKey
> 配置国内加速
>
> ```bash
> export KKZONE=cn
> ```
```bash
curl -sfL https://get-kk.kubesphere.io | sh -
```
> 指定版本
>
> ```bash
> curl -sfL https://get-kk.kubesphere.io | VERSION=v3.0.13 sh -
> ```
2. 为 `kk` 添加可执行权限
```bash
sudo chmod +x kk
sudo mv kk /usr/local/bin/
```
3. 生成配置文件
```bash
kk create config -f kubesphere.yaml
```
> 安装 Kubesphere 指定参数
>
> [Kubesphere-Github-Releases](https://github.com/kubesphere/kubesphere/releases)
>
> ```bash
> --with-kubesphere v3.4.1
> ```
修改如下内容
```yaml
apiVersion: kubekey.kubesphere.io/v1alpha2
kind: Cluster
metadata:
name: sample
spec:
hosts:
- {name: k8s-master-1, address: 192.168.100.10, internalAddress: 192.168.100.10, user: kubekey, password: "123456"}
- {name: k8s-master-2, address: 192.168.100.20, internalAddress: 192.168.100.20, user: kubekey, password: "123456"}
- {name: k8s-master-3, address: 192.168.100.30, internalAddress: 192.168.100.30, user: kubekey, password: "123456"}
roleGroups:
etcd:
- k8s-master-1
- k8s-master-2
- k8s-master-3
control-plane:
- k8s-master-1
- k8s-master-2
- k8s-master-3
worker:
- k8s-master-1
- k8s-master-2
- k8s-master-3
controlPlaneEndpoint:
# 启用内置的 HAProxy 负载均衡器
internalLoadbalancer: haproxy
domain: lb.kubesphere.local
address: ""
port: 6443
kubernetes:
# 指定 Kubernetes 版本, 可使用 kk version --show-supported-k8s 命令查询当前 KubeKey 支持的版本
version: v1.23.10
clusterName: cluster.local
autoRenewCerts: true
# 指定容器运行时
containerManager: docker
etcd:
type: kubekey
network:
plugin: calico
kubePodsCIDR: 10.233.64.0/18
kubeServiceCIDR: 10.233.0.0/18
multusCNI:
enabled: false
registry:
privateRegistry: ""
namespaceOverride: ""
registryMirrors: []
insecureRegistries: []
addons: []
```
## 开始安装 Kubernetes
```bash
kk create cluster -f kubesphere.yaml -y
```
扩容节点
```bash
kk add nodes -f kubesphere.yaml -y
```
## 卸载集群
```bash
kk delete cluster -f kubesphere.yaml
```

26
部署文档/KubeSphere/基于KubeSphereLuban快速部署单机Kubernetes.md Normal file
View File

@@ -0,0 +1,26 @@
> 本文作者：丁辉
# 基于KubeSphereLuban搭建开发环境
[官方文档](https://dev-guide.kubesphere.io/extension-dev-guide/zh/quickstart/prepare-development-environment/)
1. 准备 Kubernetes 集群
```bash
curl -sfL https://get-kk.kubesphere.io | sh -
./kk create cluster --with-local-storage --with-kubernetes v1.25.4 --container-manager containerd -y
```
2. 准备 Helm 工具
```bash
curl https://raw.githubusercontent.com/helm/helm/main/scripts/get-helm-3 | bash
```
3. 安装 KubeSphere Luban Helm Chart
```bash
helm upgrade --install -n kubesphere-system --create-namespace ks-core https://charts.kubesphere.io/main/ks-core-0.4.0.tgz --set apiserver.nodePort=30881 --debug --wait
```
> 更多配置参数，请参考[KubeSphere Helm Chart 配置](https://docs.kubesphere.com.cn/v4.0/03-install-and-uninstall/01-install-ks-core/#_高级配置)

36
部署文档/Kubeadm/Kubeadm初始化安装Kubernetes节点.md Normal file
View File

@@ -0,0 +1,36 @@
> 本文作者：丁辉
## Kubeadm初始化安装Kubernetes节点
1. Kubernetes安装
```bash
kubeadm init \
--image-repository=registry.aliyuncs.com/google_containers \
--apiserver-advertise-address=192.168.1.10 \
--pod-network-cidr=10.244.0.0/16 \
--service-cidr=10.96.0.0/12
```
2. 根据提示配置文件
```bash
mkdir -p $HOME/.kube
sudo cp -i /etc/kubernetes/admin.conf $HOME/.kube/config
sudo chown $(id -u):$(id -g) $HOME/.kube/config
export KUBECONFIG=/etc/kubernetes/admin.conf
```
> 永久生效
>
> ```bash
> echo "export KUBECONFIG=/etc/kubernetes/admin.conf" >> ~/.bash_profile
> source ~/.bash_profile
> ```
3. 安装网络插件
请跳转此文档
- [Flannel网络插件安装](https://gitee.com/offends/Kubernetes/blob/main/部署文档/网络插件安装/Flannel网络插件安装.md)
- [Calico网络插件安装](https://gitee.com/offends/Kubernetes/blob/main/部署文档/网络插件安装/Calico网络插件安装.md)

15
部署文档/Kubeadm/Kubeadm基础常用命令.md Normal file
View File

@@ -0,0 +1,15 @@
> 本文作者：丁辉
# Kubeadm基础常用命令
- 打印出 `kubeadm` 工具初始化 Kubernetes 集群时的默认配置
```bash
kubeadm config print init-defaults > kubeadm.yaml
```
- 列出所有容器镜像
```bash
kubeadm config images list --config kubeadm.yaml
```

41
部署文档/Kubeadm/Kubeadm部署单机Kubernetes(Containerd).md Normal file
View File

@@ -0,0 +1,41 @@
> 本文作者：丁辉
# Kubeadm部署单机Kubernetes(Containerd)
| 节点名 | IP |
| :----: | :----------: |
| master | 192.168.1.10 |
## 环境准备
> !!!每次部署都写挺麻烦的索性都放在一个文件内了请查看 [Kubernetes基础环境准备](https://gitee.com/offends/Kubernetes/blob/main/部署文档/Kubernetes基础环境准备.md) ,请按照此文档初始化环境
1. 配置主机名
```bash
hostnamectl set-hostname master && bash
```
2. 配置主机 hosts
```bash
vi /etc/hosts
```
添加如下内容
```bash
192.168.1.10 master
```
## 安装Containerd
请跳转此文档 [网络源安装Containerd](https://gitee.com/offends/Kubernetes/blob/main/Containerd/Docs/%E7%BD%91%E7%BB%9C%E6%BA%90%E5%AE%89%E8%A3%85Containerd.md)
## 安装Kubeadm
请跳转此文档 [安装Kubeadm](https://gitee.com/offends/Kubernetes/blob/main/%E9%83%A8%E7%BD%B2%E6%96%87%E6%A1%A3/Kubeadm/%E5%AE%89%E8%A3%85Kubeadm.md)
## 安装 Kubernetes
请跳转此文档 [Kubeadm初始化安装Kubernetes节点](https://gitee.com/offends/Kubernetes/tree/main/%E9%83%A8%E7%BD%B2%E6%96%87%E6%A1%A3/Kubeadm/Kubeadm%E5%88%9D%E5%A7%8B%E5%8C%96%E5%AE%89%E8%A3%85Kubernetes%E8%8A%82%E7%82%B9.md)

142
部署文档/Kubeadm/Kubeadm部署单机Kubernetes(Docker).md Normal file
View File

@@ -0,0 +1,142 @@
> 本文作者：丁辉
# Kubeadm部署单机Kubernetes(Docker)
> Kubernetes v1.24 以后需要额外安装 cri-dockerd , Kubernetes 就正常识别到 Docker
>
| 节点名 | IP |
| :----: | :----------: |
| master | 192.168.1.10 |
## 环境准备
> !!!每次部署都写挺麻烦的索性都放在一个文件内了请查看 [Kubernetes基础环境准备](https://gitee.com/offends/Kubernetes/blob/main/部署文档/Kubernetes基础环境准备.md) ,请按照此文档初始化环境
1. 配置主机名
```bash
hostnamectl set-hostname master && bash
```
2. 配置主机 hosts
```bash
vi /etc/hosts
```
添加如下内容
```bash
192.168.1.10 master
```
## 安装Docker
请跳转此文档 [Docker网络安装](https://gitee.com/offends/Kubernetes/blob/main/Docker/Docs/Centos%E5%AE%89%E8%A3%85Docker.md)
## 安装Cri-dockerd
[Github软件包下载](https://github.com/Mirantis/cri-dockerd/releases)
1. 下载
```bash
wget https://github.com/Mirantis/cri-dockerd/releases/download/v0.3.8/cri-dockerd-0.3.8-3.el7.x86_64.rpm
```
2. 安装
```bash
rpm -ivh *.rpm --force --nodeps
```
3. 配置国内源
```bash
vi /usr/lib/systemd/system/cri-docker.service
```
修改
```bash
ExecStart=/usr/bin/cri-dockerd --network-plugin=cni --pod-infra-container-image=registry.aliyuncs.com/google_containers/pause:3.9
```
4. 启动
```bash
systemctl daemon-reload
systemctl enable cri-docker.socket cri-docker
systemctl start cri-docker.socket cri-docker
systemctl status cri-docker.socket
systemctl status cri-docker
```
## 安装Runc
[Github软件包下载](https://github.com/opencontainers/runc/releases)
1. 下载
```bash
wget https://github.com/opencontainers/runc/releases/download/v1.1.10/runc.amd64
```
2. 安装
```bash
install -m 755 runc.amd64 /usr/local/bin/runc
```
## 安装Kubeadm
请跳转此文档 [安装Kubeadm](https://gitee.com/offends/Kubernetes/blob/main/部署文档/Kubeadm/安装Kubeadm.md)
## 安装Kubernetes
1. Kubernetes 安装
```bash
kubeadm init \
--node-name=master \
--image-repository=registry.aliyuncs.com/google_containers \
--cri-socket=unix:///var/run/cri-dockerd.sock \
--apiserver-advertise-address=192.168.1.10 \
--pod-network-cidr=10.244.0.0/16 \
--service-cidr=10.96.0.0/12
```
**参数解释**
| 参数 | 说明 |
| :------------------------------: | :----------------------------------------------------------: |
| `--node-name=master` | 指定节点的名称为“master”。 |
| `--image-repository=` | 指定容器镜像仓库地址，此处指定了镜像仓库为registry.aliyuncs.com/google_containers。 |
| `--cri-socket=` | 指定容器运行时接口（CRI）的Unix套接字文件路径，用于与容器运行时通信。此处设置为`unix:///var/run/cri-dockerd.sock`，与CRI-Dockerd通信。 |
| `--apiserver-advertise-address=` | 指定API服务器公告地址，即API服务器将会公布的地址。在此设置为`192.168.1.10`。 |
| `--pod-network-cidr=` | 指定Pod网络的CIDR地址段。这个CIDR地址段用于分配给Pod。在此设置为`10.244.0.0/16`。 |
| `--service-cidr=` | 指定Service的CIDR地址段。这个CIDR地址段用于分配给Service。在此设置为`10.96.0.0/12`。 |
2. 根据提示配置文件
```bash
mkdir -p $HOME/.kube
sudo cp -i /etc/kubernetes/admin.conf $HOME/.kube/config
sudo chown $(id -u):$(id -g) $HOME/.kube/config
export KUBECONFIG=/etc/kubernetes/admin.conf
```
> 永久生效
>
> ```bash
> echo "export KUBECONFIG=/etc/kubernetes/admin.conf" >> ~/.bash_profile
> source ~/.bash_profile
> ```
## 安装网络插件
请跳转此文档
- [Flannel网络插件安装](https://gitee.com/offends/Kubernetes/blob/main/部署文档/网络插件安装/Flannel网络插件安装.md)
- [Calico网络插件安装](https://gitee.com/offends/Kubernetes/blob/main/部署文档/网络插件安装/Calico网络插件安装.md)

188
部署文档/Kubeadm/安装Kubeadm.md Normal file
View File

@@ -0,0 +1,188 @@
> 本文作者：丁辉
# 安装Kubeadm
[阿里源配置文件](https://developer.aliyun.com/mirror/kubernetes)
[官方安装文档](https://kubernetes.io/docs/setup/production-environment/tools/kubeadm/install-kubeadm/#installing-kubeadm-kubelet-and-kubectl)
## YUM安装
1. 添加网络源
- 官方源
```bash
cat <<EOF | sudo tee /etc/yum.repos.d/kubernetes.repo
[kubernetes]
name=Kubernetes
baseurl=https://pkgs.k8s.io/core:/stable:/v1.30/rpm/
enabled=1
gpgcheck=1
gpgkey=https://pkgs.k8s.io/core:/stable:/v1.30/rpm/repodata/repomd.xml.key
exclude=kubelet kubeadm kubectl cri-tools kubernetes-cni
EOF
```
- 阿里源
- 新版
```bash
cat <<EOF | tee /etc/yum.repos.d/kubernetes.repo
[kubernetes]
name=Kubernetes
baseurl=https://mirrors.aliyun.com/kubernetes-new/core/stable/v1.28/rpm/
enabled=1
gpgcheck=1
gpgkey=https://mirrors.aliyun.com/kubernetes-new/core/stable/v1.28/rpm/repodata/repomd.xml.key
EOF
```
- 旧版
```bash
cat <<EOF > /etc/yum.repos.d/kubernetes.repo
[kubernetes]
name=Kubernetes
baseurl=https://mirrors.aliyun.com/kubernetes/yum/repos/kubernetes-el7-x86_64/
enabled=1
gpgcheck=1
repo_gpgcheck=1
gpgkey=https://mirrors.aliyun.com/kubernetes/yum/doc/yum-key.gpg https://mirrors.aliyun.com/kubernetes/yum/doc/rpm-package-key.gpg
EOF
```
2. 安装
- 官方源
```bash
yum install -y kubelet kubeadm kubectl --disableexcludes=kubernetes
```
- 阿里源
> 由于官网未开放同步方式, 可能会有索引gpg检查失败的情况, 这时请用 `yum install -y --nogpgcheck kubelet kubeadm kubectl` 安装
```bash
yum install -y --nogpgcheck kubelet kubeadm kubectl
```
3. 启动
```bash
systemctl enable --now kubelet
```
## APT安装
- 官方源
1. 更新`apt`软件包索引并安装使用 Kubernetes`apt`存储库所需的软件包
```bash
sudo apt-get update
sudo apt-get install -y apt-transport-https ca-certificates curl gpg
```
2. 下载 Kubernetes 软件包存储库的公共签名密钥。所有存储库都使用相同的签名密钥，因此您可以忽略 URL 中的版本
```bash
curl -fsSL https://pkgs.k8s.io/core:/stable:/v1.30/deb/Release.key | sudo gpg --dearmor -o /etc/apt/keyrings/kubernetes-apt-keyring.gpg
```
3. 添加适当的 Kubernetes`apt`存储库。请注意，此存储库仅包含适用于 Kubernetes 1.30 的软件包；对于其他 Kubernetes 次要版本，您需要更改 URL 中的 Kubernetes 次要版本以匹配所需的次要版本（您还应该检查您正在阅读的文档是否适用于您计划安装的 Kubernetes 版本）。
```bash
echo 'deb [signed-by=/etc/apt/keyrings/kubernetes-apt-keyring.gpg] https://pkgs.k8s.io/core:/stable:/v1.30/deb/ /' | sudo tee /etc/apt/sources.list.d/kubernetes.list
```
4. 更新`apt`软件包索引，安装 kubelet、kubeadm 和 kubectl，并固定其版本
```bash
sudo apt-get update
sudo apt-get install -y kubelet kubeadm kubectl
sudo apt-mark hold kubelet kubeadm kubectl
```
5. 运行 kubeadm 之前启用 kubelet 服务
```bash
systemctl enable --now kubelet
```
- 阿里源
- 新版
1. 更新`apt`软件包索引并安装使用 Kubernetes`apt`存储库所需的软件包
```bash
apt-get update && apt-get install -y apt-transport-https
```
2. 下载 Kubernetes 软件包存储库的公共签名密钥。
```bash
curl -fsSL https://mirrors.aliyun.com/kubernetes-new/core/stable/v1.28/deb/Release.key |
gpg --dearmor -o /etc/apt/keyrings/kubernetes-apt-keyring.gpg
```
3. 添加适当的 Kubernetes`apt`存储库。
```bash
echo "deb [signed-by=/etc/apt/keyrings/kubernetes-apt-keyring.gpg] https://mirrors.aliyun.com/kubernetes-new/core/stable/v1.28/deb/ /" |
tee /etc/apt/sources.list.d/kubernetes.list
```
4. 更新`apt`软件包索引，安装 kubelet、kubeadm 和 kubectl，并固定其版本
```bash
apt-get update
apt-get install -y kubelet kubeadm kubectl
```
5. 运行 kubeadm 之前启用 kubelet 服务
```bash
systemctl enable --now kubelet
```
- 旧版
1. 更新`apt`软件包索引并安装使用 Kubernetes`apt`存储库所需的软件包
```bash
apt-get update && apt-get install -y apt-transport-https
```
2. 下载 Kubernetes 软件包存储库的公共签名密钥。
```bash
curl https://mirrors.aliyun.com/kubernetes/apt/doc/apt-key.gpg | apt-key add -
```
3. 添加适当的 Kubernetes`apt`存储库。
```bash
cat <<EOF >/etc/apt/sources.list.d/kubernetes.list
deb https://mirrors.aliyun.com/kubernetes/apt/ kubernetes-xenial main
EOF
```
4. 更新`apt`软件包索引，安装 kubelet、kubeadm 和 kubectl，并固定其版本
```bash
apt-get update
apt-get install -y kubelet kubeadm kubectl
```
5. 运行 kubeadm 之前启用 kubelet 服务
```bash
systemctl enable --now kubelet
```

138
部署文档/Kubeadm/旧版Kubeadm部署单机Kubernetes-v1.23(Docker).md Normal file
View File

@@ -0,0 +1,138 @@
> 本文作者：丁辉
# 旧版Kubeadm部署单机Kubernetes-v1.23(Docker)
[Github-v1.23版本情况](https://github.com/kubernetes/kubernetes/blob/master/CHANGELOG/CHANGELOG-1.23.md)
> 指定 v1.23 版本安装
>
| 节点名 | IP |
| :----: | :----------: |
| master | 192.168.1.10 |
## 环境准备
> !!!每次部署都写挺麻烦的索性都放在一个文件内了请查看 [Kubernetes基础环境准备](https://gitee.com/offends/Kubernetes/blob/main/部署文档/Kubernetes基础环境准备.md) ,请按照此文档初始化环境
1. 配置主机名
```bash
hostnamectl set-hostname master && bash
```
2. 配置主机 hosts
```bash
vi /etc/hosts
```
添加如下内容
```bash
192.168.1.10 master
```
## 安装 Docker
- 设置存储库
[阿里源配置文件](https://developer.aliyun.com/mirror/docker-ce?spm=a2c6h.13651102.0.0.4eac1b11shXBpr)
```bash
yum install -y yum-utils
yum-config-manager --add-repo https://mirrors.aliyun.com/docker-ce/linux/centos/docker-ce.repo
```
- 安装(特定版本)
```bash
yum install docker-ce-20.10.24-3.el7 docker-ce-cli-20.10.24-3.el7 -y
```
- 编辑配置文件
```bash
vi /etc/docker/daemon.json
```
```bash
{
"exec-opts": ["native.cgroupdriver=systemd"]
}
```
- 启动
```bash
systemctl start docker
systemctl enable docker
systemctl status docker
```
## 安装Kubeadm
[阿里源配置文件](https://developer.aliyun.com/mirror/kubernetes?spm=a2c6h.13651102.0.0.4eac1b11shXBpr)
- 添加网络源
```bash
cat <<EOF > /etc/yum.repos.d/kubernetes.repo
[kubernetes]
name=Kubernetes
baseurl=https://mirrors.aliyun.com/kubernetes/yum/repos/kubernetes-el7-x86_64/
enabled=1
gpgcheck=1
repo_gpgcheck=1
gpgkey=https://mirrors.aliyun.com/kubernetes/yum/doc/yum-key.gpg https://mirrors.aliyun.com/kubernetes/yum/doc/rpm-package-key.gpg
EOF
```
- 安装(特定版本)
```bash
yum install kubelet-1.23.17 kubeadm-1.23.17 kubectl-1.23.17 -y
```
- 启动
```bash
systemctl enable --now kubelet
```
## 安装Kubernetes
- master 安装
```bash
kubeadm init \
--kubernetes-version=v1.23.17 \
--pod-network-cidr=10.244.0.0/16 \
--service-cidr=10.96.0.0/12 \
--apiserver-advertise-address=192.168.1.10 --image-repository=registry.aliyuncs.com/google_containers
```
**参数**
- 根据提示配置文件
```bash
mkdir -p $HOME/.kube
sudo cp -i /etc/kubernetes/admin.conf $HOME/.kube/config
sudo chown $(id -u):$(id -g) $HOME/.kube/config
export KUBECONFIG=/etc/kubernetes/admin.conf
```
> 永久生效
>
> ```bash
> echo "export KUBECONFIG=/etc/kubernetes/admin.conf" >> ~/.bash_profile
> source ~/.bash_profile
> ```
## 安装网络插件
请跳转此文档
- [Flannel网络插件安装](https://gitee.com/offends/Kubernetes/blob/main/部署文档/网络插件安装/Flannel网络插件安装.md)
- [Calico网络插件安装](https://gitee.com/offends/Kubernetes/blob/main/部署文档/网络插件安装/Calico网络插件安装.md)

268
部署文档/Kubeasz/Kubeasz部署Kubernetes集群.md Normal file
View File

@@ -0,0 +1,268 @@
> 本文作者：丁辉
# Kubeasz部署Kubernetes集群
[Github官方文档](https://github.com/easzlab/kubeasz)
[Github安装文档](https://github.com/easzlab/kubeasz/blob/master/docs/setup/quickStart.md)
| 节点名称 | IP | Kubernetes角色 |
| :----------------------: | :----------: | :--------------: |
| k8s-master-1,Kubeasz管理 | 192.168.1.10 | master,etcd,node |
| k8s-master-2 | 192.168.1.20 | master,etcd,node |
| k8s-master-3 | 192.168.1.30 | master,etcd,node |
## 环境准备
1. 配置免密
```bash
ssh-keygen -t rsa -N "" -f ~/.ssh/id_rsa -q
```
2. 配置免密登录
```bash
ssh-copy-id root@192.168.1.10
ssh-copy-id root@192.168.1.20
ssh-copy-id root@192.168.1.30
```
3. 更改主机名
- 192.168.1.10
```bash
hostnamectl set-hostname k8s-master-1 && bash
```
- 192.168.1.20
```bash
hostnamectl set-hostname k8s-master-2 && bash
```
- 192.168.1.30
```bash
hostnamectl set-hostname k8s-master-3 && bash
```
4. 编辑 /etc/hosts 文件
```bash
vi /etc/hosts
```
添加如下内容
```bash
192.168.1.10 k8s-master-1
192.168.1.20 k8s-master-2
192.168.1.30 k8s-master-3
```
## 开始部署 Kubeasz
[Github Releases](https://github.com/easzlab/kubeasz/releases)
1. 下载 ezdown
```bash
wget https://github.com/easzlab/kubeasz/releases/download/3.6.2/ezdown && chmod 777 ezdown
```
> 下载支持 Docker 的版本
>
> ```bash
> wget https://github.com/easzlab/kubeasz/releases/download/3.2.0/ezdown && chmod 777 ezdown
> ```
2. 下载kubeasz代码、二进制、默认容器镜像
- 国内环境
```bash
./ezdown -D
```
> 下载 flannel 镜像
>
> ```bash
> ./ezdown -X flannel
> ```
- 海外环境
```bash
./ezdown -D -m standard
```
> 下载 flannel 镜像
>
> ```bash
> ./ezdown -D -m standard -X flannel
> ```
3. 运行 Kubeasz
```bash
./ezdown -S
```
> 配置快捷命令
>
> ```bash
> echo "alias dk='docker exec -it kubeasz'" >> ~/.bashrc
> source ~/.bashrc
> ```
>
> 配置后执行 `dk` 即可
4. 创建新集群
```bash
dk ezctl new k8s-01
```
5. 编辑 hosts 文件
```bash
vi /etc/kubeasz/clusters/k8s-01/hosts
```
内容如下
```bash
# 'etcd' cluster should have odd member(s) (1,3,5,...)
[etcd]
192.168.1.10
192.168.1.20
192.168.1.30
# master node(s)
[kube_master]
192.168.1.10 k8s_nodename='k8s-master-1'
192.168.1.20 k8s_nodename='k8s-master-2'
192.168.1.30 k8s_nodename='k8s-master-3'
# work node(s)
[kube_node]
192.168.1.10 k8s_nodename='k8s-master-1'
192.168.1.20 k8s_nodename='k8s-master-2'
192.168.1.30 k8s_nodename='k8s-master-3'
# VIP
[ex_lb]
192.168.1.10 LB_ROLE=master EX_APISERVER_VIP=192.168.1.100 EX_APISERVER_PORT=8443
192.168.1.20 LB_ROLE=backup EX_APISERVER_VIP=192.168.1.100 EX_APISERVER_PORT=8443
192.168.1.30 LB_ROLE=backup EX_APISERVER_VIP=192.168.1.100 EX_APISERVER_PORT=8443
...#此处省略
# Cluster container-runtime supported: docker, containerd
CONTAINER_RUNTIME="containerd"
# Network plugins supported: calico, flannel, kube-router, cilium, kube-ovn
CLUSTER_NETWORK="flannel"
...#此处省略
```
6. 修改 config.yml 文件
```bash
vi /etc/kubeasz/clusters/k8s-01/config.yml
```
内容如下
```yml
############################
# role:kube-master
############################
# k8s 集群 master 节点证书配置，可以添加多个ip和域名（比如增加公网ip和域名）尽量预留一些IP使用
MASTER_CERT_HOSTS:
- "192.168.1.10"
- "192.168.1.20"
- "192.168.1.30"
- "192.168.1.100"
```
## 开始安装 Kubernetes
1. 安装
```bash
dk ezctl setup k8s-01 all
```
> 或一步一步安装
>
> ```bash
> # 初始化集群配置
> dk ezctl setup k8s-01 01
> # 安装 etcd
> dk ezctl setup k8s-01 02
> ...#此处省略
> ```
2. 加载新配置
```bash
source ~/.bashrc
```
3. 查看节点状态
```bash
kubectl get node
```
## 添加节点
[官方文档](https://github.com/easzlab/kubeasz/blob/master/docs/op/op-node.md)
- 添加 worker
```bash
dk ezctl add-node k8s-01 192.168.1.40 k8s_nodename='k8s-master-4'
```
> SSH 非 22 端口
>
> ```bash
> dk ezctl add-node k8s-01 192.168.1.40 k8s_nodename='k8s-master-4' ansible_ssh_port=10022
> ```
- 添加 master
```bash
dk ezctl add-master k8s-01 192.168.1.40 k8s_nodename='k8s-master-4'
```
- 添加 etcd
```bash
dk ezctl add-etcd k8s-01 192.168.1.40
```
### 删除节点
- 删除 worker
```bash
dk ezctl del-node k8s-01 192.168.1.40
```
- 删除 master
```bash
dk ezctl del-master k8s-01 192.168.1.40
```
- 删除 etcd
```bash
dk ezctl del-etcd k8s-01 192.168.1.40
```

55
部署文档/Kubectl工具安装/Kubectl安装Convert插件.md Normal file
View File

@@ -0,0 +1,55 @@
> 本文作者：丁辉
# Kubectl安装Convert插件
> 一个 Kubernetes 命令行工具 `kubectl` 的插件，允许你将清单在不同 API 版本间转换。 这对于将清单迁移到新的 Kubernetes 发行版上未被废弃的 API 版本时尤其有帮助。
[官方文档](https://kubernetes.io/zh-cn/docs/tasks/tools/install-kubectl-linux/#install-kubectl-convert-plugin)
## 安装Convert
- X86-64
```bash
curl -LO "https://dl.k8s.io/release/$(curl -L -s https://dl.k8s.io/release/stable.txt)/bin/linux/amd64/kubectl-convert"
```
- ARM64
```bash
curl -LO "https://dl.k8s.io/release/$(curl -L -s https://dl.k8s.io/release/stable.txt)/bin/linux/arm64/kubectl-convert"
```
## 验证该可执行文件(可选步骤)
- X86-64
```bash
curl -LO "https://dl.k8s.io/release/$(curl -L -s https://dl.k8s.io/release/stable.txt)/bin/linux/amd64/kubectl-convert.sha256"
```
- ARM64
```bash
curl -LO "https://dl.k8s.io/release/$(curl -L -s https://dl.k8s.io/release/stable.txt)/bin/linux/arm64/kubectl-convert.sha256"
```
**基于校验和文件，验证 kubectl 的可执行文件**
```bash
echo "$(cat kubectl-convert.sha256) kubectl-convert" | sha256sum --check
```
> 验证通过时，输出为 `kubectl: OK`
## 安装
```bash
install -o root -g root -m 0755 kubectl-convert /usr/local/bin/kubectl-convert
```
## 验证
```bash
kubectl convert --help
```

26
部署文档/Kubectl工具安装/Kubectl安装命令自动补全工具.md Normal file
View File

@@ -0,0 +1,26 @@
> 本文作者：丁辉
# Kubectl安装命令自动补全工具
[官方文档](https://kubernetes.io/zh-cn/docs/tasks/tools/install-kubectl-linux/#optional-kubectl-configurations)
## 安装 bash-completion
- Ubuntu
```bash
apt-get install bash-completion
```
- Centos
```bash
yum install bash-completion
```
## 启动 kubectl 自动补全功能
```bash
echo 'source <(kubectl completion bash)' >>~/.bashrc
source ~/.bashrc
```

74
部署文档/Kubectl工具安装/二进制文件安装Kubectl.md Normal file
View File

@@ -0,0 +1,74 @@
> 本文作者：丁辉
# 二进制文件安装Kubectl(推荐)
[官方文档](https://kubernetes.io/zh-cn/docs/tasks/tools/install-kubectl-linux/#install-kubectl-binary-with-curl-on-linux)
## 下载最新版Kubectl
- X86-64
```bash
curl -LO "https://dl.k8s.io/release/$(curl -L -s https://dl.k8s.io/release/stable.txt)/bin/linux/amd64/kubectl"
```
> 下载指定版本
>
> ```bash
> curl -LO https://dl.k8s.io/release/v1.29.2/bin/linux/amd64/kubectl
> ```
- ARM64
```bash
curl -LO "https://dl.k8s.io/release/$(curl -L -s https://dl.k8s.io/release/stable.txt)/bin/linux/arm64/kubectl"
```
> 下载指定版本
>
> ```bash
> curl -LO https://dl.k8s.io/release/v1.29.2/bin/linux/arm64/kubectl
> ```
## 验证该可执行文件(可选步骤)
- X86-64
```bash
curl -LO "https://dl.k8s.io/$(curl -L -s https://dl.k8s.io/release/stable.txt)/bin/linux/amd64/kubectl.sha256"
```
- ARM64
```bash
curl -LO "https://dl.k8s.io/$(curl -L -s https://dl.k8s.io/release/stable.txt)/bin/linux/arm64/kubectl.sha256"
```
**基于校验和文件，验证 kubectl 的可执行文件**
```bash
echo "$(cat kubectl.sha256) kubectl" | sha256sum --check
```
> 验证通过时，输出为 `kubectl: OK`
## 安装
```bash
install -o root -g root -m 0755 kubectl /usr/local/bin/kubectl
```
## 验证
- 查看版本
```bash
kubectl version --client
```
- 查看版本详细信息
```bash
kubectl version --client --output=yaml
```

82
部署文档/Kubectl工具安装/包管理工具安装Kubectl.md Normal file
View File

@@ -0,0 +1,82 @@
> 本文作者：丁辉
# 包管理工具安装Kubectl
[官方文档](https://kubernetes.io/zh-cn/docs/tasks/tools/install-kubectl-linux/#install-using-native-package-management)
## Centos安装
1. 添加 Kubernetes 的 `yum` 仓库
> 如果你想使用 v1.29 之外的 Kubernetes 版本， 将下面命令中的 v1.29 替换为所需的次要版本。
```bash
cat <<EOF | tee /etc/yum.repos.d/kubernetes.repo
[kubernetes]
name=Kubernetes
baseurl=https://pkgs.k8s.io/core:/stable:/v1.29/rpm/
enabled=1
gpgcheck=1
gpgkey=https://pkgs.k8s.io/core:/stable:/v1.29/rpm/repodata/repomd.xml.key
EOF
```
2. 更新仓库
```bash
yum update
```
3. 安装 kubectl
```bash
yum install -y kubectl
```
## Ubuntu安装
1. 创建目录
```bash
mkdir -p -m 755 /etc/apt/keyrings
```
2. 下载 Kubernetes 软件包仓库的公共签名密钥。 同一个签名密钥适用于所有仓库，因此你可以忽略 URL 中的版本信息。
```bash
curl -fsSL https://pkgs.k8s.io/core:/stable:/v1.29/deb/Release.key | sudo gpg --dearmor -o /etc/apt/keyrings/kubernetes-apt-keyring.gpg
```
3. 添加 Kubernetes 的 `apt` 仓库
> 如果你想用 v1.29 之外的 Kubernetes 版本， 请将下面命令中的 v1.29 替换为所需的次要版本。
```bash
echo 'deb [signed-by=/etc/apt/keyrings/kubernetes-apt-keyring.gpg] https://pkgs.k8s.io/core:/stable:/v1.29/deb/ /' | tee /etc/apt/sources.list.d/kubernetes.list
```
4. 更新 `apt` 包索引
```bash
apt-get update
```
5. 安装 kubectl
```bash
apt-get install -y kubectl
```
## 验证
- 查看版本
```bash
kubectl version --client
```
- 查看版本详细信息
```bash
kubectl version --client --output=yaml
```

199
部署文档/Kubernetes基础环境准备.md Normal file
View File

@@ -0,0 +1,199 @@
> 本文作者：丁辉
# Kubernetes基础环境准备
## 时间同步
1. 安装 ntpdate
```bash
yum -y install ntpdate
```
2. 配置时区并同步
```bash
ln -sf /usr/share/zoneinfo/Asia/Shanghai /etc/localtime
ntpdate -u ntp.aliyun.com && date
```
> 离线环境使用此篇文档同步
>
> [NTP时间同步](https://gitee.com/offends/Linux/blob/main/Docs/NTP%E6%97%B6%E9%97%B4%E5%90%8C%E6%AD%A5.md)
## Linux环境配置
1. 关闭防火墙
```bash
systemctl stop firewalld && systemctl disable firewalld
```
2. 禁用 selinux
```bash
sudo setenforce 0
sudo sed -i 's/^SELINUX=enforcing$/SELINUX=permissive/' /etc/selinux/config
```
3. 禁用 swap
```bash
swapoff -a
sed -i '/ swap / s/^\(.*\)$/#\1/g' /etc/fstab
```
**解释**
在 Kubernetes 集群部署过程中，禁用 Swap 和 SELinux 是出于一些安全和性能方面的考虑。
- 禁用 Swap：Swap（交换空间）是一种可以将内存中的数据暂时存储到硬盘上的机制。在 Kubernetes 中，默认情况下是禁用 Swap 的。禁用 Swap 可以避免因为将数据交换到磁盘导致的性能下降，同时也避免了节点上的内存使用不一致性问题。
- 禁用 SELinux：SELinux（Security-Enhanced Linux）是为了增强 Linux 系统的安全性而提供的一种安全子系统。尽管 SELinux 提供了强大的安全功能，但它更适合于传统的单机环境，而不是容器化环境。在 Kubernetes 中，禁用 SELinux 可以简化集群的配置和管理，并且减少可能由于权限配置不正确而导致的问题。
当然，禁用 Swap 和 SELinux 并不是绝对必需的，这取决于你的具体场景和需求。如果你有特定的安全需求或者对性能有较高的要求，禁用 Swap 和 SELinux 可能是一个好的选择。但在某些情况下，可能需要根据实际情况来进行配置和调整。
## 主机配置
| 主机名 | IP |
| :----: | :----------: |
| k8s-1 | 192.168.1.10 |
| k8s-2 | 192.168.1.20 |
| k8s-3 | 192.168.1.30 |
1. 配置主机名
- k8s-1
```bash
hostnamectl set-hostname k8s-1
```
- k8s-2
```bash
hostnamectl set-hostname k8s-2
```
- k8s-3
```bash
hostnamectl set-hostname k8s-3
```
2. 添加 hosts
```bash
vi /etc/hosts
```
添加内容如下
```bash
192.168.1.10 k8s-1
192.168.1.20 k8s-2
192.168.1.30 k8s-3
```
## 修改内核参数
1. 加载 br_netfilter 网络过滤器模块
```bash
cat <<EOF | sudo tee /etc/modules-load.d/k8s.conf
overlay
br_netfilter
EOF
```
加载
```bash
modprobe overlay
modprobe br_netfilter
```
2. 设置所需的 sysctl 参数
> 更多完整参数配置请查看 [参数配置](https://gitee.com/offends/Kubernetes/blob/main/File/Conf/k8s.conf)
```bash
cat <<EOF | sudo tee /etc/sysctl.d/k8s.conf
net.bridge.bridge-nf-call-ip6tables = 1
net.bridge.bridge-nf-call-iptables = 1
net.ipv4.ip_forward = 1
vm.swappiness = 0
EOF
```
加载
```bash
sysctl --system
```
## NetworkManager配置
Network Manager 是一个能够动态控制和配置网络的守护进程，NetworkManager 管理除 lo(环回)设备以外的所有设备。但是，在容器环境下很多网络设备是由网络驱动创建，NetworkManager 对容器网络设备的控制可能导致集群网络通信异常。因为需要将容器相关的设备设置为 unmanaged，以使 NetworkManager 忽略这些设备。
- 直接关闭 NetworkManager
```bash
systemctl stop NetworkManager && systemctl disable NetworkManager
```
- 临时 unmanaged
```bash
nmcli device set xxx managed no
```
- 永久 unmanaged
1. 启用插件
```bash
vi /etc/NetworkManager/NetworkManager.conf
```
添加如下内容
```bash
[main]
plugins=keyfile
```
2. 编写配置文件
```bash
cat <<EOF > /etc/NetworkManager/conf.d/99-unmanaged-devices.conf
[keyfile]
unmanaged-devices=interface-name:eth*,except:interface-name:eth0;interface-name:docker0;interface-name:flannel*;interface-name:cali*;interface-name:cni0;mac:66:77:88:99:00:aa
EOF
```
**参数解释**
- `interface-name:eth*`：表示匹配以"eth"开头的接口名称。
- `except:interface-name:eth0`：表示排除名为"eth0"的接口。
- `interface-name:docker0`：表示匹配名为"docker0"的接口。
- `interface-name:flannel*`：表示匹配以"flannel"开头的接口名称。
- `interface-name:cali*`：表示匹配以"flannel"开头的接口名称。
- `interface-name:cni0`：表示匹配名为"cni0"的接口。
- `mac:66:77:88:99:00:aa`：表示匹配MAC地址为"66:77:88:99:00:aa"的接口。
总结起来，这段代码的作用是配置网络接口的命名规则，包括匹配以"eth"开头的接口名称（除了"eth0"），匹配名为"docker0"、"flannel"开头的接口名称以及名为"cni0"的接口，并且排除MAC地址为"66:77:88:99:00:aa"的接口。
3. 重新加载配置
```bash
systemctl reload NetworkManager
```
### 问题记录
在 centos 8.x 环境中，默认没有安装 `network-scripts`，禁止 Network Manager 服务后则无法重启网络，可以通过手动安装。
```bash
yum -y install network-scripts
```

63
部署文档/Rancher-K3s/K3s单机部署.md Normal file
View File

@@ -0,0 +1,63 @@
> 本文作者：丁辉
# K3s单机部署
[Github仓库](https://github.com/k3s-io/k3s/)
[中文官方文档](https://docs.k3s.io/zh/)
## 开始部署
[K3s基础环境准备官方文档](https://docs.k3s.io/zh/installation/requirements)
| 节点名称 | IP | 角色 |
| :--------: | :----------: | :------------------: |
| k3s-master | 192.168.1.10 | control-plane,master |
[所有变量参数解释](https://docs.k3s.io/zh/cli/server)
- 国外源
```bash
curl -sfL https://get.k3s.io | \
K3S_KUBECONFIG_OUTPUT=~/.kube/config \
K3S_KUBECONFIG_MODE=644 \
K3S_NODE_NAME=k3s-master \
sh -
```
- 国内源
```bash
curl -sfL https://rancher-mirror.rancher.cn/k3s/k3s-install.sh | INSTALL_K3S_MIRROR=cn \
K3S_SYSTEM_DEFAULT_REGISTRY=registry.cn-hangzhou.aliyuncs.com \
K3S_KUBECONFIG_OUTPUT=~/.kube/config \
K3S_KUBECONFIG_MODE=644 \
K3S_NODE_NAME=k3s-master \
sh -
```
**参数解释**
| 参数 | 解释 |
| :-------------------------: | :----------------------------------------------------------: |
| INSTALL_K3S_MIRROR | 该参数用于指定 k3s 安装过程中下载软件包和镜像的镜像站点。 |
| K3S_SYSTEM_DEFAULT_REGISTRY | 该参数用于指定 k3s 系统组件（如 kube-apiserver、kube-controller-manager 等）使用的默认镜像仓库地址。 |
| K3S_KUBECONFIG_OUTPUT | 指定 K3s 安装完成后生成的 kubeconfig 文件的输出路径。在这个例子中，设置为 `~/.kube/config`，表示 kubeconfig 文件将保存在当前用户的主目录下的 `.kube` 目录中，文件名为 `config`。 |
| K3S_KUBECONFIG_MODE | 指定生成的 kubeconfig 文件的权限模式。在这个例子中，设置为 `644`，表示生成的 kubeconfig 文件权限模式为 `-rw-r--r--`，即当前用户有读写权限，其他用户只有读权限。 |
| K3S_NODE_NAME | 指定 K3s 安装节点的名称。在这个例子中，设置为 `k3s-master`，表示安装的节点将被命名为 `k3s-master`。 |
## 卸载
1. 停止
```bash
k3s-killall.sh
```
2. 卸载
```bash
k3s-uninstall.sh
```

108
部署文档/Rancher-K3s/K3s单机部署指定容器运行时Docker.md Normal file
View File

@@ -0,0 +1,108 @@
> 本文作者：丁辉
# K3s单机部署指定容器运行时Docker
> K3s默认容器运行时为: Containerd, 本文教你如何使用 Docker 容器运行时
[官方文档](https://docs.k3s.io/zh/advanced#%E4%BD%BF%E7%94%A8-docker-%E4%BD%9C%E4%B8%BA%E5%AE%B9%E5%99%A8%E8%BF%90%E8%A1%8C%E6%97%B6)
## 部署Docker
1. Docker安装
```bash
curl https://releases.rancher.com/install-docker/20.10.sh | sh
```
> 传递参数使用国内源
>
> ```bash
> curl -fsSL https://releases.rancher.com/install-docker/20.10.sh | sh -s -- --mirror Aliyun
> ```
2. 启动 Docker
```bash
systemctl enable docker
systemctl start docker
```
## 部署K3s
> 使用 `--docker` 参数指定 K3s 要使用的运行时
- 国外源
```bash
curl -sfL https://get.k3s.io | \
K3S_KUBECONFIG_OUTPUT=~/.kube/config \
K3S_KUBECONFIG_MODE=644 \
K3S_NODE_NAME=k3s-master \
sh -s - --docker
```
- 国内源
```bash
curl -sfL https://rancher-mirror.rancher.cn/k3s/k3s-install.sh | INSTALL_K3S_MIRROR=cn \
K3S_SYSTEM_DEFAULT_REGISTRY=registry.cn-hangzhou.aliyuncs.com \
K3S_KUBECONFIG_OUTPUT=~/.kube/config \
K3S_KUBECONFIG_MODE=644 \
K3S_NODE_NAME=k3s-master \
sh -s - --docker
```
**参数解释**
| 参数 | 解释 |
| :-------------------------: | :----------------------------------------------------------: |
| INSTALL_K3S_MIRROR | 该参数用于指定 k3s 安装过程中下载软件包和镜像的镜像站点。 |
| K3S_SYSTEM_DEFAULT_REGISTRY | 该参数用于指定 k3s 系统组件（如 kube-apiserver、kube-controller-manager 等）使用的默认镜像仓库地址。 |
| K3S_KUBECONFIG_OUTPUT | 指定 K3s 安装完成后生成的 kubeconfig 文件的输出路径。在这个例子中，设置为 `~/.kube/config`，表示 kubeconfig 文件将保存在当前用户的主目录下的 `.kube` 目录中，文件名为 `config`。 |
| K3S_KUBECONFIG_MODE | 指定生成的 kubeconfig 文件的权限模式。在这个例子中，设置为 `644`，表示生成的 kubeconfig 文件权限模式为 `-rw-r--r--`，即当前用户有读写权限，其他用户只有读权限。 |
| K3S_NODE_NAME | 指定 K3s 安装节点的名称。在这个例子中，设置为 `k3s-master`，表示安装的节点将被命名为 `k3s-master`。 |
## 卸载
1. 停止 K3s
```bash
k3s-killall.sh
```
2. 卸载 K3s
```bash
k3s-uninstall.sh
```
3. 停止 Docker
```bash
systemctl stop docker
```
4. 卸载 Docker
- Centos
```bash
yum remove docker-ce docker-ce-cli containerd.io docker-buildx-plugin docker-compose-plugin docker-ce-rootless-extras -y
```
- Ubuntu
```bash
sudo apt-get purge docker-ce docker-ce-cli containerd.io docker-buildx-plugin docker-compose-plugin docker-ce-rootless-extras
```
5. 删除 Docker 数据残留
```bash
rm -rf /var/lib/docker
rm -rf /var/lib/containerd
```

8
部署文档/Rancher-K3s/K3s自动部署清单.md Normal file
View File

@@ -0,0 +1,8 @@
> 本文作者：丁辉
# K3s自动部署清单
> 在 `/var/lib/rancher/k3s/server/manifests` 中找到的任何文件都会以类似 `kubectl apply` 的方式自动部署到 Kubernetes，在启动和在磁盘上更改文件时都是如此。从该目录中删除文件不会从集群中删除相应的资源。
[官方文档](https://docs.k3s.io/zh/installation/packaged-components)

64
部署文档/Rancher-K3s/K3s部署禁用自带附加组件.md Normal file
View File

@@ -0,0 +1,64 @@
> 本文作者：丁辉
# K3s部署禁用自带附加组件
[官方文档](https://docs.k3s.io/zh/installation/packaged-components)
**附加组件介绍**
| 可选项 | 描述 |
| :------------: | :----------------------------------------------------------: |
| coredns | 用于 Kubernetes 集群中 DNS 服务的核心组件。 |
| servicelb | 提供了服务负载均衡的组件，用于在集群中分发流量。 |
| traefik | 一个流行的反向代理和负载均衡工具，用于管理应用程序的入口流量。 |
| local-storage | 本地存储提供了将本地磁盘挂载到 Kubernetes Pod 中的功能。 |
| metrics-server | 用于收集和暴露 Kubernetes 集群中各种对象的度量数据的组件。 |
## 部署K3s
> 使用 `--disable` 禁用自带附加组件安装
- 国外源
```bash
curl -sfL https://get.k3s.io | \
K3S_KUBECONFIG_OUTPUT=~/.kube/config \
K3S_KUBECONFIG_MODE=644 \
K3S_NODE_NAME=k3s-master \
sh -s - --disable traefik,metrics-server,local-storage,servicelb
```
- 国内源
```bash
curl -sfL https://rancher-mirror.rancher.cn/k3s/k3s-install.sh | INSTALL_K3S_MIRROR=cn \
K3S_SYSTEM_DEFAULT_REGISTRY=registry.cn-hangzhou.aliyuncs.com \
K3S_KUBECONFIG_OUTPUT=~/.kube/config \
K3S_KUBECONFIG_MODE=644 \
K3S_NODE_NAME=k3s-master \
sh -s - --disable traefik,metrics-server,local-storage,servicelb
```
**参数解释**
| 参数 | 解释 |
| --------------------------- | ------------------------------------------------------------ |
| INSTALL_K3S_MIRROR | 该参数用于指定 k3s 安装过程中下载软件包和镜像的镜像站点。 |
| K3S_SYSTEM_DEFAULT_REGISTRY | 该参数用于指定 k3s 系统组件（如 kube-apiserver、kube-controller-manager 等）使用的默认镜像仓库地址。 |
| K3S_KUBECONFIG_OUTPUT | 指定 K3s 安装完成后生成的 kubeconfig 文件的输出路径。在这个例子中，设置为 `~/.kube/config`，表示 kubeconfig 文件将保存在当前用户的主目录下的 `.kube` 目录中，文件名为 `config`。 |
| K3S_KUBECONFIG_MODE | 指定生成的 kubeconfig 文件的权限模式。在这个例子中，设置为 `644`，表示生成的 kubeconfig 文件权限模式为 `-rw-r--r--`，即当前用户有读写权限，其他用户只有读权限。 |
| K3S_NODE_NAME | 指定 K3s 安装节点的名称。在这个例子中，设置为 `k3s-master`，表示安装的节点将被命名为 `k3s-master`。 |
## 卸载
1. 停止
```bash
k3s-killall.sh
```
2. 卸载
```bash
k3s-uninstall.sh
```

184
部署文档/Rancher-K3s/K3s部署高可用集群.md Normal file
View File

@@ -0,0 +1,184 @@
> 本文作者：丁辉
# K3s部署高可用集群
[Github仓库](https://github.com/k3s-io/k3s/)
[中文官方文档](https://docs.k3s.io/zh/)
[K3s基础环境准备官方文档](https://docs.k3s.io/zh/installation/requirements)
| 节点名称 | IP | 角色 |
| :----------: | :----------: | :-----------------------: |
| k3s-master-1 | 192.168.1.10 | control-plane,etcd,master |
| k3s-master-2 | 192.168.1.20 | control-plane,etcd,master |
| k3s-master-3 | 192.168.1.30 | control-plane,etcd,master |
| k3s-worker-1 | 192.168.1.40 | worker |
> Master节点VIP: 192.168.1.100
[集群数据存储配置](https://docs.k3s.io/zh/datastore)
[高可用嵌入式 etcd](https://docs.k3s.io/zh/datastore/ha-embedded)
## 开始部署管理节点
[所有变量参数解释](https://docs.k3s.io/zh/cli/server)
[集群负载均衡器](https://docs.k3s.io/zh/datastore/cluster-loadbalancer)
- 国外源
```bash
curl -sfL https://get.k3s.io | \
K3S_NODE_NAME=k3s-master-1 \
K3S_KUBECONFIG_OUTPUT=~/.kube/config \
K3S_KUBECONFIG_MODE=644 \
K3S_TOKEN=SECRET \
INSTALL_K3S_EXEC="--node-taint k3s-controlplane=true:NoExecute" \
sh -s - server \
--cluster-init \
--tls-san 192.168.1.100
```
- 国内源
```bash
curl -sfL https://rancher-mirror.rancher.cn/k3s/k3s-install.sh | INSTALL_K3S_MIRROR=cn \
K3S_NODE_NAME=k3s-master-1 \
K3S_KUBECONFIG_OUTPUT=~/.kube/config \
K3S_KUBECONFIG_MODE=644 \
K3S_TOKEN=SECRET \
INSTALL_K3S_EXEC="--node-taint k3s-controlplane=true:NoExecute" \
sh -s - server \
--cluster-init \
--tls-san 192.168.1.100
```
>该参数用于指定 k3s 系统组件（如 kube-apiserver、kube-controller-manager 等）使用的默认镜像仓库地址。(阿里同步较慢有时会获取不到最新镜像)
>
>```bash
>K3S_SYSTEM_DEFAULT_REGISTRY=registry.cn-hangzhou.aliyuncs.com
>```
**参数解释**
| 参数 | 解释 |
| :----------------------------------------------------------: | :----------------------------------------------------------: |
| K3S_NODE_NAME | 指定 K3s 安装节点的名称。在这个例子中，设置为 `k3s-master-1`，表示安装的节点将被命名为 `k3s-master-1`。 |
| K3S_KUBECONFIG_OUTPUT | 指定 K3s 安装完成后生成的 kubeconfig 文件的输出路径。在这个例子中，设置为 `~/.kube/config`，表示 kubeconfig 文件将保存在当前用户的主目录下的 `.kube` 目录中，文件名为 `config`。 |
| K3S_KUBECONFIG_MODE | 指定生成的 kubeconfig 文件的权限模式。在这个例子中，设置为 `644`，表示生成的 kubeconfig 文件权限模式为 `-rw-r--r--`，即当前用户有读写权限，其他用户只有读权限。 |
| K3S_TOKEN | 配置共享 secret |
| INSTALL_K3S_EXEC="--node-taint k3s-controlplane=true:NoExecute" | controlplane节点禁止调度 |
| --cluster-init | 使用嵌入式 Etcd 初始化新集群 |
| --tls-san | 在 TLS 证书上添加其他主机名或 IPv4/IPv6 地址作为 Subject Alternative Name |
| INSTALL_K3S_MIRROR | 该参数用于指定 k3s 安装过程中下载软件包和镜像的镜像站点。 |
## 添加管理节点[2,3节点同理]
- 国外源
```bash
curl -sfL https://get.k3s.io | \
K3S_NODE_NAME=k3s-master-2 \
K3S_KUBECONFIG_OUTPUT=~/.kube/config \
K3S_KUBECONFIG_MODE=644 \
K3S_TOKEN=SECRET \
INSTALL_K3S_EXEC="--node-taint k3s-controlplane=true:NoExecute" \
sh -s - server \
--server https://192.168.1.100:6443 \
--tls-san 192.168.1.100
```
- 国内源
```bash
curl -sfL https://rancher-mirror.rancher.cn/k3s/k3s-install.sh | INSTALL_K3S_MIRROR=cn \
K3S_NODE_NAME=k3s-master-2 \
K3S_KUBECONFIG_OUTPUT=~/.kube/config \
K3S_KUBECONFIG_MODE=644 \
K3S_TOKEN=SECRET \
INSTALL_K3S_EXEC="--node-taint k3s-controlplane=true:NoExecute" \
sh -s - server \
--server https://192.168.1.100:6443 \
--tls-san 192.168.1.100
```
## 添加计算节点
> 在管理节点获取 ${node-token}
>
> ```bash
> cat /var/lib/rancher/k3s/server/node-token
> ```
- 国外源
```bash
curl -sfL https://get.k3s.io | \
K3S_NODE_NAME=k3s-worker-1 \
K3S_URL=https://192.168.1.100:6443 \
K3S_TOKEN=${node-token} \
sh -s - agent
```
- 国内源
```bash
curl -sfL https://rancher-mirror.rancher.cn/k3s/k3s-install.sh | INSTALL_K3S_MIRROR=cn \
K3S_NODE_NAME=k3s-worker-1 \
K3S_URL=https://192.168.1.100:6443 \
K3S_TOKEN=${node-token} \
sh -s - agent
```
**计算节点添加角色标签**
```bash
kubectl label node ${node} node-role.kubernetes.io/worker=true --overwrite
```
> `--overwrite` 强制覆盖
## 卸载
### 卸载 Server
1. 删除 Server 节点
```bash
kubectl delete node ${node}
```
2. 停止 Server
```bash
k3s-killall.sh
```
3. 卸载 Server
```bash
k3s-uninstall.sh
```
### 卸载 Agent
1. 删除 Agent 节点
```bash
kubectl delete node ${node}
```
2. 停止 K3s-Agent
```bash
k3s-killall.sh
```
3. 卸载 K3s-Agent
```bash
k3s-agent-uninstall.sh
```

24
部署文档/Rancher/Rancher组件公开Metrics访问.md Normal file
View File

@@ -0,0 +1,24 @@
> 本文作者：丁辉
# Rancher组件公开Metrics访问
## RKE1添加Arg
```bash
vi cluster.yml
```
修改如下内容(当前只有这俩默认不对外开放)
```yaml
services:
etcd:
image: ""
extra_args:
listen-metrics-urls: "http://0.0.0.0:2381"
...
kubeproxy:
image: ""
extra_args:
metrics-bind-address: "0.0.0.0:10249"
```

396
部署文档/Rancher/Rke1部署Kubernetes集群.md Normal file
View File

@@ -0,0 +1,396 @@
> 本文作者：丁辉
# Rke1部署Kubernetes集群
[RKE1文档](https://rke.docs.rancher.com/)
[Rancher中文文档](https://docs.rancher.cn/)
| 节点名称 | IP | Kubernetes角色 |
| :------------------: | :----------: | :----------------------: |
| k8s-master-1,Rke管理 | 192.168.1.10 | controlplane,etcd,worker |
| k8s-master-2 | 192.168.1.20 | controlplane,etcd,worker |
| k8s-master-3 | 192.168.1.30 | controlplane,etcd,worker |
## 环境准备
> !!!每次部署都写挺麻烦的索性都放在一个文件内了请查看 [Kubernetes基础环境准备](https://gitee.com/offends/Kubernetes/blob/main/%E9%83%A8%E7%BD%B2%E6%96%87%E6%A1%A3/Kubernetes%E5%9F%BA%E7%A1%80%E7%8E%AF%E5%A2%83%E5%87%86%E5%A4%87.md) ,请按照此文档初始化环境
### 所有节点执行
1. 配置 SSH
```bash
sed -i 's/#AllowTcpForwarding yes/AllowTcpForwarding yes/g' /etc/ssh/sshd_config
```
重启 SSH
```bash
systemctl restart sshd
```
2. 将用户添加到 docker 组
```bash
groupadd docker
useradd -m docker -g docker
```
> 使用其他用户
>
> ```bash
> useradd rke # 创建用户
> usermod -aG docker rke 将rke用户加入docker组
> ```
3. 配置 docker 用户免密登录
```bash
mkdir -p /home/docker/.ssh/
touch /home/docker/.ssh/authorized_keys
chmod 700 /home/docker/.ssh/
chown -R docker.docker /home/docker/.ssh/
chmod 600 /home/docker/.ssh/authorized_keys
```
### Rke管理节点执行
1. 生成密钥
```bash
ssh-keygen -t rsa -N "" -f ~/.ssh/id_rsa -q
```
2. 查看主节点密钥
> 密钥需要到 RKE 初始化节点上获取，所有节点都是用此密钥
```bash
cat ~/.ssh/id_rsa.pub
```
### 所有节点执行
1. 粘贴密钥内容到此文件内(提示：所有节点粘贴Rke管理节密钥)
```bash
vi /home/docker/.ssh/authorized_keys
```
2. 验证是否可以免密登录
```bash
ssh docker@192.168.1.10
```
## Docker安装
1. Docker安装
```bash
curl https://releases.rancher.com/install-docker/20.10.sh | sh
```
> 传递参数使用国内源
>
> ```bash
> curl -fsSL https://releases.rancher.com/install-docker/20.10.sh | sh -s -- --mirror Aliyun
> ```
2. Docker参数配置
[文件参考](https://gitea.offends.cn/Offends/Kubernetes/src/branch/main/Docker/Files/daemon.json)
```bash
curl -so /etc/docker/daemon.json https://gitee.com/offends/Kubernetes/raw/main/Docker/Files/daemon.json
```
3. 启动 Docker
```bash
systemctl enable docker
systemctl start docker
```
## 安装并初始化Rke
[RKE二进制文件](https://github.com/rancher/rke/releases/)
1. 下载 RKE 二进制文件，并添加到可执行路径下
> 1.8 版本是 RKE 1.x 系列的最终版本
```bash
wget https://github.com/rancher/rke/releases/download/v1.8.6/rke_linux-amd64
```
2. 授权
```bash
chmod 777 rke_linux-amd64 && mv rke_linux-amd64 /usr/local/bin/rke
```
### 方法一 (不推荐怪麻烦的请看"方法二")
> 如果 `Number of Hosts` 填的是多节点则会提示输入多次节点信息
```bash
rke config --name cluster.yml
```
```bash
[+] Cluster Level SSH Private Key Path [~/.ssh/id_rsa]: #默认回车
[+] Number of Hosts [1]: #节点数量
[+] SSH Address of host (1) [none]: 192.168.1.10 #节点IP地址
[+] SSH Port of host (1) [22]: #默认回车
[+] SSH Private Key Path of host (192.168.1.10) [none]: #默认回车
[-] You have entered empty SSH key path, trying fetch from SSH key parameter
[+] SSH Private Key of host (192.168.1.10) [none]: #默认回车
[-] You have entered empty SSH key, defaulting to cluster level SSH key: ~/.ssh/id_rsa
[+] SSH User of host (192.168.1.10) [ubuntu]: docker #SSH用户
[+] Is host (192.168.1.10) a Control Plane host (y/n)? [y]: y #是否为控制节点
[+] Is host (192.168.1.10) a Worker host (y/n)? [n]: y #是否为计算节点
[+] Is host (192.168.1.10) an etcd host (y/n)? [n]: y #是否为etcd节点
[+] Override Hostname of host (192.168.1.10) [none]: #默认回车
[+] Internal IP of host (192.168.1.10) [none]: 192.168.1.10 #主机内部IP
[+] Docker socket path on host (192.168.1.10) [/var/run/docker.sock]: #默认回车
[+] Network Plugin Type (flannel, calico, weave, canal, aci) [canal]: flannel #选择网络插件类型
[+] Authentication Strategy [x509]: #默认回车
[+] Authorization Mode (rbac, none) [rbac]: #默认回车
[+] Kubernetes Docker image [rancher/hyperkube:v1.26.8-rancher1]: #选择 k8s 版本
[+] Cluster domain [cluster.local]: #集群域
[+] Service Cluster IP Range [10.43.0.0/16]: #服务集群IP范围
[+] Enable PodSecurityPolicy [n]: #默认回车
[+] Cluster Network CIDR [10.42.0.0/16]: #集群网络CIDR
[+] Cluster DNS Service IP [10.43.0.10]: #集群DNS服务IP
[+] Add addon manifest URLs or YAML files [no]: #默认回车
```
基础参数修改
```bash
sed -i '/^ingress:$/,/^ provider:/ s/provider: ""/provider: "none"/' cluster.yml
```
### 方法二
1. 生成初始文件
```bash
rke config --empty --name cluster.yml
```
2. 按需要修改 address 参数
> 多节点则写多个 `address` 并通过调整 role 指定节点属性
```yml
nodes:
- address: 192.168.1.10
port: "22"
internal_address: 192.168.1.10
role:
- controlplane #管理
- worker #计算
- etcd #etcd节点
hostname_override: ""
user: docker
docker_socket: /var/run/docker.sock
ssh_key: ""
ssh_key_path: ~/.ssh/id_rsa
ssh_cert: ""
ssh_cert_path: ""
labels: {}
taints: []
# 格式一样此处省略 20,30 节点配置 ...
services:
...
```
3. 基础参数修改
```bash
sed -i 's/service_cluster_ip_range: ""/service_cluster_ip_range: 10.43.0.0\/16/' cluster.yml
sed -i 's/cluster_cidr: ""/cluster_cidr: 10.42.0.0\/16/' cluster.yml
sed -i 's/cluster_domain: ""/cluster_domain: cluster.local/' cluster.yml
sed -i 's/cluster_dns_server: ""/cluster_dns_server: 10.43.0.10/' cluster.yml
sed -i 's/plugin: ""/plugin: flannel/' cluster.yml
sed -i 's/strategy: ""/strategy: x509/' cluster.yml
sed -i 's/^\s*mode: ""$/ mode: rbac/' cluster.yml
sed -i '/^ingress:$/,/^ provider:/ s/provider: ""/provider: "none"/' cluster.yml
sed -i '/^[^ ]/ s/ssh_key_path: ""/ssh_key_path: ~\/.ssh\/id_rsa/g' cluster.yml
sed -i '0,/^\s*ssh_key_path: ""$/{s,^\s*ssh_key_path: ""$, ssh_key_path: ~/.ssh/id_rsa,}' cluster.yml
```
## 初始化 Kubernetes 集群
```bash
rke up
```
> - 禁用 metrics-server 组件
>
> ```bash
> sed -i '/^monitoring:$/,/^ provider:/ s/provider: ""/provider: "none"/' cluster.yml
> ```
>
> - 调整节点端口范围
>
> > 默认端口范围：30000-32767
>
> ```bash
> sed -i 's/service_node_port_range: ""/service_node_port_range: "10000-30000"/' cluster.yml
> ```
>
> - 关闭 Docker 版本检测
>
> ```bash
> sed -i 's/ignore_docker_version: null/ignore_docker_version: true/' cluster.yml
> ```
>
> - 调整部署版本
>
> - 查看当前 RKE 支持的Kubernetes版本
>
> ```bash
> rke config --list-version --all
> ```
>
> - 替换版本
>
> ```bash
> sed -i 's/kubernetes_version: ""/kubernetes_version: "v1.24.17-rancher1-1"/' cluster.yml
> ```
>
> - 更新集群
>
> ```bash
> rke up --update-only
> ```
## 安装 kubectl
[Kubectl二进制文件](https://kubernetes.io/docs/tasks/tools/install-kubectl-linux/)
1. 下载 kubectl
```bash
curl -LO https://dl.k8s.io/release/v1.26.8/bin/linux/amd64/kubectl
```
2. 授权
```bash
chmod 777 kubectl && mv kubectl /usr/local/bin/
```
3. 添加 kubctl 文件
```bash
mkdir ~/.kube && cp kube_config_cluster.yml ~/.kube/config && chmod 600 ~/.kube/config
```
4. 验证
```bash
kubectl get node
```
> 本文中没有禁用 `monitoring` 所以也可以使用 `kubectl top node` 测试
## 卸载
1. 卸载 RKE 集群
```bash
rke remove
```
2. 清理残余容器
```bash
for i in $(docker ps -a | grep rancher | awk '{print $1}');do docker rm -f $i;done
for i in $(docker ps -a | grep rke | awk '{print $1}');do docker rm -f $i;done
```
3. 清除 Docker 引擎的废弃资源和缓存
```bash
docker system prune --all
```
4. 卸载挂载
```bash
mount | grep /var/lib/kubelet/pods/ | awk '{print $1}' | xargs umount -l
```
5. 删除持久化目录
```bash
rm -rf /var/lib/kubelet/
rm -rf /run/flannel/
```
## 备份和恢复
> 非常重要，他奶奶的吃大亏了
### 创建一次性快照
> RKE 会将节点快照保存在 `/opt/rke/etcd-snapshots` 路径下
```bash
rke etcd snapshot-save --config cluster.yml --name <快照名称>
```
### 恢复集群
```bash
rke etcd snapshot-restore --config cluster.yml --name <快照名称>
```
## 恢复 Rke配置文件
> 准备依赖 `jq`
>
> - Centos
>
> ```
> yum install jq -y
> ```
>
> - Ubuntu
>
> ```bash
> apt install jq -y
> ```
- 恢复 Kubectl 配置文件
> 修改 `--master-ip=` 为任意 K8S Master节点IP
```bash
curl -sfL https://gitee.com/offends/Kubernetes/raw/main/File/Shell/restore-rkestate-kubeconfig.sh | bash -s -- --master-ip=<K8S Master节点IP>
```
- 恢复 rkestate 状态文件
- 通过本地 kubectl 找回
```bash
kubectl get configmap -n kube-system full-cluster-state -o json | jq -r .data.\"full-cluster-state\" | jq -r . > cluster.rkestate
```
- 通过 master 节点找回
```bash
curl -sfL https://gitee.com/offends/Kubernetes/raw/main/File/Shell/restore-rkestate-config.sh | bash -s
```

126
部署文档/Rancher/Rke2单机快速部署Kubernetes.md Normal file
View File

@@ -0,0 +1,126 @@
> 本文作者：丁辉
[Rke2文档](https://docs.rke2.io/)
[Rancher中文文档](https://docs.rancher.cn/)
# Rke2单机快速部署Kubernetes
| 节点名称 | IP | Kubernetes角色 |
| :----------: | :----------: | :----------------------------------------: |
| k8s-master-1 | 192.168.1.10 | Controlplane,etcd,worker,keepalived-master |
## 环境准备
> !!!每次部署都写挺麻烦的索性都放在一个文件内了请查看 [Kubernetes基础环境准备](https://gitee.com/offends/Kubernetes/blob/main/%E9%83%A8%E7%BD%B2%E6%96%87%E6%A1%A3/Kubernetes%E5%9F%BA%E7%A1%80%E7%8E%AF%E5%A2%83%E5%87%86%E5%A4%87.md) ,请按照此文档初始化环境
### 所有节点执行
1. 更改主机名
```bash
hostnamectl set-hostname k8s-master-1 && bash
```
3. 在三台节点上配置 NetworkManager
- 配置 cali 和 flannel 的网卡不被 NetworkManager 管理
```bash
mkdir -p /etc/NetworkManager/conf.d
```
内容如下
```bash
cat <<EOF > /etc/NetworkManager/conf.d/rke2-canal.conf
[keyfile]
unmanaged-devices=interface-name:cali*;interface-name:flannel*
EOF
```
- 重启 NetworkManager
```bash
systemctl daemon-reload
systemctl restart NetworkManager
```
### 开始部署
[Rke2-Github-releases](https://github.com/rancher/rke2/releases)
1. 安装 RKE2
```bash
curl -sfL https://get.rke2.io | sh -
```
> - 使用国内源
>
> ```bash
> curl -sfL http://rancher-mirror.rancher.cn/rke2/install.sh | INSTALL_RKE2_MIRROR=cn INSTALL_RKE2_TYPE="server" sh -
> ```
>
> - 指定版本
>
> ```bash
> curl -sfL https://rancher-mirror.rancher.cn/rke2/install.sh | INSTALL_RKE2_MIRROR=cn INSTALL_RKE2_TYPE="server" INSTALL_RKE2_VERSION="v1.29.3+rke2r1" sh -
> ```
2. 开始部署主节点
```bash
systemctl enable rke2-server.service
systemctl start rke2-server.service
```
> 启动失败查看日志
>
> ```bash
> rke2 server --config /etc/rancher/rke2/config.yaml --debug
> ```
3. 配置 RKE2 可执行文件加入到系统的 PATH 中
```bash
echo "export PATH=$PATH:/var/lib/rancher/rke2/bin" >> /etc/profile && source /etc/profile
```
4. 配置 config 文件
```bash
mkdir ~/.kube && cp /etc/rancher/rke2/rke2.yaml ~/.kube/config
```
5. 验证
```bash
kubectl get node
```
6. 配置 crictl 软链接
```bash
ln -s /var/lib/rancher/rke2/agent/etc/crictl.yaml /etc/crictl.yaml
```
7. 验证
```bash
crictl ps
```
## 卸载节点
1. 停止 Rke2
```bash
rke2-killall.sh
```
2. 卸载 Rke2
```bash
rke2-uninstall.sh
```

476
部署文档/Rancher/Rke2部署Kubernetes集群.md Normal file
View File

@@ -0,0 +1,476 @@
> 本文作者：丁辉
[Rke2文档](https://docs.rke2.io/)
[Rancher中文文档](https://docs.rancher.cn/)
# Rke2部署Kubernetes集群
| 节点名称 | IP | Kubernetes角色 |
| :----------: | :----------: | :----------------------------------------: |
| k8s-master-1 | 192.168.1.10 | Controlplane,etcd,worker,keepalived-master |
| k8s-master-2 | 192.168.1.20 | Controlplane,etcd,worker,keepalived-backup |
| k8s-master-3 | 192.168.1.30 | controlplane,etcd,worker,keepalived-backup |
| k8s-worker-1 | 192.168.1.40 | worker |
> Master节点VIP: 192.168.1.100
## 环境准备
> !!!每次部署都写挺麻烦的索性都放在一个文件内了请查看 [Kubernetes基础环境准备](https://gitee.com/offends/Kubernetes/blob/main/%E9%83%A8%E7%BD%B2%E6%96%87%E6%A1%A3/Kubernetes%E5%9F%BA%E7%A1%80%E7%8E%AF%E5%A2%83%E5%87%86%E5%A4%87.md) ,请按照此文档初始化环境
### 所有节点执行
1. 更改主机名
- 192.168.1.10
```bash
hostnamectl set-hostname k8s-master-1 && bash
```
- 192.168.1.20
```bash
hostnamectl set-hostname k8s-master-2 && bash
```
- 192.168.1.30
```bash
hostnamectl set-hostname k8s-master-3 && bash
```
- 192.168.1.40
```bash
hostnamectl set-hostname k8s-node-1 && bash
```
2. 编辑 /etc/hosts 文件
```bash
vi /etc/hosts
```
添加如下内容
```bash
192.168.1.10 k8s-master-1
192.168.1.20 k8s-master-2
192.168.1.30 k8s-master-3
192.168.1.40 k8s-node-1
```
3. 在三台节点上配置 NetworkManager
- 配置 cali 和 flannel 的网卡不被 NetworkManager 管理
```bash
mkdir -p /etc/NetworkManager/conf.d
```
内容如下
```bash
cat <<EOF > /etc/NetworkManager/conf.d/rke2-canal.conf
[keyfile]
unmanaged-devices=interface-name:cali*;interface-name:flannel*
EOF
```
- 重启 NetworkManager
```bash
systemctl daemon-reload
systemctl restart NetworkManager
```
### 安装主节点
[Rke2-Github-releases](https://github.com/rancher/rke2/releases)
1. 安装 RKE2
```bash
curl -sfL https://get.rke2.io | sh -
```
> - 使用国内源
>
> ```bash
> curl -sfL http://rancher-mirror.rancher.cn/rke2/install.sh | INSTALL_RKE2_MIRROR=cn INSTALL_RKE2_TYPE="server" sh -
> ```
>
> - 指定版本
>
> ```bash
> curl -sfL https://rancher-mirror.rancher.cn/rke2/install.sh | INSTALL_RKE2_MIRROR=cn INSTALL_RKE2_TYPE="server" INSTALL_RKE2_VERSION="v1.29.3+rke2r1" sh -
> ```
2. 创建 RKE2 配置文件
[Server 配置参考](https://docs.rke2.io/zh/reference/server_config)
[高级选项和配置](https://docs.rke2.io/zh/advanced)
```bash
mkdir -p /etc/rancher/rke2/
vi /etc/rancher/rke2/config.yaml
```
内容如下
```yaml
#server: "https://192.168.1.100:9345" # 全部 Master 启动后解除注释, 重启服务"
# 创建 token
token: rke2-create-token
# 负载均衡统一入口 IP 或 域名
tls-san:
- "192.168.1.100"
# 阿里镜像源加速, 通常由社区志愿者维护, 镜像同步通常存在滞后性
#system-default-registry: "registry.cn-hangzhou.aliyuncs.com"
# 节点 NAME
node-name: k8s-master-1 # 与当前主机名保持一致
# 节点污点, 禁止 master 节点运行容器
node-taint:
- "CriticalAddonsOnly=true:NoExecute"
disable: # 取消安装 Rke2 默认安装 Charts
- "rke2-ingress-nginx"
- "rke2-metrics-server"
#### 网络配置
# 指定网络模式, [ ipvs , iptables ] 默认是:iptables
kube-proxy-arg:
- "proxy-mode=iptables"
# Kubernetes 集群域名
cluster-domain: "cluster.local"
# 指定要部署的 CNI（Container Network Interface）插件[ none , calico , flannel , canal , cilium ] 默认: canal
cni: "canal"
# 指定 Pod IP 的 IPv4/IPv6 网络 CIDR
cluster-cidr: "10.42.0.0/16"
# 指定 Service IP 的 IPv4/IPv6 网络 CIDR
service-cidr: "10.43.0.0/16"
# 指定用于具有 NodePort 访问权限的 Service 的端口范围
service-node-port-range: "30000-32767"
#### ETCD存储配置
# 快照备份时间
etcd-snapshot-schedule-cron: "0 */12 * * *"
# 快照文件保留个数
etcd-snapshot-retention: "10"
# 快照存储目录, 默认位置 /var/lib/rancher/rke2/server/db/snapshots
etcd-snapshot-dir: "${data-dir}/db/snapshots"
#### 存储目录配置
# kube-config 文件位置
write-kubeconfig: "/root/.kube/config"
# kube-config 文件权限
write-kubeconfig-mode: "0644"
# Rke2文件存储目录
data-dir: "/var/lib/rancher/rke2"
```
> 其他参数配置
>
> ```yaml
> # 自定义垃圾回收机制
> kubelet-arg:
> # 设置硬性回收阈值，当节点的文件系统可用空间低于 10% 或内存可用空间低于 2048Mi 时，kubelet 将触发硬性回收，即强制驱逐 Pod 以释放资源
> - "eviction-hard=nodefs.available<10%,memory.available<2048Mi"
> # 置软性回收的宽限期，当节点的文件系统可用空间或镜像文件系统可用空间低于一定阈值时，kubelet 将在触发硬性回收之前等待 30 秒
> - "eviction-soft-grace-period=nodefs.available=30s,imagefs.available=30s"
> # 设置软性回收的阈值，当节点的文件系统可用空间低于 10% 或镜像文件系统可用空间低于 10% 时，kubelet 将触发软性回收，尝试释放资源
> - "eviction-soft=nodefs.available<10%,imagefs.available<10%"
>
> kube-controller-manager-extra-env:
> # 设置 Kubernetes 集群签名证书的路径
> - "cluster-signing-cert-file=/etc/kubernetes/ssl/kube-ca.pem"
> # 设置 Kubernetes 集群签名密钥的路径
> - "cluster-signing-key-file=/etc/kubernetes/ssl/kube-ca-key.pem"
>
> kube-apiserver-extra-env:
> # apiserver启用metadata.selfLink 字段
> - "feature-gates='RemoveSelfLink=false'"
> ```
3. 开始部署主节点
```bash
systemctl enable rke2-server.service
systemctl start rke2-server.service
```
> 启动失败查看日志
>
> ```bash
> rke2 server --config /etc/rancher/rke2/config.yaml --debug
> ```
4. 配置 RKE2 可执行文件加入到系统的 PATH 中
```bash
echo "export PATH=$PATH:/var/lib/rancher/rke2/bin" >> /etc/profile && source /etc/profile
```
5. 验证
```bash
kubectl get node
```
6. 配置 crictl 软链接
```bash
ln -s /var/lib/rancher/rke2/agent/etc/crictl.yaml /etc/crictl.yaml
```
7. 验证
```bash
crictl ps
```
10. 查看集群 Token
```bash
cat /var/lib/rancher/rke2/server/node-token
```
## 添加管理节点[2,3节点同理]
1. 安装 RKE2
```bash
curl -sfL https://get.rke2.io | sh -
```
> - 使用国内源
>
> ```bash
> curl -sfL http://rancher-mirror.rancher.cn/rke2/install.sh | INSTALL_RKE2_MIRROR=cn INSTALL_RKE2_TYPE="server" sh -
> ```
>
> - 指定版本
>
> ```bash
> curl -sfL https://rancher-mirror.rancher.cn/rke2/install.sh | INSTALL_RKE2_MIRROR=cn INSTALL_RKE2_TYPE="server" INSTALL_RKE2_CHANNEL=v1.20 sh -
> ```
2. 创建 RKE2 配置文件
```bash
mkdir -p /etc/rancher/rke2/
vi /etc/rancher/rke2/config.yaml
```
内容如下
```yaml
# 指定要连接的集群服务器地址
server: https://192.168.1.100:9345
# Master 节点 token
token: <token> #主节点获取的token值
# 负载均衡统一入口 IP 或 域名
tls-san:
- "192.168.1.100"
# 阿里镜像源加速, 通常由社区志愿者维护, 镜像同步通常存在滞后性
#system-default-registry: "registry.cn-hangzhou.aliyuncs.com"
# 节点 NAME
node-name: k8s-master-2 # 与当前主机名保持一致
# 节点污点, 禁止 master 节点运行容器
node-taint:
- "CriticalAddonsOnly=true:NoExecute"
disable: # 取消安装 Rke2 默认安装 Charts
- "rke2-ingress-nginx"
- "rke2-metrics-server"
#### 网络配置
# 指定网络模式, [ ipvs , iptables ] 默认是:iptables
kube-proxy-arg:
- "proxy-mode=iptables"
# Kubernetes 集群域名
cluster-domain: "cluster.local"
# 指定要部署的 CNI（Container Network Interface）插件[ none , calico , flannel , canal , cilium ] 默认: canal
cni: "canal"
# 指定 Pod IP 的 IPv4/IPv6 网络 CIDR
cluster-cidr: "10.42.0.0/16"
# 指定 Service IP 的 IPv4/IPv6 网络 CIDR
service-cidr: "10.43.0.0/16"
# 指定用于具有 NodePort 访问权限的 Service 的端口范围
service-node-port-range: "30000-32767"
#### ETCD存储配置
# 快照备份时间
etcd-snapshot-schedule-cron: "0 */12 * * *"
# 快照文件保留个数
etcd-snapshot-retention: "10"
# 快照存储目录, 默认位置 /var/lib/rancher/rke2/server/db/snapshots
etcd-snapshot-dir: "${data-dir}/db/snapshots"
#### 存储目录配置
# kube-config 文件位置
write-kubeconfig: "/root/.kube/config"
# kube-config 文件权限
write-kubeconfig-mode: "0644"
# Rke2文件存储目录
data-dir: "/var/lib/rancher/rke2"
```
4. 启动
```bash
systemctl enable rke2-server.service
systemctl start rke2-server.service
```
## 添加计算节点
[Agent 配置参考](https://docs.rke2.io/zh/reference/linux_agent_config)
1. 安装 RKE2
```bash
curl -sfL https://get.rke2.io | INSTALL_RKE2_TYPE="agent" sh -
```
> - 使用国内源
>
> ```bash
> curl -sfL http://rancher-mirror.rancher.cn/rke2/install.sh | INSTALL_RKE2_MIRROR=cn INSTALL_RKE2_TYPE="agent" sh -
> ```
>
> - 指定版本
>
> ```bash
> curl -sfL https://rancher-mirror.rancher.cn/rke2/install.sh | INSTALL_RKE2_MIRROR=cn INSTALL_RKE2_TYPE="agent" INSTALL_RKE2_CHANNEL=v1.20 sh -
> ```
2. 创建 RKE2 配置文件
```bash
mkdir -p /etc/rancher/rke2/
vi /etc/rancher/rke2/config.yaml
```
内容如下
```yaml
# 指定要连接的集群服务器地址
server: https://192.168.1.100:9345
# Master 节点 token
token: <token> #主节点获取的token值
# 节点 NAME
node-name: k8s-node-1 # 与当前主机名保持一致
# 阿里镜像源加速, 通常由社区志愿者维护, 镜像同步通常存在滞后性
#system-default-registry: "registry.cn-hangzhou.aliyuncs.com"
#### 网络配置
# 指定网络模式, [ ipvs , iptables ] 默认是:iptables
kube-proxy-arg:
- "proxy-mode=iptables"
```
3. 部署计算节点
```bash
systemctl enable rke2-agent.service
systemctl start rke2-agent.service
```
4. 计算节点添加角色标签
```bash
kubectl label node ${node} node-role.kubernetes.io/worker=true --overwrite
```
## 卸载节点
1. 删除 node 节点
```bash
kubectl delete node ${node}
```
2. 停止 Rke2
```bash
rke2-killall.sh
```
3. 卸载 Rke2
```bash
rke2-uninstall.sh
```
## RKE2高可用部署Kubernetes
1. 编辑 Nginx 配置文件
```bash
vi nginx.conf
```
内容如下
```nginx
events {
worker_connections 1024;
}
stream {
upstream kube-apiserver {
server host1:6443 max_fails=3 fail_timeout=30s;
server host2:6443 max_fails=3 fail_timeout=30s;
server host3:6443 max_fails=3 fail_timeout=30s;
}
upstream rke2 {
server host1:9345 max_fails=3 fail_timeout=30s;
server host2:9345 max_fails=3 fail_timeout=30s;
server host3:9345 max_fails=3 fail_timeout=30s;
}
server {
listen 6443;
proxy_connect_timeout 2s;
proxy_timeout 900s;
proxy_pass kube-apiserver;
}
server {
listen 9345;
proxy_connect_timeout 2s;
proxy_timeout 900s;
proxy_pass rke2;
}
}
```
2. 启动 Nginx
```bash
docker run -itd -p 9345:9345 -p 6443:6443 -v ~/nginx.conf:/etc/nginx/nginx.conf nginx
```
3. 更改之前的 config.yaml
```bash
vi /etc/rancher/rke2/config.yaml
```
内容如下
```bash
tls-san:
- xxx.xxx.xxx.xxx
```

294
部署文档/二进制/Kubernetes手动证书签发.md Normal file
View File

@@ -0,0 +1,294 @@
> 本文作者：丁辉
# Kubernetes手动证书签发
## 环境准备
> 安装 CFSSL
1. 创建证书目录
```bash
mkdir /root/k8s
cd /root/k8s
```
2. 下载 CFSSL 文件
[Github下载地址](https://github.com/cloudflare/cfssl/releases)
```bash
wget https://github.com/cloudflare/cfssl/releases/download/v1.6.4/cfssl_1.6.4_linux_amd64
wget https://github.com/cloudflare/cfssl/releases/download/v1.6.4/cfssljson_1.6.4_linux_amd64
wget https://github.com/cloudflare/cfssl/releases/download/v1.6.4/cfssl-certinfo_1.6.4_linux_amd64
```
3. 授权并移动到可执行目录下
```bash
chmod +x cfssl_*_linux_amd64 cfssljson_*_linux_amd64 cfssl-certinfo_*_linux_amd64
mv cfssl_*_linux_amd64 /usr/local/bin/cfssl
mv cfssljson_*_linux_amd64 /usr/local/bin/cfssljson
mv cfssl-certinfo_*_linux_amd64 /usr/bin/cfssl-certinfo
```
## 开始签发证书
1. 创建 CA 证书签名请求
```bash
cat > ca-csr.json <<EOF
{
"CN": "kubernetes",
"key": {
"algo": "rsa",
"size": 2048
},
"names": [
{
"C": "CN",
"ST": "BeiJing",
"L": "BeiJing",
"O": "k8s",
"OU": "System"
}
],
"ca": {
"expiry": "87600h"
}
}
EOF
```
2. 生成 CA 证书和私钥
```bash
cfssl gencert -initca ca-csr.json | cfssljson -bare ca
```
3. 创建 CA 配置文件
```bash
cat > ca-config.json <<EOF
{
"signing": {
"default": {
"expiry": "87600h"
},
"profiles": {
"kubernetes": {
"usages": [
"signing",
"key encipherment",
"server auth",
"client auth"
],
"expiry": "87600h"
}
}
}
}
EOF
```
4. 创建 kubernetes 证书
```bash
cat > kubernetes-csr.json <<EOF
{
"CN": "kubernetes",
"hosts": [
"127.0.0.1",
"192.168.1.10",
"192.168.1.20",
"192.168.1.30",
"10.244.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": "BeiJing",
"L": "BeiJing",
"O": "k8s",
"OU": "System"
}
]
}
EOF
```
5. 生成 kubernetes 证书和私钥
```bash
cfssl gencert -ca=ca.pem -ca-key=ca-key.pem -config=ca-config.json -profile=kubernetes kubernetes-csr.json | cfssljson -bare kubernetes
```
6. 创建 admin 证书
```bash
cat > admin-csr.json <<EOF
{
"CN": "admin",
"hosts": [],
"key": {
"algo": "rsa",
"size": 2048
},
"names": [
{
"C": "CN",
"ST": "BeiJing",
"L": "BeiJing",
"O": "system:masters",
"OU": "System"
}
]
}
EOF
```
7. 生成 admin 证书和私钥
```bash
cfssl gencert -ca=ca.pem -ca-key=ca-key.pem -config=ca-config.json -profile=kubernetes admin-csr.json | cfssljson -bare admin
```
8. 创建 kube-proxy 证书
```bash
cat > kube-proxy-csr.json <<EOF
{
"CN": "system:kube-proxy",
"hosts": [],
"key": {
"algo": "rsa",
"size": 2048
},
"names": [
{
"C": "CN",
"ST": "BeiJing",
"L": "BeiJing",
"O": "k8s",
"OU": "System"
}
]
}
EOF
```
9. 生成 kube-proxy 客户端证书和私钥
```bash
cfssl gencert -ca=ca.pem -ca-key=ca-key.pem -config=ca-config.json -profile=kubernetes kube-proxy-csr.json | cfssljson -bare kube-proxy
```
10. 创建 kube-controller-manager 证书
```bash
cat > kube-controller-manager-csr.json <<EOF
{
"CN": "system:kube-controller-manager",
"hosts": [
"127.0.0.1",
"192.168.1.10",
"192.168.1.20",
"192.168.1.30"
],
"key": {
"algo": "rsa",
"size": 2048
},
"names": [
{
"C": "CN",
"ST": "BeiJing",
"L": "BeiJing",
"O": "system:kube-controller-manager",
"OU": "System"
}
]
}
EOF
```
11. 生成 kube-scheduler 客户端证书和私钥
```bash
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
```
12. 创建 kube-scheduler 证书
```bash
cat > kube-scheduler-csr.json <<EOF
{
"CN": "system:kube-scheduler",
"hosts": [
"127.0.0.1",
"192.168.1.10",
"192.168.1.20",
"192.168.1.30"
],
"key": {
"algo": "rsa",
"size": 2048
},
"names": [
{
"C": "CN",
"ST": "BeiJing",
"L": "BeiJing",
"O": "system:kube-scheduler",
"OU": "System"
}
]
}
EOF
```
13. 生成 kube-scheduler 客户端证书和私钥
```bash
cfssl gencert -ca=ca.pem -ca-key=ca-key.pem -config=ca-config.json -profile=kubernetes kube-scheduler-csr.json | cfssljson -bare kube-scheduler
```
14. 校验证书
- openssl 校验
```bash
openssl x509 -noout -text -in kubernetes.pem
```
- cfssl-certinfo 校验
```bash
cfssl-certinfo -cert kubernetes.pem
```
15. 分发证书
```bash
mkdir -p /etc/kubernetes/pki
cp *.pem /etc/kubernetes/pki
```
**使用证书的组件如下**
- etcd：使用 kubernetes-key.pem、kubernetes.pem
- kube-apiserver：使用 kubernetes-key.pem、kubernetes.pem
- kubelet：使用 ca.pem
- kube-proxy：使用 kube-proxy-key.pem、kube-proxy.pem
- kubectl：使用 dmin-key.pem、admin.pem
- kube-controller-manager：使用 kube-controller-manager-key.pem、kube-controller-manager.pem
- kube-scheduler ：使用 kube-scheduler-key.pem、kube-scheduler.pem

19
部署文档/网络插件安装/Calico网络插件安装.md Normal file
View File

@@ -0,0 +1,19 @@
> 本文作者：丁辉
# Calico网络插件安装
[Github官网](https://github.com/projectcalico/calico) [Github-Calico-Yaml文件](https://github.com/projectcalico/calico/blob/master/manifests/calico.yaml)
1. 最新版下载
```bash
wget https://docs.projectcalico.org/manifests/calico.yaml
```
2. 部署
```bash
kubectl apply -f calico.yaml
```

45
部署文档/网络插件安装/Flannel网络插件安装.md Normal file
View File

@@ -0,0 +1,45 @@
> 本文作者：丁辉
# Flannel网络插件安装
[Github软件包下载](https://github.com/flannel-io/flannel/releases) [Github-Flannel-Yaml文件](https://github.com/flannel-io/flannel/blob/master/Documentation/kube-flannel.yml)
## 开始部署
1. 最新版下载
```bash
wget https://raw.githubusercontent.com/coreos/flannel/master/Documentation/kube-flannel.yml
```
2. 部署
```bash
kubectl apply -f kube-flannel.yml
```
## 其他参数配置(可选步骤)
1. 编辑 Yaml 文件
```bash
vi kube-flannel.yml
```
2. 添加如下内容
```bash
containers:
- args:
- --ip-masq
- --kube-subnet-mgr
- --iface=eth0 #此参数指定网卡
```
**参数解释**
| 参数 | 解释 |
| :---------------: | :----------------------------------------------------------: |
| --ip-masq | 启用 IP masquerade 功能，允许从内部网络发送的数据包经过 NAT 转换，以伪装成外部网络的数据包，确保 Kubernetes Pod 可以与集群外部通信。 |
| --kube-subnet-mgr | 启用 Kubernetes 子网管理器，负责动态分配每个节点的 Pod CIDR（Pod的IP地址范围），以确保在整个集群中不会发生 IP 地址冲突。 |
| --iface=eth0 | 指定 flannel 使用的网络接口，这里设置为 eth0。flannel 将通过指定的网络接口与其他节点通信。您可能需要根据实际情况更改此参数以匹配正确的网络接口。 |