Kubernetes 源码深度解析：从架构设计到核心机制实现

tianyamingyue1993

958人浏览 · 2026-03-01 14:09:55

tianyamingyue1993 · 2026-03-01 14:09:55 发布

Kubernetes 源码深度解析：从架构设计到核心机制实现

引言

Kubernetes 作为容器编排领域的事实标准，其复杂而精妙的架构设计背后蕴含着丰富的技术实现细节。深入理解 Kubernetes 源码不仅是掌握容器编排技术的关键，更是成为云原生领域专家的必经之路。本报告将从源码角度全面解析 Kubernetes 的核心组件架构、工作机制和实现原理，为技术人员提供系统性的学习指导。

当前，Kubernetes 已发布到 v1.35.1 版本（2026 年 2 月 10 日发布），该版本引入了多项重要特性，包括 Pod 资源就地更新功能毕业为稳定版（GA）、节点级路由偏好功能、受限的身份扮演特性等(41)。本报告将基于当前主流版本的源码，深入剖析各个核心组件的实现机制，涵盖 API Server、Scheduler、Controller Manager、Kubelet 等关键组件，并重点关注 Pod 调度、网络策略、存储管理等核心功能的源码实现。

一、版本定位与环境搭建

1.1 当前主流版本分析

Kubernetes 采用 语义版本控制 策略，版本号格式为 x.y.z，其中 x 是主要版本，y 是次要版本，z 是补丁版本。截至 2026 年 2 月，Kubernetes 维护最近三个次要版本：1.35、1.34 和 1.33，这三个版本均处于支持状态。

具体版本支持情况如下：

版本	最新补丁版本	发布日期	停止支持日期	当前状态
v1.35	1.35.1	2026-02-10	2027-02-28	支持中
v1.34	1.34.4	2026-02-10	2026-10-27	支持中
v1.33	1.33.8	2026-02-10	2026-06-28	支持中
v1.32	1.32.12	2026-02-10	2026-02-28	即将停止支持

v1.35 版本的重要更新包括：Pod 资源就地更新功能现已毕业为稳定版（GA），允许调整 CPU 和内存资源而无需重启 Pod；Service 新增节点级路由偏好功能，优先调度本地端点；引入受限的身份扮演（Constrained Impersonation）特性；扩展 Toleration 支持数值比较运算符（Gt、Lt）；引入 GangScheduling 调度器插件等(41)。

1.2 开发环境配置要求

Kubernetes 1.35 版本的构建环境要求 Go 1.25.7 版本。开发环境配置建议如下：

操作系统要求：

Linux 系统（推荐 Ubuntu 20.04 或更高版本）
macOS（需要 Docker Desktop for Mac，建议设置至少 8GB 初始内存）
Windows（需要 Docker Desktop WSL2 后端）

依赖工具：

Docker：用于容器化构建环境，需要确保 Docker CLI plugin buildx 正确安装
Go 语言环境：Go 1.25.x 版本，需要正确设置 GOPATH 和 GOROOT
Git：用于克隆 Kubernetes 源码仓库
make：用于执行构建脚本

构建环境准备：

\# 下载并安装 Go 1.25.7

wget https://go.dev/dl/go1.25.7.linux-amd64.tar.gz

sudo tar -C /usr/local -xzf go1.25.7.linux-amd64.tar.gz

\# 设置环境变量

export GOROOT=/usr/local/go

export GOPATH=\$HOME/go

export PATH=\$GOPATH/bin:\$GOROOT/bin:\$PATH

\# 验证安装

go version

1.3 源码获取与构建

Kubernetes 源码托管在 GitHub 上，获取源码的标准方式是使用 Git 克隆官方仓库：

\# 克隆 Kubernetes 源码仓库

git clone https://github.com/kubernetes/kubernetes.git

cd kubernetes

Kubernetes 提供了 容器化构建环境，这是推荐的构建方式，因为它简化了初始设置并提供了非常一致的构建和测试环境。主要构建脚本位于 build/ 目录下：

核心构建脚本：

build/``run.sh：在构建 Docker 容器中运行命令
build/``make-clean.sh：清理构建产物
build/``shell.sh：进入构建容器的 shell

常用构建命令：

\# 在容器中构建 Linux 二进制文件

build/run.sh make

\# 构建所有平台的二进制文件

build/run.sh make cross

\# 构建特定平台的 kubectl

build/run.sh make kubectl KUBE\_BUILD\_PLATFORMS=darwin/amd64

\# 运行所有单元测试

build/run.sh make test

\# 运行集成测试

build/run.sh make test-integration

\# 构建 release 版本

build/run.sh make release

构建产物输出到源码仓库顶层的 _output/ 目录，包括编译的二进制包（如 kubectl、kube-scheduler 等）和归档的 Docker 镜像。

1.4 源码目录结构概览

Kubernetes 源码采用 模块化和组织化 的结构来管理其复杂性。核心目录结构如下：

目录	功能描述
`cmd/`	各种 Kubernetes 二进制文件的入口点，如 kubelet、kubeadm、kubectl
`pkg/`	包含不同组件共享的可重用包
`staging/`	用于暂存依赖项，这些依赖项后来会被提升为独立的仓库（如 client-go）
`test/`	包括端到端测试、集成测试和其他测试工具
`vendor/`	包含使用 go mod 管理的 vendored 依赖项
`api/`	API 对象定义
`plugin/`	各种插件实现

各组件源码位置：

API Server：cmd/kube-apiserver/ 和 pkg/apiserver/
Scheduler：cmd/kube-scheduler/ 和 pkg/scheduler/
Controller Manager：cmd/kube-controller-manager/ 和 pkg/controller/
Kubelet：cmd/kubelet/ 和 pkg/kubelet/
Kube-proxy：cmd/kube-proxy/ 和 pkg/proxy/

二、整体架构概览与启动流程

2.1 核心组件架构设计

Kubernetes 集群由 控制平面（Control Plane） 和 工作节点（Worker Nodes） 组成。控制平面负责对集群做出全局决策（如调度），以及检测和响应集群事件（如当 Deployment 的 replicas 字段不满足时启动新的 Pod）。工作节点托管运行应用程序工作负载组件的 Pod。

控制平面核心组件：

kube-apiserver：作为 Kubernetes 控制平面的前端，是 Kubernetes HTTP API 的核心组件服务器。它设计为支持水平扩展，即通过部署更多实例来扩展(54)。
etcd：一个一致且高可用的键值存储，用于保存 API 服务器的所有数据，是集群所有数据的持久化存储(55)。
kube-scheduler：监控未绑定到节点的 Pod，并将每个 Pod 分配给合适的节点。调度决策考虑的因素包括资源需求、硬件 / 软件 / 策略约束、亲和性和反亲和性规范、数据本地性等(55)。
kube-controller-manager：运行各种控制器来实现 Kubernetes API 的操作。逻辑上每个控制器是一个独立的进程，但为了降低复杂性，所有控制器都编译在一个二进制文件中并在同一个进程中运行(55)。
cloud-controller-manager（可选）：嵌入特定于云的控制逻辑，允许将集群连接到云提供商的 API，将与云平台交互的组件与仅与集群交互的组件分离。

节点组件：

kubelet：确保包含容器的 Pod 正常运行
kube-proxy（可选）：维持节点上的网络规则并实现 Service
容器运行时：负责运行容器的软件

2.2 组件间通信机制

Kubernetes 采用 “中心辐射”（hub-and-spoke）API 模式，所有来自节点（或它们运行的 Pod）的 API 使用都终止于 API 服务器。没有其他控制平面组件被设计为暴露远程服务。

通信安全机制：

API 服务器配置为在安全的 HTTPS 端口（通常是 443）上监听远程连接，启用一种或多种形式的客户端认证
节点应该配置有集群的公共根证书，以便它们可以使用有效的客户端凭证安全地连接到 API 服务器
Pod 可以通过服务账户安全地连接到 API 服务器，Kubernetes 会在 Pod 实例化时自动注入公共根证书和有效的 bearer token

控制平面到节点的通信路径：

API Server 到 Kubelet：用于获取 Pod 日志、附加到运行中的 Pod、提供 Kubelet 的端口转发功能。这些连接终止于 Kubelet 的 HTTPS 端点。
API Server 到节点、Pod 和服务：默认使用普通 HTTP 连接，因此既不认证也不加密。可以通过在 API URL 中将节点、Pod 或服务名称前缀为 https: 来在安全的 HTTPS 连接上运行，但不会验证 HTTPS 端点提供的证书，也不会提供客户端凭证。

2.3 启动流程分析

Kubernetes 各组件的启动流程具有相似的模式，都使用 Cobra 命令行框架 进行初始化(79)：

func main() {

    command := app.NewAPIServerCommand()

    code := cli.Run(command)

    os.Exit(code)

}

通用启动流程：

设置全局随机数种子
初始化命令行标志
初始化日志系统
解析命令行参数
创建并初始化主组件对象
启动各种 informer 监听资源变化
启动主运行循环

以 API Server 为例，其启动流程的核心代码位于 cmd/kube-apiserver/apiserver.go：

func main() {

    rand.Seed(time.Now().UnixNano())

    s := options.NewAPIServer()

    s.AddFlags(pflag.CommandLine)

    flag.InitFlags()

    logs.InitLogs()

    defer logs.FlushLogs()

    verflag.PrintAndExitIfRequested()

    

    if err := app.Run(s); err != nil {

        fmt.Fprintf(os.Stderr, "%v\n", err)

        os.Exit(1)

    }

}

在 app.Run(s) 方法中，会进行以下关键步骤：

验证 etcd 服务器列表
初始化 GenericAPIServer
组装 Master 配置（包括 SSH 隧道配置、存储工厂配置、认证器配置和授权器配置等）
创建并启动 Master
启动共享 informer

各组件启动顺序：

etcd：提供分布式键值存储服务
kube-apiserver：提供 API 服务，处理集群中的所有操作
kube-controller-manager：通过控制循环来管理集群的状态
kube-scheduler：调度容器到节点上运行

这种启动顺序确保了核心基础设施（etcd 和 API Server）首先启动，然后是负责集群管理的控制组件。

三、API Server 源码深度解析

3.1 RESTful API 实现机制

