Go语言学习笔记(一)

学习目标：掌握Go语言，为K8s二次开发做准备

学习路线#

基础语法

实战应用

Go概念 -> K8s应用对照#

fmt -> 调试输出Pod状态
struct -> Pod/Service数据结构
slice -> Pod列表管理
map -> Labels/Annotations处理
goroutine -> 并发处理多个Pod

环境搭建#

Go环境配置步骤：

官网下载Go
设置环境变量 GOPROXY=https://goproxy.cn,direct (国内必须)
初始化项目 go mod init project-name
运行 go run main.go 或 go build

第一个程序：

1
package main
2
import "fmt"
3
func main() {
4
    fmt.Println("Hello K8s!")
5
}

常用命令：

go mod init k8s-tools - 创建模块
go run main.go - 直接运行
go build - 编译成可执行文件

输入输出#

fmt包的三个主要函数：

fmt.Print() - 输出不换行
fmt.Println() - 输出并换行
fmt.Printf() - 格式化输出(重点)

1
package main
2
import "fmt"
3

4
func main() {
5
    // 格式化输出
6
    podName := "nginx-pod"
7
    replicas := 3
8
    fmt.Printf("Pod名称: %s, 副本数: %d\n", podName, replicas)
9

10
    // 读取输入
11
    var name string
12
    var count int
13
    fmt.Print("请输入Pod名称: ")
14
    fmt.Scan(&name)  // 注意&符号
15
    fmt.Print("请输入副本数: ")
16
    fmt.Scan(&count)
17
}

常用格式化符号：

%s - 字符串
%d - 整数
%f - 浮点数
%.1f - 保留1位小数
%t - 布尔值
%v - 任意类型

练习：写个简单的K8s工具

1
func main() {
2
    var podname string
3
    var replicas int
4

5
    fmt.Print("请输入pod名称：")
6
    fmt.Scan(&podname)
7
    fmt.Print("请输入pod副本数：")
8
    fmt.Scan(&replicas)
9

10
    fmt.Printf("准备创建pod：%s，副本数：%d\n", podname, replicas)
11
    fmt.Println("正在连接到 K8s 集群...")
12
}

变量和类型#

Go基础数据类型：

string - 字符串，存储Pod名称、命名空间等
int - 整数，存储副本数、端口号等
float64 - 浮点数，存储CPU/内存限制
bool - 布尔值，存储Pod就绪状态等

变量声明的三种方式：

1
// 1. 完整声明
2
var podName string = "nginx-pod"
3

4
// 2. 类型推断
5
var serviceName = "my-service"
6

7
// 3. 简短声明 (函数内)
8
deploymentName := "web-deployment"

常量声明：

1
const (
2
    DefaultNamespace = "default"
3
    MaxReplicas = 100
4
)

K8s Deployment示例：

1
func main() {
2
    deploymentName := "web-server"
3
    namespace := "production"
4
    replicas := 5
5
    cpuLimit := 1.5
6
    enabled := true
7

8
    fmt.Printf(`=== K8s Deployment 信息 ===
9
部署名称: %s
10
命名空间: %s
11
副本数量: %d
12
CPU限制: %.1f核
13
状态: %t`, deploymentName, namespace, replicas, cpuLimit, enabled)
14
}

注意：

:= 只能在函数内使用
声明的变量必须使用，否则编译错误
重新赋值用 =，不是 :=

流程控制 if/else#

if语句用来根据条件执行不同的代码分支，K8s开发中经常用到。

基本语法：

1
// 基础if
2
if podStatus == "Running" {
3
    fmt.Println("✅ Pod 状态正常")
4
}
5

6
// if-else
7
if cpuUsage > 80.0 {
8
    fmt.Println("🔥 需要扩容")
9
} else {
10
    fmt.Println("✅ CPU正常")
11
}
12

13
// 多分支
14
if podStatus == "Running" {
15
    fmt.Println("✅ 运行正常")
16
} else if podStatus == "Pending" {
17
    fmt.Println("⚠️ 等待调度")
18
} else if podStatus == "Failed" {
19
    fmt.Println("❌ 启动失败")
20
} else {
21
    fmt.Println("❓ 未知状态")
22
}

比较运算符：

== 等于
!= 不等于
> >= 大于(等于)
< <= 小于(等于)

逻辑运算符：

&& 逻辑与 (都为true)
|| 逻辑或 (至少一个true)
! 逻辑非 (取反)

