Gaussli's Blog Learn More Everyday 2025-05-18T13:13:32.923Z https://gaussli.com/ gaussli Hexo 【Go】Context用法 https://gaussli.com/2025/05/18/%E3%80%90go%E3%80%91context%E7%94%A8%E6%B3%95/ 2025-05-18T12:57:15.000Z 2025-05-18T13:13:32.923Z Context 主要被用于在并发的 goroutine 之间传递请求范围的数据、取消信号以及超时信息等。其中包含4个方法

  • Done() <-chan strct{}：当 Context 被取消或超时时，这个通道会被关闭。通常用于在 goroutine 中监听取消信号
  • Err() error：表示为什么 Context 被取消。当 Done() 通道关闭后调用 Err() 方法会返回非 nil 的错误。常见错误值：
    • context.Canceled：表示 Context 被显式取消
    • context.DeadlineExceeded：表示 Context 超过了截止时间
  • Value(key interface{}) interface{}：从 Context 中获取与 key 相关联的值。如果 key 不存在，则返回 nil。用于传递请求范围的上下文数据，如用户身份信息、请求 ID 等。
  • Deadline() (deadline time.Time, ok bool)：返回 Context 的截止时间以及一个布尔值 ok。如果 ok 为 true，表示 Context 有一个明确的截止时间；否则，表示没有截止时间。当前时间超过截止时间时，Context 会被自动取消。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
package main

import (
"context"
"fmt"
"time"
)

func main() {
createBackground()

createTODO()

createWithCancel()

createWithTimeout()

createWithDeadline()

createWithValue()
}

// 说明：返回一个空的、不会被取消、没有截止时间的 Context, 通常用于整个请求处理的最顶层，作为其他 Context 的基础。这个
// Context 不包含任何值，也不能被取消。
// 场景：在构建一个 Web 服务器应用时，在处理 HTTP 请求的最开始，可以使用 Context.Background() 作为整个请求处理流程的起点，
// 后续基于它创建带有请求特定信息（如请求ID、用户信息等）或带有取消、超时等功能的 Context。
func createBackground() {
ctx := context.Background()
fmt.Println(ctx)
// 可以将这个基础 Context 传递给其他函数
doSomething(ctx)
}

// 说明：返回一个空的、不会被取消、没有截止时间的 Context, 用于内部库中不确定应该使用什么 Context 时，或者在还没有确定具体的
// Context 使用方式时暂时使用这个 Context。它与 Context.Background() 类似，但更倾向于用于尚未确定具体使用场景的情况。
// 场景：在开发一个通用的工具库时，如果库的某些功能暂时不确定应该使用什么样的 Context （如是基于用户的请求 Context 还是全局的后台任务
// Context），可以先使用 Context.TODO()，后续根据实际业务需求再进行调整。
func createTODO() {
ctx := context.TODO()
fmt.Println(ctx)
// 暂时不清楚如何使用这个 Context 时可以先用它
doSomething(ctx)
}

func doSomething(ctx context.Context) {
// 在函数内部可以基于这个基础 Context 创建带有新特性的 Context
fmt.Println(ctx, "in doSomething method")
}

// 说明：这个函数创建一个带有取消功能的 Context。当调用返回的 cancel 函数时，它会取消这个新的 Context，并且通知所有监听这个
// Context 的 goroutine。
// 场景：在一个长时间运行的任务（如文件处理任务、网络请求任务等）中，当用户要求取消任务或者任务需要提前终止时，可以使用
// Context.WithCancel()。例如，在一个文件下载应用中，如果用户点击取消下载按钮，就可以调用 cancel 函数来取消下载任务。
func createWithCancel() {
ctx, cancel := context.WithCancel(context.Background())
// 启动一个 goroutine 执行任务
go doLongTaskWithCancel(ctx)
// 等待一段时间后取消任务
time.Sleep(5 * time.Second)
cancel()
// 确保 cancel 通知已经生效
time.Sleep(2 * time.Second)
fmt.Println("ctx.Err: ", ctx.Err())
}

func doLongTaskWithCancel(ctx context.Context) {
for {
select {
case <-ctx.Done():
fmt.Println("[WithCancel] Task is cancelled")
return
default:
fmt.Println("[WithCancel] Task is running")
time.Sleep(1 * time.Second)
}
}
}

// 说明：它创建一个带有超时时间的 Context。如果在这个超时时间之前任务没有完成，Context 会被自动取消。
// 场景：在调用外部服务（如 API 调用）时，为了避免长时间等待导致系统资源被占用，可以使用 Context.WithTimeout()。例如，在一个电商
// 应用中，当向支付网关发送支付请求时，可以设置一个超时时间，如果支付网关在超时时间内没有返回结果，就取消支付请求。
func createWithTimeout() {
// 设置超时时间为 2 秒
ctx, cancel := context.WithTimeout(context.Background(), 2*time.Second)
defer cancel() // 确保释放资源
go doLongTaskWithTimeout(ctx)
// 等待一段时间
time.Sleep(3 * time.Second)
}

func doLongTaskWithTimeout(ctx context.Context) {
for {
select {
case <-ctx.Done():
fmt.Println("[WithTimeout] Task is timed out")
return
default:
fmt.Println("[WithTimeout] Task is running")
time.Sleep(500 * time.Millisecond)
}
}
}

// 说明：它创建一个带有截止时间的 Context。如果当前时间超过了这个截止时间，Context 会被自动取消。
// 场景：在一个任务调度系统中，有些任务必须在特定的时间点之前完成。比如，在一个实时数据处理系统中，处理某个时间段的数据必须在这个时间段结束后的一定时间内完
// 成，否则数据就会失去价值了，这时可以使用 Context.WithDeadline() 来确保任务在规定的时间内完成。
func createWithDeadline() {
deadline := time.Now().Add(2 * time.Second)
ctx, cancel := context.WithDeadline(context.Background(), deadline)
defer cancel() // 确保释放资源
go doLongTaskWithDeadline(ctx)
// 等待一段时间
time.Sleep(3 * time.Second)
fmt.Println("ctx.Err: ", ctx.Err())
}

func doLongTaskWithDeadline(ctx context.Context) {
for {
select {
case <-ctx.Done():
fmt.Println("[WithDeadline] Task is beyond deadline")
return
default:
fmt.Println("[WithDeadline] Task is running")
time.Sleep(500 * time.Millisecond)
}
}
}

// 说明：用于向 Context 中添加键值对数据。这可以在整个请求链中传递一些与请求相关的上下文信息，比如用户身份信息、请求 ID 等。
// 场景：在一个分布式系统中，当处理一个用户请求时，可以在请求进入系统的入口处（如 API 网关）使用 Context.WithValue() 向
// Context 添加用户身份信息，然后这个 Context 会随着请求在系统内部的各个服务之间传递，后续的服务就可以从 Context 中获取用户身份信
// 息来执行相应的操作，如权限验证等。
func createWithValue() {
// 创建一个带有值的 Context，添加用户 ID 信息
ctx := context.WithValue(context.Background(), "userID", "12345")
// 在函数中使用这个 Context
doSomethingWithValue(ctx)
}

func doSomethingWithValue(ctx context.Context) {
// 从 Context 中获取值
if userID, ok := ctx.Value("userID").(string); ok {
fmt.Println("[WithValue] User ID:", userID)
} else {
fmt.Println("[WithValue] No User ID found")
}
}

(•̀ᴗ•́)و ̑̑

]]> <p>Context 主要被用于在并发的 goroutine 之间传递请求范围的数据、取消信号以及超时信息等。其中包含4个方法</p> <ul> <li>Done() &lt;-chan strct{}：当 Context 被取消或超时时，这个通道会被关闭。通常用于在 gorou 主流开源协议 https://gaussli.com/2025/05/17/%E4%B8%BB%E6%B5%81%E5%BC%80%E6%BA%90%E5%8D%8F%E8%AE%AE/ 2025-05-17T07:43:01.000Z 2025-05-17T07:47:24.586Z Git 上的开源协议是定义开源软件使用规则和条款的许可证。这些协议规定了用户如何使用、修改和分发开源软件。以下是一些主流的开源协议及其特点的通俗解释：

1. MIT 协议

  • 特点：用户可以自由使用、复制、修改、合并、发布和分发软件，包括原始版本和修改版本。
  • 适用场景：适用于希望软件被广泛使用和修改的开发者，适合小型项目或个人项目。
  • 优点：简单、灵活、限制少，用户拥有极大的自由度。
  • 缺点：缺乏对软件的商业使用的限制，用户可以将开源软件用于商业产品而无需开源其衍生产品。

2. Apache 协议

  • 特点：与 MIT 协议类似，用户可以自由使用、修改和分发软件，但需要保留版权声明和许可证声明。
  • 适用场景：适用于需要保留版权声明和许可证声明的项目。适合大型开源项目和企业级项目。
  • 优点：保留版权和许可证声明，提供知识产权保护。
  • 缺点：需要在分发时保留版权声明和许可证声明，增加了分发的复杂性。

3. GPL 协议（GNU General Public License）

  • 特点：要求任何基于该软件修改或分发的版本也必须采用相同的许可证，即“传染性”。
  • 适用场景：适用于希望确保软件及其衍生产品保持开源的项目，适合需要保护软件不被闭源的项目。
  • 优点：保护软件不被闭源，确保所有衍生产品都保持开源。
  • 缺点：要求所有基于 GPL 软件的修改和分发必须采用相同的许可证，限制了商业使用的灵活性。

4. LGPL 协议（GNU Lesser General Public License）

  • 特点：比 GPL 更加宽松，允许将 LGPL 软件作为库被闭源软件使用，但要求库本身的修改部分保持开源。
  • 适用场景：适用于希望软件作为库被广泛使用，但要求库本身保持开源的项目。
  • 优点：允许闭源软件使用 LGPL 库，促进了库的广泛使用。
  • 缺点：库的修改部分必须保持开源，限制了闭源软件对库的修改自由度。