API Server 是 Kubernetes 集群的 统一门户，所有外部请求都通过它进行认证、授权和路由。它使用 Go 语言的 http 包构建 HTTP 服务器，并通过 gorilla/mux 路由库实现复杂的路由逻辑(82)。

路由注册机制：

API 资源初始化完成后，需要将这些 API 资源注册为 RESTful API。API 注册的入口函数有两个：m.InstallAPIs 和 m.InstallLegacyAPI，分别注册 /api 和 /apis 的 API(98)。

路由注册遵循 go-restful 设计模式：

将处理方法注册到 Route 中
同一个根路径下的 Route 注册到 WebService 中
WebService 注册到 Container 中
Container 负责分发请求(89)

关键路由注册函数：

路由注册的核心逻辑位于 k8s.io/apiserver/pkg/endpoints/installer.go 中的 registerResourceHandlers 函数，该函数有 700 多行代码，负责将 REST-Storage 转换为一个个 Route(91)。

3.2 认证授权机制

Kubernetes API Server 实现了 三层安全控制机制：认证（Authentication）、授权（Authorization）和准入控制（Admission Control），每个请求都需要经过这三个阶段才有权限操作资源对象(106)。

认证流程：

认证阶段使用多种认证模块，包括客户端证书、密码、普通 token、bootstrap token、JWT（用于服务账户）等。当配置多个认证模块时，会依次尝试每个模块直到其中一个成功。认证失败返回 HTTP 状态码 401(101)。

认证相关源码位于 staging/src/``k8s.io/apiserver/pkg/endpoints/filters/authentication.go，核心函数是 withAuthentication，它返回带有认证功能的 HTTP Handler(96)。

授权流程：

授权阶段检查已认证的用户是否有权限执行请求的操作。Kubernetes 支持多种授权策略，包括 RBAC（基于角色的访问控制）、ABAC（基于属性的访问控制） 等(104)。

授权相关源码位于 staging/src/``k8s.io/apiserver/pkg/endpoints/filters/authorization.go，核心函数是 withAuthorization，它返回带有授权功能的 HTTP Handler(97)。

准入控制流程：

准入控制在授权完成之后发生（因此，仅在授权决定允许请求时才发生），可以在对象被持久化前后执行拦截式检查和修改，例如资源配额验证、网络策略注入、Pod 注入 sidecar 等(104)。

准入控制配置通过命令行参数 --admission-control 设置，例如：

kube-apiserver --admission-control=NamespaceLifecycle,LimitRanger,ServiceAccount,DefaultStorageClass,ResourceQuota

3.3 Watch 机制实现

Watch 机制是 Kubernetes 实现 实时状态同步 的核心技术，允许客户端持续监听资源对象的变化。Watch 机制的实现涉及多个层次：

API 层 Watch 实现：

Watch 处理程序的核心源码位于 staging/src/``k8s.io/apiserver/pkg/endpoints/handlers/watch.go，核心函数是 serveWatchHandler，它处理 HTTP Watch 请求并返回持续的数据流(108)。

存储层 Watch 实现：

底层存储的 Watch 实现位于 staging/src/``k8s.io/apiserver/pkg/storage/etcd3/watcher.go。当 etcd 中存储的对象发生变化时，Watcher 会解码变化的数据并生成相应的事件(110)。

客户端 Watch 使用：

客户端通过 client-go 的 ListWatch 机制使用 Watch 功能。ListWatch 结构体定义如下：

type ListWatch struct {

    ListFunc func() (runtime.Object, error)

    WatchFunc func(options metav1.ListOptions) (watch.Interface, error)

    DisableChunking bool

}

3.4 自定义资源定义（CRD）机制

CRD（CustomResourceDefinition）是 Kubernetes 推荐的资源扩展方式。CRD 本质是向 K8s API Server 注册自定义资源的 “契约”，定义了资源的组（Group）、版本（Version）、类别（Kind）、范围（Scope，Namespace 或 Cluster）及字段结构(115)。

CRD 定义示例：

apiVersion: apiextensions.k8s.io/v1

kind: CustomResourceDefinition

metadata:

  name: databaseclusters.database.example.com

spec:

  group: database.example.com

  versions:

    - name: v1alpha1

      served: true

      storage: true

      schema:

        openAPIV3Schema:

          type: object

          properties:

            spec:

              type: object

              required:

                - databaseType

                - replicas

              properties:

                databaseType:

                  type: string

                  enum:

                    - mysql

                    - postgresql

                    - mongodb

  scope: Namespaced

  names:

    plural: databaseclusters

    singular: databasecluster

    kind: DatabaseCluster

    shortNames:

      - db

      - dbcluster

CRD 实现原理：

基于 CRD 技术，用户能将自定义资源注册到 Kubernetes 系统，并像使用原生资源（如 Pod、StatefulSet）一样对自定义资源进行创建、查看、修改、删除等操作，实现了类似于插件式的功能增强(119)。

CRD 的核心源码位于 staging/src/``k8s.io/apiextensions-apiserver/ 目录，包括 CRD 的 API 定义、存储实现、验证逻辑等。

四、Scheduler 源码深度解析

4.1 Pod 调度流程

Kubernetes Scheduler 负责将未绑定节点的 Pod 分配到合适的 Node 上，其核心调度流程分为 预选（Predicates） 和 优选（Priorities） 两个阶段(129)。

调度流程概览：

监听与入队：监听 API Server 的 Pod 创建事件，将未调度 Pod 加入队列
调度周期：从队列取出 Pod 进行调度决策
过滤阶段（预选）：筛选符合条件的节点
评分阶段（优选）：为候选节点打分
绑定阶段：将 Pod 绑定到最优节点

调度流程的简化伪代码如下：

for pod := range unscheduledPods {

    // 阶段1：预选

    feasibleNodes := filterNodes(pod, allNodes)

    

    // 阶段2：优选

    priorityList := prioritize(pod, feasibleNodes)

    

    // 绑定

    bind(pod, selectHost(priorityList))

}

4.2 调度算法实现

核心调度逻辑位于 pkg/scheduler/core/generic_scheduler.go 中的 Schedule 函数(122)。该函数实现了完整的调度流程：

func (g \*GenericScheduler) Schedule(ctx context.Context, extenders []framework.Extender, state \*framework.CycleState, pod \*v1.Pod) (result ScheduleResult, err error) {

    // 1. 获取节点快照

    nodeInfoSnapshot := g.nodeInfoSnapshot

    

    // 2. 执行预过滤插件

    status := g.framework.RunPreFilterPlugins(ctx, state, pod)

    if !status.IsSuccess() {

        return result, status.AsError()

    }

    

    // 3. 过滤阶段

    feasibleNodes, err := g.findNodesThatFit(ctx, state, pod)

    if err != nil {

        return result, err

    }

    

    // 4. 后过滤（抢占）

    if len(feasibleNodes) == 0 {

        feasibleNodes, err = g.runPostFilterPlugins(ctx, state, pod, feasibleNodes)

    }

    

    // 5. 执行预评分插件

    if status := g.framework.RunPreScorePlugins(ctx, state, pod, feasibleNodes); !status.IsSuccess() {

        return result, status.AsError()

    }

    

    // 6. 评分阶段

    priorityList, err := g.prioritizeNodes(ctx, state, pod, feasibleNodes)

    if err != nil {

        return result, err

    }

    

    // 7. 选择最优节点

    host, err := g.selectHost(priorityList)

    

    return ScheduleResult{SuggestedHost: host}, nil

}

4.3 调度框架与插件机制

Kubernetes 1.15 引入的 调度框架（Scheduler Framework） 将调度过程分解为多个扩展点，实现了高度模块化。调度框架定义了 11 个扩展点，覆盖调度全生命周期：

type Framework interface {

    RunPreFilterPlugins(ctx context.Context, state \*CycleState, pod \*v1.Pod) \*Status

    RunFilterPlugins(ctx context.Context, state \*CycleState, pod \*v1.Pod, nodeInfo \*NodeInfo) \*Status

    RunPostFilterPlugins(ctx context.Context, state \*CycleState, pod \*v1.Pod, filteredNodeStatusMap NodeToStatusMap) \*Status

    RunPreScorePlugins(ctx context.Context, state \*CycleState, pod \*v1.Pod, nodes []\*v1.Node) \*Status

    RunScorePlugins(ctx context.Context, state \*CycleState, pod \*v1.Pod, nodes []\*v1.Node) (PluginToNodeScores, \*Status)

    RunPreBindPlugins(ctx context.Context, state \*CycleState, pod \*v1.Pod, nodeName string) \*Status

    RunBindPlugins(ctx context.Context, state \*CycleState, pod \*v1.Pod, nodeName string) \*Status

    RunPostBindPlugins(ctx context.Context, state \*CycleState, pod \*v1.Pod, nodeName string)

    // ... 其他扩展点

}

内置插件注册：

内置插件在 pkg/scheduler/framework/plugins/registry.go 中注册，包括：

队列排序插件：queuesort、prioritysort
过滤插件：noderesources、nodeaffinity、tainttoleration
评分插件：noderesources、imagelocality、interpodaffinity、podtopologyspread

4.4 节点亲和性与反亲和性

节点亲和性和反亲和性是 Kubernetes 调度器实现 高级拓扑约束 的重要机制。

节点亲和性实现：

节点亲和性通过 pkg/scheduler/framework/plugins/nodeaffinity 包实现，核心过滤函数是 Filter：

func (pl \*NodeAffinity) Filter(ctx context.Context, state \*framework.CycleState, pod \*v1.Pod, nodeInfo \*framework.NodeInfo) \*framework.Status {

    node := nodeInfo.Node()

    if pod.Spec.Affinity != nil && pod.Spec.Affinity.NodeAffinity != nil {

        nodeAffinity := pod.Spec.Affinity.NodeAffinity

        

        // 检查硬性要求

        if nodeAffinity.RequiredDuringSchedulingIgnoredDuringExecution != nil {

            terms := nodeAffinity.RequiredDuringSchedulingIgnoredDuringExecution.NodeSelectorTerms

            if !v1helper.MatchNodeSelectorTerms(node, terms) {

                return framework.NewStatus(framework.UnschedulableAndUnresolvable, "node(s) didn't match node selector")

            }

        }

        

        // 检查软性要求（影响评分）

        // ...

    }

    return framework.NewStatus(framework.Success)

}

