┌─────────────────────────────────────────────────────────────────────────────┐
│                  起点：Run() 函数                                             │
│                  cmd/kube-apiserver/app/server.go:154                       │
├─────────────────────────────────────────────────────────────────────────────┤
│  func Run(ctx context.Context, opts options.CompletedOptions) error {      │
│      // 🔥 第一步：创建配置                                                  │
│      config, err := NewConfig(opts)                                        │
│      //                  👆                                                │
│      //                  传入命令行选项                                     │
│                                                                             │
│      completed, err := config.Complete()                                   │
│      server, err := CreateServerChain(completed)                           │
│      prepared, err := server.PrepareRun()                                  │
│      return prepared.Run(ctx)                                              │
│  }                                                                         │
└─────────────────────────────────────────────────────────────────────────────┘
                                    ↓
┌─────────────────────────────────────────────────────────────────────────────┐
│                  第一步：NewConfig() 创建总配置                               │
│                  cmd/kube-apiserver/app/config.go:74                        │
├─────────────────────────────────────────────────────────────────────────────┤
│  func NewConfig(opts options.CompletedOptions) (*Config, error) {          │
│      c := &Config{                                                         │
│          Options: opts,  // 保存命令行选项                                  │
│      }                                                                      │
│                                                                             │
│      // 🔥 步骤 1.1：构建 Generic Config（通用配置）                         │
│      genericConfig, versionedInformers, storageFactory, err :=             │
│          controlplaneapiserver.BuildGenericConfig(                         │
│              opts.CompletedOptions,                                        │
│              []*runtime.Scheme{                                            │
│                  legacyscheme.Scheme,           // Kube 核心资源            │
│                  apiextensionsapiserver.Scheme, // CRD 资源                │
│                  aggregatorscheme.Scheme,       // AA 资源                 │
│              },                                                            │
│              controlplane.DefaultAPIResourceConfigSource(),                │
│              generatedopenapi.GetOpenAPIDefinitions,                       │
│          )                                                                 │
│      // 返回：                                                              │
│      //   - genericConfig: 通用 API Server 配置（认证、授权、审计等）        │
│      //   - versionedInformers: 共享 Informer 工厂                         │
│      //   - storageFactory: 存储工厂（etcd 配置）                           │
│                                                                             │
│      // 继续下一步...                                                       │
│  }                                                                         │
└─────────────────────────────────────────────────────────────────────────────┘
                                    ↓
┌─────────────────────────────────────────────────────────────────────────────┐
│                  第二步：CreateKubeAPIServerConfig()                         │
│                  cmd/kube-apiserver/app/config.go:89                        │
├─────────────────────────────────────────────────────────────────────────────┤
│  func NewConfig(opts options.CompletedOptions) (*Config, error) {          │
│      // ... 接上一步                                                        │
│                                                                             │
│      // 🔥 步骤 1.2：创建 Kube API Server 配置                              │
│      kubeAPIs, serviceResolver, pluginInitializer, err :=                  │
│          CreateKubeAPIServerConfig(                                        │
│              opts,                  // 命令行选项                           │
│              genericConfig,         // 通用配置（步骤 1.1 的输出）           │
│              versionedInformers,    // Informer 工厂                        │
│              storageFactory,        // 存储工厂                             │
│          )                                                                 │
│      // 返回：                                                              │
│      //   - kubeAPIs: Kube API Server 配置                                 │
│      //       └─ kubeAPIs.ControlPlane.Generic: Generic Config             │
│      //       └─ kubeAPIs.ControlPlane.VersionedInformers: Informers       │
│      //       └─ kubeAPIs.ControlPlane.ProxyTransport: 代理传输             │
│      //   - serviceResolver: 服务解析器                                     │
│      //   - pluginInitializer: 准入插件初始化器                             │
│                                                                             │
│      c.KubeAPIs = kubeAPIs  // 保存到 Config                               │
│                                                                             │
│      // 继续下一步...                                                       │
│  }                                                                         │
└─────────────────────────────────────────────────────────────────────────────┘
                                    ↓
