搭建时使用WSL2，预期通过宿主机访问虚拟机的OpenClaw，通过虚拟机OpenClaw操作生成文档等，以及自动创建项目生成代码

需支持hyper-v，安装wsl2

安装环境为ubuntu22.04

部署

安装nmv

1
2

curl -o- https://raw.githubusercontent.com/nvm-sh/nvm/v0.39.6/install.sh | bash
source ~/.bashrc

安装node.js

1
2
3

nvm install 22
nvm use 22
node -v

安装OpenClaw

1

curl -fsSL https://openclaw.ai/install.sh | bash

OpenClaw终端常用命令

常见指令集

检查服务状态

1

openclaw status

运行配置向导

1

openclaw onboard 

查看控制台

1

openclaw dashboard

配置其他模型(deepseek示例)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

openclaw config set models.providers.deepseek '{
  "baseUrl": "https://api.deepseek.com/v1",
  "apiKey": "你的API_KEY",
  "api": "openai-completions",
  "models": [
    {
      "id": "deepseek-chat",
      "name": "DeepSeek Chat (V3)"
    },
    {
      "id": "deepseek-reasoner",
      "name": "DeepSeek Reasoner (R1)"
    }
  ]
}'

查看可用模型列表

1

openclaw models list --all

设置默认模型

1

openclaw config set agents.defaults.model.primary "deepseek/deepseek-chat"

基础指令集

网关指令集

配置指令集

模型管理指令集

频道管理指令集

配对管理指令集

消息发送指令集

代理（agent）指令集

会话指令集

技能指令集

日志、诊断指令集

更新升级

安全相关

OpenClaw聊天常用命令

基础命令

模型和上下文

命令控制

语音和子代理

常用命令速查

附件

docs.openclaw.ai-OpenClaw Docs

博客总是在起起伏伏，关了又开，开了又关中反复，这一次，我将风向标博客放在了Github Page上。
程序采用了当下比较流行的静态博客程序 Hexo ，Hexo其实是一个非常好的程序，但由于我经常换电脑，以前用hexo搭建的博客数据丢失了很多次，后经过更换为Wordpress，Typecho之类的开源博客程序后，我又回到了 Hexo 的怀抱，可能是真的懒得折腾了，上了年纪？
这次我将源代码都备份好了，应该会长期更新，有什么好的东西我应该会分享出来，主打原创~
可能之前认识我的人也很少，但我这个域名还是很好记的，sb coder 也是一种自嘲吧，有想跟我交流技术或者有外包工作介绍给我的，我的微信与域名同号~
多的不说了，我将尽我所能，一周至少写一篇文章，可能有时候晚上回家写一点，一天写一点，一周下来也能写不少，希望各位监督~

关于我

我是谁，职业是Go,PHP，目前全职Go开发，爱好Python，云服务器爱好者
有想法的朋友可以联系我 Telegram : ai0by

承接业务

运维及开发，个人有团队可承接业务

基于iptables的内核通讯大杀器，使用nfnetlink协议与内核通信。

他可以通过iptables定义的规则去拦截相应的网络报文，他可以基于iptables前或者后去自定义拦截这些报文，也可以通过解析这些报文做一些审计之类的工作，也可以通过这些报文来形成一个阻断功能

NFQUEU 的源代码分为 nf_queue 和 nfnetlink_queue 两部分。nf_queue 是 iptables 的一部分，nfnetlink_queue 是netfilter 的一个子模块。

nfnetlink_queue 是 nf_queue 跟用户程序之间的桥梁，是基于 nfnetlink 的专门用于 NFQUEUE 的通信机制；而 nfnetlink 是一套基于 netlink的专门用于 netfilter 的通信机制。

安全性

nfqueue是一个队列，程序通过队列的形式来处理报文，默认这个队列的长度是1024，超出此队列的报文默认会丢弃，正常环境下，要控制好这些流量。在内核 3.6 之后，可以使用 --fail-open 选项将这默认丢包改为默认接收。在 /proc/net/netfilter/nfnetlink_queue 中可以看到丢包统计。

NFQUEUE 很容易地为任意入队的包做包重排序。然而，需要注意的是内核是使用链式列表来排队包的；所以，乱序判决会带来一定的损耗。

配置

按照iptables的四表五链配置规则即可

例如：

1

iptables -t raw -I PREROUTING -p tcp --syn -j NFQUEUE --queue-num=1 --queue-bypass

• –queue-num 代表队列号
• –queue-bypass 默认情况下，如果没有用户空间程序正在监听 NFQUEUE，那么将丢弃所有要排队的数据包。使用此选项时，NFQUEUE 规则的行为类似于 ACCEPT，数据包将转移到下一个表。但此规则要求 内核 >= 2.6.39，iptables >= 1.4.11

同时，为了防止丢包，也有负载均衡的配置

--queue-balance 是 NFQUEUE 选项，由 Florian Westphal 实现，实现了同一条 iptables 规则的网络包负载均衡到多个队列。用法非常简单。比如，负载均衡 INPUT 流量到 0-3 队列的规则如下，注意，负载均衡是基于流实现的（made with respect to the flow），一条流的所有网络包会发送到同一个队列。但此规则要求 Linux 内核 >= 2.6.31，iptables >= 1.4.5

1

iptables -A INPUT -j NFQUEUE --queue-balance 0:3

其他iptables配置可以参照 iptables 配置

代码参考

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

package main

import (
"fmt"
"os"
"github.com/subgraph/go-nfnetlink/nfqueue"
)

func main() {
q := nfqueue.NewNFQueue(1) // 此处参数1需要改为绑定的对列号
ps, err := q.Open()
if err != nil {
fmt.Printf("Error opening NFQueue: %v\n", err)
os.Exit(1)
}
defer q.Close()
fmt.Println("Start Listen ...")
for p := range ps {
fmt.Println(p.Packet.String())
err = p.Accept()
if err != nil {
fmt.Println(err)
}
}
}

Audit是Linux中的审计程序，主要的作用可以看做审计日志，功能全面，可以说市面上大部分Linux探针都绕不开Audit，且Audit有着实时性很强的特性，因此可以替代部分Linux Hook操作及监控操作。

Audit主要监测的内容包含但不限于

• 文件监控（文件操作日志，创建，删除，增加，修改，权限 …）
• 网络监控 （connect，close，bind）
• 进程监控 （execve）（按pid监控）

本文主体也按照如上几种常见探针功能描述

Audit使用方式

audit 启动

如何使用肯定是第一话题，现在绝大部分的Linux主机都内置了Audit

通过命令启动即可 /etc/init.d/auditd start

audit会在目录 /var/log/audit/ 下生成log文件，通过解析audit的原始log可以拿到非常多的审计日志信息

Netlink监控，通过netlink也可以监控audit信息

audit 日志配置

列举一些常见配置

监控execve，也可用作进程启动

1

-a exit,always -F arch=b64 -S execve -k ProcStart

系统关键目录监控

1
2
3

-w /etc/hosts -p w -k HostChange
-w /etc/services -p w -k ServicesChange
-w /etc/sysconfig/network-devices/ -p w -k NetCardChange

套接字监控

1

-a always,exit -F arch=b64 -S socket -k SocketChange

连接监控

1

-a always,exit -F arch=b64 -S connect -k ConnectChange

发送消息监控

1

-a always,exit -F arch=b64 -S sendmsg -k SendMsgChange

绑定监控

1

-a always,exit -F arch=b64 -S bind -k BindChange

接收消息监控

1

-a always,exit -F arch=b64 -S recvmsg -k RecvMsgChange

关闭操作监控(量大)

1

-a always,exit -F arch=b64 -S close -k CloseChange

过滤日志

1
2

# 参照如下写法
-A exit,never -F path=/bin/ls -F perm=x

以上部分监控项实则为监控系统调用，查看整个系统的调用可以查看 ausyscall --dump，不同机型监控也不同

audit 日志配置

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

#  设置日志文件
log_file = /var/log/audit/audit.log
log_group = root
log_format = ENRICHED
flush = INCREMENTAL_ASYNC
freq = 50
#  设置日志文件大小，单位是MB
max_log_file = 8
#  日志文件滚动的数目，如果设置为小于 2，则不会循环记录。没设置则位0，不循环日志文件
num_logs = 5
priority_boost = 4
name_format = NONE
##name = mydomain
#  日志文件到达最大值后的动作，ROTATE是滚动记录
max_log_file_action = ROTATE

Audit监控文件

为什么不选择Inotify

inotify应该是应用最广泛的文件监控工具了，针对Linux的思想，一切皆文件，Inotify确实是得天独厚

inotify适用的场景不同，inotify使用epoll，性能更佳，但inotify只能监控文件的部分信息，无法做到审计，也就是操作进程的信息和操作用户信息，作为一个优秀的EDR，必然需要审计分析能力，因此Inotify只能作为部分监控项所用，如果需要溯源，audit更适合

如何判断文件的操作行为

根据不同的文件制定不同的key，如果key是唯一的那么可以通过key来识别文件，或者根据audit日志中的path来识别

操作行为可以通过系统的syscall来判断 增删改查，需要监控文件时增加文件监控属性 -p rwax

Audit监控网络访问

必须配置对应的采集配置

Audit监控进程启动

必须配置对应的采集配置

进程监控建议增加过滤，否则会积压很多Audit日志

关于探针

探针采集内容目前非常稳定，各类进程，网络，文件，防火墙（适配多种主流防火墙），系统信息，系统状态，外设，硬件设备….

欢迎交流~

• 限制并发，使程序可控
• 错峰处理，使程序平衡性更强，性能占用可控（自动错峰，如果用户不配置错峰处理，则程序自动错峰处理，区间可配置最少为1秒）
• 定时发送任务，周期型任务（按分钟），单项程序管控，使得程序定时器结束后立刻增加权重，并在结束后恢复其权重重新排序

协程控制

77sPsK.png

权重配比说明

参考了CPU及GMP的调度算法，增加了权重的配置，权重可以使程序不断地插队

建议增加任务时按大到小形式增加任务，且权重尽可能不重复，重复权重会依次排序

TODO

轮询任务，定时器监控

增加定时增加权重，轮询任务增加权重，避免一个任务长期被插队无法执行

设计

每个控制器被称作一个worker，每个worker可以控制协程数，由于各个参数不同因此不支持带参数的任务

程序在worker初始化时开启一个协程去监听add操作，并在start后退出该协程，之后所有的任务都以动态加载形式增加

任务使用链表形式存储，为了按权重插队，插队速度更快

每个worker都有一个入口workerentry，用来控制任务链表，每个workerentry都是一个协程

7XcVlF.png

worker在add的时候会再workerentry中按大到小顺序添加任务，但多个workerentry不能排序因此需要用户自行按从大到小增加任务，否则权重可能不生效

循环worker中的workerentry增加任务，到头后停止增加并从第一个workerentry重新添加

workerentry中遇到相同的权重任务时会将后加入的任务权重自动后排

删除任务时只能通过权重删除，因此权重也被视为一个编号，尽可能不要重复

head只作为链表头部，执行从head后面开始执行

7Xcnm9.png

kd-edr 中的应用

edr-agent作为系统底层硬件监控，需要对其限制性能，性能瓶颈时做出告警行为，这是 kd-schedule 的作用

edr-agent希望 kd-schedule 在初始化结束后启用动态加载的形式给链表重新排队，但当队列出现延时过高时提示错误，并重新分配协程任务

同时在任务中增加定时器概念，使得不使用重新排队也可以让任务继续执行，定时器只能保证单个entry，重新排队需要手动调用或者等待程序自动调用

不同于协程池

协程池是一个worker从池子里取任务，控制协程数不超过一个阈值，但权重排序问题比较麻烦，而且协程池无法控制程序周期

链表结构保证了可以由程序控制下一个执行的方法，支持了动态加载

动态加载（插队）

动态加载时给每个workerentry一个标记，当workerentry队列为空的时候，将动态加载的任务送给这个workerentry

