小哥之哥
tchua
2023-03-31
目录

GO语言gin框架总结

# 一、介绍

Gin 是一个用 Go (Golang) 编写的 web 框架。 它是一个类似于martini但拥有更好性能的API框架, 由于使用httprouter，速度提高了近 40 倍。
1

# 二、安装

# 2.1 下载安装
go get -u github.com/gin-gonic/gin
1
# 2.2 简单示例
package main

import (
	"github.com/gin-gonic/gin"
	"net/http"
)
// 业务处理函数 固定签名
func getBoy(ctx *gin.Context) {
	ctx.Writer.Write([]byte("Hi Boy"))
}

func main()  {
	// 创建默认路由引擎
	r := gin.Default()
	
    // get 路由请求
	r.GET("/hello", func(c *gin.Context) {
		c.JSON(http.StatusOK,gin.H{
			"msg":"ok",
		})
	})
    // 自定义handle
    r.GET("/usr",getBoy)
	
    // 启动
	r.Run() // 默认监听8080端口

}

访问: 127.0.0.1:8080/hello
返回: {"msg":"ok"}
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
# 2.3 response

返回值，业务中常用的就是json格式

  • string示例
// 直接返回想要的字符串
c.String(200, "Hello 小哥！")
1
2
  • json示例

json可以返回值自定义字段

func index(c *gin.Context) {
	type User struct {
		Name   string `json:"name"`
		PassWd string `json:"-"` // 如果不想被渲染，则使用-
		Age    int    `json:"age"`
	}

	user := User{
		Name:   "小哥",
		PassWd: "123456",
		Age:    22,
	}
	c.JSON(200, user)
}

浏览器返回:
{"name":"小哥","age":22}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
  • json示例(直接响应)
func index(c *gin.Context) {
    c.JSON(200, gin.H{"msg":"success"})
}
1
2
3
  • map示例

跟json比较类似，只是无法自定义字段

func index(c *gin.Context) {
    userMap := map[string]string{
        "name":"小哥",
        "age":18,
    }
    c.JSON(200, userMap)
}
1
2
3
4
5
6
7
  • 响应xml
func index(c *gin.Context) {
	c.XML(200, gin.H{"name": "小哥", "age": 18})
}

返回值:
<map>
<name>小哥</name>
<age>18</age>
</map>
1
2
3
4
5
6
7
8
9
  • 响应yaml
func index(c *gin.Context) {
	c.YAML(200, gin.H{"name": "小哥", "age": 18, "data": gin.H{"msg": "success"}})
}

返回值(通过postman):
age: 18
data:
    msg: success
name: 小哥
1
2
3
4
5
6
7
8
9
  • 响应html

创建index模版

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>gin_demo</title>
</head>
<body>
你好 {{ .name }}
</body>
</html>
1
2
3
4
5
6
7
8
9
10

响应

func index(c *gin.Context) {
	c.HTML(200, "index.html", gin.H{"name": "小哥"})
}

// 需要在路由之前先加载模板
r.LoadHTMLGlob("templates/*")
1
2
3
4
5
6
  • 响应文件
// 第一个参数为请求路径，第二个为服务器文件路径参数
// 请求示例: http://127.0.0.1:8080/download/${filename} 后街files目录下文件名 
r.StaticFS("/download", http.Dir("static/files"))
	
// 单个文件 第一个参数为请求路径 第二个参数为服务器文件路径
r.StaticFile("/file","static/file.txt")
1
2
3
4
5
6
# 2.4 Gin 渲染
# 2.4.1 GO语言的模板引擎
Go语言内置了文本模板引擎text/template和用于HTML文档的html/template。它们的作用机制可以简单归纳如下：
1) 模板文件通常定义为.tmpl和.tpl为后缀（也可以使用其他的后缀），必须使用UTF8编码。
2) 模板文件中使用{{和}}包裹和标识需要传入的数据。
3) 传给模板这样的数据就可以通过点号（.）来访问，如果数据是复杂类型的数据，可以通过{{ .FieldName }}来访问它的字段。
4) 除{{和}}包裹的内容外，其他内容均不做修改原样输出。
1
2
3
4
5
# 2.4.2 模板使用
  • 定义模板文件
