K8S管理系统项目实战[API开发]-2

news2024/9/25 13:20:49

 后端: go+gin

后端代码地址GitHub - yunixiangfeng/k8s-platform: K8s管理系统后端: go+gin

5、存储与配置

5.1 ConfigMap

5.2 Secret

5.3 PersistentVolumeClaims

6、工作流

6.1 流程设计

6.2 数据库操作（GORM）

（1）初始化数据库

db/db.go

6.3 Workflow

service/workflow.go

(1)列表

（2）获取Workflow详情

（3）新增Workflow

（4）表数据列表

7、中间件

7.1 什么是中间件

7.2 gin中间件用法

7.2 Cors跨域

7.3 JWT token验证

8、WebShell终端

8.1 kubectl exec原理

8.2 实现思路

8.3 代码实现

9、总结

API开发：存储与配置资源

5、存储与配置

5.1 ConfigMap

（1）列表

（2）获取ConfigMap详情

（3）更新ConfigMap

（4)   删除ConfigMap

5.2 Secret

（1）列表

（2）获取Secret详情

（3）更新Secret

（4)   删除Secret

5.3 PersistentVolumeClaims

（1）列表

（2）获取Pvc详情

（3）更新Pvc

（4)   删除Pvc

API开发：部署工作流

6、工作流

6.1 流程设计

6.2 数据库操作（GORM）

（1）初始化数据库

db/init.go

package db

import (
	"fmt"
	"k8s-plantform/config"
	"time"

	"github.com/wonderivan/logger"

	"github.com/jinzhu/gorm"
	_ "github.com/jinzhu/gorm/dialects/mysql"
)

var (
	isInit bool
	GORM   *gorm.DB
	err    error
)

// DB的初始化函数，与数据库建立连接
func Init() {
	// 判断是否已经初始化
	if isInit {
		return
	}
	// 组装连接配置
	dsn := fmt.Sprintf("%s:%s@tcp(%s:%d)/%s?charset=utf8&parseTime=True&loc=Local",
		config.DbUser,
		config.DbPass,
		config.DbHost,
		config.DbPort,
		config.DbName)
	GORM, err := gorm.Open(config.DbType, dsn)
	if err != nil {
		panic("数据库连接失败," + err.Error())
	}
	// 打印sql语句
	GORM.LogMode(config.LogMode)
	// 开启连接池
	GORM.DB().SetMaxIdleConns(config.MaxIdleConns)
	GORM.DB().SetMaxOpenConns(config.MaxOpenConns)
	GORM.DB().SetConnMaxLifetime(time.Duration(config.MaxLifeTime))
	isInit = true
	logger.Info("数据库初始化成功")
}

// 关闭数据库连接
func Close() error {
	return GORM.Close()
}

加数据库配置

service/config.go

package config

import "time"

const (
	ListenAddr = "0.0.0.0:9090"
	KubeConfig = "C:\\Users\\Administrator\\.kube\\config"
	// tail的日志行数
	// tail -n 2000
	PodLogTailLine = 2000

	// DB Config
	DbType = "mysql"
	DbHost = "192.168.204.129"
	DbPort = 3306
	DbName = "k8s_dashboard"
	DbUser = "root"
	DbPass = ""
	// 打印mysql debug的sql日志
	LogMode = false
	// 连接池配置
	MaxIdleConns = 10               // 最大空闲连接
	MaxOpenConns = 100              // 最大连接数
	MaxLifeTime  = 30 * time.Second // 会话时间
)

SetMaxOpenConns
默认情况下，连接池的最大数量是没有限制的，一般来说，连接数越多，访问数据库的性能越高，但是系统资源不是无限的，数据库的并发能力也不是无限的，因此为了减少系统和数据据库崩溃的风险，可以给并发连接教设置一个上限，这个数值一般不超过进程的最大文件句柄打开数，不超过数据库服务自身支持的并发连接数，比如1000。
SetMaxldleConns
理论上maxldleConns连接的上限越高，也即允许在连接池中的空闲连接最大值越大，可以有效减少连接创建和消毁的次数，提高程序的性能，但是连接对象也是占用内存资源的，而且如果空闲连接越多，存在于连接池内的时间可能越长，连接在经过一段时间后有可能会变得不可用，而这时连接还在连接池内没有回收的话，后续被征用的时候就会出问题，一般建议maxidleConns的值为MaxOpenConns的1/2仅供参考。
SetConnMaxLifetime
设置一个连接被使用的最长时间，即过了一段时间后会被强制回收，理论上这可以有效减少不可用连接出现的概率，当数据库方面也设置了连接的超时时间时，这个值应当不超过数据库的超时参数值。