Pod 间亲和性 / 反亲和性：

Pod 间亲和性通过 pkg/scheduler/framework/plugins/interpodaffinity 包实现，支持复杂的拓扑约束：

func (pl \*InterPodAffinity) Filter(ctx context.Context, state \*framework.CycleState, pod \*v1.Pod, nodeInfo \*framework.NodeInfo) \*framework.Status {

    node := nodeInfo.Node()

    

    // 检查反亲和性

    if !satisfyPodAntiAffinity(pod, nodeInfo, pl) {

        return framework.NewStatus(framework.Unschedulable, "node(s) didn't satisfy pod anti-affinity")

    }

    

    // 检查亲和性

    if !satisfyPodAffinity(pod, nodeInfo, pl) {

        return framework.NewStatus(framework.Unschedulable, "node(s) didn't satisfy pod affinity")

    }

    

    return framework.NewStatus(framework.Success)

}

4.5 调度队列管理

调度器使用 多级优先级队列 管理待调度的 Pod，确保高优先级 Pod 优先调度。队列实现位于 pkg/scheduler/internal/queue/scheduling_queue.go。

队列管理特性：

优先级排序：基于 Pod 的 PriorityClass 值排序
退避机制：调度失败的 Pod 会进入退避队列，避免频繁重试
不可调度处理：暂时无法调度的 Pod 单独存储
事件触发：节点资源变化时重新评估不可调度 Pod

队列使用 Go 语言的 container/heap 包实现最小堆结构，确保每次取出的都是优先级最高的 Pod。

五、Controller Manager 源码深度解析

5.1 控制器模式实现

Controller Manager 是一个 永不停息的控制回路组件，负责控制集群资源的状态。通过监控 kube-apiserver 的资源状态，比较当前资源状态和期望状态，如果不一致，更新 kube-apiserver 的资源状态以保持两者一致(151)。

控制器模式核心原理：

每个资源都有相应的控制器（Controller）来实现这个控制循环，比如管理节点资源的 NodeController，管理 Deployment 的 DeploymentController。kube-controller-manager 的主要职责就是启动和管理这些 Controller(150)。

控制器模式基于 Informer/Reflector + 控制循环 的架构：

Informer 机制：通过 Reflector 监听 API Server 的资源变化
Delta FIFO 队列：存储待处理对象
WorkQueue：存储所有待处理对象的 key
控制循环：不断从队列中取出对象进行处理

5.2 工作队列机制

WorkQueue 是控制器实现的核心组件，位于 client-go/util/workqueue 包中，支持延迟队列、定时队列和速率限制队列(157)。

工作队列类型：

普通队列：FIFO 队列，先进先出
延迟队列：支持延迟处理
定时队列：支持定时处理
速率限制队列：限制处理频率

以 Deployment Controller 为例，其工作队列初始化代码：

queue: workqueue.NewNamedRateLimitingQueue(workqueue.DefaultControllerRateLimiter(), "deployment"),

5.3 各类控制器实现

Controller Manager 包含多种控制器，每种控制器负责特定资源的状态管理。以下是主要控制器的实现分析：

ReplicaSet 控制器：

ReplicaSet 控制器的核心逻辑位于 pkg/controller/replicaset/replica_set.go，其 syncReplicaSet 函数实现了控制循环：

func (rsc \*ReplicaSetController) syncReplicaSet(ctx context.Context, key string) error {

    namespace, name, err := cache.SplitMetaNamespaceKey(key)

    if err != nil {

        return err

    }

    

    // 获取 ReplicaSet 对象

    rs, err := rsc.rsLister.ReplicaSets(namespace).Get(name)

    if apierrors.IsNotFound(err) {

        return nil

    }

    if err != nil {

        return err

    }

    

    // 获取所有 Pod

    allPods, err := rsc.podLister.Pods(rs.Namespace).List(labels.Everything())

    if err != nil {

        return err

    }

    

    // 过滤活跃的 Pod

    filteredPods := controller.FilterActivePods(klog.FromContext(ctx), allPods)

    

    // 获取属于该 ReplicaSet 的 Pod

    selector, err := metav1.LabelSelectorAsSelector(rs.Spec.Selector)

    if err != nil {

        return err

    }

    filteredPods, err = rsc.claimPods(ctx, rs, selector, filteredPods)

    if err != nil {

        return err

    }

    

    // 管理副本数

    if rsNeedsSync && rs.DeletionTimestamp == nil {

        if err := rsc.manageReplicas(ctx, filteredPods, rs); err != nil {

            return err

        }

    }

    

    // 更新状态

    newStatus := calculateStatus(rs, filteredPods, manageReplicasErr)

    if \_, err := updateReplicaSetStatus(klog.FromContext(ctx), rsc.kubeClient.AppsV1().ReplicaSets(rs.Namespace), rs, newStatus); err != nil {

        return err

    }

    

    return nil

}

Deployment 控制器：

Deployment 控制器通过 Informer 监听 Deployment 对象的增删改，当发现新的 Deployment 创建时，将其加入工作队列，控制器的 worker 从队列取出任务并执行同步操作(155)。

5.4 控制器协调机制

Controller Manager 实现了 Leader Election（领导者选举） 机制，确保在多副本部署时只有一个实例处于活动状态。

Leader Election 核心逻辑：

func Run(ctx context.Context, c \*config.CompletedConfig) error {

    // ... 省略其他代码

    

    if !c.ComponentConfig.Generic.LeaderElection.LeaderElect {

        // 无 Leader Election，直接运行

        controllerDescriptors := NewControllerDescriptors()

        controllerDescriptors[names.ServiceAccountTokenController] = saTokenControllerDescriptor

        run(ctx, controllerDescriptors)

        return nil

    }

    

    // 启动 Leader Election

    leaderElector, err := leaderelection.NewLeaderElector(leaderelection.LeaderElectionConfig{

        Lock:          c.ClientBuilder.ClientOrDie("leader-election").CoreV1().Endpoints(metav1.NamespaceSystem),

        LeaseDuration: c.ComponentConfig.Generic.LeaderElection.LeaseDuration.Duration,

        RenewDeadline: c.ComponentConfig.Generic.LeaderElection.RenewDeadline.Duration,

        RetryPeriod:   c.ComponentConfig.Generic.LeaderElection.RetryPeriod.Duration,

        Callbacks: leaderelection.LeaderCallbacks{

            OnStartedLeading: func(ctx context.Context) {

                run(ctx, NewControllerDescriptors())

            },

            OnStoppedLeading: func() {

                klog.Fatalf("leaderelection lost")

            },

        },

    })

    

    leaderElector.Run(ctx)

    return nil

}

六、Kubelet 源码深度解析

6.1 Kubelet 架构与启动流程

Kubelet 是运行在每个节点上的主要 “节点代理”，负责处理 Master 节点下发到本节点的任务，按照 PodSpec 描述来管理 Pod 和其中的容器(72)。

Kubelet 启动流程：

Kubelet 的启动流程分为多个阶段，核心源码位于 cmd/kubelet/kubelet.go：

初始化阶段：

func main() {

    rand.Seed(time.Now().UnixNano())

    

    // 创建 Kubelet 命令

    command := app.NewKubeletCommand()

    

    // 初始化日志

    logs.InitLogs()

    defer logs.FlushLogs()

    

    // 执行命令

    if err := command.Execute(); err != nil {

        os.Exit(1)

    }

}

组件初始化：

初始化各种管理器（容器管理器、资源管理器、卷管理器等）
启动健康检查器
启动证书管理器
启动 OOM Watcher

主循环启动：

Kubelet 启动后进入一个永不停止的控制循环，持续监听 API Server 的 Pod 变化，执行 Pod 的创建、更新和删除操作。

6.2 Pod 生命周期管理

Kubelet 的核心职责是管理节点上 Pod 的完整生命周期，包括创建、运行、监控和销毁。

Pod 同步循环：

Kubelet 的主循环是一个无限循环，不断同步节点上的 Pod 状态：

func (kl \*Kubelet) Run(updates <-chan kubetypes.PodUpdate) {

    // ... 省略初始化代码

    

    // 进入主循环

    for {

        select {

        case u, open := <-updates:

            if !open {

                updates = nil

            } else {

                kl.syncUp(u)

            }

            

        // 处理其他事件

        case <-kl.livenessManager.Healthy():

            kl.syncNodeStatus()

            

        // 定时同步

        case <-kl.statusUpdateCh:

            kl.updateNodeStatus()

            

        // 其他 case...

        }

    }

}

6.3 容器运行时接口（CRI）

Kubelet 通过 容器运行时接口（CRI） 与底层容器运行时（如 Docker、containerd）交互。CRI 定义了容器和镜像管理的标准接口。

CRI 接口定义：

type RuntimeService interface {

    RunPodSandbox(ctx context.Context, req \*runtimeapi.RunPodSandboxRequest) (\*runtimeapi.RunPodSandboxResponse, error)

    StopPodSandbox(ctx context.Context, req \*runtimeapi.StopPodSandboxRequest) (\*runtimeapi.StopPodSandboxResponse, error)

    RemovePodSandbox(ctx context.Context, req \*runtimeapi.RemovePodSandboxRequest) (\*runtimeapi.RemovePodSandboxResponse, error)

    // ... 其他方法

}

type ImageService interface {

    PullImage(ctx context.Context, req \*runtimeapi.PullImageRequest) (\*runtimeapi.PullImageResponse, error)

    RemoveImage(ctx context.Context, req \*runtimeapi.RemoveImageRequest) (\*runtimeapi.RemoveImageResponse, error)

    // ... 其他方法

}

Kubelet 通过 pkg/kubelet/dockershim 包与 Docker 运行时交互，通过 pkg/kubelet/cri 包与其他 CRI 兼容的运行时交互。

6.4 健康检查机制

Kubelet 实现了完善的 健康检查机制，包括：

容器健康检查：通过探针（Probe）机制
节点健康检查：定期向 API Server 上报节点状态
Kubelet 自身健康检查：通过 HTTP 端点提供健康状态

容器探针机制：

Kubelet 支持三种类型的探针：

