第一章：Go语言入门金典
Go 语言以简洁、高效和并发友好著称，是构建云原生与高并发服务的首选之一。其语法干净、编译迅速、运行时轻量，且内置强大的标准库与工具链（如 go fmt、go test、go mod），大幅降低工程化门槛。
安装与环境验证
在主流系统中，推荐通过官方二进制包或包管理器安装。以 macOS 为例（Linux/Windows 类似）：
# 下载并解压（以 Go 1.22 为例）
curl -OL https://go.dev/dl/go1.22.4.darwin-arm64.tar.gz
sudo rm -rf /usr/local/go
sudo tar -C /usr/local -xzf go1.22.4.darwin-arm64.tar.gz
# 配置环境变量（添加到 ~/.zshrc 或 ~/.bash_profile）
export PATH=$PATH:/usr/local/go/bin
export GOPATH=$HOME/go
export PATH=$PATH:$GOPATH/bin
# 验证安装
go version # 应输出类似：go version go1.22.4 darwin/arm64
go env GOROOT GOPATH # 确认路径配置正确编写第一个程序
创建 hello.go 文件，内容如下：
package main // 每个可执行程序必须有 main 包
import "fmt" // 导入标准库 fmt（格式化I/O）
func main() { // 程序入口函数，名称固定为 main
fmt.Println("Hello, 世界！") // 输出带换行的字符串
}执行命令：
go run hello.go # 直接编译并运行（不生成可执行文件）
# 或编译为二进制：
go build -o hello hello.go && ./hello核心特性速览
- 静态类型 + 类型推导：
age := 30→ 编译器自动推断为int - 无类继承，靠组合实现复用：通过结构体嵌套与方法绑定
- goroutine 与 channel：轻量级协程（
go func()）配合通道实现 CSP 并发模型 - 内存安全：自动垃圾回收，禁止指针算术，避免典型 C/C++ 内存错误
| 特性 | Go 表现 | 对比说明 |
|---|---|---|
| 错误处理 | 多返回值显式返回 error | 不使用 try/catch，强调显式检查 |
| 依赖管理 | go mod init example.com/hello |
基于语义化版本的模块化系统 |
| 接口实现 | 隐式满足（无需 implements 声明） |
接口即契约，解耦更自然 |
初学者建议从 net/http、encoding/json 和 os 等标准库模块入手，在实践中理解 Go 的“少即是多”哲学。
第二章：Kubernetes源码中高频出现的接口抽象惯用法深度溯源（附cmd/kube-apiserver/app/server.go:217等关键行号）
2.1 接口定义与鸭子类型：从pkg/api/types.go中RuntimeObject接口看Go的契约式设计
Go 不依赖继承，而靠隐式实现接口达成松耦合——这正是鸭子类型（”If it walks like a duck…”）在静态语言中的优雅落地。
RuntimeObject 接口的核心契约
// pkg/api/types.go
type RuntimeObject interface {
GetObjectKind() schema.ObjectKind
GetTypeMeta() *metav1.TypeMeta
}该接口仅声明两个方法，不约束具体结构体字段或实现方式。任何类型只要提供 GetObjectKind() 和 GetTypeMeta()，即自动满足 RuntimeObject 契约，无需显式 implements 声明。
鸭子类型的实践价值
- ✅ 解耦序列化层与业务对象（如
Pod、Deployment各自独立实现） - ✅ 支持泛型前时代的统一反射操作（
Scheme.Convert()仅依赖此接口） - ❌ 不提供运行时类型校验，需靠测试与约定保障一致性
| 特性 | 传统 OOP 接口 | Go 的 RuntimeObject |
|---|---|---|
| 实现方式 | 显式声明 | 隐式满足 |
| 类型检查时机 | 编译期强制 | 编译期推导（结构匹配） |
| 扩展灵活性 | 受限于继承树 | 任意类型自由适配 |
graph TD
A[Pod struct] -->|隐式实现| B(RuntimeObject)
C[Deployment struct] -->|隐式实现| B
D[Scheme.Encode] -->|接受参数| B2.2 空接口与类型断言：解析staging/src/k8s.io/apimachinery/pkg/runtime/scheme.go:189处Scheme.Decode调用链
Scheme.Decode 是 Kubernetes 序列化核心路径的入口，其参数 data []byte 经反序列化后返回 runtime.Object（即 interface{}）和 *schema.GroupVersionKind：
// scheme.go:189
func (s *Scheme) Decode(data []byte, defaultGVK *schema.GroupVersionKind, into runtime.Object) (runtime.Object, *schema.GroupVersionKind, error) {
// ... 实际解码逻辑
obj, gvk, err := s.unsafeDecode(data, defaultGVK, into)
if err != nil {
return nil, nil, err
}
// 类型断言：确保返回对象满足 runtime.Object 接口
if _, ok := obj.(runtime.Object); !ok {
return nil, gvk, fmt.Errorf("decoded object is not a runtime.Object")
}
return obj, gvk, nil
}该调用链关键依赖空接口的泛型承载能力与运行时类型断言的安全校验。obj 作为 interface{} 接收任意结构体，再通过 obj.(runtime.Object) 断言强制验证是否实现 GetObjectKind() schema.ObjectKind 等方法。
类型断言的三重语义
- 安全性：失败时返回
(nil, false)，避免 panic - 合约检查：确保对象符合 Kubernetes 对象生命周期契约
- 动态分发：为后续
ConvertToVersion、DeepCopyObject提供类型上下文
| 断言形式 | 用途 | 风险 |
|---|---|---|
v.(T) |
强制转换，失败 panic | 生产环境禁用 |
v, ok := v.(T) |
安全检查 + 赋值 | 推荐用于 Decode 路径 |
switch v := x.(type) |
多类型分支处理 | 常用于 Scheme 内部路由 |
graph TD
A[Decode call] --> B[unmarshal JSON/YAML]
B --> C[NewRawObject via reflect.New]
C --> D[类型断言 obj.(runtime.Object)]
D --> E{ok?}
E -->|true| F[Return typed object]
E -->|false| G[Error: not runtime.Object]2.3 接口组合复用：剖析pkg/client/cache/reflector.go:245中Store与Lister接口的嵌套实现
数据同步机制
Reflector 通过组合 Store（增删改查）与 Lister（只读遍历）实现无锁读写分离：
type Store interface {
Add(obj interface{}) error
Delete(obj interface{}) error
List() []interface{}
}
type Lister interface {
List() []interface{}
GetIndexers() Indexer
}Store 嵌入 Lister，复用 List() 方法，避免重复实现；Lister 不含写操作，保障并发读安全。
接口嵌套关系
| 接口 | 关键方法 | 复用来源 |
|---|---|---|
Store |
Add, Delete |
— |
Lister |
List, GetIndexers |
被 Store 嵌入 |
同步流程示意
graph TD
A[Reflector.ListAndWatch] --> B[DeltaFIFO.Replace]
B --> C[Store.Add/Update/Delete]
C --> D[Lister.List 供 Informer 消费]2.4 Context-aware接口演进：追踪staging/src/k8s.io/apimachinery/pkg/watch/streamwatcher.go:62中Watcher接口的上下文注入路径
数据同步机制
StreamWatcher 在 streamwatcher.go:62 处将 context.Context 注入底层 Watcher，通过包装 watch.Interface 实现可取消监听：
func NewStreamWatcher(watchInterface watch.Interface, decoder runtime.Decoder) *StreamWatcher {
return &StreamWatcher{
watcher: watchInterface,
decoder: decoder,
result: make(chan Event, 10),
// context 未直接暴露，但由 Watch() 调用链隐式传递
}
}watch.Interface.Watch() 方法签名已从 Watch(opts metav1.ListOptions) 演进为 Watch(ctx context.Context, opts metav1.ListOptions)（v1.19+），使 cancel signal 可穿透至 HTTP transport 层。
上下文传播路径
client-go的RESTClient→Watch()→http.RoundTrip()context.WithTimeout()触发net/http底层连接中断StreamWatcher的receive()goroutine 响应<-ctx.Done()并关闭resultchannel
| 阶段 | 关键实现位置 | 上下文参与方式 |
|---|---|---|
| API 调用 | rest/client.go#Watch() |
ctx 传入 http.NewRequestWithContext() |
| 流解析 | watch/streamwatcher.go#receive() |
监听 ctx.Done() 并清理 goroutine |
graph TD
A[clientset.CoreV1().Pods().Watch(ctx)] --> B[RESTClient.Watch(ctx, opts)]
B --> C[HTTP transport with ctx]
C --> D[StreamWatcher.receive()]
D --> E{select { case <-ctx.Done(): close result }}2.5 接口零值安全实践：解析pkg/util/wait/wait.go:196中Until函数对Interface{}参数的防御性校验逻辑
Until 函数接受 func() 类型的 f 参数，但其底层签名实际为 func() interface{} —— 这一设计暴露了接口零值风险。
零值陷阱与校验动机
Go 中 interface{} 的零值是 nil，若传入 nil 函数，运行时 panic：panic: call of nil function。Kubernetes 在 wait.Until 中显式拦截该场景：
// pkg/util/wait/wait.go:196
if f == nil {
panic("nil function passed to Until")
}此校验在调用前立即触发，避免延迟到 goroutine 启动后才崩溃，提升可观测性与调试效率。
校验策略对比
| 策略 | 时机 | 安全性 | 可维护性 |
|---|---|---|---|
| 运行时反射检查 | 每次调用前 | ✅ 高 | ❌ 低（开销大） |
| 编译期类型约束 | Go 1.18+ generics | ✅✅ 最高 | ✅ 高 |
| 静态 nil 判定 | 初始化路径 | ✅ 高、零开销 | ✅ 显式清晰 |
核心逻辑流
graph TD
A[Until called] --> B{f == nil?}
B -->|Yes| C[Panic with message]
B -->|No| D[Start goroutine]
D --> E[Loop: f()]第三章：结构体嵌入与匿名字段驱动的可扩展性模式溯源（附pkg/apis/core/v1/types.go:3120等核心定义）
3.1 匿名字段继承与方法提升：解构pkg/apis/meta/v1/types.go中ObjectMeta嵌入机制及其在Pod结构中的传播效应
Go 语言的匿名字段（嵌入）是 Kubernetes 类型系统实现“垂直复用”的核心机制。Pod 结构体直接嵌入 ObjectMeta，而非通过命名字段引用：
type Pod struct {
metav1.TypeMeta `json:",inline"`
metav1.ObjectMeta `json:"metadata,omitempty" protobuf:"bytes,1,opt,name=metadata"`
Spec PodSpec `json:"spec,omitempty" protobuf:"bytes,2,opt,name=spec"`
Status PodStatus `json:"status,omitempty" protobuf:"bytes,3,opt,name=status"`
}该嵌入使 Pod 实例可直接调用 ObjectMeta 的所有字段（如 Name, Namespace, Labels）和方法（如 GetLabels()），无需 pod.ObjectMeta.Labels —— 编译器自动提升。
方法提升的本质
- 编译器将嵌入类型的方法集并入外层类型方法集；
Pod类型自动获得metav1.ObjectMeta的全部方法（含GetAnnotations(),SetResourceVersion()等）；- 提升不可覆盖：若
Pod自定义同名方法，则优先使用Pod自身方法。
嵌入传播链示意
graph TD
A[Pod] --> B[ObjectMeta]
B --> C[TypeMeta]
B --> D[CommonEmbeddedStruct]| 特性 | ObjectMeta 嵌入效果 | 影响范围 |
|---|---|---|
| 字段访问 | pod.Name 直接有效 |
所有客户端、序列化、校验逻辑 |
| 方法调用 | pod.GetOwnerReferences() 可用 |
控制器/Admission Webhook 通用处理 |
| JSON 序列化 | json:",inline" 消除嵌套层级 |
API Server 存储与 REST 响应扁平化 |
3.2 嵌入式接口与组合优先原则：分析staging/src/k8s.io/client-go/tools/cache/controller.go:128中Controller结构对ProcessorListener的嵌入设计
Controller 并未直接嵌入 ProcessorListener，而是通过组合其依赖组件（如 processor *sharedProcessor）间接实现事件分发能力。这种设计严格遵循 Go 的组合优先原则。
数据同步机制
Controller 结构体在第128行定义时嵌入了 cache.Controller 接口（非 ProcessorListener），而后者由 sharedIndexInformer 实例持有并委托给 processor：
// controller.go:128（简化）
type Controller struct {
cache.Controller // 嵌入标准控制器接口
processor *sharedProcessor // 组合而非嵌入ProcessorListener
}
cache.Controller是控制循环抽象；ProcessorListener是sharedProcessor内部用于注册回调的接口类型，不被直接嵌入——避免接口污染与职责混淆。
设计权衡对比
| 维度 | 直接嵌入 ProcessorListener |
当前组合方式 |
|---|---|---|
| 职责清晰度 | 降低（监听逻辑侵入控制器） | 高（关注点分离） |
| 可测试性 | 差（强耦合） | 优（可 mock sharedProcessor） |
graph TD
A[Controller.Run] --> B[reflector.ListAndWatch]
B --> C[DeltaFIFO.Pop]
C --> D[sharedProcessor.distribute]
D --> E[ProcessorListener.OnAdd/OnUpdate]该流程印证：事件消费路径由 sharedProcessor 统一调度，Controller 仅专注协调，体现正交设计哲学。
3.3 嵌入带来的零值语义陷阱：定位pkg/scheduler/framework/runtime/framework.go:156中PluginFactory函数签名中嵌入结构体的初始化盲区
零值嵌入的隐式风险
Go 中嵌入结构体（struct{ PluginFactory }）不触发其字段初始化，导致 PluginFactory 类型的零值（nil 函数指针）被静默继承。
关键代码片段
// pkg/scheduler/framework/runtime/framework.go:156
type PluginFactory func(PluginArgs) (framework.Plugin, error)
func NewFramework(...) *Framework {
return &Framework{
pluginFactories: map[string]PluginFactory{}, // ✅ 显式初始化
// ... 其他字段
}
}此处
PluginFactory是函数类型别名，非结构体；但若某中间结构体type Config struct { PluginFactory }被嵌入，则Config{}构造时PluginFactory字段为nil—— 调用即 panic。
初始化盲区对比表
| 场景 | 是否触发初始化 | 运行时行为 |
|---|---|---|
Config{PluginFactory: myFactory} |
✅ 显式赋值 | 安全调用 |
Config{}（含嵌入） |
❌ 零值继承 | nil 函数调用 panic |
修复路径
- 禁止直接嵌入函数类型别名
- 使用
*PluginFactory指针 + 构造函数校验 - 在
NewFramework中对嵌入字段做nil断言
第四章：错误处理与错误链构建的工业级实践溯源（附staging/src/k8s.io/apimachinery/pkg/api/errors/status.go:112等关键路径）
4.1 错误类型分层建模：从pkg/api/errors/errors.go:35开始追溯BadRequestError、NotFoundError等具体错误类型的构造范式
核心接口定义
errors.go 第35行起定义了 APIError 接口，统一抽象错误的 HTTP 状态码、业务码与可序列化消息：
type APIError interface {
Error() string
StatusCode() int
ErrorCode() string
Details() map[string]interface{}
}该接口使所有业务错误具备标准化响应能力，是分层建模的契约基石。
具体错误类型构造范式
所有子类型均通过组合 baseError 实现，例如：
type BadRequestError struct {
baseError
}
func NewBadRequestError(msg string, details ...map[string]interface{}) *BadRequestError {
return &BadRequestError{
baseError{code: "BAD_REQUEST", status: http.StatusBadRequest, message: msg, details: mergeDetails(details...)},
}
}baseError 封装共性字段（code, status, message, details），子类型仅声明语义身份，符合“组合优于继承”原则。
错误类型映射关系
| 错误类型 | HTTP 状态码 | ErrorCode |
|---|---|---|
| BadRequestError | 400 | BAD_REQUEST |
| NotFoundError | 404 | NOT_FOUND |
| InternalError | 500 | INTERNAL_ERROR |
构造流程示意
graph TD
A[NewBadRequestError] --> B[初始化baseError]
B --> C[注入ErrorCode/BAD_REQUEST]
C --> D[绑定HTTP状态码400]
D --> E[返回APIError接口实例]4.2 errors.Is与errors.As的Kubernetes定制化适配：解析staging/src/k8s.io/apimachinery/pkg/util/wait/wait.go:224中对WrappedError的递归展开逻辑
Kubernetes 的 wait.Until 等重试逻辑依赖精准错误分类，而原生 errors.Is/errors.As 在嵌套 WrappedError（如 &wrapError{err: underlying}）场景下无法自动解包。
递归展开的核心逻辑
// wait.go:224 节选（简化）
func isRetryable(err error) bool {
var opErr *net.OpError
if errors.As(err, &opErr) && opErr.Err != nil {
return isRetryable(opErr.Err) // ✅ 显式递归穿透
}
return errors.Is(err, context.DeadlineExceeded) ||
errors.Is(err, context.Canceled)
}该函数绕过标准 errors.As 的单层匹配，手动递归调用自身，确保穿透任意深度的 Unwrap() 链。
与标准库的关键差异
| 特性 | 标准 errors.As |
Kubernetes wait 实现 |
|---|---|---|
| 展开深度 | 仅一层 Unwrap() |
手动递归至叶子错误 |
| 类型匹配时机 | 匹配失败即终止 | 每层 Unwrap() 后均尝试 As |
错误穿透流程
graph TD
A[Root WrappedError] --> B[Unwrap→OpError]
B --> C[Unwrap→syscall.Errno]
C --> D[匹配 context.DeadlineExceeded?]4.3 HTTP状态码到Go错误的精准映射：追踪staging/src/k8s.io/apimachinery/pkg/api/errors/doc.go:42定义的StatusError体系与REST API响应的双向转换
Kubernetes 的 StatusError 是 error 接口的实现，封装 metav1.Status 并携带原始 HTTP 状态码，构成 REST 客户端错误处理的核心抽象。
StatusError 的构造逻辑
// pkg/api/errors/errors.go
func NewGenericServerResponse(code int, verb, resource string, name string, serverMessage string, retryAfter int, isUnexpected bool) *StatusError {
status := metav1.Status{
Status: metav1.StatusFailure,
Code: int32(code),
Reason: metav1.StatusReasonServerTimeout,
Message: serverMessage,
}
return &StatusError{ErrStatus: status, Code: code}
}该函数将 HTTP code（如 503）注入 Status.Code（int32）与 StatusError.Code（int），确保下游可按 HTTP 语义分流（如 if err.Code == http.StatusConflict）。
双向转换关键路径
- HTTP → Go：
RESTClient.Do().Get().StatusCode→decodeStatus()→NewStatusError() - Go → HTTP：
StatusError.ErrStatus序列化为 JSON 响应体，Code决定http.ResponseWriter.WriteHeader()
| HTTP 状态码 | Status.Reason | 典型 Go 错误检查方式 |
|---|---|---|
| 404 | NotFound | errors.IsNotFound(err) |
| 409 | Conflict | errors.IsConflict(err) |
| 422 | Invalid | errors.IsInvalid(err) |
graph TD
A[HTTP Response] -->|statusCode + body| B[Decoder.decodeStatus]
B --> C[metav1.Status]
C --> D[StatusError]
D --> E[errors.IsNotFound/IsConflict...]4.4 错误上下文注入与诊断增强：剖析pkg/util/validation/validate.go:48中ValidatePodSpec函数如何通过fmt.Errorf(“%w: %s”)构建可追溯错误链
错误链的核心动机
Kubernetes 验证层需区分“根本原因”与“调用路径上下文”。%w 动词启用 Go 1.13+ 的 error wrapping，保留原始错误类型与堆栈线索，同时叠加语义化描述。
关键代码片段
if err := validateContainers(pod.Spec.Containers); err != nil {
return fmt.Errorf("invalid pod containers: %w", err) // ← 上下文注入点
}%w：包裹原始err，使errors.Is()和errors.As()仍可穿透识别底层错误（如ErrInvalidName）；"invalid pod containers: "：提供高阶业务上下文，明确失效域，辅助运维定位。
错误传播效果对比
| 方式 | 可追溯性 | 类型保真 | 诊断友好度 |
|---|---|---|---|
fmt.Errorf("...: %v", err) |
❌（丢失包装） | ❌（转为字符串） | ⚠️（仅消息） |
fmt.Errorf("...: %w", err) |
✅（errors.Unwrap() 链式访问） |
✅（底层类型不变） | ✅（结构化上下文+原始错误） |
graph TD
A[ValidatePodSpec] --> B[validateContainers]
B --> C{valid?}
C -->|no| D[return ErrInvalidContainer]
C -->|yes| E[success]
A -->|wrap| F[fmt.Errorf “invalid pod containers: %w”]
F --> D第五章：Go语言入门金典
为什么选择Go作为云原生开发首选
Go语言自2009年发布以来，已成为Docker、Kubernetes、Terraform等核心基础设施项目的主力语言。其静态编译、无依赖二进制分发、原生协程（goroutine）与通道（channel）模型，天然适配高并发微服务场景。某电商中台团队将Java订单服务重构为Go后，单实例QPS从1200提升至4800，内存占用下降63%，部署包体积从126MB压缩至9.2MB。
快速启动一个HTTP微服务
以下是一个生产就绪的最小API服务示例，集成日志、超时控制与JSON响应：
package main
import (
"encoding/json"
"log"
"net/http"
"time"
)
type Order struct {
ID string `json:"id"`
Amount float64 `json:"amount"`
CreatedAt time.Time `json:"created_at"`
}
func handler(w http.ResponseWriter, r *http.Request) {
w.Header().Set("Content-Type", "application/json")
w.WriteHeader(http.StatusOK)
json.NewEncoder(w).Encode(Order{
ID: "ORD-789456",
Amount: 299.99,
CreatedAt: time.Now(),
})
}
func main() {
http.HandleFunc("/order", handler)
log.Println("Server starting on :8080")
log.Fatal(http.ListenAndServe(":8080", nil))
}并发安全的计数器实战
使用sync.Mutex与sync/atomic两种方案对比：
| 方案 | CPU缓存行友好性 | GC压力 | 适用场景 |
|---|---|---|---|
sync.Mutex |
中等 | 低 | 复杂状态更新（如结构体字段批量修改） |
atomic.Int64 |
高 | 极低 | 单一整型计数（如请求总量统计） |
// atomic方案（推荐用于指标采集）
var requestCount atomic.Int64
func increment() {
requestCount.Add(1)
}
func getCount() int64 {
return requestCount.Load()
}模块化依赖管理最佳实践
Go Modules要求明确声明依赖版本。在go.mod中应禁用replace指令用于生产环境，并启用校验和验证：
# 初始化模块（指定Go版本）
go mod init github.com/myorg/payment-service
go mod tidy
go mod verify # 验证所有依赖校验和错误处理的工程化模式
避免if err != nil嵌套地狱，采用错误包装与分类处理：
import "fmt"
var ErrInvalidAmount = fmt.Errorf("invalid amount")
func processPayment(amount float64) error {
if amount <= 0 {
return fmt.Errorf("payment amount must be positive: %w", ErrInvalidAmount)
}
return nil
}性能调优关键配置
通过GOGC与GOMAXPROCS参数优化GC行为与并行度：
# 生产环境典型设置（4核CPU，内存敏感型服务）
export GOGC=20 # GC触发阈值设为20%，降低停顿频率
export GOMAXPROCS=4 # 限制P数量匹配物理核心数实战：构建可观察性友好的服务
集成OpenTelemetry自动注入trace与metrics：
go get go.opentelemetry.io/otel/sdk/metric
go get go.opentelemetry.io/otel/exporters/stdout/stdoutmetric启动时注入全局tracer provider，所有HTTP handler自动携带span上下文，无需修改业务逻辑。
工具链生态成熟度验证
| 工具 | 版本兼容性 | 生产就绪度 | 典型用途 |
|---|---|---|---|
golangci-lint |
Go 1.18+ | ★★★★★ | 静态检查（含12种linter） |
pprof |
内置 | ★★★★★ | CPU/内存/阻塞分析 |
delve |
v1.8+ | ★★★★☆ | 远程调试（支持goroutine堆栈快照） |
测试驱动开发工作流
使用testify/assert编写表驱动测试，覆盖边界条件：
func TestCalculateDiscount(t *testing.T) {
tests := []struct {
input float64
expected float64
}{
{100.0, 90.0}, // 10% discount
{0.0, 0.0}, // zero case
{-50.0, 0.0}, // negative input
}
for _, tt := range tests {
t.Run(fmt.Sprintf("input_%f", tt.input), func(t *testing.T) {
assert.Equal(t, tt.expected, calculateDiscount(tt.input))
})
}
}持续交付流水线设计
GitHub Actions示例，包含跨平台构建、安全扫描与镜像推送：
- name: Build multi-arch binaries
run: |
docker buildx build \
--platform linux/amd64,linux/arm64 \
--output type=image,name=myorg/payment:v1.2.0,push=true \
.
- name: Run SAST scan
uses: securego/gosec@v2.12.0
with:
args: ./...