main.go

初始化

package main

import (
	"k8s-platform/config"
	"k8s-platform/controller"
	"k8s-platform/db"
	"k8s-platform/service"

	"github.com/gin-gonic/gin"
)

func main() {
	// 初始化k8s client
	service.K8s.Init() // 可以使用service.K8s.clientset 进行跨包调用

	// 初始化数据库
	db.Init()
	// 初始化gin对象/路由配置
	r := gin.Default()
	// 初始化路由规则
	controller.Router.InitApiRouter(r)
	// gin程序启动
	r.Run(config.ListenAddr)

	// 关闭数据库
	db.Close()
}

创建数据库k8s_dashboard

PS C:\Users\Administrator\Desktop\k8s-platform> go run main.go
2023-05-07 10:37:11 [INFO] [C:/Users/Administrator/Desktop/k8s-platform/service/init.go:26] 获取K8s配置成功！
2023-05-07 10:37:11 [INFO] [C:/Users/Administrator/Desktop/k8s-platform/service/init.go:33] 创建K8s client 成功!
2023-05-07 10:37:11 [INFO] [C:/Users/Administrator/Desktop/k8s-platform/db/init.go:44] 数据库初始化成功
[GIN-debug] [WARNING] Creating an Engine instance with the Logger and Recovery middleware already attached.

[GIN-debug] [WARNING] Running in "debug" mode. Switch to "release" mode in production.
 - using env:   export GIN_MODE=release
 - using code:  gin.SetMode(gin.ReleaseMode)

[GIN-debug] GET    /api/k8s/pods             --> k8s-platform/controller.(*pod).GetPods-fm (3 handlers)
[GIN-debug] GET    /api/k8s/pod/detail       --> k8s-platform/controller.(*pod).GetPodDetail-fm (3 handlers)
[GIN-debug] DELETE /api/k8s/pod/del          --> k8s-platform/controller.(*pod).DeletePod-fm (3 handlers)
[GIN-debug] PUT    /api/k8s/pod/update       --> k8s-platform/controller.(*pod).UpdatePod-fm (3 handlers)
[GIN-debug] GET    /api/k8s/pod/container    --> k8s-platform/controller.(*pod).GetPodContainer-fm (3 handlers)
[GIN-debug] GET    /api/k8s/pod/log          --> k8s-platform/controller.(*pod).GetPodLog-fm (3 handlers)
[GIN-debug] GET    /api/k8s/pod/numnp        --> k8s-platform/controller.(*pod).GetPodNumPerNp-fm (3 handlers)
[GIN-debug] GET    /api/k8s/deployments      --> k8s-platform/controller.(*deployment).GetDeployments-fm (3 handlers)
[GIN-debug] GET    /api/k8s/deployment/detail --> k8s-platform/controller.(*deployment).GetDeploymentDetail-fm (3 handlers)
[GIN-debug] PUT    /api/k8s/deployment/scale --> k8s-platform/controller.(*deployment).ScaleDeployment-fm (3 handlers)
[GIN-debug] DELETE /api/k8s/deployment/del   --> k8s-platform/controller.(*deployment).DeleteDeployment-fm (3 handlers)
[GIN-debug] PUT    /api/k8s/deployment/restart --> k8s-platform/controller.(*deployment).RestartDeployment-fm (3 handlers)
[GIN-debug] PUT    /api/k8s/deployment/update --> k8s-platform/controller.(*deployment).UpdateDeployment-fm (3 handlers)
[GIN-debug] GET    /api/k8s/deployment/numnp --> k8s-platform/controller.(*deployment).GetDeployNumPerNp-fm (3 handlers)
[GIN-debug] POST   /api/k8s/deployment/create --> k8s-platform/controller.(*deployment).CreateDeployment-fm (3 handlers)
[GIN-debug] [WARNING] You trusted all proxies, this is NOT safe. We recommend you to set a value.Please check https://pkg.go.dev/github.com/gin-gonic/gin#readme-don-t-trust-all-proxies for details.
[GIN-debug] Listening and serving HTTP on 0.0.0.0:9090