┌─────────────────────────────────────────────────────────────────────────────┐
│                  第三步：CreateAPIExtensionsConfig() 👈 关键！                │
│                  cmd/kube-apiserver/app/config.go:95                        │
├─────────────────────────────────────────────────────────────────────────────┤
│  func NewConfig(opts options.CompletedOptions) (*Config, error) {          │
│      // ... 接上一步                                                        │
│                                                                             │
│      // 🔥🔥🔥 步骤 1.3：创建 API Extensions Server 配置                    │
│      apiExtensions, err := controlplaneapiserver.CreateAPIExtensionsConfig(│
│          //                 👆                                             │
│          //                 调用 pkg/controlplane/apiserver/apiextensions.go│
│                                                                             │
│          // 参数 1：Generic Config（从 kubeAPIs 中提取）                    │
│          *kubeAPIs.ControlPlane.Generic,                                   │
│          //  👆 包含：认证、授权、审计、etcd、序列化器等通用配置              │
│                                                                             │
│          // 参数 2：Informer 工厂（从 kubeAPIs 中提取）                     │
│          kubeAPIs.ControlPlane.VersionedInformers,                         │
│          //  👆 共享 Informer，监听 Kube 资源变化                           │
│                                                                             │
│          // 参数 3：准入插件初始化器（从步骤 1.2 返回）                      │
│          pluginInitializer,                                                │
│          //  👆 用于初始化准入控制插件                                       │
│                                                                             │
│          // 参数 4：命令行选项（原始输入）                                   │
│          opts.CompletedOptions,                                            │
│          //  👆 包含 etcd、API 启用等配置                                   │
│                                                                             │
│          // 参数 5：Master 节点数（从 opts 中提取）                          │
│          opts.MasterCount,                                                 │
│          //  👆 用于 HA 检测                                                │
│                                                                             │
│          // 参数 6：服务解析器（从步骤 1.2 返回）                            │
│          serviceResolver,                                                  │
│          //  👆 解析 Webhook Service 名称为地址                             │
│                                                                             │
│          // 参数 7：认证解析器包装器（现场创建）                             │
│          webhook.NewDefaultAuthenticationInfoResolverWrapper(              │
│              kubeAPIs.ControlPlane.ProxyTransport,      // 代理传输         │
│              kubeAPIs.ControlPlane.Generic.EgressSelector, // 出口选择器    │
│              kubeAPIs.ControlPlane.Generic.LoopbackClientConfig, // 回环配置│
│              kubeAPIs.ControlPlane.Generic.TracerProvider, // 追踪提供者    │
│          ),                                                                │
│          //  👆 为 Webhook 提供认证信息                                     │
│      )                                                                      │
│                                                                             │
│      c.ApiExtensions = apiExtensions  // 保存到 Config                     │
│                                                                             │
│      // 继续下一步...                                                       │
│  }                                                                         │
└─────────────────────────────────────────────────────────────────────────────┘
                                    ↓
┌─────────────────────────────────────────────────────────────────────────────┐
│                  第四步：进入 CreateAPIExtensionsConfig()                    │
│                  pkg/controlplane/apiserver/apiextensions.go:34             │
├─────────────────────────────────────────────────────────────────────────────┤
│  func CreateAPIExtensionsConfig(                                           │
│      kubeAPIServerConfig server.Config,                 // 👈 参数 1        │
│      kubeInformers informers.SharedInformerFactory,     // 👈 参数 2        │
│      pluginInitializers []admission.PluginInitializer,  // 👈 参数 3        │
│      commandOptions options.CompletedOptions,           // 👈 参数 4        │
│      masterCount int,                                   // 👈 参数 5        │
│      serviceResolver webhook.ServiceResolver,           // 👈 参数 6        │
│      authResolverWrapper webhook.AuthenticationInfoResolverWrapper, // 👈 7 │
│  ) (*apiextensionsapiserver.Config, error) {                               │
│                                                                             │
│      // 步骤 4.1：复制并清理 Generic Config                                 │
│      genericConfig := kubeAPIServerConfig                                  │
│      genericConfig.PostStartHooks = map[string]...{}                       │
│      genericConfig.RESTOptionsGetter = nil                                 │
│                                                                             │
│      // 步骤 4.2：配置 etcd 存储                                            │
│      etcdOptions := *commandOptions.Etcd                                   │
│      etcdOptions.StorageConfig.Codec = ...                                 │
│      etcdOptions.StorageConfig.EncodeVersioner = ...                       │
│      etcdOptions.ApplyTo(&genericConfig)                                   │
│                                                                             │
│      // 步骤 4.3：配置 API 启用                                             │
│      commandOptions.APIEnablement.ApplyTo(&genericConfig, ...)             │
│                                                                             │
│      // 步骤 4.4：组装最终配置                                              │
│      apiextensionsConfig := &apiextensionsapiserver.Config{                │
│          GenericConfig: &server.RecommendedConfig{                         │
│              Config:                genericConfig,                         │
│              SharedInformerFactory: kubeInformers,                         │
│          },                                                                │
│          ExtraConfig: apiextensionsapiserver.ExtraConfig{                  │
│              CRDRESTOptionsGetter: NewCRDRESTOptionsGetter(...),           │
│              MasterCount:          masterCount,                            │
│              AuthResolverWrapper:  authResolverWrapper,                    │
│              ServiceResolver:      serviceResolver,                        │
│          },                                                                │
│      }                                                                     │
│                                                                             │
│      return apiextensionsConfig, nil                                       │
│  }                                                                         │
└─────────────────────────────────────────────────────────────────────────────┘
                                    ↓