5. BSD 协议

  • 特点：类似于 MIT 协议，用户可以自由使用、修改和分发软件，但需要保留版权声明和免责声明。
  • 适用场景：适用于希望软件被广泛使用和修改的项目，适合需要保留版权声明的开源项目。
  • 优点：简单、灵活，保留版权声明和免责声明。
  • 缺点：缺乏对商业使用的限制，用户可以将开源软件用于商业产品而无需开源其衍生产品。

6. MPL 协议（Mozilla Public License）

  • 特点：要求任何基于该软件修改或分发的版本必须开源，但允许与其他协议的代码集成。
  • 适用场景：适用于需要保护软件不被闭源但允许与其他协议代码集成的项目。
  • 优点：保护软件不被闭源，允许与其他协议的代码集成。
  • 缺点：要求修改部分开源，增加了分发的复杂性。

7. CC 协议（Creative Commons）

  • 特点：主要用于内容创作（如文档、图片、音乐等），允许用户以特定方式使用和分发内容。
  • 适用场景：适用于非软件内容的开源项目，如文档、教程、图片等。
  • 优点：灵活地定义内容的使用方式，适用于不同类型的创作内容。
  • 缺点：不适合用于软件项目，主要用于内容创作。

8. Unlicense 协议

  • 特点：完全放弃软件的版权，允许用户以任何方式使用、修改和分发软件，没有任何限制。
  • 适用场景：适用于开发者希望完全放弃软件的版权，没有任何限制的项目。
  • 优点：完全自由，没有任何限制。
  • 缺点：缺乏法律保护，用户可以随意使用和分发软件。

9. AGPL 协议（Affero General Public License）

  • 特点：与 GPL 类似，但更严格，要求任何基于该软件的修改和分发都必须开源，包括通过网络服务的方式分发。
  • 适用场景：适用于需要保护软件不被闭源，包括通过网络服务分发的项目。
  • 优点：保护软件不被闭源，包括通过网络服务分发的场景。
  • 缺点：限制了商业使用的灵活性，用户必须开源所有基于该软件的修改和分发版本。

10. Eclipse Public License (EPL)

  • 特点：要求基于该软件的修改和分发版本必须开源，但允许与其他协议的代码集成。
  • 适用场景：适用于 Eclipse 项目和其他需要保护软件不被闭源但允许与其他协议代码集成的项目。
  • 优点：保护软件不被闭源，允许与其他协议的代码集成。
  • 缺点：要求修改部分开源，增加了分发的复杂性。

总结

协议主要特点适用场景
MIT用户可自由使用、修改、分发，无限制小型项目、个人项目
Apache用户可自由使用、修改、分发，需保留版权声明和许可证声明大型开源项目、企业级项目
GPL修改和分发必须开源，传染性需保护软件不被闭源的项目
LGPL修改和分发可闭源，但库本身修改部分需开源作为库被广泛使用的项目
BSD用户可自由使用、修改、分发，需保留版权声明和免责声明小型项目、个人项目，需保留版权声明
MPL修改和分发必须开源，允许与其他协议代码集成需保护软件不被闭源但允许与其他协议代码集成的项目
CC适用于内容创作，如文档、图片、音乐等内容创作项目
Unlicense完全放弃版权，无限制开发者希望完全放弃版权的项目
AGPL修改和分发必须开源，包括通过网络服务分发需保护软件不被闭源包括通过网络服务分发的项目
EPL修改和分发必须开源，允许与其他协议代码集成Eclipse 项目，需保护软件不被闭源但允许与其他协议代码集成的项目

(•̀ᴗ•́)و ̑̑

]]> <p>Git 上的开源协议是定义开源软件使用规则和条款的许可证。这些协议规定了用户如何使用、修改和分发开源软件。以下是一些主流的开源协议及其特点的通俗解释：</p> <h3 id="1-MIT-协议"><a href="#1-MIT-协议" class="headerlink" SOURCECODE-Kubernetes项目依赖的框架及作用 https://gaussli.com/2025/05/16/sourcecode-kubernetes%E9%A1%B9%E7%9B%AE%E4%BE%9D%E8%B5%96%E7%9A%84%E6%A1%86%E6%9E%B6%E5%8F%8A%E4%BD%9C%E7%94%A8/ 2025-05-16T08:30:21.000Z 2025-05-16T08:34:48.900Z Kubernetes 作为云原生很重要的一环，自然是学习 go 以及云原生知识必不可少的内容。Kubernetes 在代码架构设计和编写方面，都有很多我们需要学习的。本文说一下 Kubernetes 使用了哪些第三方框架，以及这些框架一般的作用。

(•̀ᴗ•́)و ̑̑

]]> <p>Kubernetes 作为云原生很重要的一环，自然是学习 go 以及云原生知识必不可少的内容。Kubernetes 在代码架构设计和编写方面，都有很多我们需要学习的。本文说一下 Kubernetes 使用了哪些第三方框架，以及这些框架一般的作用。</p> <h1 id="" COOKBOOK-Kubernetes二进制高可用部署-Flannel https://gaussli.com/2025/05/10/cookbook-kubernetes%E4%BA%8C%E8%BF%9B%E5%88%B6%E9%AB%98%E5%8F%AF%E7%94%A8%E9%83%A8%E7%BD%B2-flannel/ 2025-05-10T13:09:02.000Z 2025-05-10T14:37:03.734Z 下载 Flannel 相关文件
1
2
# 选用版本：0.26.7
wget -P /usr/local/src https://github.com/flannel-io/flannel/releases/download/v0.26.7/kube-flannel.yml

修改 Yaml 内容

1
2
3
4
# 修改 pod cidr 信息
sed -i 's/\("Network": \).*/\1"20.20.0.0\/16",/' /usr/local/src/kube-flannel.yml
# 新增指定网卡信息
sed -i '/--kube-subnet-mgr/a\        - --iface=enp0s8' /usr/local/src/kube-flannel.yml

运行 Flannel

1
kubectl --kubeconfig=/etc/kubernetes/admin.kubeconfig create -f /usr/local/src/kube-flannel.yml

结果

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
# kubectl get node 命令结果，节点从 NotReady 转变为 Ready
NAME             STATUS   ROLES    AGE   VERSION
192.168.56.109   Ready    <none>   47h   v1.31.2
192.168.56.110   Ready    <none>   47h   v1.31.2
192.168.56.111   Ready    <none>   47h   v1.31.2


# 产生 kube-flannel 命名空间下 kube-flannel-ds 的 daemonset 以及它对应的 pod
NAMESPACE      NAME                             DESIRED   CURRENT   READY   UP-TO-DATE   AVAILABLE   NODE SELECTOR   AGE
kube-flannel   daemonset.apps/kube-flannel-ds   3         3         3       3            3           <none>          7h19m

NAMESPACE      NAME                        READY   STATUS    RESTARTS        AGE
kube-flannel   pod/kube-flannel-ds-775kd   1/1     Running   10 (147m ago)   165m
kube-flannel   pod/kube-flannel-ds-fxw76   1/1     Running   5 (158m ago)    165m
kube-flannel   pod/kube-flannel-ds-zwfqg   1/1     Running   0               165m


# 产生名为 flannel.1 的网络接口，ip 由 pod cidr 配置信息确定
flannel.1: <BROADCAST,MULTICAST,UP,LOWER_UP> mtu 1450 qdisc noqueue state UNKNOWN group default 
    link/ether be:69:89:e5:1a:66 brd ff:ff:ff:ff:ff:ff
    inet 20.20.0.0/32 scope global flannel.1
       valid_lft forever preferred_lft forever
    inet6 fe80::bc69:89ff:fee5:1a66/64 scope link 
       valid_lft forever preferred_lft forever


# 产生 /etc/cni/net.d/10-flannel.conflist 文件
{
  "name": "cbr0",
  "cniVersion": "0.3.1",
  "plugins": [
    {
      "type": "flannel",
      "delegate": {
        "hairpinMode": true,
        "isDefaultGateway": true
      }
    },
    {
      "type": "portmap",
      "capabilities": {
        "portMappings": true
      }
    }
  ]
}

(•̀ᴗ•́)و ̑̑

]]> <h1 id="下载-Flannel-相关文件"><a href="#下载-Flannel-相关文件" class="headerlink" title="下载 Flannel 相关文件"></a>下载 Flannel 相关文件</h1><figure class="highli COOKBOOK-Kubernetes二进制高可用部署-Calico https://gaussli.com/2025/05/08/cookbook-kubernetes%E4%BA%8C%E8%BF%9B%E5%88%B6%E9%AB%98%E5%8F%AF%E7%94%A8%E9%83%A8%E7%BD%B2-calico/ 2025-05-08T14:50:25.000Z 2025-05-08T16:20:56.517Z 下载 Calico 相关文件
1
2
3
4
5
# 选用版本：3.28.2
# 推荐使用 Tigera operator 来安装部署 Calico，并且同时能管理 Calico 的生命周期
wget -P /usr/local/src https://raw.githubusercontent.com/projectcalico/calico/v3.30.0/manifests/operator-crds.yaml
wget -P /usr/local/src https://raw.githubusercontent.com/projectcalico/calico/v3.30.0/manifests/tigera-operator.yaml
wget -P /usr/local/src https://raw.githubusercontent.com/projectcalico/calico/v3.30.0/manifests/custom-resources.yaml

修改 Pod CIDR 信息

1
sed -i 's/\(cidr: \).*/\120.20.0.0\/16/' /usr/local/src/custom-resources.yaml

运行 Tigera operator

1
2
3
kubectl --kubeconfig=/etc/kubernetes/admin.kubeconfig create -f /usr/local/src/operator-crds.yaml
kubectl --kubeconfig=/etc/kubernetes/admin.kubeconfig create -f /usr/local/src/tigera-operator.yaml
kubectl --kubeconfig=/etc/kubernetes/admin.kubeconfig create -f /usr/local/src/custom-resources.yaml