任务自动加载，任务在初始阶段给定一个数值，标记其需要执行的次数，并增加定时，0为不限制次数，默认为1

示例代码

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

package main

import (
"fmt"
"github.com/ai0by/kd-schedule/schedule"
"time"
)

type edr struct {
Num int
}
type edr2 struct {
Num int
}

func main() {
var edrS = &edr{Num:0}
var edr2 = &edr2{Num:0}
wk := schedule.NewWorker(1, 100)
for i := 1; i < 9999; i++ {
_ = wk.Add(uint8(i), 50, edrS)
}
wk.Start()
// 实现接口增加任务
wk.Add(200,50, edr2)
// 闭包带参数任务
wk.AddClosureFunc(199,50, func(args ...interface{}) {
for _,v := range args{
fmt.Println(v.(string))
}
},"~~~~~~~~~~~~~~~~~~~~~~~~~~~~")
wk.AddClosureFunc(199,50, func(args ...interface{}) {
for _,v := range args{
fmt.Println(v.(string))
}
},"---------------------------")
time.Sleep(2 * time.Second)
//wk.Stop()
var cc = make(chan int)
<-cc
}

func (e *edr)TaskFunc(args ...interface{}) {
fmt.Println("--------------",e.Num)
e.Num++
time.Sleep(500 * time.Millisecond)
}

func (e *edr2)TaskFunc(args ...interface{}){
fmt.Println("+++++++++++++++++",e.Num)
e.Num++
time.Sleep(50 * time.Millisecond)
}

后续这个库应该会用在edr项目中，根据edr的需求会再迭代

Linux一切皆文件的概念，都可以用“打开open –> 读写write/read –> 关闭close”模式来操作。Socket就是该模式的一个实现，socket即是一种特殊的文件，一些socket函数就是对其进行的操作（读/写IO、打开、关闭），这些函数我们在后面进行介绍。

想要客户端和服务端在网络间通信则必须使用Socket，支持跨主机通信

在建立两端通信时，需要将客户端和服务端都创建一个Socket，像一条线通过Socket连接起两端主机，Socket创建时可以指定使用的网络协议，通常情况下是使用TCP 和UDP，而相对来说TCP的场景偏多一些

如何创建两端通信呢？首先，服务端调用 socket()函数，创建网络协议IPV4，传输协议为TCP 的Socket，接着调用 bind()函数给这个Socket绑定IP和端口，接着会调用 listen() 函数监听连接接入，通过 accept()函数等待连接连入，如无客户端连接则阻塞，客户端则在创建好 Socket 后调用 connect() 函数发起连接，指定服务端的IP及端口，然后通过TCP的三次握手后连接建立完成

这个连接过程中，监听和连接的Socket 实际上是两个Socket

T9V5Uf.png

通过上图可以发现，Socket本质上与文件传输很接近，而Linux一切皆文件的概念，Socket本质上也是文件，而上面这种Socket通信，是最简单的一对一通信，当服务端未处理完一个客户端的网络I/O时则会阻塞，而这个时候其他客户端是无法连接的，只能等待

多进程模型

基于上述的Socket阻塞传输I/O，衍生出了多进程模型，即为每个连接进来的客户端都分配一个进程去处理，阻塞也只阻塞当前进程，服务器主进程通过accept()监听客户端连接，当接收到连接后，调用系统fork()函数创建子进程，将父进程的一切内容复制到子进程中，这种复制更像是一种指针，通过子进程来继续与客户端通信，待子进程处理完后再返回给父进程，通过不同的返回值，子进程为 0。

T9eyXd.png

这种做法很容易出现垃圾无法回收的问题，子进程无法销毁，因此父进程可以调用wait()和waitpid()来回收子进程

这种多进程模型的缺点在于，不断地fork子进程会造成大量的进程间上下文切换，而且进程并不足够轻量，每次创建进程则也需要创建对应的 堆栈.寄存器等一系列资源

多线程模型

通过上面的多进程模型理念可以看出，不够轻量会导致更多的负载，那么后续又衍生出了多线程模型的概念，既然进程不满足那么就从多线程去下手

通过线程池的概念，连接连接进来时，将已连接的Socket塞到Socket等待队列中，另一边从线程池不断地取出已连接的Socket，然后创建线程交给线程去处理

T9Ju7D.png

结合之前的文章，实际应用中，每个创建的线程创建后都需要加锁，避免资源竞争问题

而这种多线程的做法很大程度上提高了一些效率，也减少了上下文切换的资源消耗问题，但是当数量很大的请求过来时，维护一个超大数量的线程池，或者说给线程池加上限，这并不是一个很好的做法，而维护也更麻烦，调度可能就会宕机，调度宕机也就面临着不可预测的问题。

I/O多路复用

多路复用的概念则是从源头出发，这种一对一的方式显然不是最好的，那么就衍生出了 一个进程/线程 对应多个Socket的技术

一个进程同时只能处理一个Socket，但是如果将这个任务时间控制到毫秒微妙级时，将多个Socket都指向同一个进程则是多路复用，他与CPU的并发模型很接近，也被称为时分多路复用

I/O 复用其实复用的不是 I/O 连接，而是复用线程，让一个 thread of control 能够处理多个连接（I/O 事件）

T9YOs0.png

select

将已连接的Socket放到一个文件描述集合(类指针)中，调用select函数将集合拷贝到内核中，内核遍历其中的Socket是否有事件产生，然后将其标记为可读,可写标识，将改过的集合送回用户态，然后用户态则继续遍历找到可读,可写的Socket对其处理

select使用bitsmap标识文件描述集合，所支持的描述符个数有限制，在Linux中的FD_SETSIZE限制，默认最大值是1024，因此只能监听0~1023个文件描述符

poll

poll与select很接近，只是不采用bitsmap存储，改用了链表，解除了限制

但由于结构未变，因此poll与select都有遍历两次循环的问题，且都需要复制两次集合的操作

epoll

epoll的诞生就是为了解决select/poll留下的问题，且目前epoll的应用场景也很多

关于存储文件描述符，epoll使用红黑树来跟踪进程所有待检测的文件描述符，将需要监控的 Socket 使用 epoll_ctl() 函数将其加入至内核中的红黑树中，这样检查 Socket 是否有事件发生则只需要传入一个待检测的 Socket 即可，不需要整个集合复制，减少了多次数据拷贝的问题

epoll 使用事件驱动，内核中维护一个链表来记录就绪事件，当 Socket 发生了事件时，内核会将其加入这个链表中，用户调用 epoll_wait() 时，只返回链表（事件发生的个数）即可，不需要整个集合返回

T9aLhF.png

水平触发

实则上面的 select/poll/epoll 都支持水平触发，当Socket有可读事件发生时，服务端不断地苏醒，直到read函数执行完才停止

边缘触发

epoll独有的边缘触发，当 Socket 有可读事件发生时，服务端从 epoll_wait 中苏醒，并执行read读取数据，由于他只苏醒一次的概念，因此我们在读取时要一次性将数据读完

边缘触发是循环从文件描述符读写数据，那么如果文件描述符是阻塞的，没有数据可读写时，进程会阻塞在读写函数那里，程序就没办法继续往下执行。所以，边缘触发模式一般和非阻塞 I/O 搭配使用，程序会一直执行 I/O 操作，直到系统调用(如 read 和 write)返回错误，错误类型为 EAGAIN 或 EWOULDBLOCK

结语

多路复用 API 返回的事件并不一定可读写的，因此使用多路复用时最好配合 非阻塞 I/O一起使用，应对特殊情况

缓冲与非缓冲 I/O

• 缓冲 I/O，利用的是标准库的缓存实现文件的加速访问，而标准库再通过系统调用访问文件。

• 非缓冲 I/O，直接通过系统调用访问文件，不经过标准库缓存。

程序在读写操作时系统并不会立刻返回数据或者处理数据，系统会监听操作并存储在缓冲区，例如C中的 Scanf 操作，只有在用户敲下了回车时才能真正将输入的字符写入，而输入的过程中可能有删除有追加，他们都是存储在缓冲区的

而非缓冲则是使程序直接访问文件系统，直接读取文件内容

直接与非直接I/O

「是否利用操作系统的缓存」，可以把文件 I/O 分为直接 I/O 与非直接 I/O

在操作文件时 可以使用参数O_DIRECT来指定是否需要直接I/O，如果有此参数则说明不需要走操作系统缓存IO

他与缓冲I/O不同在于，一个是操作系统缓存，一个是标准库缓存

例如在Go语言中，利用Go的StringBuffer，可以先将待写入的文件存入系统缓存中，待到调用 write 时才真正的写入到文件中

阻塞I/O与异步I/O

用户在发起I/O请求时，内核态会阻塞该线程，直到内核态准备好数据将数据移到程序的缓冲区阻塞才会解除

ojr1Fe.png

而非阻塞I/O是在请求后立即返回，如果没有得到结果则反复请求的过程

ojsFnP.png

如果设置了 O_NONBLOCK 标志，那么就表示使用的是非阻塞 I/O 的 方式访问，而不做任何设置的话，默认是阻塞 I/O。

这种I/O轮询的方式会拖慢整个线程的速度，因此I/O多路复用就出现了

而I/O多路复用也是基于非阻塞I/O的衍生，实际上IO多路复用也是从内核态阻塞线程变更到内核态阻塞，当数据准备好后再通知线程，这样做的好处是可以将CPU的利用率达到更高

而实际上上面所说的阻塞 非阻塞 基于非阻塞的I/O多路复用实际上本质都是同步I/O

而异步I/O则是在内核态阻塞后立即返回，当数据处理好后再通知线程

文件

DMA

在DMA技术没有应用时，I/O的过程是这样的

ovkTdH.png

当接收到程序发送的 I/O 请求时，CPU会直接阻塞住，处理数据，等待I/O处理完成后才能继续执行任务

DMA则是在这之中起到了一个中间价的作用，当CPU接收到请求时，会把任务扔给DMA就去做别的事去了，DMA将处理请求给磁盘，磁盘将缓冲区数据拷贝到内核缓冲区，当DMA读取到了足够的数据会给CPU发送中断信号，CPU接收到信号后将内核缓冲区数据返回给用户态，返回数据

文件传输

socket传输

Socket是一种可以远程可以本地传输的套接字，可以理解为一个接口，他的应用场景非常多，可以连接应用程序，可以连接网络层，websocket也正是借鉴了socket的特性开发出的一种协议

实际应用中，我们也是使用socket作为文件传输工具，也可以说，很多I/O操作也都是使用了Socket来操作的，而我们文件传输则需要socket来作为连接网卡的接口来使用

mmap

文件拷贝时，相当于 先 read 再 write

应用发起read操作时，应用调用 mmap() 可以将内核缓冲区的数据映射到用户缓冲区里面

当应用调用 mmap()时，DMA会将磁盘的数据拷贝到内核缓冲区，然后将应用进程及内核共享此内容，然后调用write，操作系统将内核缓冲区的内容拷贝到Socket缓冲区，最后把Socket缓冲区的内容拷贝到网卡缓冲区，整个过程都是由DMA操作的

sendfile（零拷贝）

在 Linux 内核版本 2.1 中，提供了一个专⻔发送文件的系统调用函数 sendfile() ，函数形式如下

1
2

#include <sys/socket.h>
ssize_t sendfile(int out_fd, int in_fd, off_t *offset, size_t count);

它的前两个参数分别是目的端和源端的文件描述符，后面两个参数是源端的偏移量和复制数据的⻓度，返回值是实际复制数据的⻓度，通过sendfile调用来发送数据，则可以替代 read + write 的操作，这样就只调用一次文件拷贝，减少了上下文开销且该方法类似mmap可以直接跳过用户态将内核态数据复制到 socket缓冲区

而网卡如果支持SG-DMA技术的话则可以在此基础上更近一步，跳过socket缓冲区直接将数据发送到网卡缓冲区

