倒霉狐狸的博客

Prometheus常用监控指标及说明

Thu, 06 Jul 2023 11:01:42 +0800

倒霉狐狸的博客 /posts/2023/0706-prometheus/ -

node_exporter 主机监控指标

node_memory_MemTotal_bytes # 内存总量
node_memory_MemFree_bytes # 空闲内存

# CUP 使用率
(1 - sum(increase(node_cpu_seconds_total{mode="idle"}[10s])) by (instance) / sum(increase(node_cpu_seconds_total[10s])) by (instance) ) * 100

node_filesystem_size_bytes # 磁盘总量
node_filesystem_free_bytes # 磁盘空闲
sum by (instance) (rate(node_disk_writes_completed_total[10s])) # 写入速率

node_network_receive_bytes_total # 网络接收
node_network_transmit_bytes_total # 网络发送
sum by (instance)(irate (node_network_receive_bytes_total[10s])) # 接收速率
sum by (instance)(irate (node_network_transmit_bytes_total[10s])) # 发送速率

golang应用监控指标

go_gc_duration_seconds  # 持续时间秒
go_gc_duration_seconds_sum  # gc-持续时间-秒数-总和
go_memstats_alloc_bytes  # Go内存统计分配字节
go_memstats_alloc_bytes_total  # Go内存统计分配字节总数
go_memstats_buck_hash_sys_bytes  # 用于剖析桶散列表的堆空间字节
go_memstats_frees_total  # 内存释放统计
go_memstats_gc_cpu_fraction  # 垃圾回收占用服务CPU工作的时间总和
go_memstats_gc_sys_bytes  # 圾回收标记元信息使用的内存字节
go_memstats_heap_alloc_bytes  # 服务分配的堆内存字节数
go_memstats_heap_idle_bytes  # 申请但是未分配的堆内存或者回收了的堆内存（空闲）字节数
go_memstats_heap_inuse_bytes  # 正在使用的堆内存字节数
go_memstats_heap_objects  # 堆内存块申请的量
go_memstats_heap_released_bytes  # 返回给OS的堆内存
go_memstats_heap_sys_bytes  # 系统分配的作为运行栈的内存
go_memstats_last_gc_time_seconds  # 垃圾回收器最后一次执行时间
go_memstats_lookups_total  # 被runtime监视的指针数
go_memstats_mallocs_total  # 服务malloc的次数
go_memstats_mcache_inuse_bytes  # mcache结构体申请的字节数(不会被视为垃圾回收)
go_memstats_mcache_sys_bytes  # 操作系统申请的堆空间用于mcache的字节数
go_memstats_mspan_inuse_bytes  # 用于测试用的结构体使用的字节数
go_memstats_mspan_sys_bytes  # 系统为测试用的结构体分配的字节数
go_memstats_next_gc_bytes  # 垃圾回收器检视的内存大小
go_memstats_other_sys_bytes  # golang系统架构占用的额外空间
go_memstats_stack_inuse_bytes  # 正在使用的栈字节数
go_memstats_stack_sys_bytes  # 系统分配的作为运行栈的内存
go_memstats_sys_bytes  # 服务现在系统使用的内存
go_threads  # 线程

- /posts/2023/0706-prometheus/ - 2015 纸喵软件

netsh interface portproxy

Wed, 15 Mar 2023 17:11:42 +0800

倒霉狐狸的博客 /posts/2023/0315-win-proxy/ -

创建映射

netsh interface portproxy 命令作为 IPv4 和 IPv6 网络与应用程序之间的代理。

可以通过以下方式使用这些命令建立代理服务：

发送到 IPv4 配置的其他计算机和应用程序的 IPv4 配置的计算机和应用程序消息。

发送到 IPv6 配置的计算机和应用程序的 IPv4 配置的计算机和应用程序消息。

发送到 IPv4 配置的计算机和应用程序的 IPv6 配置的计算机和应用程序消息。

发送到 IPv6 配置的其他计算机和应用程序的 IPv6 配置的计算机和应用程序消息。

netsh interface portproxy add v4tov4  listenaddress=0.0.0.0 listenport=3306  connectaddress=192.168.2.4 connectport=3306

参数说明：

v4tov4 Portproxy服务器侦听发送到特定端口和 IPv4 地址的消息，并映射端口和 IPv4 地址以发送在建立单独的 TCP 连接后收到的消息。

listenaddress 指定要侦听的 IPv4 地址。可接受的值为 IP 地址、计算机 NetBIOS 名称或计算机 DNS 名称。如果未指定地址，则默认值为本地计算机。

