快速上手deployment模块开发

说说我们cilliandevops平台的开发进度，目前前端有了大的框架，后端api的开发还在进行中，目前后端接口可以获取node、pod信息。

上次已经知道如何开发获取K8s集群中pod相关信息的接口，那么今天再看下如何完成获取deployment相关信息的接口开发。

package main
import (
 "context"
 "fmt"
 "time"
 metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 "k8s.io/client-go/kubernetes"
 "k8s.io/client-go/tools/clientcmd"
)
func main() {
 // 使用 kubeconfig 文件创建客户端
 config, err := clientcmd.BuildConfigFromFlags("", "/path/to/kubeconfig")
 if err != nil {
 panic(err)
 }
 clientset, err := kubernetes.NewForConfig(config)
 if err != nil {
 panic(err)
 }
 // 获取 Deployment 列表
 deployments, err := clientset.AppsV1().Deployments("default").List(context.TODO(), metav1.ListOptions{})
 if err != nil {
 panic(err)
 }
 fmt.Printf("Deployments: %v\n", deployments.Items)
 // 获取指定 Deployment 
 deployment, err := clientset.AppsV1().Deployments("default").Get(context.TODO(), "nginx-deployment", metav1.GetOptions{})
 if err != nil {
 panic(err)
 }
 fmt.Printf("Deployment: %v\n", deployment)
 // 监听 Deployment 的 rollout 状态
  watch, err := clientset.AppsV1().Deployments("default").Watch(context.TODO(), metav1.ListOptions{
 FieldSelector: "metadata.name=nginx-deployment"})
 if err != nil {
 panic(err)
 }
 // 事件循环
 for event := range watch.ResultChan() {
 deployment = event.Object.(*v1.Deployment)
 fmt.Printf("Deployment: %s, Status: %v\n", deployment.Name, deployment.Status.Conditions[0].Status)
 // 成功部署后停止监听
 if deployment.Status.Conditions[0].Status == "True" && 
  deployment.Status.Conditions[0].Reason == "NewReplicaSetAvailable" {
 watch.Stop()
 }
 }
}

package main
import (
 "context"
 "fmt"
 metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 "k8s.io/client-go/kubernetes"
 "k8s.io/client-go/tools/clientcmd"
)
func main() {
 // 使用 kubeconfig 文件创建客户端
 config, err := clientcmd.BuildConfigFromFlags("", "/path/to/kubeconfig")
 if err != nil {
 panic(err)
 }
 clientset, err := kubernetes.NewForConfig(config)
 if err != nil {
 panic(err)
 }
 // 获取 Deployment 列表
 deployments, err := clientset.AppsV1().Deployments("").List(context.TODO(), metav1.ListOptions{})
 if err != nil {
 panic(err)
 }
 // 遍历并打印每个 Deployment 的详情
 for _, d := range deployments.Items {
 // Deployment 详细信息
 fmt.Printf("Name:%s\n", d.Name)
 fmt.Printf("Namespace:%s\n", d.Namespace)
 fmt.Printf("CreationTimestamp:%s\n", d.CreationTimestamp)
 fmt.Printf("Labels:%v\n", d.Labels)
 // Status 信息
 status := d.Status
 fmt.Printf("AvailableReplicas:%d\n", status.AvailableReplicas)
 fmt.Printf("ReadyReplicas:%d\n", status.ReadyReplicas)
 fmt.Printf("UpdatedReplicas:%d\n", status.UpdatedReplicas)
 fmt.Println() }
}

Name:coredns
Namespace:kube-system
CreationTimestamp:2022-07-16 16:21:28 +0800 CST
Labels:map[k8s-app:kube-dns]
AvailableReplicas:2
ReadyReplicas:2
 UpdatedReplicas:2

到这就可以获取deployment相关信息，这里知识列出相关信息，这里相当于查询，增删改查的接口调用开发也是同样的道理。

说完这个，我们只是有了调用接口的程序，但是要开发完成一个完整的后端接口项目没有这么简单，所以我们这里来看看如果使用go开发后端项目，一般的通用目录结构是如何的：

├── api    // API 接口目录        
│  ├── v1             
│  │   ├── node.go    
│  │   ├── pod.go
│  │   └── ...
│  └── v2
├── config          
│  ├── config.go    // 全局配置结构体和读取配置函数
│  └── config.yaml // 配置文件
├── controllers       // controller层 
│  ├── node_controller.go
│   ├── pod_controller.go
│  └── ...
├── dao           // 数据访问层目录   
│  ├── node_dao.go  
│  ├── pod_dao.go
│  └── ...
├── docs            
├── logs
├── models          // 模型层目录
│  ├── node.go      
│  ├── pod.go  
│  └── ...
├── routers         // 路由目录
│  └── router.go    
├── services        // 服务层目录
│  ├── node_service.go
│  ├── pod_service.go
│  └── ... 
└── utils             // 工具函数目录
├── consts.go   
├── jwt.go      
└── ...

这个目录结构主要分为:

1. API:对外提供 v1 和 v2 两个 API 版本接口。
2. Config:配置文件读取。
3. Controllers:请求参数获取,调用服务层,返回响应。
4. Services:核心业务逻辑。
5. DAO:数据访问层。
6. Models:数据模型。
7. Utils:工具函数等。
8. Routers:API 路由注册。
9. Docs:OpenAPI 文档。
10. Logs:日志目录。

有了这个目录，我们再去一步一步开发：

层与层关系：

- controller 层负责解析请求,获取参数,调用服务层执行业务逻辑,返回响应

- 服务层专注于核心业务逻辑,被 controller 层调用

- API 层对外提供接口,接受请求并将请求提交给 router，暂时还没开发

- router 注册路由,将请求交给对应 controller 处理

所以,其中的关系可以概括为:

API -> Router -> Controller -> Services -> DAO

有了一个大的框架，那么再来看看go开发中有哪些点需要关注：

1. 包名:包名全部小写,不要使用下划线, 如:mypackage,不要my_package。

2. 函数名:使用 camelCase 命名风格,如:myFunction。

3. 变量名:使用 camelCase 命名风格,如:myVariable。

4. 常量名:全部大写,使用下划线连接,如:MY_CONSTANT。

5. 结构体名:使用 PascalCase 命名风格,如:MyStruct。

6. 导入包:每行导入一个包,按字母顺序导入。如:

go
import "fmt"
import "os"
import "strings"

7. 包和文件:一个包一个文件夹,文件夹名就是包名,package 语句在文件夹内唯一的 .go 文件首行。

8. go.mod 文件:每个项目的根目录下有 go.mod 文件,标识项目所依赖的包及版本。

9. GOPATH/GOROOT:GOROOT 是 Go 安装路径,GOPATH 是你的工作区路径。

10. 项目结构:遵循中间件设计,分为 API、Config、Controller、Service、DAO、Model 等层。

11. error 处理:Go 以错误为值,使用 if err != nil 检查错误。

12. defer 语句:defer 语句会在函数返回之前执行,用于资源清理。

13. 变量作用域:Go 只有函数作用域,没有块作用域。

14. 指针:Go 支持指针,BUT 不支持指针运算。

15. 切片:Go 切片像数组的引用,更加灵活,length 和capacity 可变。

16. 结构体:Go 结构体使用 type 定义,支持匿名结构体和内嵌结构体。

17. 接口:Go 接口使用 type 定义,不需要实现接口中的所有方法。

18. 并发:Go 协程使用 goroutine 关键字,channel 用于协程通讯。

19. 反射:Go 反射可以在运行时检查类型和值,并且可以调用对应的方法。

…待补充

今天的分享就到这了，感兴趣的朋友记得点赞关注呀！