通过以下命令查看是否支持

1

ethtool -k eth0 | grep scatter-gather

在 Linux 2.4之后的版本，通过调用sendfile()来实现复制，如果网卡支持SG-DMA则复制文件则会产生如下操作

第一步，通过 DMA 将磁盘上的数据拷⻉到内核缓冲区里;

第二步，缓冲区描述符和数据⻓度传到 socket 缓冲区，这样网卡的 SG-DMA 控制器就可以直接将内 核缓存中的数据拷⻉到网卡的缓冲区里，此过程不需要将数据从操作系统内核缓冲区拷⻉到 socket 缓冲区中，这样就减少了一次数据拷⻉;

ovu7GQ.png

这就是所谓的零拷⻉(Zero-copy)技术，因为我们没有在内存层面去拷⻉数据，也就是说全程没有通过 CPU 来搬运数据，所有的数据都是通过 DMA 来进行传输的，总体来看，零拷⻉技术可以把文件传输的性能提高至少一倍以上

类似零拷贝技术的应用场景有很多，例如 ：

kafka内部使用的transferTo()实际上就是调用 sendfile

nginx通过配置可以选择是否开启sendfile

1
2
3
4
5

http { 
...
sendfile on 
...
}

大文件传输

大文件传输很少使用同步传输，由于文件的不可确定性，小文件更适合使用同步传输，大文件由于占用时间过长，如果一直等待的情况下，会让CPU一直阻塞，因此大文件通常使用 异步 I/O + 直接 I/O来替代零拷贝技术

nginx中则可以使用 如下配置

1
2
3
4
5
6

location /sbcoder.cn/ {
    sendfile on;
    aio on;
    directio 1024m;
}

当我们有两个线程同时操作同一块儿内存空间时，就容易出现资源竞争问题，这种问题目前有各种各样的出现情况，但在分布式系统中，或者说多线程任务中都是需要处理的

多线程是线程阻塞通过调度器去协调处理的，那么按理说即使是多线程实际上也都是串行操作，为什么也会出现资源竞争呢？

如下图

osnXcQ.png

当进入线程操作时，会先把变量存的值存入寄存器，待到处理完后在重新放回i的所属内存空间，那么当在放回内存时就有可能覆盖掉上一个线程操作的值，也就出现了资源竞争

解决策略

互斥

由于多线程执行操作共享变量的这段代码可能会导致竞争状态，因此我们将此段代码称为临界区(critical section)，它是访问共享资源的代码片段，一定不能给多线程同时执行。我们希望这段代码是互斥(mutualexclusion)的，也就说保证一个线程在临界区执行时，其他线程应该 被阻止进入临界区，说白了，就是这段代码执行过程中，最多只能出现一个线程。

osKHSS.png

这种行为也被称为 互斥，通过阻塞完成

同步

另外还有一种Go语言中常用的操作是 同步，当任务一和任务二同时执行时，任务二的某处任务需要等到等到任务一执行完得到的数据才能继续执行任务二，相当于Go中的信道阻塞select，只有取到数据才执行否则就一直阻塞

原子操作与锁

原子操作，类似于事务，原子操作就是要么全部执行，要么都不执行，不能出现执行到一半的中间状态

锁的概念与进程资源锁一样，进程中通过信号判断是否可以执行，而在线程中，可以通过代码来处理

声明一个变量存储 0 1 为占用状态，为 0 时进入等待队列，使用while循环等待，直到为1时才可执行，这只是一种最简单的锁

信号量

信号量则是一个类似线程池的概念，通过信号量控制线程数，当一个方法被多个线程调用时，每个线程进入方法时就增加信号量的值，直到一个负荷后阻塞后来的线程进入等待队列，当信号量发生变更时再决定是否要让新的线程进入

而信号量同样可以适用于更丰富的场景，当程序需要同时执行两块儿代码段时，那就需要占两个锁，而进入第一个锁时，另外的程序占用了第二块儿程序，就无法出现同时占两个锁的情况，也有可能造成同时的阻塞，通过信号量则可以处理此类问题，将程序1加入信号量，程序2也加入信号量，当信号量为2时可以执行两个程序，如果线程1占用了一个锁，那么线程2看到自己没有抢到锁且信号量为1则直接进入等待队列，线程1则继续拿第二个锁，程序执行完时释放加回信号量即可

读写问题

「读-读」允许:同一时刻，允许多个读者同时读
「读-写」互斥:没有写者时读者才能读，没有读者时写者才能写
「写-写」互斥:没有其他写者时，写者才能写

通过信号量来处理读写问题，所有的操作都存储于队列，当写操作开始时，所有其他任务都终止。即当写操作的信号量为0时才可以进行读操作，读操作信号量不为0时写操作不允许执行，所有任务以队列形式进入，因此，此为公平的读写操作

锁的安全性

deadlock

死锁，一个生产环境上最为可怕的错误之一，他的形成原因大概可以被解释为，程序1和程序2都在等待对方结束才可执行，结果造成了无限期的等待，程序就此卡死，典型的死锁场景

死锁一般长出现于并发线程场景，满足如下条件时会发生

• 互斥条件，互相等待对方结束后才可继续执行，一次两个或多个线程同时阻塞
• 持有并等待条件，持有资源一后需要拿到资源二的时候发生，不释放资源一（参照哲学家就餐的问题，可以按照规定顺序拿资源解决，按场景使用信号量解决）
• 不可剥夺条件，当线程A持有资源时，必须等到线程A结束时线程B才可获取
• 环路等待条件，两个线程获取的资源形成环形链，死循环造成死锁

在Go语言中可以使用pprof来跟踪堆栈获取死锁行为的信息

死锁解决策略

所有的资源全部按顺序获取，例如强制线程来的时候先拿A资源再拿B资源，当A信号量不足时线程阻塞等待，直到 A，B资源同时被上一个线程拿到后再释放信号量

这么做的目的是为了资源的合理分配，而这种情况也会导致资源的缓慢阻塞问题，要最大化的利用则可以根据场景去制定更好的合理化资源分配方案

自旋锁还是互斥锁

简单来说，互斥锁是通过内核态由CPU调度处理的锁，当程序没有拿到锁的时候会直接释放CPU，进入睡眠等待，也就是上下文切换，等到拿到锁的时候再唤醒

自旋锁是发生于用户态的锁，由用户程序控制，通俗地讲使用while去轮询获取锁，也算是阻塞等待了，这种操作在Go语言中还挺常见的（所以我总是认为Go的设计理念很大部分都是基于用户态的），CPU提供了PAUSE函数去等待获取锁，相对于while他可以有效减少耗电量，自旋锁可以通过CPU去加锁，CPU提供了CAS函数来加锁，也可以用户自定义锁的方式来做

是否有必要读优先或者写优先

字面意思，读优先是，不管什么情况下，读写锁，只要有读操作的线程加入，那么写就要向后排，直到所有的读操作结束写操作才能结束，而写优先则反之

这种情况可以有效地解决一些并发场景，但一昧的单条优先行为，可能会导致 读或者写长期阻塞（饥饿），这并不是开发者愿意看到的，所以使用这种读写优先锁，还是要谨慎

悲观锁和乐观锁

首先，为了安全性稳定性，我们上述的所有操作都属于悲观锁

乐观锁是什么呢？它的工作方式是，先修改完共享资源，再验证这段时间内 有没有发生冲突，如果没有其他线程在修改资源，那么操作完成，如果发现有其他线程已经修改过这个资源，就放弃本次操作，释放寄存器。

反之悲观锁是只要占用上就不能继续操作

但某些场景下，为了效率，有的人也推荐使用乐观锁

例如在线文档，如果使用悲观锁，那么有人进入文档操作时，剩下的人都得等待，直到编写完成后才能查看或写入，使用乐观锁则可以通过数据判断修改内容，达成在线多人文档的需求

我们常用的Git和Svn等常见的版本控制工具也都是借鉴了这种想法思路

进程

基本概念

将编译好的的二进制程序，在系统中执行起来的程序会被CPU装载到内存中，CPU会按照程序的指令去顺序执行程序，这个执行中的程序被称之为进程，多个程序同时执行则被称为多进程

单核CPU在执行任务过程中不能同时执行多余的任务，但是我们在实际场景中往往可以看到一台电脑有非常多的进程在运行，这就引出了进程的中断，当程序在读写硬盘这种慢IO操作时，当前进程会发出中断指令，使得CPU去执行下一个进程，防止了阻塞等待的问题，而CPU的执行效率是非常快的，所以更多时候即使他是串行执行程序，但也可以完美接收并发任务

o8RNHH.png

值得注意的是，并发和并行并非一样的东西，并发是代表一个CPU核心同时处理多个任务的情况，而并行是多个CPU核心处理多个任务

o8RSBQ.png

当进程中有大量硬盘IO操作时，将会出现大量的进程阻塞行为，而这种情况可能会占用大量的物理内存，在虚拟内存中，则会将这种阻塞的进程物理内存地址转移至硬盘地址，直至阻塞结束后再替换回物理内存中

而这种进程的执行过程也可以分为 创建、终止、阻塞、唤醒 的过程

线程

基本概念

一个进程可以有一个或多个线程

个人认为 ~ 线程是进程的抽象化，当一个进程只有一个线程时，那么这个线程就是进程

线程与进程，进程容纳了所有的资源，内存文件及各种单位，线程则只有寄存器和栈，线程与进程相同，同样有 阻塞和唤醒。

线程只有寄存器和栈的特性，以至于创建一个线程比创建进程更方便快捷，占用资源更少，当然前提是这些线程之间的共享资源大部分相同

进程占用资源，线程执行过程，线程都是依托于进程的，线程之间可以共享进程的资源

三种形式

• 用户线程 （User Thread）
• 内核线程 （Kennel Thread）
• 轻量线程 （LightWeight Thread）

首先要明确一个事实，他们并不是同一个维度的，多个用户线程对应多个内核线程，也就是他们是多对多的关系（协程则相当于一个内核线程对应了多个用户线程）

oG86l6.png

通常我们常说的线程大部分指的是内核线程 ~

用户线程是由用户发起的调用，操作系统无法干预，当用户线程执行过程中，操作系统无法查看当前线程的情况也无法由操作系统关闭，即任务管理器也没用（协程则可以通过 pprof 之类的debug工具去测试）

用户线程相当于用户自发开启的线程，不通过系统内核，也可以认为启动用户线程的速度要比内核线程要快的多，也因为如此，即使是不支持线程的系统，也能由用户自发开启的线程来开启用户线程无需兼容内核

内核线程则是通过操作系统调用的，可以通过操作系统去管理该线程，相比于用户线程，内核线程的资源分配更加合理，且用户线程可能会因为阻塞导致多个线程同时阻塞，而内核线程的调度则由操作系统直接完成，无需考虑这一问题，但相比于用户线程，显然内核线程要更重量级一些

轻量线程有多重解释，它相当于内核线程与用户线程的对应和结合，相当于用户线程与内核线程的桥梁或者中间层，与用户线程也是，多对多的关系，兼容三种模式 1:1 N:1 N:N

1:1 一个用户线程 对应一个轻量线程 对应一个内核线程
N:1 多个用户线程对应一个轻量线程 对应一个内核线程
N:N 混合模式，前面两种方式的结合，多个用户线程对应多个轻量线程，由轻量线程找到内核线程一一对应

调度

调度模型

进程调度，当出现IO请求的时候，调度会将当前执行的进程切换到另一个进程，并保留上下文，以便于稍后切换回来时能够继续执行之前的进程

进程调度，当出现长时间占用CPU的进程时，造成系统吞吐量降低，调度会权衡任务完成数量

如果一个进程本身计算不复杂，而占用时间长时，需要考虑是否是IO的调用导致的，频繁的IO请求会增加CPU的进程切换，也会加大程序的执行时长

调度对于鼠标键盘等需要实时响应的程序会优先考虑

进程如果处于就绪状态，调度会尽快让进程继续执行