listenport 按端口号或服务名称指定要对其进行侦听的 IPv4 端口。

connectaddress 指定要连接的 IPv4 地址。可接受的值为 IP 地址、计算机 NetBIOS 名称或计算机 DNS 名称。如果未指定地址，则默认值为本地计算机。

connectport 按端口号或服务名称指定要连接的 IPv4 端口。如果未指定 connectport，则默认值为本地计算机上 listenport 的值。

查看所有映射

netsh interface portproxy show all

删除映射

netsh interface portproxy delete v4tov4 listenaddress=0.0.0.0 listenport=3306

- /posts/2023/0315-win-proxy/ - 2015 纸喵软件

linux五级时间轮高仿(golang版)

Wed, 22 Feb 2023 14:10:04 +0800

倒霉狐狸的博客 /posts/2023/0222-linux-timing-wheel/ -

package main

import (
	"log"
	"sync"
	"time"
)

func main() {
	// wait := sync.WaitGroup{}
	id := 0
	wh := NewTimingWheeler(func(data any) {
		if clock, ok := data.(time.Time); ok {
			id++
			log.Println(clock.Format(time.DateTime), id)
		}
	})
	for i := 0; i < 50000000; i++ {
		clock := time.Now().Add(time.Second * time.Duration(i))
		wh.Add(clock, clock)
	}
	select {}
}

type TimingWheeler interface {
	Add(t time.Time, data any)
	Close()
}

type timingWheelData struct {
	clock time.Time
	data  any
}

type timingWheelImpl struct {
	tickDuration time.Duration
	done         chan struct{}
	index        uint32
	tv1          [256][]*timingWheelData // 0000 0000 0000 0000 0000 0000 1111 1111
	tv2          [64][]*timingWheelData  // 0000 0000 0000 0000 0011 1111 0000 0000
	tv3          [64][]*timingWheelData  // 0000 0000 0000 1111 1100 0000 0000 0000
	tv4          [64][]*timingWheelData  // 0000 0011 1111 0000 0000 0000 0000 0000
	tv5          [64][]*timingWheelData  // 1111 1100 0000 0000 0000 0000 0000 0000
	sync.RWMutex
	callback func(data any)
}

func (tw *timingWheelImpl) Close() {
	close(tw.done)
}

func (tw *timingWheelImpl) Add(t time.Time, data any) {
	tw.add(&timingWheelData{
		clock: t,
		data:  data,
	})
}

func (tw *timingWheelImpl) add(item *timingWheelData) {
	diff := time.Until(item.clock).Seconds()
	if diff < 2 {
		go tw.callback(item.data)
		return
	}
	after := uint32(diff)
	// 一轮
	after += tw.index & 0xFF
	if after < (1 << 8) {
		if tw.tv1[after] == nil {
			tw.tv1[after] = make([]*timingWheelData, 0)
		}
		tw.tv1[after] = append(tw.tv1[after], item)
		return
	}
	// 二轮
	after += tw.index & (0x3F << 8)
	if after < (1 << 14) {
		lv := (after >> 8) & 0x3F
		if tw.tv2[lv] == nil {
			tw.tv2[lv] = make([]*timingWheelData, 0)
		}
		tw.tv2[lv] = append(tw.tv2[lv], item)
		return
	}
	// 三轮
	after += tw.index & (0x3F << 14)
	if after < (1 << 20) {
		lv := (after >> 14) & 0x3F
		if tw.tv3[lv] == nil {
			tw.tv3[lv] = make([]*timingWheelData, 0)
		}
		tw.tv3[lv] = append(tw.tv3[lv], item)
		return
	}
	// 四轮
	after += tw.index & (0x3F << 20)
	if after < (1 << 26) {
		lv := (after >> 20) & 0x3F
		if tw.tv4[lv] == nil {
			tw.tv4[lv] = make([]*timingWheelData, 0)
		}
		tw.tv4[lv] = append(tw.tv4[lv], item)
		return
	}
	// 五轮
	after += tw.index & (0x3F << 26)
	lv := after >> 26
	if tw.tv5[lv] == nil {
		tw.tv5[lv] = make([]*timingWheelData, 0)
	}
	tw.tv5[lv] = append(tw.tv5[lv], item)
}