（2）建立表的映射关系

表结构

model/workflow.go

package model

import "time"

// 定义结构体，属性与mysql表字段对齐
type Workflow struct {
	// gorm:"primarykey"用于声明主键
	ID       uint       `json:"id" gorm:"primaryKey"`
	CreateAt *time.Time `json:"created_at"`
	UpdateAt *time.Time `json:"update_at"`
	DeleteAt *time.Time `json:"deleted_at"`

	Name       string `json:"name"`
	Namespace  string `json:"namespace"`
	Replicas   int32  `json:"replicas"`
	Deployment string `json:"deployment"`
	Service    string `json:"service"`
	Ingress    string `json:"ingress"`
	// gorm:"column:type"用于声明mysql中表的字段名
	Type string `json:"type" gorm:"column:type"`
}

// 定义TableName方法，返回mysql表名，以次定义mysql中的表名
func (*Workflow) TableName() string {
	return "workflow"
}

(3)数据库创建表

db\workflow.sql

CREATE TABLE `workflow` ( 
	`id` int NOT NULL AUTO_INCREMENT,
	`name` varchar(32) COLLATE utf8mb4_general_ci NOT NULL,
	`namespace` varchar(32) COLLATE utf8mb4_general_ci DEFAULT NULL,
	`replicas` int DEFAULT NULL,
	`deployment` varchar(32) COLLATE utf8mb4_general_ci DEFAULT NULL,
	`service` varchar(32) COLLATE utf8mb4_general_ci DEFAULT NULL,
	`ingress` varchar(32) COLLATE utf8mb4_general_ci DEFAULT NULL,
	`type` varchar(32) COLLATE utf8mb4_general_ci DEFAULT NULL,
	`created_at` datetime DEFAULT NULL,
	`updated_at` datetime DEFAULT NULL,
	`deleted_at` datetime DEFAULT NULL,
	PRIMARY KEY (`id`) USING BTREE,
	UNIQUE KEY `name` (`name`)
	) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_general_ci;

（4）表数据列表

// 获取workflow列表/获取列表分页查询GetList
func (w *workflow) GetWorkflows(filterName, namespace string, limit, page int) (data *WorkflowResp, err error) {
	//定义分页的起始位置
	startSet := (page - 1) * limit
	//定义数据库查询返回的内容
	var (
		workflowList []*model.Workflow
		total        int
	)
	//数据库查询，Limit方法用于限制条数，Offset方法用于设置起始位置
	tx := db.GORM.
		Model(&model.Workflow{}).
		Where("name like ?", "%"+filterName+"%").
		Count(&total).
		Limit(limit).
		Offset(startSet).
		Order("id desc").
		Find(&workflowList)
	if tx.Error != nil && tx.Error.Error() != "record not found" {
		logger.Error("获取Workflow列表失败, " + tx.Error.Error())
		return nil, errors.New("获取Workflow列表失败, " + tx.Error.Error())
	}
	return &WorkflowResp{
		Items: workflowList,
		Total: total,
	}, nil
}

（5）获取单条

// 获取详情
func (w *workflow) GetById(id int) (workflow *model.Workflow, err error) {
	workflow = &model.Workflow{}
	tx := db.GORM.Where("id = ?", id).First(&workflow)
	if tx.Error != nil && tx.Error.Error() != "record not found" {
		logger.Error("获取Workflow详情失败, " + tx.Error.Error())
		return nil, errors.New("获取Workflow详情失败, " + tx.Error.Error())
	}
	return workflow, nil
}

（6）表数据新增

// 创建
func (w *workflow) Add(workflow *model.Workflow) (err error) {
	tx := db.GORM.Create(&workflow)
	if tx.Error != nil && tx.Error.Error() != "record not found" {
		logger.Error("创建Workflow失败, " + tx.Error.Error())
		return errors.New("创建Workflow失败, " + tx.Error.Error())
	}
	return nil
}

（7）表数据删除