(•̀ᴗ•́)و ̑̑

]]> <h1 id="下载-Calico-相关文件"><a href="#下载-Calico-相关文件" class="headerlink" title="下载 Calico 相关文件"></a>下载 Calico 相关文件</h1><figure class="highlight COOKBOOK-Kubernetes二进制高可用部署-Kube-Proxy https://gaussli.com/2025/05/08/cookbook-kubernetes%E4%BA%8C%E8%BF%9B%E5%88%B6%E9%AB%98%E5%8F%AF%E7%94%A8%E9%83%A8%E7%BD%B2-kube-proxy/ 2025-05-08T14:38:09.000Z 2025-05-08T14:48:51.613Z 所有虚拟机移动可执行文件
1
2
3
4
5
# 移动可执行文件到bin目录
mv /usr/local/src/kubernetes/server/bin/kube-proxy /usr/local/bin/

# 配置可执行文件的属性
chmod 755 /usr/local/bin/kube-proxy

所有虚拟机创建 kube-proxy systemd 服务

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
# 创建 kube-proxy systemd 服务文件
cat << EOF > /etc/kubernetes/kube-proxy.service
[Unit]
Description=Kubernetes Kube-Proxy Server
Documentation=https://github.com/kubernetes/kubernetes
After=network.target

[Service]
EnvironmentFile=/etc/kubernetes/kube-proxy.arg
ExecStart=/usr/local/bin/kube-proxy \$KUBE_PROXY_ARGS
Restart=always

[Install]
WantedBy=multi-user.target
EOF

# 软链到系统服务目录
ln -s /etc/kubernetes/kube-proxy.service /usr/lib/systemd/system/kube-proxy.service

创建 kube-proxy 启动参数配置文件

1
2
3
4
5
6
7
# 192.168.56.109执行
cat << EOF > /etc/kubernetes/kube-proxy.arg
KUBE_PROXY_ARGS="--kubeconfig=/etc/kubernetes/admin.kubeconfig \
--bind-address=192.168.56.109 \
--hostname-override=192.168.56.109 \
--proxy-mode=iptables"
EOF
1
2
3
4
5
6
7
# 192.168.56.110执行
cat << EOF > /etc/kubernetes/kube-proxy.arg
KUBE_PROXY_ARGS="--kubeconfig=/etc/kubernetes/admin.kubeconfig \
--bind-address=192.168.56.110 \
--hostname-override=192.168.56.110 \
--proxy-mode=iptables"
EOF
1
2
3
4
5
6
7
# 192.168.56.111执行
cat << EOF > /etc/kubernetes/kube-proxy.arg
KUBE_PROXY_ARGS="--kubeconfig=/etc/kubernetes/admin.kubeconfig \
--bind-address=192.168.56.111 \
--hostname-override=192.168.56.111 \
--proxy-mode=iptables"
EOF

所有虚拟机启动 kube-proxy 服务

systemctl start kube-proxy && systemctl enable kube-proxy(•̀ᴗ•́)و ̑̑
]]> <h1 id="所有虚拟机移动可执行文件"><a href="#所有虚拟机移动可执行文件" class="headerlink" title="所有虚拟机移动可执行文件"></a>所有虚拟机移动可执行文件</h1><figure class="highlight bash"><t COOKBOOK-Kubernetes二进制高可用部署-Containerd https://gaussli.com/2025/05/08/cookbook-kubernetes%E4%BA%8C%E8%BF%9B%E5%88%B6%E9%AB%98%E5%8F%AF%E7%94%A8%E9%83%A8%E7%BD%B2-containerd/ 2025-05-07T16:52:57.000Z 2025-05-10T13:03:40.362Z 准备
1
2
3
4
5
6
7
8
9
10
# 安装runc工具
yum install -y runc

# 安装cni plugin
# 创建 cni plugin 目录
mkdir -p /opt/cni/bin
# 下载cni1.5.1版本
wget -P /usr/local/src https://github.com/containernetworking/plugins/releases/download/v1.5.1/cni-plugins-linux-amd64-v1.5.1.tgz
# 解压
tar -C /opt/cni/bin -zxvf /usr/local/src/cni-plugins-linux-amd64-v1.5.1.tgz

安装 containerd

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
# 下载containerd
wget -P /usr/local/src https://github.com/containerd/containerd/releases/download/v1.7.7/containerd-1.7.7-linux-amd64.tar.gz

# 解压
tar -C /usr/local/ -zxvf /usr/local/src/containerd-1.7.7-linux-amd64.tar.gz

# 创建 containerd 服务文件
# wget https://raw.githubusercontent.com/containerd/containerd/main/containerd.service
cat << EOF > /usr/lib/systemd/system/containerd.service
# Copyright The containerd Authors.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#     http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.

[Unit]
Description=containerd container runtime
Documentation=https://containerd.io
After=network.target dbus.service

[Service]
ExecStartPre=-/sbin/modprobe overlay
ExecStart=/usr/local/bin/containerd

Type=notify
Delegate=yes
KillMode=process
Restart=always
RestartSec=5

# Having non-zero Limit*s causes performance problems due to accounting overhead
# in the kernel. We recommend using cgroups to do container-local accounting.
LimitNPROC=infinity
LimitCORE=infinity

# Comment TasksMax if your systemd version does not supports it.
# Only systemd 226 and above support this version.
TasksMax=infinity
OOMScoreAdjust=-999

[Install]
WantedBy=multi-user.target
EOF

配置国内代理源

推荐使用DaoCloud的代理源，稳定可靠：DaoCloud Mirror

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
# 创建 containerd 默认配置文件
mkdir -p /etc/containerd
containerd config default > /etc/containerd/config.toml

# 修改 /etc/containerd/config.toml 中的 [plugins."io.containerd.grpc.v1.cri".registry] 的 config_path 内容
# 改为 config_path = "/etc/containerd/certs.d"
sed -i '/\[plugins."io.containerd.grpc.v1.cri".registry\]/ {
n
s/\(config_path = \).*/\1"\/etc\/containerd\/certs.d"/
}' /etc/containerd/config.toml

# 验证修改是否成功，有输出为成功，无输出为失败
grep 'config_path = "/etc/containerd/certs.d"' -C 3 /etc/containerd/config.toml

# 配置 containerd 使用 cgroupfs Cgroup 驱动（需同 kubelet 配置参数一致）
sed -i 's/\(SystemdCgroup = \).*/\1false/' /etc/containerd/config.toml

# 验证修改是否成功，SystemdCgroup = true 时使用 Systemd Cgroup；SystemCgroup = false 时使用 Cgroupfs Cgroup
grep 'SystemdCgroup' -C 12 /etc/containerd/config.toml

# 创建 certs.d 目录
mkdir -p /etc/containerd/certs.d

# 配置 docker.io 代理源
mkdir /etc/containerd/certs.d/docker.io
cat << EOF > /etc/containerd/certs.d/docker.io/hosts.toml
server = "https://docker.io"

[host."docker.m.daocloud.io"]
  capabilities = ["pull", "resolve"]
EOF

# 配置 registry.k8s.io 代理源
mkdir /etc/containerd/certs.d/registry.k8s.io
cat << EOF > /etc/containerd/certs.d/registry.k8s.io/hosts.toml
server = "https://registry.k8s.io"

[host."k8s.m.daocloud.io"]
  capabilities = ["pull", "resolve"]
EOF

# 配置 quay.io 代理源
mkdir /etc/containerd/certs.d/quay.io
cat << EOF > /etc/containerd/certs.d/quay.io/hosts.toml
server = "https://quay.io"

[host."quay.m.daocloud.io"]
  capabilities = ["pull", "resolve"]
EOF

# 配置 ghcr.io 代理源
mkdir /etc/containerd/certs.d/ghcr.io
cat << EOF > /etc/containerd/certs.d/ghcr.io/hosts.toml
server = "https://ghcr.io"

[host."ghcr.m.daocloud.io"]
  capabilities = ["pull", "resolve"]
EOF

启动 containerd 服务

1
2
systemctl daemon-reload
systemctl start containerd && systemctl enable containerd

查看 containerd 配置是否生效

1
containerd config dump

安装 nerdctl

1
2
3
4
5
# 下载nerdctl
wget -P /usr/local/src https://github.com/containerd/nerdctl/releases/download/v1.7.7/nerdctl-1.7.7-linux-amd64.tar.gz

# 解压
tar -C /usr/local/bin/ -zxvf /usr/local/src/nerdctl-1.7.7-linux-amd64.tar.gz

(•̀ᴗ•́)و ̑̑

]]> <h1 id="准备"><a href="#准备" class="headerlink" title="准备"></a>准备</h1><figure class="highlight bash"><table><tr><td class="gutter"><pre><span c COOKBOOK-Kubernetes二进制高可用部署-Kubelet https://gaussli.com/2025/05/08/cookbook-kubernetes%E4%BA%8C%E8%BF%9B%E5%88%B6%E9%AB%98%E5%8F%AF%E7%94%A8%E9%83%A8%E7%BD%B2-kubelet/ 2025-05-07T16:23:55.000Z 2025-05-10T13:43:19.106Z 所有虚拟机移动可执行文件
1
2
3
4
5
# 移动可执行文件到bin目录
mv /usr/local/src/kubernetes/server/bin/kubelet /usr/local/bin/

# 配置可执行文件的属性
chmod 755 /usr/local/bin/kubelet

所有虚拟机创建 kubelet systemd 服务

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
# 创建 kubelet systemd 服务文件
cat << EOF > /etc/kubernetes/kubelet.service
[Unit]
Description=Kubernetes Kubelet Server
Documentation=https://github.com/kubernetes/kubernetes
After=network.target containerd.service