func (tw *timingWheelImpl) tick() {
	tw.index++
	// 一轮跳帧
	idx := tw.index & 0xFF
	expireData := tw.tv1[idx]
	tw.tv1[idx] = nil
	for _, v := range expireData {
		go tw.callback(v.data)
	}
	// 二轮跳帧
	if idx != 0 {
		return
	}
	idx = (tw.index >> 8) & 0x3F
	expireData = tw.tv2[idx]
	tw.tv2[idx] = nil
	for _, v := range expireData {
		tw.add(v)
	}
	// 三轮跳帧
	if idx != 0 {
		return
	}
	idx = (tw.index >> 14) & 0x3F
	expireData = tw.tv3[idx]
	tw.tv3[idx] = nil
	for _, v := range expireData {
		tw.add(v)
	}
	// 四轮跳帧
	if idx != 0 {
		return
	}
	idx = (tw.index >> 20) & 0x3F
	expireData = tw.tv4[idx]
	tw.tv4[idx] = nil
	for _, v := range expireData {
		tw.add(v)
	}
	// 五轮跳帧
	if idx != 0 {
		return
	}
	idx = tw.index >> 26
	expireData = tw.tv5[idx]
	tw.tv5[idx] = nil
	for _, v := range expireData {
		tw.add(v)
	}
}

func NewTimingWheeler(callback func(data any)) TimingWheeler {
	impl := &timingWheelImpl{
		done:     make(chan struct{}),
		callback: callback,
	}
	go func() {
		ticker := time.NewTicker(time.Second)
		defer ticker.Stop()
		for {
			select {
			case <-ticker.C:
				impl.tick()
			case <-impl.done:
				return
			}
		}
	}()
	return impl
}

- /posts/2023/0222-linux-timing-wheel/ - 2015 纸喵软件

GTR5 5900HX / GTR4 4900 / SER 3200U / SER 3750H/SER 5600上电开机教程

Wed, 08 Feb 2023 11:18:58 +0800

倒霉狐狸的博客 /posts/2023/0208-ser5-auto-power-on/ -

1. 开机并在开机logo界面重复按“Delete”键进入BIOS页面。

2. 进入“Advanced”界面，选择“AMD CBS”

3. 在“AMD CBS”列表中进入“FCH Common Options”

4. 在“AMD CBS”中选择“Ac Power Loss Options”。

5. 选择“Always On”选项。

6.按 F4 保存，等待电脑自动进入系统。可以将电源拔下再重新插上测试是否设置成功。

- /posts/2023/0208-ser5-auto-power-on/ - 2015 纸喵软件

快速判断一个时间是否在当天的一些时间片段内

Mon, 30 Jan 2023 17:41:40 +0800

倒霉狐狸的博客 /posts/2023/0130-time-segment/ -

前言

在一些场景中，我们需要判断一个时间是否在当天的某些时间片段内，例如用电峰谷，有些场景下，当天的时间片段可能会很多，用循环的方式去判断固然也能达到目的，但是当判断的时间流水过多的时候，这可能并不是一个好的方法

将一天的时间拆成1440分钟，每小时60分钟，分别用二进制标识，这样就可以形成一个60*24的矩阵，从而快速判断一个时间是否在这个矩阵内

示例代码：

package main

import (
	"fmt"
	"time"
)

type Segment struct {
	BeginTime string
	EndTime   string
}
type TimeSegments [24]uint64

func (s *TimeSegments) In(t time.Time) bool {
	return s[t.Hour()]&(1<<t.Minute()) > 0
}

func SegmentData(timeSegment []Segment) *TimeSegments {
	var data TimeSegments
	for _, v := range timeSegment {
		startMinute, endMinute := SegmentTime2Minute(v.BeginTime), SegmentTime2Minute(v.EndTime)
		if startMinute > endMinute {
			endMinute = 1440
		}
		for i := startMinute; i < endMinute; i++ {
			data[i/60] |= 1 << (i % 60)
		}
	}
	return &data
}

func SegmentTime2Minute(stringTime string) int {
	t, _ := time.Parse("15:04", stringTime)
	return t.Hour()*60 + t.Minute()
}

func main() {
	data := SegmentData([]Segment{{
		BeginTime: "02:08",
		EndTime:   "03:13",
	}, {
		BeginTime: "14:13",
		EndTime:   "18:00",
	}})
	for i := range data {
		fmt.Printf("Data[%d]:%b\n", i, data[i])
	}
	now := time.Now()
	for i := now; i.Before(now.AddDate(0, 0, 2)); i = i.Add(time.Minute) {
		fmt.Printf("[%s]: %t \n", i, data.In(i))
	}
}

- /posts/2023/0130-time-segment/ - 2015 纸喵软件

