一只兔

Kubernetes基于containerd集群安装（CentOS）

Wed, 20 May 2026 00:00:00 GMT

Kubernetes 集群安装 SOP（基于 containerd）#

一、基础环境配置（所有节点执行）#

1.1 网卡与 Yum 源配置#

Terminal window

1
# 1. 配置网卡（编辑网卡配置文件，根据实际网卡名/IP 修改）
2
vi /etc/sysconfig/network-scripts/ifcfg-eth0
3
# 网卡配置模板（替换IP/Gateway等为实际值）
4
TYPE="Ethernet"
5
PROXY_METHOD="none"
6
BROWSER_ONLY="no"
7
BOOTPROTO="none"
8
DEFROUTE="yes"
9
IPV4_FAILURE_FATAL="no"
10
IPV6INIT="yes"
11
IPV6_AUTOCONF="yes"
12
IPV6_DEFROUTE="yes"
13
IPV6_FAILURE_FATAL="no"
14
NAME="eth0"
15
IPV6_ADDR_GEN_MODE="stable-privacy"
16
UUID="82444210-33b1-4a9d-9790-60770794e17a"
17
DEVICE="eth0"
18
ONBOOT="yes"
19
IPADDR="10.135.40.152"  # Master节点IP，Node节点替换为10.135.40.153
20
PREFIX="24"
21
GATEWAY="10.135.40.254"
22
DNS1="114.114.114.114"
23
IPV6_PRIVACY="no"
24

25
# 2. 重启网卡生效
26
service network restart
27

28
# 3. 备份并替换 Yum 源为阿里云
29
cd /etc/yum.repos.d/
30
mkdir backup
31
mv CentOS-*.repo backup/
32
curl -o /etc/yum.repos.d/CentOS-Base.repo https://mirrors.aliyun.com/repo/Centos-7.repo
33

34
# 4. 清理缓存并生成新缓存
35
yum clean all && yum makecache
36

37
# 5. 可选：安装 EPEL 扩展源
38
yum install -y epel-release

1.2 基础服务配置#

Terminal window

1
# 1. 安装并配置 SSH（优化连接问题）
2
yum install -y openssh-server
3
systemctl start sshd && systemctl enable sshd
4
sed -i 's/^#UseDNS yes/UseDNS no/' /etc/ssh/sshd_config
5
sed -i 's/^GSSAPIAuthentication yes/GSSAPIAuthentication no/' /etc/ssh/sshd_config
6
systemctl restart sshd
7

8
# 2. 永久禁用防火墙
9
systemctl stop firewalld && systemctl disable firewalld
10

11
# 3. 关闭 SELinux
12
setenforce 0
13
sed -i 's/enforcing/disabled/' /etc/selinux/config
14

15
# 4. 关闭 Swap（K8s 强制要求）
16
swapoff -a
17
sed -ri 's/.*swap.*/#&/' /etc/fstab
18

19
# 5. 设置主机名与 hosts 解析
20
# Master 节点
21
hostnamectl set-hostname k8smaster
22
# Node 节点
23
hostnamectl set-hostname k8snode1
24

25
# 所有节点配置 hosts
26
cat >> /etc/hosts << EOF
27
10.135.40.152 k8smaster
28
10.135.40.153 k8snode1
29
EOF

1.3 内核参数与网络转发配置#

Terminal window

1
# 1. 加载内核模块
2
cat <<EOF | sudo tee /etc/modules-load.d/k8s.conf
3
overlay
4
br_netfilter
5
EOF
6
sudo modprobe overlay
7
sudo modprobe br_netfilter
8

9
# 2. 设置内核参数（转发/桥接）
10
cat <<EOF | sudo tee /etc/sysctl.d/k8s.conf
11
net.bridge.bridge-nf-call-iptables  = 1
12
net.bridge.bridge-nf-call-ip6tables = 1
13
net.ipv4.ip_forward                 = 1
14
EOF
15

16
# 3. 生效配置
17
sudo sysctl --system

二、安装 Containerd 运行时（所有节点执行）#

Terminal window

1
# 1. 配置阿里云 Docker 源
2
yum-config-manager --add-repo http://mirrors.aliyun.com/docker-ce/linux/centos/docker-ce.repo
3
yum clean all && yum makecache
4

5
# 2. 安装 Containerd
6
yum install -y containerd.io
7

8
# 3. 生成并修改 Containerd 配置
9
mkdir -p /etc/containerd
10
containerd config default > /etc/containerd/config.toml
11

12
# 启用 SystemdCgroup（K8s 要求）
13
sed -i 's/SystemdCgroup = false/SystemdCgroup = true/' /etc/containerd/config.toml
14
# 替换 pause 镜像为阿里云源
15
sed -i 's|sandbox_image = "registry.k8s.io/pause:3.6"|sandbox_image = "registry.aliyuncs.com/google_containers/pause:3.9"|' /etc/containerd/config.toml
16

17
# 4. 配置容器镜像加速（适配国内网络）
18
# Docker Hub 加速
19
mkdir -p /etc/containerd/certs.d/docker.io
20
cat > /etc/containerd/certs.d/docker.io/hosts.toml <<'EOF'
21
server = "https://registry-1.docker.io"
22
[host."https://docker.1ms.run"]
23
  capabilities = ["pull", "resolve"]
24
[host."https://docker.1panel.live"]
25
  capabilities = ["pull", "resolve"]
26
[host."https://hub.rat.dev"]
27
  capabilities = ["pull", "resolve"]
28
[host."https://dockerproxy.net"]
29
  capabilities = ["pull", "resolve"]
30
[host."https://docker-registry.nmqu.com"]
31
  capabilities = ["pull", "resolve"]
32
EOF
33

34
# K8s 镜像加速
35
mkdir -p /etc/containerd/certs.d/registry.k8s.io
36
cat > /etc/containerd/certs.d/registry.k8s.io/hosts.toml <<'EOF'
37
server = "https://registry.k8s.io"
38
[host."https://registry.cn-hangzhou.aliyuncs.com/google_containers"]
39
  capabilities = ["pull", "resolve"]
40
[host."https://k8s.m.daocloud.io"]
41
  capabilities = ["pull", "resolve"]
42
EOF
43

44
# Quay.io 镜像加速
45
mkdir -p /etc/containerd/certs.d/quay.io
46
cat > /etc/containerd/certs.d/quay.io/hosts.toml <<'EOF'
47
server = "https://quay.io"
48
[host."https://quay.nju.edu.cn"]
49
  capabilities = ["pull", "resolve"]
50
[host."https://quay.1ms.run"]
51
  capabilities = ["pull", "resolve"]
52
EOF
53

54
# 5. 生效配置并重启 Containerd
55
sed -i 's#config_path =.*#config_path = "/etc/containerd/certs.d"#' /etc/containerd/config.toml
56
systemctl daemon-reload
57
systemctl restart containerd
58
systemctl enable containerd
59

60
# 6. 安装 crictl 工具（验证 Containerd）
61
VERSION="v1.30.0"
62
ARCH="amd64"
63
curl -sL https://ghproxy.net/https://github.com/kubernetes-sigs/cri-tools/releases/download/${VERSION}/crictl-${VERSION}-linux-${ARCH}.tar.gz | tar -xzf - -C /usr/local/bin
64

65
# 配置 crictl
66
cat <<EOF | tee /etc/crictl.yaml
67
runtime-endpoint: unix:///run/containerd/containerd.sock
68
image-endpoint: unix:///run/containerd/containerd.sock
69
timeout: 10
70
debug: false
71
EOF
72

73
# 7. 验证 Containerd 可用性
74
crictl info
75
# 验证镜像拉取（可选）
76
crictl pull registry.k8s.io/pause:3.10.1
77
crictl pull docker.io/library/nginx:alpine
78
crictl pull quay.io/prometheus/prometheus:v2.53.0

三、安装 K8s 组件（所有节点执行）#

Terminal window

1
# 1. 配置阿里云 K8s Yum 源
2
cat <<EOF > /etc/yum.repos.d/kubernetes.repo
3
[kubernetes]
4
name=Kubernetes
5
baseurl=https://mirrors.aliyun.com/kubernetes/yum/repos/kubernetes-el7-x86_64/
6
enabled=1
7
gpgcheck=0
8
EOF
9

10
# 2. 安装 K8s 组件（推荐 1.28.x 版本）
11
yum install -y kubelet kubeadm kubectl
12
systemctl enable kubelet

四、部署 K8s 集群#

4.1 初始化 Master 节点（仅 Master 执行）#

Terminal window

1
kubeadm init \
2
   --apiserver-advertise-address=10.135.40.152 \  # Master 节点 IP
3
   --image-repository registry.aliyuncs.com/google_containers \  # 阿里云镜像源
4
   --kubernetes-version v1.28.2 \  # K8s 版本
5
   --service-cidr=10.96.0.0/12 \  # 服务网段
6
   --pod-network-cidr=10.244.0.0/16  # Pod 网段（需与网络插件一致）
7

8
# 配置 kubectl 权限（普通用户）
9
mkdir -p $HOME/.kube
10
sudo cp -i /etc/kubernetes/admin.conf $HOME/.kube/config
11
sudo chown $(id -u):$(id -g) $HOME/.kube/config

4.2 Node 节点加入集群（仅 Node 执行）#

Terminal window

1
# 替换 <你的TOKEN> 和 <你的HASH> 为 Master 初始化后输出的内容
2
kubeadm join 10.135.40.152:6443 --token <你的TOKEN> \
3
    --discovery-token-ca-cert-hash sha256:<你的HASH>

4.3 安装 Calico 网络插件（仅 Master 执行）#

Terminal window

1
# 下载 Calico 配置文件
2
curl https://raw.githubusercontent.com/projectcalico/calico/v3.26.1/manifests/calico.yaml -O
3

4
# 修改 Pod 网段（与 init 时的 pod-network-cidr 一致）
5
sed -i '/^[[:space:]]*# - name: CALICO_IPV4POOL_CIDR/c\            - name: CALICO_IPV4POOL_CIDR' calico.yaml
6
sed -i '/^[[:space:]]*#   value: "192.168.0.0\/16"/c\              value: "10.244.0.0\/16"' calico.yaml
7

8
# 应用配置
9
kubectl apply -f calico.yaml
10

11
# 验证集群状态
12
kubectl get pods -n kube-system  # 所有 Pod 状态为 Running 则正常
13
kubectl get nodes  # 所有节点状态为 Ready 则正常

五、关键验证命令#

操作	命令
检查节点状态	kubectl get nodes
检查系统组件 Pod	kubectl get pods -n kube-system
检查 Containerd 状态	systemctl status containerd
检查 Kubelet 状态	systemctl status kubelet
验证镜像拉取	crictl pull registry.aliyuncs.com/google_containers/pause:3.9

六、注意事项#

所有操作建议以 root 用户执行，避免权限问题；
确保节点间网络互通（6443、8472 等端口需放行）；
生产环境建议关闭 root 直接 SSH 登录，改用普通用户 + sudo；
若镜像拉取失败，检查 Containerd 镜像加速配置是否生效；
K8s 版本与 Calico 版本需兼容（推荐 Calico v3.26+ 适配 K8s 1.28+）。

Kubernetes基于containerd集群安装（Ubuntu）

Sat, 21 Mar 2026 00:00:00 GMT

Kubernetes 集群安装 SOP（基于 containerd）#

1. 目的#

本文档为标准化操作流程（SOP），用于指导运维人员在 Linux 服务器上通过 kubeadm + containerd 方式安装 Kubernetes 集群，确保部署过程规范、可复用、可排查，最终完成以下目标：

初始化系统内核与网络参数，满足 K8s 运行前置要求
安装并配置 containerd 容器运行时，确保与 K8s 兼容
配置镜像加速，解决国内网络环境下镜像拉取慢、失败问题
安装 Kubernetes 核心组件（kubelet、kubeadm、kubectl）
完成 Master 节点初始化与 Node 节点加入，搭建集群架构
安装 Calico 网络插件，实现 Pod 网络通信
完成集群验证，确保组件正常运行、网络互通

2. 环境规划#

2.1 节点规划示例#

角色	主机名	IP 地址	备注
Master 节点	k8smaster	10.135.40.150	集群控制平面，1 台即可（生产环境建议高可用）
Node 节点	k8snode1	10.135.40.151	工作节点，负责运行 Pod
Node 节点	k8snode2	10.135.40.152	工作节点，负责运行 Pod
Node 节点	k8snode3	10.135.40.153	工作节点，负责运行 Pod

2.2 版本信息示例#

组件	版本	说明
Kubernetes	v1.34.6	稳定版，与 Calico v3.29.2 兼容
containerd	系统源默认版本	通过 apt 安装，便于维护升级
Calico	v3.29.2	CNI 网络插件，支持 Pod 网络通信
Pause 镜像	3.10	Pod Sandbox 基础镜像，适配国内镜像源

实际部署时，请确保 Kubernetes 版本、Pause 镜像版本、Calico 版本互相兼容，避免版本不匹配导致集群异常。

3. 前置条件#

在执行任何安装操作前，必须确保所有节点满足以下条件，否则会导致部署失败或集群异常：

时间同步：所有节点系统时间一致（误差不超过 1 分钟），建议配置 chrony 或 ntpd 时间同步服务。
网络互通：所有节点之间（Master 与 Node、Node 与 Node）网络互通，无防火墙/安全组拦截。
主机解析：所有节点可通过主机名互相解析，可通过配置 /etc/hosts 或企业 DNS 实现。
权限要求：所有节点具备 root 权限或 sudo 权限（执行命令时需加 sudo）。
端口放行：防火墙、安全组、云厂商 ACL 已放通 K8s 所需端口（详见附录）。
Swap 关闭：所有节点已关闭 Swap，K8s 要求必须关闭 Swap 否则 kubelet 无法正常运行。

4. 安装范围说明#

为提高部署效率，明确各节点执行范围，按节点角色划分操作步骤，避免重复操作：

4.1 所有节点（Master + Node）必执行#

系统初始化（关闭 Swap、加载内核模块、配置网络参数）
安装并配置 containerd 容器运行时
配置镜像加速（解决国内网络拉取镜像问题）
安装 kubelet、kubeadm、kubectl 组件
设置主机名与 hosts 解析

4.2 仅 Master 节点执行#

执行 kubeadm init 初始化控制平面
配置 kubectl 命令行工具
安装 Calico 网络插件
生成 Node 节点加入集群的 kubeadm join 命令

4.3 仅 Node 节点执行#

执行 Master 节点生成的 kubeadm join 命令，加入集群

5. 系统初始化（所有节点执行）#

系统初始化是 K8s 部署的基础，所有节点必须严格执行，每一步均需验证是否成功。

5.1 关闭 Swap（必须执行）#

执行以下命令，立即关闭 Swap 并禁止开机自动启用：

Terminal window

1
swapoff -a
2
sed -i '/^\/swap.img/s/^/# /' /etc/fstab

说明#

swapoff -a：立即关闭当前系统的 Swap 分区，无需重启。
sed -i ...：注释 /etc/fstab 中 Swap 相关配置，防止重启后 Swap 自动启用。

验证方式#

Terminal window

1
free -h
2
swapon --show

若 swapon --show 无任何输出，说明 Swap 已成功关闭。

5.2 加载内核模块#

K8s 依赖overlay 和 br_netfilter 两个内核模块，执行以下命令加载并设置开机自动加载：

Terminal window

1
cat <<EOF | sudo tee /etc/modules-load.d/k8s.conf
2
overlay
3
br_netfilter
4
EOF
5

6
sysctl --system

说明#

overlay：容器镜像与容器文件系统的核心依赖模块，支持分层存储。
br_netfilter：使 Linux bridge 流量能够被 iptables 处理，是 K8s CNI 网络的基础。

验证方式#

Terminal window

1
lsmod | grep overlay
2
lsmod | grep br_netfilter

若两条命令均有输出，说明内核模块加载成功。

5.3 配置内核网络参数#

配置 K8s 所需的内核网络参数，确保网络转发、桥接流量正常：

Terminal window

1
# 1. 写入配置
2
cat <<EOF | sudo tee /etc/sysctl.d/k8s.conf
3
net.bridge.bridge-nf-call-iptables  = 1
4
net.bridge.bridge-nf-call-ip6tables = 1
5
net.ipv4.ip_forward                 = 1
6
EOF
7

8
# 2. 加载内核模块
9
modprobe overlay
10
modprobe br_netfilter
11

12
# 3. 让配置生效（关键！你之前少了这一步！）
13
sysctl --system

说明#

net.bridge.bridge-nf-call-iptables = 1：让桥接流量进入 iptables 规则，实现网络策略控制。
net.bridge.bridge-nf-call-ip6tables = 1：支持 IPv6 桥接流量，适配未来扩展。
net.ipv4.ip_forward = 1：启用 IPv4 转发，是 Pod 之间、Pod 与外部网络通信的必要条件。

验证方式#

Terminal window

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

三条命令的输出结果均为 1，说明内核网络参数配置成功。

5.4 安装ipvs#

Terminal window

1
apt install -y ipset ipvsadm
2

3
# 配置ipvsadm的模块，这些都是算法模块，目的是为了让开机自动加载
4
cat << EOF | tee /etc/modules-load.d/ipvs.conf
5
ip_vs
6
ip_vs_rr
7
ip_VS_wrr
8
ip_vs_sh
9
nf_conntrack
10
EOF
11

12
# 编写脚本自动加载
13
cat << EOF | tee ipvs.sh
14
#!/bin/sh
15
modprobe -- ip_vs
16
modprobe -- ip_vs_rr
17
modprobe -- ip_vs_wrr
18
modprobe -- ip_vs_sh
19
modprobe -- nf_conntrack
20
EOF
21

22
sh ipvs.sh
23
# 验证脚本是否生效
24
lsmod | grep ip_vs

6. 安装与配置 containerd（所有节点执行）#

containerd 是 K8s 官方推荐的容器运行时，替代传统 Docker 运行时，步骤如下：

6.1 安装 containerd#

通过系统包管理器 apt 安装，操作简单且便于后续维护升级：

Terminal window

1
apt update && apt install -y containerd

6.2 生成默认配置文件#

生成 containerd 的默认配置文件，便于后续修改镜像源、cgroup 驱动等参数：

Terminal window

1
mkdir -p /etc/containerd
2
containerd config default | tee /etc/containerd/config.toml

说明#

若不生成显式配置文件，containerd 会使用内置默认值运行，不利于统一管理和问题排查。

6.3 修改 cgroup 驱动（关键步骤）#

kubeadm 推荐 containerd 与 kubelet 使用一致的 systemd cgroup 驱动，否则会导致 kubelet 启动失败：

Terminal window

1
sed -i 's/SystemdCgroup = false/SystemdCgroup = true/' /etc/containerd/config.toml

验证方式#

Terminal window

1
grep SystemdCgroup /etc/containerd/config.toml

预期输出：SystemdCgroup = true，说明修改成功。

6.4 配置 Pause 镜像（国内环境推荐）#

Pause 镜像是 Pod Sandbox 基础镜像，每个 Pod 启动前都会拉取，默认从 registry.k8s.io 拉取，国内网络可能失败，建议替换为阿里云镜像：

Terminal window

1
sed -i "s#sandbox = 'registry.k8s.io/pause:.*'#sandbox = 'registry.aliyuncs.com/google_containers/pause:3.10'#" /etc/containerd/config.toml

验证方式#

Terminal window

1
grep sandbox /etc/containerd/config.toml

预期输出包含 registry.aliyuncs.com/google_containers/pause:3.10，说明配置成功。

7. 配置 containerd 镜像加速（所有节点执行）#

国内网络环境下，直接拉取 Docker Hub、K8s 官方镜像速度慢、易超时，需配置镜像加速，确保镜像拉取成功。

7.1 配置 Docker Hub 加速#

使用毫秒镜像（https://docker.1ms.run）加速 Docker Hub 镜像拉取：