[Service]
EnvironmentFile=/etc/kubernetes/kubelet.arg
ExecStart=/usr/local/bin/kubelet \$KUBELET_ARGS
Restart=always

[Install]
WantedBy=multi-user.target
EOF

# 软链到系统服务目录
ln -s /etc/kubernetes/kubelet.service /usr/lib/systemd/system/kubelet.service

创建 kubelet 启动参数配置文件

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
# 192.168.56.109执行
# 其中 cgroup-driver 需同 containerd 配置一致
# 其中 pod-cidr 需同 kube-controller-manager、calico（或flannel）配置一致
cat << EOF > /etc/kubernetes/kubelet.arg
KUBELET_ARGS="--kubeconfig=/etc/kubernetes/admin.kubeconfig \
--anonymous-auth=true \
--address=192.168.56.109 \
--hostname-override=192.168.56.109 \
--node-ip=192.168.56.109 \
--port=10250 \
--cluster-dns=169.169.0.100 \
--cluster-domain=cluster.local \
--cgroup-driver=cgroupfs \
--containerd=/run/containerd/containerd.sock \
--pod-infra-container-image=registry.k8s.io/pause:3.10 \
--pod-cidr=20.20.0.0/16"
EOF
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
# 192.168.56.110执行
# 其中 cgroup-driver 需同 containerd 配置一致
cat << EOF > /etc/kubernetes/kubelet.arg
KUBELET_ARGS="--kubeconfig=/etc/kubernetes/admin.kubeconfig \
--anonymous-auth=true \
--address=192.168.56.110 \
--hostname-override=192.168.56.110 \
--node-ip=192.168.56.110 \
--port=10250 \
--cluster-dns=169.169.0.100 \
--cluster-domain=cluster.local \
--cgroup-driver=cgroupfs \
--containerd=/run/containerd/containerd.sock \
--pod-infra-container-image=registry.k8s.io/pause:3.10 \
--pod-cidr=20.20.0.0/16"
EOF
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
# 192.168.56.111执行
# 其中 cgroup-driver 需同 containerd 配置一致
cat << EOF > /etc/kubernetes/kubelet.arg
KUBELET_ARGS="--kubeconfig=/etc/kubernetes/admin.kubeconfig \
--anonymous-auth=true \
--address=192.168.56.111 \
--hostname-override=192.168.56.111 \
--node-ip=192.168.56.111 \
--port=10250 \
--cluster-dns=169.169.0.100 \
--cluster-domain=cluster.local \
--cgroup-driver=cgroupfs \
--containerd=/run/containerd/containerd.sock \
--pod-infra-container-image=registry.k8s.io/pause:3.10 \
--pod-cidr=20.20.0.0/16"
EOF

所有虚拟机启动 kubelet 服务

systemctl start kubelet && systemctl enable kubelet(•̀ᴗ•́)و ̑̑
]]> <h1 id="所有虚拟机移动可执行文件"><a href="#所有虚拟机移动可执行文件" class="headerlink" title="所有虚拟机移动可执行文件"></a>所有虚拟机移动可执行文件</h1><figure class="highlight bash"><t COOKBOOK-Kubernetes二进制高可用部署-Kube-Controller-Manager和kube-Scheduler高可用 https://gaussli.com/2025/05/07/cookbook-kubernetes%E4%BA%8C%E8%BF%9B%E5%88%B6%E9%AB%98%E5%8F%AF%E7%94%A8%E9%83%A8%E7%BD%B2-kube-controller-manager%E5%92%8Ckube-scheduler%E9%AB%98%E5%8F%AF%E7%94%A8/ 2025-05-07T15:34:23.000Z 2025-05-10T13:42:25.249Z 所有虚拟机移动可执行文件
1
2
3
4
5
6
7
# 移动可执行文件到bin目录
mv /usr/local/src/kubernetes/server/bin/kube-controller-manager /usr/local/bin/
mv /usr/local/src/kubernetes/server/bin/kube-scheduler /usr/local/bin/

# 配置可执行文件的属性
chmod 755 /usr/local/bin/kube-controller-manager
chmod 755 /usr/local/bin/kube-scheduler

所有虚拟机创建 kubeconfig 文件

供 kube-controller-manager、kube-scheduler、kubelet、kube-proxy 服务连接 kube-apiserver 使用。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
cat << EOF > /etc/kubernetes/admin.kubeconfig
apiVersion: v1
kind: Config
clusters:
- name: default
  cluster: 
    server: https://192.168.56.109:6443
    certificate-authority: /etc/kubernetes/pki/ca.crt
users:
- name: admin
  user:
    client-certificate: /etc/kubernetes/pki/apiserver_client.crt
    client-key: /etc/kubernetes/pki/apiserver_client.key
contexts:
- name: default
  context:
    cluster: default
    user: admin
current-context: default
EOF

所有虚拟机创建 kube-controller-manager systemd 服务

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
# 创建 kube-controller-manager systemd 服务文件
cat << EOF > /etc/kubernetes/kube-controller-manager.service
[Unit]
Description=Kubernetes Controller Manager
Documentation=https://github.com/kubernetes/kubernetes
After=network.target etcd.service kube-apiserver.service

[Service]
EnvironmentFile=/etc/kubernetes/kube-controller-manager.arg
ExecStart=/usr/local/bin/kube-controller-manager \$KUBE_CONTROLLER_MANAGER_ARGS
Restart=always

[Install]
WantedBy=multi-user.target
EOF

# 软链到系统服务目录
ln -s /etc/kubernetes/kube-controller-manager.service /usr/lib/systemd/system/kube-controller-manager.service

创建 kube-controller-manager 启动参数配置文件

其中 –cluster-cidr 为 Pod 的IP 范围，需要和 kubelet、calico（或flannel）配置一致

1
2
3
4
5
6
7
8
9
10
11
12
# 192.168.56.109执行
cat << EOF > /etc/kubernetes/kube-controller-manager.arg
KUBE_CONTROLLER_MANAGER_ARGS="--kubeconfig=/etc/kubernetes/admin.kubeconfig \
--leader-elect=true \
--bind-address=192.168.56.109 \
--secure-port=10257 \
--service-cluster-ip-range=169.169.0.0/16 \
--allocate-node-cidrs=true \
--cluster-cidr=20.20.0.0/16 \
--root-ca-file=/etc/kubernetes/pki/ca.crt \
--service-account-private-key-file=/etc/kubernetes/pki/apiserver_server.key"
EOF
1
2
3
4
5
6
7
8
9
10
11
12
# 192.168.56.110执行
cat << EOF > /etc/kubernetes/kube-controller-manager.arg
KUBE_CONTROLLER_MANAGER_ARGS="--kubeconfig=/etc/kubernetes/admin.kubeconfig \
--leader-elect=true \
--bind-address=192.168.56.110 \
--secure-port=10257 \
--service-cluster-ip-range=169.169.0.0/16 \
--allocate-node-cidrs=true \
--cluster-cidr=20.20.0.0/16 \
--root-ca-file=/etc/kubernetes/pki/ca.crt \
--service-account-private-key-file=/etc/kubernetes/pki/apiserver_server.key"
EOF
1
2
3
4
5
6
7
8
9
10
11
12
# 192.168.56.111执行
cat << EOF > /etc/kubernetes/kube-controller-manager.arg
KUBE_CONTROLLER_MANAGER_ARGS="--kubeconfig=/etc/kubernetes/admin.kubeconfig \
--leader-elect=true \
--bind-address=192.168.56.111 \
--secure-port=10257 \
--service-cluster-ip-range=169.169.0.0/16 \
--allocate-node-cidrs=true \
--cluster-cidr=20.20.0.0/16 \
--root-ca-file=/etc/kubernetes/pki/ca.crt \
--service-account-private-key-file=/etc/kubernetes/pki/apiserver_server.key"
EOF

所有虚拟机启动 kube-controller-manager 服务

1
systemctl start kube-controller-manager && systemctl enable kube-controller-manager

所有虚拟机创建 kube-scheduler systemd 服务

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
# 创建 kube-scheduler systemd 服务文件
cat << EOF > /etc/kubernetes/kube-scheduler.service
[Unit]
Description=Kubernetes Scheduler
Documentation=https://github.com/kubernetes/kubernetes
After=network.target etcd.service kube-apiserver.service

[Service]
EnvironmentFile=/etc/kubernetes/kube-scheduler.arg
ExecStart=/usr/local/bin/kube-scheduler \$KUBE_SCHEDULER_ARGS
Restart=always

[Install]
WantedBy=multi-user.target
EOF

# 软链到系统服务目录
ln -s /etc/kubernetes/kube-scheduler.service /usr/lib/systemd/system/kube-scheduler.service

创建 kube-scheduler 启动参数配置文件

1
2
3
4
5
6
7
# 192.168.56.109执行
cat << EOF > /etc/kubernetes/kube-scheduler.arg
KUBE_SCHEDULER_ARGS="--kubeconfig=/etc/kubernetes/admin.kubeconfig \
--leader-elect=true \
--bind-address=192.168.56.109 \
--secure-port=10259"
EOF
1
2
3
4
5
6
7
# 192.168.56.110执行
cat << EOF > /etc/kubernetes/kube-scheduler.arg
KUBE_SCHEDULER_ARGS="--kubeconfig=/etc/kubernetes/admin.kubeconfig \
--leader-elect=true \
--bind-address=192.168.56.110 \
--secure-port=10259"
EOF
1
2
3
4
5
6
7
# 192.168.56.111执行
cat << EOF > /etc/kubernetes/kube-scheduler.arg
KUBE_SCHEDULER_ARGS="--kubeconfig=/etc/kubernetes/admin.kubeconfig \
--leader-elect=true \
--bind-address=192.168.56.111 \
--secure-port=10259"
EOF

所有虚拟机启动 kube-scheduler 服务

1
systemctl start kube-scheduler && systemctl enable kube-scheduler