MODBUS协议报文详解

Tue, 03 Jan 2023 14:59:51 +0800

倒霉狐狸的博客 /posts/2023/0103-modbus-protocol/ -

基础信息

报文长度

串行链路上第一个 MODBUS 执行的长度约束限制了 MODBUS PDU 大小（最大 RS485ADU=256字节）。

因此，对串行链路通信来说，MODBUS PDU=256-服务器地址(1 字节)-CRC(2 字节)＝253字节。

从而：

RS232 / RS485 ADU = 253 字节+服务器地址(1 byte) + CRC (2 字节) = 256 字节。

TCP MODBUS ADU = 249 字节+ MBAP (7 字节) = 256 字节。

操作对象

操作对象	描述
线圈	相当于开关，在MODBUS中可读可写，数据只有00和01
离散量	输入位，开关量，在MODBUS中只读
输入寄存器	只能从模拟量输入端改变的寄存器，在MODBUS中只读
保持寄存器	用于输出模拟量信号的寄存器，在MODBUS中可读可写

功能码

注: 异常码为功能码+0x80

功能码	异常码	描述
0x01	0x81	读线圈
0x05	0x05	写单个线圈
0x0F	0x0F	写多个线圈
0x02	0x02	读离散量输入
0x04	0x04	读输入寄存器
0x03	0x03	读保持寄存器
0x06	0x06	写单个保持寄存器
0x10	0x10	写多个保持寄存器

MODBUS TCP

报文结构

MBAP报文头

域	长度(字节)	示例	描述
事务元标识符	2	0x00 0x00	MODBUS 请求/响应事务处理的识别码，可以解释为报文的序列号，由于我们测试使用的Modbus Poll客户端是一直发送数据，所以每发送一次数据标识符就加一。服务器接收时会把这个数据原封返回。
协议标识符	2	0x00 0x00	0=MODBUS 协议
长度	2	0x00 0x00	表示从单元标识符开始后面数据的长度。如：00 06表示后面有0x06个字节长度的数据。
单元标识符	1	0x01	串行链路或其它总线上连接的远程从站的识别码，相当于设备的地址。一般为01。

PDU (帧结构)

域	长度(字节)	示例	描述
功能码	1	0x01	modbus的功能码列
数据	0~248	0x00	受限于ADU256字节上限

示例报文解读

读取01-03号线圈值

发送响应

抓包确认

报文解析

TX(发送): 08 80 00 00 00 06 01 01 00 01 00 03

报文	描述
08 80	事务标识符
00 00	Modbus TCP协议标识
00 06	剩余报文长度
01	单元标识符
01	功能码(读线圈)
00 01 00 03	指令数据，此处代表从1开始读3个

RX(响应): 08 80 00 00 00 04 01 01 01 05

报文	描述
08 80	事务标识符
00 00	Modbus TCP协议标识
00 04	剩余报文长度
01	单元标识符
01	功能码(读线圈)
01 05	此处01代表有效数据长度1字节，05=0101，反向得出1,3线圈true

MODBUS RTU

报文结构

地址域	功能码	数据	CRC校验
1字节	1字节	0-252字节	2字节

地址域

Modbus 寻址空间有 256 个不同地址。

0	1~247	248~255
广播地址	子节点单独地址	保留地址

地址 0 保留为广播地址。所有的子节点必须识别广播地址。

Modbus 主节点没有地址，只有子节点必须有一个地址。该地址必须在 Modbus 串行总线上唯一。

PDU (帧结构)

域	长度(字节)	示例	描述
功能码	1	0x01	modbus的功能码列
数据	0~248	0x00	受限于ADU256字节上限

CRC校验

校验码：Modbus通讯采用CRC-16循环冗余错误校验，冗余循环码CRC包含2个字节,即16位二进制。

CRC计算方法是：

1、加载一值为0xFFFF的16位寄存器，此寄存器为CRC寄存器。

2、把第一个8位二进制数据（即通讯信息帧的第一个字节）与16位的CRC寄存器的相异或，异或的结果仍存放于该CRC寄存器中。

3、把CRC寄存器的内容右移一位，用0填补最高位，并检测移出位是0还是1。

4、如果移出位为零，则重复第三步（再次右移一位）；如果移出位为1，CRC寄存器与0xA001进行异或。

5、重复步骤3和4，直到右移8次，这样整个8位数据全部进行了处理。

6、重复步骤2和5，进行通讯信息帧下一个字节的处理。