进程之间会通过内核的时间分片去模拟出并发场景，当单核CPU出现三个进程时，如果都没有阻塞，则调度会通过时间分片的方式先完成简单的程序然后再完成复杂程序，ABC三个进程同时存在时，按照进程顺序， A B C，内核会分配一个固定时间分片，例如 5ns，A执行5ns后执行B，B执行5ns后执行C，假设进程B执行完成时，则调度会继续A C之间的循环，B完成后执行C，C执行5ns后执行A，然后循环执行A C

如上操作会出现一个问题就是内核会频繁的切换进程，我们知道上下文也是消耗资源的，那么内核会做一个递增时间分片的操作，例如一开始是5ns，后续可能就递增为 10ns 15ns，以便于尽早完成一个进程减少进程上下文

oaUUtx.png

通信

管道
在Linux中我们常用的通信管道，|，如下命令中 ps -ef |grep sbcoder ，里面的符号位 | 就是一个管道，他代表将前一个进程中的数据带到下一个进程中

这种没有命名的管道被称之为 匿名管道，匿名管道将在进程结束后释放，有匿名则也有有名字的管道 命名管道 ，Linux中通过关键字 mkfifo 创建命名管道 mkfifo sbcoderChannel，通过命令可以将数据传输至管道中，echo "sbcoder" > sbcoderChannel，接着命令就卡住了，这与Go语言中的信道很类似，有阻塞的作用通过阻塞我们可以做很多事情，有入则有出，可以通过命令取出数据 cat < sbcoderChannel 获取刚才echo进去的数据

管道实际上是内核中的缓存，而读取管道数据则是在一个进程中fork出一个子进程去读取，而如果由一个进程同事负责读写则会非常混乱，所以如果需要双向通信则需要fork两个子进程，而创建子进程也会徒增负荷，也要尽可能避免此类操作

oa1uHf.png

消息队列
消息队列是保存在内核中的消息链表，由于消息队列的特性，会出现通信不及时和大小限制问题，更适合小数据的场景

共享内存
进程A与进程B都使用虚拟内存（只保存物理地址），则可以实现同一个数据块儿被两个进程同时使用

oa38IO.png

当A和B同时操作一块儿内存时，则也会出现问题，很容易造成数据冲突，就出现了lock的概念，也被称为 信号量，A操作时将信号量数值更改，B同时操作时发现数值已经被更改则说明资源被占用，进程阻塞，A在操作完成后会将信号量数值再改回去，B此时即可继续执行

oa89YD.png

信号Signal

信号，也就是Signal，通过进程中的各种指令做通信，例如：程序接收到快捷键 ctrl + c 则会终止程序

Go语言中的Signal同理~

socket

不同主机之间的socket通信，为了方便不同主机之间的进程通信，衍生出的通信方式，他可以借助 TCP以及UDP以及本地进程等方式通信，其中TCP和UDP更适用于远程主机通信，而本地通信可以借助本地进程通信（字节流，数据报）

思考

• 高并发场景是否应该频繁读取硬盘信息呢

个人感觉可以通过一个大文本读取至内存，然后并发处理的过程中将会很少产生阻塞行为，但也属于物理内存充足的情况下（空间换时间）

• 如何更好的利用进程特性处理高并发任务

我们了解并发实际也是自上至下的串行执行程序，那么也要适当地减少并发任务的复杂度和频繁的IO操作，但合理运用内存很重要，如果能计算出什么时间内物理内存的占用情况则更合理一些

• 单内核多进程调度场景，如何设计更适合的程序结构

个人认为，应该尽可能减少进程数量，在用户态之间搞定，类似Go的GMP调度，如果进程数量实在无法减少可以尝试将某些轻量级程序减负，让重量级的程序保持，多应用消息队列的方式进行通信（过多使用消息队列也是负担），需要综合考量异步的优缺点

物理内存

物理内存是真实的内存空间，通过物理内存地址，标记存储的数据，物理内存的实际大小也与内存条有关，由内核直接调用使用

虚拟内存

虚拟内存是物理内存的映射关系，为了防止程序开辟不同的物理内存空间，或者多处占用，则由操作系统去调度，使得进程在调用使用内存时需要通过虚拟内存的映射找到对应的物理内存地址，最终才能使用存储数据

如下图所示

olRoWT.png

Swap内存空间

Swap内存空间，顾名思义就是交换内存的空间，它的空间是硬盘空间，他是一个很有意思的东西，我们真实的内存空间存储时也是分一段一段去存储的，由于无法连续，那么可能也就无法让性能最大化

例如下图

olWiOH.png

游戏，浏览器及音乐各占不同的内存空间，当浏览器进程退出时，操作系统会回收内存空间，但由于它是一段一段存储的，导致后来的程序想要占用200M的内存空间则无法实现，最多只能使用128M。

而交换空间则应运而生，程序在发生浏览器退出时，会将后面的音乐占用内存放到交换空间中，而后清空游戏后面的内存，再将音乐内存直接放到游戏内存后面，而后面的下一个程序则可以直接占用内存200m

所以交换空间配置适量的大小也很重要，太大没意义，太小则可能无法满足释放内存的需求，而由于交换空间是硬盘空间，速度显然不是很友好，因此相当大的程序释放（放入）时也许会造成程序卡顿。

而这种分段的片段，也可以称之为内存分段

由于内存分段的数量过于庞大，他需要每次程序释放时同时释放内存碎片，为了更好地释放内存，物理内存存储的也是映射关系，也称之为 内存分页，相当于一个索引，一个内存分页存储着不同内存分段的物理地址，而程序只需要通过内存分页即可找到真实的内存数据，由于现实场景中，进程数量的激增，一层分页也无法满足所有，需要每个进程都保存一份分页不太现实，就出现了多级分页，只存储顶级分页及常用的二级分页

olj5DI.png

总结来说 Swap是硬盘空间，速度较差，它存储的进程数据一般是交换空间数据或者不活跃的进程数据

总结

为了在多进程环境下，使得进程之间的内存地址不受影响，相互隔离，于是操作系统就为每个进程独立分 配一套虚拟地址空间，每个程序只关心自己的虚拟地址就可以，实际上大家的虚拟地址都是一样的，但分 布到物理地址内存是不一样的。作为程序，也不用关心物理地址的事情。

每个进程都有自己的虚拟(内存)空间，而物理内存只有一个，所以当启用了大量的进程，物理内存必然会很紧 张，于是操作系统会通过内存交换技术，把不常使用的内存暂时存放到硬盘(换出)，在需要的时候再装 载回物理内存(换入)。

划分空间

C语言中的空间划分

C语言有着各式各样的内存清理问题，这也是各种C语言BUG的大头

o1pdmj.png

C语言中，动态分配的内存（malloc，mmap）则是动态分配堆和文件的内存

参考

• 小林Coding（图解系统）

近期写一写感谢大佬的电子图书笔记，小白受益良多

CPU Cache是在内存的基础上，可以被CPU直接读取的缓存，分为 L1,L2,L3 三层缓存级别，他的读取速度，是内存的100倍以上，我们都知道基于内存的数据库Redis，仅仅是使用了内存存储就很快了，CPU Cache则更快，利用好CPU Cache则可以让你编写的程序更快。

相比较各类IO操作，CPU Cache则是最底层的，分级一般为 L1 Cache > L2 Cache > L3 Cache > MEM > SSD > HDD，按照现在市场上面的定价，相对应的价格也是梯形下降

相对于CPU Cache昂贵的价格，带来的收益自然也要更高，可以通过如下命令查看所在机器的CPU Cache分别是多少，从而更有利于优化代码

1
2
3
4
5
6
7
8
9
10
11

# 获取L1 数据缓存大小
cat /sys/devices/system/cpu/cpu0/cache/index0/size

# 获取L1 指令缓存大小
cat /sys/devices/system/cpu/cpu0/cache/index1/size

# 获取L2 Cache 大小
cat /sys/devices/system/cpu/cpu0/cache/index2/size

# 获取L3 Cache 大小
cat /sys/devices/system/cpu/cpu0/cache/index3/size

一般来说 L3 的容量 > L2 > L1数据 = L1指令

oMLjgI.png

越靠近 CPU 核心的缓存其访问速度越快，CPU 访问 L1 Cache 只需要 24 个时钟周期，访问 L2 Cache 大约 1020 个时钟周期，访问 L3 Cache 大约 2060 个时钟周期，而访问内存速度大概在 200300 个 时钟周期之间。

时钟周期是CPU主频的倒数，例如 2GHZ主频的CPU，一个时钟周期是 0.5ns

CPU Cache Line

CPU Cache Line 是每次CPU载入缓存的大小，CPU在读取缓存信息时并非是一次一字节读取而是每次读一个固定字节长度的数据

1

cat /sys/devices/system/cpu/cpu0/cache/index0/coherency_line_size

oMOIRs.png

由于他每次是读一块儿数据，那么我们在编写代码时则可以避免多次读取内存，可以将数据内容压缩到64位以内，避免重复读

当我们在使用数组时，例如一个 数据 A 长度 65，则会缓存前64位数组内容，例如从下标0读到63，则不会重复读取内容，那么如果读0 然后 读 64呢？

答案是会重复读内存，他会自动缓存从0开始的一共长度64的数据，那么下标64已经超出这个长度则会重复读内存

那么如果读 0 然后读 2呢，还会重复读内存吗？

答案也是肯定的，如果跳着读他会重复缓存，必须是一个连续的数值才可以利用上这个长度

1
2
3
4
5
6
7

p : = [3][3]int{{1, 2, 3}, {4 ,5, 6}, {7, 8, 9}}
for i := 0; i < 3; i++ {
for j := 0; j < 3; i++ {
fmt.Println("echo : " ,p[i][j])
// fmt.Println("echo : " ,p[j][i])
}
}

上述Go代码中 fmt.Println("echo : " ,p[i][j]) 是在内存中读取连续的数值，而 fmt.Println("echo : " ,p[j][i]) 则并非是在读连续数据，他会不断地请求内存，从而会发现前者的效率更高一些

总结 ： 抛开一切因素，读取数据时按照存储顺序来读一定要比任意读效率要高，如果有条件控制数据长度那么可以结合CPU Cache Line 的长度来做一些优化

CPU分支预测

CPU本身是有一个分支预测功能，它相当于一个CPU自带的优化器，当我们在代码中使用if判断的时候，CPU会自行预测他的结果并缓存，那么CPU预测的结果就一定是准确的么，当然不是~

既然CPU的分支预测可以在不知道结果的情况下缓存他认为正确的数据，那么我们在编写代码时则可以适当地让CPU的分支预测更准确，那么也就避免了继续从内存读取数据，避免了多余的操作

代码实现该如何做呢，当一个if语句大多数时间都是 真 的情况下，那么CPU的分支预测将在后续预测中更容易缓存 真 的数据，也可以说，我们的代码尽量让数据保持在一个分支中，可以避免重复读取操作

除了这种CPU自动的分支预测，C语言也提供了一个方法可以告诉CPU大概的结果，从而使CPU更多的缓存某个分支的数据

1
2
3
4
5
6
7
8
9

#define likely(x) __builtin_expect(!!(x),1)
#define unlikely(x) __builtin_expect(!!(x),0)

if (likely(a == 1))
{
/* code */
}else{
/* code */
}

数据类型和线程绑定

一般情况下，long 类型 要占用更多的空间，所以很多人在使用时更愿意使用 int，但是在CPU Cache line 中确并不如此，如果一些相同的数据经常要一起使用，我们尽量需要把数据长度控制在特定长度之内或者将数据按照指定顺序来存储更好。

数据类型会影响什么，真的是占用内存越小越好吗？

并非如此，现在的服务器更多的是多核CPU，单核CPU则不需要特别注意，多核CPU在处理数据的时候，L1，L2 Cache是独立存在于各个CPU核心的，只有L3 Cache是共享的，既如此，那么L1 和L2的Cache是如何共享信息保持数据一致性？