(•̀ᴗ•́)و ̑̑

]]> <h1 id="所有虚拟机移动可执行文件"><a href="#所有虚拟机移动可执行文件" class="headerlink" title="所有虚拟机移动可执行文件"></a>所有虚拟机移动可执行文件</h1><figure class="highlight bash"><t COOKBOOK-Kubernetes二进制高可用部署-Apiserver高可用 https://gaussli.com/2025/05/07/cookbook-kubernetes%E4%BA%8C%E8%BF%9B%E5%88%B6%E9%AB%98%E5%8F%AF%E7%94%A8%E9%83%A8%E7%BD%B2-apiserver%E9%AB%98%E5%8F%AF%E7%94%A8/ 2025-05-07T11:43:28.000Z 2025-05-09T17:51:51.656Z 所有虚拟机下载 kubernetes 二进制文件并解压
1
2
3
4
5
6
7
8
9
10
11
# 下载kubernetes 二进制文件
wget -P /usr/local/src https://dl.k8s.io/v1.31.2/kubernetes-server-linux-amd64.tar.gz

# 解压
tar -C /usr/local/src -zxvf kubernetes-server-linux-amd64.tar.gz

# 移动可执行文件到bin目录
mv /usr/local/src/kubernetes/server/bin/kube-apiserver /usr/local/bin/

# 配置可执行文件的属性
chmod 755 /usr/local/bin/kube-apiserver

所有虚拟机创建 apiserver systemd 服务

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
# 创建 apiserver systemd 服务文件
cat << EOF > /etc/kubernetes/kube-apiserver.service
[Unit]
Description=Kubernetes API Server
Documentation=https://github.com/kubernetes/kubernetes
After=network.target etcd.service

[Service]
EnvironmentFile=/etc/kubernetes/kube-apiserver.arg
ExecStart=/usr/local/bin/kube-apiserver \$KUBE_API_ARGS
Restart=always

[Install]
WantedBy=multi-user.target
EOF

# 软链到系统服务目录
ln -s /etc/kubernetes/kube-apiserver.service /usr/lib/systemd/system/kube-apiserver.service

创建 apiserver 启动参数配置文件

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
# 192.168.56.109执行
cat << EOF > /etc/kubernetes/kube-apiserver.arg
KUBE_API_ARGS="--advertise-address=192.168.56.109 \
--external-hostname=192.168.56.109 \
--enable-aggregator-routing=true \
--etcd-cafile=/etc/etcd/pki/ca.crt \
--etcd-certfile=/etc/etcd/pki/etcd_client.crt \
--etcd-keyfile=/etc/etcd/pki/etcd_client.key \
--etcd-servers=https://192.168.56.109:2379,https://192.168.56.110:2379,https://192.168.56.111:2379 \
--bind-address=192.168.56.109 \
--secure-port=6443 \
--tls-cert-file=/etc/kubernetes/pki/apiserver_server.crt \
--tls-private-key-file=/etc/kubernetes/pki/apiserver_server.key \
--client-ca-file=/etc/kubernetes/pki/ca.crt \
--api-audiences=https://kubernetes.default.svc \
--service-account-issuer=https://kubernetes.default.svc.cluster.local \
--service-account-key-file=/etc/kubernetes/pki/apiserver_server.crt \
--service-account-signing-key-file=/etc/kubernetes/pki/apiserver_server.key \
--allow-privileged=true \
--service-cluster-ip-range=169.169.0.0/16 \
--service-node-port-range=30000-32767"
EOF
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
# 192.168.56.110执行
cat << EOF > /etc/kubernetes/kube-apiserver.arg
KUBE_API_ARGS="--advertise-address=192.168.56.110 \
--external-hostname=192.168.56.110 \
--enable-aggregator-routing=true \
--etcd-cafile=/etc/etcd/pki/ca.crt \
--etcd-certfile=/etc/etcd/pki/etcd_client.crt \
--etcd-keyfile=/etc/etcd/pki/etcd_client.key \
--etcd-servers=https://192.168.56.109:2379,https://192.168.56.110:2379,https://192.168.56.111:2379 \
--bind-address=192.168.56.110 \
--secure-port=6443 \
--tls-cert-file=/etc/kubernetes/pki/apiserver_server.crt \
--tls-private-key-file=/etc/kubernetes/pki/apiserver_server.key \
--client-ca-file=/etc/kubernetes/pki/ca.crt \
--api-audiences=https://kubernetes.default.svc \
--service-account-issuer=https://kubernetes.default.svc.cluster.local \
--service-account-key-file=/etc/kubernetes/pki/apiserver_server.crt \
--service-account-signing-key-file=/etc/kubernetes/pki/apiserver_server.key \
--allow-privileged=true \
--service-cluster-ip-range=169.169.0.0/16 \
--service-node-port-range=30000-32767"
EOF
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
# 192.168.56.111执行
cat << EOF > /etc/kubernetes/kube-apiserver.arg
KUBE_API_ARGS="--advertise-address=192.168.56.111 \
--external-hostname=192.168.56.111 \
--enable-aggregator-routing=true \
--etcd-cafile=/etc/etcd/pki/ca.crt \
--etcd-certfile=/etc/etcd/pki/etcd_client.crt \
--etcd-keyfile=/etc/etcd/pki/etcd_client.key \
--etcd-servers=https://192.168.56.109:2379,https://192.168.56.110:2379,https://192.168.56.111:2379 \
--bind-address=192.168.56.111 \
--secure-port=6443 \
--tls-cert-file=/etc/kubernetes/pki/apiserver_server.crt \
--tls-private-key-file=/etc/kubernetes/pki/apiserver_server.key \
--client-ca-file=/etc/kubernetes/pki/ca.crt \
--api-audiences=https://kubernetes.default.svc \
--service-account-issuer=https://kubernetes.default.svc.cluster.local \
--service-account-key-file=/etc/kubernetes/pki/apiserver_server.crt \
--service-account-signing-key-file=/etc/kubernetes/pki/apiserver_server.key \
--allow-privileged=true \
--service-cluster-ip-range=169.169.0.0/16 \
--service-node-port-range=30000-32767"
EOF

所有虚拟机启动 kube-apiserver 服务

1
systemctl start kube-apiserver && systemctl enable kube-apiserver

(•̀ᴗ•́)و ̑̑

]]> <h1 id="所有虚拟机下载-kubernetes-二进制文件并解压"><a href="#所有虚拟机下载-kubernetes-二进制文件并解压" class="headerlink" title="所有虚拟机下载 kubernetes 二进制文件并解压"></a>所有虚拟机 COOKBOOK-Kubernetes二进制高可用部署-Etcd高可用 https://gaussli.com/2025/05/07/cookbook-kubernetes%E4%BA%8C%E8%BF%9B%E5%88%B6%E9%AB%98%E5%8F%AF%E7%94%A8%E9%83%A8%E7%BD%B2-etcd%E9%AB%98%E5%8F%AF%E7%94%A8/ 2025-05-07T10:13:17.000Z 2025-05-08T13:27:32.153Z 所有虚拟机创建 etcd 目录
1
mkdir -p /etc/etcd/data

所有虚拟机下载 etcd 并解压

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
# 下载etcd
wget -P /usr/local/src https://github.com/etcd-io/etcd/releases/download/v3.5.14/etcd-v3.5.14-linux-amd64.tar.gz

# 解压
tar -C /usr/local/src -zxvf etcd-v3.5.14-linux-amd64.tar.gz

# 移动可执行文件到bin目录
mv /usr/local/src/etcd-v3.5.14-linux-amd64/etcd /usr/local/bin/
mv /usr/local/src/etcd-v3.5.14-linux-amd64/etcdctl /usr/local/bin/
mv /usr/local/src/etcd-v3.5.14-linux-amd64/etcdutl /usr/local/bin/

# 配置可执行文件的属性
chmod 755 /usr/local/bin/etcd
chmod 755 /usr/local/bin/etcdctl
chmod 755 /usr/local/bin/etcdutl

所有虚拟机创建 etcd systemd 服务

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
# 创建 etcd systemd 服务文件
cat << EOF > /etc/etcd/etcd.service
[Unit]
Description=etcd key-value store
Documentation=https://github.com/etcd-io/etcd
After=network.target

[Service]
EnvironmentFile=/etc/etcd/etcd.env
ExecStart=/usr/local/bin/etcd
Restart=always

[Install]
WantedBy=multi-user.target
EOF

# 软链到系统服务目录
ln -s /etc/etcd/etcd.service /usr/lib/systemd/system/etcd.service

创建 etcd 环境变量配置文件

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
# 192.168.56.109执行
cat << EOF > /etc/etcd/etcd.env
ETCD_NAME=etcd1
ETCD_DATA_DIR=/etc/etcd/data

ETCD_CLIENT_CERT_AUTH=true
ETCD_TRUSTED_CA_FILE=/etc/etcd/pki/ca.crt
ETCD_CERT_FILE=/etc/etcd/pki/etcd_server.crt
ETCD_KEY_FILE=/etc/etcd/pki/etcd_server.key
ETCD_LISTEN_CLIENT_URLS=https://192.168.56.109:2379
ETCD_ADVERTISE_CLIENT_URLS=https://192.168.56.109:2379

ETCD_PEER_CLIENT_CERT_AUTH=true
ETCD_PEER_TRUSTED_CA_FILE=/etc/etcd/pki/ca.crt
ETCD_PEER_CERT_FILE=/etc/etcd/pki/etcd_peer.crt
ETCD_PEER_KEY_FILE=/etc/etcd/pki/etcd_peer.key
ETCD_LISTEN_PEER_URLS=https://192.168.56.109:2380
ETCD_INITIAL_ADVERTISE_PEER_URLS=https://192.168.56.109:2380