7、将该通讯信息帧所有字节按上述步骤计算完成后，得到的16位CRC寄存器的高、低字节进行交换

8、最后得到的CRC寄存器内容即为：CRC校验码。

示例报文解读

读取01-03号线圈值

发送响应

报文解析

TX(发送): 01 01 00 01 00 03 2d cb

报文	描述
01	地址域，此处代表发送到1号从机
01	功能码(读线圈)
00 01 00 03	指令数据，此处代表从1开始读3个
2d cb	CRC校验

在线校验截图，高低位反转得到2d cb

RX(响应): 01 01 01 05 91 8b

报文	描述
01	地址域，此处代表1号从机响应
01	功能码(读线圈)
01 05	此处01代表有效数据长度1字节，05=0101，反向得出1,3线圈true
91 8b	CRC校验

MODBUS ASCII

起始符	地址域	功能码	数据	LRC校验	结束符
1字节	2字节	2字节	0-2*252字节	2字节	2字节

报文结构

在 ASCII 模式，报文用特殊的字符区分帧起始和帧结束。一个报文必须以一个冒号(: ASCII 十六进制 3A )起始，以回车-换行 (CR LF ASCII 十六进制 0D 和 0A) 结束。

注 : LF 字符可以通过特定的 Modbus 应用命令 (参见 Modbus 应用协议规范) 改变。

对于所有的域，允许传送的字符为十六进制 0–9, A–F (ASCII 编码)。 设备连续的监视总线上的起始符。当收到:这个字符后，每个设备解码后续的字符一直到帧结束。

报文中字符间的时间间隔可以达一秒。如果有更大的间隔，则接受设备认为发生了错误。

起始符&结束符

报文位	十六进制	备注
起始符	0x3A	:
结束符	0x0D 0x0A	\r\n

LRC校验

纵向冗余校验(LRC)为一个字节，含有 8 位二进制值。LRC 由发送设备计算，并附加 LRC 到报文。接收设备在接收文时计算 LRC, 并将计算的结果与在 LRC 接收到的实际值相比较，如果两个值不相等，则结果为错。

LRC 的计算, 对报文中的所有的连续 8 位字节相加，忽略任何进位，然后求出其二进制补码。 LRC 为一个 8 位域，那么每个会导致值大于 255 新的相加只是简单的将域的值在零”回绕”。因为没有第 9 位，进位被自动放弃。

生成一个 LRC 的过程为:

1.不包括起始”冒号”和结束 CRLF 的报文中的所有字节相加到一个 8 位域，故此进位被丢弃。

2.从 FF (全 1)十六进制中减去域的最终值，产生 1 的补码(二进制反码)。

3.加 1 产生二进制补码.

其他

原始数据同RTU模式数据，进行bin2hex操作，0xAA => 0x61 0x61 (aa), 因此在ASCII模式下，地址域、功能码、数据长度翻倍

示例报文解读

暂无相关设备模拟

- /posts/2023/0103-modbus-protocol/ - 2015 纸喵软件

是时候告别传统便签了，一款亲民的桌面电子便签工具《便签喵》，解放生产力，提高工作效率

Tue, 27 Dec 2022 16:22:06 +0800

倒霉狐狸的博客 /posts/2022/1227-bqm-01/ -

便签是一个非常实用的发明，方便快捷又能够很好的提醒我们一些需要记住的事情，我也买过各种各样的便签，但是实际上并没有使用多少就扔掉了，并不是它不实用，而是每次手写的时候都让我很痛苦，尤其是忙起来的时候，根本不愿意去找笔写它

当然，也有这种桌面便签，倒是不用手写了，但是很难受的是，最小化之后我经常会忘记，完全起不到提醒的作用，完全没有纸质的那种看着方便，而且电脑关机了之后就看不到了，也很不方便

直至《便签喵》的出现，这应该是市面上第一款真正意义上的桌面电子便签，设备usb供电，卡通外壳，配备了一块3.5寸的超大屏幕，支持WiFi联网，小程序控制，随时随地都可以快速编辑显示，卡通外壳，放在桌上还能当个时钟摆件，上面还能显示温湿度，冬天的时候再也不用凭感觉去开加湿器了。

最近出了V3了，虽然取消了卡通外壳，但是价格更加亲民，功能上，支持了亮度调整、主题、背景更换等功能，更加实用

由于主打硬件，微信小程序端的设计也是非常的简洁实用，没有任何花里胡哨的东西

- /posts/2022/1227-bqm-01/ - 2015 纸喵软件

Docker清理命令