go语言定义模板有自己的专门语法
1
  • 解析模板文件

上面定义好了模板文件之后，可以使用下面的常用方法去解析模板文件，得到模板对象：

func (t *Template) Parse(src string) (*Template, error) // 从字符串中解析

// 从文件中解析
func ParseFiles(filenames ...string) (*Template, error)

// 解析一个正则
func ParseGlob(pattern string) (*Template, error)
1
2
3
4
5
6
7
  • 渲染模板文件
func (t *Template) Execute(wr io.Writer, data interface{}) error
func (t *Template) ExecuteTemplate(wr io.Writer, name string, data interface{}) error
1
2

# 三、参数相关

gin把所有请求参数都放在了context中
1) c.Query() 从GET请求的URL中获取参数
2) c.Param() 从Restful风格的url中获取参数
3) c.PostForm() 从post表单中获取参数
4) FormFile() 获取上传的文件，消息类型为form-data
5) c.MultipartForm() multipart/form-data 可以上传多个form-data并且用分隔符进行分割
1
2
3
4
5
6
# 3.1 获取querystring参数
querystring指的是URL中?后面携带的参数，例如：/user/search?username=tchua&address=上海。 
获取请求的querystring参数的方法如下:
package main

import (
	"github.com/gin-gonic/gin"
	"net/http"
)

func main()  {
	// 创建默认路由
	r := gin.Default()

	r.GET("/user/search", func(c *gin.Context) {
		// DefaultQuery，当获取的参数不存在时，使用后面指定的默认值
		username := c.DefaultQuery("username","小哥")
		address := c.Query("address")
        // 响应内容(response) JSON 直接返回 json类型数据
		c.JSON(http.StatusOK,gin.H{
			"msg":http.StatusOK,
			"username": username,
			"address": address,
		})
	})
	r.Run()

}

请求: http://127.0.0.1:8080/user/search?username=小花&address=上海
响应: {"address":"上海","msg":200,"username":"小花"}
说明:
	c.DefaultQuery --> 当获取的参数不存在时，使用后面指定的默认值
	c.Query --> 获取参数不存在，返回空
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
# 3.2 获取PostForm参数

表单参数

package main

import (
	"fmt"
	"github.com/gin-gonic/gin"
	"net/http"
)

func main()  {
	// 创建默认路由
	r := gin.Default()
	r.POST("/user/search", func(c *gin.Context) {
        // 如果没有传值，则使用默认值
		//username := c.DefaultPostForm("username","小哥哈")
		username := c.PostForm("username")
		password := c.PostForm("password")
		c.JSON(http.StatusOK,gin.H{
			"msg":"用户创建成功",
			"用户名":username,
		})
		fmt.Println(password)
	})
	r.Run()

}

请求: 通过post请求，会获取前端提交的数据
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
# 3.3 获取json参数

比较常用,主要用于接受json参数，也可以接收form-data和x-www-form-urlencoded,但是返回类型不一样

package main

import (
	"encoding/json"
	"github.com/gin-gonic/gin"
	"net/http"
)