┌─────────────────────────────────────────────────────────────────────────────┐
│                  第五步：返回到 NewConfig()                                   │
│                  cmd/kube-apiserver/app/config.go:101                       │
├─────────────────────────────────────────────────────────────────────────────┤
│  func NewConfig(opts options.CompletedOptions) (*Config, error) {          │
│      // ... 接步骤 1.3                                                      │
│                                                                             │
│      c.ApiExtensions = apiExtensions  // 保存 API Extensions 配置          │
│                                                                             │
│      // 🔥 步骤 1.4：创建 Aggregator Server 配置                            │
│      aggregator, err := controlplaneapiserver.CreateAggregatorConfig(      │
│          *kubeAPIs.ControlPlane.Generic,                                   │
│          opts.CompletedOptions,                                            │
│          kubeAPIs.ControlPlane.VersionedInformers,                         │
│          serviceResolver,                                                  │
│          kubeAPIs.ControlPlane.ProxyTransport,                             │
│          kubeAPIs.ControlPlane.Extra.PeerProxy,                            │
│          pluginInitializer,                                                │
│      )                                                                      │
│      c.Aggregator = aggregator  // 保存 Aggregator 配置                    │
│                                                                             │
│      return c, nil  // 🎯 返回完整配置                                      │
│  }                                                                         │
└─────────────────────────────────────────────────────────────────────────────┘
                                    ↓
┌─────────────────────────────────────────────────────────────────────────────┐
│                  最终结果：Config 结构体                                      │
│                  cmd/kube-apiserver/app/config.go:33                        │
├─────────────────────────────────────────────────────────────────────────────┤
│  type Config struct {                                                      │
│      Options options.CompletedOptions  // 命令行选项                        │
│                                                                             │
│      Aggregator    *aggregatorapiserver.Config       // 聚合层配置          │
│      KubeAPIs      *controlplane.Config              // 核心 API 配置       │
│      ApiExtensions *apiextensionsapiserver.Config    // 扩展 API 配置 👈    │
│                                                                             │
│      ExtraConfig                                                           │
│  }                                                                         │
│                                                                             │
│  // 三个配置的关系：                                                         │
│  // 1. 都基于同一个 Generic Config（通用配置）                              │
│  // 2. 共享同一个 Informer 工厂                                             │
│  // 3. 使用相同的 serviceResolver 和 pluginInitializer                     │
│  // 4. 各自有专属的 ExtraConfig                                             │
└─────────────────────────────────────────────────────────────────────────────┘

// 代码: pkg\controlplane\apiserver\apiextensions.go#L34-L86
func CreateAPIExtensionsConfig(
	kubeAPIServerConfig server.Config,
	kubeInformers informers.SharedInformerFactory,
	pluginInitializers []admission.PluginInitializer,
	commandOptions options.CompletedOptions,
	masterCount int,
	serviceResolver webhook.ServiceResolver,
	authResolverWrapper webhook.AuthenticationInfoResolverWrapper,
) (*apiextensionsapiserver.Config, error) {
	// make a shallow copy to let us twiddle a few things
	// most of the config actually remains the same.  We only need to mess with a couple items related to the particulars of the apiextensions
    // 要点①
	genericConfig := kubeAPIServerConfig
	genericConfig.PostStartHooks = map[string]server.PostStartHookConfigEntry{}
	genericConfig.RESTOptionsGetter = nil

	// copy the etcd options so we don't mutate originals.
	// we assume that the etcd options have been completed already.  avoid messing with anything outside
	// of changes to StorageConfig as that may lead to unexpected behavior when the options are applied.
	etcdOptions := *commandOptions.Etcd
	// this is where the true decodable levels come from.
	etcdOptions.StorageConfig.Codec = apiextensionsapiserver.Codecs.LegacyCodec(v1beta1.SchemeGroupVersion, v1.SchemeGroupVersion)
	// prefer the more compact serialization (v1beta1) for storage until https://issue.k8s.io/82292 is resolved for objects whose v1 serialization is too big but whose v1beta1 serialization can be stored
	etcdOptions.StorageConfig.EncodeVersioner = runtime.NewMultiGroupVersioner(v1beta1.SchemeGroupVersion, schema.GroupKind{Group: v1beta1.GroupName})
	etcdOptions.SkipHealthEndpoints = true // avoid double wiring of health checks
	if err := etcdOptions.ApplyTo(&genericConfig); err != nil {
		return nil, err
	}

	// override MergedResourceConfig with apiextensions defaults and registry
	if err := commandOptions.APIEnablement.ApplyTo(
		&genericConfig,
		apiextensionsapiserver.DefaultAPIResourceConfigSource(),
		apiextensionsapiserver.Scheme); err != nil {
		return nil, err
	}
	apiextensionsConfig := &apiextensionsapiserver.Config{     // 要点②
		GenericConfig: &server.RecommendedConfig{	// 要点③
			Config:                genericConfig,
			SharedInformerFactory: kubeInformers,
		},
		ExtraConfig: apiextensionsapiserver.ExtraConfig{	// 要点④
			CRDRESTOptionsGetter: apiextensionsoptions.NewCRDRESTOptionsGetter(etcdOptions, genericConfig.ResourceTransformers, genericConfig.StorageObjectCountTracker),
			MasterCount:          masterCount,
			AuthResolverWrapper:  authResolverWrapper,
			ServiceResolver:      serviceResolver,
		},
	}

	// we need to clear the poststarthooks so we don't add them multiple times to all the servers (that fails)
	apiextensionsConfig.GenericConfig.PostStartHooks = map[string]server.PostStartHookConfigEntry{}

	return apiextensionsConfig, nil
}