Thu, 14 Apr 2022 17:47:19 +0800

倒霉狐狸的博客 /posts/2022/0414-docker-clear/ -

杀死所有正在运行的容器

docker kill $(docker ps -a -q)

删除所有已经停止的容器

docker rm $(docker ps -a -q)

删除所有未打 dangling 标签的镜像

docker rmi $(docker images -q -f dangling=true)

通过镜像的id来删除指定镜像

docker rmi <image id>

删除所有镜像

docker rmi $(docker images -q)

为这些命令创建别名

# ~/.bash_aliases

# 杀死所有正在运行的容器.
alias dockerkill='docker kill $(docker ps -a -q)'

# 删除所有已经停止的容器.
alias dockercleanc='docker rm $(docker ps -a -q)'

# 删除所有未打标签的镜像.
alias dockercleani='docker rmi $(docker images -q -f dangling=true)'

# 删除所有已经停止的容器和未打标签的镜像.
alias dockerclean='dockercleanc || true && dockercleani'

转载： https://www.runoob.com/w3cnote/docker-clear-command.html

- /posts/2022/0414-docker-clear/ - 2015 纸喵软件

利用docker快速编排个人开发电脑环境

Mon, 21 Mar 2022 17:59:42 +0800

倒霉狐狸的博客 /posts/2022/0221-docker-work-space/ -

由于本人开发场景是win10系统，所以本说明书也是按照win系统来的本文章为迁移文章，撰写时间超过三年

首先安装docker环境，这个可以从docker官网下载安装包，https://hub.docker.com/editions/community/docker-ce-desktop-windows, 建议下载稳定版的，免得毛病多

克隆纸喵docker-worker-pc-compose项目到D:\docker目录(这里如果要改变目录，须改变项目中的docker-comose.yml文件中的地址)，地址：https://gitee.com/zhimiao/docker-worker-pc-compose

这样处理一下，就不存在加密方式问题导致的mysql登陆问题了

这个时候docker大概也安装好了，安装过程可能会重启，托盘区小鲸鱼提示已经start了表明已经正常启动了，右击图标-setting-Shared Drives,映射目录用到了那个盘这里就要分享哪个盘，不然会失败，设置的时候需要验证用户，最好新建一个专用的管理员账户，因为如果改密码了，这里会失效，并且没有任何提示。

开启General-TLS，方便接下来phpstorm能够连接到docker环境：

配置D:/docker/nginx/vhost/default.conf虚拟主机，方便测试

server {
	listen 1301;
	set $app default;
	include docker.server;
}

创建D:/docker/wwwroot/default/i.php,内容如下

<?php
phpinfo();

命令行最好用powerShell(不要用cmd或者ISE)，进入D:\docker执行docker-compose up -d

启动完成之后，浏览器访问 http://localhost:1301/i.php

如果后面再次修改了nginx配置，可以通过docker-compose restart nginx来重启nginx，此命令要在D:\docker目录下执行，到这里环境就算搭建好了，接下来进入phpstorm开发环境配置（主要是xdebug配置）,打开default项目，修改i.php

<?php
$a = "hello zhimiao";
echo $a;
phpinfo();

配置default项目的server（此处主要是定义一个映射，因为本地的路径和容器内的路径不一致，容器内是linux系统，php目录为/var/www/html,nginx目录为/usr/share/nginx）

设置remote debug配置，如下图

配置好之后，选择刚刚配置的xdebug-1301，然后点击小虫子，进入监听状态，接着对i.php第三行断点

用浏览器访问i.php,发现开始转圈圈，然后phpstorm中出现xdebug信息

有的时候我们经常需要查看docker容器的状态以及一些配置，总是用命令行比较费劲，其实phpstorm里面提供了对docker的操控面板，这里需要用到文初设置的TLS

推广了一段时间后发现mysql8的加密方式是个坑，导致初始化成功后连接各种毛病，在此附上修正方案

# 登陆到容器内
docker exec -it mysql的容器ID /bin/bash
# 登陆到容器内的mysql内
mysql -uroot -proot
# 重置root密码
alter USER 'root'@'%' IDENTIFIED WITH mysql_native_password BY 'root';
flush privileges;

- /posts/2022/0221-docker-work-space/ - 2015 纸喵软件

同时运行多个gin服务并使用不同的swagger文档

Thu, 30 Dec 2021 10:37:26 +0800

倒霉狐狸的博客 /posts/2021/1230-gin-multi-swag/ -

前言