Terminal window

1
mkdir -p /etc/containerd/certs.d/docker.io

创建加速配置文件 /etc/containerd/certs.d/docker.io/hosts.toml，内容如下：

1
cat > /etc/containerd/certs.d/docker.io/hosts.toml <<'EOF'
2
server = "https://registry-1.docker.io"
3
[host."https://docker.1ms.run"]
4
  capabilities = ["pull", "resolve"]
5
[host."https://docker.1panel.live"]
6
  capabilities = ["pull", "resolve"]
7
[host."https://hub.rat.dev"]
8
  capabilities = ["pull", "resolve"]
9
[host."https://dockerproxy.net"]
10
  capabilities = ["pull", "resolve"]
11
[host."https://docker-registry.nmqu.com"]
12
  capabilities = ["pull", "resolve"]
13
EOF

说明#

毫秒镜像是国内专业的 Docker 镜像加速平台，下载速度可提升 10 倍以上，基础服务永久免费，稳定可靠。

7.2 配置 K8s 官方镜像仓库加速#

K8s 官方镜像默认从 registry.k8s.io 拉取，配置阿里云镜像源加速：

Terminal window

1
mkdir -p /etc/containerd/certs.d/registry.k8s.io

创建加速配置文件 /etc/containerd/certs.d/registry.k8s.io/hosts.toml，内容如下：

1
cat > /etc/containerd/certs.d/registry.k8s.io/hosts.toml <<'EOF'
2
server = "https://registry.k8s.io"
3
[host."https://registry.cn-hangzhou.aliyuncs.com/google_containers"]
4
  capabilities = ["pull", "resolve"]
5
[host."https://k8s.m.daocloud.io"]
6
  capabilities = ["pull", "resolve"]
7
EOF

7.3 配置 quay.io 加速（可选）#

若需拉取 quay.io 镜像（如 Prometheus、Grafana 等），可预先创建目录，后续按需添加加速配置：

Terminal window

1
mkdir -p /etc/containerd/certs.d/quay.io

创建加速配置文件 /etc/containerd/certs.d/registry.k8s.io/hosts.toml，内容如下：

Terminal window

1
cat > /etc/containerd/certs.d/quay.io/hosts.toml <<'EOF'
2
server = "https://quay.io"
3
[host."https://quay.nju.edu.cn"]
4
  capabilities = ["pull", "resolve"]
5
[host."https://quay.1ms.run"]
6
  capabilities = ["pull", "resolve"]
7
EOF

7.4 启用 certs.d 配置目录#

修改 containerd 配置，告诉 containerd 从 /etc/containerd/certs.d 读取镜像加速配置，否则前面的加速配置不生效：

Terminal window

1
sed -i 's#config_path =.*#config_path = "/etc/containerd/certs.d"#' /etc/containerd/config.toml

验证方式#

Terminal window

1
grep config_path /etc/containerd/config.toml

预期输出：config_path = "/etc/containerd/certs.d"，说明启用成功。

7.5 重启 containerd 并设置开机自启#

配置修改后，重启 containerd 使配置生效，并设置开机自启，确保服务器重启后正常运行：

Terminal window

1
systemctl daemon-reload
2
systemctl restart containerd
3
systemctl enable containerd

验证方式#

Terminal window

1
systemctl status containerd

预期状态为 active (running)，说明 containerd 启动成功。

8. 镜像拉取测试（所有节点执行）#

镜像拉取是集群部署的关键前提，建议必须执行测试，确保各镜像仓库可正常拉取：

Terminal window

1
# 1. 定义版本（建议与 K8s 版本一致，如 v1.30.3）
2
VERSION="v1.34.6"
3
ARCH="amd64"
4

5
# 2. 下载并解压到 /usr/local/bin
6
curl -sL "https://github.com/kubernetes-sigs/cri-tools/releases/download/${VERSION}/crictl-${VERSION}-linux-${ARCH}.tar.gz" \
7
  | tar -xzf - -C /usr/local/bin
8

9
# 3. 验证
10
crictl --version
11

12
crictl pull registry.k8s.io/pause:3.10.1
13
crictl pull docker.io/library/nginx:alpine
14
crictl pull quay.io/prometheus/prometheus:v2.53.0

说明#

该测试分别验证以下 3 个常用镜像仓库的拉取能力，确保后续集群部署无镜像拉取问题：

registry.k8s.io：K8s 官方镜像仓库
docker.io：Docker Hub 官方仓库
quay.io：常用开源组件镜像仓库

若拉取失败，通常原因：加速配置未生效、网络不通、DNS 异常、crictl 未配置运行时端点。

补充 crictl 配置（可选）#

若系统未配置 crictl，执行以下命令配置，确保 crictl 能正常连接 containerd：

Terminal window

1
cat <<EOF | tee /etc/crictl.yaml
2
runtime-endpoint: unix:///run/containerd/containerd.sock
3
image-endpoint: unix:///run/containerd/containerd.sock
4
timeout: 10
5
debug: false
6
EOF

验证方式#

Terminal window

1
crictl info

若输出 containerd 相关信息，说明 crictl 配置成功。

9. 安装 Kubernetes 组件（所有节点执行）#

安装 K8s 核心组件 kubelet、kubeadm、kubectl，三者版本需保持一致，避免兼容性问题。

9.1 安装依赖包#

安装 HTTPS 软件源、密钥管理相关依赖，用于添加 K8s 官方软件源：

Terminal window

1
apt-get install -y apt-transport-https ca-certificates curl gpg

9.2 添加 K8s 官方软件源#

添加 K8s 官方稳定版软件源，确保组件版本最新且稳定：

Terminal window

1
# 如果 `/etc/apt/keyrings` 目录不存在，则应在 curl 命令之前创建它，请阅读下面的注释。
2
# sudo mkdir -p -m 755 /etc/apt/keyrings
3
curl -fsSL https://pkgs.k8s.io/core:/stable:/v1.34/deb/Release.key | sudo gpg --dearmor -o /etc/apt/keyrings/kubernetes-apt-keyring.gpg
4

5
# 此操作会覆盖 /etc/apt/sources.list.d/kubernetes.list 中现存的所有配置。
6
echo 'deb [signed-by=/etc/apt/keyrings/kubernetes-apt-keyring.gpg] https://pkgs.k8s.io/core:/stable:/v1.34/deb/ /' | sudo tee /etc/apt/sources.list.d/kubernetes.list

说明#

该软件源为 K8s 官方新源，替代旧源，建议所有节点统一使用该源，避免版本不一致。

9.3 安装 kubelet、kubeadm、kubectl#

Terminal window

1
apt-get update
2
apt-get install -y kubelet kubeadm kubectl

组件说明#

kubelet：节点代理，运行在每个节点上，负责 Pod 生命周期管理、与 Master 节点通信。
kubeadm：集群初始化工具，用于初始化 Master 节点、将 Node 节点加入集群。
kubectl：K8s 命令行管理工具，用于操作集群、查看集群状态、管理资源。

9.4 锁定版本（关键）#

锁定组件版本，防止系统自动升级导致 Master 与 Node 版本不一致、组件不兼容：

Terminal window

1
apt-mark hold kubelet kubeadm kubectl

9.5 启动 kubelet 并设置开机自启#

Terminal window

1
systemctl enable --now kubelet

说明#

安装后 kubelet 可能处于“不断重启”状态，这是正常现象——因为此时尚未执行 kubeadm init，kubelet 未拿到集群配置。

验证方式#

Terminal window

1
systemctl status kubelet

只要 kubelet 处于“active”状态（即使重启），即说明启动成功。

10. 主机配置（所有节点执行）#

配置主机名和 hosts 解析，确保节点之间可通过主机名互相访问，便于集群管理和通信。

10.1 设置主机名#

根据节点角色，分别设置唯一的主机名（每台节点主机名不可重复）：

Master 节点#

Terminal window

1
hostnamectl set-hostname k8smaster
2
hostnamectl set-hostname k8snode1
3
hostnamectl set-hostname k8snode2
4
hostnamectl set-hostname k8snode3

10.2 配置 hosts 解析#

在所有节点执行以下命令，添加 hosts 解析（替换 IP 为实际节点 IP）：

Terminal window

1
cat >> /etc/hosts << EOF
2
10.135.40.150 k8smaster
3
10.135.40.151 k8snode1
4
10.135.40.152 k8snode2
5
10.135.40.153 k8snode3
6
EOF

说明#

若企业已有统一 DNS 服务器，且能解析所有节点主机名，可无需手工修改 /etc/hosts。

验证方式#

Terminal window

1
ping -c 1 k8smaster
2
ping -c 1 k8snode1

若 ping 能正常通，说明 hosts 解析配置成功。

11. 初始化 Master 节点（仅 Master 节点执行）#

Master 节点是集群的控制平面，执行 kubeadm init 命令完成初始化，步骤如下：

Terminal window

1
kubeadm init \
2
  --apiserver-advertise-address=10.135.40.150 \
3
  --kubernetes-version v1.34.6 \
4
  --service-cidr=10.96.0.0/12 \
5
  --pod-network-cidr=10.244.0.0/16 \
6
  --image-repository registry.aliyuncs.com/google_containers \
7
  --cri-socket unix:///var/run/containerd/containerd.sock

11.1 参数说明#

参数	说明
`--apiserver-advertise-address=10.135.40.150`	指定 API Server 对外通告地址，填写 Master 节点实际 IP（不可用 localhost 或 127.0.0.1）
`--kubernetes-version v1.34.6`	指定安装的 K8s 版本，与前面安装的 kubelet 版本一致
`--service-cidr=10.96.0.0/12`	指定 Service 网段，默认规划即可，无需修改
`--pod-network-cidr=10.244.0.0/16`	指定 Pod 网段，必须与后续 Calico 插件配置的网段一致
`--image-repository registry.aliyuncs.com/google_containers`	使用阿里云镜像源，加速 K8s 基础镜像拉取（国内环境必加）
`--cri-socket unix:///var/run/containerd/containerd.sock`	指定使用 containerd 作为容器运行时，与前面配置一致

11.2 初始化成功标志#

初始化成功后，命令输出末尾会出现以下内容，说明 Master 节点初始化完成：

提示信息：Your Kubernetes control-plane has initialized successfully!
一段完整的 kubeadm join 命令（用于 Node 节点加入集群）

重要：请务必保存这段 kubeadm join 命令，后续 Node 节点加入集群时必须使用，丢失后需重新生成。

12. 配置 kubectl（仅 Master 节点执行）#

Master 节点初始化完成后，需配置 kubectl 命令行工具，才能正常操作集群：

Terminal window

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

说明#

/etc/kubernetes/admin.conf 是集群管理员配置文件，复制到当前用户目录后，kubectl 才能读取集群配置，实现集群管理。

验证方式#

Terminal window

1
kubectl get nodes

此时输出 Master 节点信息，但状态为NotReady，属于正常现象——因为尚未安装网络插件。

13. Node 节点加入集群（仅 Node 节点执行）#

使用 Master 节点初始化完成后输出的 kubeadm join 命令，在每个 Node 节点分别执行，加入集群：

Terminal window

1
kubeadm join 10.135.40.150:6443 \
2
  --token <token> \
3
  --discovery-token-ca-cert-hash sha256:<hash>

说明#

--token：用于 Node 节点与 Master 节点认证，由 Master 初始化时自动生成。
--discovery-token-ca-cert-hash：用于校验 API Server CA 证书指纹，确保通信安全。

验证方式#

在 Master 节点执行以下命令，查看 Node 节点是否成功加入：

Terminal window

1
kubectl get nodes

若能看到所有 Node 节点，但状态为 NotReady，说明节点已成功加入，等待安装网络插件后即可变为 Ready。

补充：重新生成 join 命令#

若丢失 join 命令，在 Master 节点执行以下命令重新生成：

Terminal window

1
kubeadm token create --print-join-command

14. 安装网络插件（Calico）（仅 Master 节点执行）#

网络插件是 Pod 之间、Pod 与外部网络通信的核心，本文选用 Calico（主流、稳定、易用），版本为 v3.29.2。

14.1 安装 Calico Operator#

Calico Operator 用于统一管理 Calico 组件，执行以下命令安装：

Terminal window

1
kubectl create -f https://raw.githubusercontent.com/projectcalico/calico/v3.29.2/manifests/tigera-operator.yaml

14.2 下载自定义资源配置#

Terminal window

1
wget https://raw.githubusercontent.com/projectcalico/calico/v3.29.2/manifests/custom-resources.yaml

14.3 修改 Pod 网段（关键）#

编辑 custom-resources.yaml 文件，将其中的 Pod 网段修改为与 kubeadm init 中一致的 10.244.0.0/16：

1
# 编辑文件
2
vim custom-resources.yaml
3

4
# 修改内容（找到以下配置，修改 cidr 值）
5
spec:
6
  calicoNetwork:
7
    ipPools:
8
    - blockSize: 26
9
      cidr: 10.244.0.0/16  # 必须与 --pod-network-cidr 一致
10
      encapsulation: VXLANCrossSubnet
11
      natOutgoing: Enabled
12
      nodeSelector: all()

说明#

Pod 网段必须与 kubeadm init 中的 --pod-network-cidr=10.244.0.0/16 完全一致，否则 Pod 网络无法正常通信。

14.4 应用配置#

Terminal window

1
kubectl create -f custom-resources.yaml

14.5 查看 Calico 状态#

执行以下命令，监控 Calico 组件启动状态，等待所有 Pod 进入 Running 状态：

Terminal window

1
watch kubectl get pod -n calico-system

说明#

Calico 组件启动需要 1-5 分钟，若 Pod 长时间未就绪，需检查：镜像拉取是否成功、节点网络是否正常、DNS 配置是否正确。

按Ctrl + C 可退出监控模式。

15. 集群安装完成验证#

Calico 安装完成后，集群部署基本完成，执行以下验证步骤，确认集群正常可用：

15.1 查看节点状态#

Terminal window

1
kubectl get nodes

期望结果#

所有节点（Master + Node）状态均为 Ready，示例如下：

Terminal window

1
NAME         STATUS   ROLES           AGE   VERSION
2
k8smaster    Ready    control-plane   10m   v1.34.6
3
k8snode1     Ready    <none>          5m    v1.34.6
4
k8snode2     Ready    <none>          5m    v1.34.6
5
k8snode3     Ready    <none>          5m    v1.34.6

15.2 查看系统 Pod 状态#

Terminal window

1
kubectl get pod -A

期望结果#

kube-system 命名空间下，所有核心 Pod（kube-apiserver、kube-controller-manager、kube-scheduler、etcd）均为 Running。
calico-system 命名空间下，所有 Calico 相关 Pod 均为 Running。

15.3 查看集群信息#

Terminal window

1
kubectl cluster-info

期望结果#

输出 API Server 地址、CoreDNS 地址等信息，说明集群控制平面正常运行。

15.4 测试 Pod 调度（可选）#

创建一个测试 Pod，验证集群是否能正常调度和运行：

Terminal window

1
kubectl run test-pod --image=nginx:alpine
2
kubectl get pod
3

4
cat<<EOF | kubectl apply -f -
5
apiVersion: v1
6
kind: Pod
7
metadata:
8
  name: busybox
9
spec:
10
  containers:
11
  - name: busybox
12
    image: docker.m.daocloud.io/library/busybox:1.28
13
    command: ["sleep","3600"]
14
EOF
15

16
kubectl get po
17
NAME      READY   STATUS    RESTARTS   AGE
18
busybox   1/1     Running   0          3s
19

20
kubectl get svc
21
NAME         TYPE        CLUSTER-IP   EXTERNAL-IP   PORT(S)   AGE
22
kubernetes   ClusterIP   10.96.0.1    <none>        443/TCP   23h
23

24
# 验证集群是否内部可通讯
25
kubectl exec busybox -n default -- nslookup kubernetes
26
Server:    10.96.0.10
27
Address 1: 10.96.0.10 kube-dns.kube-system.svc.cluster.local
28

29
Name:      kubernetes
30
Address 1: 10.96.0.1 kubernetes.default.svc.cluster.local

期望结果#

test-pod 状态为 Running，说明 Pod 调度正常，集群可正常使用。

删除测试 Pod：kubectl delete pod busybox

K8s 高可用集群搭建

Fri, 20 Mar 2026 00:00:00 GMT

🚀 Ubuntu 三节点 K8s 高可用集群搭建 SOP#

📑 节点规划#

角色	主机名	IP 示例	硬件建议
控制节点	`k8smaster`	10.135.40.150	4C 8G
工作节点 1	`k8snode1`	10.135.40.151	8C 16G
工作节点 2	`k8snode2`	10.135.40.152	8C 16G
工作节点 3	`k8snode3`	10.135.40.153	8C 16G

🛠️ 第一阶段：系统基础环境配置（所有 3 台机器执行）#

在安装 K8s 之前，必须先将 Linux 宿主机的环境调教到最佳状态。

1.设置主机名与 Host 解析#

Terminal window

1
# 在各自机器上分别设置主机名（以 master 为例）
2
sudo hostnamectl set-hostname k8smaster
3
sudo hostnamectl set-hostname k8snode1
4
sudo hostnamectl set-hostname k8snode2
5
sudo hostnamectl set-hostname k8snode3
6

7
# 在所有机器的 /etc/hosts 追加以下内容，打通内网解析
8
cat <<EOF | sudo tee -a /etc/hosts
9
10.135.40.150 k8smaster
10
10.135.40.151 k8snode1
11
10.135.40.152 k8snode2
12
10.135.40.153 k8snode3
13
EOF

2.关闭 Swap 交换分区（K8s 强依赖）#

Terminal window

1
sudo swapoff -a
2
sudo sed -i '/ swap / s/^\(.*\)$/#\1/g' /etc/fstab
3

4
# ubuntu系统
5
# 1. 在 fstab 中注释掉 swap 行
6
vim /etc/fstab
7
# /swap.img       none    swap    sw      0       0
8

9
# 2. 删除 swap 文件释放空间
10
rm /swap.img
11

12
# 3.验证 swap 已关闭
13
free -h
14
swapon --show
15
cat /proc/swaps

3.配置内核路由转发与网桥过滤#

Terminal window

1
cat << EOF | tee /etc/sysctl.d/k8s.conf
2
net.bridge.bridge-nf-call-ip6tables = 1
3
net.bridge.bridge-nf-call-iptables = 1
4
net.ipv4.ip_forward = 1
5
EOF
6

7
sudo modprobe overlay
8
sudo modprobe br_netfilter
9

10
cat << EOF | tee /etc/modules-load.d/k8s.conf
11
overlay
12
br_netfilter
13
EOF
14

15
sudo sysctl --system
16

17
apt install -y ipset ipvsadm
18

19
cat << EOF | tee /etc/modules-load.d/ipvs.conf
20
ip_vs
21
ip_vs_rr
22
ip_VS_wrr
23
ip_vs_sh
24
nf_conntrack
25
EOF
26

27
cat << EOF | tee ipvs.sh
28
#!/bin/sh
29
modprobe -- ip_vs
30
modprobe -- ip_vs_rr
31
modprobe -- ip_vs_wrr
32
modprobe -- ip_vs_sh
33
modprobe -- nf_conntrack
34
EOF
35

36
# 验证脚本是否生效
37
sh ipvs.sh
38
lsmod | grep ip_vs

4.配置时间同步#

Terminal window

1
timedatectl set-timezone Asia/Shanghai
2

3
# 安装ntpdate并与阿里云同步
4
apt install -y ntpsec-ntpdate
5
ntpdate ntp.aliyun.com
6

7
# 配置自动同步
8
crontab -e
9
0 0 * * * ntpdate ntp.aliyun.com

🐳 第二阶段：安装容器运行时与 K8s 组件（所有 3 台机器执行）#

1.安装 Docker Engine 容器引擎#

Terminal window