┌─────────────────────────────────────────────────────────────────────────────┐
│                  起点：Run() 函数                                             │
│                  cmd/kube-apiserver/app/server.go:148                       │
├─────────────────────────────────────────────────────────────────────────────┤
│  func Run(ctx context.Context, opts options.CompletedOptions) error {      │
│      ...                                                                   │
│      config, err := NewConfig(opts)                                        │
│      completed, err := config.Complete()                                   │
│      server, err := CreateServerChain(completed)  // 👈 关键                │
│      ...                                                                   │
│  }                                                                         │
└─────────────────────────────────────────────────────────────────────────────┘
                                    ↓
┌─────────────────────────────────────────────────────────────────────────────┐
│                  CreateServerChain() - 创建服务器链                           │
│                  cmd/kube-apiserver/app/server.go:176                       │
├─────────────────────────────────────────────────────────────────────────────┤
│  func CreateServerChain(config CompletedConfig) (*APIAggregator, error) {  │
│      notFoundHandler := notfoundhandler.New(...)                           │
│                                                                             │
│      // 🔥 调用扩展 API Server 的 New 方法                                   │
│      apiExtensionsServer, err := config.ApiExtensions.New(                 │
│          genericapiserver.NewEmptyDelegateWithCustomHandler(notFoundHandler)│
│      )                                                                      │
│      // 👆 到达目标：apiserver.go:127                                       │
│                                                                             │
│      kubeAPIServer, err := config.KubeAPIs.New(...)                        │
│      aggregatorServer, err := CreateAggregatorServer(...)                  │
│      return aggregatorServer, nil                                          │
│  }                                                                         │
└─────────────────────────────────────────────────────────────────────────────┘
                                    ↓
┌─────────────────────────────────────────────────────────────────────────────┐
│                  目标：apiExtensions.New()                                   │
│                  staging/src/k8s.io/apiextensions-apiserver/pkg/apiserver/ │
│                  apiserver.go:127                                           │
├─────────────────────────────────────────────────────────────────────────────┤
│  func (c completedConfig) New(delegationTarget DelegationTarget)           │
│      (*CustomResourceDefinitions, error) {                                 │
│      ...                                                                   │
│  }                                                                         │
└─────────────────────────────────────────────────────────────────────────────┘

// 代码: staging\src\k8s.io\apiextensions-apiserver\pkg\apis\apiextensions\install\install.go#L17-L33
package install

import (
	"k8s.io/apiextensions-apiserver/pkg/apis/apiextensions"
	v1 "k8s.io/apiextensions-apiserver/pkg/apis/apiextensions/v1"
	"k8s.io/apiextensions-apiserver/pkg/apis/apiextensions/v1beta1"
	"k8s.io/apimachinery/pkg/runtime"
	utilruntime "k8s.io/apimachinery/pkg/util/runtime"
)

// Install registers the API group and adds types to a scheme
func Install(scheme *runtime.Scheme) {
	utilruntime.Must(apiextensions.AddToScheme(scheme))
	utilruntime.Must(v1beta1.AddToScheme(scheme))
	utilruntime.Must(v1.AddToScheme(scheme))
	utilruntime.Must(scheme.SetVersionPriority(v1.SchemeGroupVersion, v1beta1.SchemeGroupVersion))
}