存活探针（Liveness Probe）：判断容器是否存活，失败时重启容器
就绪探针（Readiness Probe）：判断容器是否准备好接收流量
启动探针（Startup Probe）：判断容器是否已经启动完成

探针的执行通过 pkg/kubelet/prober 包实现，支持 HTTP、TCP 和 Exec 三种探测方式。

6.5 节点状态管理

Kubelet 负责维护节点的状态信息，并定期向 API Server 上报。节点状态包括：

节点状态字段：

基本信息：节点名称、操作系统、内核版本、容器运行时版本
资源信息：CPU、内存、存储容量
地址信息：IP 地址、主机名
条件状态：Ready、MemoryPressure、DiskPressure、PIDPressure、NetworkUnavailable
容量和可分配资源：节点总容量和可分配给 Pod 的资源

节点状态更新通过 kl.updateNodeStatus() 方法实现，该方法会定期调用（默认 10 秒），将节点状态同步到 API Server。

七、网络策略源码深度解析

7.1 网络插件机制

Kubernetes 的网络模型基于 CNI（Container Network Interface）插件 机制，支持多种网络实现方案。CNI 插件负责为容器分配网络接口和 IP 地址，实现容器间的网络通信。

CNI 插件接口定义：

CNI 插件需要实现以下基本接口：

type CNI interface {

    AddNetworkList(ctx context.Context, netList \*NetworkConfigList, rt RuntimeConf) (types.Result, error)

    DelNetworkList(ctx context.Context, netList \*NetworkConfigList, rt RuntimeConf) error

}

Kubernetes 通过 pkg/kubelet/dockershim/network 包与 CNI 插件交互，具体实现位于 pkg/kubelet/network/cni 包。

7.2 网络策略控制器

网络策略通过 NetworkPolicy 对象定义，网络策略控制器负责实现网络流量的安全控制。网络策略的核心逻辑位于 pkg/controller/networkpolicy 包。

网络策略实现原理：

网络策略定义：通过标签选择器定义作用范围
规则匹配：基于协议、端口、源 / 目标地址匹配
隔离机制：通过 iptables 或 IPVS 规则实现隔离

网络策略控制器通过 Informer 监听 NetworkPolicy 对象的变化，并通过 Controller 模式实现网络规则的同步。

7.3 服务发现与负载均衡

Kubernetes Service 提供了服务发现和负载均衡功能，其实现涉及多个组件：

Service 实现组件：

kube-proxy：运行在每个节点上，负责 Service 的本地实现
kube-dns/coredns：提供 DNS 服务发现
ingress controller：提供七层负载均衡

kube-proxy 工作模式：

kube-proxy 支持三种工作模式：

userspace 模式：通过用户态代理实现
iptables 模式：通过 iptables 规则实现
ipvs 模式：通过 IPVS 实现（推荐模式）

ipvs 模式的实现位于 pkg/proxy/ipvs 包，具有更好的性能和扩展性。

7.4 网络流量控制

Kubernetes 通过多种机制实现网络流量的控制和管理：

流量控制机制：

NetworkPolicy：基于策略的网络隔离
Pod 亲和性 / 反亲和性：控制 Pod 的网络拓扑分布
Service 负载均衡：流量分发
Ingress：七层流量路由

Ingress 资源的实现位于 staging/src/``k8s.io/ingress-nginx/ 等 ingress controller 仓库，通过 Ingress 对象定义 HTTP/HTTPS 路由规则。

八、存储管理源码深度解析

8.1 存储卷管理机制

Kubernetes 的存储卷管理基于 插件化架构，支持多种存储后端。存储卷的核心逻辑位于 pkg/volume 包。

存储卷类型：

临时卷：EmptyDir、HostPath
持久卷：GCEPersistentDisk、AWSElasticBlockStore、NFS、Ceph、GlusterFS 等
云存储：AzureDisk、AzureFile、CSI 等
特殊卷：ConfigMap、Secret、DownwardAPI

每种存储卷类型都有对应的插件实现，通过统一的接口与 Kubelet 交互。

8.2 PV/PVC 实现机制

PV（PersistentVolume）和 PVC（PersistentVolumeClaim） 是 Kubernetes 存储管理的核心抽象，实现了存储资源的声明和绑定。

PV/PVC 控制器：

PV/PVC 的控制逻辑位于 pkg/controller/volume/persistentvolume 包，包括：

PersistentVolumeController：管理 PV 的生命周期
PersistentVolumeClaimController：管理 PVC 的生命周期
VolumeBinder：负责 PV 和 PVC 的绑定

PV 绑定逻辑：

PV 与 PVC 的绑定通过 volume.Sync 方法实现，该方法会尝试为 PVC 找到匹配的 PV：

func (b \*PersistentVolumeBinder) Sync(ctx context.Context, claim \*v1.PersistentVolumeClaim) error {

    // 获取所有可用的 PV

    volumes, err := b.pvLister.List(labels.Everything())

    if err != nil {

        return err

    }

    

    // 过滤出可用的 PV

    availableVolumes := filterAvailableVolumes(volumes)

    

    // 尝试绑定

    for \_, volume := range availableVolumes {

        if b.matchVolumeAndClaim(volume, claim) {

            // 执行绑定操作

            if err := b.bindVolume(ctx, volume, claim); err != nil {

                return err

            }

            return nil

        }

    }

    

    return nil

}

8.3 存储插件接口

Kubernetes 支持多种存储插件接口，包括：

CSI（Container Storage Interface）插件：

CSI 是容器存储接口标准，Kubernetes 通过 CSI 接口支持各种存储系统。CSI 插件的实现位于 staging/src/``k8s.io/csi-api/ 包。

CSI 插件接口定义：

type IdentityServer interface {

    GetPluginInfo(context.Context, \*GetPluginInfoRequest) (\*GetPluginInfoResponse, error)

    GetPluginCapabilities(context.Context, \*GetPluginCapabilitiesRequest) (\*GetPluginCapabilitiesResponse, error)

    Probe(context.Context, \*ProbeRequest) (\*ProbeResponse, error)

}

type ControllerServer interface {

    CreateVolume(context.Context, \*CreateVolumeRequest) (\*CreateVolumeResponse, error)

    DeleteVolume(context.Context, \*DeleteVolumeRequest) (\*DeleteVolumeResponse, error)

    ControllerPublishVolume(context.Context, \*ControllerPublishVolumeRequest) (\*ControllerPublishVolumeResponse, error)

    // ... 其他方法

}

type NodeServer interface {

    NodePublishVolume(context.Context, \*NodePublishVolumeRequest) (\*NodePublishVolumeResponse, error)

    NodeUnpublishVolume(context.Context, \*NodeUnpublishVolumeRequest) (\*NodeUnpublishVolumeResponse, error)

    // ... 其他方法

}

8.4 存储卷挂载流程

存储卷的挂载流程涉及多个组件的协作，主要流程如下：

存储卷挂载步骤：

PVC 绑定：PVC 与 PV 完成绑定
Volume 准备：Kubelet 调用存储插件准备 Volume
节点阶段（Node Stage）：在节点上准备 Volume（CSI 特有）
挂载阶段（Mount）：将 Volume 挂载到 Pod 的挂载点
容器挂载：将 Volume 挂载到容器中

存储卷挂载的核心逻辑位于 pkg/kubelet/volume/util 包，通过 MountVolume 函数实现。

九、深入机制分析

9.1 client-go 库的使用

client-go 是 Kubernetes 官方的 Go 语言客户端库，提供了与 Kubernetes API 交互的各种工具和机制。client-go 的核心组件包括：

核心组件：

REST Client：直接与 Kubernetes API 交互的 HTTP 客户端
Informers：提供资源对象的本地缓存和变更通知
Listers：提供只读的缓存访问接口
Workqueue：提供各种类型的工作队列
Rate Limiter：提供速率限制功能

Informers 机制：

Informers 是 client-go 中最重要的机制之一，它通过 List-Watch 机制实现资源的实时同步。Informer 的工作流程：

通过 List API 获取资源列表
通过 Watch API 监听资源变化
将资源存储在本地缓存（Delta FIFO）
触发事件处理函数

9.2 Informers 机制实现

Informers 机制的核心实现位于 staging/src/``k8s.io/client-go/informers 包，其架构设计如下：

Informer 架构组件：

Reflector：负责从 API Server 获取资源变更
Delta FIFO：存储资源变更事件
Indexer：提供资源的索引和查询功能
EventHandler：处理资源变更事件

Reflector 实现：

Reflector 通过 ListAndWatch 方法实现资源的同步：

func (r \*Reflector) ListAndWatch(ctx context.Context) error {

    // 执行 List 操作

    list, err := r.listFunc()

    if err != nil {

        return err

    }

    

    // 执行 Watch 操作

    watcher, err := r.watchFunc(list.GetResourceVersion())

    if err != nil {

        return err

    }

    

    // 处理 Watch 事件

    for {

        select {

        case event, ok := <-watcher.ResultChan():

            if !ok {

                return nil

            }

            

            // 处理事件

            r.processEvent(event)

        case <-ctx.Done():

            return ctx.Err()

        }

    }

}

9.3 工作队列设计模式

工作队列是 Kubernetes 控制器实现的核心模式，client-go 提供了多种工作队列实现。

工作队列模式：

生产者 - 消费者模式：多个生产者将任务放入队列，多个消费者从队列取出任务处理
速率限制模式：限制任务的处理频率，避免系统过载
延迟重试模式：失败的任务延迟后重试
优先级队列模式：根据任务优先级决定处理顺序

9.4 controller-runtime 框架

controller-runtime 是 Kubernetes 社区提供的现代化控制器开发框架，简化了控制器的开发流程。它提供了：

核心功能：

Controller 抽象：简化控制器的创建
Informer 管理：自动管理 Informer 的生命周期
Reconciler 模式：定义统一的 Reconcile 方法
事件过滤：支持基于事件类型和对象元数据的过滤
Leader Election：内置 Leader Election 支持

controller-runtime 的使用示例：

import (

    "context"

    

    ctrl "sigs.k8s.io/controller-runtime"

    "sigs.k8s.io/controller-runtime/pkg/builder"

    "sigs.k8s.io/controller-runtime/pkg/controller"

    "sigs.k8s.io/controller-runtime/pkg/event"

    "sigs.k8s.io/controller-runtime/pkg/handler"

    "sigs.k8s.io/controller-runtime/pkg/reconcile"

)