Pod监控示例：

1
func main() {
2
    podName := "web-server-pod"
3
    status := "Running"
4
    cpuUsage := 75.5
5
    memUsage := 60.2
6

7
    fmt.Println("=== Pod监控报告 ===")
8

9
    if status == "Running" {
10
        fmt.Println("✅ Pod运行正常")
11
    } else {
12
        fmt.Println("⚠️ Pod状态异常")
13
    }
14

15
    if cpuUsage > 80 && memUsage > 85 {
16
        fmt.Println("⚠️ 资源使用率过高，建议扩容")
17
    } else {
18
        fmt.Println("✅ 资源使用正常")
19
    }
20
}

注意：

条件表达式结果必须是bool类型
大括号{}必须有，左大括号必须在同一行
多分支从上到下检查，遇到true就执行并跳出

循环#

循环用来重复执行代码，K8s开发中处理批量Pod、容器等数据时必不可少。

1. 传统for循环#

1
// 基本语法: for 初始化; 条件; 更新 { }
2
for i := 0; i < 3; i++ {
3
    fmt.Printf("第 %d 次重试连接...\n", i+1)
4
}

2. for range循环 (最常用)#

1
// 遍历Pod列表
2
pods := []string{"nginx-pod", "redis-pod", "mysql-pod"}
3

4
// 只要值
5
for _, podName := range pods {
6
    fmt.Println(podName)
7
}
8

9
// 要索引和值
10
for i, podName := range pods {
11
    fmt.Printf("[%d] %s\n", i+1, podName)
12
}

3. 无限循环#

1
for {
2
    // 监控Pod状态
3
    if podReady {
4
        break  // 退出条件
5
    }
6
    time.Sleep(1 * time.Second)
7
}

4. 循环控制#

1
// break - 跳出循环
2
for _, pod := range pods {
3
    if pod == "target-pod" {
4
        fmt.Println("找到目标Pod")
5
        break
6
    }
7
}
8

9
// continue - 跳过当前循环
10
for _, pod := range pods {
11
    if pod == "skip-pod" {
12
        continue  // 跳过这个pod
13
    }
14
    fmt.Println("处理:", pod)
15
}

集群健康检查练习：

1
func main() {
2
    services := []string{"web-service", "api-service", "db-service"}
3
    pods := [][]string{
4
        {"web-1", "web-2", "web-3"},
5
        {"api-1", "api-2"},
6
        {"mysql-1", "mysql-2"},
7
    }
8
    statuses := [][]string{
9
        {"Running", "Running", "Failed"},
10
        {"Running", "Pending"},
11
        {"Running", "Running"},
12
    }
13

14
    // 嵌套循环遍历
15
    for i, serviceName := range services {
16
        fmt.Printf("🔍 检查服务: %s\n", serviceName)
17
        servicePods := pods[i]
18
        serviceStatuses := statuses[i]
19

20
        for j, podName := range servicePods {
21
            status := serviceStatuses[j]
22
            if status == "Running" {
23
                fmt.Printf("  ✅ %s: %s\n", podName, status)
24
            } else {
25
                fmt.Printf("  ❌ %s: %s\n", podName, status)
26
            }
27
        }
28
    }
29
}

数组和切片#

切片是动态数组，K8s开发中管理Pod列表、容器列表必备。

数组 vs 切片#

数组: 固定长度 [3]int{1,2,3}，很少用
切片: 动态长度 []int{1,2,3}，常用

切片操作#

1
// 创建切片
2
pods := []string{"nginx-pod", "redis-pod"}
3
pods = append(pods, "mysql-pod")  // 添加元素
4

5
// 访问元素
6
fmt.Println(pods[0])    // 第一个元素
7
fmt.Println(len(pods))  // 长度
8

9
// 切片截取
10
fmt.Println(pods[:2])   // 前2个: [nginx-pod redis-pod]
11
fmt.Println(pods[1:])   // 从第2个开始: [redis-pod mysql-pod]
12

13
// 遍历
14
for i, pod := range pods {
15
    fmt.Printf("[%d] %s\n", i, pod)
16
}

二维切片#

1
// K8s多服务Pod管理
2
services := []string{"web-service", "api-service"}
3
pods := [][]string{
4
    {"web-1", "web-2", "web-3"},  // web-service的Pod
5
    {"api-1", "api-2"},           // api-service的Pod
6
}
7