应用场景中，我们偶尔会遇到一个项目需要同时对外暴露多个端口，并提供不同的API服务，目前在go语言圈子中，gin+swagger对外提供API是一个很棒的组合，gin的官方文档也提供了同时运行多个服务的示例，但是对于swag，目前网上的文章中，多半都是简单的介绍gin如何整合swag，并没有太多的文章来介绍如何在一个项目中起多个互相不干扰的swag,鉴于最近遇到了这种需求场景，趟了一遍后，我觉着有必要分享一下我的实现。

准备工作

下载swag工具，本文使用的swag版本为1.7.8

$ go get -u github.com/swaggo/swag/cmd/swag
# 1.16 及以上版本
$ go install github.com/swaggo/swag/cmd/swag@latest
$ swag -version
swag.exe version v1.7.8

问题分析

首先，这个问题要分成两部分来看：

1：gin多服务

gin多服务这不是什么问题，官方就提供了相关的示例

package main

import (
	"log"
	"net/http"
	"time"

	"github.com/gin-gonic/gin"
	"golang.org/x/sync/errgroup"
)

var (
	g errgroup.Group
)

func router01() http.Handler {
	e := gin.New()
	e.Use(gin.Recovery())
	e.GET("/", func(c *gin.Context) {
		c.JSON(
			http.StatusOK,
			gin.H{
				"code":  http.StatusOK,
				"error": "Welcome server 01",
			},
		)
	})

	return e
}

func router02() http.Handler {
	e := gin.New()
	e.Use(gin.Recovery())
	e.GET("/", func(c *gin.Context) {
		c.JSON(
			http.StatusOK,
			gin.H{
				"code":  http.StatusOK,
				"error": "Welcome server 02",
			},
		)
	})

	return e
}

func main() {
	server01 := &http.Server{
		Addr:         ":8080",
		Handler:      router01(),
		ReadTimeout:  5 * time.Second,
		WriteTimeout: 10 * time.Second,
	}

	server02 := &http.Server{
		Addr:         ":8081",
		Handler:      router02(),
		ReadTimeout:  5 * time.Second,
		WriteTimeout: 10 * time.Second,
	}

	g.Go(func() error {
		return server01.ListenAndServe()
	})

	g.Go(func() error {
		return server02.ListenAndServe()
	})

	if err := g.Wait(); err != nil {
		log.Fatal(err)
	}
}

2：swag文档多份。

swag多服务文档，这涉及到两个地方，swag-cli工具的解析、api路由的挂载

swag-cli工具参数说明

swag init -h
NAME:
   swag init - Create docs.go

USAGE:
   swag init [command options] [arguments...]

OPTIONS:
   --generalInfo value, -g value          API通用信息所在的go源文件路径，如果是相对路径则基于API解析目录 (默认: "main.go")
   --dir value, -d value                  API解析目录 (默认: "./")
   --exclude value                        解析扫描时排除的目录，多个目录可用逗号分隔（默认：空）
   --propertyStrategy value, -p value     结构体字段命名规则，三种：snakecase,camelcase,pascalcase (默认: "camelcase")
   --output value, -o value               文件(swagger.json, swagger.yaml and doc.go)输出目录 (默认: "./docs")
   --parseVendor                          是否解析vendor目录里的go源文件，默认不
   --parseDependency                      是否解析依赖目录中的go源文件，默认不
   --markdownFiles value, --md value      指定API的描述信息所使用的markdown文件所在的目录
   --generatedTime                        是否输出时间到输出文件docs.go的顶部，默认是
   --codeExampleFiles value, --cef value  解析包含用于 x-codeSamples 扩展的代码示例文件的文件夹，默认禁用
   --parseInternal                        解析 internal 包中的go文件，默认禁用
   --parseDepth value                     依赖解析深度 (默认: 100)
   --instanceName value                   设置文档实例名 (默认: "swagger")

--generalInfo参数为我们提供了不同入口定义的可能

--dir,--exclude参数为我们提供了不同api定义的扫描

--output参数让我们能够把不同的文档生成到不同的地方

api路由挂载

下面是一个swaggo/gin-swagger提供的简单示例

package main

import (
   "github.com/gin-gonic/gin"
   docs "github.com/go-project-name/docs"
   swaggerfiles "github.com/swaggo/files"
   ginSwagger "github.com/swaggo/gin-swagger"
   "net/http"
)
// @BasePath /api/v1