type MyReconciler struct {

    client.Client

    Scheme \*runtime.Scheme

}

func (r \*MyReconciler) Reconcile(ctx context.Context, req ctrl.Request) (ctrl.Result, error) {

    // 实现 Reconcile 逻辑

    return ctrl.Result{}, nil

}

func main() {

    // 创建控制器

    mgr, err := ctrl.NewManager(ctrl.GetConfigOrDie(), ctrl.Options{

        Scheme: scheme,

    })

    if err != nil {

        log.Fatal(err)

    }

    

    // 注册控制器

    if err := ctrl.NewControllerManagedBy(mgr).

        For(\&appsv1.Deployment{}).

        Complete(\&MyReconciler{Client: mgr.GetClient(), Scheme: mgr.GetScheme()}); err != nil {

        log.Fatal(err)

    }

    

    // 启动管理器

    if err := mgr.Start(ctrl.SetupSignalHandler()); err != nil {

        log.Fatal(err)

    }

}

十、实践建议与学习路径

10.1 环境搭建最佳实践

基于前述分析，以下是 Kubernetes 源码学习和开发的环境搭建最佳实践：

推荐环境配置：

操作系统：Ubuntu 20.04 LTS 或更高版本（推荐）
硬件配置：至少 8GB 内存、4 核 CPU、50GB 存储空间
Go 版本：Go 1.25.7（与 Kubernetes 1.35 版本匹配）
Docker 配置：确保 Docker 版本 >= 20.10，启用 buildx 插件

源码获取建议：

使用 SSH 克隆以获得更好的性能：git clone ``git@github.com``:kubernetes/kubernetes.git
切换到指定版本：git checkout release-1.35
配置 Git 用户名和邮箱：

git config --global user.name "Your Name"

git config --global user.email "your.email@example.com"

开发工具推荐：

IDE：Visual Studio Code（推荐）或 GoLand
插件：Go 语言插件、GitLens、Markdown 预览
调试工具：Delve（Go 调试器）
性能分析：pprof、trace

10.2 源码阅读方法

Kubernetes 源码庞大而复杂，采用系统性的阅读方法至关重要：

分层阅读策略：

整体架构层：先理解各组件的职责和交互
核心组件层：深入学习 API Server、Scheduler、Controller Manager、Kubelet
功能模块层：学习特定功能的实现（如 Pod 调度、服务发现）
基础库层：学习 client-go、controller-runtime 等基础库

代码导航技巧：

从 main 函数开始：每个组件都有明确的入口
使用 IDE 导航：利用 Go to Definition、Find References 等功能
关注注释：Kubernetes 源码有丰富的注释
查看测试用例：测试代码往往是理解功能的最佳途径

10.3 调试技巧

调试是理解源码的重要手段，以下是常用调试技巧：

断点调试：

在关键函数入口设置断点
使用条件断点过滤特定场景
调试表达式查看变量值
单步调试跟踪执行流程

日志调试：

增加调试日志：使用 klog.V(4).Info() 等分级日志
查看组件日志：kubectl logs <pod-name> -n kube-system
启用详细日志：通过命令行参数 --v=4 或更高

性能分析：

CPU 分析：go tool pprof -alloc_space ``http://localhost:6060/debug/pprof/profile
内存分析：go tool pprof -inuse_space ``http://localhost:6060/debug/pprof/heap
trace 分析：go tool trace trace.out

10.4 贡献指南

参与 Kubernetes 开源社区是深入学习的最佳方式：

贡献流程：

Issue 认领：从 “good first issue” 标签开始
分支创建：基于 release-1.35 分支创建功能分支
代码编写：遵循 Kubernetes 编码规范
测试编写：为新增功能编写单元测试和集成测试
Pull Request：提交 PR 并等待 review

编码规范：

Go 语言规范：遵循官方 Go 语言规范
Kubernetes 特定规范：

使用 klog 包进行日志记录
使用 client-go 进行 API 操作
遵循 controller-runtime 的 Reconciler 模式
编写 godoc 注释

社区资源：

邮件列表：kubernetes-dev@googlegroups.com
Slack：#sig-api-machinery、#sig-scheduling 等频道
GitHub：https://github.com/kubernetes/kubernetes
文档：https://kubernetes.io/docs/home/

10.5 推荐学习资源

官方文档：

源码相关资源：

实战项目推荐：

Minikube：本地 Kubernetes 集群
Kind：Kubernetes in Docker
Kubeadm：Kubernetes 集群部署工具
Operator SDK：用于开发 Kubernetes Operators

结语

通过对 Kubernetes 源码的全面解析，我们深入理解了这个云原生编排系统的架构设计和实现原理。从 API Server 的 RESTful 接口实现，到 Scheduler 的智能调度算法，从 Controller Manager 的状态协调机制，到 Kubelet 的节点管理功能，每个组件都体现了分布式系统设计的精妙之处。

Kubernetes 的成功不仅在于其功能的强大，更在于其 模块化和插件化的设计理念。通过深入学习源码，我们掌握了 client-go 的使用、Informer 机制、工作队列模式、controller-runtime 框架等核心技术，这些都是构建现代云原生应用的必备技能。

展望未来，随着云原生技术的不断发展，Kubernetes 将继续演进和完善。建议读者持续关注官方发布的新版本，学习新特性的实现原理，并积极参与开源社区的贡献。通过不断的实践和学习，最终成为云原生领域的技术专家，为推动云原生技术的发展贡献力量。

**参考资料 **

[1] 发行版本 | Kubernetes https://kubernetes.io/zh-cn/releases/

[2] k8s1.35.1二进制部署 https://blog.csdn.net/peng_s_w/article/details/158069753

[3] Kubernetes v1.35版本发布，十大重点确定性更新，v1.31版本停止维护Kubernetes v1.35版本 - 掘金 https://juejin.cn/post/7585289701793742874

[4] [x-cmd] Kubernetes v1.35 发布:Kubelet 配置 Drop-in 目录正式进入 GA-CSDN博客 https://x-cmd.blog.csdn.net/article/details/157900852

[5] Azure Kubernetes Service (AKS) 中支援的 Kubernetes 版本。 - Azure Kubernetes Service | Microsoft Learn https://learn.microsoft.com/zh-tw/azure/aks/supported-kubernetes-versions?source=recommendations

[6] Amazon EKS 和 Amazon EKS Distro 现在支持 Kubernetes 版本 1.35 https://www.amazonaws.cn/new/2026/amazon-eks-and-amazon-eks-distro-supports-kubernetes-version-1-35/

[7] 一、注意事项 | 👋运维锻造，知识沉淀 http://opforge.srebro.cn/cloud-native/kubernetes/05.html

[8] 查看 Kubernetes 版本延期支持的发布说明 - Amazon EKS https://docs.amazonaws.cn/zh_cn/eks/latest/userguide/kubernetes-versions-extended.html

[9] Supported Kubernetes versions in Azure Kubernetes Service (AKS) https://learn.microsoft.com/el-gr/azure/aks/supported-kubernetes-versions?view=azureml-api-1

[10] Review release notes for Kubernetes versions on extended support https://docs.aws.amazon.com/en_en/eks/latest/userguide/kubernetes-versions-extended.html

[11] Container Compute Service:Kubernetes 1.30 release notes https://www.alibabacloud.com/help/en/cs/acs-releases-kubernetes-1-30-release-notes

[12] Kubernetes version 1.30 is now available in IBM Cloud Kubernetes Service https://community.ibm.com/community/user/cloud/blogs/elvin-galarza/2024/05/31/kubernetes-version-130-now-available-in-ibm-cloud

[13] Kubernetes v1.30: Uwubernetes https://kubernetes.io/blog/2024/04/17/kubernetes-v1-30-release/

[14] Kubernetes 1.29 Release Notes https://support.huaweicloud.com/eu/bulletin-cce/cce_bulletin_0089.html

[15] Building Kubernetes https://github.com/kubernetes/kubernetes/blob/master/build/README.md

[16] Kubernetes (K8s) https://github.com/kubernetes/kubernetes

[17] 搭建 Kubernetes 源码编译环境 · atompi https://atompi.com/posts/kubernetes-dev-env/

[18] k8s 组件编译 https://github.com/bmwx4/k8s-in-practice/blob/master/tasks/k8s-compile.md

[19] CentOS7.2中使用Kubernetes(k8s)1.4.6源码搭建k8s容器集群环境-CSDN博客 https://blog.csdn.net/yu_jinyu/article/details/53292399

[20] Kubernetes herunterladen https://kubernetes.io/de/docs/setup/release/_print/

[21] Descargando Kubernetes https://kubernetes.io/es/docs/setup/release/_print/

[22] 1. 使用 vs-code 来阅读源码_vscode查看库源码-CSDN博客 https://blog.csdn.net/qq_32468785/article/details/136330197

[23] Go 1.25.5 通关讲解Go 1.25.5 通关讲解作者:吴佳浩最后更新:2025-12-24 适用版本:gol - 掘金 https://juejin.cn/post/7586939930155401259

[24] kubernetes:源码编译-CSDN博客 https://blog.csdn.net/textdemo123/article/details/106262119

[25] 编译打包-kubesphere/kubekey - GitHub说明对kubesphere/kubekey - Git - 掘金 https://juejin.cn/post/7592524811860656162

[26] setup-envtest@latest requires golang >=1.25.0? #3358 https://github.com/kubernetes-sigs/controller-runtime/issues/3358

[27] Kubernetes源码编译-CSDN博客 https://blog.csdn.net/weixin_33912246/article/details/91427602

[28] 讲解 Kubernetes 源码_kubernetes 源码剖析与实战-CSDN博客 https://blog.csdn.net/u011091936/article/details/150841027

[29] Deep Dive into Kubernetes Source Code https://collabnix.com/deep-dive-into-kubernetes-source-code/

[30] Learning Large-Scale Go Project Architecture from Kubernetes | Leapcell https://leapcell.io/blog/learning-large-scale-go-project-architecture-from-kubernetes

