// 代码: staging\src\k8s.io\kube-aggregator\pkg\apis\apiregistration\types.go#L46-L86
// APIServiceSpec contains information for locating and communicating with a server.
// Only https is supported, though you are able to disable certificate verification.
type APIServiceSpec struct {
	// Service is a reference to the service for this API server.  It must communicate
	// on port 443.
	// If the Service is nil, that means the handling for the API groupversion is handled locally on this server.
	// The call will simply delegate to the normal handler chain to be fulfilled.
	// +optional
	Service *ServiceReference
	// Group is the API group name this server hosts
	Group string
	// Version is the API version this server hosts.  For example, "v1"
	Version string

	// InsecureSkipTLSVerify disables TLS certificate verification when communicating with this server.
	// This is strongly discouraged.  You should use the CABundle instead.
	InsecureSkipTLSVerify bool
	// CABundle is a PEM encoded CA bundle which will be used to validate an API server's serving certificate.
	// If unspecified, system trust roots on the apiserver are used.
	// +listType=atomic
	// +optional
	CABundle []byte

	// GroupPriorityMinimum is the priority this group should have at least. Higher priority means that the group is preferred by clients over lower priority ones.
	// Note that other versions of this group might specify even higher GroupPriorityMinimum values such that the whole group gets a higher priority.
	// The primary sort is based on GroupPriorityMinimum, ordered highest number to lowest (20 before 10).
	// The secondary sort is based on the alphabetical comparison of the name of the object.  (v1.bar before v1.foo)
	// We'd recommend something like: *.k8s.io (except extensions) at 18000 and
	// PaaSes (OpenShift, Deis) are recommended to be in the 2000s
	GroupPriorityMinimum int32

	// VersionPriority controls the ordering of this API version inside of its group.  Must be greater than zero.
	// The primary sort is based on VersionPriority, ordered highest to lowest (20 before 10).
	// Since it's inside of a group, the number can be small, probably in the 10s.
	// In case of equal version priorities, the version string will be used to compute the order inside a group.
	// If the version string is "kube-like", it will sort above non "kube-like" version strings, which are ordered
	// lexicographically. "Kube-like" versions start with a "v", then are followed by a number (the major version),
	// then optionally the string "alpha" or "beta" and another number (the minor version). These are sorted first
	// by GA > beta > alpha (where GA is a version with no suffix such as beta or alpha), and then by comparing major
	// version, then minor version. An example sorted list of versions:
	// v10, v2, v1, v11beta2, v10beta3, v3beta1, v12alpha1, v11alpha2, foo1, foo10.
	VersionPriority int32
}

apiVersion: apiregistration.k8s.io/v1beta1
kind: APIService
metadata:
  name: v1alpha1.dummy
spec:
  caBundle: <base64-encoded-serving-ca-certificate>
  group: dummyGroup
  version: v1alpha1
  groupPriorityMinimum: 1000
  versionPriority: 15
  service:
    name: dummy-server
    namespace: dummy-namespace
  status:
    …

┌──────────────────────────────────────────────────────────────────────────────────┐
│  起点：Run() 函数                                                                 │
│  cmd/kube-apiserver/app/server.go:148                                            │
├──────────────────────────────────────────────────────────────────────────────────┤
│  func Run(ctx context.Context, opts options.CompletedOptions) error {            │
│      ...                                                                         │
│      config, err := NewConfig(opts)  // 👈 进入配置构建                           │
│      ...                                                                         │
│  }                                                                               │
└──────────────────────────────────────────────────────────────────────────────────┘
                                       ↓
