migrate more rest handlers to select by resource enablement

pkg/controlplane/instance.go

@@ -392,24 +392,9 @@ func (c completedConfig) New(delegationTarget genericapiserver.DelegationTarget)
 	}
 
 	// install legacy rest storage
-	if c.ExtraConfig.APIResourceConfigSource.VersionEnabled(apiv1.SchemeGroupVersion) {
+
-		legacyRESTStorageProvider := corerest.LegacyRESTStorageProvider{
+	if err := m.InstallLegacyAPI(&c, c.GenericConfig.RESTOptionsGetter); err != nil {
-			StorageFactory:              c.ExtraConfig.StorageFactory,
+		return nil, err
-			ProxyTransport:              c.ExtraConfig.ProxyTransport,
-			KubeletClientConfig:         c.ExtraConfig.KubeletClientConfig,
-			EventTTL:                    c.ExtraConfig.EventTTL,
-			ServiceIPRange:              c.ExtraConfig.ServiceIPRange,
-			SecondaryServiceIPRange:     c.ExtraConfig.SecondaryServiceIPRange,
-			ServiceNodePortRange:        c.ExtraConfig.ServiceNodePortRange,
-			LoopbackClientConfig:        c.GenericConfig.LoopbackClientConfig,
-			ServiceAccountIssuer:        c.ExtraConfig.ServiceAccountIssuer,
-			ExtendExpiration:            c.ExtraConfig.ExtendExpiration,
-			ServiceAccountMaxExpiration: c.ExtraConfig.ServiceAccountMaxExpiration,
-			APIAudiences:                c.GenericConfig.Authentication.APIAudiences,
-		}
-		if err := m.InstallLegacyAPI(&c, c.GenericConfig.RESTOptionsGetter, legacyRESTStorageProvider); err != nil {
-			return nil, err
-		}
 	}
 
 	// The order here is preserved in discovery.
@@ -524,11 +509,28 @@ func labelAPIServerHeartbeat(lease *coordinationapiv1.Lease) error {
 }
 
 // InstallLegacyAPI will install the legacy APIs for the restStorageProviders if they are enabled.
-func (m *Instance) InstallLegacyAPI(c *completedConfig, restOptionsGetter generic.RESTOptionsGetter, legacyRESTStorageProvider corerest.LegacyRESTStorageProvider) error {
+func (m *Instance) InstallLegacyAPI(c *completedConfig, restOptionsGetter generic.RESTOptionsGetter) error {
-	legacyRESTStorage, apiGroupInfo, err := legacyRESTStorageProvider.NewLegacyRESTStorage(restOptionsGetter)
+	legacyRESTStorageProvider := corerest.LegacyRESTStorageProvider{
+		StorageFactory:              c.ExtraConfig.StorageFactory,
+		ProxyTransport:              c.ExtraConfig.ProxyTransport,
+		KubeletClientConfig:         c.ExtraConfig.KubeletClientConfig,
+		EventTTL:                    c.ExtraConfig.EventTTL,
+		ServiceIPRange:              c.ExtraConfig.ServiceIPRange,
+		SecondaryServiceIPRange:     c.ExtraConfig.SecondaryServiceIPRange,
+		ServiceNodePortRange:        c.ExtraConfig.ServiceNodePortRange,
+		LoopbackClientConfig:        c.GenericConfig.LoopbackClientConfig,
+		ServiceAccountIssuer:        c.ExtraConfig.ServiceAccountIssuer,
+		ExtendExpiration:            c.ExtraConfig.ExtendExpiration,
+		ServiceAccountMaxExpiration: c.ExtraConfig.ServiceAccountMaxExpiration,
+		APIAudiences:                c.GenericConfig.Authentication.APIAudiences,
+	}
+	legacyRESTStorage, apiGroupInfo, err := legacyRESTStorageProvider.NewLegacyRESTStorage(c.ExtraConfig.APIResourceConfigSource, restOptionsGetter)
 	if err != nil {
 		return fmt.Errorf("error building core storage: %v", err)
 	}
+	if len(apiGroupInfo.VersionedResourcesStorageMap) == 0 { // if all core storage is disabled, return.
+		return nil
+	}
 
 	controllerName := "bootstrap-controller"
 	coreClient := corev1client.NewForConfigOrDie(c.GenericConfig.LoopbackClientConfig)

pkg/controlplane/instance_test.go

@@ -39,6 +39,7 @@ import (
 	genericapiserver "k8s.io/apiserver/pkg/server"
 	"k8s.io/apiserver/pkg/server/options"
 	"k8s.io/apiserver/pkg/server/resourceconfig"
+	"k8s.io/apiserver/pkg/server/storage"
 	serverstorage "k8s.io/apiserver/pkg/server/storage"
 	etcd3testing "k8s.io/apiserver/pkg/storage/etcd3/testing"
 	"k8s.io/client-go/discovery"
@@ -156,7 +157,7 @@ func TestLegacyRestStorageStrategies(t *testing.T) {
 		LoopbackClientConfig: apiserverCfg.GenericConfig.LoopbackClientConfig,
 	}
 
-	_, apiGroupInfo, err := storageProvider.NewLegacyRESTStorage(apiserverCfg.GenericConfig.RESTOptionsGetter)
+	_, apiGroupInfo, err := storageProvider.NewLegacyRESTStorage(storage.NewResourceConfig(), apiserverCfg.GenericConfig.RESTOptionsGetter)
 	if err != nil {
 		t.Errorf("failed to create legacy REST storage: %v", err)
 	}

pkg/registry/core/rest/storage_core.go

@@ -27,6 +27,7 @@ import (
 
 	"k8s.io/klog/v2"
 
+	corev1 "k8s.io/api/core/v1"
 	"k8s.io/apimachinery/pkg/runtime/schema"
 	utilnet "k8s.io/apimachinery/pkg/util/net"
 	"k8s.io/apiserver/pkg/authentication/authenticator"
@@ -102,7 +103,7 @@ type LegacyRESTStorage struct {
 	ServiceNodePortAllocator           rangeallocation.RangeRegistry
 }
 
-func (c LegacyRESTStorageProvider) NewLegacyRESTStorage(restOptionsGetter generic.RESTOptionsGetter) (LegacyRESTStorage, genericapiserver.APIGroupInfo, error) {
+func (c LegacyRESTStorageProvider) NewLegacyRESTStorage(apiResourceConfigSource serverstorage.APIResourceConfigSource, restOptionsGetter generic.RESTOptionsGetter) (LegacyRESTStorage, genericapiserver.APIGroupInfo, error) {
 	apiGroupInfo := genericapiserver.APIGroupInfo{
 		PrioritizedVersions:          legacyscheme.Scheme.PrioritizedVersionsForGroup(""),
 		VersionedResourcesStorageMap: map[string]map[string]rest.Storage{},
@@ -273,63 +274,107 @@ func (c LegacyRESTStorageProvider) NewLegacyRESTStorage(restOptionsGetter generi
 		return LegacyRESTStorage{}, genericapiserver.APIGroupInfo{}, err
 	}
 
-	restStorageMap := map[string]rest.Storage{
+	storage := map[string]rest.Storage{}
-		"pods":             podStorage.Pod,
+	if resource := "pods"; apiResourceConfigSource.ResourceEnabled(corev1.SchemeGroupVersion.WithResource(resource)) {
-		"pods/attach":      podStorage.Attach,
+		storage[resource] = podStorage.Pod
-		"pods/status":      podStorage.Status,
+		storage[resource+"/attach"] = podStorage.Attach
-		"pods/log":         podStorage.Log,
+		storage[resource+"/status"] = podStorage.Status
-		"pods/exec":        podStorage.Exec,
+		storage[resource+"/log"] = podStorage.Log
-		"pods/portforward": podStorage.PortForward,
+		storage[resource+"/exec"] = podStorage.Exec
-		"pods/proxy":       podStorage.Proxy,
+		storage[resource+"/portforward"] = podStorage.PortForward
-		"pods/binding":     podStorage.Binding,
+		storage[resource+"/proxy"] = podStorage.Proxy
-		"bindings":         podStorage.LegacyBinding,
+		storage[resource+"/binding"] = podStorage.Binding
+		if podStorage.Eviction != nil {
+			storage[resource+"/eviction"] = podStorage.Eviction
+		}
+		if utilfeature.DefaultFeatureGate.Enabled(features.EphemeralContainers) {
+			storage[resource+"/ephemeralcontainers"] = podStorage.EphemeralContainers
+		}
 
-		"podTemplates": podTemplateStorage,
-
-		"replicationControllers":        controllerStorage.Controller,
-		"replicationControllers/status": controllerStorage.Status,
-
-		"services":        serviceRESTStorage,
-		"services/proxy":  serviceRESTProxy,
-		"services/status": serviceStatusStorage,
-
-		"endpoints": endpointsStorage,
-
-		"nodes":        nodeStorage.Node,
-		"nodes/status": nodeStorage.Status,
-		"nodes/proxy":  nodeStorage.Proxy,
-
-		"events": eventStorage,
-
-		"limitRanges":                   limitRangeStorage,
-		"resourceQuotas":                resourceQuotaStorage,
-		"resourceQuotas/status":         resourceQuotaStatusStorage,
-		"namespaces":                    namespaceStorage,
-		"namespaces/status":             namespaceStatusStorage,
-		"namespaces/finalize":           namespaceFinalizeStorage,
-		"secrets":                       secretStorage,
-		"serviceAccounts":               serviceAccountStorage,
-		"persistentVolumes":             persistentVolumeStorage,
-		"persistentVolumes/status":      persistentVolumeStatusStorage,
-		"persistentVolumeClaims":        persistentVolumeClaimStorage,
-		"persistentVolumeClaims/status": persistentVolumeClaimStatusStorage,
-		"configMaps":                    configMapStorage,
-
-		"componentStatuses": componentstatus.NewStorage(componentStatusStorage{c.StorageFactory}.serversToValidate),
 	}
-	if legacyscheme.Scheme.IsVersionRegistered(schema.GroupVersion{Group: "autoscaling", Version: "v1"}) {
+	if resource := "bindings"; apiResourceConfigSource.ResourceEnabled(corev1.SchemeGroupVersion.WithResource(resource)) {
-		restStorageMap["replicationControllers/scale"] = controllerStorage.Scale
+		storage[resource] = podStorage.LegacyBinding
 	}
-	if podStorage.Eviction != nil {
+
-		restStorageMap["pods/eviction"] = podStorage.Eviction
+	if resource := "podtemplates"; apiResourceConfigSource.ResourceEnabled(corev1.SchemeGroupVersion.WithResource(resource)) {
+		storage[resource] = podTemplateStorage
 	}
-	if serviceAccountStorage.Token != nil {
+
-		restStorageMap["serviceaccounts/token"] = serviceAccountStorage.Token
+	if resource := "replicationcontrollers"; apiResourceConfigSource.ResourceEnabled(corev1.SchemeGroupVersion.WithResource(resource)) {
+		storage[resource] = controllerStorage.Controller
+		storage[resource+"/status"] = controllerStorage.Status
+		if legacyscheme.Scheme.IsVersionRegistered(schema.GroupVersion{Group: "autoscaling", Version: "v1"}) {
+			storage[resource+"/scale"] = controllerStorage.Scale
+		}
 	}
-	if utilfeature.DefaultFeatureGate.Enabled(features.EphemeralContainers) {
+
-		restStorageMap["pods/ephemeralcontainers"] = podStorage.EphemeralContainers
+	if resource := "services"; apiResourceConfigSource.ResourceEnabled(corev1.SchemeGroupVersion.WithResource(resource)) {
+		storage[resource] = serviceRESTStorage
+		storage[resource+"/proxy"] = serviceRESTProxy
+		storage[resource+"/status"] = serviceStatusStorage
+	}
+
+	if resource := "endpoints"; apiResourceConfigSource.ResourceEnabled(corev1.SchemeGroupVersion.WithResource(resource)) {
+		storage[resource] = endpointsStorage
+	}
+
+	if resource := "nodes"; apiResourceConfigSource.ResourceEnabled(corev1.SchemeGroupVersion.WithResource(resource)) {
+		storage[resource] = nodeStorage.Node
+		storage[resource+"/proxy"] = nodeStorage.Proxy
+		storage[resource+"/status"] = nodeStorage.Status
+	}
+
+	if resource := "events"; apiResourceConfigSource.ResourceEnabled(corev1.SchemeGroupVersion.WithResource(resource)) {
+		storage[resource] = eventStorage
+	}
+
+	if resource := "limitranges"; apiResourceConfigSource.ResourceEnabled(corev1.SchemeGroupVersion.WithResource(resource)) {
+		storage[resource] = limitRangeStorage
+	}
+
+	if resource := "resourcequotas"; apiResourceConfigSource.ResourceEnabled(corev1.SchemeGroupVersion.WithResource(resource)) {
+		storage[resource] = resourceQuotaStorage
+		storage[resource+"/status"] = resourceQuotaStatusStorage
+	}
+
+	if resource := "namespaces"; apiResourceConfigSource.ResourceEnabled(corev1.SchemeGroupVersion.WithResource(resource)) {
+		storage[resource] = namespaceStorage
+		storage[resource+"/status"] = namespaceStatusStorage
+		storage[resource+"/finalize"] = namespaceFinalizeStorage
+	}
+
+	if resource := "secrets"; apiResourceConfigSource.ResourceEnabled(corev1.SchemeGroupVersion.WithResource(resource)) {
+		storage[resource] = secretStorage
+	}
+
+	if resource := "serviceaccounts"; apiResourceConfigSource.ResourceEnabled(corev1.SchemeGroupVersion.WithResource(resource)) {
+		storage[resource] = serviceAccountStorage
+		if serviceAccountStorage.Token != nil {
+			storage[resource+"/token"] = serviceAccountStorage.Token
+		}
+	}
+
+	if resource := "persistentvolumes"; apiResourceConfigSource.ResourceEnabled(corev1.SchemeGroupVersion.WithResource(resource)) {
+		storage[resource] = persistentVolumeStorage
+		storage[resource+"/status"] = persistentVolumeStatusStorage
+	}
+
+	if resource := "persistentvolumeclaims"; apiResourceConfigSource.ResourceEnabled(corev1.SchemeGroupVersion.WithResource(resource)) {
+		storage[resource] = persistentVolumeClaimStorage
+		storage[resource+"/status"] = persistentVolumeClaimStatusStorage
+	}
+
+	if resource := "configmaps"; apiResourceConfigSource.ResourceEnabled(corev1.SchemeGroupVersion.WithResource(resource)) {
+		storage[resource] = configMapStorage
+	}
+
+	if resource := "componentstatuses"; apiResourceConfigSource.ResourceEnabled(corev1.SchemeGroupVersion.WithResource(resource)) {
+		storage[resource] = componentstatus.NewStorage(componentStatusStorage{c.StorageFactory}.serversToValidate)
+	}
+
+	if len(storage) > 0 {
+		apiGroupInfo.VersionedResourcesStorageMap["v1"] = storage
 	}
-	apiGroupInfo.VersionedResourcesStorageMap["v1"] = restStorageMap
 
 	return restStorage, apiGroupInfo, nil
 }

pkg/registry/discovery/rest/storage_discovery.go

@@ -37,19 +37,15 @@ func (p StorageProvider) NewRESTStorage(apiResourceConfigSource serverstorage.AP
 	// If you add a version here, be sure to add an entry in `k8s.io/kubernetes/cmd/kube-apiserver/app/aggregator.go with specific priorities.
 	// TODO refactor the plumbing to provide the information in the APIGroupInfo
 
-	if apiResourceConfigSource.VersionEnabled(discoveryv1beta1.SchemeGroupVersion) {
+	if storageMap, err := p.v1beta1Storage(apiResourceConfigSource, restOptionsGetter); err != nil {
-		storageMap, err := p.v1beta1Storage(apiResourceConfigSource, restOptionsGetter)
+		return genericapiserver.APIGroupInfo{}, false, err
-		if err != nil {
+	} else if len(storageMap) > 0 {
-			return genericapiserver.APIGroupInfo{}, false, err
-		}
 		apiGroupInfo.VersionedResourcesStorageMap[discoveryv1beta1.SchemeGroupVersion.Version] = storageMap
 	}
 
-	if apiResourceConfigSource.VersionEnabled(discoveryv1.SchemeGroupVersion) {
+	if storageMap, err := p.v1Storage(apiResourceConfigSource, restOptionsGetter); err != nil {
-		storageMap, err := p.v1Storage(apiResourceConfigSource, restOptionsGetter)
+		return genericapiserver.APIGroupInfo{}, false, err
-		if err != nil {
+	} else if len(storageMap) > 0 {
-			return genericapiserver.APIGroupInfo{}, false, err
-		}
 		apiGroupInfo.VersionedResourcesStorageMap[discoveryv1.SchemeGroupVersion.Version] = storageMap
 	}
 
@@ -59,25 +55,29 @@ func (p StorageProvider) NewRESTStorage(apiResourceConfigSource serverstorage.AP
 func (p StorageProvider) v1beta1Storage(apiResourceConfigSource serverstorage.APIResourceConfigSource, restOptionsGetter generic.RESTOptionsGetter) (map[string]rest.Storage, error) {
 	storage := map[string]rest.Storage{}
 
-	endpointSliceStorage, err := endpointslicestorage.NewREST(restOptionsGetter)
+	if resource := "endpointslices"; apiResourceConfigSource.ResourceEnabled(discoveryv1beta1.SchemeGroupVersion.WithResource(resource)) {
-	if err != nil {
+		endpointSliceStorage, err := endpointslicestorage.NewREST(restOptionsGetter)
-		return storage, err
+		if err != nil {
+			return storage, err
+		}
+		storage[resource] = endpointSliceStorage
 	}
 
-	storage["endpointslices"] = endpointSliceStorage
+	return storage, nil
-	return storage, err
 }
 
 func (p StorageProvider) v1Storage(apiResourceConfigSource serverstorage.APIResourceConfigSource, restOptionsGetter generic.RESTOptionsGetter) (map[string]rest.Storage, error) {
 	storage := map[string]rest.Storage{}
 
-	endpointSliceStorage, err := endpointslicestorage.NewREST(restOptionsGetter)
+	if resource := "endpointslices"; apiResourceConfigSource.ResourceEnabled(discoveryv1.SchemeGroupVersion.WithResource(resource)) {
-	if err != nil {
+		endpointSliceStorage, err := endpointslicestorage.NewREST(restOptionsGetter)
-		return storage, err
+		if err != nil {
+			return storage, err
+		}
+		storage[resource] = endpointSliceStorage
 	}
 
-	storage["endpointslices"] = endpointSliceStorage
+	return storage, nil
-	return storage, err
 }
 
 // GroupName is the group name for the storage provider.

pkg/registry/events/rest/storage_events.go

@@ -39,19 +39,16 @@ func (p RESTStorageProvider) NewRESTStorage(apiResourceConfigSource serverstorag
 	// If you add a version here, be sure to add an entry in `k8s.io/kubernetes/cmd/kube-apiserver/app/aggregator.go with specific priorities.
 	// TODO refactor the plumbing to provide the information in the APIGroupInfo
 
-	if apiResourceConfigSource.VersionEnabled(eventsapiv1beta1.SchemeGroupVersion) {
+	if storageMap, err := p.v1beta1Storage(apiResourceConfigSource, restOptionsGetter); err != nil {
-		if storageMap, err := p.v1beta1Storage(apiResourceConfigSource, restOptionsGetter); err != nil {
+		return genericapiserver.APIGroupInfo{}, false, err
-			return genericapiserver.APIGroupInfo{}, false, err
+	} else if len(storageMap) > 0 {
-		} else {
+		apiGroupInfo.VersionedResourcesStorageMap[eventsapiv1beta1.SchemeGroupVersion.Version] = storageMap
-			apiGroupInfo.VersionedResourcesStorageMap[eventsapiv1beta1.SchemeGroupVersion.Version] = storageMap
-		}
 	}
-	if apiResourceConfigSource.VersionEnabled(eventsapiv1.SchemeGroupVersion) {
+
-		if storageMap, err := p.v1Storage(apiResourceConfigSource, restOptionsGetter); err != nil {
+	if storageMap, err := p.v1Storage(apiResourceConfigSource, restOptionsGetter); err != nil {
-			return genericapiserver.APIGroupInfo{}, false, err
+		return genericapiserver.APIGroupInfo{}, false, err
-		} else {
+	} else if len(storageMap) > 0 {
-			apiGroupInfo.VersionedResourcesStorageMap[eventsapiv1.SchemeGroupVersion.Version] = storageMap
+		apiGroupInfo.VersionedResourcesStorageMap[eventsapiv1.SchemeGroupVersion.Version] = storageMap
-		}
 	}
 
 	return apiGroupInfo, true, nil
@@ -59,26 +56,32 @@ func (p RESTStorageProvider) NewRESTStorage(apiResourceConfigSource serverstorag
 
 func (p RESTStorageProvider) v1beta1Storage(apiResourceConfigSource serverstorage.APIResourceConfigSource, restOptionsGetter generic.RESTOptionsGetter) (map[string]rest.Storage, error) {
 	storage := map[string]rest.Storage{}
-	// events
-	eventsStorage, err := eventstore.NewREST(restOptionsGetter, uint64(p.TTL.Seconds()))
-	if err != nil {
-		return storage, err
-	}
-	storage["events"] = eventsStorage
 
-	return storage, err
+	// events
+	if resource := "events"; apiResourceConfigSource.ResourceEnabled(eventsapiv1beta1.SchemeGroupVersion.WithResource(resource)) {
+		eventsStorage, err := eventstore.NewREST(restOptionsGetter, uint64(p.TTL.Seconds()))
+		if err != nil {
+			return storage, err
+		}
+		storage[resource] = eventsStorage
+	}
+
+	return storage, nil
 }
 
 func (p RESTStorageProvider) v1Storage(apiResourceConfigSource serverstorage.APIResourceConfigSource, restOptionsGetter generic.RESTOptionsGetter) (map[string]rest.Storage, error) {
 	storage := map[string]rest.Storage{}
-	// events
-	eventsStorage, err := eventstore.NewREST(restOptionsGetter, uint64(p.TTL.Seconds()))
-	if err != nil {
-		return storage, err
-	}
-	storage["events"] = eventsStorage
 
-	return storage, err
+	// events
+	if resource := "events"; apiResourceConfigSource.ResourceEnabled(eventsapiv1.SchemeGroupVersion.WithResource(resource)) {
+		eventsStorage, err := eventstore.NewREST(restOptionsGetter, uint64(p.TTL.Seconds()))
+		if err != nil {
+			return storage, err
+		}
+		storage[resource] = eventsStorage
+	}
+
+	return storage, nil
 }
 
 func (p RESTStorageProvider) GroupName() string {

pkg/registry/flowcontrol/rest/storage_flowcontrol.go

@@ -21,6 +21,7 @@ import (
 	"fmt"
 	"time"
 
+	"k8s.io/apimachinery/pkg/runtime/schema"
 	"k8s.io/apimachinery/pkg/util/wait"
 	flowcontrolbootstrap "k8s.io/apiserver/pkg/apis/flowcontrol/bootstrap"
 	"k8s.io/apiserver/pkg/registry/generic"
@@ -56,51 +57,49 @@ const PostStartHookName = "priority-and-fairness-config-producer"
 func (p RESTStorageProvider) NewRESTStorage(apiResourceConfigSource serverstorage.APIResourceConfigSource, restOptionsGetter generic.RESTOptionsGetter) (genericapiserver.APIGroupInfo, bool, error) {
 	apiGroupInfo := genericapiserver.NewDefaultAPIGroupInfo(flowcontrol.GroupName, legacyscheme.Scheme, legacyscheme.ParameterCodec, legacyscheme.Codecs)
 
-	if apiResourceConfigSource.VersionEnabled(flowcontrolapisv1alpha1.SchemeGroupVersion) {
+	if storageMap, err := p.storage(apiResourceConfigSource, restOptionsGetter, flowcontrolapisv1alpha1.SchemeGroupVersion); err != nil {
-		flowControlStorage, err := p.storage(apiResourceConfigSource, restOptionsGetter)
+		return genericapiserver.APIGroupInfo{}, false, err
-		if err != nil {
+	} else if len(storageMap) > 0 {
-			return genericapiserver.APIGroupInfo{}, false, err
+		apiGroupInfo.VersionedResourcesStorageMap[flowcontrolapisv1alpha1.SchemeGroupVersion.Version] = storageMap
-		}
-		apiGroupInfo.VersionedResourcesStorageMap[flowcontrolapisv1alpha1.SchemeGroupVersion.Version] = flowControlStorage
 	}
 
-	if apiResourceConfigSource.VersionEnabled(flowcontrolapisv1beta1.SchemeGroupVersion) {
+	if storageMap, err := p.storage(apiResourceConfigSource, restOptionsGetter, flowcontrolapisv1beta1.SchemeGroupVersion); err != nil {
-		flowControlStorage, err := p.storage(apiResourceConfigSource, restOptionsGetter)
+		return genericapiserver.APIGroupInfo{}, false, err
-		if err != nil {
+	} else if len(storageMap) > 0 {
-			return genericapiserver.APIGroupInfo{}, false, err
+		apiGroupInfo.VersionedResourcesStorageMap[flowcontrolapisv1beta1.SchemeGroupVersion.Version] = storageMap
-		}
-		apiGroupInfo.VersionedResourcesStorageMap[flowcontrolapisv1beta1.SchemeGroupVersion.Version] = flowControlStorage
 	}
 
-	if apiResourceConfigSource.VersionEnabled(flowcontrolapisv1beta2.SchemeGroupVersion) {
+	if storageMap, err := p.storage(apiResourceConfigSource, restOptionsGetter, flowcontrolapisv1beta2.SchemeGroupVersion); err != nil {
-		flowControlStorage, err := p.storage(apiResourceConfigSource, restOptionsGetter)
+		return genericapiserver.APIGroupInfo{}, false, err
-		if err != nil {
+	} else if len(storageMap) > 0 {
-			return genericapiserver.APIGroupInfo{}, false, err
+		apiGroupInfo.VersionedResourcesStorageMap[flowcontrolapisv1beta2.SchemeGroupVersion.Version] = storageMap
-		}
-		apiGroupInfo.VersionedResourcesStorageMap[flowcontrolapisv1beta2.SchemeGroupVersion.Version] = flowControlStorage
 	}
 
 	return apiGroupInfo, true, nil
 }
 
-func (p RESTStorageProvider) storage(apiResourceConfigSource serverstorage.APIResourceConfigSource, restOptionsGetter generic.RESTOptionsGetter) (map[string]rest.Storage, error) {
+func (p RESTStorageProvider) storage(apiResourceConfigSource serverstorage.APIResourceConfigSource, restOptionsGetter generic.RESTOptionsGetter, groupVersion schema.GroupVersion) (map[string]rest.Storage, error) {
 	storage := map[string]rest.Storage{}
 
 	// flow-schema
-	flowSchemaStorage, flowSchemaStatusStorage, err := flowschemastore.NewREST(restOptionsGetter)
+	if resource := "flowschemas"; apiResourceConfigSource.ResourceEnabled(groupVersion.WithResource(resource)) {
-	if err != nil {
+		flowSchemaStorage, flowSchemaStatusStorage, err := flowschemastore.NewREST(restOptionsGetter)
-		return nil, err
+		if err != nil {
+			return nil, err
+		}
+		storage[resource] = flowSchemaStorage
+		storage[resource+"/status"] = flowSchemaStatusStorage
 	}
-	storage["flowschemas"] = flowSchemaStorage
-	storage["flowschemas/status"] = flowSchemaStatusStorage
 
 	// priority-level-configuration
-	priorityLevelConfigurationStorage, priorityLevelConfigurationStatusStorage, err := prioritylevelconfigurationstore.NewREST(restOptionsGetter)
+	if resource := "prioritylevelconfigurations"; apiResourceConfigSource.ResourceEnabled(groupVersion.WithResource(resource)) {
-	if err != nil {
+		priorityLevelConfigurationStorage, priorityLevelConfigurationStatusStorage, err := prioritylevelconfigurationstore.NewREST(restOptionsGetter)
-		return nil, err
+		if err != nil {
+			return nil, err
+		}
+		storage[resource] = priorityLevelConfigurationStorage
+		storage[resource+"/status"] = priorityLevelConfigurationStatusStorage
 	}
-	storage["prioritylevelconfigurations"] = priorityLevelConfigurationStorage
-	storage["prioritylevelconfigurations/status"] = priorityLevelConfigurationStatusStorage
 
 	return storage, nil
 }

pkg/registry/networking/rest/storage_settings.go

@@ -36,12 +36,10 @@ func (p RESTStorageProvider) NewRESTStorage(apiResourceConfigSource serverstorag
 	// If you add a version here, be sure to add an entry in `k8s.io/kubernetes/cmd/kube-apiserver/app/aggregator.go with specific priorities.
 	// TODO refactor the plumbing to provide the information in the APIGroupInfo
 
-	if apiResourceConfigSource.VersionEnabled(networkingapiv1.SchemeGroupVersion) {
+	if storageMap, err := p.v1Storage(apiResourceConfigSource, restOptionsGetter); err != nil {
-		if storageMap, err := p.v1Storage(apiResourceConfigSource, restOptionsGetter); err != nil {
+		return genericapiserver.APIGroupInfo{}, false, err
-			return genericapiserver.APIGroupInfo{}, false, err
+	} else if len(storageMap) > 0 {
-		} else {
+		apiGroupInfo.VersionedResourcesStorageMap[networkingapiv1.SchemeGroupVersion.Version] = storageMap
-			apiGroupInfo.VersionedResourcesStorageMap[networkingapiv1.SchemeGroupVersion.Version] = storageMap
-		}
 	}
 
 	return apiGroupInfo, true, nil
@@ -49,27 +47,34 @@ func (p RESTStorageProvider) NewRESTStorage(apiResourceConfigSource serverstorag
 
 func (p RESTStorageProvider) v1Storage(apiResourceConfigSource serverstorage.APIResourceConfigSource, restOptionsGetter generic.RESTOptionsGetter) (map[string]rest.Storage, error) {
 	storage := map[string]rest.Storage{}
+
 	// networkpolicies
-	networkPolicyStorage, err := networkpolicystore.NewREST(restOptionsGetter)
+	if resource := "networkpolicies"; apiResourceConfigSource.ResourceEnabled(networkingapiv1.SchemeGroupVersion.WithResource(resource)) {
-	if err != nil {
+		networkPolicyStorage, err := networkpolicystore.NewREST(restOptionsGetter)
-		return storage, err
+		if err != nil {
+			return storage, err
+		}
+		storage[resource] = networkPolicyStorage
 	}
-	storage["networkpolicies"] = networkPolicyStorage
 
 	// ingresses
-	ingressStorage, ingressStatusStorage, err := ingressstore.NewREST(restOptionsGetter)
+	if resource := "ingresses"; apiResourceConfigSource.ResourceEnabled(networkingapiv1.SchemeGroupVersion.WithResource(resource)) {
-	if err != nil {
+		ingressStorage, ingressStatusStorage, err := ingressstore.NewREST(restOptionsGetter)
-		return storage, err
+		if err != nil {
+			return storage, err
+		}
+		storage[resource] = ingressStorage
+		storage[resource+"/status"] = ingressStatusStorage
 	}
-	storage["ingresses"] = ingressStorage
-	storage["ingresses/status"] = ingressStatusStorage
 
 	// ingressclasses
-	ingressClassStorage, err := ingressclassstore.NewREST(restOptionsGetter)
+	if resource := "ingressclasses"; apiResourceConfigSource.ResourceEnabled(networkingapiv1.SchemeGroupVersion.WithResource(resource)) {
-	if err != nil {
+		ingressClassStorage, err := ingressclassstore.NewREST(restOptionsGetter)
-		return storage, err
+		if err != nil {
+			return storage, err
+		}
+		storage[resource] = ingressClassStorage
 	}
-	storage["ingressclasses"] = ingressClassStorage
 
 	return storage, nil
 }

pkg/registry/node/rest/runtime_class.go

@@ -36,28 +36,22 @@ type RESTStorageProvider struct{}
 func (p RESTStorageProvider) NewRESTStorage(apiResourceConfigSource serverstorage.APIResourceConfigSource, restOptionsGetter generic.RESTOptionsGetter) (genericapiserver.APIGroupInfo, bool, error) {
 	apiGroupInfo := genericapiserver.NewDefaultAPIGroupInfo(nodeinternal.GroupName, legacyscheme.Scheme, legacyscheme.ParameterCodec, legacyscheme.Codecs)
 
-	if apiResourceConfigSource.VersionEnabled(nodev1alpha1.SchemeGroupVersion) {
+	if storageMap, err := p.v1alpha1Storage(apiResourceConfigSource, restOptionsGetter); err != nil {
-		if storageMap, err := p.v1alpha1Storage(apiResourceConfigSource, restOptionsGetter); err != nil {
+		return genericapiserver.APIGroupInfo{}, false, err
-			return genericapiserver.APIGroupInfo{}, false, err
+	} else if len(storageMap) > 0 {
-		} else {
+		apiGroupInfo.VersionedResourcesStorageMap[nodev1alpha1.SchemeGroupVersion.Version] = storageMap
-			apiGroupInfo.VersionedResourcesStorageMap[nodev1alpha1.SchemeGroupVersion.Version] = storageMap
-		}
 	}
 
-	if apiResourceConfigSource.VersionEnabled(nodev1beta1.SchemeGroupVersion) {
+	if storageMap, err := p.v1beta1Storage(apiResourceConfigSource, restOptionsGetter); err != nil {
-		if storageMap, err := p.v1beta1Storage(apiResourceConfigSource, restOptionsGetter); err != nil {
+		return genericapiserver.APIGroupInfo{}, false, err
-			return genericapiserver.APIGroupInfo{}, false, err
+	} else if len(storageMap) > 0 {
-		} else {
+		apiGroupInfo.VersionedResourcesStorageMap[nodev1beta1.SchemeGroupVersion.Version] = storageMap
-			apiGroupInfo.VersionedResourcesStorageMap[nodev1beta1.SchemeGroupVersion.Version] = storageMap
-		}
 	}
 
-	if apiResourceConfigSource.VersionEnabled(nodev1.SchemeGroupVersion) {
+	if storageMap, err := p.v1Storage(apiResourceConfigSource, restOptionsGetter); err != nil {
-		if storageMap, err := p.v1Storage(apiResourceConfigSource, restOptionsGetter); err != nil {
+		return genericapiserver.APIGroupInfo{}, false, err
-			return genericapiserver.APIGroupInfo{}, false, err
+	} else if len(storageMap) > 0 {
-		} else {
+		apiGroupInfo.VersionedResourcesStorageMap[nodev1.SchemeGroupVersion.Version] = storageMap
-			apiGroupInfo.VersionedResourcesStorageMap[nodev1.SchemeGroupVersion.Version] = storageMap
-		}
 	}
 
 	return apiGroupInfo, true, nil
@@ -65,35 +59,44 @@ func (p RESTStorageProvider) NewRESTStorage(apiResourceConfigSource serverstorag
 
 func (p RESTStorageProvider) v1alpha1Storage(apiResourceConfigSource serverstorage.APIResourceConfigSource, restOptionsGetter generic.RESTOptionsGetter) (map[string]rest.Storage, error) {
 	storage := map[string]rest.Storage{}
-	s, err := runtimeclassstorage.NewREST(restOptionsGetter)
-	if err != nil {
-		return storage, err
-	}
-	storage["runtimeclasses"] = s
 
-	return storage, err
+	if resource := "runtimeclasses"; apiResourceConfigSource.ResourceEnabled(nodev1alpha1.SchemeGroupVersion.WithResource(resource)) {
+		s, err := runtimeclassstorage.NewREST(restOptionsGetter)
+		if err != nil {
+			return storage, err
+		}
+		storage[resource] = s
+	}
+
+	return storage, nil
 }
 
 func (p RESTStorageProvider) v1beta1Storage(apiResourceConfigSource serverstorage.APIResourceConfigSource, restOptionsGetter generic.RESTOptionsGetter) (map[string]rest.Storage, error) {
 	storage := map[string]rest.Storage{}
-	s, err := runtimeclassstorage.NewREST(restOptionsGetter)
-	if err != nil {
-		return storage, err
-	}
-	storage["runtimeclasses"] = s
 
-	return storage, err
+	if resource := "runtimeclasses"; apiResourceConfigSource.ResourceEnabled(nodev1beta1.SchemeGroupVersion.WithResource(resource)) {
+		s, err := runtimeclassstorage.NewREST(restOptionsGetter)
+		if err != nil {
+			return storage, err
+		}
+		storage[resource] = s
+	}
+
+	return storage, nil
 }
 
 func (p RESTStorageProvider) v1Storage(apiResourceConfigSource serverstorage.APIResourceConfigSource, restOptionsGetter generic.RESTOptionsGetter) (map[string]rest.Storage, error) {
 	storage := map[string]rest.Storage{}
-	s, err := runtimeclassstorage.NewREST(restOptionsGetter)
-	if err != nil {
-		return storage, err
-	}
-	storage["runtimeclasses"] = s
 
-	return storage, err
+	if resource := "runtimeclasses"; apiResourceConfigSource.ResourceEnabled(nodev1.SchemeGroupVersion.WithResource(resource)) {
+		s, err := runtimeclassstorage.NewREST(restOptionsGetter)
+		if err != nil {
+			return storage, err
+		}
+		storage[resource] = s
+	}
+
+	return storage, nil
 }
 
 // GroupName is the group name for the storage provider

pkg/registry/policy/rest/storage_policy.go

@@ -36,54 +36,58 @@ func (p RESTStorageProvider) NewRESTStorage(apiResourceConfigSource serverstorag
 	// If you add a version here, be sure to add an entry in `k8s.io/kubernetes/cmd/kube-apiserver/app/aggregator.go with specific priorities.
 	// TODO refactor the plumbing to provide the information in the APIGroupInfo
 
-	if apiResourceConfigSource.VersionEnabled(policyapiv1beta1.SchemeGroupVersion) {
+	if storageMap, err := p.v1beta1Storage(apiResourceConfigSource, restOptionsGetter); err != nil {
-		if storageMap, err := p.v1beta1Storage(apiResourceConfigSource, restOptionsGetter); err != nil {
+		return genericapiserver.APIGroupInfo{}, false, err
-			return genericapiserver.APIGroupInfo{}, false, err
+	} else if len(storageMap) > 0 {
-		} else {
+		apiGroupInfo.VersionedResourcesStorageMap[policyapiv1beta1.SchemeGroupVersion.Version] = storageMap
-			apiGroupInfo.VersionedResourcesStorageMap[policyapiv1beta1.SchemeGroupVersion.Version] = storageMap
-		}
 	}
 
-	if apiResourceConfigSource.VersionEnabled(policyapiv1.SchemeGroupVersion) {
+	if storageMap, err := p.v1Storage(apiResourceConfigSource, restOptionsGetter); err != nil {
-		if storageMap, err := p.v1Storage(apiResourceConfigSource, restOptionsGetter); err != nil {
+		return genericapiserver.APIGroupInfo{}, false, err
-			return genericapiserver.APIGroupInfo{}, false, err
+	} else if len(storageMap) > 0 {
-		} else {
+		apiGroupInfo.VersionedResourcesStorageMap[policyapiv1.SchemeGroupVersion.Version] = storageMap
-			apiGroupInfo.VersionedResourcesStorageMap[policyapiv1.SchemeGroupVersion.Version] = storageMap
-		}
 	}
+
 	return apiGroupInfo, true, nil
 }
 
 func (p RESTStorageProvider) v1beta1Storage(apiResourceConfigSource serverstorage.APIResourceConfigSource, restOptionsGetter generic.RESTOptionsGetter) (map[string]rest.Storage, error) {
 	storage := map[string]rest.Storage{}
+
 	// poddisruptionbudgets
-	poddisruptionbudgetStorage, poddisruptionbudgetStatusStorage, err := poddisruptionbudgetstore.NewREST(restOptionsGetter)
+	if resource := "poddisruptionbudgets"; apiResourceConfigSource.ResourceEnabled(policyapiv1beta1.SchemeGroupVersion.WithResource(resource)) {
-	if err != nil {
+		poddisruptionbudgetStorage, poddisruptionbudgetStatusStorage, err := poddisruptionbudgetstore.NewREST(restOptionsGetter)
-		return storage, err
+		if err != nil {
+			return storage, err
+		}
+		storage[resource] = poddisruptionbudgetStorage
+		storage[resource+"/status"] = poddisruptionbudgetStatusStorage
 	}
-	storage["poddisruptionbudgets"] = poddisruptionbudgetStorage
-	storage["poddisruptionbudgets/status"] = poddisruptionbudgetStatusStorage
 
-	rest, err := pspstore.NewREST(restOptionsGetter)
+	if resource := "podsecuritypolicies"; apiResourceConfigSource.ResourceEnabled(policyapiv1beta1.SchemeGroupVersion.WithResource(resource)) {
-	if err != nil {
+		rest, err := pspstore.NewREST(restOptionsGetter)
-		return storage, err
+		if err != nil {
+			return storage, err
+		}
+		storage[resource] = rest
 	}
-	storage["podsecuritypolicies"] = rest
 
-	return storage, err
+	return storage, nil
 }
 
 func (p RESTStorageProvider) v1Storage(apiResourceConfigSource serverstorage.APIResourceConfigSource, restOptionsGetter generic.RESTOptionsGetter) (map[string]rest.Storage, error) {
 	storage := map[string]rest.Storage{}
 
-	poddisruptionbudgetStorage, poddisruptionbudgetStatusStorage, err := poddisruptionbudgetstore.NewREST(restOptionsGetter)
+	if resource := "poddisruptionbudgets"; apiResourceConfigSource.ResourceEnabled(policyapiv1.SchemeGroupVersion.WithResource(resource)) {
-	if err != nil {
+		poddisruptionbudgetStorage, poddisruptionbudgetStatusStorage, err := poddisruptionbudgetstore.NewREST(restOptionsGetter)
-		return storage, err
+		if err != nil {
+			return storage, err
+		}
+		storage[resource] = poddisruptionbudgetStorage
+		storage[resource+"/status"] = poddisruptionbudgetStatusStorage
 	}
-	storage["poddisruptionbudgets"] = poddisruptionbudgetStorage
-	storage["poddisruptionbudgets/status"] = poddisruptionbudgetStatusStorage
 
-	return storage, err
+	return storage, nil
 }
 
 func (p RESTStorageProvider) GroupName() string {

pkg/registry/rbac/rest/storage_rbac.go

@@ -70,12 +70,10 @@ func (p RESTStorageProvider) NewRESTStorage(apiResourceConfigSource serverstorag
 	// If you add a version here, be sure to add an entry in `k8s.io/kubernetes/cmd/kube-apiserver/app/aggregator.go with specific priorities.
 	// TODO refactor the plumbing to provide the information in the APIGroupInfo
 
-	if apiResourceConfigSource.VersionEnabled(rbacapiv1.SchemeGroupVersion) {
+	if storageMap, err := p.storage(rbacapiv1.SchemeGroupVersion, apiResourceConfigSource, restOptionsGetter); err != nil {
-		if storageMap, err := p.storage(rbacapiv1.SchemeGroupVersion, apiResourceConfigSource, restOptionsGetter); err != nil {
+		return genericapiserver.APIGroupInfo{}, false, err
-			return genericapiserver.APIGroupInfo{}, false, err
+	} else if len(storageMap) > 0 {
-		} else {
+		apiGroupInfo.VersionedResourcesStorageMap[rbacapiv1.SchemeGroupVersion.Version] = storageMap
-			apiGroupInfo.VersionedResourcesStorageMap[rbacapiv1.SchemeGroupVersion.Version] = storageMap
-		}
 	}
 
 	return apiGroupInfo, true, nil
@@ -83,6 +81,7 @@ func (p RESTStorageProvider) NewRESTStorage(apiResourceConfigSource serverstorag
 
 func (p RESTStorageProvider) storage(version schema.GroupVersion, apiResourceConfigSource serverstorage.APIResourceConfigSource, restOptionsGetter generic.RESTOptionsGetter) (map[string]rest.Storage, error) {
 	storage := map[string]rest.Storage{}
+
 	rolesStorage, err := rolestore.NewREST(restOptionsGetter)
 	if err != nil {
 		return storage, err
@@ -108,16 +107,24 @@ func (p RESTStorageProvider) storage(version schema.GroupVersion, apiResourceCon
 	)
 
 	// roles
-	storage["roles"] = rolepolicybased.NewStorage(rolesStorage, p.Authorizer, authorizationRuleResolver)
+	if resource := "roles"; apiResourceConfigSource.ResourceEnabled(rbacapiv1.SchemeGroupVersion.WithResource(resource)) {
+		storage[resource] = rolepolicybased.NewStorage(rolesStorage, p.Authorizer, authorizationRuleResolver)
+	}
 
 	// rolebindings
-	storage["rolebindings"] = rolebindingpolicybased.NewStorage(roleBindingsStorage, p.Authorizer, authorizationRuleResolver)
+	if resource := "rolebindings"; apiResourceConfigSource.ResourceEnabled(rbacapiv1.SchemeGroupVersion.WithResource(resource)) {
+		storage[resource] = rolebindingpolicybased.NewStorage(roleBindingsStorage, p.Authorizer, authorizationRuleResolver)
+	}
 
 	// clusterroles
-	storage["clusterroles"] = clusterrolepolicybased.NewStorage(clusterRolesStorage, p.Authorizer, authorizationRuleResolver)
+	if resource := "clusterroles"; apiResourceConfigSource.ResourceEnabled(rbacapiv1.SchemeGroupVersion.WithResource(resource)) {
+		storage[resource] = clusterrolepolicybased.NewStorage(clusterRolesStorage, p.Authorizer, authorizationRuleResolver)
+	}
 
 	// clusterrolebindings
-	storage["clusterrolebindings"] = clusterrolebindingpolicybased.NewStorage(clusterRoleBindingsStorage, p.Authorizer, authorizationRuleResolver)
+	if resource := "clusterrolebindings"; apiResourceConfigSource.ResourceEnabled(rbacapiv1.SchemeGroupVersion.WithResource(resource)) {
+		storage[resource] = clusterrolebindingpolicybased.NewStorage(clusterRoleBindingsStorage, p.Authorizer, authorizationRuleResolver)
+	}
 
 	return storage, nil
 }

pkg/registry/scheduling/rest/storage_scheduling.go

@@ -47,23 +47,25 @@ var _ genericapiserver.PostStartHookProvider = RESTStorageProvider{}
 func (p RESTStorageProvider) NewRESTStorage(apiResourceConfigSource serverstorage.APIResourceConfigSource, restOptionsGetter generic.RESTOptionsGetter) (genericapiserver.APIGroupInfo, bool, error) {
 	apiGroupInfo := genericapiserver.NewDefaultAPIGroupInfo(scheduling.GroupName, legacyscheme.Scheme, legacyscheme.ParameterCodec, legacyscheme.Codecs)
 
-	if apiResourceConfigSource.VersionEnabled(schedulingapiv1.SchemeGroupVersion) {
+	if storageMap, err := p.v1Storage(apiResourceConfigSource, restOptionsGetter); err != nil {
-		if storage, err := p.v1Storage(apiResourceConfigSource, restOptionsGetter); err != nil {
+		return genericapiserver.APIGroupInfo{}, false, err
-			return genericapiserver.APIGroupInfo{}, false, err
+	} else if len(storageMap) > 0 {
-		} else {
+		apiGroupInfo.VersionedResourcesStorageMap[schedulingapiv1.SchemeGroupVersion.Version] = storageMap
-			apiGroupInfo.VersionedResourcesStorageMap[schedulingapiv1.SchemeGroupVersion.Version] = storage
-		}
 	}
+
 	return apiGroupInfo, true, nil
 }
 
 func (p RESTStorageProvider) v1Storage(apiResourceConfigSource serverstorage.APIResourceConfigSource, restOptionsGetter generic.RESTOptionsGetter) (map[string]rest.Storage, error) {
 	storage := map[string]rest.Storage{}
+
 	// priorityclasses
-	if priorityClassStorage, err := priorityclassstore.NewREST(restOptionsGetter); err != nil {
+	if resource := "priorityclasses"; apiResourceConfigSource.ResourceEnabled(schedulingapiv1.SchemeGroupVersion.WithResource(resource)) {
-		return nil, err
+		if priorityClassStorage, err := priorityclassstore.NewREST(restOptionsGetter); err != nil {
-	} else {
+			return nil, err
-		storage["priorityclasses"] = priorityClassStorage
+		} else {
+			storage[resource] = priorityClassStorage
+		}
 	}
 
 	return storage, nil

pkg/registry/storage/rest/storage_storage.go

@@ -41,26 +41,20 @@ func (p RESTStorageProvider) NewRESTStorage(apiResourceConfigSource serverstorag
 	// If you add a version here, be sure to add an entry in `k8s.io/kubernetes/cmd/kube-apiserver/app/aggregator.go with specific priorities.
 	// TODO refactor the plumbing to provide the information in the APIGroupInfo
 
-	if apiResourceConfigSource.VersionEnabled(storageapiv1alpha1.SchemeGroupVersion) {
+	if storageMap, err := p.v1alpha1Storage(apiResourceConfigSource, restOptionsGetter); err != nil {
-		if storageMap, err := p.v1alpha1Storage(apiResourceConfigSource, restOptionsGetter); err != nil {
+		return genericapiserver.APIGroupInfo{}, false, err
-			return genericapiserver.APIGroupInfo{}, false, err
+	} else if len(storageMap) > 0 {
-		} else {
+		apiGroupInfo.VersionedResourcesStorageMap[storageapiv1alpha1.SchemeGroupVersion.Version] = storageMap
-			apiGroupInfo.VersionedResourcesStorageMap[storageapiv1alpha1.SchemeGroupVersion.Version] = storageMap
-		}
 	}
-	if apiResourceConfigSource.VersionEnabled(storageapiv1beta1.SchemeGroupVersion) {
+	if storageMap, err := p.v1beta1Storage(apiResourceConfigSource, restOptionsGetter); err != nil {
-		if storageMap, err := p.v1beta1Storage(apiResourceConfigSource, restOptionsGetter); err != nil {
+		return genericapiserver.APIGroupInfo{}, false, err
-			return genericapiserver.APIGroupInfo{}, false, err
+	} else if len(storageMap) > 0 {
-		} else {
+		apiGroupInfo.VersionedResourcesStorageMap[storageapiv1beta1.SchemeGroupVersion.Version] = storageMap
-			apiGroupInfo.VersionedResourcesStorageMap[storageapiv1beta1.SchemeGroupVersion.Version] = storageMap
-		}
 	}
-	if apiResourceConfigSource.VersionEnabled(storageapiv1.SchemeGroupVersion) {
+	if storageMap, err := p.v1Storage(apiResourceConfigSource, restOptionsGetter); err != nil {
-		if storageMap, err := p.v1Storage(apiResourceConfigSource, restOptionsGetter); err != nil {
+		return genericapiserver.APIGroupInfo{}, false, err
-			return genericapiserver.APIGroupInfo{}, false, err
+	} else if len(storageMap) > 0 {
-		} else {
+		apiGroupInfo.VersionedResourcesStorageMap[storageapiv1.SchemeGroupVersion.Version] = storageMap
-			apiGroupInfo.VersionedResourcesStorageMap[storageapiv1.SchemeGroupVersion.Version] = storageMap
-		}
 	}
 
 	return apiGroupInfo, true, nil
@@ -70,11 +64,13 @@ func (p RESTStorageProvider) v1alpha1Storage(apiResourceConfigSource serverstora
 	storage := map[string]rest.Storage{}
 
 	// register csistoragecapacities
-	csiStorageStorage, err := csistoragecapacitystore.NewStorage(restOptionsGetter)
+	if resource := "csistoragecapacities"; apiResourceConfigSource.ResourceEnabled(storageapiv1alpha1.SchemeGroupVersion.WithResource(resource)) {
-	if err != nil {
+		csiStorageStorage, err := csistoragecapacitystore.NewStorage(restOptionsGetter)
-		return storage, err
+		if err != nil {
+			return storage, err
+		}
+		storage[resource] = csiStorageStorage.CSIStorageCapacity
 	}
-	storage["csistoragecapacities"] = csiStorageStorage.CSIStorageCapacity
 
 	return storage, nil
 }
@@ -83,11 +79,13 @@ func (p RESTStorageProvider) v1beta1Storage(apiResourceConfigSource serverstorag
 	storage := map[string]rest.Storage{}
 
 	// register csistoragecapacities
-	csiStorageStorage, err := csistoragecapacitystore.NewStorage(restOptionsGetter)
+	if resource := "csistoragecapacities"; apiResourceConfigSource.ResourceEnabled(storageapiv1beta1.SchemeGroupVersion.WithResource(resource)) {
-	if err != nil {
+		csiStorageStorage, err := csistoragecapacitystore.NewStorage(restOptionsGetter)
-		return storage, err
+		if err != nil {
+			return storage, err
+		}
+		storage[resource] = csiStorageStorage.CSIStorageCapacity
 	}
-	storage["csistoragecapacities"] = csiStorageStorage.CSIStorageCapacity
 
 	return storage, nil
 }
@@ -102,28 +100,36 @@ func (p RESTStorageProvider) v1Storage(apiResourceConfigSource serverstorage.API
 		return nil, err
 	}
 
-	storage := map[string]rest.Storage{
+	storage := map[string]rest.Storage{}
-		// storageclasses
-		"storageclasses": storageClassStorage,
 
-		// volumeattachments
+	// storageclasses
-		"volumeattachments":        volumeAttachmentStorage.VolumeAttachment,
+	if resource := "storageclasses"; apiResourceConfigSource.ResourceEnabled(storageapiv1.SchemeGroupVersion.WithResource(resource)) {
-		"volumeattachments/status": volumeAttachmentStorage.Status,
+		storage[resource] = storageClassStorage
+	}
+
+	// volumeattachments
+	if resource := "volumeattachments"; apiResourceConfigSource.ResourceEnabled(storageapiv1.SchemeGroupVersion.WithResource(resource)) {
+		storage[resource] = volumeAttachmentStorage.VolumeAttachment
+		storage[resource+"/status"] = volumeAttachmentStorage.Status
 	}
 
 	// register csinodes
-	csiNodeStorage, err := csinodestore.NewStorage(restOptionsGetter)
+	if resource := "csinodes"; apiResourceConfigSource.ResourceEnabled(storageapiv1.SchemeGroupVersion.WithResource(resource)) {
-	if err != nil {
+		csiNodeStorage, err := csinodestore.NewStorage(restOptionsGetter)
-		return nil, err
+		if err != nil {
+			return nil, err
+		}
+		storage[resource] = csiNodeStorage.CSINode
 	}
-	storage["csinodes"] = csiNodeStorage.CSINode
 
 	// register csidrivers
-	csiDriverStorage, err := csidriverstore.NewStorage(restOptionsGetter)
+	if resource := "csidrivers"; apiResourceConfigSource.ResourceEnabled(storageapiv1.SchemeGroupVersion.WithResource(resource)) {
-	if err != nil {
+		csiDriverStorage, err := csidriverstore.NewStorage(restOptionsGetter)
-		return storage, err
+		if err != nil {
+			return storage, err
+		}
+		storage[resource] = csiDriverStorage.CSIDriver
 	}
-	storage["csidrivers"] = csiDriverStorage.CSIDriver
 
 	return storage, nil
 }

staging/src/k8s.io/apiextensions-apiserver/pkg/apiserver/apiserver.go

@@ -149,16 +149,17 @@ func (c completedConfig) New(delegationTarget genericapiserver.DelegationTarget)
 
 	apiResourceConfig := c.GenericConfig.MergedResourceConfig
 	apiGroupInfo := genericapiserver.NewDefaultAPIGroupInfo(apiextensions.GroupName, Scheme, metav1.ParameterCodec, Codecs)
-	if apiResourceConfig.VersionEnabled(v1.SchemeGroupVersion) {
+	storage := map[string]rest.Storage{}
-		storage := map[string]rest.Storage{}
+	// customresourcedefinitions
-		// 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["customresourcedefinitions"] = customResourceDefinitionStorage
+		storage[resource] = customResourceDefinitionStorage
-		storage["customresourcedefinitions/status"] = customresourcedefinition.NewStatusREST(Scheme, customResourceDefinitionStorage)
+		storage[resource+"/status"] = customresourcedefinition.NewStatusREST(Scheme, customResourceDefinitionStorage)
-
+	}
+	if len(storage) > 0 {
 		apiGroupInfo.VersionedResourcesStorageMap[v1.SchemeGroupVersion.Version] = storage
 	}
 

staging/src/k8s.io/apiserver/pkg/server/genericapiserver.go

@@ -539,7 +539,10 @@ func (s *GenericAPIServer) installAPIResources(apiPrefix string, apiGroupInfo *A
 			continue
 		}
 
-		apiGroupVersion := s.getAPIGroupVersion(apiGroupInfo, groupVersion, apiPrefix)
+		apiGroupVersion, err := s.getAPIGroupVersion(apiGroupInfo, groupVersion, apiPrefix)
+		if err != nil {
+			return err
+		}
 		if apiGroupInfo.OptionsExternalVersion != nil {
 			apiGroupVersion.OptionsExternalVersion = apiGroupInfo.OptionsExternalVersion
 		}
@@ -652,15 +655,18 @@ func (s *GenericAPIServer) InstallAPIGroup(apiGroupInfo *APIGroupInfo) error {
 	return s.InstallAPIGroups(apiGroupInfo)
 }
 
-func (s *GenericAPIServer) getAPIGroupVersion(apiGroupInfo *APIGroupInfo, groupVersion schema.GroupVersion, apiPrefix string) *genericapi.APIGroupVersion {
+func (s *GenericAPIServer) getAPIGroupVersion(apiGroupInfo *APIGroupInfo, groupVersion schema.GroupVersion, apiPrefix string) (*genericapi.APIGroupVersion, error) {
 	storage := make(map[string]rest.Storage)
 	for k, v := range apiGroupInfo.VersionedResourcesStorageMap[groupVersion.Version] {
-		storage[strings.ToLower(k)] = v
+		if strings.ToLower(k) != k {
+			return nil, fmt.Errorf("resource names must be lowercase only, not %q", k)
+		}
+		storage[k] = v
 	}
 	version := s.newAPIGroupVersion(apiGroupInfo, groupVersion)
 	version.Root = apiPrefix
 	version.Storage = storage
-	return version
+	return version, nil
 }
 
 func (s *GenericAPIServer) newAPIGroupVersion(apiGroupInfo *APIGroupInfo, groupVersion schema.GroupVersion) *genericapi.APIGroupVersion {

staging/src/k8s.io/apiserver/pkg/server/storage/resource_config.go

@@ -22,7 +22,6 @@ import (
 
 // APIResourceConfigSource is the interface to determine which groups and versions are enabled
 type APIResourceConfigSource interface {
-	VersionEnabled(version schema.GroupVersion) bool
 	ResourceEnabled(resource schema.GroupVersionResource) bool
 	AnyResourceForGroupEnabled(group string) bool
 }

staging/src/k8s.io/kube-aggregator/pkg/registry/apiservice/rest/storage_apiservice.go

@@ -33,11 +33,15 @@ import (
 func NewRESTStorage(apiResourceConfigSource serverstorage.APIResourceConfigSource, restOptionsGetter generic.RESTOptionsGetter, shouldServeBeta bool) genericapiserver.APIGroupInfo {
 	apiGroupInfo := genericapiserver.NewDefaultAPIGroupInfo(apiregistration.GroupName, aggregatorscheme.Scheme, metav1.ParameterCodec, aggregatorscheme.Codecs)
 
-	if apiResourceConfigSource.VersionEnabled(v1.SchemeGroupVersion) {
+	storage := map[string]rest.Storage{}
-		storage := map[string]rest.Storage{}
+
+	if resource := "apiservices"; apiResourceConfigSource.ResourceEnabled(v1.SchemeGroupVersion.WithResource(resource)) {
 		apiServiceREST := apiservicestorage.NewREST(aggregatorscheme.Scheme, restOptionsGetter)
-		storage["apiservices"] = apiServiceREST
+		storage[resource] = apiServiceREST
-		storage["apiservices/status"] = apiservicestorage.NewStatusREST(aggregatorscheme.Scheme, apiServiceREST)
+		storage[resource+"/status"] = apiservicestorage.NewStatusREST(aggregatorscheme.Scheme, apiServiceREST)
+	}
+
+	if len(storage) > 0 {
 		apiGroupInfo.VersionedResourcesStorageMap["v1"] = storage
 	}