// 代码: staging\src\k8s.io\apiextensions-apiserver\pkg\apiserver\apiserver.go#L54-L77
var (
	Scheme = runtime.NewScheme() //要点①
	Codecs = serializer.NewCodecFactory(Scheme)

	// if you modify this, make sure you update the crEncoder
	unversionedVersion = schema.GroupVersion{Group: "", Version: "v1"}
	unversionedTypes   = []runtime.Object{
		&metav1.Status{},
		&metav1.WatchEvent{},
		&metav1.APIVersions{},
		&metav1.APIGroupList{},
		&metav1.APIGroup{},
		&metav1.APIResourceList{},
	}
)

func init() {
	install.Install(Scheme) //要点②

	// we need to add the options to empty v1
	metav1.AddToGroupVersion(Scheme, schema.GroupVersion{Group: "", Version: "v1"})

	Scheme.AddUnversionedTypes(unversionedVersion, unversionedTypes...)
}

// 代码: staging\src\k8s.io\apiextensions-apiserver\pkg\apiserver\apiserver.go#L145-163
// New returns a new instance of CustomResourceDefinitions from the given config.
func (c completedConfig) New(delegationTarget genericapiserver.DelegationTarget) (*CustomResourceDefinitions, error) {
	genericServer, err := c.GenericConfig.New("apiextensions-apiserver", delegationTarget)
	if err != nil {
		return nil, err
	}

	// hasCRDInformerSyncedSignal is closed when the CRD informer this server uses has been fully synchronized.
	// It ensures that requests to potential custom resource endpoints while the server hasn't installed all known HTTP paths get a 503 error instead of a 404
	hasCRDInformerSyncedSignal := make(chan struct{})
	if err := genericServer.RegisterMuxAndDiscoveryCompleteSignal("CRDInformerHasNotSynced", hasCRDInformerSyncedSignal); err != nil {
		return nil, err
	}

	s := &CustomResourceDefinitions{
		GenericAPIServer: genericServer,
	}

	apiResourceConfig := c.GenericConfig.MergedResourceConfig
	apiGroupInfo := genericapiserver.NewDefaultAPIGroupInfo(apiextensions.GroupName, Scheme, metav1.ParameterCodec, Codecs)
	storage := map[string]rest.Storage{}
	// customresourcedefinitions
	if resource := "customresourcedefinitions"; apiResourceConfig.ResourceEnabled(v1.SchemeGroupVersion.WithResource(resource)) {
		customResourceDefinitionStorage, err := customresourcedefinition.NewREST(Scheme, c.GenericConfig.RESTOptionsGetter)
		if err != nil {
			return nil, err
		}
		storage[resource] = customResourceDefinitionStorage
		storage[resource+"/status"] = customresourcedefinition.NewStatusREST(Scheme, customResourceDefinitionStorage)
	}
	if len(storage) > 0 {
		apiGroupInfo.VersionedResourcesStorageMap[v1.SchemeGroupVersion.Version] = storage
	}

	if err := s.GenericAPIServer.InstallAPIGroup(&apiGroupInfo); err != nil {
		return nil, err
	}
    ...
}