┌──────────────────────────────────────────────────────────────────────────────────┐
│  第一步：NewConfig() 函数                                                         │
│  cmd/kube-apiserver/app/config.go:74                                             │
├──────────────────────────────────────────────────────────────────────────────────┤
│  func NewConfig(opts options.CompletedOptions) (*Config, error) {                │
│      ...                                                                         │
│      aggregator, err := controlplaneapiserver.CreateAggregatorConfig( // :101    │
│          *kubeAPIs.ControlPlane.Generic,                                         │
│          opts.CompletedOptions,                                                  │
│          kubeAPIs.ControlPlane.VersionedInformers,                               │
│          serviceResolver,                                                        │
│          kubeAPIs.ControlPlane.ProxyTransport,                                   │
│          kubeAPIs.ControlPlane.Extra.PeerProxy,                                  │
│          pluginInitializer,                                                      │
│      )                                                                           │
│      c.Aggregator = aggregator                                                   │
│      ...                                                                         │
│  }                                                                               │
└──────────────────────────────────────────────────────────────────────────────────┘
                                       ↓
┌──────────────────────────────────────────────────────────────────────────────────┐
│  第二步：CreateAggregatorConfig() 函数                                            │
│  pkg/controlplane/apiserver/aggregator.go:53                                     │
├──────────────────────────────────────────────────────────────────────────────────┤
│  func CreateAggregatorConfig(                                                    │
│      kubeAPIServerConfig genericapiserver.Config,                                │
│      commandOptions options.CompletedOptions,                                    │
│      externalInformers kubeexternalinformers.SharedInformerFactory,              │
│      serviceResolver aggregatorapiserver.ServiceResolver,                        │
│      proxyTransport *http.Transport,                                             │
│      peerProxy utilpeerproxy.Interface,                                          │
│      pluginInitializers []admission.PluginInitializer,                           │
│  ) (*aggregatorapiserver.Config, error) {                                        │
│      ...                                                                         │
│  }                                                                               │
└──────────────────────────────────────────────────────────────────────────────────┘