[31] Examination of a High Quality Repository: Kubernetes · CankutER/SWE-573 Wiki · GitHub https://github.com/CankutER/SWE-573/wiki/Examination-of-a-High-Quality-Repository:-Kubernetes

[32] Kubernetes - Source Code https://www.hackingnote.com/en/kubernetes/source-code/

[33] Let’s Talk About the Kubernetes Source Code https://dev.to/kubefeeds/lets-talk-about-the-kubernetes-source-code-14d3

[34] Kubernertes源码结构分析_kubenetes源码-CSDN博客 https://blog.csdn.net/maxiaorong92/article/details/107619222

[35] k8s源码分析——kubectl主要框架_kubernetes的源码中有main吗-CSDN博客 https://blog.csdn.net/cbmljs/article/details/102568433

[36] 《深入理解Kubernetes》源码阅读方法与实践指南 https://www.iesdouyin.com/share/note/7416550563069873447/?region=&mid=6881996450729822215&u_code=0&did=MS4wLjABAAAANwkJuWIRFOzg5uCpDRpMj4OX-QryoDgn-yYlXQnRwQQ&iid=MS4wLjABAAAANwkJuWIRFOzg5uCpDRpMj4OX-QryoDgn-yYlXQnRwQQ&with_sec_did=1&video_share_track_ver=&titleType=title&schema_type=37&share_sign=94tLphsNvzdftP1BtQjiOWnhVkLpmQW0Z.lHY9LXs_U-&share_version=280700&ts=1772204483&from_aid=1128&from_ssr=1&share_track_info=%7B%22link_description_type%22%3A%22%22%7D

[37] K8S kube-apiserver 源码层次分析 https://github.com/DavadDi/go_study/blob/master/kube-apiserver.md

[38] k8s api-server源码阅读简易摘要对 Kubernetes 的 API Server 进行详细的源代码分析是一 - 掘金 https://juejin.cn/post/7394272287430541324

[39] kubernetes 源码分析_mb62678baacf737的技术博客_51CTO博客 https://blog.51cto.com/u_15616991/9375619

[40] Kubernetes kubelet 源码架构及启动流程深入剖析-Kubernetes商业环境实战 https://juejin.cn/post/6844903924139294733

[41] Kubernetes 1.35 Released with In-Place Pod Resize and AI-Optimized Scheduling https://www.infoq.com/news/2025/12/kubernetes-1-35/

[42] Amazon EKS and Amazon EKS Distro now supports Kubernetes version 1.35 https://aws.amazon.com/about-aws/whats-new/2026/01/amazon-eks-distro-kubernetes-version-1-35/

[43] Kubernetes 1.33 “Octarine” Released: Native Sidecars and In-Place Pod Resizing https://www.infoq.com/news/2025/04/kubernetes-octarine-release/

[44] Kubernetes 1.35: In-Place Pod Resize is GA Scale Vertically Without Restarting https://www.webnuz.com/article/2026-01-06/Kubernetes%201.35:%20In-Place%20Pod%20Resize%20is%20GA%20%20Scale%20Vertically%20Without%20Restarting

[45] Kubernetes 1.33: Native Sidecars are here, plus Big Security Boost with User Namespaces https://tfir.io/kubernetes-1-33-native-sidecars-are-here-plus-big-security-boost-with-user-namespaces/

[46] Kubernetes v1.34: What’s New and Improved? https://www.perfectscale.io/blog/kubernetes-v1-34-release

[47] Amazon EKS and Amazon EKS Distro now supports Kubernetes version 1.34 https://www.amazonaws.cn/en/new/2025/amazon-eks-and-eks-distro-supports-kubernetes-version-1-34/

[48] Kubernetes v1.35:Timbernetes(世界树版本) | Kubernetes https://kubernetes.io/zh-cn/blog/2025/12/17/kubernetes-v1-35-release/

[49] Kubernetes v1.35 Timbernetes(世界树) 来了!垂直扩容、KYAML 优化、废弃 cgroup v1 和 ipvs，更稳定、更安全、更易运维-CSDN博客 https://mingongge.blog.csdn.net/article/details/156403263

[50] Kubernetes 1.35 “世界树“版本深度解析:从GA到Alpha的实战指南-CSDN博客 https://blog.csdn.net/qq_39965541/article/details/157993045

[51] Kubernetes v1.35 Deep Dive: In-Place Resize GA, Gang Scheduling & the Cgroup v2 Cliff https://scaleops.com/blog/kubernetes-1-35-release-overview/

[52] Kubernetes v1.35: Timbernetes (The World Tree Release) https://kubernetes.io/blog/2025/12/17/kubernetes-v1-35-release/

[53] Kubernetes 1.35: In-Place Pod Resize Graduates to Stable https://kubernetes.io/blog/2025/12/19/kubernetes-v1-35-in-place-pod-resize-ga/

[54] Cluster Architecture https://kubernetes.io/docs/concepts/architecture/_print/

[55] Kubernetes Components | Kubernetes https://kubernetes.io/docs/concepts/overview/components/

[56] Kubernetesのコンポーネント https://kubernetes.io/ja/docs/concepts/overview/components/

[57] Компоненты Kubernetes https://kubernetes.io/ru/docs/concepts/overview/components/

[58] Architecture du cluster | Kubernetes https://kubernetes.io/fr/docs/concepts/architecture/

[59] Componentes de Kubernetes | Kubernetes https://kubernetes.io/es/docs/concepts/overview/components/

[60] I componenti di Kubernetes https://kubernetes.io/it/docs/concepts/overview/components/

[61] Kubernetes 架构 | Kubernetes https://kubernetes.io/zh/docs/concepts/architecture/

[62] Kubernetes 集群架构概述_kubernetes组件详细介绍-CSDN博客 https://blog.csdn.net/JHXXH/article/details/158010607

[63] Kubernetes架构简介_mob6454cc67554d的技术博客_51CTO博客 https://blog.51cto.com/u_16099206/14381119

[64] Kubernetes架构核心组件与工作机制解析 https://www.iesdouyin.com/share/video/7571111203041299747/?region=&mid=7571111198647290676&u_code=0&did=MS4wLjABAAAANwkJuWIRFOzg5uCpDRpMj4OX-QryoDgn-yYlXQnRwQQ&iid=MS4wLjABAAAANwkJuWIRFOzg5uCpDRpMj4OX-QryoDgn-yYlXQnRwQQ&with_sec_did=1&video_share_track_ver=&titleType=title&share_sign=6506r0Q5uYtgq7DbH4mofKtbzR.Eu9M0RuZQ4j2b1Uo-&share_version=280700&ts=1772204512&from_aid=1128&from_ssr=1&share_track_info=%7B%22link_description_type%22%3A%22%22%7D

[65] 深入解析 Kubernetes 核心架构与工作原理-CSDN博客 https://blog.csdn.net/qq_21886255/article/details/153337814

[66] Kubernetes集群架构与核心组件详解_51CTO学堂_专业的IT技能学习平台 https://edu.51cto.com/article/note/20707.html

[67] 第2章:Kubernetes核心概念大白话Kubernetes的架构虽然复杂，但它的设计思想很直观 - 就像管理一个高效 - 掘金 https://juejin.cn/post/7565268465708384296

[68] 万字长文:Kubernetes 创建 Pod 时，背后到底发生了什么?-CSDN博客 https://blog.csdn.net/easylife206/article/details/119121886

[69] Kubernetes kubelet 源码架构及启动流程深入剖析-Kubernetes商业环境实战 https://juejin.cn/post/6844903924139294733

[70] kube-galaxy-test/src/kube_galaxy/pkg/components/_base.py at e5f3efa37afcf78bc9731fccb38cc51d9faa384c · canonical/kube-galaxy-test · GitHub https://github.com/canonical/kube-galaxy-test/blob/e5f3efa37afcf78bc9731fccb38cc51d9faa384c/src/kube_galaxy/pkg/components/_base.py

[71] 【kubernetes/k8s源码分析】ingress-nginx 源码解析_listingress-CSDN博客 https://blog.csdn.net/zhonglinzhang/article/details/81014693

[72] k8s源码解析之kubelet启动主流程 https://www.cnblogs.com/ltaodream/p/16817143.html

[73] k8s源码解析之kube-scheduler启动流程 https://www.cnblogs.com/ltaodream/p/16837107.html

[74] Cluster boot sequence https://kops.sigs.k8s.io/boot-sequence/

[75] k8s源码分析-----kubelet启动流程分析_streaming-connection-idle-timeout-CSDN博客 https://blog.csdn.net/yan234280533/article/details/52349076

[76] kubernetes各组件如何启动_mb63219befd4271的技术博客_51CTO博客 https://blog.51cto.com/u_15792033/9305636

[77] Kubernetes Init Container核心机制与使用注意事项解析 https://www.iesdouyin.com/share/video/7550673853992406331/?region=&mid=7550673897943763753&u_code=0&did=MS4wLjABAAAANwkJuWIRFOzg5uCpDRpMj4OX-QryoDgn-yYlXQnRwQQ&iid=MS4wLjABAAAANwkJuWIRFOzg5uCpDRpMj4OX-QryoDgn-yYlXQnRwQQ&with_sec_did=1&video_share_track_ver=&titleType=title&share_sign=pi9dIuui81evKce3CtPoD.pkfTLDyK56RzYUdk8vtKE-&share_version=280700&ts=1772204526&from_aid=1128&from_ssr=1&share_track_info=%7B%22link_description_type%22%3A%22%22%7D

[78] kubelet组件的启动流程源码分析_kubelet 源码分析-CSDN博客 https://blog.csdn.net/xsw164711368/article/details/142030556

[79] Kubernetes 系列 - 4. apiserver (一、启动流程)4. apiserver (一、启动流程) 4 - 掘金 https://juejin.cn/post/7459705455838265371

[80] k8s启动顺序启动顺序_wx5d6f0f4a50ea3的技术博客_51CTO博客 https://blog.51cto.com/u_14530969/10382494

[81] kubernetes源码解析---- apiserver路由构建解析(2) - LDaniel - 博客园 https://www.cnblogs.com/ldaniel/p/5889931.html

[82] 10.8Kubernetes源码情景分析-云计算那些事儿:从IaaS到PaaS进阶(五) - 码小课 - 程序员在线学习平台 | Java Python PHP Go JavaScript Linux教程 https://www.maxiaoke.com/manual/yjsnxs_five/15747.html