ETCD_INITIAL_CLUSTER="etcd1=https://192.168.56.109:2380,etcd2=https://192.168.56.110:2380,etcd3=https://192.168.56.111:2380"
ETCD_INITIAL_CLUSTER_STATE=new
ETCD_INITIAL_CLUSTER_TOKEN=etcd-cluster
EOF
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
# 192.168.56.110执行
cat << EOF > /etc/etcd/etcd.env
ETCD_NAME=etcd2
ETCD_DATA_DIR=/etc/etcd/data

ETCD_CLIENT_CERT_AUTH=true
ETCD_TRUSTED_CA_FILE=/etc/etcd/pki/ca.crt
ETCD_CERT_FILE=/etc/etcd/pki/etcd_server.crt
ETCD_KEY_FILE=/etc/etcd/pki/etcd_server.key
ETCD_LISTEN_CLIENT_URLS=https://192.168.56.110:2379
ETCD_ADVERTISE_CLIENT_URLS=https://192.168.56.110:2379

ETCD_PEER_CLIENT_CERT_AUTH=true
ETCD_PEER_TRUSTED_CA_FILE=/etc/etcd/pki/ca.crt
ETCD_PEER_CERT_FILE=/etc/etcd/pki/etcd_peer.crt
ETCD_PEER_KEY_FILE=/etc/etcd/pki/etcd_peer.key
ETCD_LISTEN_PEER_URLS=https://192.168.56.110:2380
ETCD_INITIAL_ADVERTISE_PEER_URLS=https://192.168.56.110:2380

ETCD_INITIAL_CLUSTER="etcd1=https://192.168.56.109:2380,etcd2=https://192.168.56.110:2380,etcd3=https://192.168.56.111:2380"
ETCD_INITIAL_CLUSTER_STATE=new
ETCD_INITIAL_CLUSTER_TOKEN=etcd-cluster
EOF
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
# 192.168.56.111执行
cat << EOF > /etc/etcd/etcd.env
ETCD_NAME=etcd3
ETCD_DATA_DIR=/etc/etcd/data

ETCD_CLIENT_CERT_AUTH=true
ETCD_TRUSTED_CA_FILE=/etc/etcd/pki/ca.crt
ETCD_CERT_FILE=/etc/etcd/pki/etcd_server.crt
ETCD_KEY_FILE=/etc/etcd/pki/etcd_server.key
ETCD_LISTEN_CLIENT_URLS=https://192.168.56.111:2379
ETCD_ADVERTISE_CLIENT_URLS=https://192.168.56.111:2379

ETCD_PEER_CLIENT_CERT_AUTH=true
ETCD_PEER_TRUSTED_CA_FILE=/etc/etcd/pki/ca.crt
ETCD_PEER_CERT_FILE=/etc/etcd/pki/etcd_peer.crt
ETCD_PEER_KEY_FILE=/etc/etcd/pki/etcd_peer.key
ETCD_LISTEN_PEER_URLS=https://192.168.56.111:2380
ETCD_INITIAL_ADVERTISE_PEER_URLS=https://192.168.56.111:2380

ETCD_INITIAL_CLUSTER="etcd1=https://192.168.56.109:2380,etcd2=https://192.168.56.110:2380,etcd3=https://192.168.56.111:2380"
ETCD_INITIAL_CLUSTER_STATE=new
ETCD_INITIAL_CLUSTER_TOKEN=etcd-cluster
EOF

所有虚拟机启动 etcd 服务

1
systemctl start etcd && systemctl enable etcd

验证 etcd 服务

1
2
3
4
5
6
etcdctl --cacert=/etc/etcd/pki/ca.crt --cert=/etc/etcd/pki/etcd_client.crt --key=/etc/etcd/pki/etcd_client.key --endpoints=https://192.168.56.109:2379,https://192.168.56.110:2379,https://192.168.56.111:2379 endpoint health

# 结果如下：
# https://192.168.56.109:2379 is healthy: successfully committed proposal: took = 36.035318ms
# https://192.168.56.110:2379 is healthy: successfully committed proposal: took = 38.578044ms
# https://192.168.56.111:2379 is healthy: successfully committed proposal: took = 38.20696ms

(•̀ᴗ•́)و ̑̑

]]> <h1 id="所有虚拟机创建-etcd-目录"><a href="#所有虚拟机创建-etcd-目录" class="headerlink" title="所有虚拟机创建 etcd 目录"></a>所有虚拟机创建 etcd 目录</h1><figure class="highli COOKBOOK-Kubernetes二进制高可用部署-证书 https://gaussli.com/2025/05/07/cookbook-kubernetes%E4%BA%8C%E8%BF%9B%E5%88%B6%E9%AB%98%E5%8F%AF%E7%94%A8%E9%83%A8%E7%BD%B2-%E8%AF%81%E4%B9%A6/ 2025-05-07T09:09:49.000Z 2025-05-07T11:37:44.139Z 所有虚拟机创建目录
1
2
3
4
5
# 创建 etcd pki 目录
mkdir -p /etc/etcd/pki

# 创建 kubernetes pki 目录
mkdir -p /etc/kubernetes/pki

【etcd】CA根证书

1
2
3
# 192.168.56.109 执行
openssl genrsa -out /etc/etcd/pki/ca.key 2048
openssl req -x509 -new -nodes -key /etc/etcd/pki/ca.key -subj "/CN=etcd-ca" -days 36500 -out /etc/etcd/pki/ca.crt

【etcd】x509 v3 配置文件

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
# 192.168.56.109 执行
# x509 v3 配置文件
cat << EOF > /etc/etcd/pki/etcd_ssl.cnf
[ req ]
req_extensions = v3_req
distinguished_name = req_distinguished_name

[ req_distinguished_name ]

[ v3_req ]
basicConstraints = CA:FALSE
keyUsage = nonRepudiation, digitalSignature, keyEncipherment
subjectAltName = @alt_names

[ alt_names ]
IP.1 = 192.168.56.109
IP.2 = 192.168.56.110
IP.3 = 192.168.56.111
EOF

【etcd】服务端证书

1
2
3
4
5
6
7
8
9
# 192.168.56.109 执行
# server证书
openssl genrsa -out /etc/etcd//pki/etcd_server.key 2048
openssl req -new -key /etc/etcd/pki/etcd_server.key -config /etc/etcd/pki/etcd_ssl.cnf -subj "/CN=etcd-server" -out /etc/etcd//pki/etcd_server.csr
openssl x509 -req -in /etc/etcd/pki/etcd_server.csr -CA /etc/etcd/pki/ca.crt -CAkey /etc/etcd/pki/ca.key -CAcreateserial -days 36500 -extensions v3_req -extfile /etc/etcd/pki/etcd_ssl.cnf -out /etc/etcd/pki/etcd_server.crt
# peer证书
openssl genrsa -out /etc/etcd//pki/etcd_peer.key 2048
openssl req -new -key /etc/etcd/pki/etcd_peer.key -config /etc/etcd/pki/etcd_ssl.cnf -subj "/CN=etcd-peer" -out /etc/etcd//pki/etcd_peer.csr
openssl x509 -req -in /etc/etcd/pki/etcd_peer.csr -CA /etc/etcd/pki/ca.crt -CAkey /etc/etcd/pki/ca.key -CAcreateserial -days 36500 -extensions v3_req -extfile /etc/etcd/pki/etcd_ssl.cnf -out /etc/etcd/pki/etcd_peer.crt

【etcd】客户端证书

1
2
3
4
5
# 192.168.56.109 执行
# client证书
openssl genrsa -out /etc/etcd//pki/etcd_client.key 2048
openssl req -new -key /etc/etcd/pki/etcd_client.key -config /etc/etcd/pki/etcd_ssl.cnf -subj "/CN=etcd-client" -out /etc/etcd//pki/etcd_client.csr
openssl x509 -req -in /etc/etcd/pki/etcd_client.csr -CA /etc/etcd/pki/ca.crt -CAkey /etc/etcd/pki/ca.key -CAcreateserial -days 36500 -extensions v3_req -extfile /etc/etcd/pki/etcd_ssl.cnf -out /etc/etcd/pki/etcd_client.crt

【kubernetes】CA根证书

1
2
3
# 192.168.56.109 执行
openssl genrsa -out /etc/kubernetes/pki/ca.key 2048
openssl req -x509 -new -nodes -key /etc/kubernetes/pki/ca.key -subj "/CN=kubernetes-ca" -days 36500 -out /etc/kubernetes/pki/ca.crt

【kubernetes】x509 v3 配置文件

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
# 192.168.56.109 执行
# x509 v3 配置文件
cat << EOF > /etc/kubernetes/pki/kubernetes_ssl.cnf
[ req ]
req_extensions = v3_req
distinguished_name = req_distinguished_name

[ req_distinguished_name ]

[ v3_req ]
basicConstraints = CA:FALSE
keyUsage = nonRepudiation, digitalSignature, keyEncipherment
subjectAltName = @alt_names

[ alt_names ]
DNS.1 = kubernetes
DNS.2 = kubernetes.default
DNS.3 = kubernetes.default.svc
DNS.4 = kubernetes.default.svc.cluster.local
DNS.5 = centos1
DNS.6 = centos2
DNS.7 = centos3
IP.1 = 169.169.0.1
IP.2 = 192.168.56.109
IP.3 = 192.168.56.110
IP.4 = 192.168.56.111
IP.5 = 192.168.56.250
EOF

其中169.169.0.1为 kubernetes service 的 ClusterIP，用于 pod 内部直接访问 kubernetes。192.168.56.250为3个master对应的VIP，后续使用HAProxy和keepalive来实现VIP。

【kubernetes】apiserver 服务端证书