如果一个进程在不同核心 来回切换，各个核心的缓存命中率就会受到影响，当有多个同时执行「计算密集型」的线程，为了防止因为切换到不同的核心，而导致缓存命中率下降的问 题，我们可以把线程绑定在某一个 CPU 核心上

在 Linux 上提供了 sched_setaffinity 方法，来实现将线程绑定到某个 CPU 核心这一功能，从某些程度上来说，亦可以保证数据的一致性问题

多核多线程之间的数据一致性如何保证？现在市面上大多数的CPU核心是通过 MESI 协议来保持数据一致性的，是Modified Exclusive Shared Invalidated的缩写，即是： 已修改 独占 已共享 已失效

oleDCd.png

如上，当两个线程都在操作时，A和B都是从内存取出一块儿数据来操作（CPU Cache Line），很多情况下，如果未能保证数据的连续性，A线程就容易拿到B的数据，B也会拿到A的数据，如果A线程操作变量内容时，那么B也需要同时修改才能保证数据的一致性

那么数据的’锁‘该如何保证呢，则是 MESI协议来保证的。

线程A操作变量发生变化时，线程A不会广播写入到内存，而是将数据标识为 已修改，而其他线程则是将数据标记为 已失效，当线程读取数据发现标识为已失效时才会重复读取数据更新数据，否则频繁的刷新数据则失去了CPU Cache的意义

当线程A将已修改的数据写入到内存后，其他线程也更新完数据，那么，将会把数据标记为 已共享

当线程A创建一个数据，其他线程缓存并不存在该数据时则该数据为 独占

如上，当出现越来越多的数据在不断地变化，多个线程操作同一块儿缓存，即使有MESI协议的调度，也不免多了很多操作，所以有些人就想到了用占位更大的字符类型让一个变量占用更多的字节数，从而达到保证线程永远拿到这一块儿数据的时候不会有其他线程的共享数据，而实际上，在多核系统中，也提供了宏定义 __cacheline_aligned_in_smp 来保证数据的长度与CPU Cache Line 保持一致

olnX9J.png

如上，A和B通过宏定义 __cacheline_aligned_in_smp 定义后，字节数会各自占用一块儿，则避免了数据频繁共享的问题

参考

• 小林Coding（图解系统）

近期写一写感谢大佬的电子图书笔记，小白受益良多

基于 fatedier/frp 的内网穿透服务
参考文档 frp中文文档
参考文档 使用frp进行内网穿透

服务端

直接下载 Releases · fatedier/frp
找到对应版本下载即可，我这里服务端选用的是 frp_0.33.0_linux_386

国内机器速度慢可以使用我的个人镜像地址

1

wget https://api.0161.org/resources/frp_0.33.0_linux_386.tar.gz

修改配置文件 frps.ini 文件，建议增加Token验证 关于服务端配置可以参照官方给出的完全版配置文件及注释查看 frps_full.ini 文件

配置示例

1
2
3
4
5
6
7
8

[common]
bind_port = 7000
token = 123456
dashboard_port = 7500
dashboard_user = admin
dashboard_pwd = 123456
vhost_http_port = 10088
vhost_https_port = 10443

1

nohup ./frps -c ./frps.ini &

查看后台进程

1

jobs

删除进程示例

1
2

ps -ef | grep frps | grep -v grep
kill <进程id>

根据上述配置好的端口 7500 使用 IP+端口 访问frp面板 输入面板用户名+密码
该面板无实际性作用，仅用来做探针以及查看当前服务的状态，如未配置dashboard则无法使用dashboard

1.png

客户端

下载 客户端 可以直接在github下载或者使用我的

1

wget https://api.0161.org/resources/frp_0.33.0_windows_amd64.zip

解压后修改 frpc.ini

1
2
3
4
5
6
7
8
9
10
11
12
13

[common]
server_addr = <你的服务器IP地址>
server_port = 7000
token = 123456
[rdp]
type = tcp
local_ip = 127.0.0.1           
local_port = 3389
remote_port = 7001
[web]
type = http
local_port = 80
custom_domains = <你的远程解析域名 例如: xxx.0161.org>

上述使用Windows开启3389后可以访问远程桌面，Linux同理，只需要修改为 SSH 即可

2.png

值得注意的是 custom_domains 这个参数需要配合 vhost_http_port 这个参数使用，由于跟Nginx冲突所以上述端口我开启的是 10088
可以使用域名解析的方式 架设游戏服务器 或者网络云盘 群晖 你懂得网站等

Nginx反向代理

使用上述配置必须要使用 域名+端口 的形式才能访问，如果要用正式环境则不美观，且我们希望它与Nginx共存，因此，可以通过Nginx反向代理的形式去解析
配置Nginx配置文件

1
2
3
4
5
6
7
8
9
10
11
12

server {
    listen       80;
    server_name xxx.0161.org;

    location / {
        proxy_pass  http://127.0.0.1:10088;
        proxy_set_header Host $host;
        proxy_set_header X-Real-IP $remote_addr;
        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
        proxy_set_header REMOTE-HOST $remote_addr;
    }
}

流程图解

3.png

至此，可以直接访问 xxx.0161.org 无需携带端口号

网易云是有一个官方的音乐解析接口的，只是隐藏的比较深（其实也还好），可以选择使用官方的解析接口也可以使用我的，可能官方的有时效性

Step1. 找到一张无版权歌曲
点击生成外链播放器

aPDuNR.png

Step2. 选择flash播放器
开启F12 审查元素 选择flash播放器

aPDnE9.png

Step3. 搜索接口
直接在F12 搜索 song 找到如下接口

aPDZB4.png

Step. 复制接口地址
302直接跳转，我们可以直接获取到直链地址

aPDeHJ.png

找到官方接口

1

https://music.163.com/song/media/outer/url?id=<歌曲ID>

根据官方内容自制接口

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

<?php
$params = $_REQUEST;
$returnData = [];
$returnData['src'] = 'error 500';
$returnData['code'] = 0;
$returnData['msg'] = '无状态';
if (!isset($params['url']) || empty($params['url'])) {
$returnData['msg'] = '5001 URL或者ID参数不存在';
    echo json_encode($returnData,JSON_UNESCAPED_SLASHES);
    exit();
}
$url     = $params['url'];
$pattern = '/(\d{5,20})/i';
preg_match($pattern, $url, $matches);
if (!$matches) {
$returnData['msg'] = '5002 URL或者ID格式有误';
    echo json_encode($returnData,JSON_UNESCAPED_SLASHES);
    exit();
}

$getParameterUrl = 'https://music.163.com/song/media/outer/url?id=' . $matches[0];
var_dump($getParameterUrl);exit();
$headers = get_headers($getParameterUrl, TRUE);
//输出跳转到的网址
if ($headers['Location']) {
$returnData['msg'] = '成功';
$returnData['src'] = $headers['Location'];
$returnData['code'] = 1;
}
echo json_encode($returnData,JSON_UNESCAPED_SLASHES);

exit();

二次封装之后可以使用
注意：网易云的这个接口无法使用国外IP访问，如IP不符可能会返回404

可以使用我的API接口获取最新版解析

注意：最低配置为 2H4G1M 本教程使用 2H8G5M Ubuntu18.04
卸载旧版Docker

1

sudo apt-get remove docker docker-engine docker.io containerd runc

脚本安装Docker

1

curl -fsSL https://get.docker.com | bash -s docker --mirror Aliyun

更换阿里云源
登录 https://cr.console.aliyun.com/cn-hangzhou/instances/mirrors

找到 加速地址，或者使用我的

1
2
3
4
5
6
7
8

sudo mkdir -p /etc/docker
sudo tee /etc/docker/daemon.json <<-'EOF'
{
  "registry-mirrors": ["https://p4sew3ge.mirror.aliyuncs.com"]
}
EOF
sudo systemctl daemon-reload
sudo systemctl restart docker

安装Rancher

1

sudo docker run -d --restart=unless-stopped -v /home/rancher:/var/lib/rancher/ -p 80:80 -p 443:443 rancher/rancher:stable

打开 https://<你的IP>
忽略掉证书提示，继续进入

1.png

添加集群

Step1.设置语言

2.png

Step2.选择右上角添加集群，选择自定义

3.png

Step3.设置好集群名字后直接点击下一步

Step4.配置节点
按照需要配置，我这里选择全部

4.png

Step5.配置公网IP
云主机需要配置

5.png

Step6.复制命令执行

6.png

执行后会启动一个容器

7.png

Step7.集群部署节点完成
准备中…

8.png

完成部署

9.png

增加节点

选择主机 - 编辑集群

11.png

拉到最下面，与上面添加节点方式一样，修改为子节点的ip，然后在子节点运行该命令
等待添加完成

10.png

架构

Kubernetes是一个完备的分布式系统支撑平台。Kubernetes具有完备的集群管理能力，包括多层次的安全防护和准入机制/多租户应用支撑能力、透明的服务注册和服务发现机制、内建智能负载均衡器、强大的故障发现和自我修复功能、服务滚动升级和在线扩容能力、可扩展的资源自动调度机制，以及多粒度的资源配额管理能力。同时kubernetes提供了完善的管理工具，这些工具覆盖了包括开发、测试部署、运维监控在内的各个环节；因此kubernetes是一个全新的基于容器技术的分布式架构解决方案，并且是一个一站式的完备的分布式系统开发和支撑平台

Kubernetes简易.png

Kubernetes Service

Service的服务进程目前都基于Socker通信方式对外提供服务，比如redis、memcache、MySQL、Web Server，或者是实现了某个具体业务的一个特定的TCP Server进程。虽然一个Service通常由多个相关的服务进程来提供服务，每个服务进程都有一个独立的Endpoint(IP+Port)访问点，但Kubernetes 能够让我们通过Service虚拟Cluster IP+Service Port连接到指定的Service上。有了Kubernetes内建的透明负载均衡和故障恢复机制，不管后端有多少服务进程，也不管某个服务进程是否会由于发生故障而重新部署到其他机器，都不会影响到我们对服务的正常调用。更重要的是这个Service本身一旦创建就不再变化，这意味着Kubernetes集群中，我们再也不用为了服务的IP地址变来变去的问题而头疼。

service可以通过访问点去访问不同的子节点下面的Pod上，类似一个Proxy的概念，个人理解为他本身类似集群，通过service分发
与swarm集群中的service类似，可以保持容器启动数量，由于权限相关问题，用户手动命令要大于service控制的权限级别，因此如果在使用service控制Pod时，有可能导致报错，不推荐使用

Kubernetes Service.png

Kubernetes Pod

Pod运行在一个我们称之为节点Node的环境中，可以是私有云也可以是公有云的虚拟机或者物理机，通常在一个节点上运行几百个Pod;其次，每个Pod里运行着一个特殊的被称之为Pause的容器，其他容器则为业务容器，这些业务容器共享Pause容器的网络栈和Volume挂载卷，因此他们之间的通讯和数据交换更为高效。在设计时我们可以充分利用这一特征将一组密切相关的服务进程放入同一个Pod中。
并不是每个Pod和它里面运行的容器都能映射到一个Service 上，只有那些提供服务(无论是对内还是对外)的一组Pod才会被映射成一个服务。

Kubernetes Pod.png

Pod & Container

• 容器（Container）是一种高度隔离的封装程序

  

  容器1.png

  非所有的应用都适合选择容器，开发者可以根据自己应用的特点和需求选择最适合的计算单元。例如，你的应用是高性能、互信的，且处于同一个管理区域，那么用线程或者进程就可以满足；但如果你的应用是多租户的，并且和其他应用运行在同一个空间，那么你就需要考虑如何将这些应用安全地隔离开，使得数据不会被泄露或性能受到影响。那么这时，容器也许就是一个不错的选择了。
  容器便于管理，因为现在市场上有着完全完善的生态以及Docker的支持度愈发增加，越来越多的公司（个人）选择Docker，我个人也更倾向于Docker，有了Docker就可以非常完美的管理Images以及Container

  

  容器2.png

  容器是只占用很少的空间的，真正占用空间大的是Images，也可以说 Container 依赖 Images