[83] kubernetes/staging/src/k8s.io/apiserver/pkg/server/routes/version.go at master · kubernetes/kubernetes · GitHub https://github.com/kubernetes/kubernetes/blob/master/staging/src/k8s.io/apiserver/pkg/server/routes/version.go

[84] 【kubernetes/k8s源码分析】kube-apiserver 启动_kubelet api接口url具体有哪些-CSDN博客 https://blog.csdn.net/zhonglinzhang/article/details/68062613

[85] kubernetes源码解析---- apiserver路由构建解析(2) - LDaniel - 博客园 https://www.cnblogs.com/ldaniel/p/5889931.html

[86] kubernetes/staging/src/k8s.io/apiserver/pkg/server/routes/openapi.go at master · kubernetes/kubernetes · GitHub https://github.com/kubernetes/kubernetes/blob/master/staging/src/k8s.io/apiserver/pkg/server/routes/openapi.go

[87] kube-apiserver https://github.com/duyanghao/kubernetes-reading-notes/blob/master/core/api-server/design.md

[88] Kubernetes API Server源码学习（二）：OpenAPI、API Resource的装载、HTTP Server具体是怎么跑起来的？原创 https://blog.csdn.net/qq_40378034/article/details/131341129

[89] kube-apiserver启动流程分析_delegate apiserver-CSDN博客 https://blog.csdn.net/u012986012/article/details/105755991

[90] kubernetes apiserver原理概览 https://github.com/duyanghao/kubernetes-reading-notes/blob/master/core/api-server/overview.md

[91] api k8s restful 创建pods_K8S APIServer 源码剖析(三)| 注册 API-CSDN博客 https://blog.csdn.net/weixin_33099377/article/details/112527703

[92] 深度解析 | K8S API Server之请求处理_51CTO博客_k8s api https://blog.51cto.com/u_15077561/2584808

[93] Kubernetes源码解读 PDF 密码解压_寂寞沙冷州的技术博客_51CTO博客 https://blog.51cto.com/u_39037/12778115

[94] 5.1 API核心server的启动流程_api-server怎么启动-CSDN博客 https://blog.csdn.net/weixin_48502062/article/details/145579338

[95] 深入理解 Kubernetes 中的用户与身份认证授权-CSDN博客 https://blog.csdn.net/alex_yangchuansheng/article/details/128030875

[96] kubernetes/staging/src/k8s.io/apiserver/pkg/endpoints/filters/authentication.go at master · kubernetes/kubernetes · GitHub https://github.com/kubernetes/kubernetes/blob/master/staging/src/k8s.io/apiserver/pkg/endpoints/filters/authentication.go

[97] kubernetes/staging/src/k8s.io/apiserver/pkg/endpoints/filters/authorization.go at master · kubernetes/kubernetes · GitHub https://github.com/kubernetes/kubernetes/blob/master/staging/src/k8s.io/apiserver/pkg/endpoints/filters/authorization.go

[98] 【kubernetes/k8s源码分析】kube-apiserver 启动_kubelet api接口url具体有哪些-CSDN博客 https://blog.csdn.net/zhonglinzhang/article/details/68062613

[99] kubernetes/pkg/kubeapiserver/authenticator/config.go at master · kubernetes/kubernetes · GitHub https://github.com/kubernetes/kubernetes/blob/master/pkg/kubeapiserver/authenticator/config.go

[100] Admission Control in Kubernetes https://kubernetes.io/docs/reference/access-authn-authz/admission-controllers/?ref=ghostwriter

[101] Kubernetes APIへのアクセスコントロール | Kubernetes https://kubernetes.io/ja/docs/concepts/security/controlling-access/

[102] Kubernetes 源码剖析与实战Kubernetes源码解密:kube-apiserver的架构哲学与安全体系设计 - 掘金 https://juejin.cn/post/7551690245617500175

[103] Kubernetes控制平面组件:APIServer 基于 ServiceAccount 的认证机制_kube-apiserver --service-accout-CSDN博客 https://blog.csdn.net/a1369760658/article/details/145717399

[104] Kubernetes【05】k8s-APIServer-CSDN博客 https://blog.csdn.net/Aerkui/article/details/153875841

[105] Kubernetes API Server核心功能与架构解析 https://www.iesdouyin.com/share/video/7368429619541724442/?region=&mid=7368429708326849290&u_code=0&did=MS4wLjABAAAANwkJuWIRFOzg5uCpDRpMj4OX-QryoDgn-yYlXQnRwQQ&iid=MS4wLjABAAAANwkJuWIRFOzg5uCpDRpMj4OX-QryoDgn-yYlXQnRwQQ&with_sec_did=1&video_share_track_ver=&titleType=title&share_sign=6g4cb7DxXRU68OsPSybXOq4vprTWGpNdFaANTe9VCGs-&share_version=280700&ts=1772204543&from_aid=1128&from_ssr=1&share_track_info=%7B%22link_description_type%22%3A%22%22%7D

[106] kube-apiserver 权限控制_kube-apiserver authorization-mode-CSDN博客 https://blog.csdn.net/UFOfuck/article/details/135626794

[107] 授权 | Kubernetes (K8s) 容器编排系统 https://kubernetes.ac.cn/docs/reference/access-authn-authz/authorization/

[108] kubernetes/staging/src/k8s.io/apiserver/pkg/endpoints/handlers/watch.go at master · kubernetes/kubernetes · GitHub https://github.com/kubernetes/kubernetes/blob/master/staging/src/k8s.io/apiserver/pkg/endpoints/handlers/watch.go

[109] K8s 如何提供更高效稳定的编排能力?K8s Watch 实现机制浅析-CSDN博客 https://blog.csdn.net/u012676824/article/details/154414731

[110] kubernetes/staging/src/k8s.io/apiserver/pkg/storage/etcd3/watcher.go at master · kubernetes/kubernetes · GitHub https://github.com/kubernetes/kubernetes/blob/master/staging/src/k8s.io/apiserver/pkg/storage/etcd3/watcher.go

[111] kubernetes-dev-docs/client-go/3.listwatch-reflector-controller.md at master · opsnull/kubernetes-dev-docs · GitHub https://github.com/opsnull/kubernetes-dev-docs/blob/master/client-go/3.listwatch-reflector-controller.md

[112] Kubernetes client-go Informer 机制详解_桂晨的技术博客_51CTO博客 https://blog.51cto.com/u_16638093/14279688

[113] kubernetes/staging/src/k8s.io/apimachinery/pkg/watch/watch.go at master · kubernetes/kubernetes · GitHub https://github.com/kubernetes/kubernetes/blob/master/staging/src/k8s.io/apimachinery/pkg/watch/watch.go

[114] kubernetes/staging/src/k8s.io/client-go/rest/watch/decoder.go at master · kubernetes/kubernetes · GitHub https://github.com/kubernetes/kubernetes/blob/master/staging/src/k8s.io/client-go/rest/watch/decoder.go

[115] 【Linux】Linux + K8s 核心玩法:CRD 自定义资源开发，解锁集群管理新姿势-CSDN博客 https://blog.csdn.net/lbbxmx111/article/details/156547346

[116] 使用 CustomResourceDefinition 扩展 Kubernetes API | Kubernetes https://kubernetes.io/zh-cn/docs/tasks/extend-kubernetes/custom-resources/custom-resource-definitions/

[117] kubernetes系列之十四:Kubernetes CRD(CustomResourceDefinition)概览-CSDN博客 https://blog.csdn.net/cloudvtech/article/details/80277960

[118] Kubernetes自定义控制器开发机制与核心步骤解析 https://www.iesdouyin.com/share/video/7350617530349767963/?region=&mid=7350617663351098150&u_code=0&did=MS4wLjABAAAANwkJuWIRFOzg5uCpDRpMj4OX-QryoDgn-yYlXQnRwQQ&iid=MS4wLjABAAAANwkJuWIRFOzg5uCpDRpMj4OX-QryoDgn-yYlXQnRwQQ&with_sec_did=1&video_share_track_ver=&titleType=title&share_sign=uSzIFR8BnOc91kqeArJ8VgQP9jUl8G9e99VAxkMMFwY-&share_version=280700&ts=1772204550&from_aid=1128&from_ssr=1&share_track_info=%7B%22link_description_type%22%3A%22%22%7D

[119] Kubernetes CRD开发模式及源码实现深入剖析-Kubernetes商业环境实战-CSDN博客 https://blog.csdn.net/weixin_30577801/article/details/100092457

[120] K8S系列之6.1:自定义扩展(CRD 与 Operator 设计模式)_Allen http://m.toutiao.com/group/7584383841654129203/?upstream_biz=doubao

[121] kubernetes crd 源码_wx6225b14cdec17的技术博客_51CTO博客 https://blog.51cto.com/u_15538975/9305499

[122] 【K8S】Kubernetes 调度器深度解析:原理与源码分析_kubernetes调度器源码分析-CSDN博客 https://blog.csdn.net/weixin_42969320/article/details/152417398

[123] kube-schedulerのソースコードを読みながらPodがNodeにBindされるまでを理解する https://qiita.com/everpeace/items/601dc613a0f424fb5619

[124] k8s-source-code-analysis/kube-scheduler/scheduleOne.md at master · huweihuang/k8s-source-code-analysis · GitHub https://github.com/huweihuang/k8s-source-code-analysis/blob/master/kube-scheduler/scheduleOne.md

[125] kubernetes/pkg/scheduler/schedule_one.go at master · kubernetes/kubernetes · GitHub https://github.com/kubernetes/kubernetes/blob/master/pkg/scheduler/schedule_one.go

[126] kubernetes kube-scheduler 源码：预选和优选 https://juejin.cn/post/7178072424301199418

[127] blog/content/kubernetes/source code: scheduling - how to find a proper node for pod.md at master · zxdvd/blog · GitHub https://github.com/zxdvd/blog/blob/master/content/kubernetes/source%20code:%20scheduling%20-%20how%20to%20find%20a%20proper%20node%20for%20pod.md

[128] Kube Scheduler 源码分析 https://developer.aliyun.com/article/688729