1
sudo apt-get update
2
sudo apt-get install ca-certificates curl
3
sudo install -m 0755 -d /etc/apt/keyrings
4
sudo curl -fsSL https://download.docker.com/linux/ubuntu/gpg -o /etc/apt/keyrings/docker.asc
5
sudo chmod a+r /etc/apt/keyrings/docker.asc
6

7
echo \
8
  "deb [arch=$(dpkg --print-architecture) signed-by=/etc/apt/keyrings/docker.asc] https://download.docker.com/linux/ubuntu \
9
  $(. /etc/os-release && echo "${UBUNTU_CODENAME:-$VERSION_CODENAME}") stable" | \
10
  sudo tee /etc/apt/sources.list.d/docker.list > /dev/null
11
sudo apt-get update
12

13
# 安装最新版docker
14
sudo apt-get install docker-ce docker-ce-cli containerd.io docker-buildx-plugin docker-compose-plugin
15

16
# 使用 docker --version 检查
17

18

19
# 配置 Docker 使用 systemd 作为 cgroup 驱动（K8s 推荐规范）
20
cat <<EOF | sudo tee /etc/docker/daemon.json
21
{
22
  "registry-mirrors": [
23
    "https://docker.1ms.run",
24
    "https://doublezonline.cloud",
25
    "https://dislabaiot.xyz",
26
    "https://docker.fxxk.dedyn.io",
27
    "https://dockerpull.org",
28
    "https://docker.unsee.tech",
29
    "https://hub.rat.dev",
30
    "https://docker.1panel.live",
31
    "https://docker.nastool.de",
32
    "https://docker.zhai.cm",
33
    "https://docker.5z5f.com",
34
    "https://a.ussh.net",
35
    "https://docker.udayun.com",
36
    "https://hub.geekery.cn"
37
  ],
38
  "insecure-registries": ["kubernetes-register.sswang.com"],
39
  "exec-opts": [
40
    "native.cgroupdriver=systemd"
41
  ]
42
}
43
EOF
44

45
sudo systemctl enable docker
46
sudo systemctl daemon-reload
47
sudo systemctl restart docker

2.安装 `cri-dockerd`（让 K8s 认出 Docker 的关键）#

Terminal window

1
# 下载对应的 deb 安装包 (以 v0.3.4 为例)
2
wget https://github.com/Mirantis/cri-dockerd/releases/download/v0.3.16/cri-dockerd_0.3.16.3-0.ubuntu-jammy_amd64.deb
3

4
# 解压
5
tar xf cri-dockerd-0.3.16.amd64.tgz
6
cp -r cri-dockerd/cri-dockerd /usr/local/bin/
7
cp -r cri-dockerd/cri-dockerd /usr/bin/
8

9
# 查看版本号
10
cri-dockerd --version
11

12
# 设置开机启动脚本，创建文件 /etc/systemd/system/cri-dockerd.service ，写入如下内容（完全复制即可）
13
cat > /etc/systemd/system/cri-dockerd.service<<-EOF
14
[Unit]
15
Description=CRI Interface for Docker Application Container Engine
16
Documentation=https://docs.mirantis.com
17
After=network-online.target firewalld.service docker.service
18
Wants=network-online.target
19
Requires=cri-docker.socket     #system cri-docker.socket  文件名
20

21
[Service]
22
Type=notify
23
ExecStart=/usr/local/bin/cri-dockerd --pod-infra-container-image=registry.cn-hangzhou.aliyuncs.com/google_containers/pause:3.10
24
 --network-plugin=cni --cni-conf-dir=/etc/cni/net.d --cni-bin-dir=/opt/cni/bin --container-runtime-endpoint=unix:///var/run/cri-dockerd.sock --cri-dockerd-root-directory=/var/lib/dockershim --docker-endpoint=unix:///var/run/docker.sock --cri-dockerd-root-directory=/var/lib/docker
25
ExecReload=/bin/kill -s HUP $MAINPID
26
TimeoutSec=0
27
RestartSec=2
28
Restart=always
29
StartLimitBurst=3
30
StartLimitInterval=60s
31
LimitNOFILE=infinity
32
LimitNPROC=infinity
33
LimitCORE=infinity
34
TasksMax=infinity
35
Delegate=yes
36
KillMode=process
37
[Install]
38
WantedBy=multi-user.target
39
EOF
40

41
# 创建 /etc/systemd/system/cri-docker.socket 文件，并写入如下内容
42
cat > /etc/systemd/system/cri-docker.socket <<-EOF
43
[Unit]
44
Description=CRI Docker Socket for the API
45
PartOf=cri-docker.service    #systemd cri-docker.servics 文件名
46

47
[Socket]
48
ListenStream=/var/run/cri-dockerd.sock
49
SocketMode=0660
50
SocketUser=root
51
SocketGroup=docker
52

53
[Install]
54
WantedBy=sockets.target
55
EOF
56

57
# 启动服务
58
sudo systemctl daemon-reload
59
sudo systemctl enable cri-docker.service
60
sudo systemctl start cri-docker.service
61

62
# 验证启动信息
63
root@master:/opt# ls  /var/run | grep docker
64
cri-dockerd.sock
65
docker
66
docker.pid
67
docker.sock

3.安装 Kubeadm, Kubelet 和 Kubectl（使用阿里云镜像加速）#

Terminal window

1
sudo apt-get update
2
sudo apt-get install -y apt-transport-https ca-certificates curl gpg
3

4
# 下载阿里云 GPG 密钥（二选一）
5
1、curl -fsSL https://mirrors.aliyun.com/kubernetes/apt/doc/apt-key.gpg | sudo gpg --dearmor -o /etc/apt/keyrings/kubernetes-archive-keyring.gpg
6
2、curl -fsSL https://pkgs.k8s.io/core:/stable:/v1.32/deb/Release.key | sudo gpg --dearmor -o /etc/apt/keyrings/kubernetes-apt-keyring.gpg
7

8

9
# 添加阿里云 K8s 软件源
10
echo "deb [signed-by=/etc/apt/keyrings/kubernetes-archive-keyring.gpg] https://mirrors.aliyun.com/kubernetes/apt/ kubernetes-xenial main" | sudo tee /etc/apt/sources.list.d/kubernetes.list
11

12
# 安装组件（锁定版本防止意外升级）
13
sudo apt-get update
14
sudo apt-cache policy kubeadm
15
sudo apt-get install -y kubelet kubeadm kubectl
16
sudo apt-mark hold kubelet kubeadm kubectl
17

18
# 配置kubelet（进入文件kubelet，1.30版本之后都是在 /etc/default/kubelet配置）
19
vim /etc/default/kubelet
20
KUBELET_EXTRA_ARGS="--cgroup-driver=systemd"
21
systemctl enable kubelet

👑 第三阶段：初始化 Master 节点（仅在 k8smaster 执行）#

1.在 Master 节点上执行初始化。#

注意：因为我们用的是 Docker，必须通过 --cri-socket 明确告诉 K8s 去找 cri-dockerd！

Terminal window

1
# 执行初始化
2
sudo kubeadm init \
3
--kubernetes-version=1.32.13 \
4
--control-plane-endpoint=k8smaster \
5
--apiserver-advertise-address=10.135.40.150 \
6
--image-repository registry.aliyuncs.com/google_containers \
7
--pod-network-cidr=10.244.0.0/16 \
8
--service-cidr=10.96.0.0/12 \
9
--cri-socket unix:///var/run/cri-dockerd.sock \
10
--upload-certs \
11
--v=9

根据自己的ip设置好参数后，在master！注意是master节点，上执行`kubeadm init`命令。可能会需要一两分钟下载镜像，执行完毕后输出如下：#

Terminal window

1
规划pod/service网段，这两个网段和宿主机网段不能重复！原则只有一个：三个网段不重复，没有交叉即可！
2

3
- 宿主机网段：前面已经规划过。即：192.168.31.0/24
4
- service网段：10.96.0.0/12
5
- pod网段：10.244.0.0/16
6

7
kubernetes-version：指定k8s的版本，我这里是1.32.2，你的也许是1.31.1-1.1等
8
control-plane-endpoint：可以理解为集群master的命名，随意写即可
9
apiserver-advertise-address：集群中master的地址！注意不要抄，写你自己虚拟机的ip地址
10
pod-network-cidr：pod网段地址
11
service-cidr：service网段地址
12
image-repository：指定使用国内镜像
13
cri-socket：指定使用的容器运行时，如果你使用的containerd容器，那就不用写这个参数
14
v：日志级别，9表示输出的信息会很详细

2.初始化成功后，配置普通用户的 kubectl 权限：#

Terminal window

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

⚠️ 保存终端最后输出的 `kubeadm join ...` 命令，下一步要用！#

3.安装网络插件（👑 仅 k8s master 执行）#

K8s 需要网络插件才能让 Pod 互相通信。这里使用最简单稳定的 calico。#

Terminal window

1
# master节点上安装官方插件
2
kubectl create -f https://raw.githubusercontent.com/projectcalico/calico/v3.29.2/manifests/tigera-operator.yaml
3

4
# 下载配置文件
5
wget  https://raw.githubusercontent.com/projectcalico/calico/v3.29.2/manifests/custom-resources.yaml
6

7
# 修改配置文件
8
vim custom-resources.yaml
9
cidr: 10.244.0.0/16（修改其中的网段为之前规划好的pod网段10.244.0.0/16）
10

11
# 运行calico
12
kubectl create -f custom-resources.yaml
13

14
# 使用watch命令可以持续监视pod状态
15
watch kubectl get pod -n calico-system

🤝 第四阶段：Node 节点加入集群（仅在 node1, node2 执行）#

1.把刚才 Master 节点初始化成功后输出的 `kubeadm join` 命令复制到两个 Node 节点执行。#

核心注意：命令末尾必须加上 `--cri-socket`！#

Terminal window

1
# 示例（请替换为你自己的 token 和 hash）：
2
sudo kubeadm join k8smaster:6443 \
3
  --token 3xgw7j.9o7d4051pfteeb0t \
4
  --discovery-token-ca-cert-hash sha256:fc3fd63d42581d6c31be38026b6ff5f82278c723cfc0a572b239647fe3633e58 \
5
  --cri-socket unix:///var/run/cri-dockerd.sock

2.验证集群状态（👑 仅 k8smaster 执行）#

在 Master 节点上查看集群是否搭建成功#

Terminal window

1
# 查看节点状态（大约 1-2 分钟后，所有节点应该变成 Ready）
2
kubectl get nodes -o wide
3

4
# 查看系统核心 Pod 是否都在 Running 状态
5
kubectl get pods -n kube-system -o wide

3、想给现在的集群“加一台新机器（加一个 Node 节点）#

在 Master 节点上重新生成加入口令#

Terminal window

1
kubeadm token create --print-join-command
2
# 屏幕上会输出一串类似 `kubeadm join 192.168.1.10:6443 --token xyz...` 的命令
3
新节点加入集群
4
复制刚才在 Master 节点上生成的那串命令，拿到 新机器（k8snode3） 上执行。
5
⚠️ 极其重要：千万别忘了在末尾加上 cri-dockerd 的尾巴！

🐉 第五阶段：安装 Longhorn#

1、环境准备（在【所有 4 个节点】上执行）#

Longhorn 需要底层操作系统支持 `iSCSI`（用于提供块存储）和 `NFS`（用于提供多读多写存储）。#

Terminal window

1
# 1. 更新系统的软件源列表（相当于刷新应用商店）
2
sudo apt-get update
3

4
# 2. 安装 open-iscsi（Longhorn 核心依赖）和 nfs-common（用于支持多节点共享挂载）
5
sudo apt-get install open-iscsi nfs-common -y
6

7
# 3. 启动 iscsid 服务，并设置为开机自启
8
sudo systemctl enable --now iscsid

2、检查环境（在【Master 节点】执行）#

Longhorn 官方提供了一个检测脚本，用来帮你检查刚才的环境有没有准备好。#

Terminal window

1
# 下载并运行 Longhorn 的环境检查脚本，依赖了 bash 和 jq（如果没有 jq 可能会报错，但如果不报错就说明没问题）
2
curl -sSfL https://raw.githubusercontent.com/longhorn/longhorn/v1.6.0/scripts/environment_check.sh | bash

作用：如果输出结果中所有的 `Status` 都是 `True` 或者没有报明显的红色 `Error`，就可以放心进行下一步了。#

Terminal window

1
# 实时查看 longhorn-system 命名空间下所有 Pod（容器）的运行状态
2
kubectl get pods -n longhorn-system -w

作用：`-w` 表示实时监控。你会看到很多组件正在 `ContainerCreating`（拉取镜像创建中）。请耐心等待几分钟，直到所有的 Pod 的状态（STATUS）都变成 `Running`。 (看到全部 Running 后，按 `Ctrl + C` 退出监控)。#

4、暴露并访问 Longhorn 可视化界面（在【Master 节点】执行）#

Longhorn 自带一个非常漂亮的 Web 界面，但默认情况下它只在集群内部可以访问。我们需要把它暴露出来。对于小白来说，最简单的方法是改成 `NodePort` 模式。#

Terminal window

1
# 1. 修改 UI 服务的类型，从默认的 ClusterIP 改为 NodePort（暴露到主机的物理端口上）
2
kubectl patch svc longhorn-frontend -n longhorn-system -p '{"spec": {"type": "NodePort"}}'
3

4
# 2. 查看系统为你分配了哪个物理端口
5
kubectl get svc longhorn-frontend -n longhorn-system
6

7
# 3. 修改默认分配的端口
8
kubectl patch svc longhorn-frontend -n longhorn-system --type='json' -p='[{"op": "replace", "path": "/spec/ports/0/nodePort", "value": 30880}]'

作用：执行完第二条命令后，你会看到类似这样的输出： `longhorn-frontend NodePort 10.97.x.x <none> 80:30880/TCP`#

请注意看 `80:` 后面的那个五位数（例如上面的 30880），这就是你的访问端口。#

如何访问：打开你的电脑浏览器，输入： `http://<任意一个节点的IP地址>:<刚刚查到的五位数端口>` （例如：`http://10.135.40.150:30880`）你就能看到 Longhorn 的管理界面了！#

5、将 Longhorn 设置为集群的默认存储（在【Master 节点】执行）#

为了以后你创建 MySQL、Redis 等需要持久化数据的应用时，Kubernetes 能自动帮你向 Longhorn 要硬盘，我们需要把它设为默认存储。#

Terminal window

1
# 给 Longhorn 的 StorageClass 打上“默认”的标记
2
kubectl patch storageclass longhorn -p '{"metadata": {"annotations":{"storageclass.kubernetes.io/is-default-class":"true"}}}'
3

4
# 查看是否设置成功
5
kubectl get sc

作用：执行第二条命令后，如果你看到 `longhorn (default)` 字样，说明大功告成！#

🎉 第六阶段：Docker卷目录迁移至K8S集群#

1、在【旧 Docker 服务器】打包老数据#

假设你以前 Docker 跑的时候，宿主机上存数据的目录是 `/opt/data/postgres` 和 `/opt/data/minio`#

Terminal window

1
# 1. 进入数据所在的父目录
2
cd /opt/data
3

4
# 3. 把包传到你的 K8s Master 节点
5
scp /opt/data root@<新K8s_Master的IP>:/opt/teable_data

2、在 K8s 部署并“断电”#

我们要先让 K8s 按照你的 YAML 把 Longhorn 硬盘全自动建出来。#

1
---
2
# ==========================================
3
# 1. 基础配置层 (保持不变)
4
# ==========================================
5
apiVersion: v1
6
kind: ConfigMap
7
metadata:
8
  name: teable-config
9
  namespace: teable
10
data:
11
  PUBLIC_ORIGIN: "http://10.135.40.150:30000"
12

13
  # MinIO 存储配置（内外网分离架构）
14
  BACKEND_STORAGE_PROVIDER: "minio"
15
  BACKEND_STORAGE_PUBLIC_BUCKET: "teable-pub"
16
  BACKEND_STORAGE_PRIVATE_BUCKET: "teable-pvt"
17
  BACKEND_STORAGE_MINIO_USE_SSL: "false"
18

19
  # 【外部地址】：前端浏览器下载、预览附件时使用的地址
20
  BACKEND_STORAGE_MINIO_ENDPOINT: "10.135.40.150"
21
  BACKEND_STORAGE_MINIO_PORT: "32000"
22
  STORAGE_PREFIX: "http://10.135.40.150:32000"
23

24
  # 【内部地址】：Teable后端容器上传、读写附件时直连的 K8s 内网地址（极速）
25
  BACKEND_STORAGE_MINIO_INTERNAL_ENDPOINT: "minio.teable.svc.cluster.local"
26
  BACKEND_STORAGE_MINIO_INTERNAL_PORT: "9000"
27

28
  BACKEND_CACHE_PROVIDER: "redis"
29
  NEXT_ENV_IMAGES_ALL_REMOTE: "true"
30
  PRISMA_ENGINES_CHECKSUM_IGNORE_MISSING: "1"
31
---
32
apiVersion: v1
33
kind: Secret
34
metadata:
35
  name: teable-secrets
36
  namespace: teable
37
type: Opaque
38
stringData:
39
  PRISMA_DATABASE_URL: "postgresql://teable:teable@postgres.teable.svc.cluster.local:5432/teable"
40
  BACKEND_CACHE_REDIS_URI: "redis://@redis.teable.svc.cluster.local:6379/0"
41
  BACKEND_JWT_SECRET: "teable-random-jwt-secret-abc123"
42
  BACKEND_SESSION_SECRET: "teable-random-session-secret-xyz890"
43
  BACKEND_STORAGE_MINIO_ACCESS_KEY: "root"
44
  BACKEND_STORAGE_MINIO_SECRET_KEY: "P@ssw0rd"
45

46
---
47
# ==========================================
48
# 2. 数据库层 (PostgreSQL - 升级为 StatefulSet + Longhorn)
49
# ==========================================
50
apiVersion: apps/v1
51
kind: StatefulSet
52
metadata:
53
  name: postgres
54
  namespace: teable
55
spec:
56
  serviceName: "postgres"
57
  replicas: 1
58
  selector:
59
    matchLabels:
60
      app: postgres
61
  template:
62
    metadata:
63
      labels:
64
        app: postgres
65
    spec:
66
      containers:
67
        - name: postgres
68
          image: registry.cn-shenzhen.aliyuncs.com/teable/postgres:15.4
69
          env:
70
            - name: POSTGRES_DB
71
              value: teable
72
            - name: POSTGRES_USER
73
              value: teable
74
            - name: POSTGRES_PASSWORD
75
              value: teable
76
            - name: PGDATA
77
              value: /var/lib/postgresql/data/pgdata
78
          ports:
79
            - containerPort: 5432
80
          volumeMounts:
81
            - name: pg-data
82
              mountPath: /var/lib/postgresql/data
83
  # 【核心机制】：向 Longhorn 动态申请 10G 虚拟网络磁盘
84
  volumeClaimTemplates:
85
    - metadata:
86
        name: pg-data
87
      spec:
88
        accessModes: [ "ReadWriteOnce" ]
89
        storageClassName: "longhorn"
90
        resources:
91
          requests:
92
            storage: 10Gi
93
---
94
apiVersion: v1
95
kind: Service
96
metadata:
97
  name: postgres
98
  namespace: teable
99
spec:
100
  selector:
101
    app: postgres
102
  ports:
103
    - port: 5432
104

105
---
106
# ==========================================
107
# 3. 缓存层 (Redis - 升级为 StatefulSet + Longhorn)
108
# ==========================================
109
apiVersion: apps/v1
110
kind: StatefulSet
111
metadata:
112
  name: redis
113
  namespace: teable
114
spec:
115
  serviceName: "redis"
116
  replicas: 1
117
  selector:
118
    matchLabels:
119
      app: redis
120
  template:
121
    metadata:
122
      labels:
123
        app: redis
124
    spec:
125
      containers:
126
        - name: redis
