跳转到内容

云原生开发篇概述

课程目标

通过本系列课程的学习,你将能够:

  • 理解云原生开发的概念和核心原则
  • 掌握Kubernetes Operator开发模式
  • 开发自定义CRD和控制器
  • 使用client-go与K8s API交互
  • 构建云原生应用和工具
  • 应用云原生开发最佳实践

前置要求

  • 熟练掌握Go语言编程
  • 已完成K8S基础篇和进阶篇所有课程
  • 了解Kubernetes架构和核心资源

一、云原生开发简介

1.1 什么是云原生开发

云原生开发是一种基于Kubernetes等云原生技术的软件开发方法,它扩展了Kubernetes的能力,实现:

能力说明典型应用
自定义资源扩展K8s API,定义新的资源类型数据库、消息队列等复杂应用管理
自动化运维将运维知识编码到软件中自动扩缩容、故障恢复、备份
平台扩展开发K8s插件和扩展CSI存储插件、CNI网络插件、调度器扩展
工具开发开发K8s生态工具CLI工具、Dashboard、监控系统

1.2 云原生开发 vs 传统运维开发

┌─────────────────────────────────────────────────────────────────┐
│                   云原生开发 vs 传统运维开发                      │
├─────────────────────────────────────────────────────────────────┤
│                                                                 │
│  传统运维开发                        云原生开发                   │
│  ├─ Shell/Python脚本                ├─ Go语言为主                │
│  ├─ 调用命令行工具                   ├─ 直接调用K8s API          │
│  ├─ 外部协调管理                     ├─ 控制器模式(声明式)       │
│  ├─ 被动响应                         ├─ 主动监听和调谐            │
│  └─ 难以扩展                         └─ 充分利用K8s生态          │
│                                                                 │
└─────────────────────────────────────────────────────────────────┘

1.3 云原生开发技术栈

技术领域核心技术用途
编程语言GoK8s原生语言,生态完善
K8s客户端client-go与K8s API交互的官方SDK
代码生成controller-gen, code-generator自动生成K8s相关代码
Operator框架Operator SDK, Kubebuilder快速开发Operator
API设计OpenAPI, CRD定义自定义资源
存储etcd client直接与etcd交互(高级)

二、课程体系

2.1 课程结构

云原生开发篇
├── 140-云原生开发篇概述(本文档)
│   └── 介绍云原生开发的概念和学习路径

├── 141-Operator开发基础
│   ├── Operator概念和架构
│   ├── Operator SDK入门
│   ├── 控制器模式详解
│   └── 开发第一个Operator

├── 142-自定义CRD开发
│   ├── CRD结构和定义
│   ├── OpenAPI验证
│   ├── 多版本管理
│   └── 开发自定义控制器

└── 143-K8s客户端开发
    ├── client-go架构和组件
    ├── Informer机制
    ├── WorkQueue使用
    └── 开发K8s管理工具

2.2 学习路径建议

┌─────────────────────────────────────────────────────────────────┐
│                      推荐学习路径                                │
├─────────────────────────────────────────────────────────────────┤
│                                                                 │
│  第1阶段:基础准备                                                │
│  ├─ 确保Go语言基础扎实(并发、接口、反射)                         │
│  ├─ 完成K8S基础篇和进阶篇                                         │
│  └─ 了解K8s架构和核心资源                                         │
│                          │                                      │
│                          ▼                                      │
│  第2阶段:Operator开发                                            │
│  ├─ 学习Operator概念和架构                                        │
│  ├─ 使用Operator SDK创建项目                                      │
│  ├─ 理解控制器模式和Reconcile循环                                  │
│  └─ 开发简单的Operator(如自定义应用管理器)                        │
│                          │                                      │
│                          ▼                                      │
│  第3阶段:CRD深入开发                                             │
│  ├─ 掌握CRD高级特性(验证、版本、转换)                            │
│  ├─ 开发复杂的自定义控制器                                        │
│  └─ 实现Status子资源和Finalizer                                   │
│                          │                                      │
│                          ▼                                      │
│  第4阶段:client-go开发                                           │
│  ├─ 理解client-go架构                                             │
│  ├─ 掌握Informer和WorkQueue                                       │
│  └─ 开发K8s管理工具和CLI                                          │
│                                                                 │
└─────────────────────────────────────────────────────────────────┘