// PingExample godoc
// @Summary ping example
// @Schemes
// @Description do ping
// @Tags example
// @Accept json
// @Produce json
// @Success 200 {string} Helloworld
// @Router /example/helloworld [get]
func Helloworld(g *gin.Context)  {
   g.JSON(http.StatusOK,"helloworld")
}

func main()  {
   r := gin.Default()
   docs.SwaggerInfo.BasePath = "/api/v1"
   v1 := r.Group("/api/v1")
   {
      eg := v1.Group("/example")
      {
         eg.GET("/helloworld",Helloworld)
      }
   }
   r.GET("/swagger/*any", ginSwagger.WrapHandler(swaggerfiles.Handler))
   r.Run(":8080")

}

可以看到，gin加载swag的关键节点就在于ginSwagger.WrapHandler，我们找到这个方法的源码，看到它其实是有一个配置入参的

通过官方文档，我找到了这几个配置入参说明

Option	Type	Default	Description
URL	string	“doc.json”	URL pointing to API definition
DocExpantion	string	“list”	Controls the default expansion setting for the operations and tags. It can be ‘list’ (expands only the tags), ‘full’ (expands the tags and operations) or ‘none’ (expands nothing).
DeepLinking	bool	true	If set to true, enables deep linking for tags and operations. See the Deep Linking documentation for more information.
DefaultModelsExpandDepth	int	1	Default expansion depth for models (set to -1 completely hide the models).
InstanceName	string	“swagger”	The instance name of the swagger document. If multiple different swagger instances should be deployed on one gin router, ensure that each instance has a unique name (use the –instanceName parameter to generate swagger documents with swag init).

InstanceName: swagger文档的实例名称。如果在一个gin路由器上部署多个不同的swagger实例，请确保每个实例都有一个唯一的名称。

这是一个很关键的点，由于项目是一个，但是swag库是全局的，只有注册不同的实例才能分别加载成功,同时我们翻看上文，swag-cli中，也提供了--instanceName参数，用于定义生成的文档实例名

撰写demo

文末提供了示例的源码，此处可以不用复制粘贴。

1、创建如下目录结构

/api/swa 服务A的API目录，里面定义了A相关的API

/api/swb 服务A的API目录，里面定义了B相关的API

/docs 为swag-cli生成的文档目录

/route 定义A/B服务的路由，以及swag入口文件

如上，分别在AB服务的路由swag加载处定义各自InstanceName,用于不同服务加载不同的swag

e.GET("/swagger/*any", ginSwagger.WrapHandler(swaggerFiles.Handler, func(c *ginSwagger.Config) {
    c.InstanceName = "swa"
}))

e.GET("/swagger/*any", ginSwagger.WrapHandler(swaggerFiles.Handler, func(c *ginSwagger.Config) {
    c.InstanceName = "swb"
}))

main.go 定义入口

package main

import (
	"log"
	"net/http"
	"time"
	"github.com/zhimiaox/gin-swagger/route"
	"golang.org/x/sync/errgroup"
	_ "github.com/zhimiaox/gin-swagger/docs/swa" // 导入swag文档
	_ "github.com/zhimiaox/gin-swagger/docs/swb" // 导入swag文档
)
var g errgroup.Group
func main() {
	server01 := &http.Server{
		Addr:         ":8080",
		Handler:      route.Swa(),
		ReadTimeout:  5 * time.Second,
		WriteTimeout: 10 * time.Second,
	}
	server02 := &http.Server{
		Addr:         ":8081",
		Handler:      route.Swb(),
		ReadTimeout:  5 * time.Second,
		WriteTimeout: 10 * time.Second,
	}
	g.Go(func() error {
		return server01.ListenAndServe()
	})
	g.Go(func() error {
		return server02.ListenAndServe()
	})
	if err := g.Wait(); err != nil {
		log.Fatal(err)
	}
}

2、生成文档

# 请在根目录下执行
$ swag init --instanceName=swa --generalInfo=route/swa.go --exclude=api/swb --output docs/swa
$ swag init --instanceName=swb --generalInfo=route/swb.go --exclude=api/swa --output docs/swb

3、启动服务验证

总结

过程很简单，也没啥曲折，重点就在于去仔细看看文档，现在很多文档都有中文了，没有中文的，谷歌翻译也好用的很

很久不写这些玩意了，真的很耽误时间，就这点东西，比特么写4个demo用的时间还长，真希望能够帮助到一些人，不至于让自己的努力变成互联网上的垃圾

附件链接

本文示例源码

gin运行多个服务示例文档

swag-cli工具文档

- /posts/2021/1230-gin-multi-swag/ - 2015 纸喵软件