8
// 访问: pods[服务索引][Pod索引]
9
fmt.Println(pods[0])     // web-service的所有Pod
10
fmt.Println(pods[0][1])  // web-service的第2个Pod: web-2
11

12
// 遍历二维切片
13
for i, serviceName := range services {
14
    fmt.Printf("服务: %s\n", serviceName)
15
    servicePods := pods[i]
16
    for j, podName := range servicePods {
17
        fmt.Printf("  [%d] %s\n", j+1, podName)
18
    }
19
}

Pod管理练习：

1
func main() {
2
    pods := []string{"web-pod-1", "db-pod-1"}
3
    pods = append(pods, "cache-pod-1", "api-pod-1", "worker-pod-1")
4

5
    fmt.Println("=== K8s 集群状态 ===")
6
    fmt.Println("Pod 总数:", len(pods))
7
    fmt.Println("Pod 列表:")
8

9
    for i, podName := range pods {
10
        fmt.Printf("  [%d] %s\n", i+1, podName)
11
    }
12

13
    fmt.Println("前3个Pod:", pods[:3])
14
    fmt.Println("最后2个Pod:", pods[len(pods)-2:])
15
}

映射(map)#

映射是键值对集合，用来处理K8s的Labels、Annotations、ConfigMap等。

基本语法#

1
// 创建映射
2
labels := map[string]string{
3
    "app":     "nginx",
4
    "version": "v1.0",
5
    "env":     "production",
6
}
7

8
// 访问值
9
appName := labels["app"]
10

11
// 检查键是否存在
12
version, exists := labels["version"]
13
if exists {
14
    fmt.Println("版本:", version)
15
}
16

17
// 添加/修改
18
labels["tier"] = "frontend"
19

20
// 删除
21
delete(labels, "version")
22

23
// 获取长度
24
fmt.Println("标签数量:", len(labels))

遍历映射#

1
// 遍历键值对
2
for key, value := range labels {
3
    fmt.Printf("%s = %s\n", key, value)
4
}
5

6
// 只要键
7
for key := range labels {
8
    fmt.Println("键:", key)
9
}
10

11
// 只要值
12
for _, value := range labels {
13
    fmt.Println("值:", value)
14
}

嵌套映射#

1
// Pod标签管理: namespace -> podName -> labels
2
podLabels := map[string]map[string]string{
3
    "default": {
4
        "web-pod":   "app=nginx,version=v1.0",
5
        "cache-pod": "app=redis,version=v6.0",
6
    },
7
    "production": {
8
        "api-pod": "app=api,version=v2.1",
9
        "db-pod":  "app=mysql,version=v8.0",
10
    },
11
}
12

13
// 安全访问嵌套映射
14
if prodPods, exists := podLabels["production"]; exists {
15
    if apiLabels, exists := prodPods["api-pod"]; exists {
16
        fmt.Println("API Pod标签:", apiLabels)
17
    }
18
}

Labels管理练习：

1
func main() {
2
    podLabels := map[string]map[string]string{
3
        "web-pod-1": {"app": "nginx", "version": "v1.0", "env": "prod"},
4
        "web-pod-2": {"app": "nginx", "version": "v1.1", "env": "prod"},
5
        "api-pod":   {"app": "api", "version": "v2.0", "env": "staging"},
6
        "db-pod":    {"app": "mysql", "version": "v8.0", "env": "prod"},
7
    }
8

9
    // 统计环境分布
10
    envCount := map[string]int{"prod": 0, "staging": 0}
11
    appCount := map[string]int{}
12

13
    for podName, labels := range podLabels {
14
        fmt.Printf("📋 Pod: %s\n", podName)
15

16
        for key, value := range labels {
17
            fmt.Printf("  %s = %s\n", key, value)
18

19
            if key == "env" {
20
                envCount[value]++
21
            }
22
            if key == "app" {
23
                appCount[value]++
24
            }
25
        }
26
    }
27

28
    fmt.Println("📊 统计:")
29
    fmt.Printf("- 生产环境Pod: %d\n", envCount["prod"])
30
    fmt.Printf("- 应用分布: %v\n", appCount)

注意：

映射遍历顺序是随机的
访问不存在的键会返回零值
必须先初始化才能使用: make(map[string]string)

学习进度: 完成基础语法部分，接下来学习函数、结构体、错误处理等高级特性，最终实现K8s二次开发目标。

Simple Blog