三、开发环境准备

3.1 安装Go

bash
# 下载Go 1.21+(推荐最新稳定版)
wget https://go.dev/dl/go1.21.5.linux-amd64.tar.gz
sudo tar -C /usr/local -xzf go1.21.5.linux-amd64.tar.gz

# 配置环境变量
echo 'export PATH=$PATH:/usr/local/go/bin' >> ~/.bashrc
echo 'export GOPATH=$HOME/go' >> ~/.bashrc
echo 'export GOROOT=/usr/local/go' >> ~/.bashrc
source ~/.bashrc

# 验证安装
go version

3.2 安装开发工具

bash
# 安装Operator SDK
export ARCH=$(case $(uname -m) in x86_64) echo -n amd64 ;; aarch64) echo -n arm64 ;; *) echo -n $(uname -m) ;; esac)
export OS=$(uname | awk '{print tolower($0)}')
export OPERATOR_SDK_DL_URL=https://github.com/operator-framework/operator-sdk/releases/download/v1.33.0
curl -LO ${OPERATOR_SDK_DL_URL}/operator-sdk_${OS}_${ARCH}
gpg --keyserver keyserver.ubuntu.com --recv-keys 052996E2A20B5C7E
curl -LO ${OPERATOR_SDK_DL_URL}/checksums.txt
curl -LO ${OPERATOR_SDK_DL_URL}/checksums.txt.asc
gpg -u "Operator SDK (release) <cncf-operator-sdk@cncf.io>" --verify checksums.txt.asc
chmod +x operator-sdk_${OS}_${ARCH} && sudo mv operator-sdk_${OS}_${ARCH} /usr/local/bin/operator-sdk

# 安装Kubebuilder
wget https://github.com/kubernetes-sigs/kubebuilder/releases/download/v3.13.0/kubebuilder_linux_amd64
chmod +x kubebuilder_linux_amd64
sudo mv kubebuilder_linux_amd64 /usr/local/bin/kubebuilder

# 安装kustomize
curl -s "https://raw.githubusercontent.com/kubernetes-sigs/kustomize/master/hack/install_kustomize.sh" | bash
sudo mv kustomize /usr/local/bin/

# 安装其他工具
go install sigs.k8s.io/controller-tools/cmd/controller-gen@latest
go install sigs.k8s.io/kind@latest

3.3 配置K8s开发集群

bash
# 使用kind创建开发集群
cat > kind-config.yaml <<EOF
kind: Cluster
apiVersion: kind.x-k8s.io/v1alpha4
nodes:
- role: control-plane
  kubeadmConfigPatches:
  - |
    kind: InitConfiguration
    nodeRegistration:
      kubeletExtraArgs:
        node-labels: "ingress-ready=true"
  extraPortMappings:
  - containerPort: 80
    hostPort: 80
    protocol: TCP
  - containerPort: 443
    hostPort: 443
    protocol: TCP
- role: worker
- role: worker
EOF

kind create cluster --config kind-config.yaml --name dev

# 验证集群
kubectl cluster-info
kubectl get nodes

四、核心概念预习

4.1 Operator模式

┌─────────────────────────────────────────────────────────────────┐
│                      Operator模式                                │
├─────────────────────────────────────────────────────────────────┤
│                                                                 │
│  ┌─────────────────┐         ┌─────────────────┐               │
│  │   用户声明期望    │────────▶│   自定义资源(CR)  │               │
│  │   (Desired State)│         │   (MySQL集群)    │               │
│  └─────────────────┘         └────────┬────────┘               │
│                                       │                        │
│                                       ▼                        │
│  ┌─────────────────┐         ┌─────────────────┐               │
│  │   实际状态       │◀────────│    Operator     │               │
│  │   (Actual State) │         │   (控制器)       │               │
│  │   (运行的Pod)   │         │                 │               │
│  └─────────────────┘         └─────────────────┘               │
│                                       │                        │
│                                       │ 调谐(Reconcile)         │
│                                       ▼                        │
│                              ┌─────────────────┐               │
│                              │   Kubernetes    │               │
│                              │   API Server    │               │
│                              └─────────────────┘               │
│                                                                 │
│  核心思想:声明式管理 + 控制循环 + 领域知识编码                      │
│                                                                 │
└─────────────────────────────────────────────────────────────────┘