func main()  {
	// 创建默认路由
	r := gin.Default()
	r.POST("/user/json", func(c *gin.Context) {
        
        // 从c.Request.Body读取原始请求数据,b 为[]uint8类型
		b,_ := c.GetRawData() 

		var m map[string]interface{} // 定义map
		_ = json.Unmarshal(b,&m) // 反序列化 可映射为对应的map或者结构体 常用解析结构体
		c.JSON(http.StatusOK,m)
	})
	r.Run()
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
  • 简单封装数据解析函数
func dataPas(c *gin.Context, obj any) error {
	b, _ := c.GetRawData()
	contentType := c.GetHeader("Content-type")

	switch contentType {
	case "application/json":
		err := json.Unmarshal(b, &obj)
		if err != nil {
			return err
		}
	case "application/x-www-form-urlencoded":
		fmt.Println("")
	default:
		fmt.Printf("未知Content-type类型:%v\n",contentType)
		
	}
	return nil
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
# 3.4 获取path参数
请求的参数通过URL路径传递，例如：/user/search/小哥/上海。 获取请求URL路径中的参数的方式如下:
package main

import (
	"github.com/gin-gonic/gin"
	"net/http"
)

func main()  {
	// 创建默认路由
	r := gin.Default()
	r.GET("/user/search/:username/:address", func(c *gin.Context) {
		username := c.Param("username")
		address := c.Param("address")
		c.JSON(http.StatusOK,gin.H{
			"msg":"ok",
			"username":username,
			"address":address,
		})
	})
	r.Run()
}

请求: /user/search/小哥/上海
返回: {"address":"上海","msg":"ok","username":"小哥"}
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
# 3.5 获取用户上传文件
package main

import (
	"fmt"
	"github.com/gin-gonic/gin"
	"net/http"
	"strconv"
)


func main()  {
	r := gin.Default()
	r.GET("/usr",getBoy)
    
	// 上传单个文件
	r.POST("/upload", func(c *gin.Context) {
		file_obj,err := c.FormFile("file")
		if err != nil {
			fmt.Println(err)
			c.String(http.StatusInternalServerError,"file upload failed")
		}else {
			c.SaveUploadedFile(file_obj,"./data/"+file_obj.Filename)
			c.String(http.StatusOK,file_obj.Filename + "上传成功!")
		}
	})
	// 上传多个文件
	r.POST("/multi_upload", func(c *gin.Context) {
		file_obj,_ := c.MultipartForm()
		files := file_obj.File["files"]
		for _,file := range files {
			c.SaveUploadedFile(file,"./data/"+file.Filename)
		}
		c.String(http.StatusOK,strconv.Itoa(len(files))+"upload success")
	})
	r.Run("0.0.0.0:18081")
}

注意事项:
1) 上传文件指定参数时，一定要注意对应代码中指定的参数名称:file、files
2) 客户端指定content-type: form-data
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
# 3.6 参数绑定
  为了能够更方便的获取请求相关参数，提高开发效率，我们可以基于请求的Content-Type识别请求数据类型并利用反射机制自动提取请求中QueryString、form表单、JSON、XML等参数到结构体中。 下面的示例代码演示了.ShouldBind()强大的功能，它能够基于请求自动提取JSON、form表单和QueryString类型的数据，并把值绑定到指定的结构体对象。
1
package main

import (
	"fmt"
	"github.com/gin-gonic/gin"
	"net/http"
)

// 指定标签 ShouldBind()会根据Content-Type来选择使用哪种标签进行绑定
// 客户端传递参数时需要对应tag上对应的标签值
type Login struct {
	User string `form:"user" json:"user" binding:"required"`
	Password string `form:"password" json:"password" binding:"required"`
}
func main()  {
	router := gin.Default()

	// 绑定json示例 {"user":"小哥","password":"123456"}
	router.POST("/login", func(c *gin.Context) {
		var login Login
        // ShouldBind()会根据请求的Content-Type自行选择绑定器
        // 指定特定格式解析参数绑定: ShouldBindJSON、ShouldBindXML、ShouldBindYAML
        // gin.H 自定义返回json数据，也可以直接传一个结构体替换gin.H
		if err := c.ShouldBind(&login); err == nil {
			fmt.Printf("login info:%#v\n",login)
			c.JSON(http.StatusOK,gin.H{
				"user":login.User,
				"password":login.Password,
			})
		}else {
			c.JSON(http.StatusBadRequest,gin.H{
				"error":err.Error(),
			})
		}
	})
	router.Run()
}
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
ShouldBind会按照下面的顺序解析请求中的数据完成绑定：
    1) 如果是 GET 请求，只使用 Form 绑定引擎（query）。
    2) 如果是 POST 请求，首先检查 content-type 是否为 JSON 或 XML，然后再使用 Form（form-data）