127
          image: registry.cn-shenzhen.aliyuncs.com/teable/redis:7.2.4
128
          args: ["redis-server", "--appendonly", "yes"]
129
          ports:
130
            - containerPort: 6379
131
          volumeMounts:
132
            - name: redis-data
133
              mountPath: /data
134
  volumeClaimTemplates:
135
    - metadata:
136
        name: redis-data
137
      spec:
138
        accessModes: [ "ReadWriteOnce" ]
139
        storageClassName: "longhorn"
140
        resources:
141
          requests:
142
            storage: 1Gi
143
---
144
apiVersion: v1
145
kind: Service
146
metadata:
147
  name: redis
148
  namespace: teable
149
spec:
150
  selector:
151
    app: redis
152
  ports:
153
    - port: 6379
154

155
---
156
# ==========================================
157
# 4. 对象存储层 (MinIO - 升级为 StatefulSet + Longhorn)
158
# ==========================================
159
apiVersion: apps/v1
160
kind: StatefulSet
161
metadata:
162
  name: minio
163
  namespace: teable
164
spec:
165
  serviceName: "minio"
166
  replicas: 1
167
  selector:
168
    matchLabels:
169
      app: minio
170
  template:
171
    metadata:
172
      labels:
173
        app: minio
174
    spec:
175
      containers:
176
        - name: minio
177
          image: registry.cn-shenzhen.aliyuncs.com/teable/minio:RELEASE.2024-10-13T13-34-11Z-cpuv1
178
          args:
179
            - server
180
            - /data
181
            - --console-address
182
            - ":9001"
183
          env:
184
            - name: MINIO_ROOT_USER
185
              value: root
186
            - name: MINIO_ROOT_PASSWORD
187
              value: P@ssw0rd
188
          ports:
189
            - containerPort: 9000
190
            - containerPort: 9001
191
          volumeMounts:
192
            - name: minio-data
193
              mountPath: /data
194
  volumeClaimTemplates:
195
    - metadata:
196
        name: minio-data
197
      spec:
198
        accessModes: [ "ReadWriteOnce" ]
199
        storageClassName: "longhorn"
200
        resources:
201
          requests:
202
            storage: 10Gi
203
---
204
apiVersion: v1
205
kind: Service
206
metadata:
207
  name: minio
208
  namespace: teable
209
spec:
210
  type: NodePort
211
  selector:
212
    app: minio
213
  ports:
214
    - port: 9000
215
      targetPort: 9000
216
      nodePort: 32000
217
      name: api
218
    - port: 9001
219
      targetPort: 9001
220
      nodePort: 32001
221
      name: console
222
---
223
apiVersion: batch/v1
224
kind: Job
225
metadata:
226
  name: minio-setup
227
  namespace: teable
228
spec:
229
  template:
230
    spec:
231
      containers:
232
      - name: minio-mc
233
        image: minio/mc:RELEASE.2022-12-13T00-23-28Z
234
        command:
235
        - /bin/sh
236
        - -c
237
        - |
238
          echo "等待 MinIO..."
239
          until mc alias set teable-minio http://minio:9000 root P@ssw0rd; do sleep 3; done
240
          mc mb --ignore-existing teable-minio/teable-pub
241
          mc mb --ignore-existing teable-minio/teable-pvt
242
          mc anonymous set public teable-minio/teable-pub
243
          echo "初始化完成！"
244
      restartPolicy: OnFailure
245

246
---
247
# ==========================================
248
# 5. 应用层 (Teable 主程序 - 目前保持 1 副本用于导数据)
249
# ==========================================
250
apiVersion: apps/v1
251
kind: Deployment
252
metadata:
253
  name: teable
254
  namespace: teable
255
spec:
256
  replicas: 1  # 稍后数据导入完毕，我们再横向扩容到 2
257
  selector:
258
    matchLabels:
259
      app: teable
260
  template:
261
    metadata:
262
      labels:
263
        app: teable
264
    spec:
265
      # 【核心新增】：反亲和性，如果有多副本，强制打散到不同物理机
266
      affinity:
267
        podAntiAffinity:
268
          requiredDuringSchedulingIgnoredDuringExecution:
269
          - labelSelector:
270
              matchExpressions:
271
              - key: app
272
                operator: In
273
                values:
274
                - teable
275
            topologyKey: "kubernetes.io/hostname"
276
      initContainers:
277
        - name: db-migrate
278
          image: registry.cn-shenzhen.aliyuncs.com/teable/teable:latest
279
          args: ["migrate-only"]
280
          envFrom:
281
            - configMapRef:
282
                name: teable-config
283
            - secretRef:
284
                name: teable-secrets
285
      containers:
286
        - name: teable
287
          image: registry.cn-shenzhen.aliyuncs.com/teable/teable:latest
288
          args: ["skip-migrate"]
289
          ports:
290
            - containerPort: 3000
291
          # 【新增】跳过自签名证书的验证
292
          env:
293
            - name: NODE_TLS_REJECT_UNAUTHORIZED
294
              value: "0"
295
          envFrom:
296
            - configMapRef:
297
                name: teable-config
298
            - secretRef:
299
                name: teable-secrets
300
          resources:
301
            requests:
302
              cpu: 200m
303
              memory: 400Mi
304
            limits:
305
              cpu: 1000m
306
              memory: 1536Mi
307
---
308
apiVersion: v1
309
kind: Service
310
metadata:
311
  name: teable
312
  namespace: teable
313
spec:
314
  type: NodePort
315
  selector:
316
    app: teable
317
  ports:
318
    - port: 3000
319
      targetPort: 3000
320
      nodePort: 30000

Terminal window

1
# 1. 部署你上面发给我的这份完美的 YAML（假设文件名叫 teable.yaml）
2
kubectl create namespace teable
3
kubectl apply -f teable.yaml
4

5
# 2. 等待大概 1-2 分钟，让系统把硬盘建好，并自动初始化一下。
6
kubectl get pods -n teable
7
# （看到 postgres-0, minio-0, teable 等都变成 Running 后进行下一步）
8

9
# 3. 停掉水电！（把组件副本数缩减为 0，相当于关机，防止它们继续往盘里写数据）
10
kubectl scale statefulset postgres minio redis -n teable --replicas=0
11
kubectl scale deployment teable -n teable --replicas=0
12

13
# 4. 确认全部关机了（应该只剩下一个叫 minio-setup 的已完成的 Job）
14
kubectl get pods -n teable
15

16
# 5. 查看teable分配的pvc硬盘情况
17
kubectl get pvc -n teable

因为你用的是 `StatefulSet`，K8s 给硬盘起的代号是固定的：#

Postgres 的硬盘叫：pg-data-postgres-0#
MinIO 的硬盘叫：minio-data-minio-0#

我们建一个临时容器，把这两块盘插进去。创建一个叫 `helper.yaml` 的文件，复制以下内容并执行 `kubectl apply -f helper.yaml`：#

1
apiVersion: v1
2
kind: Pod
3
metadata:
4
  name: helper-pod
5
  namespace: teable
6
spec:
7
  containers:
8
  - name: helper
9
    image: ubuntu:latest
10
    command: ["sleep", "infinity"]
11
    volumeMounts:
12
    # 名字普普通通，直接挂载为 /data/postgres 和 /data/minio
13
    - name: pg-vol
14
      mountPath: /data/postgres
15
    - name: minio-vol
16
      mountPath: /data/minio
17
  volumes:
18
  - name: pg-vol
19
    persistentVolumeClaim:
20
      claimName: pg-data-postgres-0   # K8s 自动生成的 Postgres 硬盘
21
  - name: minio-vol
22
    persistentVolumeClaim:
23
      claimName: minio-data-minio-0   # K8s 自动生成的 MinIO 硬盘

Terminal window

1
# 执行启动并等待它运行
2
kubectl apply -f helper.yaml
3
# 确认搬运工启动成功
4
kubectl get pod helper-pod -n teable

3、文件夹直传（核心操作）#

不用进容器内部！我们直接在 K8s Master 宿主机上，用 4 条命令搞定所有操作。#

假设你在宿主机上的旧数据目录是 `/opt/data/postgres` 和 `/opt/data/minio`，请直接在 Master 节点终端执行：#

Terminal window

1
# 1. 把 K8s 自动生成的空文件打扫干净
2
kubectl exec -it helper-pod -n teable -- sh -c "rm -rf /data/postgres/* /data/minio/*"
3

4
# 2. 为 Postgres 创建专门的子目录
5
# ⚠️ 必须做这步！因为你的 YAML 里写了 PGDATA: /var/lib/postgresql/data/pgdata
6
kubectl exec -it helper-pod -n teable -- mkdir -p /data/postgres/pgdata
7

8
# 3. 直接将宿主机的文件夹内容，拷贝到容器的 Longhorn 硬盘里！
9
# ⚠️ 注意源路径后面的 "/." 不能漏掉！它代表把里面所有的文件拷过去，而不是把外层文件夹套个娃。
10
kubectl cp /opt/teable-data/postgres/_data/. teable/helper-pod:/data/postgres/pgdata/
11
kubectl cp /opt/teable-data/minio/_data/. teable/helper-pod:/data/minio/
12

13
# 4. 修复数据库权限（Postgres 认死理，必须是 UID 999 才能读写）
14
kubectl exec -it helper-pod -n teable -- chown -R 999:999 /data/postgres

(注：`kubectl cp` 传输大量碎文件时可能不会显示进度条，如果终端卡住不要慌，是在传输中，耐心等待执行完毕回到命令行即可。)#

4、清理搬运工，重新通电#

数据已经全部完美平移到 Longhorn 硬盘里了！#

Terminal window

1
# 1. 删掉搬运工
2
kubectl delete pod helper-pod -n teable
3

4
# 2. 依次唤醒数据库和存储（恢复为 1 个副本）
5
kubectl scale statefulset postgres minio redis -n teable --replicas=1
6

7
# 3. 唤醒 Teable 主程序！
8
kubectl scale deployment teable -n teable --replicas=1

K8s高可用环境搭建和迁移

Mon, 16 Mar 2026 00:00:00 GMT

企业级别高可用Teable迁移方案#

📝 环境与角色划分总览#

K8s Master: 10.135.40.150 (不参与有状态服务部署)
Node 1 (.151): PG 主库 | Redis队列(主) | Redis性能(从) | MinIO 节点 1
Node 2 (.152): PG 从库 | Redis队列(从) | Redis性能(主) | MinIO 节点 2
Node 3 (.153): (不跑PG) | Redis队列(从) | Redis性能(从) | MinIO 节点 3

🐘 第一步：搭建 PostgreSQL 15 (主从复制)#

1. 在 Node 1 (.151) 和 Node 2 (.152) 上安装 PG 15：

Terminal window

1
# 在 151 和 152 上都执行
2
sudo sh -c 'echo "deb http://apt.postgresql.org/pub/repos/apt $(lsb_release -cs)-pgdg main" > /etc/apt/sources.list.d/pgdg.list'
3
wget --quiet -O - https://www.postgresql.org/media/keys/ACCC4CF8.asc | sudo apt-key add -
4
sudo apt-get update
5
sudo apt-get -y install postgresql-15

2. 在 Node 1 (.151) 配置主库：

Terminal window

1
# 切换到 postgres 用户
2
sudo su - postgres
3

4
# 登录数据库创建 Teable 用户和复制用户
5
psql -c "CREATE USER teable_user WITH PASSWORD 'P@ssw0rd';"
6
psql -c "CREATE DATABASE teable OWNER teable;"
7
psql -c "CREATE ROLE replicator WITH REPLICATION PASSWORD 'P@ssw0rd' LOGIN;"
8
exit
9

10
# 修改配置允许远程连接和复制
11
sudo sed -i "s/#listen_addresses = 'localhost'/listen_addresses = '*'/g" /etc/postgresql/15/main/postgresql.conf
12
sudo sed -i "s/#wal_level = replica/wal_level = replica/g" /etc/postgresql/15/main/postgresql.conf
13

14
# 修改 pg_hba.conf 允许密码登录和从库连接
15
echo "host    all             all             0.0.0.0/0               md5" | sudo tee -a /etc/postgresql/15/main/pg_hba.conf
16
echo "host    replication     replicator      10.135.40.152/32        md5" | sudo tee -a /etc/postgresql/15/main/pg_hba.conf
17

18
# 重启主库
19
sudo systemctl restart postgresql

3. 在 Node 2 (.152) 配置从库：

Terminal window

1
# 停止当前运行的 PG 服务
2
sudo systemctl stop postgresql
3