4.2 CRD与Controller关系

┌─────────────────────────────────────────────────────────────────┐
│                   CRD与Controller关系                            │
├─────────────────────────────────────────────────────────────────┤
│                                                                 │
│  CRD (Custom Resource Definition)                                │
│  ├─ 定义新的资源类型(Schema)                                    │
│  ├─ 扩展Kubernetes API                                          │
│  └─ 声明式配置接口                                               │
│                                                                 │
│  Controller (控制器)                                             │
│  ├─ 监听资源变化(Watch)                                        │
│  ├─ 调谐实际状态(Reconcile)                                    │
│  └─ 实现业务逻辑                                                 │
│                                                                 │
│  Operator = CRD + Controller(s)                                  │
│                                                                 │
└─────────────────────────────────────────────────────────────────┘

4.3 client-go架构

┌─────────────────────────────────────────────────────────────────┐
│                   client-go架构                                  │
├─────────────────────────────────────────────────────────────────┤
│                                                                 │
│  ┌─────────────┐    ┌─────────────┐    ┌─────────────┐         │
│  │   Client    │───▶│  Informer   │───▶│  WorkQueue  │         │
│  │   (RESTClient│    │  (缓存+监听)  │    │  (事件队列)  │         │
│  └─────────────┘    └──────┬──────┘    └──────┬──────┘         │
│                            │                   │               │
│                            ▼                   ▼               │
│                     ┌─────────────┐    ┌─────────────┐         │
│                     │  Indexer    │    │  Handler    │         │
│                     │  (本地缓存)  │    │  (处理逻辑)  │         │
│                     └─────────────┘    └─────────────┘         │
│                                                                 │
│  核心组件:                                                      │
│  ├─ RESTClient:底层HTTP客户端                                   │
│  ├─ Informer:监听资源变化,维护本地缓存                          │
│  ├─ WorkQueue:异步处理队列                                      │
│  └─ Indexer:本地存储索引                                        │
│                                                                 │
└─────────────────────────────────────────────────────────────────┘

五、实战项目预览

5.1 项目1:MySQL Operator

目标:开发一个管理MySQL集群的Operator

功能

  • 创建/删除MySQL集群
  • 自动配置主从复制
  • 自动故障切换
  • 定时备份

5.2 项目2:自定义Ingress控制器

目标:开发轻量级Ingress控制器

功能

  • 监听Ingress资源
  • 动态配置Nginx
  • 支持TLS终止
  • 访问日志记录

5.3 项目3:K8s资源管理CLI

目标:开发K8s资源管理工具

功能

  • 批量操作资源
  • 资源使用统计
  • 成本分析
  • 资源清理

六、学习资源

6.1 官方文档

6.2 推荐书籍

  • 《Kubernetes编程》
  • 《Kubernetes Operator开发指南》
  • 《Go语言高级编程》

6.3 开源项目参考

七、总结

云原生开发是运维工程师进阶的重要方向,通过开发Operator和自定义控制器,你可以:

  1. 将运维经验代码化:把重复性运维工作自动化
  2. 构建平台能力:为团队提供标准化的运维平台
  3. 深入理解K8s:通过开发更深入理解Kubernetes原理
  4. 提升职业竞争力:云原生开发是云时代的高薪技能

下节预告

在《Operator开发基础》中,我们将:

  • 深入了解Operator架构和工作原理
  • 学习使用Operator SDK创建项目
  • 理解控制器模式和Reconcile循环
  • 开发第一个简单的Operator

💡 学习建议

  1. 确保Go语言基础扎实,特别是接口和并发编程
  2. 在开始学习前,确保已完成K8S基础篇和进阶篇
  3. 准备充足的实验时间,云原生开发需要大量实践

评论区

专业的Linux技术学习平台,从入门到精通的完整学习路径