[129] Kubernetes调度机制深度剖析(面试官最关注的底层原理)-CSDN博客 https://blog.csdn.net/IterStream/article/details/152605671

[130] Kubernetes 1.24 版本 scheduler(调度器)原理_1.24 kubernetes kubeschedulerconfiguration api-CSDN博客 https://blog.csdn.net/hezuijiudexiaobai/article/details/149056041

[131] k8s Pod 是如何调度到 Node 上的 ? # 编程 # Kubernetes # k8s 面试 # 面试 # k8s 嗨，老铁！觉得有用就点个赞，加个关注呗！创作不易，你的认可，就是我持续创作的动力！ https://www.iesdouyin.com/share/video/7565107518196747562/?region=&mid=7565107504540027700&u_code=0&did=MS4wLjABAAAANwkJuWIRFOzg5uCpDRpMj4OX-QryoDgn-yYlXQnRwQQ&iid=MS4wLjABAAAANwkJuWIRFOzg5uCpDRpMj4OX-QryoDgn-yYlXQnRwQQ&with_sec_did=1&video_share_track_ver=&titleType=title&share_sign=VdBm…m3_elmOirg8xheKTlVqP.NCvbEI89e5k62ryg-&share_version=280700&ts=1772204560&from_aid=1128&from_ssr=1&share_track_info=%7B%22link_description_type%22%3A%22%22%7D

[132] kube-scheduler_运维邦的技术博客_51CTO博客 https://blog.51cto.com/aklaus/14485371

[133] kube-scheduler predicates 与 priorities 调度算法源码分析-腾讯云开发者社区-腾讯云 https://cloud.tencent.com/developer/article/1553952?areaSource=106000.9

[134] kubernetesapidocument下载 https://blog.51cto.com/u_14731/12120774

[135] kubernetes/staging/src/k8s.io/component-helpers/scheduling/corev1/nodeaffinity/nodeaffinity.go at master · kubernetes/kubernetes · GitHub https://github.com/kubernetes/kubernetes/blob/master/staging/src/k8s.io/component-helpers/scheduling/corev1/nodeaffinity/nodeaffinity.go

[136] 专题-亲和性调度(Author - XiaoYang) https://github.com/daniel-hutao/k8s-source-code-analysis/blob/master/core/scheduler/affinity.md

[137] kubernetes/staging/src/k8s.io/client-go/applyconfigurations/core/v1/nodeaffinity.go at master · kubernetes/kubernetes · GitHub https://github.com/kubernetes/kubernetes/blob/master/staging/src/k8s.io/client-go/applyconfigurations/core/v1/nodeaffinity.go

[138] kubernetes/pkg/scheduler/framework/plugins/interpodaffinity/scoring.go at master · kubernetes/kubernetes · GitHub https://github.com/kubernetes/kubernetes/blob/master/pkg/scheduler/framework/plugins/interpodaffinity/scoring.go

[139] Use Affinity with Oracle Cloud Native Environment http://docs.oracle.com/en/learn/ocne-affinity/

[140] Assigning Pods to Nodes https://kubernetes.io/docs/concepts/scheduling-eviction/assign-pod-node/

[141] Class V1Affinity https://kubernetes-client.github.io/csharp/api/k8s.Models.V1Affinity.html

[142] Kubernetes节点选择器:标签与亲和性调度策略_kubernetes 节点亲和性标签自动管理-CSDN博客 https://blog.csdn.net/sjsndy/article/details/149247971

[143] 终极指南:Cluster Autoscaler节点亲和性与反亲和性配置全解析-CSDN博客 https://blog.csdn.net/gitblog_00952/article/details/152149167

[144] 【 K8s 源码之调度学习】Pod 间亲和性和反亲和性的源码分析_weightedpodaffinityterm-CSDN博客 https://blog.csdn.net/qq_24433609/article/details/129204194

[145] k8s Pod 是如何调度到 Node 上的 ? # 编程 # Kubernetes # k8s 面试 # 面试 # k8s 嗨，老铁！觉得有用就点个赞，加个关注呗！创作不易，你的认可，就是我持续创作的动力！ https://www.iesdouyin.com/share/video/7565107518196747562/?region=&mid=7565107504540027700&u_code=0&did=MS4wLjABAAAANwkJuWIRFOzg5uCpDRpMj4OX-QryoDgn-yYlXQnRwQQ&iid=MS4wLjABAAAANwkJuWIRFOzg5uCpDRpMj4OX-QryoDgn-yYlXQnRwQQ&with_sec_did=1&video_share_track_ver=&titleType=title&share_sign=VdBm…m3_elmOirg8xheKTlVqP.NCvbEI89e5k62ryg-&share_version=280700&ts=1772204581&from_aid=1128&from_ssr=1&share_track_info=%7B%22link_description_type%22%3A%22%22%7D

[146] 将 Pod 分配到节点 | Kubernetes (K8s) 容器编排系统 https://v1-30.kubernetes.ac.cn/docs/concepts/scheduling-eviction/assign-pod-node/

[147] 将 Pod 分配给节点 | Kubernetes (K8s) 容器编排系统 https://kubernetes.ac.cn/docs/concepts/scheduling-eviction/assign-pod-node/

[148] 【Kubernetes】(九)Pod调度-CSDN博客 https://blog.csdn.net/lxyydh88888888/article/details/151924532

[149] kubernetes/cmd/kube-controller-manager/app/core.go at master · kubernetes/kubernetes · GitHub https://github.com/kubernetes/kubernetes/blob/master/cmd/kube-controller-manager/app/core.go

[150] 【Kubernetes 源码剖析】kube-controller-manager 工作原理与实现-CSDN博客 https://blog.csdn.net/Ahri_J/article/details/150559209

[151] Kubernetes: kube-controller-manager 源码分析 https://www.cnblogs.com/xingzheanan/p/18066472

[152] kube-controller-manager源码分析-AD controller分析 https://www.cnblogs.com/lianngkyle/p/14877829.html

[153] Kube Controller Manager 源码分析 https://developer.aliyun.com/article/688622

[154] 控制器概述 https://github.com/daniel-hutao/k8s-source-code-analysis/blob/master/core/controller-manager/controller.md

[155] 【技术】从POD创建看Kubernetes源码实现 (三)- kube-controller manager-CSDN博客 https://blog.csdn.net/u010494323/article/details/157180840

[156] Kubernetes源码阅读笔记——Controller Manager(之三)-CSDN博客 https://blog.csdn.net/weixin_30889885/article/details/98845070

[157] Kubernetes 控制器:从 Kubernetes 资源控制到开放应用模型、工作原理解读_什么情况触发 reconcile-CSDN博客 https://blog.csdn.net/fly910905/article/details/105099256

[158] 《深入理解Kubernetes》源码阅读方法与实践指南 https://www.iesdouyin.com/share/note/7416550563069873447/?region=&mid=6881996450729822215&u_code=0&did=MS4wLjABAAAANwkJuWIRFOzg5uCpDRpMj4OX-QryoDgn-yYlXQnRwQQ&iid=MS4wLjABAAAANwkJuWIRFOzg5uCpDRpMj4OX-QryoDgn-yYlXQnRwQQ&with_sec_did=1&video_share_track_ver=&titleType=title&schema_type=37&share_sign=94tLphsNvzdftP1BtQjiOWnhVkLpmQW0Z.lHY9LXs_U-&share_version=280700&ts=1772204605&from_aid=1128&from_ssr=1&share_track_info=%7B%22link_description_type%22%3A%22%22%7D

[159] Kubernetes控制平面组件:Controller Manager详解-CSDN博客 https://blog.csdn.net/a1369760658/article/details/147718758

[160] Kubernetes 1.12.0 Kube-controller-manager之deployment-controller源码阅读分析-CSDN博客 https://blog.csdn.net/choucou19790207/article/details/101007317

亚马逊云科技技术品牌专区

更多推荐

智能物联网场景下，支持多模型的AI平台实际表现解析

亚马逊云科技技术品牌专区

基于大数据+Hadoop+深度学习的淘宝用户购物可视化与行为预测系统设计与开发

亚马逊云科技技术品牌专区

空间智能场景下，AI算力成本优化的核心路径与平台选型

亚马逊云科技技术品牌专区

所有评论(0)

查看更多评论

tianyamingyue1993

@tianyamingyue1993

已为社区贡献12条内容

Kubernetes 源码深度解析：从架构设计到核心机制实现

tianyamingyue1993

Kubernetes 源码深度解析：从架构设计到核心机制实现

引言

一、版本定位与环境搭建

1.1 当前主流版本分析

1.2 开发环境配置要求

1.3 源码获取与构建

1.4 源码目录结构概览

二、整体架构概览与启动流程

2.1 核心组件架构设计

2.2 组件间通信机制

2.3 启动流程分析

三、API Server 源码深度解析

3.1 RESTful API 实现机制

3.2 认证授权机制

3.3 Watch 机制实现

3.4 自定义资源定义（CRD）机制

四、Scheduler 源码深度解析

4.1 Pod 调度流程

4.2 调度算法实现

4.3 调度框架与插件机制

4.4 节点亲和性与反亲和性

4.5 调度队列管理

五、Controller Manager 源码深度解析

5.1 控制器模式实现

5.2 工作队列机制

5.3 各类控制器实现

5.4 控制器协调机制

六、Kubelet 源码深度解析

6.1 Kubelet 架构与启动流程

6.2 Pod 生命周期管理

6.3 容器运行时接口（CRI）

6.4 健康检查机制

6.5 节点状态管理

七、网络策略源码深度解析

7.1 网络插件机制

7.2 网络策略控制器

7.3 服务发现与负载均衡

7.4 网络流量控制

八、存储管理源码深度解析

8.1 存储卷管理机制

8.2 PV/PVC 实现机制

8.3 存储插件接口

8.4 存储卷挂载流程

九、深入机制分析

9.1 client-go 库的使用

9.2 Informers 机制实现

9.3 工作队列设计模式

9.4 controller-runtime 框架

十、实践建议与学习路径

10.1 环境搭建最佳实践

10.2 源码阅读方法

10.3 调试技巧

10.4 贡献指南

10.5 推荐学习资源

结语

所有评论(0)

温馨提示：您尚未绑定手机号

tianyamingyue1993