• Pod，一种增强型容器
  Pod是一种组合的多容器运行单元，也是Kubernetes里的一个基础单元。你可以把它看作是一种容器的扩展或者增强型的容器。Pod里面包括一个主容器和数个辅助容器，它们共同完成一个特定的功能。把多个进程（容器也是一种隔离的进程）打包在一个Name Space里的时候，就构成了一个Pod。Pod里面不同进程的应用包装仍然是独立的（每个容器都会有自己的镜像）。
  Pod的意义在于，它可以既保持主容器和辅助容器的的密切关系，又保持主容器的独立性。由于主容器和辅助容器的生命周期相同，可以同时被创建和销毁，因此把它们放在一个Pod中，可以使他们的交互更加高效。

参考文档

Aholiab - 云原生的基石，一文读懂容器、Docker、Pod到底是什么！
abcdocker编写k8s中文文档
Ubuntu18.04使用kubeadm部署v1.18 HA集群

部署k8s

机器选择

这里我只做学习用途，因此开通的是阿里的按量计费机器以及低配置机器

• master01 2H8G 阿里云 Ubuntu18.04
• node01 2H8G 阿里云 Ubuntu18.04

部署环境

Ubuntu修改仓库镜像

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

sudo cat > /etc/apt/sources.list << EOF
deb http://mirrors.aliyun.com/ubuntu/ bionic main restricted universe multiverse
deb-src http://mirrors.aliyun.com/ubuntu/ bionic main restricted universe multiverse

deb http://mirrors.aliyun.com/ubuntu/ bionic-security main restricted universe multiverse
deb-src http://mirrors.aliyun.com/ubuntu/ bionic-security main restricted universe multiverse

deb http://mirrors.aliyun.com/ubuntu/ bionic-updates main restricted universe multiverse
deb-src http://mirrors.aliyun.com/ubuntu/ bionic-updates main restricted universe multiverse

deb http://mirrors.aliyun.com/ubuntu/ bionic-proposed main restricted universe multiverse
deb-src http://mirrors.aliyun.com/ubuntu/ bionic-proposed main restricted universe multiverse

deb http://mirrors.aliyun.com/ubuntu/ bionic-backports main restricted universe multiverse
deb-src http://mirrors.aliyun.com/ubuntu/ bionic-backports main restricted universe multiverse
EOF

关闭防火墙

1

sudo ufw disable

时间同步

1
2
3
4
5
6
7
8

sudo apt-get install chrony -y && sudo systemctl start chrony && sudo systemctl enable chrony

#查看chrony连接的公网服务器
cat /etc/chrony/chrony.conf 
pool ntp.ubuntu.com        iburst maxsources 4
pool 0.ubuntu.pool.ntp.org iburst maxsources 1
pool 1.ubuntu.pool.ntp.org iburst maxsources 1
pool 2.ubuntu.pool.ntp.org iburst maxsources 2

禁用swap

1

sudo swapoff -a

上述命令可以临时禁用掉swap，如果想要永久禁止，需要编辑 /etc/fstab 文件,将swap那一行注释掉，如果没有则不管

禁用SELinux
如果安装了则需要禁止掉，如果没有安装则可以跳过此步骤

1
2
3

sudo setenforce 0           #临时关闭
sudo vi /etc/selinux/config #永久关闭
SELINUX=permissive 

修改内核

1
2
3
4
5
6

sudo  cat > /etc/sysctl.d/k8s.conf << EOF
net.bridge.bridge-nf-call-ip6tables = 1
net.bridge.bridge-nf-call-iptables = 1
net.ipv4.ip_forward = 1                     #开启ipv4转发，允许内置路由
EOF
sudo sysctl --system

修改时区

1
2

sudo ln -snf /usr/share/zoneinfo/Asia/Shanghai /etc/localtime
sudo bash -c "echo 'Asia/Shanghai' > /etc/timezone"

安装Docker
Step 1: 安装必要的一些系统工具

1
2

sudo apt-get update
sudo apt-get -y install apt-transport-https ca-certificates curl software-properties-common

Step 2: 安装GPG证书

1

sudo curl -fsSL https://mirrors.aliyun.com/docker-ce/linux/ubuntu/gpg | sudo apt-key add -

Step 3: 写入软件源信息

1

sudo add-apt-repository "deb [arch=amd64] https://mirrors.aliyun.com/docker-ce/linux/ubuntu $(lsb_release -cs) stable"

Step 4: 查找Docker-CE的版本

1

sudo apt-cache madison docker-ce

Step 5: 安装指定版本的Docker-CE,docker-ce=VERSION

1

sudo apt-get -y install docker-ce

Setp 6: 安装完成后Docker默认就已经启动和加入开机自启了，这点我们不需要再做了，不过可以检查一下

1
2

sudo systemctl status docker
sudo systemctl is-enabled docker

Setp 7: 配置Docker镜像加速以及指定cgroup驱动为systemd

1
2
3
4
5
6
7
8
9

sudo mkdir -p /etc/docker
sudo tee /etc/docker/daemon.json <<-'EOF'
{
  "exec-opts": ["native.cgroupdriver=systemd"],
  "registry-mirrors": ["https://81z69sad.mirror.aliyuncs.com"]
}
EOF
sudo systemctl daemon-reload
sudo systemctl restart docker

Setp 8: 配置完成后使用 docker info 可以看到修改的配置信息

配置主机名

1
2
3
4

cat >> /etc/hosts << EOF
172.26.147.37  master01
172.26.147.36  node01
EOF

安装Kubeadm Kubelet Kubectl
Step 1: 安装必要的程序包

1

apt-get update && apt-get install -y apt-transport-https

Step 2: 导入Kubernetes官方包签名密钥

1

sudo curl https://mirrors.aliyun.com/kubernetes/apt/doc/apt-key.gpg | apt-key add - 

Step 3: 添加Kubernetes仓库

1
2
3

cat > /etc/apt/sources.list.d/kubernetes.list << EOF
deb https://mirrors.aliyun.com/kubernetes/apt/ kubernetes-xenial main
EOF 

Step 4: 更新仓库

1

apt-get update

Step 5: 查找kubeadm kubelet kubectl版本

1
2
3

apt-cache madison kubeadm | grep 1.18
apt-cache madison kubelet | grep 1.18
apt-cache madison kubectl | grep 1.18

目前1.18发布了1.18.0-00 1.18.1-00 1.18.2-00 三个版本

Step 6: 指定版本安装kubelet kubeadm kubectl(如果安装最新版本则无需带版本号)

1

apt-get install kubeadm kubelet kubectl -y

Master节点部署

根据需要修改的参数更换以下内容

1
2
3
4
5
6
7
8
9

kubeadm init \
--image-repository registry.aliyuncs.com/google_containers \
--kubernetes-version v1.18.0 \
--control-plane-endpoint master01 \
--pod-network-cidr=10.244.0.0/16 \
--service-cidr=10.96.0.0/12 \
--apiserver-advertise-address=0.0.0.0 \
--ignore-preflight-errors=Swap \
--token-ttl 30m

参数说明

• image-repository：初始化过程中会去docker仓库拉去镜像，默认指定的为docker hub(国内访问网速不堪)，所以在此使用–image-repository参数指定阿里云镜像。
• kubernetes-version：指定正在使用的 Kubernetes 程序组件的版本号，需要与 kubelet kubeadm kubectl 的版本号一致。
• control-plane-endpoint: 指定控制平面的固定访问端点，可以是IP地址或DNS名称，会被用于集群管理员及集群组件的kubeconfig配置文件API Server的访问地址；单控制平面部署时可以不使用该选项(如果是单个Master部署则不需要使用该选项，因为等会我们要再加入其它两个Master节点到控制平面，所以这里加上此参数)。
• pod-network-cidr：Pod 网络的地址范围，其值为 CIDR 格式的网络地址，使用 flannel 网络插件时，其默认地址为 10.244.0.0/16。
• service-cidr：Service 的网络地址范围，其值为 CIDR 格式的网络地址，默认地址为 10.96.0.0/12。
• apiserver-advertise-address：API Server 通告给其它组件的IP地址，一般为 Master 节点的IP地址，0.0.0.0 标识节点上所有可用的地址。
  ignore-preflight-errors：忽略哪些运行时的错误信息，其值为 Swap 时，表示忽略因 swap 未关闭而导致的错误。
• token-ttl：token令牌自动删除时间，默认为24小时，指定为 0 表示永不过期，指定单位可以使 秒s 分m 时h，在node加入Kubernetes集群时需要指定token。
  初始化过程

  

  01.png

  

  02.png

  

  03.png

  初始化完成

  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

  #您的Kubernetes控制平面初始化成功! Your Kubernetes control-plane has initialized successfully! #要开始使用您的集群，您需要作为一个普通用户运行以下程序: To start using your cluster, you need to run the following as a regular user: mkdir -p $HOME/.kube sudo cp -i /etc/kubernetes/admin.conf $HOME/.kube/config sudo chown $(id -u):$(id -g) $HOME/.kube/config #你需要部署一个网络插件到集群中才能够使Kubernetes网络运转起来 You should now deploy a pod network to the cluster. Run "kubectl apply -f [podnetwork].yaml" with one of the options listed at: https://kubernetes.io/docs/concepts/cluster-administration/addons/ #如果要添加其它控制平面到集群中使用以下命令 You can now join any number of control-plane nodes by copying certificate authorities and service account keys on each node and then running the following as root: kubeadm join k8s-devops.io:6443 --token 8r7sjk.9a31rmcjot9650fe \ --discovery-token-ca-cert-hash sha256: \ --control-plane #如果要添加数据平面节点到集群中使用以下命令 Then you can join any number of worker nodes by running the following on each as root: kubeadm join k8s-devops.io:6443 --token 8r7sjk.9a31rmcjot9650fe \ --discovery-token-ca-cert-hash sha256:

创建用户

1
2
3
4
5

root@master01:~# useradd -m -s /bin/bash k8s  # 创建用户
root@master01:~# passwd k8s  # 设置密码
Enter new UNIX password:
Retype new UNIX password:
passwd: password updated successfully

为普通用户提权

1

root@master01:~# echo 'k8s ALL=(ALL:ALL) NOPASSWD:ALL' >> /etc/sudoers.d/k8s

创建权限

1
2
3
4
5
6

root@master01:~# su k8s  # 切换用户
k8s@master01:/root$    
k8s@master01:/root$ cd /  # 切换目录
k8s@master01:/$ mkdir -p $HOME/.kube                                     #在当前用户家目录下创建.kube目录
k8s@master01:/$ sudo cp -i /etc/kubernetes/admin.conf $HOME/.kube/config  #复制config命令配置文件到当前用户.kube目录下
k8s@master01:/$ sudo chown $(id -u):$(id -g) $HOME/.kube/config           #修改config文件权限

部署网络插件
Step 1: 可以直接在线部署(如果网络下载不了的情况下,也可以先试用浏览器下载后上传到服务器上)

1

k8s@master01:/$ kubectl apply -f https://raw.githubusercontent.com/coreos/flannel/master/Documentation/kube-flannel.yml

Step 2: 如果上述方法还是不行，则可以尝试使用我的

1

kubectl apply -f https://api.0161.org/resources/kube-flannel.yml

Step 3: 上传完后修改文件的属性信息(如上述1,2步骤已完成则直接跳过)

1

k8s@master01:/$ sudo chown -Rf k8s.k8s kube-flannel.yml

Step 4: 然后指定文件部署网络插件(如上述1,2步骤已完成则直接跳过)

1
2
3
4
5
6
7
8
9
10
11