// 删除
func (w *workflow) DelById(id int) (err error) {
	tx := db.GORM.Where("id = ?", id).Delete(&model.Workflow{})
	if tx.Error != nil && tx.Error.Error() != "record not found" {
		logger.Error("获取Workflow详情失败, " + tx.Error.Error())
		return errors.New("获取Workflow详情失败, " + tx.Error.Error())
	}
	return nil
}
package dao

import (
	"errors"
	"k8s-platform/db"
	"k8s-platform/model"

	"github.com/wonderivan/logger"
)

var Workflow workflow

type workflow struct{}

//定义列表的返回内容，Items是workflow元素列表，Total为workflow元素数量
type WorkflowResp struct {
	Items []*model.Workflow `json:"items"`
	Total int               `json:"total"`
}

6.3 Workflow

service/workflow.go

package service

import (
	"k8s-platform/dao"
	"k8s-platform/model"
)

var Workflow workflow

type workflow struct{}

//定义workflowCreate类型
type WorkflowCreate struct {
	Name          string                 `json:"name"`
	Namespace     string                 `json:"namespace"`
	Replicas      int32                  `json:"replicas"`
	Image         string                 `json:"image"`
	Label         map[string]string      `json:"label"`
	Cpu           string                 `json:"cpu"`
	Memory        string                 `json:"memory"`
	ContainerPort int32                  `json:"container_port"`
	HealthCheck   bool                   `json:"health_check"`
	HealthPath    string                 `json:"health_path"`
	Type          string                 `json:"type"`
	Port          int32                  `json:"port"`
	NodePort      int32                  `json:"node_port"`
	Hosts         map[string][]*HttpPath `json:"hosts"`
}

(1)列表

//获取列表分页查询
func(w *workflow) GetList(name, namespace string, page, limit int) (data *dao.WorkflowResp, err error) {
	data, err = dao.Workflow.GetWorkflows(name, namespace, page, limit)
	if err != nil {
		return nil, err
	}
	return data, nil
}

（2）获取Workflow详情

//查询workflow单条数据
func(w *workflow) GetById(id int) (data *model.Workflow, err error) {
	data, err = dao.Workflow.GetById(id)
	if err != nil {
		return nil, err
	}
	return data, nil
}

（3）新增Workflow

//创建workflow
func(w *workflow) CreateWorkFlow(data *WorkflowCreate) (err error) {
	//定义ingress名字
	var ingressName string
	if data.Type == "Ingress" {
		ingressName = getIngressName(data.Name)
	} else {
		ingressName = ""
	}

	//workflow数据落库
	workflow := &model.Workflow{
		Name:       data.Name,
		Namespace:  data.Namespace,
		Replicas:   data.Replicas,
		Deployment: data.Name,
		Service:    getServiceName(data.Name),
		Ingress:    ingressName,
		Type:       data.Type,
	}
	err = dao.Workflow.Add(workflow)
	if err != nil {
		return err
	}
	//创建k8s资源
	err = createWorkflowRes(data)
	if err != nil {
		return err
	}

	return err
}

//创建k8s资源 deployment service ingress
func createWorkflowRes(data *WorkflowCreate) (err error) {

	//创建deployment
	dc := &DeployCreate{
		Name:          data.Name,
		Namespace:     data.Namespace,
		Replicas:      data.Replicas,
		Image:         data.Image,
		Label:         data.Label,
		Cpu:           data.Cpu,
		Memory:        data.Memory,
		ContainerPort: data.ContainerPort,
		HealthCheck:   data.HealthCheck,
		HealthPath:    data.HealthPath,
	}
	err = Deployment.CreateDeployment(dc)
	if err != nil {
		return err
	}
	var serviceType string
	if data.Type != "Ingress" {
		serviceType = data.Type
	} else {
		serviceType = "ClusterIP"
	}
	//创建service
	sc := &ServiceCreate{
		Name:          getServiceName(data.Name),
		Namespace:     data.Namespace,
		Type:          serviceType,
		ContainerPort: data.ContainerPort,
		Port:          data.Port,
		NodePort:      data.NodePort,
		Label:         data.Label,
	}
	if err := Servicev1.CreateService(sc); err != nil {
		return err
	}
	//创建ingress
	var ic *IngressCreate
	if data.Type == "Ingress" {
		ic = &IngressCreate{
			Name:      getIngressName(data.Name),
			Namespace: data.Namespace,
			Label:     data.Label,
			Hosts:     data.Hosts,
		}
		err = Ingress.CreateIngress(ic)
		if err != nil {
			return err
		}
	}

	return nil
}