1
2
3
# 3.7 参数校验

gin参数校验，也是依赖于validate库

package main

import (
	"fmt"
	"github.com/gin-gonic/gin"
	"github.com/gin-gonic/gin/binding"
	"github.com/go-playground/validator/v10"
	"net/http"
	"time"
)

type Student struct {
	Name string `form:"name" binding:"required"` //required:必须上传name参数
	Addr string `form:"addr" binding:"required"`
	//自定义验证before_today，日期格式东8区
	// time_format 固定格式
	Enrollment time.Time `form:"enrollment" binding:"required,before_today" time_format:"2006-01-02" time_utc:"8"`
	//毕业时间要晚于入学时间 gtfield跨字段校验
	Graduation time.Time `form:"graduation" binding:"required,gtfield=Enrollment" time_format:"2006-01-02" time_utc:"8"`
}
// 自定义实现before_today校验方法
var beforeToday validator.Func= func(fl validator.FieldLevel) bool {
	if data,ok := fl.Field().Interface().(time.Time);ok{
		today := time.Now()
		if data.Before(today) {
			return true
		}
	}
	return false
}

func main()  {
	r := gin.Default()
    
	// 注册自定义校验函数
	if v,ok := binding.Validator.Engine().(*validator.Validate);ok {
		v.RegisterValidation("before_today",beforeToday)
	}
	// 请求路由
	r.POST("/stu/reg", func(c *gin.Context) {
		var stu Student
		if err := c.ShouldBind(&stu); err != nil {
			fmt.Println(err)
			c.String(http.StatusBadRequest,"parse param failed")
		} else {
			c.String(http.StatusOK,stu.Name+"live in"+stu.Addr+"enroll "+stu.Enrollment.String()+" graduate "+stu.Graduation.String())
		}
	})
	r.Run("0.0.0.0:18081")
}
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
  • 客户端请求示例
1) 根据校验规则，如果enrollment大于当前时间则会抛出校验不通过
	"Key: 'Student.Enrollment' Error:Field validation for 'Enrollment' failed on the 'before_today' tag"
2) 如果enrollment小于graduation，则校验也不通过
	"Key: 'Student.Graduation' Error:Field validation for 'Graduation' failed on the 'gtfield' tag"
1
2
3
4

image-20211231150510983

# 四、路由

# 4.1 重定向
# 4.1.1 http重定向

跳转到指定url

package main

import (
	"github.com/gin-gonic/gin"
	"net/http"
)