4
# 清空默认的数据目录
5
sudo rm -rf /var/lib/postgresql/15/main/*
6

7
# 使用 pg_basebackup 从主库同步数据（执行时输入密码 Replicate@123）
8
sudo -u postgres pg_basebackup -h 10.135.40.151 -D /var/lib/postgresql/15/main -U replicator -P -v -R -X stream
9

10
# 启动从库
11
sudo systemctl start postgresql

验证：PG 搭建完毕，Teable 后续将直接连接 10.135.40.151:5432

4.清理之前的旧 PG（仅在 .151 和 .152 执行）

我们需要把之前手动搭的半吊子主从清空，把数据库的控制权完全交给 Patroni。在 Node 1 (.151) 和 Node 2 (.152) 执行：

Terminal window

1
sudo systemctl stop postgresql
2
sudo systemctl disable postgresql
3
# 清空数据目录，Patroni 会帮我们重新初始化并同步
4
sudo rm -rf /var/lib/postgresql/15/main/*

5.搭建 etcd 集群（分布式大脑）

Patroni 需要一个大脑来决定“谁是主库”，防止脑裂。etcd 需要奇数个节点，所以我们部署在 .151, .152, .153 三台机器上。

Terminal window

1
# Patroni 需要一个大脑来决定“谁是主库”，防止脑裂。etcd 需要奇数个节点，所以我们部署在 .151, .152, .153 三台机器上。
2
sudo apt-get update
3
sudo apt-get install -y etcd

Terminal window

1
# 在 Node 1 (.151) 修改配置：
2
cat <<EOF | sudo tee /etc/default/etcd
3
ETCD_NAME="node1"
4
ETCD_DATA_DIR="/var/lib/etcd/default.etcd"
5
ETCD_LISTEN_PEER_URLS="http://10.135.40.151:2380"
6
ETCD_LISTEN_CLIENT_URLS="http://10.135.40.151:2379,http://127.0.0.1:2379"
7
ETCD_INITIAL_ADVERTISE_PEER_URLS="http://10.135.40.151:2380"
8
ETCD_INITIAL_CLUSTER="node1=http://10.135.40.151:2380,node2=http://10.135.40.152:2380,node3=http://10.135.40.153:2380"
9
ETCD_INITIAL_CLUSTER_STATE="new"
10
ETCD_INITIAL_CLUSTER_TOKEN="teable-etcd-cluster"
11
ETCD_ADVERTISE_CLIENT_URLS="http://10.135.40.151:2379"
12
EOF
13
sudo systemctl restart etcd
14

15
# 在 Node 2 (.152) 修改配置：
16
cat <<EOF | sudo tee /etc/default/etcd
17
ETCD_NAME="node2"
18
ETCD_DATA_DIR="/var/lib/etcd/default.etcd"
19
ETCD_LISTEN_PEER_URLS="http://10.135.40.152:2380"
20
ETCD_LISTEN_CLIENT_URLS="http://10.135.40.152:2379,http://127.0.0.1:2379"
21
ETCD_INITIAL_ADVERTISE_PEER_URLS="http://10.135.40.152:2380"
22
ETCD_INITIAL_CLUSTER="node1=http://10.135.40.151:2380,node2=http://10.135.40.152:2380,node3=http://10.135.40.153:2380"
23
ETCD_INITIAL_CLUSTER_STATE="new"
24
ETCD_INITIAL_CLUSTER_TOKEN="teable-etcd-cluster"
25
ETCD_ADVERTISE_CLIENT_URLS="http://10.135.40.152:2379"
26
EOF
27
sudo systemctl restart etcd
28

29
# 在 Node 3 (.153) 修改配置：
30
cat <<EOF | sudo tee /etc/default/etcd
31
ETCD_NAME="node3"
32
ETCD_DATA_DIR="/var/lib/etcd/default.etcd"
33
ETCD_LISTEN_PEER_URLS="http://10.135.40.153:2380"
34
ETCD_LISTEN_CLIENT_URLS="http://10.135.40.153:2379,http://127.0.0.1:2379"
35
ETCD_INITIAL_ADVERTISE_PEER_URLS="http://10.135.40.153:2380"
36
ETCD_INITIAL_CLUSTER="node1=http://10.135.40.151:2380,node2=http://10.135.40.152:2380,node3=http://10.135.40.153:2380"
37
ETCD_INITIAL_CLUSTER_STATE="new"
38
ETCD_INITIAL_CLUSTER_TOKEN="teable-etcd-cluster"
39
ETCD_ADVERTISE_CLIENT_URLS="http://10.135.40.153:2379"
40
EOF
41
sudo systemctl restart etcd

(验证：在任意机器执行 etcdctl cluster-health，应该显示 cluster is healthy)

6.配置 Patroni 自动故障切换

在 Node 1 (.151) 和 Node 2 (.152) 机器上安装并配置 Patroni。

Terminal window

1
# 在 .151 和 .152 安装 Patroni：
2
sudo apt-get install -y patroni
3
# 在 Node 1 (.151) 写入配置：
4
cat <<EOF | sudo tee /etc/patroni/config.yml
5
scope: teable-pg-cluster
6
namespace: /db/
7
name: pg-node1
8

9
restapi:
10
  listen: 0.0.0.0:8008
11
  connect_address: 10.135.40.151:8008
12

13
etcd:
14
  hosts: 10.135.40.151:2379,10.135.40.152:2379,10.135.40.153:2379
15

16
bootstrap:
17
  dcs:
18
    ttl: 30
19
    loop_wait: 10
20
    retry_timeout: 10
21
    maximum_lag_on_failover: 1048576
22
    postgresql:
23
      use_pg_rewind: true
24
  initdb:
25
  - auth-host: md5
26
  - auth-local: trust
27
  - encoding: UTF8
28
  - data-checksums
29
  pg_hba:
30
  - host replication replicator 10.135.40.0/24 md5
31
  - host all all 0.0.0.0/0 md5
32
  users:
33
    teable:
34
      password: P@ssw0rd
35
      options:
36
        - createdb
37

38
postgresql:
39
  listen: 0.0.0.0:5432
40
  connect_address: 10.135.40.151:5432
41
  data_dir: /var/lib/postgresql/15/main
42
  bin_dir: /usr/lib/postgresql/15/bin
43
  pgpass: /tmp/pgpass
44
  authentication:
45
    replication:
46
      username: replicator
47
      password: P@ssw0rd
48
    superuser:
49
      username: postgres
50
      password: P@ssw0rd
51
EOF
52
sudo systemctl restart patroni
53

54
# 在 Node 2 (.152) 写入配置：
55
# 配置几乎一样，只需改 name 和 IP
56
cat <<EOF | sudo tee /etc/patroni/config.yml
57
scope: teable-pg-cluster
58
namespace: /db/
59
name: pg-node2
60

61
restapi:
62
  listen: 0.0.0.0:8008
63
  connect_address: 10.135.40.152:8008
64

65
etcd:
66
  hosts: 10.135.40.151:2379,10.135.40.152:2379,10.135.40.153:2379
67

68
bootstrap:
69
  dcs:
70
    ttl: 30
71
    loop_wait: 10
72
    retry_timeout: 10
73
    maximum_lag_on_failover: 1048576
74
    postgresql:
75
      use_pg_rewind: true
76
  initdb:
77
  - auth-host: md5
78
  - auth-local: trust
79
  - encoding: UTF8
80
  - data-checksums
81
  pg_hba:
82
  - host replication replicator 10.135.40.0/24 md5
83
  - host all all 0.0.0.0/0 md5
84
  users:
85
    teable:
86
      password: P@ssw0rd
87
      options:
88
        - createdb
89

90
postgresql:
91
  listen: 0.0.0.0:5432
92
  connect_address: 10.135.40.152:5432
93
  data_dir: /var/lib/postgresql/15/main
94
  bin_dir: /usr/lib/postgresql/15/bin
95
  pgpass: /tmp/pgpass
96
  authentication:
97
    replication:
98
      username: replicator
99
      password: P@ssw0rd
100
    superuser:
101
      username: postgres
102
      password: P@ssw0rd
103
EOF
104
sudo systemctl restart patroni

为了确保 100% 成功，我们先只启动 Node 1，等它成为 Leader 后，再启动 Node 2。

Terminal window

1
# 成功标志，像这样：
2
+----------+---------------+--------+---------+----+-----------+
3
| Member   | Host          | Role   | State   | TL | Lag in MB |
4
+----------+---------------+--------+---------+----+-----------+
5
| pg-node1 | 10.135.40.151 | Leader | running |  1 |           |
6
+----------+---------------+--------+---------+----+-----------+

(验证：执行 patronictl -c /etc/patroni/config.yml list，你会看到 pg-node1 是 Leader，pg-node2 是 Replica，状态都是 running)

Terminal window

1
# 初始化 Teable 数据库（仅在 Leader 节点 .151 执行一次）
2
sudo -u postgres psql -c "CREATE DATABASE teable OWNER teable;"

7.配置 HAProxy（智能路由）

应用不用管谁是主库，直接连 HAProxy，HAProxy 会自动把流量转发给当前的 Leader。

在 Node 1 (.151) 和 Node 2 (.152) 上执行：

Terminal window

1
sudo apt-get install -y haproxy
2

3
cat <<EOF | sudo tee /etc/haproxy/haproxy.cfg
4
global
5
    maxconn 1000
6
    daemon
7

8
defaults
9
    log global
10
    mode tcp
11
    retries 2
12
    timeout client 30m
13
    timeout connect 4s
14
    timeout server 30m
15
    timeout check 5s
16

17
listen postgres
18
    bind *:5000
19
    option httpchk GET /master
20
    http-check expect status 200
21
    default-server inter 3s fall 3 rise 2 on-marked-down shutdown-sessions
22
    server pg1 10.135.40.151:5432 maxconn 500 check port 8008
23
    server pg2 10.135.40.152:5432 maxconn 500 check port 8008
24
EOF
25

26
sudo systemctl restart haproxy

(现在，访问 151:5000 或 152:5000 都能直接连到主库了！)

8.配置 Keepalived（虚拟 IP）

最后一步，弄一个永远不宕机的 IP (10.135.40.160)。

Terminal window

1
# 在 **Node 1 (.151)** 和 **Node 2 (.152)** 上安装：
2
sudo apt-get install -y keepalived
3

4
# 在 Node 1 (.151) 配置为 MASTER：
5
cat <<EOF | sudo tee /etc/keepalived/keepalived.conf
6
vrrp_script chk_haproxy {
7
    script "killall -0 haproxy" # 检查 HAProxy 是否活着
8
    interval 2
9
    weight 2
10
}
11

12
vrrp_instance VI_1 {
13
    interface ens16 # 请用 'ip a' 命令确认你的网卡名，有可能是 ens33 或 eth16，必须填对！
14
    state MASTER
15
    virtual_router_id 51
16
    priority 101 # 优先级高
17
    virtual_ipaddress {
18
        10.135.40.160 # 你的虚拟 IP
19
    }
20
    track_script {
21
        chk_haproxy
22
    }
23
}
24
EOF
25
sudo systemctl restart keepalived
26

27
# 在 Node 2 (.152) 配置为 BACKUP：
28
cat <<EOF | sudo tee /etc/keepalived/keepalived.conf
29
vrrp_script chk_haproxy {
30
    script "killall -0 haproxy"
31
    interval 2
32
    weight 2
33
}
34

35
vrrp_instance VI_1 {
36
    interface eth16 # 同样，确保网卡名是对的
37
    state BACKUP
38
    virtual_router_id 51
39
    priority 100 # 优先级略低
40
    virtual_ipaddress {
41
        10.135.40.160 # 同一个虚拟 IP
42
    }
43
    track_script {
44
        chk_haproxy
45
    }
46
}
47
EOF
48
sudo systemctl restart keepalived

(验证：在 .151 执行 ip a，你应该能看到 10.135.40.160 这个 IP 挂在你的网卡上。如果 .151 关机，它会瞬间跑去 .152)

🔴 第二步：搭建两套 Redis 实例#

目标：在 3 台机器上运行两个 Redis 进程 (6379 和 6380)。按照你的要求进行主从交叉配置。

1. 在所有三台机器 (.151, .152, .153) 上安装 Redis：

Terminal window

1
sudo apt-get update
2
sudo apt-get install -y redis-server
3
# 停止默认服务，我们自己配置
4
sudo systemctl stop redis-server
5
sudo systemctl disable redis-server

2. 在所有三台机器上创建两套目录和基础配置文件：

Terminal window

1
sudo mkdir -p /etc/redis /var/lib/redis/queue /var/lib/redis/perf
2
sudo chown -R redis:redis /var/lib/redis
3

4
# 创建队列缓存配置 (6379)
5
cat <<EOF | sudo tee /etc/redis/redis-queue.conf
6
port 6379
7
dir /var/lib/redis/queue
8
bind 0.0.0.0
9
protected-mode no
10
requirepass P@ssw0rd
11
masterauth P@ssw0rd
12
daemonize yes
13
pidfile /var/run/redis/redis-queue.pid
14
logfile /var/log/redis/redis-queue.log
15
EOF
16

17
# 创建性能缓存配置 (6380)
18
cat <<EOF | sudo tee /etc/redis/redis-perf.conf
19
port 6380
20
dir /var/lib/redis/perf
21
bind 0.0.0.0
22
protected-mode no
23
requirepass P@ssw0rd
24
masterauth P@ssw0rd
25
daemonize yes
26
pidfile /var/run/redis/redis-perf.pid
27
logfile /var/log/redis/redis-perf.log
28
EOF

3. 配置主从关系 (最关键的一步)：

在 Node 2 (.152) 和 Node 3 (.153) 上，配置队列(6379)从属于 Node 1：

Terminal window

1
echo "replicaof 10.135.40.151 6379" | sudo tee -a /etc/redis/redis-queue.conf

在 Node 1 (.151) 和 Node 3 (.153) 上，配置性能(6380)从属于 Node 2：

Terminal window

1
echo "replicaof 10.135.40.152 6380" | sudo tee -a /etc/redis/redis-perf.conf

4. 在三台机器上启动这两套 Redis：

Terminal window

1
sudo -u redis redis-server /etc/redis/redis-queue.conf
2
sudo -u redis redis-server /etc/redis/redis-perf.conf

验证：6379 主节点在 .151，6380 主节点在 .152。Teable 将连接这两个主节点写入数据。

5. 验证主从角色（最重要）

Terminal window

1
# 在 Node 1 (.151) 上验证 6379 是主节点：
2
redis-cli -p 6379 -a P@ssw0rd INFO replication
3
# 在 Node 2 (.152) 上验证 6379 是从节点：
4
redis-cli -p 6379 -a P@ssw0rd INFO replication
5

6
# 在 Node 2 (.152) 上验证 6380 是主节点：
7
redis-cli -p 6380 -a P@ssw0rd INFO replication
8
# 在 Node 3 (.153) 上验证 6380 是从节点：
9
redis-cli -p 6380 -a P@ssw0rd INFO replication

6.测试数据同步

Terminal window

1
测试队列缓存（6379）：
2
# 在 Node 1 (.151) 主节点写入
3
redis-cli -p 6379 -a P@ssw0rd SET test_queue "hello"
4
# 在 Node 2 (.152) 从节点读取
5
redis-cli -p 6379 -a P@ssw0rd GET test_queue
6
# 应该返回 "hello"
7

8
测试性能缓存（6380）
9
# 在 Node 2 (.152) 主节点写入
10
redis-cli -p 6380 -a P@ssw0rd SET test_perf "world"
11
# 在 Node 1 (.151) 从节点读取
12
redis-cli -p 6380 -a P@ssw0rd GET test_perf
13
# 应该返回 "world"

📦 第三步：搭建 MinIO 3节点集群#

目标：在三台机器上搭建分布式 MinIO。由于 MinIO 分布式要求至少 4 个驱动器(盘)，我们可以在每台机器上创建 2 个目录，3台机器共计 6 个“盘”来完美满足集群要求。

1. 在三台机器 (.151, .152, .153) 上执行相同操作：

Terminal window

1
# 下载 MinIO 二进制文件
2
wget https://dl.min.io/server/minio/release/linux-amd64/minio
3
chmod +x minio
4
sudo mv minio /usr/local/bin/
5

6
# 创建两个数据目录以满足分布式盘数要求
7
sudo mkdir -p /data/minio/disk1 /data/minio/disk2
8
sudo chown -R $USER:$USER /data/minio

2. 在三台机器上创建启动脚本 (环境变量保持一致)：

Terminal window

1
cat <<EOF | sudo tee /etc/systemd/system/minio.service
2
[Unit]
3
Description=MinIO
4
Wants=network-online.target
5
After=network-online.target
6

7
[Service]
8
User=root
9
Environment="MINIO_ROOT_USER=admin"
10
Environment="MINIO_ROOT_PASSWORD=P@ssw0rd"
11
Environment="MINIO_CI_CD=1" # 强制使用根分区目录（仅测试环境）
12
ExecStart=/usr/local/bin/minio server http://10.135.40.15{1...3}:9000/data/minio/disk{1...2} --console-address ":9001"
13
Restart=always
14
LimitNOFILE=65536
15

16
[Install]
17
WantedBy=multi-user.target
18
EOF

3. 在三台机器上启动 MinIO 集群：

Terminal window

1
sudo systemctl daemon-reload
2
sudo systemctl enable minio
3
sudo systemctl start minio

验证：浏览器访问 http://10.135.40.151:9001，账号 teable_admin，密码 TeableMinio@123。登录后手动创建 teable-public 和 teable-private 两个 Bucket。

🚀 第四步：Minio数据迁移#

1. 先安装 MinIO Client (mc)：

Terminal window

1
wget https://dl.min.io/client/mc/release/linux-amd64/mc
2
chmod +x mc
3
sudo mv mc /usr/local/bin/

2. 配置 mc 连接到你的 MinIO 集群：

Terminal window

1
# 使用你的实际域名或 IP
2
mc alias set teable-minio http://10.135.40.151:9000 admin P@ssw0rd
3

4
# 测试连接
5
mc admin info teable-minio

3. 创建存储桶并设置权限：

Terminal window

1
# 创建公共桶
2
mc mb --ignore-existing teable-minio/teable-pub
3

4
# 设置公共读取权限
5
mc anonymous set download teable-minio/teable-pub
6

7
# 创建私有桶
8
mc mb --ignore-existing teable-minio/teable-pvt
9

10
# 验证
11
mc ls teable-minio
12

13
# 查看 teable-pub 的权限
14
mc anonymous get teable-minio/teable-pub
15

16
# 查看 teable-pvt 的权限（应该是 private）
17
mc anonymous get teable-minio/teable-pvt

4.配置新老 MinIO 的连接别名

Terminal window

1
# 使用以下命令查看 MinIO 客户端当前配置的所有别名：
2
mc alias list
3

4
teable-minio
5
  URL       : http://10.135.40.151:9000
6
  AccessKey : admin
7
  SecretKey : P@ssw0rd
8
  API       : s3v4
9
  Path      : auto
10
  Src       : /root/.mc/config.json
11

12
# 连接旧的 K8s MinIO
13
mc alias set teable-minio http://10.135.40.150:32000 root 'P@ssw0rd'
14
# 设置成功后，你就可以像之前一样查看文件了：
15
mc ls teable-minio
16

17
# 连接新的物理机 MinIO 集群
18
mc alias set teable-minio http://10.135.40.151:9000 admin 'P@ssw0rd'
19

20
# 详细查看存储桶使用量
21
mc du teable-minio/teable-pvt
22
1.3GiB  965 objects     teable-pvt
23

24
mc du teable-minio/teable-pub
25
87KiB   62 objects      teable-pub
26

27
# 执行复制（镜像）操作
28
mc mirror --preserve source-minio/teable-pub teable-minio/teable-pub
29
mc mirror --preserve source-minio/teable-pvt teable-minio/teable-pvt

🚀 第五步：PostgreSQL 数据迁移#

1. 从旧的 Pod 中导出数据 (注：使用 -O -x 参数是为了忽略旧的权限和所有者，这样导入新库时不会因为用户名不一致报错)

Terminal window

1
kubectl exec -it postgres-0 -n teable -- pg_dump -U teable -d teable -O -x -f /tmp/teable_dump.sql

2. 把数据文件拷贝到 K8s Master 本地

Terminal window

1
kubectl cp teable/postgres-0:/tmp/teable_dump.sql ./teable_dump.sql

3. 在 Master 节点安装 PostgreSQL 客户端

Terminal window

1
psql -h 10.135.40.160 -p 5000 -U teable -d teable -f ./teable_dump.sql

如果屏幕上刷刷刷地输出 INSERT 0 1, CREATE TABLE 等字样，说明数据库迁移成功！

Terminal window

1
**最后报错的仅仅是两个高级附加功能**
2

3
1. **`WARNING: wal_level is insufficient`**：Teable 的实时协作功能（多人在同一个表格打字实时同步）依赖 PostgreSQL 的**逻辑复制 (Logical Replication)** 功能，这要求数据库的 `wal_level` 必须设置为 `logical`，而你目前的 Patroni 默认是 `replica`。
4
2. **`ERROR: permission denied to create event trigger`**：Teable 需要在数据库里创建一个“事件触发器”来监听表结构的变化，这在 PostgreSQL 中强制要求执行者必须拥有 **超级用户 (SUPERUSER)** 权限，而你的 `teable` 只是普通用户。
5

6
这两个问题非常容易解决，我们需要在物理机上修改一下配置，然后把最后缺失的触发器补上即可。
7

8
# 提升 teable 为超级用户，在你的 物理机 Node 1 (.151) 上执行以下命令，给业务账号赋权：
9
sudo -u postgres psql -c "ALTER USER teable WITH SUPERUSER;"
10

11
# 修改 Patroni 配置开启逻辑复制
12
#在 物理机 Node 1 (.151) 上，我们需要修改 Patroni 的配置。输入以下命令进入配置编辑模式：
13
sudo patronictl -c /etc/patroni/config.yml edit-config
14
# 找到 postgresql -> parameters 这一层级，在下面添加一行 wal_level: logical。修改后看起来应该是这样的：
15
postgresql:
16
  parameters:
17
    wal_level: logical    # <--- 加上这一行
18
    max_connections: 500  # (原有的其他配置保持不变...)
19

20
# 重启数据库集群使配置生效
21
# 在 Node 2 (.152) 执行：
22
sudo systemctl restart patroni
23
# 等 10 秒后，在 Node 1 (.151) 执行：
24
sudo systemctl restart patroni
25

26
# 回到你的 K8s Master 节点，补齐最后缺失的触发器
27
psql -h 10.135.40.154 -p 5000 -U teable -d teable -f /opt/teable_dump.sql

Terminal window

1
# 报错新数据库里根本没有这个“角色 (Role)，base_schema_table_read_only_role
2

3
psql -h 10.135.40.154 -p 5000 -U teable -d teable -c "
4
DROP ROLE IF EXISTS base_schema_table_read_only_role;
5
CREATE ROLE base_schema_table_read_only_role WITH LOGIN PASSWORD 'P@ssw0rd';
6
GRANT pg_read_all_data TO base_schema_table_read_only_role;"
7
# (执行时输入密码 P@ssw0rd，看到输出 GRANT 即为成功)

🎉 第六步：在 K8s 中部署 Teable 无状态层#

有状态服务在宿主机跑起来后，现在我们回到 K8s Master 节点 (10.135.40.150)，把 Teable 部署到 K8s 里，并将连接指向宿主机。

1. 创建 teable-config.yaml： 注意看这里的 IP 地址，都是直接指向你刚才配置的宿主机物理 IP。

Terminal window

1
---
2
# ==========================================
3
# 1. 基础配置层 (ConfigMap)
4
# ==========================================
5
apiVersion: v1
6
kind: ConfigMap
7
metadata:
8
  name: teable-config
9
  namespace: teable
10
data:
11
  # 应用对外访问入口
12
  PUBLIC_ORIGIN: "http://10.135.40.150:30000"
13

14
  PUBLIC_DATABASE_PROXY: "10.135.40.160:5000"
15

16
  # MinIO 存储配置 (全部指向物理机 10.135.40.151)
17
  BACKEND_STORAGE_PROVIDER: "minio"
18
  BACKEND_STORAGE_PUBLIC_BUCKET: "teable-pub"
19
  BACKEND_STORAGE_PRIVATE_BUCKET: "teable-pvt"
20

21
  # 外网端点 (由于是内网环境，内外网端点一致)
22
  BACKEND_STORAGE_MINIO_ENDPOINT: "10.135.40.151"
23
  BACKEND_STORAGE_MINIO_PORT: "9000"
24
  STORAGE_PREFIX: "http://10.135.40.151:9000"
25

26
  # 内网端点 (不再使用 svc.cluster.local，直接写物理机 IP)
27
  BACKEND_STORAGE_MINIO_INTERNAL_ENDPOINT: "10.135.40.151"
28
  BACKEND_STORAGE_MINIO_INTERNAL_PORT: "9000"
29
  BACKEND_STORAGE_MINIO_USE_SSL: "false"
30

31
  # 缓存配置
32
  BACKEND_CACHE_PROVIDER: "redis"
33

34
  # 系统常量
35
  NEXT_ENV_IMAGES_ALL_REMOTE: "true"
36
  PRISMA_ENGINES_CHECKSUM_IGNORE_MISSING: "1"
37
  NODE_TLS_REJECT_UNAUTHORIZED: "0"
38

39
---
40
# ==========================================
41
# 2. 机密信息层 (Secret)
42
# ==========================================
43
apiVersion: v1
44
kind: Secret
45
metadata:
46
  name: teable-secrets
47
  namespace: teable
48
type: Opaque
49
stringData:
50
  # 高可用 PostgreSQL (HAProxy VIP: 10.135.40.154:5000)
51
  # 注意：密码 P@ssw0rd 必须转码为 P%40ssw0rd
52
  PRISMA_DATABASE_URL: "postgresql://teable:P%40ssw0rd@10.135.40.154:5000/teable?schema=public"
53

54
  # 独立 Redis 集群
55
  # 密码 Redis@123 转码为 Redis%40123
56
  BACKEND_CACHE_REDIS_URI: "redis://:P%40ssw0rd@10.135.40.151:6379/0"
57
  BACKEND_PERFORMANCE_CACHE: "redis://:P%40ssw0rd@10.135.40.152:6380/1"
58

59
  # 系统密钥
60
  BACKEND_JWT_SECRET: "teable-prod-jwt-secret-secure-key"
61
  BACKEND_SESSION_SECRET: "teable-prod-session-secret-secure-key"
62

63
  # MinIO 凭证
64
  BACKEND_STORAGE_MINIO_ACCESS_KEY: "admin"
65
  BACKEND_STORAGE_MINIO_SECRET_KEY: "P@ssw0rd"
66

67
---
68
# ==========================================
69
# 3. 业务应用层 (Deployment)
70
# ==========================================
71
apiVersion: apps/v1
72
kind: Deployment
73
metadata:
74
  name: teable
75
  namespace: teable
76
spec:
77
  replicas: 3 # 生产环境推荐 3 副本抗并发
78
  selector:
79
    matchLabels:
80
      app: teable
81
  template:
82
    metadata:
83
      labels:
84
        app: teable
85
    spec:
86
      # 软反亲和性：尽量将 3 个 Pod 调度到不同的 K8s Node 上，防止单台宿主机宕机导致服务全挂
87
      affinity:
88
        podAntiAffinity:
89
          preferredDuringSchedulingIgnoredDuringExecution:
90
          - weight: 100
91
            podAffinityTerm:
92
              labelSelector:
93
                matchExpressions:
94
                - key: app
95
                  operator: In
96
                  values:
97
                  - teable
98
              topologyKey: "kubernetes.io/hostname"
99

100
      # 初始化容器：执行数据库表结构合并与升级
101
      initContainers:
102
        - name: db-migrate
103
          image: registry.cn-shenzhen.aliyuncs.com/teable/teable:latest
104
          args:
105
            - migrate-only
106
          envFrom:
107
            - configMapRef:
108
                name: teable-config
109
            - secretRef:
110
                name: teable-secrets
111
          resources:
112
            requests:
113
              cpu: 100m
114
              memory: 102Mi
115
            limits:
116
              cpu: 1000m
117
              memory: 1024Mi
118

119
      # 主业务容器
120
      containers:
121
        - name: teable
122
          image: registry.cn-shenzhen.aliyuncs.com/teable/teable:latest
123
          args:
124
            - skip-migrate
125
          ports:
126
            - containerPort: 3000
127
          envFrom:
128
            - configMapRef:
129
                name: teable-config
130
            - secretRef:
131
                name: teable-secrets
132
          # 资源配额：针对 50+ 用户的生产标准
133
          resources:
134
            requests:
135
              cpu: 500m
136
              memory: 1Gi
137
            limits:
138
              cpu: 2000m
139
              memory: 4096Mi
140

141
          # 官方推荐的健康检查探针组合
142
          startupProbe:
143
            httpGet:
144
              path: /health
145
              port: 3000
146
            initialDelaySeconds: 10
147
            periodSeconds: 10
148
            timeoutSeconds: 5
149
            failureThreshold: 30 # 给予最多 300 秒的启动时间
150
            successThreshold: 1
151
          livenessProbe:
152
            httpGet:
153
              path: /health
154
              port: 3000
155
            initialDelaySeconds: 30
156
            periodSeconds: 30
157
            timeoutSeconds: 5
158
            failureThreshold: 3
159
            successThreshold: 1
160
          readinessProbe:
161
            httpGet:
162
              path: /health
163
              port: 3000
164
            initialDelaySeconds: 15
165
            periodSeconds: 10
166
            timeoutSeconds: 5
167
            failureThreshold: 3
168
            successThreshold: 1
169

170
---
171
# ==========================================
172
# 4. 服务暴露层 (Service)
173
# ==========================================
174
apiVersion: v1
175
kind: Service
176
metadata:
177
  name: teable
178
  namespace: teable
179
spec:
180
  type: NodePort
181
  ports:
182
    - port: 3000
183
      targetPort: 3000
184
      nodePort: 30000 # 固定外网访问端口，对应 PUBLIC_ORIGIN
185
  selector:
186
    app: teable

2.高可用HPA负载均衡搭建

Terminal window

1
apiVersion: autoscaling/v2
2
kind: HorizontalPodAutoscaler
3
metadata:
4
  name: teable-hpa
5
  namespace: teable
6
spec:
7
  scaleTargetRef:
8
    apiVersion: apps/v1
9
    kind: Deployment
10
    name: teable    # 关联你 YAML 里的 teable Deployment
11
  minReplicas: 1    # 闲时：最小保留 1 个 Pod（省资源）
12
  maxReplicas: 3   # 忙时：最多扩容到 3 个 Pod
13
  metrics:
14
  - type: Resource
15
    resource:
16
      name: cpu
17
      target:
18
        type: Utilization
19
        averageUtilization: 60  # 当 CPU 使用率达到 requests(200m) 的 60% 时，触发扩容

3. 在 K8s Master 上应用配置：

Terminal window

1
# 应用（创建或更新）配置文件
2
kubectl apply -f teable-config.yaml
3

4
# 实时监控 Pod 的运行状态
5
kubectl get pods -n teable -w
6

7
# 通过标签（Label）批量删除并强制重建 Pod
8
kubectl delete pods -l app=teable -n teable
9

10
# 查看特定 Pod 的详细信息和诊断日志（排错必备）
11
kubectl describe pod teable-<最新Pod> -n teable
12

13
# 平滑（滚动）重启 Deployment
14
kubectl rollout restart deployment teable -n teable

3. 最终验证：

等待 Pod 启动完毕：kubectl get pods
打开你的浏览器，访问 http://10.135.40.151:30000 或 152、153 的 30000 端口。
你现在应该能看到 Teable 的界面了！

Git 命令保姆级教程

Wed, 04 Feb 2026 00:00:00 GMT

Git 命令保姆级教程#

Git 是什么#

Git 就像是代码的”时光机”，可以随时回到以前的版本。

举个生活中的例子#

你在写一篇论文：

没有 Git：保存成「论文最终版」「论文最终版2」「论文真的最终版」「绝对不改版」… 文件乱七八糟
有 Git：一个文件，随时可以回到任何历史版本，清清爽爽

为什么要学 Git#

代码丢了？不怕，随时回退
改错了？不怕，一键撤销
多人一起写代码？不会互相覆盖
谁改了什么？每条记录都有记载

一、安装 Git#

Windows 用户#

打开这个网站：git-scm.com
点击下载安装包
双击安装，一路点击「下一步」就可以了

验证是否安装成功#

打开命令行（按 Win+R，输入 cmd），输入：

Terminal window

1
git --version

如果看到版本号（比如 git version 2.40.0），恭喜你，安装成功了！

二、初次配置#

安装好后，要先告诉 Git 你是谁，不然以后提交代码不知道是谁干的。

Terminal window

1
# 设置你的名字
2
git config --global user.name "你的名字"
3

4
# 设置你的邮箱
5
git config --global user.email "你的邮箱@example.com"

这样就配置好了！

三、Git 工作原理（超重要！）#

Git 有三个区域，理解了这三个区，你就掌握了一半。

1
┌─────────┐    git add    ┌─────────┐    git commit   ┌─────────┐
2
│ 工作区   │  ────────>    │ 暂存区   │  ────────>      │ 仓库区   |
3
│ (写代码) │               │ (准备区) │                 │ (已保存) │
4
└─────────┘               └─────────┘                 └─────────┘

区域	是什么	对应命令
工作区	你正在改的代码	改代码的地方
暂存区	准备要提交的文件	`git add` 后进入这里
仓库	已保存的版本历史	`git commit` 后存到这里

简单类比#

工作区 = 你的书桌，正在写的作业
暂存区 = 文件袋，准备交上去的作业
仓库 = 保险柜，所有已交的作业都保存在这里

四、最常用的命令#

1️⃣ git init - 创建新仓库#

在一个文件夹里运行这个命令，这个文件夹就被 Git “接管”了。

Terminal window

1
git init

2️⃣ git clone - 下载别人的项目#

Terminal window

1
git clone https://github.com/用户名/项目名.git

就像把 GitHub 上的项目复制到你的电脑上。

3️⃣ git status - 查看当前状态#

Terminal window

1
git status

这是最常用的命令！随时用它来看看：

哪些文件被改了
哪些文件还没添加到暂存区
当前在哪个分支

养成习惯：改代码前后都看一下 git status

4️⃣ git add - 添加文件到暂存区#

Terminal window

1
# 添加某个文件
2
git add 文件名.txt
3

4
# 添加所有文件
5
git add .
6

7
# 添加所有变化（包括删除的文件）
8
git add -A

5️⃣ git commit - 提交保存#

Terminal window

1
git commit -m "说明你改了什么"

每次提交都要写清楚改了什么，方便以后查找。

提交信息怎么写？#

1
❌ 别这样写：
2
"fix bug"
3
"update"
4
"改完了"
5

6
✅ 这样写才好：
7
"修复登录按钮点击没反应的问题"
8
"添加用户头像上传功能"
9
"更新导航栏样式"

6️⃣ git log - 查看历史记录#

Terminal window

1
# 简洁显示
2
git log --oneline
3

4
# 显示最近的 3 条
5
git log -3

五、常用操作指南#

场景1：改错代码了，想撤销#

Terminal window

1
# 撤销单个文件的修改（恢复到上一次提交的状态）
2
git checkout -- 文件名.txt
3

4
# 或者用新命令（推荐）
5
git restore 文件名.txt

场景2：add 错文件了，想从暂存区移除#

Terminal window

1
git reset HEAD 文件名.txt

场景3：commit 信息写错了，想改#

Terminal window

1
# 修改最后一次提交的信息
2
git commit --amend

场景4：想看看改了什么#

Terminal window

1
# 查看还没 add 的修改
2
git diff
3

4
# 查看已经 add 的修改
5
git diff --staged

六、分支是什么？#

分支就像是一个”平行宇宙”。

你在主分支（main）上，可以创建一个新分支（比如 feature/login），在新分支上写代码，写完了再合并回去。

好处：新功能开发不会影响主分支的稳定性。

分支常用命令#

Terminal window

1
# 查看所有分支
2
git branch
3

4
# 创建并切换到新分支
5
git checkout -b 分支名
6

7
# 切换到已有分支
8
git checkout 分支名
9

10
# 删除分支
11
git branch -d 分支名

七、远程操作（配合 GitHub 使用）#

把本地代码推送到 GitHub#

Terminal window

1
# 第一次推送（需要设置关联）
2
git push -u origin main
3

4
# 后续推送
5
git push

从 GitHub 拉取最新代码#

Terminal window

1
git pull

八、完整工作流程#

新项目从零开始#

Terminal window

1
# 1. 创建文件夹
2
mkdir my-project
3
cd my-project
4

5
# 2. 初始化 Git
6
git init
7

8
# 3. 创建文件并写代码
9
echo "# 我的第一个项目" > README.md
10

11
# 4. 添加文件
12
git add .
13

14
# 5. 提交
15
git commit -m "初始化项目"
16

17
# 6. 关联 GitHub 仓库（先在 GitHub 上创建仓库）
18
git remote add origin https://github.com/你的用户名/项目名.git
19

20
# 7. 推送
21
git push -u origin main

日常开发流程#

Terminal window

1
# 1. 拉取最新代码
2
git pull
3

4
# 2. 改代码...
5

6
# 3. 查看改了什么
7
git status
8

9
# 4. 添加文件
10
git add .
11

12
# 5. 提交
13
git commit -m "写清楚你改了什么"
14

15
# 6. 推送
16
git push

九、常见问题解答#

Q1: 提示 “fatal: not a git repository”#

意思：当前文件夹不是 Git 仓库

解决：运行 git init，或者确认你在这个项目文件夹里

Q2: git add 后后悔了，想撤销#

Terminal window

1
git reset HEAD 文件名

Q3: push 时提示失败#

原因：GitHub 上有别人推送的新代码，你的版本不是最新的

解决：先拉取，再推送

Terminal window

1
git pull
2
git push

Q4: 怎么忽略某些文件？#

创建一个叫 .gitignore 的文件，写进去要忽略的内容：

1
# 忽略所有 .pyc 文件
2
*.pyc
3

4
# 忽略 node_modules 文件夹
5
node_modules/
6

7
# 忽略配置文件（里面有密码）
8
config.ini
9

10
# 忽略日志文件
11
*.log

Q5: 代码改错了，怎么找回旧版本？#

Terminal window

1
# 查看某个版本的文件内容
2
git show HEAD:文件名.txt
3

4
# 恢复文件到某个版本
5
git checkout HEAD -- 文件名.txt

十、小技巧#

1. 设置命令别名（偷懒神器）#

把长命令变短命令：

Terminal window

1
# 设置别名
2
git config --global alias.st status
3
git config --global alias.co checkout
4
git config --global alias.br branch
5
git config --global alias.ci commit
6

7
# 以后可以用短命令了
8
git st        # 等同于 git status
9
git co main   # 等同于 git checkout main
10
git br        # 等同于 git branch

2. 快捷键#

按键	作用
q	退出查看日志界面
方向键	上下翻动
/关键词	搜索内容

最后的建议#

多提交：写完一个小功能就提交，不要堆一大堆
写清楚说明：让别人（和未来的自己）一眼就知道改了什么
多用分支：新功能在新分支开发，别直接改主分支
push 前先 pull：减少冲突
勤用 git status：随时知道当前状态

祝你 Git 用得顺手！🎉

每日微信推送天气

Sun, 21 Sep 2025 00:00:00 GMT

微信推送天气#

1、申请公众号测试用户#

Terminal window

1
使用微信扫码即可：https://mp.weixin.qq.com/debug/cgi-bin/sandbox?t=sandbox/login

2、进入页面以后我们来获取到这四个值#

1、appID和appSecret

image.png

2、想让谁收消息，谁就用微信扫二维码，然后出现在用户列表，获取微信号（openId）

image.png

3、新增测试模板获得 template_id（模板ID）

image.png

模板标题随便填，模板内容如下，可以根据需求自己定制

模板内容：

Terminal window

1
今天：{{date.DATA}}
2
地区：{{region.DATA}}
3
天气：{{weather.DATA}}
4
气温：{{temp.DATA}}
5
风向：{{wind_dir.DATA}}
6
每日一句小情话：{{today_note.DATA}}

3、项目配置#

Terminal window

1
# weather_report.py代码如下
2
# 安装依赖 pip3 install requests html5lib bs4 schedule
3
import os
4
import requests
5
import json
6
from bs4 import BeautifulSoup
7

8
# 从测试号信息获取
9
appID = os.environ.get("APP_ID")
10
appSecret = os.environ.get("APP_SECRET")
11
# 收信人ID即 用户列表中的微信号
12
openId = os.environ.get("OPEN_ID")
13
# 天气预报模板ID
14
weather_template_id = os.environ.get("TEMPLATE_ID")
15

16
def get_weather(my_city):
17
    urls = ["http://www.weather.com.cn/textFC/hb.shtml",
18
            "http://www.weather.com.cn/textFC/db.shtml",
19
            "http://www.weather.com.cn/textFC/hd.shtml",
20
            "http://www.weather.com.cn/textFC/hz.shtml",
21
            "http://www.weather.com.cn/textFC/hn.shtml",
22
            "http://www.weather.com.cn/textFC/xb.shtml",
23
            "http://www.weather.com.cn/textFC/xn.shtml"
24
            ]
25
    for url in urls:
26
        resp = requests.get(url)
27
        text = resp.content.decode("utf-8")
28
        soup = BeautifulSoup(text, 'html5lib')
29
        div_conMidtab = soup.find("div", class_="conMidtab")
30
        tables = div_conMidtab.find_all("table")
31
        for table in tables:
32
            trs = table.find_all("tr")[2:]
33
            for index, tr in enumerate(trs):
34
                tds = tr.find_all("td")
35
                # 这里倒着数，因为每个省会的td结构跟其他不一样
36
                city_td = tds[-8]
37
                this_city = list(city_td.stripped_strings)[0]
38
                if this_city == my_city:
39

40
                    high_temp_td = tds[-5]
41
                    low_temp_td = tds[-2]
42
                    weather_type_day_td = tds[-7]
43
                    weather_type_night_td = tds[-4]
44
                    wind_td_day = tds[-6]
45
                    wind_td_day_night = tds[-3]
46

47
                    high_temp = list(high_temp_td.stripped_strings)[0]
48
                    low_temp = list(low_temp_td.stripped_strings)[0]
49
                    weather_typ_day = list(weather_type_day_td.stripped_strings)[0]
50
                    weather_type_night = list(weather_type_night_td.stripped_strings)[0]
51

52
                    wind_day = list(wind_td_day.stripped_strings)[0] + list(wind_td_day.stripped_strings)[1]
53
                    wind_night = list(wind_td_day_night.stripped_strings)[0] + list(wind_td_day_night.stripped_strings)[1]
54

55
                    # 如果没有白天的数据就使用夜间的
56
                    temp = f"{low_temp}——{high_temp}摄氏度" if high_temp != "-" else f"{low_temp}摄氏度"
57
                    weather_typ = weather_typ_day if weather_typ_day != "-" else weather_type_night
58
                    wind = f"{wind_day}" if wind_day != "--" else f"{wind_night}"
59
                    return this_city, temp, weather_typ, wind
60

61

62
def get_access_token():
63
    # 获取access token的url
64
    url = 'https://api.weixin.qq.com/cgi-bin/token?grant_type=client_credential&appid={}&secret={}' \
65
        .format(appID.strip(), appSecret.strip())
66
    response = requests.get(url).json()
67
    print(response)
68
    access_token = response.get('access_token')
69
    return access_token
70

71

72
def get_daily_love():
73
    # 每日一句情话
74
    url = "https://api.lovelive.tools/api/SweetNothings/Serialization/Json"
75
    r = requests.get(url)
76
    all_dict = json.loads(r.text)
77
    sentence = all_dict['returnObj'][0]
78
    daily_love = sentence
79
    return daily_love
80

81

82
def send_weather(access_token, weather):
83
    # touser 就是 openID
84
    # template_id 就是模板ID
85
    # url 就是点击模板跳转的url
86
    # data就按这种格式写，time和text就是之前{{time.DATA}}中的那个time，value就是你要替换DATA的值
87

88
    import datetime
89
    today = datetime.date.today()
90
    today_str = today.strftime("%Y年%m月%d日")
91

92
    body = {
93
        "touser": openId.strip(),
94
        "template_id": weather_template_id.strip(),
95
        "url": "https://weixin.qq.com",
96
        "data": {
97
            "date": {
98
                "value": today_str
99
            },
100
            "region": {
101
                "value": weather[0]
102
            },
103
            "weather": {
104
                "value": weather[2]
105
            },
106
            "temp": {
107
                "value": weather[1]
108
            },
109
            "wind_dir": {
110
                "value": weather[3]
111
            },
112
            "today_note": {
113
                "value": get_daily_love()
114
            }
115
        }
116
    }
117
    url = 'https://api.weixin.qq.com/cgi-bin/message/template/send?access_token={}'.format(access_token)
118
    print(requests.post(url, json.dumps(body)).text)
119

120

121

122
def weather_report(this_city):
123
    # 1.获取access_token
124
    access_token = get_access_token()
125
    # 2. 获取天气
126
    weather = get_weather(this_city)
127
    print(f"天气信息： {weather}")
128
    # 3. 发送消息
129
    send_weather(access_token, weather)
130

131

132

133
if __name__ == '__main__':
134
  # 替换成自己的城市
135
    weather_report("宿州")

Terminal window

1
# weather_report.yml代码如下
2
# This workflow will install Python dependencies, run tests and lint with a single version of Python
3

4
name: 天气预报推送
5

6
on:
7
  schedule:
8
    # 设置启动时间，为 UTC 时间, UTC23点 对应北京时间早7点
9
    - cron : '00 23 * * *'
10
  workflow_dispatch:
11

12
permissions:
13
  contents: read
14

15
jobs:
16
  build:
17

18
    runs-on: ubuntu-latest
19
    env:
20
      TZ: Asia/Shanghai
21
    steps:
22
    - uses: actions/checkout@v3
23
    - name: Set up Python 3.12
24
      uses: actions/setup-python@v3
25
      with:
26
        python-version: "3.12"
27
    - name: Install dependencies
28
      run: |
29
        python -m pip install --upgrade pip
30
        if [ -f requirements.txt ]; then pip install -r requirements.txt; fi
31
    - name: Run weather Report
32
      run: |
33
        python weather_report.py
34
      env:
35
        APP_ID: ${{ secrets.APP_ID }}
36
        APP_SECRET: ${{ secrets.APP_SECRET }}
37
        OPEN_ID: ${{ secrets.OPEN_ID }}
38
        TEMPLATE_ID: ${{ secrets.TEMPLATE_ID }}

（1）将上述两个代码推送到Github上后，进入自己项目的Settings ----> Secrets and variables ---> Actions —> New repository secret 配置好以下四个值（见下文）

image.png

（2）进入自己项目的Action ----> 天气预报推送 ---> weather_report.yml —> 修改cron表达式的执行时间

image.png

（3）测试运行Flowable工作流是否可以正常使用，推送消息是否可达

image.png

从零开始搭建Bolo个人博客系统

Sun, 13 Jul 2025 00:00:00 GMT

自己个人博客系统从搭建运行至今，整个搭建过程可以说是踩坑无数。因此将整个搭建过程以及踩过的坑写到此处，希望可以给搭建个人博客系统的朋友提供一些帮助。整个过程教程包括安装 Bolo、Nginx 进行反向代理以及 SSL证书的申请与使用。云服务器的选购、域名的购买与备案、域名服务器解析就不多赘述了，百度可查。

Bolo的安装#

一：获取最新的镜像#

Terminal window

1
docker pull tangcuyu/bolo-solo

二：安装 MySQL#

Terminal window

1
# 安装mysql:5.6,直接docker run 他会自动去官方镜想下载
2
# MYSQL_ROOT_PASSWORD=[的数据库密码，此处写的是123456
3
docker run --name mysql -p 3306:3306 -e MYSQL_ROOT_PASSWORD=123456 -d mysql:5.7
4
# docker安装的mysql默认允许远程连接，可以使用Navicat等软件连接数据库
5
# 进入容器mysql
6
docker exec -it mysql bash
7

8
# 进入数据库 p后面跟你的密码
9
mysql -uroot -p123456
10

11
# 创建数据库(数据库名:solo;字符集utf8mb4;排序规则utf8mb4_general_ci)
12
create database bolo DEFAULT CHARACTER SET utf8mb4 COLLATE utf8mb4_general_ci;
13
# 出现Query OK, 1 row affected (0.00 sec)表示成功
14
#退出数据库
15
exit
16
#退出容器
17
exit

三：安装Bolo#

运行如下命令：

Terminal window

1
docker run --detach --name bolo --network=host \
2
--env RUNTIME_DB="MYSQL" \
3
--env JDBC_USERNAME="root" \
4
--env JDBC_PASSWORD="123456" \
5
--env JDBC_DRIVER="com.mysql.cj.jdbc.Driver" \
6
--env JDBC_URL="jdbc:mysql://127.0.0.1:3306/solo?useUnicode=yes&characterEncoding=UTF-8&useSSL=false&serverTimezone=UTC" \
7
tangcuyu/bolo-solo --listen_port=8080 --server_scheme=http --server_host=www.hostname.com(域名/IP地址)

--detach: 这个选项告诉 Docker 在启动后将程序与控制台分离，使其进入后台 运行。
--name bolo: bolo 是容器的名字，也可以改成自己喜欢的名字如 MyBolo，这个无所谓
RUNTIME_DB="MYSQL": 指明我们此处使用的数据库为 MYSQL
JDBC_USERNAME="root"： 指明 MYSQL 数据连接时使用的用户名，默认都是 root
JDBC_PASSWORD="123456":指明 MySQL 数据库连接时用户密码，使用时注意将 123456 替换成自己在上一步所设置的密码
env JDBC_DRIVER="com.mysql.cj.jdbc.Driver":数据库连接驱动包
--server_host=www.hostname.com:个人域名，如果没有可设置为自己的服务器 IP
—env JDBC_URL=… ：数据库的IP地址。如果是在本地安装的直接写127.0.0.1，如果通过docker安装将其改成自己的服务器的IP地址
--listen_port=8080:指明 solo 监听的端口此处使用的是 8080,如果不想配置 nginx 此处可以换成 80

命令执行完成之后没有报错的话，通过 docker ps 查看当前当前容器列表中是否有名字叫 bolo 的容器，如果有证明启动成功了，此时可以通过 个人域名/ip+:8080 来进行访问，类似 http://192.168.30.2:8080,如果不想配置 nginx 可以将 8080 换成 80，可以直接通过域名/IP来直接进行访问。不出意外会出现如下界面（如果出现不能访问的情况考虑是否是防火墙配置有问题，查看是否开发 8080 或者 80 端口）

由于后边我们需要配置 nginx 进行反向代理以及配置 ssl 证书来实现 https 方式访问，因此在看到 solo 启动正常之后，此处创建的 solo 镜像需要删除，等配置完 nginx 之后重新在创建一个。删除 solo 容器直接执行下边命令

Terminal window

1
docker kill --name bolo
2
docker rm --name bolo

四：安装 `nginx`（可选）#

安装之前为了后续配置 nginx 方便，我们需要在本地创建几个文件，用来挂载 nginx 的配置文件

Terminal window

1
# 切换到服务器根目录
2
cd /
3
# 创建主目录
4
mkdir dockerData
5
# 创建文件
6
mkdir dockerData/nginx dockerData/nginx/conf dockerData/nginx/logs dockerData/nginx/www dockerData/nginx/ssl

上边的文件目录名称可以任意，此处我使用 dockerDate

dockerData/nginx 用于存放 docker 下 nginx 自定义文件
dockerData/nginx/conf 存放 nginx 配置文件
dockerData/nginx/log 存放 nginx 日志文件
dockerData/nginx/www:存放 nginx 访问的资源文件
dockerData/nginx/ssl 存放 ssl 证书

启动 nginx

Terminal window

1
docker run --name nginx -p 80:80 -d nginx

如果没有备案，80 端口可能是禁止访问的，因此可以可以将上边的 80:80换成 8081:80。命令执行完成之后，没有报错的话可以通过 docker ps 来看 nginx 是否正常运行，在运行的情况下访问的域名加上端口号查看是否正常安装，如果使用的 80 端口默认可以省略。出现如下界面表示安装成功。

导出配置文件：

Terminal window

1
docker cp nginx:/etc/nginx/nginx.conf /dockerData/nginx/conf/nginx.conf  #导出配置文件nginx.conf
2
docker cp nginx:/etc/nginx/conf.d /dockerData/nginx/conf/conf.d  #导出conf.d
3
cd /dockerData/nginx/
4
ls conf/   #查看配置文件是否导出成功
5
docker stop nginx  #删除刚才创建的nginx容器
6
docker rm nginx

重新创建一个 nginx 容器，挂载刚才本地导出的配置文件，便于后续更改 nginx 的配置信息

Terminal window

1
docker run -d -p 80:80 --name nginx \
2
-v /dockerData/nginx/conf/nginx.conf:/etc/nginx/nginx.conf \
3
-v /dockerData/nginx/conf/conf.d:/etc/nginx/conf.d \
4
-v /dockerData/nginx/www:/usr/share/nginx/html \
5
-v /dockerData/nginx/logs:/var/log/nginx nginx

-v /dockerData/nginx/conf/nginx.conf:/etc/nginx/nginx.conf : 挂载配置文件 nginx.conf
-v /dockerData/nginx/conf/conf.d:/etc/nginx/conf.d: 挂载配置文件 default.conf
-v /dockerData/nginx/www:/usr/share/nginx/html : 挂载项目文件
-v /dockerData/nginx/logs:/var/log/nginx : 挂载配置文件

五：配置 `ssl` 证书（可选）#

从 http 升级到 https 只需要在 nginx 中配置一个证书即可，一般性的 ssl 证书是可以免费申请的

配置 nginx 配置文件

大家可以参考我的配置文件进行配置，配置自己的 default.conf 文件

Terminal window

1
worker_processes  1;
2

3
events {
4
    worker_connections  1024;
5
}
6

7
http {
8
  upstream backend {
9
        server localhost:8080; # 定义后端服务器做负载均衡
10
    }
11
    # 监听 HTTPS 端口并代理请求到 http://公网IP:8080
12
    server {
13
        listen 443 ssl;
14
        server_name www.hostname.com;
15

16
        ssl_certificate     /ssl/你的SSL证书.pem; # SSL 证书路径
17
        ssl_certificate_key /ssl/你的SSL证书.key; # SSL 证书私钥路径
18
        ssl_protocols TLSv1 TLSv1.1 TLSv1.2 TLSv1.3;
19
        ssl_prefer_server_ciphers on;
20

21
        location / {
22
            proxy_pass http://公网IP:8080/;
23
            proxy_set_header HOST $host;
24
            proxy_set_header X-Real-IP $remote_addr;
25
            proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
26
            proxy_set_header Upgrade $http_upgrade;
27
            proxy_set_header Connection "upgrade";
28
            client_max_body_size 100m;
29
        }
30
    }
31
    server {
32
        listen 80;
33
        server_name www.hostname.com;
34

35
        # 自动将 HTTP 重定向到 HTTPS
36
        return 301 https://$host$request_uri;
37
    }
38
}

注意:上边的配置文件只是参考，要根据自己的服务器做出相应更改。

由于我们现在用的 nginx 容器并未监听 443 端口，所以需要删除现在的容器，重新启动一个新的 nginx 容器

Terminal window

1
#先删除原来的nginx容器
2
docker stop nginx;
3
docker rm nginx;
4

5
#创建新的nginx容器(一般默认映射HTTP端口80,HTTPS端口443即可)
6
docker run -d -p 80:80 -p 443:443 --name nginx \
7
-v /dockerData/nginx/conf/nginx.conf:/etc/nginx/nginx.conf \
8
-v /dockerData/nginx/conf/conf.d:/etc/nginx/conf.d \
9
-v /dockerData/nginx/ssl:/ssl/ \
10
-v /dockerData/nginx/www:/usr/share/nginx/html \
11
-v /dockerData/nginx/logs:/var/log/nginx nginx
12

13
#创建新的solo容器并映射到8080端口，用上边的nginx进行反向代理
14
docker run --detach --name bolo --network=host \
15
--env RUNTIME_DB="MYSQL" \
16
--env JDBC_USERNAME="root" \
17
--env JDBC_PASSWORD="123456" \
18
--env JDBC_DRIVER="com.mysql.cj.jdbc.Driver" \
19
--env JDBC_URL="jdbc:mysql://120.55.42.140:3306/solo?useUnicode=yes&characterEncoding=UTF-8&useSSL=false&serverTimezone=UTC" \
20
tangcuyu/bolo-solo --listen_port=8080 --server_scheme=https --server_host=www.hostname.com(域名/IP地址) --server_port=443

--server_scheme=http 换成 --server_scheme=https 即可
--server_port：最终访问端口，使用浏览器默认的 80 或者 443 的话值留空即可

重启 nginx，docker restart nginx,然后用浏览器访问 https://域名

SeaFile使用Duplicati备份

Fri, 30 May 2025 00:00:00 GMT

Duplicati备份相关#

由于没有GUI界面的Linux的发行版本的包管理删去了其中比较重要的三个包管理组件,如下所示报错信息#

Terminal window

1
dpkg:dependency problems prevent configuration of duplicati:
2
duplicati depends on libappindicator0.1-cil I libappindicator3-0.1-cil I lib
3
yatana-appindicator1;however:
4

5
Package libappindicator0.1-cil is not installed.
6
Packagelibappindicator3-0.1-cil is not installed.
7
Packagelibayatana-appindicator1 is not installed.
8

9
duplicati depends on gtk-sharp2;however:
10
Package gtk-sharp2 is not installed.
11
dpkg: error processing package duplicati (--install):
12
dependency problems - leaving unconfigured
13

14
Processing triggers for mailcap (3.70+nmu1ubuntu1)
15
Errors were encounteredwhile processing

目前解决方法就是使用Docker的方式启动Duplicati进行备份和恢复#

一、配置本地镜像仓库地址或者代理Dockerhub的镜像仓库地址#

1.配置代理仓库地址#

Terminal window

1
vim /etc/docker/daemon.json
2

3
#配置文件内容如下：
4

5
{
6
    "registry-mirrors": ["https://docker.rainbond.cc/"],
7
    "insecure-registries":["10.135.40.180"]
8
}
9

10
# 加载systemd配置并重启docker
11
systemctl daemon-reload
12
systemctl restart docker

2.使用代理下载所需的duplicati容器镜像#

Terminal window

1
1.直接拉取镜像仓库image容器（速度慢）
2
docker pull lscr.io/linuxserver/duplicati：latest
3

4
2.使用本地镜像仓库拉取image容器（速度快）
5
docker login 10.135.40.180
6
username：admin
7
password：P@ssw0rd
8
--------------- 出现如下显示，则表示登陆成功 --------------
9
Authenticating with existing credentials...
10
Login Succeeded...
11

12
3.拉取docker镜像
13
docker pull 10.135.40.180/repository/linuxserver/duplicati:latest

二、启动docker或创建docker-compose配置文件#

1.启动dokcer容器#

Terminal window

1
docker run -d \
2
  --name=duplicati \
3
  -e PUID=1000 \
4
  -e PGID=1000 \
5
  -e TZ=Etc/UTC \
6
  -p 8200:8200 \
7
  -v /data/appdata/config:/config \
8
  -v /data/backups:/backups \
9
  -v /:/source \
10
  --restart unless-stopped \
11
  lscr.io/linuxserver/duplicati:latest

2.创建docker-compose配置文件如下所示#

1
version: "2.1"
2
services:
3
  duplicati:
4
    # 下面俩个image镜像二选一，不需要的注释即可
5
    image: lscr.io/linuxserver/duplicati:latest #image容器镜像
6
    image: 10.135.40.180/repository/linuxserver/duplicati:latest #本地image容器镜像
7
    container_name: duplicati
8
    environment:
9
      - PUID=1000
10
      - PGID=1000
11
      - TZ=Asia/Shanghai
12
    volumes:
13
      - /data/duplicati/config:/config
14
      - /opt:/opt
15
    ports:
16
      - 8200:8200
17
    restart: unless-stopped

最后docker-compose up -d启动容器即可

三、备份恢复数据后启动seafile服务#

notion image

使用docker-compose up 查看启动报错日志，若出现这种报错，则需要使用这行命令

Terminal window

1
chown -R root:root /opt/seafile-data

然后重启docker-comopse up -d即可打开

最后再更改一下后台的URL地址即可

notion image

使用Rsync进行Linux同步到Windows Server2019服务器备份

Thu, 17 Apr 2025 00:00:00 GMT

一、Linux配置#

1、rsync 通常预装在大多数 Linux 发行版上。但是，如果未安装，您可以使用以下命令进行安装#

Terminal window

1
apt update
2
apt install rsync
3
rsync --version

2、编写配置文件#

rsync 涉及到的配置主要有三个：

/etc/rsyncd.conf -> 对 rsync 服务进行配置
/tmp/rsync -> 待同步的目标目录，路径可以自定义
/etc/rsyncd.passwd ->里面包含用于进行密码验证的账号信息

3、/etc/rsyncd.conf 的配置#

Terminal window

1
# 备份模块配置（后续需要引用这个backup别名）
2
[backup]
3

4
# 需要备份的文件路径
5
path = /data/docker-data/volumes
6

7
# 访问的用户名
8
auth users = admin
9

10
# 创建的密码指向
11
secrets file = /etc/rsyncd.passwd

4、创建用户和密码#

Terminal window

1
# 创建文件夹
2
vim /etc/rsyncd.passwd
3

4
# 写入密码
5
echo "root:123456" > /etc/rsyncd.passwd
6

7
#更改文件权限
8
chmod 600 /etc/rsyncd.passwd

5、查看rsync状态并手动启动#

Terminal window

1
# 查看rsync状态
2
systemctl status rsyncd
3

4
# 看到这个则表示服务处于运行状态
5
● rsync.service - fast remote file copy program daemon
6
     Loaded: loaded (/lib/systemd/system/rsync.service; enabled; vendor preset: enabled)
7
     Active: active (running)
8

9
# 启动 rsync 服务：
10
systemctl start rsync
11

12
# 设置开机自启
13
systemctl enable rsync

二、Windows 配置#

1、下载 cwrsync#

Terminal window

1
# cwRsyncServer_4.1.0_Installer.exe安装即可
2
https://www.itefix.net/cwrsync-free-edition

2、本地的Linux向本地的Winodws上传输数据执行命令#

1、进入ICW文件中配置rsyncd.conf文件#

Terminal window

1
[backup]
2
path = /cygdrive/d/rsync_backup_teable/teable_backup
3
read only = false
4
transfer logging = yes
5
ignore errors
6
# 客户端请求显示模块列表时，该模块是否显示出来
7
list = no
8
# 允许所有的IP进行访问
9
hosts allow = *
10
# auth users = admin
11
# secrets file = rsync.password

2、在Linux上配置定时同步的cron#

Terminal window

1
0 * * * * date >> /var/log/rsync_backup.log && rsync -avz /var/lib/docker/volumes admin@10.135.40.201::backup --delete >> /var/log/rsync_backup.log 2>&1

3、查看系统cron运行日志#

Terminal window

1
grep CRON /var/log/syslog | grep rsync

3、云服务器上的Linux向本地的Winodws上传输数据执行命令#

1、修改云服务器上的配置文件#

Terminal window

1
# vim /etc/rsyncd.conf
2
[backup]
3
path = /data/docker-data/volumes
4
auth users = admin
5
secrets file = /etc/rsyncd.passwd

2、修改云服务器连接rsync的通讯密码 vim /etc/rsyncd.passwd#

Terminal window

1
admin:P@ssw0rd

3、本地的Winodws上写一个bat脚本去定时运行备份#

Terminal window

1
@echo off
2
set LOGFILE=D:/rsync_backup_teable/cloud_teable_backup_log.txt
3

4
echo Starting rsync backup at %DATE% %TIME% >> %LOGFILE%
5
rsync.exe -avz --port=873 --password-file=/cygdrive/d/rsync_backup_teable/cloud_teable_backup/rsyncpwd.txt < D:/rsync_backup_teable/ICW/password.txt admin@114.98.176.218::backup /cygdrive/d/rsync_backup_teable/cloud_teable_backup/volumes --delete >> %LOGFILE% 2>&1
6

7
echo Backup finished at %DATE% %TIME% >> %LOGFILE%
8
echo -------------------------------------------------------------------------------------------------------------------------------------------------- >> %LOGFILE%

4、常见的参数#

Terminal window

1
-a: 归档模式，使用递归传输并保持文件的属性
2
-v: 显示传输过程中的详细信息
3
-P: 显示文件传输的进度信息
4
-z: 传输中进行压缩，提高传输速度
5

6
--password-file： 登录时用到的密码文件，该文件直接把密码包含就可以，用户名需要显式指定
7
--exclude-from:  指定不需要进行传输的文件和文件夹
8
--delete: 在 exclude/include 规则生效后执行，假如服务器中文件比传入的文件多，则删除，少的话，则添加。

5、解决出现下面错误：password file must not be other-accessible#

Terminal window

1
@echo off
2
rsync.exe -avz --port=873 --password-file=/cygdrive/d/rsync_backup_teable/teable_backup/test/rsyncpwd.txt < D:/rsync_backup_teable/ICW/password.txt admin@114.98.176.218::backup /cygdrive/d/rsync_backup_teable/teable_backup/test --delete
3
pause

三、将rsync同步的备份文件进行定时打包，并保留15个备份#

备份工作时间保持不变，检索时间段内，是则进行备份操作：

工作日（周一到周五）：8:00-18:00
周末（周六周日）：7:00-8:00、12:00-13:00、17:00-18:00

Terminal window

1
@echo off
2
setlocal EnableDelayedExpansion
3

4
REM 设置日志文件路径
5
set "BASE_DIR=D:\rsync_backup_teable"
6
set "LOG_DIR=%BASE_DIR%\teable_backup_tar"
7
set "LOG_FILE=%LOG_DIR%\backup_log.txt"
8

9
REM 创建基础目录和日志目录（如果不存在）
10
if not exist "%BASE_DIR%" mkdir "%BASE_DIR%"
11
if not exist "%LOG_DIR%" mkdir "%LOG_DIR%"
12

13
REM 确保日志文件存在
14
if not exist "%LOG_FILE%" type nul > "%LOG_FILE%"
15

16
REM 记录开始时间
17
echo ========================================== >> "%LOG_FILE%"
18
echo 开始执行备份 %date% %time%
19
echo 开始执行备份 %date% %time% >> "%LOG_FILE%"
20

21
REM 检查是否为工作日（周一到周五）
22
for /f %%a in ('wmic path win32_localtime get dayofweek ^| findstr /r [0-6]') do set DOW=%%a
23

24
REM 使用 WMIC 获取系统时间
25
for /f "skip=1" %%a in ('wmic path win32_localtime get hour^,minute /format:value') do (
26
    for /f "tokens=1,2 delims==" %%b in ("%%a") do (
27
        if "%%b"=="Hour" set "CURRENT_HOUR=%%c"
28
        if "%%b"=="Minute" set "CURRENT_MINUTE=%%c"
29
    )
30
)
31

32
REM 确保变量不为空
33
if not defined CURRENT_HOUR set "CURRENT_HOUR=0"
34
if not defined CURRENT_MINUTE set "CURRENT_MINUTE=0"
35

36
REM 记录当前时间到日志
37
echo 当前系统时间: !CURRENT_HOUR!时!CURRENT_MINUTE!分
38
echo 当前系统时间: !CURRENT_HOUR!时!CURRENT_MINUTE!分 >> "%LOG_FILE%"
39

40
REM 检查是否在允许备份的时间段内
41
set "ALLOW_BACKUP=0"
42

43
REM 工作日（周一到周五）判断
44
if %DOW% LSS 6 (
45
    REM 工作日 8:00-18:00
46
    if !CURRENT_HOUR! GEQ 8 if !CURRENT_HOUR! LSS 18 (
47
        set "ALLOW_BACKUP=1"
48
    )
49
) else (
50
    REM 周末特定时间段判断
51
    REM 7:00-8:00
52
    if !CURRENT_HOUR!==7 set "ALLOW_BACKUP=1"
53
    REM 12:00-13:00
54
    if !CURRENT_HOUR!==12 set "ALLOW_BACKUP=1"
55
    REM 17:00-18:00
56
    if !CURRENT_HOUR!==17 set "ALLOW_BACKUP=1"
57
)
58

59
REM 如果不在允许的时间范围内，退出
60
if !ALLOW_BACKUP!==0 (
61
    if %DOW% GEQ 6 (
62
        echo 当前是周末，不在指定的备份时间段内 ^(当前时间: !CURRENT_HOUR!时!CURRENT_MINUTE!分^)
63
        echo 周末备份时间段为：7-8点、12-13点、17-18点
64
        echo 当前是周末，不在指定的备份时间段内 ^(当前时间: !CURRENT_HOUR!时!CURRENT_MINUTE!分^) >> "%LOG_FILE%"
65
        echo 周末备份时间段为：7-8点、12-13点、17-18点>> "%LOG_FILE%"
66
        timeout /t 3 > nul
67
        exit /b 0
68
    ) else (
69
        echo 当前是工作日，不在工作时间内 ^(当前时间: !CURRENT_HOUR!时!CURRENT_MINUTE!分^)
70
        echo 工作日备份时间为：8-18点
71
        echo 当前是工作日，不在工作时间内 ^(当前时间: !CURRENT_HOUR!时!CURRENT_MINUTE!分^) >> "%LOG_FILE%"
72
        echo 工作日备份时间为：8-18点 >> "%LOG_FILE%"
73
        timeout /t 3 > nul
74
        exit /b 0
75
    )
76
)
77

78
REM 源目录 (要压缩的目录)
79
set "SOURCE_DIR=%BASE_DIR%\teable_backup"
80
REM 目标目录 (存放压缩包的目录)
81
set "DESTINATION_DIR=%BASE_DIR%\teable_backup_tar"
82

83
REM 创建源目录和目标目录（如果不存在）
84
if not exist "%SOURCE_DIR%" (
85
    mkdir "%SOURCE_DIR%"
86
    echo 创建源目录: %SOURCE_DIR%
87
    echo 创建源目录: %SOURCE_DIR% >> "%LOG_FILE%"
88
)
89

90
if not exist "%DESTINATION_DIR%" (
91
    mkdir "%DESTINATION_DIR%"
92
    echo 创建目标目录: %DESTINATION_DIR%
93
    echo 创建目标目录: %DESTINATION_DIR% >> "%LOG_FILE%"
94
)
95

96
REM 备份数量
97
set "MAX_BACKUPS=15"
98

99
REM 索引文件，用于记录下一个要替换的文件编号
100
set "INDEX_FILE=%DESTINATION_DIR%\last_backup_index.txt"
101

102
REM 确保索引文件存在
103
if not exist "%INDEX_FILE%" echo 1 > "%INDEX_FILE%"
104

105
REM 获取当前日期时间 (用于压缩包名称)
106
for /f "tokens=2 delims==" %%a in ('wmic OS Get localdatetime /value') do set "dt=%%a"
107
set "YEAR=%dt:~0,4%"
108
set "MONTH=%dt:~4,2%"
109
set "DAY=%dt:~6,2%"
110
set "HOUR=%dt:~8,2%"
111
set "MINUTE=%dt:~10,2%"
112
set "SECOND=%dt:~12,2%"
113

114
set "TIMESTAMP=%YEAR%%MONTH%%DAY%%HOUR%%MINUTE%%SECOND%"
115

116
REM 读取上一个备份使用的索引号
117
if exist "%INDEX_FILE%" (
118
    for /f "usebackq delims=" %%i in ("%INDEX_FILE%") do set "LAST_INDEX=%%i"
119
) else (
120
    set "LAST_INDEX=1"
121
)
122

123
REM 计算下一个要使用的索引号
124
set /a "NEXT_INDEX=(%LAST_INDEX% %% %MAX_BACKUPS%) + 1"
125

126
REM 构建压缩包名称
127
set "ARCHIVE_NAME=teable_backup_%TIMESTAMP%_%NEXT_INDEX%.tar"
128
set "ARCHIVE_PATH=%DESTINATION_DIR%\%ARCHIVE_NAME%"
129

130
REM 构建旧的压缩包名称
131
set "OLD_ARCHIVE_NAME="
132
for /f "delims=" %%f in ('dir /b /a-d "%DESTINATION_DIR%\teable_backup_*_%NEXT_INDEX%.tar" 2^>nul') do (
133
    set "OLD_ARCHIVE_NAME=%%f"
134
    goto :found_old_archive
135
)
136

137
:found_old_archive
138

139
if defined OLD_ARCHIVE_NAME (
140
    set "OLD_ARCHIVE_PATH=%DESTINATION_DIR%\%OLD_ARCHIVE_NAME%"
141
) else (
142
    set "OLD_ARCHIVE_PATH="
143
)
144

145
REM 检查源目录是否为空
146
dir /b /a "%SOURCE_DIR%\*" >nul 2>&1
147
if errorlevel 1 (
148
    echo 源目录为空或不可访问: %SOURCE_DIR%
149
    echo 源目录为空或不可访问: %SOURCE_DIR% >> "%LOG_FILE%"
150
    timeout /t 3 > nul
151
    exit /b 1
152
)
153

154
REM 删除旧的压缩包，如果存在
155
if defined OLD_ARCHIVE_PATH (
156
    echo 删除旧的压缩包: !OLD_ARCHIVE_PATH!
157
    echo 删除旧的压缩包: !OLD_ARCHIVE_PATH! >> "%LOG_FILE%"
158
    del /f /q "!OLD_ARCHIVE_PATH!" 2>nul
159
)
160

161
REM 使用 Windows tar 命令创建压缩包
162
echo 正在创建压缩包: !ARCHIVE_PATH!
163
echo 正在创建压缩包: !ARCHIVE_PATH! >> "%LOG_FILE%"
164
tar -cvf "!ARCHIVE_PATH!" -C "%SOURCE_DIR%" .
165
if !ERRORLEVEL! neq 0 (
166
    echo 创建压缩包失败
167
    echo 创建压缩包失败 >> "%LOG_FILE%"
168
    timeout /t 3 > nul
169
    exit /b 1
170
)
171

172
echo 压缩包创建成功: !ARCHIVE_PATH!
173
echo 压缩包创建成功: !ARCHIVE_PATH! >> "%LOG_FILE%"
174

175
REM 更新索引文件
176
echo !NEXT_INDEX! > "%INDEX_FILE%"
177

178
echo 备份完成
179
echo 备份完成 >> "%LOG_FILE%"
180
echo ========================================== >> "%LOG_FILE%"
181

182
REM 等待3秒后关闭窗口
183
timeout /t 3 > nul
184

185
endlocal
186
exit /b 0

Linux常用命令

Mon, 17 Feb 2025 00:00:00 GMT

Ubuntu Server如何设置静态IP#

Terminal window

1
#进入netplan目录
2
cd /etc/netplan
3

4
#修改yaml文件为
5
# This is the network config written by 'subiquity'
6
network:
7
  version: 2
8
  renderer: networkd
9
  ethernets:
10
    ens33:
11
      dhcp4: no
12
      addresses: [10.135.30.59/24]
13
      gateway4: 10.135.30.254
14
      routes:
15
        - to: default
16
          via: 10.135.30.254
17
      nameservers:
18
        addresses: [8.8.8.8, 114.114.114.144]
19

20
#刷新一下netplan，检测IP是否变化
21
netplan apply
22
hostname -I

ubuntu开启SSH#

Terminal window

1
# 安装openssh-server
2
apt update
3
apt install openssh-server
4

5
# 安装完成后,查看ssh是否开启，如果没启动就手动
6
systemctl status ssh
7
/etc/init.d/ssh start
8

9
# 配置SSH
10
vim /etc/ssh/sshd_config
11
将PermitRootLogin prohibit-password修改为PermitRootLogin yes
12

13
#重启ssh并设置开机自启ssh
14
systemctl restart ssh
15
systemctl enable ssh
16

17
#更改管理员root密码
18
passwd 123456

Ubuntu 22.04扩容磁盘LVM空间#

Terminal window

1
# 将新的空间新建一个磁盘分区
2
fdisk /dev/sda
3
-----------------------------------------------------------------------------------------
4
Welcome to fdisk (util-linux 2.37.2).
5
Changes will remain in memory only, until you decide to write them.
6
Be careful before using the write command.
7

8
GPT PMBR size mismatch (83886079 != 167772159) will be corrected by write.
9
This disk is currently in use - repartitioning is probably a bad idea.
10
It's recommended to umount all file systems, and swapoff all swap
11
partitions on this disk.
12

13

14
Command (m for help): n
15
Partition number (4-128, default 4):
16
First sector (83884032-167772126, default 83884032):
17
Last sector, +/-sectors or +/-size{K,M,G,T,P} (83884032-167772126, default 167772126):
18

19
Created a new partition 4 of type 'Linux filesystem' and of size 40 GiB.
20

21
Command (m for help): w
22
The partition table has been altered.
23
Syncing disks.
24
-----------------------------------------------------------------------------------------
25

26
# 将新建的分区sda4转换为PV并拓展ubuntu-vg这个卷组
27
pvcreate -ff -y /dev/sda4
28
Physical volume "/dev/sda4" successfully created.
29

30
vgextend ubuntu-vg /dev/sda4
31
Volume group "ubuntu-vg" successfully extended.
32

33
#扩容ubuntu-lv这个逻辑空间，并df -h查看
34
lvextend -l +100%FREE /dev/ubuntu-vg/ubuntu-lv

Terminal window

1
# 将新的空间新建一个磁盘分区
2
fdisk /dev/sda
3
-----------------------------------------------------------------------------------------
4
Welcome to fdisk (util-linux 2.37.2).
5
Changes will remain in memory only, until you decide to write them.
6
Be careful before using the write command.
7

8
GPT PMBR size mismatch (83886079 != 167772159) will be corrected by write.
9
This disk is currently in use - repartitioning is probably a bad idea.
10
It's recommended to umount all file systems, and swapoff all swap
11
partitions on this disk.
12

13

14
Command (m for help): n
15
Partition number (4-128, default 4):
16
First sector (83884032-167772126, default 83884032):
17
Last sector, +/-sectors or +/-size{K,M,G,T,P} (83884032-167772126, default 167772126):
18

19
Created a new partition 4 of type 'Linux filesystem' and of size 40 GiB.
20

21
Command (m for help): w
22
The partition table has been altered.
23
Syncing disks.
24
-----------------------------------------------------------------------------------------
25

26
# 将新建的分区sda4转换为PV并拓展ubuntu-vg这个卷组
27
pvcreate -ff -y /dev/sda4
28
Physical volume "/dev/sda4" successfully created.
29

30
vgextend ubuntu-vg /dev/sda4
31
Volume group "ubuntu-vg" successfully extended.
32

33
#扩容ubuntu-lv这个逻辑空间，并df -h查看
34
lvextend -l +100%FREE /dev/ubuntu-vg/ubuntu-lv

Docker 翻墙VPN配置指令和镜像仓库配置#

Terminal window

1
# 代理Windows的翻墙软件实现下载
2
export http_proxy="http://10.135.20.153:7890"
3
export https_proxy="https://10.135.20.153:7890"
4

5
#代理Docker实现翻墙下载Dockerhub仓库拉取
6
vim /etc/docker/daemon.json
7

8
#配置翻墙VPN
9
{
10
  "proxies": {
11
        "http-proxy": "http://10.135.30.71:7890",
12
        "https-proxy": "http://10.135.30.71:7890"
13
    }
14
}
15

16
#配置镜像仓库
17
{
18
  "registry-mirrors": ["https://docker.rainbond.cc/"]
19
}
20

21
# 加载systemd配置并重启docker
22
systemctl daemon-reload
23
systemctl restart docker

Docker使用本地仓库进行推拉送服务#

Terminal window

1
# 使用insecure-registries参数添加http支持
2
vim /etc/docker/daemon.json
3

4
#添加如下内容
5
{
6
  "insecure-registries":["10.135.40.180"]
7
}
8

9
# 重启systemctl服务
10
systemctl daemon-reload
11
systemctl restart docker
12

13
# 检查是否连接docker harbor仓库
14
docker login 10.135.40.180
15
username：admin
16
password：P@ssw0rd
17
--------------- 出现如下显示，则表示登陆成功 --------------
18
Authenticating with existing credentials...
19
Login Succeeded...
20

21
------对本地Docker容器进行打标签------
22
# 查看本地Docker容器标签名
23
docker images
24
docker tag SOURCE_IMAGE[:TAG] 10.135.40.180/repository/REPOSITORY[:TAG]
25
# 例如参考如下命令
26
docker tag tomcat:latest(已经存在的容器名+标签名) 10.135.40.180/repository/tomcat:v1(所需打标签的容器名+标签名)
27
# 再执行以下docker images 则可以看到容器内新打上的容器+标签名
28

29
------使用Docker命令进行push推送至Harbor服务器内------
30
# 推送镜像到当前项目
31
docker push 10.135.40.180/repository/REPOSITORY[:TAG]
32
# 例如参考如下命令
33
docker push 10.135.40.180/repository/tomcat:v1(已经打好标签的容器名+标签名)
34

35
------使用Docker命令进行pull推送至本地服务器内------
36
# 拉取Docker镜像至本地服务器
37
docker pull 10.135.40.180/repository/REPOSITORY[:TAG]
38
# 例如参考如下命令
39
docker pull 10.135.40.180/repository/tomcat:v1(已经打好标签的容器名+标签名)

局域网搭建浏览器可信任的SSL证书#

Terminal window

1
# 创建CA机构证书
2
openssl genrsa -out myCA.key 2048
3
openssl req -new -x509 -key myCA.key -out myCA.cer -days 36500
4

5
#创建服务器证书
6
openssl genrsa -out server.key 2048
7

8
#创建一个签名请求
9
vim openssl.cnf
10
-----------------------------------------------------------------------------------------
11
[ req ]
12
distinguished_name = req_distinguished_name
13
req_extensions = v3_req
14
[ req_distinguished_name ]
15
countryName                     = Country Name (2 letter code)
16
countryName_default             = XX
17
countryName_min                 = 2
18
countryName_max                 = 2
19
stateOrProvinceName             = State or Province Name (full name)
20
#stateOrProvinceName_default    = Default Province
21
localityName                    = Locality Name (eg, city)
22
localityName_default            = Default City
23
0.organizationName              = Organization Name (eg, company)
24
0.organizationName_default      = Default Company Ltd
25
# we can do this but it is not needed normally :-)
26
#1.organizationName             = Second Organization Name (eg, company)
27
#1.organizationName_default     = World Wide Web Pty Ltd
28
organizationalUnitName          = Organizational Unit Name (eg, section)
29
#organizationalUnitName_default =
30
commonName                      = Common Name (eg, your name or your server\'s hostname)
31
commonName_max                  = 64
32
emailAddress                    = Email Address
33
emailAddress_max                = 64
34
# SET-ex3                       = SET extension number 3
35
[ v3_req ]
36
subjectAltName = @alt_names
37

38
[ alt_names ]
39
DNS.1 = 8.8.8.8
40
IP.1 = 192.168.1.2
41
-----------------------------------------------------------------------------------------
42

43
#生成的服务器证书文件
44
openssl req -config openssl.cnf -new -out server.req -key server.key
45

46
#通过CA机构证书对服务器证书进行签名认证
47
openssl x509 -req  -extfile openssl.cnf -extensions v3_req -in server.req -out server.cer -CAkey myCA.key -CA myCA.cer -days 36500 -CAcreateserial -CAserial serial

Ubuntu挂载磁盘#

Terminal window

1
# 使用fdisk命令
2
fdisk -l
3

4
# 磁盘创建一个 ext4 文件系统
5
mkfs.ext4 /dev/vdb
6

7
# 创建挂载点
8
mkdir /data
9

10
# 挂载硬盘
11
mount /dev/vdb /data
12

13
# 设置开机自动挂载
14
blkid /dev/vdb
15

16
记住其中的 UUID="xxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx"
17

18
重启系统或使用 df -h 命令来验证 /dev/vdb 是否已成功挂载到 /data 目录

GraphRAG搭建使用

Tue, 30 Jul 2024 00:00:00 GMT

1、本地安装Ollama，下载两个模型#

Terminal window

1
ollama pull llama3.1
2

3
ollama pull nomic-embed-text

2、安装清华大学的Anaconda环境，选择最新版本安装即可#

3、在Anaconda Powershell创建独立的虚拟环境#

Terminal window

1
创建独立的虚拟环境
2
conda create -n  Graphrag1 python=3.11
3

4
进入创建的虚拟环境
5
conda activate Graphrag1
6

7
安装版本graphrag v0.2.1版本
8
pip install graphrag==0.2.1
9

10
在文档中创建一个graphragtest后运行下面的指令
11
mkdir -p ./ragtest/input
12

13
将所需的文档放入input中
14

15
初始化文档，进入目录graphragtest目录下
16
pip install future
17
python -m graphrag.index --init --root ./ragtest
18

19
修改文件
20
替换C:\Users\Admin\Documents\graphragtest\ragtest\settings.yaml
21
替换C:\Users\Admin\Documents\graphragtest1\ragtest\prompts\community_report.txt
22
替换C:\Users\Admin\anaconda3\envs\Graphrag1\Lib\site-packages\graphrag\query\llm\oai\embedding.py
23
替换C:\Users\Admin\anaconda3\envs\Graphrag1\Lib\site-packages\graphrag\llm\openai\openai_embeddings_llm.py
24

25
运行index指令
26
pip install ollama
27
python -m graphrag.index --root ./ragtest
28
出现All workflows completed successfully表示index解析完成
29

30
局部查询
31
python -m graphrag.query --root ./ragtest --method local "who is Scrooge, and what are his main relationships?"
32

33
全局查询
34
python -m graphrag.query --root ./ragtest --method global "what are the top themes in this story?"