//workflow名字转换成service名字，添加-svc后缀
func getServiceName(workflowName string) (serviceName string) {
	return workflowName + "-svc"
}
//workflow名字转换成ingress名字，添加-ing后缀
func getIngressName(workflowName string) (ingressName string) {
	return workflowName + "-ing"
}

（4）删除workflow

//删除workflow
func(w *workflow) DelById(id int) (err error) {
	//获取数据库数据
	workflow, err := dao.Workflow.GetById(id)
	if err != nil {
		return err
	}
	//删除k8s资源
	err = delWorkflowRes(workflow)
	if err != nil {
		return err
	}
	//删除数据库数据
	err = dao.Workflow.DelById(id)
	if err != nil {
		return err
	}

	return
}

//删除k8s资源 deployment service ingress
func delWorkflowRes(workflow *model.Workflow) (err error) {
	err = Deployment.DeleteDeployment(workflow.Name, workflow.Namespace)
	if err != nil {
		return err
	}
	err = Servicev1.DeleteService(getServiceName(workflow.Name), workflow.Namespace)
	if err != nil {
		return err
	}

	if workflow.Type == "Ingress" {
		err = Ingress.DeleteIngress(getIngressName(workflow.Name), workflow.Namespace)
		if err != nil {
			return err
		}
	}

	return nil
}

controller/workflow.go

package controller

import (
	"k8s-platform/service"
	"net/http"

	"github.com/gin-gonic/gin"
	"github.com/wonderivan/logger"
)

var Workflow workflow

type workflow struct{}

// 获取列表分页查询
func (w *workflow) GetList(ctx *gin.Context) {
	params := new(struct {
		Name      string `form:"name"`
		Namespace string `form:"namespace"`
		Page      int    `form:"page"`
		Limit     int    `form:"limit"`
	})
	if err := ctx.Bind(params); err != nil {
		logger.Error("Bind请求参数失败, " + err.Error())
		ctx.JSON(http.StatusInternalServerError, gin.H{
			"msg":  err.Error(),
			"data": nil,
		})
		return
	}

	data, err := service.Workflow.GetList(params.Name, params.Namespace, params.Limit, params.Page)
	if err != nil {
		logger.Error("获取Workflow列表失败, " + err.Error())
		ctx.JSON(http.StatusInternalServerError, gin.H{
			"msg":  err.Error(),
			"data": nil,
		})
		return
	}

	ctx.JSON(http.StatusOK, gin.H{
		"msg":  "获取Workflow列表成功",
		"data": data,
	})
}

// 查询workflow单条数据
func (w *workflow) GetById(ctx *gin.Context) {
	params := new(struct {
		ID int `form:"id"`
	})
	if err := ctx.Bind(params); err != nil {
		logger.Error("Bind请求参数失败, " + err.Error())
		ctx.JSON(http.StatusInternalServerError, gin.H{
			"msg":  err.Error(),
			"data": nil,
		})
		return
	}

	data, err := service.Workflow.GetById(params.ID)
	if err != nil {
		logger.Error("查询Workflow单条数据失败, " + err.Error())
		ctx.JSON(http.StatusInternalServerError, gin.H{
			"msg":  err.Error(),
			"data": nil,
		})
		return
	}

	ctx.JSON(http.StatusOK, gin.H{
		"msg":  "查询Workflow单条数据成功",
		"data": data,
	})
}

// 创建workflow
func (w *workflow) Create(ctx *gin.Context) {
	var (
		wc  = &service.WorkflowCreate{}
		err error
	)

	if err = ctx.ShouldBindJSON(wc); err != nil {
		logger.Error("Bind请求参数dc失败, " + err.Error())
		ctx.JSON(http.StatusInternalServerError, gin.H{
			"msg":  err.Error(),
			"data": nil,
		})
		return
	}
	if err = service.Workflow.CreateWorkFlow(wc); err != nil {
		logger.Error("创建Workflow失败, " + err.Error())
		ctx.JSON(http.StatusInternalServerError, gin.H{
			"msg":  err.Error(),
			"data": nil,
		})
		return
	}

	ctx.JSON(http.StatusOK, gin.H{
		"msg":  "创建Workflow成功",
		"data": nil,
	})

}