1
2
3
4
5
# 192.168.56.109 执行
# server证书
openssl genrsa -out /etc/kubernetes/pki/apiserver_server.key 2048
openssl req -new -key /etc/kubernetes/pki/apiserver_server.key -config /etc/kubernetes/pki/kubernetes_ssl.cnf -subj "/CN=apiserver-server" -out /etc/kubernetes/pki/apiserver_server.csr
openssl x509 -req -in /etc/kubernetes/pki/apiserver_server.csr -CA /etc/kubernetes/pki/ca.crt -CAkey /etc/kubernetes/pki/ca.key -CAcreateserial -days 36500 -extensions v3_req -extfile /etc/kubernetes/pki/kubernetes_ssl.cnf -out /etc/kubernetes/pki/apiserver_server.crt

【kubernetes】apiserver 客户端证书

1
2
3
4
5
# 192.168.56.109 执行
# client证书
openssl genrsa -out /etc/kubernetes/pki/apiserver_client.key 2048
openssl req -new -key /etc/kubernetes/pki/apiserver_client.key -config /etc/kubernetes/pki/kubernetes_ssl.cnf -subj "/CN=admin" -out /etc/kubernetes/pki/apiserver_client.csr
openssl x509 -req -in /etc/kubernetes/pki/apiserver_client.csr -CA /etc/kubernetes/pki/ca.crt -CAkey /etc/kubernetes/pki/ca.key -CAcreateserial -days 36500 -extensions v3_req -extfile /etc/kubernetes/pki/kubernetes_ssl.cnf -out /etc/kubernetes/pki/apiserver_client.crt

此客户端证书供kube-controller-manager、kube-scheduler、kubelet、kube-proxy、kubectl作为客户端连接kube-apiserver服务使用。CN 中的admin作为连接kube-apiserver的客户端用户名称。

3台虚拟机同步证书文件

1
2
3
4
5
# 192.168.56.109 执行
scp /etc/etcd/pki/* root@192.168.56.110:/etc/etcd/pki/
scp /etc/kubernetes/pki/* root@192.168.56.110:/etc/kubernetes/pki/
scp /etc/etcd/pki/* root@192.168.56.111:/etc/etcd/pki/
scp /etc/kubernetes/pki/* root@192.168.56.111:/etc/kubernetes/pki/

(•̀ᴗ•́)و ̑̑

]]> <h1 id="所有虚拟机创建目录"><a href="#所有虚拟机创建目录" class="headerlink" title="所有虚拟机创建目录"></a>所有虚拟机创建目录</h1><figure class="highlight bash"><table><tr><td COOKBOOK-Kubernetes二进制高可用部署-准备 https://gaussli.com/2025/05/07/cookbook-kubernetes%E4%BA%8C%E8%BF%9B%E5%88%B6%E9%AB%98%E5%8F%AF%E7%94%A8%E9%83%A8%E7%BD%B2-%E5%87%86%E5%A4%87/ 2025-05-07T08:37:08.000Z 2025-05-07T11:37:00.418Z 版本说明
  • kubernetes：1.31.2
  • containerd：1.7.7
  • etcd：3.5.14
  • nerdctl：1.7.7

虚拟机信息

  • IP
    • 192.168.56.109，hostname：centos1
    • 192.168.56.110，hostname：centos2
    • 192.168.56.111，hostname：centos3
  • 操作系统：CentOS7
  • 内核版本：3.10.0

系统准备

所有虚拟机禁用swap虚拟内存

1
2
3
4
5
6
7
8
# 查看默认是否开启swap虚拟内存，swap端不为0则说明开启
free -h
# 临时禁用swap
swapoff -a
# 永久禁用swap，需重启服务生效
sed -i 's/.*swap.*/#&/' /etc/fstab
# 再次查看swap是否已关闭
free -h

所有虚拟机禁用SELinux

1
2
3
4
5
6
7
8
# 查看默认是否已关闭
getenforce
# 临时禁用
setenforce 0
# 永久禁用，需重启服务器生效
sed -i "s/^SELINUX=.*/SELINUX=disabled/g" /etc/selinux/config
# 再次查看是否已关闭
getenforce

所有虚拟机关闭防火墙

1
2
3
# 所有主机执行
systemctl stop firewalld
systemctl disable firewalld

所有虚拟机开启ipv4转发内核能力

1
2
3
4
5
6
7
8
9
10
# 创建k8s特有的内核能力配置文件
cat << EOF > /etc/sysctl.d/k8s-sysctl.conf
net.ipv4.ip_forward = 1
EOF

# 开启内核能力
sysctl -p /etc/sysctl.d/k8s-sysctl.conf

# 查看内核能力开启情况
sysctl -a |grep ipv4.ip-forward

所有虚拟机配置host

1
2
3
4
5
cat << EOF >> /etc/hosts
192.168.56.109 centos1
192.168.56.110 centos2
192.168.56.111 centos3
EOF

所有虚拟机安装必要工具

1
yum install -y net-tools tree wget

(•̀ᴗ•́)و ̑̑

]]> <h1 id="版本说明"><a href="#版本说明" class="headerlink" title="版本说明"></a>版本说明</h1><ul> <li>kubernetes：1.31.2</li> <li>containerd：1.7.7</li> <li>etc 【Kubernetes】pod的QoS https://gaussli.com/2024/12/07/%E3%80%90kubernetes%E3%80%91pod%E7%9A%84qos/ 2024-12-07T04:02:01.000Z 2024-12-09T15:55:44.701Z QoS，全称Quality of Service，中文称为服务质量。Kubernetes依赖这个来确认当节点不够资源时，哪些pod优先被驱逐。当节点出现资源压力而触发驱逐动作时，只有超过了配置的request的资源可能会被驱逐。

Qos分为以下3种：

  • Guaranteed
    • 这些pod最后被驱逐。
    • 这些pod能通过cpu管理策略（CPU management policy）中的静态（static）策略来使用独占cpu。
    • 标准：
      • pod所有容器必须有memory limit和request配置
      • 所有容器的memory limit必须等于memory request
      • 所有容器必须有cpu limit和request配置
      • 所有容器的cpu limit必须等于cpu request
  • Burstable
    • 这些pod优先于Guaranteed被驱逐。
    • 标准：
      • 不满足Guaranteed的标准
      • 至少一个容器有memory或cpu的request或limit配置。
  • BestEffort
    • 这些pod最优先被驱逐。
    • 无限制是有node节点的memory和cpu资源。
    • 标准；
      • 不满足Guaranteed和Burstable的标准。
      • 所有容器都没有配置memory和cpu的request和limit。

Memory QoS使用cgroup v2的内存管理控制器（memory controller），v1.22版本中处于Alpha阶段并且默认为false不开启。这里使用cgroup v2的内存管理控制器的memory.min来处理容器中的memory request的值，使用memory.high来处理容器中的memory limit的值。

(•̀ᴗ•́)و ̑̑

]]> <p><code>QoS</code>，全称<code>Quality of Service</code>，中文称为<code>服务质量</code>。<code>Kubernetes</code>依赖这个来确认当节点不够资源时，哪些<code>pod</code>优先被驱逐。当 【Kubernetes】pod的优先级 https://gaussli.com/2024/12/06/%E3%80%90kubernetes%E3%80%91pod%E7%9A%84%E4%BC%98%E5%85%88%E7%BA%A7/ 2024-12-05T17:51:26.000Z 2024-12-06T15:40:31.500Z 在Kubernetes中，支持给pod配置更高的优先级属性，使pod的重要程度提升，从而降低被驱逐的可能。特别地，可以用在一些Kubernetes关键组件的pod上，如metrics-server、DNS等服务，毕竟这些服务一旦出现异常，可能会导致Kubernetes部分功能不可用。

而配置pod的优先级，使用的是PriorityClassName资源，模版如下：

1
2
3
4
5
6
7
apiVersion: schedule.k8s.io/v1
kind: PriorityClassName
metadata:
  name: xxx
value: 1000 # 数值越大，表明优先级越高
globalDefault: false # 全局默认优先级，一个Kubernetes集群只能有一个为true的PriorityClassName
description: xxx

在pod中指定PriorityClassName资源，从而配置pod的优先级属性

1
2
3
4
5
6
7
8
9
apiVersion: v1
kind: pod
metadata:
  name: xxx
spec:
  containers:
  - name: xxx
    image: xxx
  priorityClassName: xxx # 指定PriorityClassName的metadata.name，此属性缺省表明pod优先级为0（即最低优先级）

默认地，Kubernetes初始会有两个PriorityClassName资源

  • system-cluster-critical
    用于系统关键的pod，Kubernetes系统运行依赖这些pod。

  • system-node-critical:
    用于节点关键的pod，节点运行依赖这些pod，优先级会比system-cluster-critical更高，因为Kubernetes系统的正常运行首要条件是节点正常，即只有在节点关键pod正常运行，系统关键pod运行才有意义。

(•̀ᴗ•́)و ̑̑

]]> <p>在<code>Kubernetes</code>中，支持给<code>pod</code>配置更高的优先级属性，使pod的重要程度提升，从而降低被驱逐的可能。特别地，可以用在一些<code>Kubernetes</code>关键组件的<code>pod</code>上，如< 【Kubernetes】关闭节点 https://gaussli.com/2024/12/06/%E3%80%90kubernetes%E3%80%91%E5%85%B3%E9%97%AD%E8%8A%82%E7%82%B9/ 2024-12-05T17:23:27.000Z 2024-12-06T15:40:23.573Z 在Kubernetes中，节点可以分为优雅关闭（Graceful node shutdown）及非优雅关闭（Non-graceful node shutdown）。优雅关闭可以理解为有计划的关闭节点；而非优雅关闭，一般就出现在断电或一些集群外在因素导致节点所在宿主机异常。

优雅关闭（Graceful node shutdown）

kubelet会去检测os系统的关机事件，并且终结节点上的所有pod。此外，节点也不再接收新的pod创建请求。

节点优雅关闭功能开始于v1.21版本的特性GracefulNodeShutdown，此特性默认为true。