func main()  {
	r := gin.Default()

	r.GET("/r", func(c *gin.Context) {
		c.Redirect(http.StatusMovedPermanently,"https://www.baidu.com/")
	})
	r.Run()
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
# 4.1.2 路由重定向

HandleContext 跳转到指定接口

package main

import (
	"github.com/gin-gonic/gin"
	"net/http"
)

func main()  {
	r := gin.Default()

	r.GET("/test", func(c *gin.Context) {
		c.Request.URL.Path = "/test2"
		r.HandleContext(c)
	})

	r.GET("/test2", func(c *gin.Context) {
		c.JSON(http.StatusOK,gin.H{
			"msg":"跳转成功",
		})
	})
	r.Run()
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
# 4.2 Gin路由
# 4.2.1 普通路由
r.GET("/index", func(c *gin.Context) {...})
r.GET("/login", func(c *gin.Context) {...})
r.POST("/login", func(c *gin.Context) {...})


// Any匹配所有请求方法，GET、POST....
r.Any("/login", func(c *gin.Context) {...})

// NoRoute 没有匹配到路由的请求，默认返回404，可自定义返回页面
r.NoRoute(func(c *gin.Context) {...})
1
2
3
4
5
6
7
8
9
10
# 4.2.2 路由分组

当我们需要给某些路由定义一个统一前缀时,可以使用路由分组

func main() {
	r := gin.Default()
	userGroup := r.Group("/user")
	{
		userGroup.GET("/index", func(c *gin.Context) {...})
		userGroup.GET("/login", func(c *gin.Context) {...})
		userGroup.POST("/login", func(c *gin.Context) {...})

	}
	shopGroup := r.Group("/shop")
	{
		shopGroup.GET("/index", func(c *gin.Context) {...})
		shopGroup.GET("/cart", func(c *gin.Context) {...})
		shopGroup.POST("/checkout", func(c *gin.Context) {...})
	}
	r.Run()
}

请求时:
127.0.0.1:8080/user/index
127.0.0.1:8080/shop/index
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

# 五、中间件

Gin框架允许开发者在处理请求的过程中，加入用户自己的钩子（Hook）函数。这个钩子函数就叫中间件，中间件适合处理一些公共的业务逻辑，比如登录认证、权限校验、数据分页、记录日志、耗时统计等。
1
# 5.1 定义中间件

Gin中的中间件必须是一个gin.HandlerFunc类型


// gin 中间件签名 返回gin.HandlerFunc
func StateCost() gin.HandlerFunc {
	return func(c *gin.Context) {
		start := time.Now()
		// 通过c.Set在请求上下文中设置值，后续的处理函数能够取到该值
		c.Set("name","tchua")
		// 调用该请求的剩余处理程序，也就是说会走业务逻辑函数
		c.Next()
		cost := time.Since(start)
		log.Println(cost)
	}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
# 5.2 注册中间件

在gin框架中，我们可以为每个路由添加任意数量的中间件

# 5.2.1 为全局路由注册
func main()  {
	r := gin.Default()
    // 使用Use 注册为所有路由注册中间件
	r.Use(StateCost())
	r.GET("/hello", func(c *gin.Context) {
		name := c.MustGet("name").(string)
		log.Println(name)
		c.JSON(http.StatusOK,gin.H{
			"msg":name,
		})
	})
	r.Run()
}

请求流程：
	中间件 --> 遇到Next --> 执行业务真正路由函数 --> 继续执行中间件剩下逻辑
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
# 5.2.2 单个路由注册
func main()  {
	r := gin.Default()
    //直接在业务函数前加中间件函数即可
	r.GET("/hello",StateCost(),func(c *gin.Context) {
		name := c.MustGet("name").(string)
		log.Println(name)
		c.JSON(http.StatusOK,gin.H{
			"msg":name,
		})
	})
	r.Run()
}
1
2
3
4
5
6
7
8
9
10
11
12
# 5.2.3 路由组注册
  • 第一种
shopGroup := r.Group("/shop", StatCost())
{
    shopGroup.GET("/index", func(c *gin.Context) {...})
    ...
}
1
2
3
4
5
  • 第二种
shopGroup := r.Group("/shop")
shopGroup.Use(StatCost())
{
    shopGroup.GET("/index", func(c *gin.Context) {...})
    ...
}
1
2
3
4
5
6
# 5.2.4 默认中间件
gin.Default()默认使用了Logger和Recovery中间件，其中：
	Logger中间件将日志写入gin.DefaultWriter，即使配置了GIN_MODE=release。
	Recovery中间件会recover任何panic。如果有panic的话，会写入500响应码。
如果不想使用上面两个默认的中间件，可以使用gin.New()新建一个没有任何默认中间件的路由。
1
2
3
4
# 5.3 中间件流程
当有多个中间件时，会按照循序依次执行,当遇到Next()时会去执行下一个函数，直到遇到业务逻辑函数，然后返回继续执行中间件函数Next()剩下的逻辑。
1

# 六、会话管理

http是无状态的，即服务端不知道两次请求是否来自于同一个客户端
Cookie由服务端生成，发送给客户端，客户端保存在本地
客户端每次发起请求时把Cookie带上，以证明自己的身份
HTTP请求中的Cookie头只会包含name和value信息（服务端只能取到name和value），domain、path、expires等cookie属性是由浏览器使用的，对服务器来说没有意义
Cookie可以被浏览器禁用
1
2
3
4
5
  • server
package main

import (
	"encoding/base64"
	"fmt"
	"github.com/gin-gonic/gin"
	"net/http"
	"strconv"
	"sync"
	"time"
)

// 线程安全的map
var (
	autpMap sync.Map
)
// 生产cookie函数
// 根据客户端地址生产cookieName
func genCookieName(c *gin.Context) string {
	fmt.Println("c.Request.RemoteAddr:",c.Request.RemoteAddr)
	return base64.StdEncoding.EncodeToString([]byte(c.Request.RemoteAddr))
}
// 登录函数
func login(engine *gin.Engine)  {
	engine.POST("/login", func(c *gin.Context) {
		cookie_name := genCookieName(c)
		cookie_value := strconv.Itoa(time.Now().Nanosecond())
		// 把登录生成的cookieName，cookieValue保存到服务的Map中，待需要时进行校验
		autpMap.Store(cookie_name,cookie_value)
		// 把cookie发送给客户端,该cookie信息保存再reponse的header中
		c.SetCookie(cookie_name,cookie_value,600,"/","localhost",false,true)
		c.String(http.StatusOK,"登录成功")
	})
}
// 用户中心 局部中间件
func userCenter(engine *gin.Engine)  {
	engine.GET("/user_center",authMiddleWare(), func(c *gin.Context) {
		c.String(http.StatusOK,"个人中心")
	})
}
// gin 中间件
// 从request中取出cookie_name、cookie_value，然后跟authMap中存的cookie_name与cookie_value做对比
func authMiddleWare() gin.HandlerFunc {
	return func(c *gin.Context) {
		cookie_name := genCookieName(c)
		var cookie_value string
		// 从客户端请求中遍历cookie信息
		for _,cookie := range c.Request.Cookies(){
			// 保存客户端请求头中的cookie_name,cookie_value
			if cookie.Name == cookie_name {
				cookie_value = cookie.Value
			}
		}
		// 如果客户端请求中没有cookie_value(首次登录)，则终止或者返回至登录页面
		if len(cookie_value) == 0 {
			c.JSON(http.StatusUnauthorized,gin.H{
				"msg":"未登录用户",
			})
			c.Abort()
		}else {
			// 客户端请求中 cookie信息与服务端保存上次登录的信息做对比
			if v,ok := autpMap.Load(cookie_name);ok {
				if v.(string) == cookie_value{
					c.Next()
				}else {
					// 这里仅仅时为了方便调试，返回给客户端的内容信息
					// 正常业务逻辑需要自己判断如果处理 首次登录或者cookie不正确的情况
					c.JSON(http.StatusForbidden,gin.H{
						cookie_name: cookie_value,
					})
					c.Abort()
				}
			} else {
				c.JSON(http.StatusForbidden,gin.H{
					cookie_name: cookie_value,
				})
				c.Abort()
			}
		}
	}
}

func main()  {
	engine := gin.Default()
	login(engine)
	userCenter(engine)

	engine.Run("0.0.0.0:18081")
}

"""待优化
如果用户未登录则跳转至登录页面
"""
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
编辑 (opens new window)
#Go
上次更新: 2023/07/03, 15:10:18
GO语言HTTP标准库
Gin框架集成Swagger

← Gin框架集成Swagger→

最近更新
01
cert-manager自动签发Lets Encrypt
09-05
02
Docker构建多架构镜像
08-02
03
Prometheus数据迁移至VMstorage
08-01
更多文章>
Theme by Vdoing | Copyright © 2023-2024 |豫ICP备2021026650号