// 删除workflow
func (w *workflow) DelById(ctx *gin.Context) {
	params := new(struct {
		ID int `json:"id"`
	})
	if err := ctx.ShouldBindJSON(params); err != nil {
		logger.Error("Bind请求参数失败, " + err.Error())
		ctx.JSON(http.StatusInternalServerError, gin.H{
			"msg":  err.Error(),
			"data": nil,
		})
		return
	}

	if err := service.Workflow.DelById(params.ID); err != nil {
		logger.Error("删除Workflow失败, " + err.Error())
		ctx.JSON(http.StatusInternalServerError, gin.H{
			"msg":  err.Error(),
			"data": nil,
		})
		return
	}

	ctx.JSON(http.StatusOK, gin.H{
		"msg":  "删除Workflow成功",
		"data": nil,
	})
}

配置workflow路由

controller/router.go

package controller

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

// // 初始化router类型对象，首字母大写，用于跨包调用
// var Router router

// // 声明一个router的结构体
// type router struct{}

// func (r *router) InitApiRouter(router *gin.Engine) {
// 	router.GET("/", Index)
// }

// func Index(ctx *gin.Context) {
// 	ctx.JSON(200, gin.H{
// 		"code": 200,
// 		"msg":  "In index",
// 	})
// }

// 实例化router结构体，可使用该对象点出首字母大写的方法（包外调用）
var Router router

// 创建router的结构体
type router struct{}

// // 初始化路由规则，创建测试api接口
// func (r *router) InitApiRouter(router *gin.Engine) {
// 	router.GET("/testapi", func(ctx *gin.Context) {
// 		ctx.JSON(http.StatusOK, gin.H{
// 			"msg":  "testapi success!",
// 			"data": nil,
// 		})
// 	})
// }
// 初始化路由规则
// func (r *router) InitApiRouter(router *gin.Engine) {
// 	router.
// 		GET("/api/k8s/pods", Pod.GetPods).
// 		GET("/api/k8s/pod/detail", Pod.GetPodDetail).
// 		POST("/api/k8s/pods", Pod.DeletePod).
func (r *router) InitApiRouter(router *gin.Engine) {
	router.
		// Pods
		GET("/api/k8s/pods", Pod.GetPods).
		GET("/api/k8s/pod/detail", Pod.GetPodDetail).
		DELETE("/api/k8s/pod/del", Pod.DeletePod).
		PUT("/api/k8s/pod/update", Pod.UpdatePod).
		GET("/api/k8s/pod/container", Pod.GetPodContainer).
		GET("/api/k8s/pod/log", Pod.GetPodLog).
		GET("/api/k8s/pod/numnp", Pod.GetPodNumPerNp).
		//deployment操作
		GET("/api/k8s/deployments", Deployment.GetDeployments).
		GET("/api/k8s/deployment/detail", Deployment.GetDeploymentDetail).
		PUT("/api/k8s/deployment/scale", Deployment.ScaleDeployment).
		DELETE("/api/k8s/deployment/del", Deployment.DeleteDeployment).
		PUT("/api/k8s/deployment/restart", Deployment.RestartDeployment).
		PUT("/api/k8s/deployment/update", Deployment.UpdateDeployment).
		GET("/api/k8s/deployment/numnp", Deployment.GetDeployNumPerNp).
		POST("/api/k8s/deployment/create", Deployment.CreateDeployment).
		// workflows
		GET("/api/k8s/workflows", Workflow.GetList).
		GET("/api/k8s/workflow/detail", Workflow.GetById).
		POST("/api/k8s/workflow/create", Workflow.Create).
		DELETE("/api/k8s/workflow/del", Workflow.DelById)

}

测试api接口

7、中间件

7.1 什么是中间件

中间件，英译middleware，顾名思义，放在中间的物件，那么放在谁中间呢?本来，客户端可以直接请求到服务端接口。现在，中间件横插一脚它能在请求到达接口之前拦截请求，做一些特殊处理，比如日志记录，故障处理等

7.2 gin中间件用法

7.2 Cors跨域

7.3 JWT token验证

8、WebShell终端

8.1 kubectl exec原理