k8s@master01:/$ kubectl apply -f kube-flannel.yml
podsecuritypolicy.policy/psp.flannel.unprivileged created
clusterrole.rbac.authorization.k8s.io/flannel created
clusterrolebinding.rbac.authorization.k8s.io/flannel created
serviceaccount/flannel created
configmap/kube-flannel-cfg created
daemonset.apps/kube-flannel-ds-amd64 created
daemonset.apps/kube-flannel-ds-arm64 created
daemonset.apps/kube-flannel-ds-arm created
daemonset.apps/kube-flannel-ds-ppc64le created
daemonset.apps/kube-flannel-ds-s390x created

Step 5: 查看网络插件是否部署完成(下面有一个叫kube-flannel-ds-amd64的Pod)
如果发现你的 flannel Pod 处于 ImagePullBackOff 状态，那么就是 flannel 镜像未拉取成功，而正常的则为 Running状态

1
2

k8s@master01:/$ kubectl get pods -n kube-system | grep flannel
kube-flannel-ds-amd64-hx9cr        1/1     Running   0          2m3s

Step 6: 查看目前k8s节点信息

1
2
3

k8s@master01:/$ kubectl get nodes
NAME       STATUS   ROLES    AGE   VERSION
master01   Ready    master   65m   v1.18.6

子节点加入到集群

master节点查看join参数

1

kubeadm token create --print-join-command

子节点运行

1

kubeadm join master01:6443 --token 8z8ot9.ylyj39j1po0hgyun     --discovery-token-ca-cert-hash sha256:e0bb3c41**********************************813c84472f65c

04.png

安装Dashboard

官方文档方式启动(不建议)

与端口+ip只能选择一种使用！！！

1

kubectl apply -f https://raw.githubusercontent.com/kubernetes/dashboard/v2.0.3/aio/deploy/recommended.yaml

如遇到无法访问或者网络连接问题可以使用我的备份文件

1

kubectl apply -f https://api.0161.org/resources/recommended.yaml

代理方式启动

1

kubectl proxy

05.png

端口+IP启动(推荐)

环境部署
下载文件

1

wget https://k8s-1252147235.cos.ap-chengdu.myqcloud.com/dashboard/dashboard.yaml

拉取镜像

1

sudo docker pull registry.cn-hangzhou.aliyuncs.com/google_containers/kubernetes-dashboard-amd64:v1.10.1

创建服务

1

sudo kubectl apply -f dashboard.yaml

浏览器输入 https://IP:30001 打开 （可以使用Safari或者火狐，Chrome无法访问）

06.png

绑定用户

1
2

sudo kubectl create serviceaccount dashboard-admin -n kube-system
kubectl create clusterrolebinding dashboard-admin --clusterrole=cluster-admin --serviceaccount=kube-system:dashboard

获取Token

1

kubectl describe secrets -n kube-system $(kubectl -n kube-system get secret | awk '/dashboard-admin/{print $1}')

按Token启动

07.png

赋予用户权限

单命名空间权限文件及绑定
创建 role.yaml

1
2
3
4
5
6
7
8
9
10
11
12

kind: Role
apiVersion: rbac.authorization.k8s.io/v1
metadata:
  namespace: kube-system
  name: role-dashboard-admin
rules:
- apiGroups: [""]
  resources: ["pods","services"]
  verbs: ["get", "watch", "list"]
- apiGroups: ["extensions", "apps"]
  resources: ["deployments"]
  verbs: ["get", "list", "watch", "create", "update", "patch", "delete"]

创建 role-bind.yaml

1
2
3
4
5
6
7
8
9
10
11
12
13

kind: RoleBinding
apiVersion: rbac.authorization.k8s.io/v1
metadata:
  name: role-bind-dashboard-admin
  namespace: kube-system
subjects:
- kind: ServiceAccount
  name: dashboard-admin
  namespace: kube-system
roleRef:
  kind: Role
  name: role-dashboard-admin
  apiGroup: rbac.authorization.k8s.io

集群权限配置及绑定
创建 cluster-role.yaml

1
2
3
4
5
6
7
8

kind: ClusterRole
apiVersion: rbac.authorization.k8s.io/v1
metadata:
 name: cluster-role-dashboard-admin
rules:
- apiGroups: [""]
  resources: ["pods"]
  verbs: ["get", "watch", "list"]

创建 cluster-role-bind.yaml

1
2
3
4
5
6
7
8
9
10
11
12

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

执行命令

1
2
3
4

kubectl create -f role.yaml
kubectl create -f role-bind.yaml
kubectl create -f cluster-role.yaml
kubectl create -f cluster-role-bind.yaml

完成权限配置，可根据自身情况增加配置！

常用k8s命令

• 查看pod列表

  1 2	kubectl get pods --all-namespaces # 查看所有 sudo kubectl get pod -n kube-system # 查看指定命名空间

• 查看service列表

  1	kubectl get service --all-namespaces # 查看所有

• 删除指定命名空间下的service

  1	kubectl delete service serviceName --namespace=namespaceName

• 删除指定命名空间下的pod

  1	kubectl delete pod podName --namespace=namespaceName

• 查看所有deployment

  1	kubectl get deployment -A

• 删除指定deployment

  1	kubectl delete deployment podName

• 查看指定命名空间端口

  1	sudo kubectl get pod,svc -n kube-system

Redis作为内存数据库，数据的安全性一定要得到确切的保障，很多情况下，Redis是作为存储数据库来用的，如果遇到断电，关机等突发情况，则容易丢失关键数据，对此，Redis的持久化就显得尤为关键，甚至某些情况下，需要定时去做备份

RDB

可以在每隔一段时间执行一次备份操作，性能比AOF方式更好，RDB是紧凑型文件，但是最多可以执行到5分钟左右，如果再低可能会影响性能
RDB相当于 备份数据

• 恢复数据快
• 性能更好
• 可以分时间节点备份文件
• 容易丢失数据

AOF

可以按秒级存储数据，由于长期存储，如果发生崩溃事件，它可能只会丢失几秒的数据，相比较来说，可能更安全
AOF相当于 备份执行语句

• 数据安全性更高
• 存储时不占用资源
• 可自定 fsync 策略
• 恢复速度慢

Docker安装

1
2

docker pull redis:latest
docker run -itd --name redis01 -p 6379:6379 redis

1.png

未完！！！

可以使用之前写的Canal阿里巴巴增量订阅更新做简单的主从备份，由于Canal只读取 binary log 日志做增量更新

canal工作流程图.png

通过canal可以做简单的按更新备份也可以通过canal做数据更新，根据更新的内容去更新数据库中其他的字段值
也可以通过canal客户端发送消息给 ElasticSearch 等服务，适合多样化复杂的MySQL主从操作
通过伪造slave的方式请求binary log消息

阿里巴巴也为我们提供了更好的基于Canal的分布式数据库同步系统 otter

otter工作原理.jpg

本文所用Docker目的是一台机器搞定集群功能，实际生产环境中不建议使用Docker

参考项目：

alibaba/otter - 阿里巴巴分布式数据库同步系统(解决中美异地机房)
alibaba/canal - 阿里巴巴 MySQL binlog 增量订阅&消费组件

通过MySQL配置主从备份

主从备份，通过配置MySQL做主从备份

主从备份流程图.jpg

注意事项

• 主从数据库版本保持一致
• 需要单独的两台服务器（单台机器可使用Docker，没有测试过）
• 需要网络相连，保证主从服务器通信
• 表结构不使用外键，使用外键容易造成同步失败
• 主键使用无意义自增字段
• 同步数据库所用的账号拥有一定的权限，也可以使用root

安装MySQL

参照之前的文章 MySQL Docker启动
启动两个不同的 MySQL 映射不同的端口

1
2
3

docker run --restart=always --name mysql5.7-1 -p 3307:3306 -v /Users/XXX/Downloads/Docker/mysql5.7-1:/var/lib/mysql -e MYSQL_ROOT_PASSWORD=123456 -d mysql:5.7 --character-set-server=utf8mb4 --collation-server=utf8mb4_unicode_ci

docker run --restart=always --name mysql5.7 -p 3306:3306 -v /Users/XXX/Downloads/Docker/mysql5.7:/var/lib/mysql -e MYSQL_ROOT_PASSWORD=123456 -d mysql:5.7 --character-set-server=utf8mb4 --collation-server=utf8mb4_unicode_ci

进入容器内部 安装vim 或者映射 使用参数 -v 映射位置 /etc/mysql/my.cnf 配置文件亦可

安装 vim 方式 编辑 my.cnf

1
2

apt-get install
apt-get install vim

挂载 本地文件 内容

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

# Copyright (c) 2016, Oracle and/or its affiliates. All rights reserved.
#
# This program is free software; you can redistribute it and/or modify
# it under the terms of the GNU General Public License, version 2.0,
# as published by the Free Software Foundation.
#
# This program is also distributed with certain software (including
# but not limited to OpenSSL) that is licensed under separate terms,
# as designated in a particular file or component or in included license
# documentation.  The authors of MySQL hereby grant you an additional
# permission to link the program and your derivative works with the
# separately licensed software that they have included with MySQL.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License, version 2.0, for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program; if not, write to the Free Software
# Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301 USA

!includedir /etc/mysql/conf.d/
!includedir /etc/mysql/mysql.conf.d/

配置主从备份

主节点 使用root 用户 配置

修改配置文件 /etc/mysql/my.cnf

1
2
3

[mysqld]
log-bin=mysql-bin
server-id=1

执行命令

input

1
2
3

GRANT REPLICATION SLAVE ON *.* to 'root'@'%' identified by '123456';
FLUSH PRIVILEGES;
SHOW MASTER STATUS;

output

1
2
3
4
5

+------------------+----------+--------------+------------------+-------------------+
| File             | Position | Binlog_Do_DB | Binlog_Ignore_DB | Executed_Gtid_Set |
+------------------+----------+--------------+------------------+-------------------+
| mysql-bin.000001 |      589 |              |                  |                   |
+------------------+----------+--------------+------------------+-------------------+

从节点 使用root 用户 配置
修改配置文件 /etc/mysql/my.cnf

1
2
3

[mysqld]
log-bin=mysql-bin
server-id=2

执行命令

input

1
2
3

change master to master_host='172.17.0.2',master_user='root',master_password='123456',master_log_file='mysql-bin.000001',master_log_pos=589;
start slave;
show slave status\G;

output

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

*************************** 1. row ***************************
               Slave_IO_State: Waiting for master to send event
                  Master_Host: 172.17.0.2
                  Master_User: root
                  Master_Port: 3306
                Connect_Retry: 60
              Master_Log_File: mysql-bin.000001
          Read_Master_Log_Pos: 589
               Relay_Log_File: f919535d2d58-relay-bin.000002
                Relay_Log_Pos: 320
        Relay_Master_Log_File: mysql-bin.000001
             Slave_IO_Running: Yes
            Slave_SQL_Running: Yes
              Replicate_Do_DB:
          Replicate_Ignore_DB:
           Replicate_Do_Table:
       Replicate_Ignore_Table:
      Replicate_Wild_Do_Table:
  Replicate_Wild_Ignore_Table:
                   Last_Errno: 0
                   Last_Error:
                 Skip_Counter: 0
          Exec_Master_Log_Pos: 589
              Relay_Log_Space: 534
              Until_Condition: None
              Until_Log_File:
                Until_Log_Pos: 0
           Master_SSL_Allowed: No
           Master_SSL_CA_File:
           Master_SSL_CA_Path:
              Master_SSL_Cert:
            Master_SSL_Cipher:
               Master_SSL_Key:
        Seconds_Behind_Master: 0