一旦kubelet检测到os系统的关机事件，则会把节点状态改为NotReady，且reason配置为node is shutting down。此时，kube-scheduler发现这个节点状态，将不再调度pod到该节点。而且，kubelet会在PodAdmission阶段拒绝pod的相关请求，即使pod打上了node.kubernetes.io/not-ready:NoSchedule的容忍。接着kubelet会驱逐节点上的所有pod.

一般地，节点优雅关闭受限于以下2个配置参数，参数配置为0时，则不启动节点优雅关闭功能

  • shutdownGracePeriod
    控制优雅关闭节点的时间

  • shutdownGracePeriodCriticalPods
    控制优雅关闭关键pod的时间，该时间要比shutdownGracePeriod小。这里，非关键pod会比关键pod更快驱逐。

    如何定义关键pod

此外，还有一种更细粒度控制节点优雅关闭的能力，基于kubelet configuration文件配置shutdownGracePeriodByPodPriority，这个是基于pod优先级来控制pod的驱逐顺序。此能力需要kubelet打开名为GracefulNodeShutdownBaseOnPodPriority的feature gate，此feature gate在版本v1.23进入Alpha阶段，在版本v1.31进入Beta阶段并默认配置为enabled。

具体的配置示例如下：

1
2
3
4
5
6
7
8
9
shutdownGracePeriodByPodPriority:
  - priority: 10000
    shutdownGracePeriodSeconds: 10
  - priority: 1000
    shutdownGracePeriodSeconds: 180
  - priority: 100
    shutdownGracePeriodSeconds: 120
  - priority: 0
    shutdownGracePeriodSeconds: 60

kubelet监控指标，用于提供节点关闭的指标数据

  • graceful_shutdown_start_time_seconds
  • graceful_shutdown_end_time_seconds

非优雅关闭（Non-graceful node shutdown）

在非优雅关闭的场景下，节点上的StatefulSet的pod会转变为terminating状态，但pod不会被delete以及不会调度重新运行一个新的。这是因为在非优雅关闭的场景下，kubelet无法感知关闭事件，并作出正确的delete操作。与此同时，如果pod关联了存储卷，该存储卷也无法完成解绑。所以这会导致StatefulSet应用无法提供正常的服务。

要解决上述的问题，Kubernetes已经无法自动完成处理，需要引入人工操作。在kube-controller-manager打开NodeOutOfServiceVolumeDetach的特性下，可以通过给节点打上污点：node.kubernetes.io/out-of-service，来表明节点已经无法提供服务了。此时当节点被非优雅关闭了，pod能直接自动被强制删除，并且关联存储卷也会被立即解绑，从而触发新的pod在其他节点重新拉起，StatefulSet重新提供正常的服务。

随后，一旦节点回复运行后，需要手动移除节点上node.kubernetes.io/out-of-service的污点，pod才会正常地再调度到此节点上。

(•̀ᴗ•́)و ̑̑

]]> <p>在Kubernetes中，节点可以分为优雅关闭（<code>Graceful node shutdown</code>）及非优雅关闭（<code>Non-graceful node shutdown</code>）。优雅关闭可以理解为有计划的关闭节点；而非优雅关闭，一般就出 【CentOS】yum工具问题 https://gaussli.com/2022/04/19/%E3%80%90centos%E3%80%91yum%E5%B7%A5%E5%85%B7%E9%97%AE%E9%A2%98/ 2022-04-19T15:56:47.000Z 2022-04-19T16:05:01.552Z BDB1507 Thread died in Berkeley DB library

问题描述

yum搜索、安装或更新时报错，看意思是数据库出错。

1
2
3
4
5
6
7
错误：rpmdb: BDB0113 Thread/process 19822/139881366214720 failed: BDB1507 Thread died in Berkeley DB library
错误：db5 错误(-30973) 来自 dbenv->failchk：BDB0087 DB_RUNRECOVERY: Fatal error, run database recovery
错误：无法使用 db5 -  (-30973) 打开 Packages 索引
错误：无法从 /var/lib/rpm 打开软件包数据库
CRITICAL:yum.main:

Error: rpmdb open failed

如图

问题解决

  1. 删除yum临时库文件

    1
    rm -fr /var/lib/rpm/__db.*

  2. 重建rpm数据库

    1
    rpm –rebuilddb

  3. 清理缓存及生产yumdb缓存

    1
    2
    yum clean all
    yum makecache

(•̀ᴗ•́)و ̑̑

]]> <h1 id="BDB1507-Thread-died-in-Berkeley-DB-library"><a href="#BDB1507-Thread-died-in-Berkeley-DB-library" class="headerlink" title="BDB1507 【SpringCloud】版本兼容性 https://gaussli.com/2022/03/17/%E3%80%90springcloud%E3%80%91%E7%89%88%E6%9C%AC%E5%85%BC%E5%AE%B9%E6%80%A7/ 2022-03-17T06:48:26.000Z 2022-03-17T07:02:48.630Z SpringCloud兼容性官方说明（https://spring.io/projects/spring-cloud）

SpringCloud版本SpringBoot版本
2021.0.x aka Jubilee2.6.x
2020.0.x aka Ilford2.4.x,2.5.x(Starting with 2020.0.3)
Hoxton2.2.x,2.3.x(Starting with SR5)
Greenwith2.1.x
Finchley2.0.x
Edgware1.5.x
Dalston1.5.x

Spring Cloud Dalston, Edgware, Finchley, and Greenwich have all reached end of life status and are no longer supported.
Dalston, Edgware, Finchley 和 Greenwich 版本不再更新支持。

(•̀ᴗ•́)و ̑̑

]]> <p><a href="https://spring.io/projects/spring-cloud">SpringCloud兼容性官方说明（https://spring.io/projects/spring-cloud）</a></p> <table> <thead> <tr 【容器化】Kubernetes二进制高可用部署10-Coredns部署 https://gaussli.com/2022/01/16/%E3%80%90%E5%AE%B9%E5%99%A8%E5%8C%96%E3%80%91kubernetes%E4%BA%8C%E8%BF%9B%E5%88%B6%E9%AB%98%E5%8F%AF%E7%94%A8%E9%83%A8%E7%BD%B210-coredns%E9%83%A8%E7%BD%B2/ 2022-01-16T09:11:56.000Z 2024-12-01T08:46:07.033Z 零、目录

一、说明

本文将部署Kubernetes的dns服务插件-coredns

github: https://github.com/coredns/deployment
official: https://coredns.io/

版本对应：

CoreDNS版本Kubernetes版本
v1.8.4v1.22
v1.8.0v1.21
v1.7.0v1.19 v1.20
v1.6.7v1.18
v1.6.5v1.17

二、获取coredns的部署文件

当前Kubernetes压缩包中已包含了一些扩展插件的部署yaml文件，其中就包括coredns的，在kubernetes-src.tar.gz文件中，解压出来进入cluster/addons/dns/coredns目录就能找到coredns相关的部署yaml文件

1
2
3
4
# 解压文件
tar -C /usr/local/src/kubernetes/kubernetes-src/ -zxvf /usr/local/src/kubernetes/kubernetes-src.tar.gz
# 进入coredns相关文件目录
cd /usr/local/src/kubernetes/kubernetes-src/cluster/addons/dns/coredns/

三、参数配置

1
2
3
4
5
6
7
8
9
10
# 修改其中的文件transforms2sed.sed
# 把$DNS_SERVER_IP改为kubelet启动时的DNS服务IP参数，当前为169.169.0.100
# 把$DNS_DOMAIN改为kubelet启动时的DNS域名参数，当前为cluster.local
# $SERVICE_CLUSTER_IP_RANGE此值貌似没有使用，暂不用更改
# 把$DNS_MEMORY_LIMIT改为自己设定的pod内存limit大小，官方推荐是170Mi
s/__PILLAR__DNS__SERVER__/$DNS_SERVER_IP/g
s/__PILLAR__DNS__DOMAIN__/$DNS_DOMAIN/g
s/__PILLAR__CLUSTER_CIDR__/$SERVICE_CLUSTER_IP_RANGE/g
s/__PILLAR__DNS__MEMORY__LIMIT__/$DNS_MEMORY_LIMIT/g
s/__MACHINE_GENERATED_WARNING__/Warning: This is a file generated from the base underscore template file: __SOURCE_FILENAME__/g
1
2
# 执行参数更新
sed -f transforms2sed.sed coredns.yaml.base > coredns.yaml

四、部署coredns服务

1
kubectl apply -f coredns.yaml

五、验证测试

1
2
# 查看coredns的相关资源是否启动成功，包含一个coredns的deployment，一个kube-dns的service，对应一个kube-dns的endpoints
kubectl get deploy,pod,svc,endpoints -A -owide

(•̀ᴗ•́)و ̑̑

]]> <h1 id="零、目录"><a href="#零、目录" class="headerlink" title="零、目录"></a>零、目录</h1><ul> <li><a href="/2021/09/12/%E3%80%90%E5%AE%B9%E5%99%A8%E5%8C%9 【容器化】Kubernetes二进制高可用部署9-Flannel网络插件部署 https://gaussli.com/2022/01/16/%E3%80%90%E5%AE%B9%E5%99%A8%E5%8C%96%E3%80%91kubernetes%E4%BA%8C%E8%BF%9B%E5%88%B6%E9%AB%98%E5%8F%AF%E7%94%A8%E9%83%A8%E7%BD%B29-flannel%E7%BD%91%E7%BB%9C%E6%8F%92%E4%BB%B6%E9%83%A8%E7%BD%B2/ 2022-01-16T09:11:46.000Z 2024-12-01T08:46:23.359Z 零、目录

一、说明

本文将部署Kubernetes的网络插件Flannel

占坑

(•̀ᴗ•́)و ̑̑

]]> <h1 id="零、目录"><a href="#零、目录" class="headerlink" title="零、目录"></a>零、目录</h1><ul> <li><a href="/2021/09/12/%E3%80%90%E5%AE%B9%E5%99%A8%E5%8C%9