8.2 实现思路

8.3 代码实现

（1）处理终端交互

service/terminal.go

9、总结

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/497959.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

Mysql Sharding-JDBC读写分离 原理

Mysql Sharding-JDBC读写分离 原理

0 课程视频 深入Sharding-JDBC分库分表从入门到精通【黑马程序员】_哔哩哔哩_bilibili 1 基本概念 1.1应用逻辑 1.1.1 msyql 多库 多表 多服务器 1.1.2 通过Sharding-JDBC jar包->增强JDBC 访问多数据源 -> 自动处理成一个数据源 1.1.3 使用数据的人 -> 使用Sh…
阅读更多...
Java面试题总结 | Java面试题总结12- 测试模块

Java面试题总结 | Java面试题总结12- 测试模块

测试 测试需要具备的素质 基础的理论知识、编程语言的功底、自动化测试工具、计算机基础知识 业务分析能力：分析业务的流程，分析被测业务数据、分析被测系统的框架、分析业务模块、分析测试所需资源、分析测试完成目标 缺陷洞察能力：一般…
阅读更多...
【ChatGPT】吴恩达教程笔记（预备篇）

【ChatGPT】吴恩达教程笔记（预备篇）

本文概要 众所周知，吴恩达老师与OpenAI联合推出了一门面向开发者的Prompt课程（https://www.deeplearning.ai/short-courses/chatgpt-prompt-engineering-for-developers ），时隔几天，吴恩达老师发推说已经有超过20万人…
阅读更多...
Netty基础

Netty基础

2.1Netty是什么 是一个基于异步的（多线程处理结果和接收）、事件驱动的网络应用框架，用于基于快速开发可维护、高性能的网络服务器和客户端 异步是指调用时的异步，他的IO还是多路复用的IO 许多中间件都依赖与Netty zookperhado…
阅读更多...
GUITAR PRO8吉他软件好不好用?值不值得下载

GUITAR PRO8吉他软件好不好用?值不值得下载

所谓“工欲善其事，必先利其器”，想成为一名专业甚至著名的音乐人，用到的工具软件非常多，在众多款软件工具中，Guitar Pro 8能满足乐谱创作者、学习者的所有需要。很多人在听到Guitar Pro这个名词时，本能反应…
阅读更多...
spark的RDD算子计算

spark的RDD算子计算