// 代码: pkg/controlplane/apiserver/aggregator.go#L52-L126
func CreateAggregatorConfig(
	kubeAPIServerConfig genericapiserver.Config,
	commandOptions options.CompletedOptions,
	externalInformers kubeexternalinformers.SharedInformerFactory,
	serviceResolver aggregatorapiserver.ServiceResolver,
	proxyTransport *http.Transport,
	peerProxy utilpeerproxy.Interface,
	pluginInitializers []admission.PluginInitializer,
) (*aggregatorapiserver.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 aggregator
	genericConfig := kubeAPIServerConfig
	genericConfig.PostStartHooks = map[string]genericapiserver.PostStartHookConfigEntry{}
	genericConfig.RESTOptionsGetter = nil
	// prevent generic API server from installing the OpenAPI handler. Aggregator server
	// has its own customized OpenAPI handler.
	genericConfig.SkipOpenAPIInstallation = true

	if utilfeature.DefaultFeatureGate.Enabled(genericfeatures.StorageVersionAPI) &&
		utilfeature.DefaultFeatureGate.Enabled(genericfeatures.APIServerIdentity) {
		// Add StorageVersionPrecondition handler to aggregator-apiserver.
		// The handler will block write requests to built-in resources until the
		// target resources' storage versions are up-to-date.
		genericConfig.BuildHandlerChainFunc = genericapiserver.BuildHandlerChainWithStorageVersionPrecondition
	}

	if peerProxy != nil {
		originalHandlerChainBuilder := genericConfig.BuildHandlerChainFunc
		genericConfig.BuildHandlerChainFunc = func(apiHandler http.Handler, c *genericapiserver.Config) http.Handler {
			// Add peer proxy handler to aggregator-apiserver.
			// wrap the peer proxy handler first.
			apiHandler = peerProxy.WrapHandler(apiHandler)
			return originalHandlerChainBuilder(apiHandler, c)
		}
	}

	// 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
	etcdOptions.StorageConfig.Codec = aggregatorscheme.Codecs.LegacyCodec(v1.SchemeGroupVersion, v1beta1.SchemeGroupVersion)
	etcdOptions.StorageConfig.EncodeVersioner = runtime.NewMultiGroupVersioner(v1.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 aggregator defaults and registry
	if err := commandOptions.APIEnablement.ApplyTo(
		&genericConfig,
		aggregatorapiserver.DefaultAPIResourceConfigSource(),
		aggregatorscheme.Scheme); err != nil {
		return nil, err
	}

	aggregatorConfig := &aggregatorapiserver.Config{
		GenericConfig: &genericapiserver.RecommendedConfig{
			Config:                genericConfig,
			SharedInformerFactory: externalInformers,
		},
		ExtraConfig: aggregatorapiserver.ExtraConfig{
			ProxyClientCertFile:       commandOptions.ProxyClientCertFile,
			ProxyClientKeyFile:        commandOptions.ProxyClientKeyFile,
			PeerAdvertiseAddress:      commandOptions.PeerAdvertiseAddress,
			ServiceResolver:           serviceResolver,
			ProxyTransport:            proxyTransport,
			RejectForwardingRedirects: commandOptions.AggregatorRejectForwardingRedirects,
		},
	}

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

	return aggregatorConfig, nil
}

┌─────────────────────────────────────────────────────────────────────────────┐
│                    cmd/kube-apiserver/app/server.go                         │
├─────────────────────────────────────────────────────────────────────────────┤
│                                                                             │
│  Run(ctx, opts options.CompletedOptions)                                    │
│       │                                                                     │
│       ▼                                                                     │
│  config, err := NewConfig(opts)  ─────────────────────────────────────────┐ │
│       │                                                                   │ │
│       │                                                                   │ │
│       ▼                                                                   │ │
│  completed, err := config.Complete()                                      │ │
│       │                                                                   │ │
│       ▼                                                                   │ │
│  server, err := CreateServerChain(completed)                              │ │
│       │                                                                   │ │
│       ▼                                                                   │ │
│  prepared.Run(ctx)                                                        │ │
│                                                                           │ │
└───────────────────────────────────────────────────────────────────────────┼─┘
                                                                            │
┌───────────────────────────────────────────────────────────────────────────┼─┐
│                    cmd/kube-apiserver/app/config.go                       │ │
├───────────────────────────────────────────────────────────────────────────┼─┤
│                                                                           │ │
│  NewConfig(opts) ◄────────────────────────────────────────────────────────┘ │
│       │                                                                     │
│       ├──► BuildGenericConfig()                                             │
│       │         └──► genericConfig, versionedInformers, storageFactory      │
│       │                                                                     │
│       ├──► CreateKubeAPIServerConfig()                                      │
│       │         └──► c.KubeAPIs = *controlplane.Config                      │
│       │                                                                     │
│       ├──► CreateAPIExtensionsConfig()                                      │
│       │         └──► c.ApiExtensions = *apiextensionsapiserver.Config       │
│       │                                                                     │
│       └──► CreateAggregatorConfig()                                         │
│                 └──► c.Aggregator = *aggregatorapiserver.Config             │
│                                                                             │
│  返回: &Config{KubeAPIs, ApiExtensions, Aggregator}                         │
│                                                                             │
├─────────────────────────────────────────────────────────────────────────────┤
│                                                                             │
│  (c *Config) Complete() CompletedConfig                                     │
│       │                                                                     │
│       ├──► c.Aggregator.Complete()    ──────────────────────────────────┐   │
│       │         └──► aggregatorapiserver.CompletedConfig                │   │
│       │                                                                 │   │
│       ├──► c.KubeAPIs.Complete()                                        │   │
│       │         └──► controlplane.CompletedConfig                       │   │
│       │                                                                 │   │
│       └──► c.ApiExtensions.Complete()                                   │   │
│                 └──► apiextensionsapiserver.CompletedConfig             │   │
│                                                                         │   │
│  返回: CompletedConfig{Aggregator, KubeAPIs, ApiExtensions}             │   │
│                                                                         │   │
└─────────────────────────────────────────────────────────────────────────┼───┘
                                                                          │
┌─────────────────────────────────────────────────────────────────────────┼───┐
│        staging/src/k8s.io/kube-aggregator/pkg/apiserver/apiserver.go    │   │
├─────────────────────────────────────────────────────────────────────────┼───┤
│                                                                         │   │
│  (cfg *Config) Complete() CompletedConfig  ◄────────────────────────────┘   │
│       │                                                                     │
│       ├──► cfg.GenericConfig.Complete()                                     │
│       │         └──► genericapiserver.CompletedConfig                       │
│       │                                                                     │
│       └──► c.GenericConfig.EnableDiscovery = false  // 要点                  │
│                                                                             │
│  返回: CompletedConfig{GenericConfig, ExtraConfig}                          │
│                                                                             │
└─────────────────────────────────────────────────────────────────────────────┘

// 代码: staging/src/k8s.io/kube-aggregator/pkg/apiserver/apiserver.go
s.GenericAPIServer.Handler.NonGoRestfulMux.Handle("/apis", apisHandlerWithAggregationSupport)
s.GenericAPIServer.Handler.NonGoRestfulMux.UnlistedHandle("/apis/", apisHandler)

┌──────────────────────────────────────────────────────────────────────────────────┐
│  起点：Run() 函数                                                                 │
│  cmd/kube-apiserver/app/server.go:148                                            │
├──────────────────────────────────────────────────────────────────────────────────┤
│  func Run(ctx context.Context, opts options.CompletedOptions) error {            │
│      ...                                                                         │
│      server, err := CreateServerChain(completed)  // 👈 创建服务器链 :161          │
│      ...                                                                         │
│  }                                                                               │
└──────────────────────────────────────────────────────────────────────────────────┘
                                         ↓
┌──────────────────────────────────────────────────────────────────────────────────┐
│  第一步：CreateServerChain() 函数                                                 │
│  cmd/kube-apiserver/app/server.go:171                                            │
├──────────────────────────────────────────────────────────────────────────────────┤
│  func CreateServerChain(config CompletedConfig) (                                │
│      *aggregatorapiserver.APIAggregator, error,                                  │
│  ) {                                                                             │
│      ...                                                                         │
│      aggregatorServer, err := controlplaneapiserver.CreateAggregatorServer(      │
│          config.Aggregator,                           // :183                    │
│          kubeAPIServer.ControlPlane.GenericAPIServer,                            │
│          apiExtensionsServer.Informers.Apiextensions().V1().CustomResourceDef... │
│          crdAPIEnabled,                                                          │
│          apiVersionPriorities,                                                   │
│      )                                                                           │
│      ...                                                                         │
│  }                                                                               │
└──────────────────────────────────────────────────────────────────────────────────┘
                                         ↓
┌──────────────────────────────────────────────────────────────────────────────────┐
│  终点：CreateAggregatorServer() 函数                                              │
│  pkg/controlplane/apiserver/aggregator.go:128                                    │
├──────────────────────────────────────────────────────────────────────────────────┤
│  func CreateAggregatorServer(                                                    │
│      aggregatorConfig aggregatorapiserver.CompletedConfig,                       │
│      delegateAPIServer genericapiserver.DelegationTarget,                        │
│      crds apiextensionsinformers.CustomResourceDefinitionInformer,               │
│      crdAPIEnabled bool,                                                         │
│      apiVersionPriorities map[schema.GroupVersion]APIServicePriority,            │
│  ) (*aggregatorapiserver.APIAggregator, error) {                                 │
│      ...                                                                         │
│  }                                                                               │
└──────────────────────────────────────────────────────────────────────────────────┘

// 代码: pkg\controlplane\apiserver\aggregator.go#L128-L194
func CreateAggregatorServer(aggregatorConfig aggregatorapiserver.CompletedConfig, delegateAPIServer genericapiserver.DelegationTarget, crds apiextensionsinformers.CustomResourceDefinitionInformer, crdAPIEnabled bool, apiVersionPriorities map[schema.GroupVersion]APIServicePriority) (*aggregatorapiserver.APIAggregator, error) {
	aggregatorServer, err := aggregatorConfig.NewWithDelegate(delegateAPIServer)
	if err != nil {
		return nil, err
	}

	// create controllers for auto-registration
	apiRegistrationClient, err := apiregistrationclient.NewForConfig(aggregatorConfig.GenericConfig.LoopbackClientConfig)
	if err != nil {
		return nil, err
	}
	autoRegistrationController := autoregister.NewAutoRegisterController(aggregatorServer.APIRegistrationInformers.Apiregistration().V1().APIServices(), apiRegistrationClient)
	apiServices := apiServicesToRegister(delegateAPIServer, autoRegistrationController, apiVersionPriorities)

	type controller interface {
		Run(workers int, stopCh <-chan struct{})
		WaitForInitialSync()
	}
	var crdRegistrationController controller
	if crdAPIEnabled {
		crdRegistrationController = crdregistration.NewCRDRegistrationController(
			crds,
			autoRegistrationController)
	}

	// Imbue all builtin group-priorities onto the aggregated discovery
	if aggregatorConfig.GenericConfig.AggregatedDiscoveryGroupManager != nil {
		for gv, entry := range apiVersionPriorities {
			aggregatorConfig.GenericConfig.AggregatedDiscoveryGroupManager.SetGroupVersionPriority(metav1.GroupVersion(gv), int(entry.Group), int(entry.Version))
		}
	}

	err = aggregatorServer.GenericAPIServer.AddPostStartHook("kube-apiserver-autoregistration", func(context genericapiserver.PostStartHookContext) error {
		if crdAPIEnabled {
			go crdRegistrationController.Run(5, context.Done())
		}
		go func() {
			// let the CRD controller process the initial set of CRDs before starting the autoregistration controller.
			// this prevents the autoregistration controller's initial sync from deleting APIServices for CRDs that still exist.
			// we only need to do this if CRDs are enabled on this server.  We can't use discovery because we are the source for discovery.
			if crdAPIEnabled {
				klog.Infof("waiting for initial CRD sync...")
				crdRegistrationController.WaitForInitialSync()
				klog.Infof("initial CRD sync complete...")
			} else {
				klog.Infof("CRD API not enabled, starting APIService registration without waiting for initial CRD sync")
			}
			autoRegistrationController.Run(5, context.Done())
		}()
		return nil
	})
	if err != nil {
		return nil, err
	}

	err = aggregatorServer.GenericAPIServer.AddBootSequenceHealthChecks(
		makeAPIServiceAvailableHealthCheck(
			"autoregister-completion",
			apiServices,
			aggregatorServer.APIRegistrationInformers.Apiregistration().V1().APIServices(),
		),
	)
	if err != nil {
		return nil, err
	}

	return aggregatorServer, nil
}

genericServer, err := c.GenericConfig.New("kube-aggregator", delegationTarget)

// 代码: staging\src\k8s.io\apiserver\pkg\server\config.go#L879-L886
// first add poststarthooks from delegated targets
for k, v := range delegationTarget.PostStartHooks() {
    s.postStartHooks[k] = v
}

for k, v := range delegationTarget.PreShutdownHooks() {
    s.preShutdownHooks[k] = v
}

// 代码: staging/src/k8s.io/kube-aggregator/pkg/apiserver/apiserver.go#L204-L449
func (c completedConfig) NewWithDelegate(delegationTarget genericapiserver.DelegationTarget) (*APIAggregator, error) {
	genericServer, err := c.GenericConfig.New("kube-aggregator", delegationTarget)
	if err != nil {
		return nil, err
	}

	apiregistrationClient, err := clientset.NewForConfig(c.GenericConfig.LoopbackClientConfig)
	if err != nil {
		return nil, err
	}
	informerFactory := informers.NewSharedInformerFactory(
		apiregistrationClient,
		5*time.Minute,
	)

	apiServiceRegistrationControllerInitiated := make(chan struct{})
	if err := genericServer.RegisterMuxAndDiscoveryCompleteSignal("APIServiceRegistrationControllerInitiated", apiServiceRegistrationControllerInitiated); err != nil {
		return nil, err
	}

	var proxyTransportDial *transport.DialHolder
	if c.GenericConfig.EgressSelector != nil {
		egressDialer, err := c.GenericConfig.EgressSelector.Lookup(egressselector.Cluster.AsNetworkContext())
		if err != nil {
			return nil, err
		}
		if egressDialer != nil {
			proxyTransportDial = &transport.DialHolder{Dial: egressDialer}
		}
	} else if c.ExtraConfig.ProxyTransport != nil && c.ExtraConfig.ProxyTransport.DialContext != nil {
		proxyTransportDial = &transport.DialHolder{Dial: c.ExtraConfig.ProxyTransport.DialContext}
	}

	s := &APIAggregator{
		GenericAPIServer:           genericServer,
		delegateHandler:            delegationTarget.UnprotectedHandler(),
		proxyTransportDial:         proxyTransportDial,
		proxyHandlers:              map[string]*proxyHandler{},
		handledGroupVersions:       map[string]sets.Set[string]{},
		lister:                     informerFactory.Apiregistration().V1().APIServices().Lister(),
		APIRegistrationInformers:   informerFactory,
		serviceResolver:            c.ExtraConfig.ServiceResolver,
		openAPIConfig:              c.GenericConfig.OpenAPIConfig,
		openAPIV3Config:            c.GenericConfig.OpenAPIV3Config,
		proxyCurrentCertKeyContent: func() (bytes []byte, bytes2 []byte) { return nil, nil },
		rejectForwardingRedirects:  c.ExtraConfig.RejectForwardingRedirects,
		tracerProvider:             c.GenericConfig.TracerProvider,
	}

	apiGroupInfo := apiservicerest.NewRESTStorage(c.GenericConfig.MergedResourceConfig, c.GenericConfig.RESTOptionsGetter, false)
	if err := s.GenericAPIServer.InstallAPIGroup(&apiGroupInfo); err != nil {
		return nil, err
	}

	enabledVersions := sets.NewString()
	for v := range apiGroupInfo.VersionedResourcesStorageMap {
		enabledVersions.Insert(v)
	}
	if !enabledVersions.Has(v1.SchemeGroupVersion.Version) {
		return nil, fmt.Errorf("API group/version %s must be enabled", v1.SchemeGroupVersion.String())
	}

	apisHandler := &apisHandler{
		codecs:         aggregatorscheme.Codecs,
		lister:         s.lister,
		discoveryGroup: discoveryGroup(enabledVersions),
	}

	apisHandlerWithAggregationSupport := aggregated.WrapAggregatedDiscoveryToHandler(apisHandler, s.GenericAPIServer.AggregatedDiscoveryGroupManager)
	s.GenericAPIServer.Handler.NonGoRestfulMux.Handle("/apis", apisHandlerWithAggregationSupport)
	s.GenericAPIServer.Handler.NonGoRestfulMux.UnlistedHandle("/apis/", apisHandler)

	apiserviceRegistrationController := NewAPIServiceRegistrationController(informerFactory.Apiregistration().V1().APIServices(), s)
	if len(c.ExtraConfig.ProxyClientCertFile) > 0 && len(c.ExtraConfig.ProxyClientKeyFile) > 0 {
		aggregatorProxyCerts, err := dynamiccertificates.NewDynamicServingContentFromFiles("aggregator-proxy-cert", c.ExtraConfig.ProxyClientCertFile, c.ExtraConfig.ProxyClientKeyFile)
		if err != nil {
			return nil, err
		}
		if err := aggregatorProxyCerts.RunOnce(context.Background()); err != nil {
			return nil, err
		}
		aggregatorProxyCerts.AddListener(apiserviceRegistrationController)
		s.proxyCurrentCertKeyContent = aggregatorProxyCerts.CurrentCertKeyContent

		s.GenericAPIServer.AddPostStartHookOrDie("aggregator-reload-proxy-client-cert", func(postStartHookContext genericapiserver.PostStartHookContext) error {
			go aggregatorProxyCerts.Run(postStartHookContext, 1)
			return nil
		})
	}

	s.GenericAPIServer.AddPostStartHookOrDie("start-kube-aggregator-informers", func(context genericapiserver.PostStartHookContext) error {
		informerFactory.Start(context.Done())
		c.GenericConfig.SharedInformerFactory.Start(context.Done())
		return nil
	})

	metrics := availabilitymetrics.New()
	registerIntoLegacyRegistryOnce.Do(func() { err = metrics.Register(legacyregistry.Register, legacyregistry.CustomRegister) })
	if err != nil {
		return nil, err
	}

	local, err := localavailability.New(
		informerFactory.Apiregistration().V1().APIServices(),
		apiregistrationClient.ApiregistrationV1(),
		metrics,
	)
	if err != nil {
		return nil, err
	}
	s.GenericAPIServer.AddPostStartHookOrDie("apiservice-status-local-available-controller", func(context genericapiserver.PostStartHookContext) error {
		go local.Run(5, context.Done())
		return nil
	})

	if !c.ExtraConfig.DisableRemoteAvailableConditionController {
		remote, err := remoteavailability.New(
			informerFactory.Apiregistration().V1().APIServices(),
			c.GenericConfig.SharedInformerFactory.Core().V1().Services(),
			c.GenericConfig.SharedInformerFactory.Discovery().V1().EndpointSlices(),
			apiregistrationClient.ApiregistrationV1(),
			proxyTransportDial,
			(func() ([]byte, []byte))(s.proxyCurrentCertKeyContent),
			s.serviceResolver,
			metrics,
		)
		if err != nil {
			return nil, err
		}
		s.GenericAPIServer.AddPostStartHookOrDie("apiservice-status-remote-available-controller", func(context genericapiserver.PostStartHookContext) error {
			go remote.Run(5, context.Done())
			return nil
		})
	}

	s.GenericAPIServer.AddPostStartHookOrDie("apiservice-registration-controller", func(context genericapiserver.PostStartHookContext) error {
		go apiserviceRegistrationController.Run(context.Done(), apiServiceRegistrationControllerInitiated)
		select {
		case <-context.Done():
		case <-apiServiceRegistrationControllerInitiated:
		}
		return nil
	})

	s.discoveryAggregationController = NewDiscoveryManager(
		s.GenericAPIServer.AggregatedDiscoveryGroupManager.WithSource(aggregated.AggregatorSource),
	)

	s.GenericAPIServer.AddPostStartHookOrDie("apiservice-discovery-controller", func(context genericapiserver.PostStartHookContext) error {
		select {
		case <-context.Done():
			return nil
		case <-apiServiceRegistrationControllerInitiated:
		}

		discoverySyncedCh := make(chan struct{})
		go s.discoveryAggregationController.Run(context.Done(), discoverySyncedCh)

		select {
		case <-context.Done():
			return nil
		case <-discoverySyncedCh:
		}
		return nil
	})

	if utilfeature.DefaultFeatureGate.Enabled(genericfeatures.StorageVersionAPI) &&
		utilfeature.DefaultFeatureGate.Enabled(genericfeatures.APIServerIdentity) {
		s.GenericAPIServer.AddPostStartHookOrDie(StorageVersionPostStartHookName, func(hookContext genericapiserver.PostStartHookContext) error {
			kubeClient, err := kubernetes.NewForConfig(hookContext.LoopbackClientConfig)
			if err != nil {
				return err
			}
			if err := wait.PollImmediateUntil(100*time.Millisecond, func() (bool, error) {
				_, err := kubeClient.CoordinationV1().Leases(metav1.NamespaceSystem).Get(
					context.TODO(), s.GenericAPIServer.APIServerID, metav1.GetOptions{})
				if apierrors.IsNotFound(err) {
					return false, nil
				}
				if err != nil {
					return false, err
				}
				return true, nil
			}, hookContext.Done()); err != nil {
				return fmt.Errorf("failed to wait for apiserver-identity lease %s to be created: %v",
					s.GenericAPIServer.APIServerID, err)
			}
			go wait.PollImmediateUntil(10*time.Minute, func() (bool, error) {
				s.GenericAPIServer.StorageVersionManager.UpdateStorageVersions(hookContext.LoopbackClientConfig, s.GenericAPIServer.APIServerID)
				return false, nil
			}, hookContext.Done())
			wait.PollImmediateUntil(1*time.Second, func() (bool, error) {
				return s.GenericAPIServer.StorageVersionManager.Completed(), nil
			}, hookContext.Done())
			return nil
		})
	}

	return s, nil
}