// 代码: staging\src\k8s.io\apiextensions-apiserver\pkg\apiserver\apiserver.go#L164-L208
func (c completedConfig) New(delegationTarget genericapiserver.DelegationTarget) (*CustomResourceDefinitions, error) {
	crdClient, err := clientset.NewForConfig(s.GenericAPIServer.LoopbackClientConfig)
	if err != nil {
		// it's really bad that this is leaking here, but until we can fix the test (which I'm pretty sure isn't even testing what it wants to test),
		// we need to be able to move forward
		return nil, fmt.Errorf("failed to create clientset: %v", err)
	}
	s.Informers = externalinformers.NewSharedInformerFactory(crdClient, 5*time.Minute)

	delegateHandler := delegationTarget.UnprotectedHandler()
	if delegateHandler == nil {
		delegateHandler = http.NotFoundHandler()
	}

	versionDiscoveryHandler := &versionDiscoveryHandler{
		discovery: map[schema.GroupVersion]*discovery.APIVersionHandler{},
		delegate:  delegateHandler,
	}
	groupDiscoveryHandler := &groupDiscoveryHandler{
		discovery: map[string]*discovery.APIGroupHandler{},
		delegate:  delegateHandler,
	}
	establishingController := establish.NewEstablishingController(s.Informers.Apiextensions().V1().CustomResourceDefinitions(), crdClient.ApiextensionsV1())
	crdHandler, err := NewCustomResourceDefinitionHandler(
		versionDiscoveryHandler,
		groupDiscoveryHandler,
		s.Informers.Apiextensions().V1().CustomResourceDefinitions(),
		delegateHandler,
		c.ExtraConfig.CRDRESTOptionsGetter,
		c.GenericConfig.AdmissionControl,
		establishingController,
		c.ExtraConfig.ServiceResolver,
		c.ExtraConfig.AuthResolverWrapper,
		c.ExtraConfig.MasterCount,
		s.GenericAPIServer.Authorizer,
		c.GenericConfig.RequestTimeout,
		time.Duration(c.GenericConfig.MinRequestTimeout)*time.Second,
		apiGroupInfo.StaticOpenAPISpec,
		c.GenericConfig.MaxRequestBodyBytes,
	)
	if err != nil {
		return nil, err
	}
	s.GenericAPIServer.Handler.NonGoRestfulMux.Handle("/apis", crdHandler)
	s.GenericAPIServer.Handler.NonGoRestfulMux.HandlePrefix("/apis/", crdHandler)
	s.GenericAPIServer.RegisterDestroyFunc(crdHandler.destroy)

s.GenericAPIServer.Handler.NonGoRestfulMux.Handle("/apis", crdHandler)
s.GenericAPIServer.Handler.NonGoRestfulMux.HandlePrefix("/apis/", crdHandler)

// 代码: staging\src\k8s.io\apiextensions-apiserver\pkg\apiserver\customresource_handler.go#L228-L366
func (r *crdHandler) ServeHTTP(w http.ResponseWriter, req *http.Request) {
	ctx := req.Context()
	requestInfo, ok := apirequest.RequestInfoFrom(ctx) // 要点①
	...
	if !requestInfo.IsResourceRequest { // 要点②
		pathParts := splitPath(requestInfo.Path) 
		// only match /apis/<group>/<version>
		// only registered under /apis
		if len(pathParts) == 3 { // 要点③
			r.versionDiscoveryHandler.ServeHTTP(w, req)
			return
		}
		// only match /apis/<group>
		if len(pathParts) == 2 { // 要点④
			r.groupDiscoveryHandler.ServeHTTP(w, req)
			return
		}

		r.delegate.ServeHTTP(w, req) // 要点⑤
		return
	}
	// 要点⑥
	crdName := requestInfo.Resource + "." + requestInfo.APIGroup
	...
}

// 代码: staging\src\k8s.io\apiextensions-apiserver\pkg\apiserver\customresource_handler.go#L228-L366
func (r *crdHandler) ServeHTTP(w http.ResponseWriter, req *http.Request) {
    ...
	crdName := requestInfo.Resource + "." + requestInfo.APIGroup
	crd, err := r.crdLister.Get(crdName)
	if apierrors.IsNotFound(err) {
		r.delegate.ServeHTTP(w, req)
		return
	}
	if err != nil {
		utilruntime.HandleError(err)
		responsewriters.ErrorNegotiated(
			apierrors.NewInternalError(fmt.Errorf("error resolving resource")),
			Codecs, schema.GroupVersion{Group: requestInfo.APIGroup, Version: requestInfo.APIVersion}, w, req,
		)
		return
	}

	// if the scope in the CRD and the scope in request differ (with exception of the verbs in possiblyAcrossAllNamespacesVerbs
	// for namespaced resources), pass request to the delegate, which is supposed to lead to a 404.
	namespacedCRD, namespacedReq := crd.Spec.Scope == apiextensionsv1.NamespaceScoped, len(requestInfo.Namespace) > 0
	if !namespacedCRD && namespacedReq {
		r.delegate.ServeHTTP(w, req)
		return
	}
	if namespacedCRD && !namespacedReq && !possiblyAcrossAllNamespacesVerbs.Has(requestInfo.Verb) {
		r.delegate.ServeHTTP(w, req)
		return
	}

	if !apiextensionshelpers.HasServedCRDVersion(crd, requestInfo.APIVersion) {
		r.delegate.ServeHTTP(w, req)
		return
	}

	// There is a small chance that a CRD is being served because NamesAccepted condition is true,
	// but it becomes "unserved" because another names update leads to a conflict
	// and EstablishingController wasn't fast enough to put the CRD into the Established condition.
	// We accept this as the problem is small and self-healing.
	if !apiextensionshelpers.IsCRDConditionTrue(crd, apiextensionsv1.NamesAccepted) &&
		!apiextensionshelpers.IsCRDConditionTrue(crd, apiextensionsv1.Established) {
		r.delegate.ServeHTTP(w, req)
		return
	}

	terminating := apiextensionshelpers.IsCRDConditionTrue(crd, apiextensionsv1.Terminating)

	crdInfo, err := r.getOrCreateServingInfoFor(crd.UID, crd.Name)
	if apierrors.IsNotFound(err) {
		r.delegate.ServeHTTP(w, req)
		return
	}
	if err != nil {
		utilruntime.HandleError(err)
		responsewriters.ErrorNegotiated(
			apierrors.NewInternalError(fmt.Errorf("error resolving resource")),
			Codecs, schema.GroupVersion{Group: requestInfo.APIGroup, Version: requestInfo.APIVersion}, w, req,
		)
		return
	}
	if !hasServedCRDVersion(crdInfo.spec, requestInfo.APIVersion) {
		r.delegate.ServeHTTP(w, req)
		return
	}

	deprecated := crdInfo.deprecated[requestInfo.APIVersion]
	for _, w := range crdInfo.warnings[requestInfo.APIVersion] {
		warning.AddWarning(req.Context(), "", w)
	}

	verb := strings.ToUpper(requestInfo.Verb)
	resource := requestInfo.Resource
	subresource := requestInfo.Subresource
	scope := metrics.CleanScope(requestInfo)
	supportedTypes := []string{
		string(types.JSONPatchType),
		string(types.MergePatchType),
		string(types.ApplyYAMLPatchType),
	}
	if utilfeature.DefaultFeatureGate.Enabled(features.CBORServingAndStorage) {
		supportedTypes = append(supportedTypes, string(types.ApplyCBORPatchType))
	}

	var handlerFunc http.HandlerFunc
	subresources, err := apiextensionshelpers.GetSubresourcesForVersion(crd, requestInfo.APIVersion)
	if err != nil {
		utilruntime.HandleError(err)
		responsewriters.ErrorNegotiated(
			apierrors.NewInternalError(fmt.Errorf("could not properly serve the subresource")),
			Codecs, schema.GroupVersion{Group: requestInfo.APIGroup, Version: requestInfo.APIVersion}, w, req,
		)
		return
	}
	switch {
	case subresource == "status" && subresources != nil && subresources.Status != nil:
		handlerFunc = r.serveStatus(w, req, requestInfo, crdInfo, terminating, supportedTypes)
	case subresource == "scale" && subresources != nil && subresources.Scale != nil:
		handlerFunc = r.serveScale(w, req, requestInfo, crdInfo, terminating, supportedTypes)
	case len(subresource) == 0:
		handlerFunc = r.serveResource(w, req, requestInfo, crdInfo, crd, terminating, supportedTypes)
	default:
		responsewriters.ErrorNegotiated(
			apierrors.NewNotFound(schema.GroupResource{Group: requestInfo.APIGroup, Resource: requestInfo.Resource}, requestInfo.Name),
			Codecs, schema.GroupVersion{Group: requestInfo.APIGroup, Version: requestInfo.APIVersion}, w, req,
		)
	}

	if handlerFunc != nil {
		handlerFunc = metrics.InstrumentHandlerFunc(verb, requestInfo.APIGroup, requestInfo.APIVersion, resource, subresource, scope, metrics.APIServerComponent, deprecated, "", handlerFunc)
		handler := genericfilters.WithWaitGroup(handlerFunc, longRunningFilter, crdInfo.waitGroup)
		handler.ServeHTTP(w, req)
		return
	}
}

┌─────────────────────────────────────────────────────────────────────────────┐
│  收到请求，获取信息                                                           │
│  requestInfo := apirequest.RequestInfoFrom(ctx)                             │
└─────────────────────────────────────────────────────────────────────────────┘
                                    ↓
┌─────────────────────────────────────────────────────────────────────────────┐
│  校验请求                                                                    │
│  - CRD 是否存在？                                                            │
│  - Namespace 作用域是否匹配？                                                 │
│  - API 版本是否支持？                                                         │
│  - CRD 是否已 Established？                                                  │
│  （任一校验失败 → delegate 处理）                                              │
└─────────────────────────────────────────────────────────────────────────────┘
                                    ↓
┌─────────────────────────────────────────────────────────────────────────────┐
│  获取 CRD 实例                                                               │
│  crd, err := r.crdLister.Get(crdName)                                       │
└─────────────────────────────────────────────────────────────────────────────┘
                                    ↓
┌─────────────────────────────────────────────────────────────────────────────┐
│  获取 crdInfo（调方法 GetSubresourcesForVersion）                             │
│  crdInfo := r.getOrCreateServingInfoFor(crd.UID, crd.Name)                  │
│  subresources := GetSubresourcesForVersion(crd, requestInfo.APIVersion)     │
└─────────────────────────────────────────────────────────────────────────────┘
                                    ↓
                    ┌───────────────┼───────────────┐
                    ↓               ↓               ↓
              ../status        无子资源         ../scale
                    ↓               ↓               ↓
┌─────────────┐ ┌─────────────┐ ┌─────────────┐
│ serveStatus │ │serveResource│ │ serveScale  │
│ status子资源 │ │ 客制化资源   │ │ scale子资源  │
│   响应器     │ │   响应器     │ │   响应器     │
└─────────────┘ └─────────────┘ └─────────────┘
                    └───────────────┼───────────────┘
                                    ↓
┌─────────────────────────────────────────────────────────────────────────────┐
│  调用响应器                                                                  │
│  handler.ServeHTTP(w, req)                                                  │
└─────────────────────────────────────────────────────────────────────────────┘

// 代码: staging\src\k8s.io\apiextensions-apiserver\pkg\apiserver\apiserver.go#L210-L274
func (c completedConfig) New(delegationTarget genericapiserver.DelegationTarget) (*CustomResourceDefinitions, error) {
    ...
	aggregatedDiscoveryManager := genericServer.AggregatedDiscoveryGroupManager
	if aggregatedDiscoveryManager != nil {
		aggregatedDiscoveryManager = aggregatedDiscoveryManager.WithSource(aggregated.CRDSource)
	}
	discoveryController := NewDiscoveryController(s.Informers.Apiextensions().V1().CustomResourceDefinitions(), versionDiscoveryHandler, groupDiscoveryHandler, aggregatedDiscoveryManager)
	namingController := status.NewNamingConditionController(klog.TODO() /* for contextual logging */, s.Informers.Apiextensions().V1().CustomResourceDefinitions(), crdClient.ApiextensionsV1())
	nonStructuralSchemaController := nonstructuralschema.NewConditionController(s.Informers.Apiextensions().V1().CustomResourceDefinitions(), crdClient.ApiextensionsV1())
	apiApprovalController := apiapproval.NewKubernetesAPIApprovalPolicyConformantConditionController(s.Informers.Apiextensions().V1().CustomResourceDefinitions(), crdClient.ApiextensionsV1())
	finalizingController := finalizer.NewCRDFinalizer(
		s.Informers.Apiextensions().V1().CustomResourceDefinitions(),
		crdClient.ApiextensionsV1(),
		crdHandler,
	)

	s.GenericAPIServer.AddPostStartHookOrDie("start-apiextensions-informers", func(hookContext genericapiserver.PostStartHookContext) error {
		s.Informers.Start(hookContext.Done())
		return nil
	})
	s.GenericAPIServer.AddPostStartHookOrDie("start-apiextensions-controllers", func(hookContext genericapiserver.PostStartHookContext) error {
		// OpenAPIVersionedService and StaticOpenAPISpec are populated in generic apiserver PrepareRun().
		// Together they serve the /openapi/v2 endpoint on a generic apiserver. A generic apiserver may
		// choose to not enable OpenAPI by having null openAPIConfig, and thus OpenAPIVersionedService
		// and StaticOpenAPISpec are both null. In that case we don't run the CRD OpenAPI controller.
		if s.GenericAPIServer.StaticOpenAPISpec != nil {
			if s.GenericAPIServer.OpenAPIVersionedService != nil {
				openapiController := openapicontroller.NewController(s.Informers.Apiextensions().V1().CustomResourceDefinitions())
				go openapiController.Run(s.GenericAPIServer.StaticOpenAPISpec, s.GenericAPIServer.OpenAPIVersionedService, hookContext.Done())
			}

			if s.GenericAPIServer.OpenAPIV3VersionedService != nil {
				openapiv3Controller := openapiv3controller.NewController(s.Informers.Apiextensions().V1().CustomResourceDefinitions())
				go openapiv3Controller.Run(s.GenericAPIServer.OpenAPIV3VersionedService, hookContext.Done())
			}
		}

		go namingController.Run(hookContext.Done())
		go establishingController.Run(hookContext.Done())
		go nonStructuralSchemaController.Run(5, hookContext.Done())
		go apiApprovalController.Run(5, hookContext.Done())
		go finalizingController.Run(5, hookContext.Done())

		discoverySyncedCh := make(chan struct{})
		go discoveryController.Run(hookContext.Done(), discoverySyncedCh)
		select {
		case <-hookContext.Done():
		case <-discoverySyncedCh:
		}

		return nil
	})
	// we don't want to report healthy until we can handle all CRDs that have already been registered.  Waiting for the informer
	// to sync makes sure that the lister will be valid before we begin.  There may still be races for CRDs added after startup,
	// but we won't go healthy until we can handle the ones already present.
	s.GenericAPIServer.AddPostStartHookOrDie("crd-informer-synced", func(ctx genericapiserver.PostStartHookContext) error {
		return wait.PollUntilContextCancel(ctx.Context, 100*time.Millisecond, true, func(ctx context.Context) (bool, error) {
			if s.Informers.Apiextensions().V1().CustomResourceDefinitions().Informer().HasSynced() {
				close(hasCRDInformerSyncedSignal)
				return true, nil
			}
			return false, nil
		})
	})

	return s, nil
}