一、环境配置 import osfrom pyspark import SparkConf, SparkContextif __name__ __main__:os.environ[SPARK_HOME] /export/server/sparkos.environ["PYSPARK_PYTHON"] "/root/anaconda3/envs/pyspark_env/bin/python"os.environ["PYSPARK_DRIV…
阅读更多...
JavaWeb07(MVC应用01[家居商城]连接数据库)

JavaWeb07(MVC应用01[家居商城]连接数据库)

目录 一.什么是MVC设计模式？ 1.2 MVC设计模式有什么优点？ 二.MVC运用（家居商城） 2.1 实现登录 2.2 绑定轮播【随机三个商品】 2.2.1 效果预览 index.jsp 2.3 绑定最新上架&热门家居 2.3.1 效果预览 2.3.2 代码实现 数据…
阅读更多...
linux进程基本知识

linux进程基本知识

1.什么是程序，什么是进程？ 程序是静态的概念，例如 gcc xx.c -o pro 磁盘中生成pro文件，叫做程序 进程是程序的一次运行活动，意思是程序跑起来了，系统中就多了一个进程 2.如何查看系统中有哪些进程&…
阅读更多...
EMC VNX登录Unisphere错误 certificate has invalid date问题处理

EMC VNX登录Unisphere错误 certificate has invalid date问题处理

经常有用户反应说，突然用浏览器登录EMC VNX或者Clarrion CX系统的时候出现“certificate has invalid date”的故障，然后无法正常登录图形界面。具体报错如下图所示： 导致这个问题的原因在于VNX系统中的certification认证过期，既然…
阅读更多...
SpringBoot整合Echarts实现用户人数和性别展示

SpringBoot整合Echarts实现用户人数和性别展示

一、背景 在Web应用开发中，经常需要使用图表来展示数据，而Echarts是一个非常优秀的图表库。SpringBoot是一个非常流行的Java Web框架，它可以快速搭建Web应用。本文将介绍如何使用SpringBoot集成Echarts，实现展示用户人数和性别的…
阅读更多...
百度百科如何创建？创建百度百科的秘诀你值得掌握（经验分享）

百度百科如何创建？创建百度百科的秘诀你值得掌握（经验分享）

百度百科是中国最大的百科全书式的中文网站之一，是广大用户在互联网上获取知识的重要途径之一。任何人都可以在百度百科创建新的词条，为网站的发展作出贡献。 小媒同学将从如何创建百度百科词条和注意事项两个方面来详细介绍百度百科词条的创建流程和相关…
阅读更多...
css3 flex弹性布局详解

css3 flex弹性布局详解

css3 flex弹性布局详解 一、flexbox弹性盒子 2009年，W3C 提出了一种新的方案----Flex 布局，可以简便、完整、响应式地实现各种页面布局。目前，它已经得到了所有浏览器的支持，这意味着，现在就能很安全地使用这项功能。…
阅读更多...
在选择数据库时需要考虑的因素

在选择数据库时需要考虑的因素

在文章的第一部分中，我们奠定了理解各种数据库类型及其用例的基础。随着我们继续探索数据库选择的艺术，我们现在将更深入地探讨影响这个决策过程的关键因素。通过更详细地检查每个因素，我们可以更好地装备自己做出符合项目要求的知情选择&…
阅读更多...
ubuntu 卸载 软件包 libfdt-dev

ubuntu 卸载 软件包 libfdt-dev

编译环境 Win10 64位 ubuntu 20.04 虚拟机 VMware Workstation 16 Pro NUC980 bsp 自带的编译工具链： nuc980bsp.tar.gz，版本 gcc version 4.8.4 (GCC) NUC980 uboot : https://gitee.com/OpenNuvoton/NUC970_U-Boot_v2016.11 目标 手动编译 NUC9…
阅读更多...
【Windows】Windows下载使用wget命令

【Windows】Windows下载使用wget命令

文章目录 一、前言 & 介绍二、安装步骤2.1 下载 wget 压缩包2.2 解压到指定的位置2.3 检查是否安装成功2.4 是否可以正常下载 一、前言 & 介绍 wget 是 linux 一个下载文件的工具，可以下载一些软件或从远程服务器恢复备份到本地服务器。 wget 在 Linux 下…
阅读更多...
PCA主成成分分析例题详解

PCA主成成分分析例题详解

主成分分析是一种降维算法，它能将多个指标转换为少数几个主成分，这些主成分是原始变量的线性组合，且彼此之间互不相关，其能反映出原始数据的大部分信息 需要了解具体细节可看此视频👉：什么是主成成分分析PC…
阅读更多...
webpack 5 实战（3）

webpack 5 实战（3）

四十一、代码拆分方式 通过Webpack实现前端项目整体模块化的优势很明显，但是它同样存在一些弊端，那就是项目当中所有的代码最终都会被打包到一起，试想一下，如果说应用非常复杂，模块非常多的话，那打包结果就…
阅读更多...
C++ ---- 入门基础知识总结

C++ ---- 入门基础知识总结

思维导图 目录 命名空间 命名冲突 如何定义命名空间 命名空间定义语法 嵌套定义 同一工程下定义同名命名空间 命名空间的使用 命名空间名称和作用域限定符（: :） using将命名空间中某个成员“释放”出来 using namespace 命名空间名称 C标准库…
阅读更多...
Go：值与指针

Go：值与指针

1. 计算机中的值 在百万年的演化历史中，人类对事物的属性进行了抽象，有了数量、精度、信息等概念的表示，对应的我们称之为整数、小数、文本文字等。计算机出现后，我们使用计算机对真实世界的问题进行建模，通过计算机的…
阅读更多...
WIN10安装CUDA保姆级教程[2023.5.7更新]

WIN10安装CUDA保姆级教程[2023.5.7更新]

本系列分步记录在win10上搭建CUDAcudnnpytorchYOLOv5tensorrt等深度学习架构部署及系统搭建，欢迎关注追更！ 目录 0.了解CUDA 1.注意事项 1.1显卡驱动 1.2确定关联性 1.2.1 显卡驱动与cuda的对应关系： 1.2.2 pytorch与cuda的对应关系 2.c…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023