Master_SSL_Verify_Server_Cert: No
                Last_IO_Errno: 0
                Last_IO_Error:
               Last_SQL_Errno: 0
               Last_SQL_Error:
  Replicate_Ignore_Server_Ids:
             Master_Server_Id: 1
                  Master_UUID: 380e925e-a645-11ea-a304-0242ac110004
             Master_Info_File: /var/lib/mysql/master.info
                    SQL_Delay: 0
          SQL_Remaining_Delay: NULL
      Slave_SQL_Running_State: Slave has read all relay log; waiting for more updates
           Master_Retry_Count: 86400
                  Master_Bind:
      Last_IO_Error_Timestamp:
     Last_SQL_Error_Timestamp:
               Master_SSL_Crl:
               Master_SSL_Crlpath:
           Retrieved_Gtid_Set:
            Executed_Gtid_Set:
                Auto_Position: 0
         Replicate_Rewrite_DB:
                 Channel_Name:
           Master_TLS_Version:
1 row in set (0.00 sec)

测试 创建一个 test数据库

主从数据库同步.png

监控状态

可以使用crontab 配合钉钉通知 使用 curl命令通知 主从同步是否成功

1
2
3
4
5
6
7
8

# !/bin/bash
array=($(mysql -uroot -p -e "show slave status\G" | grep "Running" | awk '{print $2}'))
if [ "${array[0]}" == "Yes" ] || [ "${array[1]}" == "Yes" ]
    then
        echo "Slave is OK"
    else
        echo "Slave is error"
fi

读写分离

master数据库处理写操作，slave数据库处理读操作。利用上面配置的主从数据库，使master数据库的变更实时更新到slave节点上，支持事务，但可能会因为某些原因有阻塞现象发生，不可避免的可能会出现数据同步慢的情况

读写分离.png

使用 MySQLProxy 做读写分离

MySQLProxy实际上是在客户端请求与MySQLServer之间建立了一个连接池。所有客户端请求都是发向MySQLProxy，然后经由MySQLProxy进行相应的分析，判断出是读操作还是写操作，分发至对应的MySQLServer上。对于多节点Slave集群，也可以起做到负载均衡的效果。

MySQLProxy.png

为何要使用MySQLProxy？其实可以不使用，但为了减少代码量，减少开发成本，可以通过运维的手段去做分发处理。
常见的开发框架实际上很多是支持读写分离操作不同数据库的，而代理服务器做的则是将这些框架封装好的东西通过代理分发的方式，分别给不同的数据库发送请求，主库只修改，从库只读

缺点

• 目前MySQLProxy仍然是 alpha（内测） 版
• 通过lua脚本做的读写分离，MySQL官方并不建议使用

配置MySQLProxy读写分离

假定 上述两台服务器 分别为 master slave 那么我们现在需要第三台服务器 proxy
proxy需要做中转代理，将接收到的数据库请求分别指向 master 和 slave

下载 MySQLProxy
下载地址：MySQL Product Archives

由于我的环境为MAC新版，对 MySQLProxy 的支持度并不好，因此并不在本机使用可以参照下面引用的文章参考配置

参考文章

• Mysql 主从备份完整版
• MySQL主从备份配置
• MySQL读写分离介绍及搭建
• MySQL Proxy

介绍

基于Lucene的搜索服务器，它提供了一个分布式多用户能力的全文搜索引擎，基于RESTful web接口。
更适用于集群部署，适合各类 分词，全文搜索，通过建立索引（分片，按节点分片）来实现更快的搜索
Elasticsearch是与Logstash的数据收集和日志解析引擎以及Kibana的分析和可视化平台一起开发的。这三个产品被设计成一个集成解决方案，称为“Elastic Stack”（以前称为“ELK stack”）。
本文只做单节点运行

ELK.png

官方介绍

Elasticsearch 是一个分布式、RESTful 风格的搜索和数据分析引擎，能够解决不断涌现出的各种用例。 作为 Elastic Stack 的核心，它集中存储您的数据，帮助您发现意料之中以及意料之外的情况。

注意事项

• 单点服务器维持稳定可能需要常驻内存 4G 以上
• 单点ELK维持稳定可能需要CPU 4核心 以上

参考文章

• Docker安装部署ELK教程 (Elasticsearch+Kibana+Logstash+Filebeat)
• 零门槛！基于Docker快速部署ES集群

下载集群所需镜像 zookeeper kafka

1
2

docker pull zookeeper
docker pull wurstmeister/kafka

单节点无内网IP使用

1

docker network create elkwork

创建内部网络后在每次 docker run 的时候 增加参数 --net elkwork

elastic相关

• 旧版本

  1 2 3

  docker pull docker.elastic.co/elasticsearch/elasticsearch:5.6.8 docker pull docker.elastic.co/kibana/kibana:5.6.8 docker pull docker.elastic.co/logstash/logstash:5.6.8

• 新版本

  1 2 3 4

  docker pull docker.elastic.co/elasticsearch/elasticsearch:7.7.0 docker pull docker.elastic.co/kibana/kibana:7.7.0 docker pull docker.elastic.co/logstash/logstash:7.7.0 docker pull store/elastic/filebeat:7.7.0

启动elasticsearch 自行替换版本

"discovery.type=single-node" 单节点

1

docker run -d --name elasticsearch -p 9200:9200 -p 9300:9300 -e "discovery.type=single-node" docker.elastic.co/elasticsearch/elasticsearch:5.6.8

默认用户名默认密码
elasticchangeme

测试是否已经连通-u elastic:changeme 验权

1

curl -u elastic:changeme localhost:9200

浏览器端口访问测试

elasticsearch.png

elasticsearch 各类语法

基本

浏览器访问
http://xxx.xx.xxx.xx:9200/_cat/indices?v 查看当前节点的所有 Index
http://xxx.xx.xxx.xx:9200/_mapping?pretty=true 列出每个 Index 所包含的 Type

验权机制增加参数 -u elastic:changeme 验权

命令行访问
curl -u elastic:changeme -X PUT 'localhost:9200/weather' 可以直接向 Elastic 服务器发出 PUT 请求
curl -u elastic:changeme -X DELETE 'localhost:9200/weather' 发出 DELETE 请求，删除这个 Index

插入数据

1
2
3
4
5
6

curl -X POST 'localhost:9200/account/person' -d '
{
  "user": "李四",
  "title": "工程师",
  "desc": "系统管理"
}'

读取数据

1

curl 'localhost:9200/account/person/1?pretty=true'

示例

1
2
3
4
5
6
7
8
9
10
11
12

{
  "_index" : "accounts",
  "_type" : "person",
  "_id" : "1",
  "_version" : 1,
  "found" : true,
  "_source" : {
    "user" : "张三",
    "title" : "工程师",
    "desc" : "数据库管理"
  }
}

删除记录

1

curl -X DELETE 'localhost:9200/accounts/person/1'

更新记录

1
2
3
4
5
6

curl -X PUT 'localhost:9200/accounts/person/1' -d '
{
    "user" : "张三",
    "title" : "工程师",
    "desc" : "数据库管理，软件开发"
}' 

返回所有记录

1

curl 'localhost:9200/accounts/person/_search'

• 索引 ：/Index/Type/_search
• total：返回记录数，本例是2条。
• max_score：最高的匹配程度，本例是1.0。
• hits：返回的记录组成的数组。

查询记录

1
2
3
4
5
6

curl 'localhost:9200/accounts/person/_search'  -d '
{
  "query" : { "match" : { "desc" : "软件 系统" }},
  "from": 1
  "size": 1
}'

• size 返回数量
• from 开始位置
• OR搜索，当前搜索的示例是 软件或系统
• AND搜索示例

  1 2 3 4 5 6 7 8 9 10

  { "query": { "bool": { "must": [ { "match": { "desc": "软件" } }, { "match": { "desc": "系统" } } ] } } }

参考文章

• 全文搜索引擎 Elasticsearch 入门教程

启动kibana 自行替换版本

1

docker run -d --name kibana -p 8001:5601 docker.elastic.co/kibana/kibana:5.6.8

kibana 容器内部修改配置ip

1

Vi ./config/kibana.yml

重启容器使配置生效

kibana.png

配置 logstash

1
2
3

mkdir /home/tjy/docker/logstash/
mkdir /home/tjy/docker/logstash/conf.d/
vi /home/tjy/docker/logstash/logstash.yml

1
2

path.config: /usr/share/logstash/conf.d/*.conf
path.logs: /var/log/logstash

1

vi /home/tjy/docker/logstash/conf.d/test.conf

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

input {
    beats {
    port => 5044
    codec => "json"
}
}

output {
  elasticsearch { 
hosts => ["xxx.xx.xxx.xx:9200"]
user => elastic 
    password => changeme 
}
  stdout { codec => rubydebug }
}

启动logstash并挂载

1

docker run -it -d -p 8011:5044 -p 9600:9600 --name logstash -v /home/tjy/docker/logstash/logstash.yml:/usr/share/logstash/config/logstash.yml -v /home/tjy/docker/logstash/conf.d/:/usr/share/logstash/conf.d/ docker.elastic.co/logstash/logstash:5.6.8

配置 filebeat

下载 通用配置文件

1
2
3
4

mkdir /Users/XXX/Downloads/Docker/filebeat/
cd /Users/XXX/Downloads/Docker/filebeat
wget https://raw.githubusercontent.com/elastic/beats/7.1/deploy/docker/filebeat.docker.yml
vi filebeat.docker.yml

配置监听 Nginx log

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

filebeat.config:
  modules:
    path: ${path.config}/modules.d/*.yml
    reload.enabled: false

filebeat.autodiscover:
  providers:
    - type: docker
      hints.enabled: true

processors:
- add_cloud_metadata: ~

filebeat.inputs:
- type: log
  enabled: true
  paths:
  - /var/log/nginx/*.log

output.logstash:
  hosts: ['logstash:5044']

filebeat 配合 logstash 挂载并启动

以下映射的路径为我自己电脑的路径，需要自行修改！

1

docker run --name filebeat --user=root -d --net elkwork -v /usr/local/var/log/nginx/:/var/log/nginx/ -v /Users/XXX/Downloads/Docker/filebeat/filebeat.docker.yml:/usr/share/filebeat/filebeat.yml -v /var/run/docker.sock:/var/run/docker.sock store/elastic/filebeat:7.7.0

success.png

1
2
3
4
5

file_uploads = On
memory_limit = 64 M
upload_max_filesize = 20M
post_max_size = 20M
max_execution_time = 600

创建 Dockerfile

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

FROM php:7.3-fpm

RUN apt-get update
RUN apt-get install -y libwebp-dev libjpeg-dev libpng-dev libfreetype6-dev

EXPOSE 9000

#上传配置成20M
COPY uploads.ini /usr/local/etc/php/conf.d

RUN docker-php-ext-install mysqli
RUN docker-php-ext-install pdo
RUN docker-php-ext-install pdo_mysql
RUN pecl install redis-4.2.0 && docker-php-ext-enable redis
RUN docker-php-ext-install bcmath
RUN docker-php-ext-configure gd  --with-webp-dir=/usr/include/webp --with-png-dir=/usr/include --with-jpeg-dir=/usr/include --with-freetype-dir=/usr/include/freetype2
RUN docker-php-ext-install gd

Docker build

1

docker build -t ai0by/php-fpm73:v1 .

运行容器

挂载物理机内容到 容器内部 可以修改下方的 /var/www/html/workspace 为你的项目地址

1

docker run -v /var/www/html/workspace:/var/www/html/workspace  -p 9002:9000 -d php73:0.1

Nginx配置

修改 fastcgi_pass 后面的 值为 127.0.0.1:9002

LNMP用户 修改 /usr/local/nginx/conf/enable-php-pathinfo.conf

将 fastcgi_pass unix:/tmp/php-cgi.sock; 修改为 fastcgi_pass 127.0.0.1:9002;

其他环境与此类似，直接改即可

MySQL Docker启动

自行修改 挂载路径 以及 密码

1

docker run --restart=always --name mysql5.7 -p 3306:3306 -v /Users/XXX/Downloads/Docker/mysql5.7:/var/lib/mysql -e MYSQL_ROOT_PASSWORD=123456 -d mysql:5.7 --character-set-server=utf8mb4 --collation-server=utf8mb4_unicode_ci

Nginx 个人不习惯扔Docker中，因此暂时不管