rebase: bump k8s.io/kubernetes from 1.26.2 to 1.27.2

Bumps [k8s.io/kubernetes](https://github.com/kubernetes/kubernetes) from 1.26.2 to 1.27.2.
- [Release notes](https://github.com/kubernetes/kubernetes/releases)
- [Commits](https://github.com/kubernetes/kubernetes/compare/v1.26.2...v1.27.2)

---
updated-dependencies:
- dependency-name: k8s.io/kubernetes
  dependency-type: direct:production
  update-type: version-update:semver-minor
...

Signed-off-by: dependabot[bot] <support@github.com>

vendor/k8s.io/controller-manager/options/debugging.go

@@ -0,0 +1,72 @@
+/*
+Copyright 2018 The Kubernetes Authors.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+package options
+
+import (
+	"github.com/spf13/pflag"
+
+	componentbaseconfig "k8s.io/component-base/config"
+)
+
+// DebuggingOptions holds the Debugging options.
+type DebuggingOptions struct {
+	*componentbaseconfig.DebuggingConfiguration
+}
+
+// RecommendedDebuggingOptions returns the currently recommended debugging options.  These are subject to change
+// between releases as we add options and decide which features should be exposed or not by default.
+func RecommendedDebuggingOptions() *DebuggingOptions {
+	return &DebuggingOptions{
+		DebuggingConfiguration: &componentbaseconfig.DebuggingConfiguration{
+			EnableProfiling: true, // profile debugging is cheap to have exposed and standard on kube binaries
+		},
+	}
+}
+
+// AddFlags adds flags related to debugging for controller manager to the specified FlagSet.
+func (o *DebuggingOptions) AddFlags(fs *pflag.FlagSet) {
+	if o == nil {
+		return
+	}
+
+	fs.BoolVar(&o.EnableProfiling, "profiling", o.EnableProfiling,
+		"Enable profiling via web interface host:port/debug/pprof/")
+	fs.BoolVar(&o.EnableContentionProfiling, "contention-profiling", o.EnableContentionProfiling,
+		"Enable lock contention profiling, if profiling is enabled")
+}
+
+// ApplyTo fills up Debugging config with options.
+func (o *DebuggingOptions) ApplyTo(cfg *componentbaseconfig.DebuggingConfiguration) error {
+	if o == nil {
+		return nil
+	}
+
+	cfg.EnableProfiling = o.EnableProfiling
+	cfg.EnableContentionProfiling = o.EnableContentionProfiling
+
+	return nil
+}
+
+// Validate checks validation of DebuggingOptions.
+func (o *DebuggingOptions) Validate() []error {
+	if o == nil {
+		return nil
+	}
+
+	errs := []error{}
+	return errs
+}

vendor/k8s.io/controller-manager/options/generic.go

@@ -0,0 +1,117 @@
+/*
+Copyright 2018 The Kubernetes Authors.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+package options
+
+import (
+	"fmt"
+	"strings"
+
+	"k8s.io/apimachinery/pkg/util/sets"
+	cliflag "k8s.io/component-base/cli/flag"
+	"k8s.io/component-base/config/options"
+	cmconfig "k8s.io/controller-manager/config"
+	migration "k8s.io/controller-manager/pkg/leadermigration/options"
+)
+
+// GenericControllerManagerConfigurationOptions holds the options which are generic.
+type GenericControllerManagerConfigurationOptions struct {
+	*cmconfig.GenericControllerManagerConfiguration
+	Debugging *DebuggingOptions
+	// LeaderMigration is the options for leader migration, a nil indicates default options should be applied.
+	LeaderMigration *migration.LeaderMigrationOptions
+}
+
+// NewGenericControllerManagerConfigurationOptions returns generic configuration default values for both
+// the kube-controller-manager and the cloud-contoller-manager. Any common changes should
+// be made here. Any individual changes should be made in that controller.
+func NewGenericControllerManagerConfigurationOptions(cfg *cmconfig.GenericControllerManagerConfiguration) *GenericControllerManagerConfigurationOptions {
+	o := &GenericControllerManagerConfigurationOptions{
+		GenericControllerManagerConfiguration: cfg,
+		Debugging:                             RecommendedDebuggingOptions(),
+		LeaderMigration:                       &migration.LeaderMigrationOptions{},
+	}
+
+	return o
+}
+
+// AddFlags adds flags related to generic for controller manager to the specified FlagSet.
+func (o *GenericControllerManagerConfigurationOptions) AddFlags(fss *cliflag.NamedFlagSets, allControllers, disabledByDefaultControllers []string) {
+	if o == nil {
+		return
+	}
+
+	o.Debugging.AddFlags(fss.FlagSet("debugging"))
+	o.LeaderMigration.AddFlags(fss.FlagSet("leader-migration"))
+	genericfs := fss.FlagSet("generic")
+	genericfs.DurationVar(&o.MinResyncPeriod.Duration, "min-resync-period", o.MinResyncPeriod.Duration, "The resync period in reflectors will be random between MinResyncPeriod and 2*MinResyncPeriod.")
+	genericfs.StringVar(&o.ClientConnection.ContentType, "kube-api-content-type", o.ClientConnection.ContentType, "Content type of requests sent to apiserver.")
+	genericfs.Float32Var(&o.ClientConnection.QPS, "kube-api-qps", o.ClientConnection.QPS, "QPS to use while talking with kubernetes apiserver.")
+	genericfs.Int32Var(&o.ClientConnection.Burst, "kube-api-burst", o.ClientConnection.Burst, "Burst to use while talking with kubernetes apiserver.")
+	genericfs.DurationVar(&o.ControllerStartInterval.Duration, "controller-start-interval", o.ControllerStartInterval.Duration, "Interval between starting controller managers.")
+	genericfs.StringSliceVar(&o.Controllers, "controllers", o.Controllers, fmt.Sprintf(""+
+		"A list of controllers to enable. '*' enables all on-by-default controllers, 'foo' enables the controller "+
+		"named 'foo', '-foo' disables the controller named 'foo'.\nAll controllers: %s\nDisabled-by-default controllers: %s",
+		strings.Join(allControllers, ", "), strings.Join(disabledByDefaultControllers, ", ")))
+
+	options.BindLeaderElectionFlags(&o.LeaderElection, genericfs)
+}
+
+// ApplyTo fills up generic config with options.
+func (o *GenericControllerManagerConfigurationOptions) ApplyTo(cfg *cmconfig.GenericControllerManagerConfiguration) error {
+	if o == nil {
+		return nil
+	}
+
+	if err := o.Debugging.ApplyTo(&cfg.Debugging); err != nil {
+		return err
+	}
+	if err := o.LeaderMigration.ApplyTo(cfg); err != nil {
+		return err
+	}
+	cfg.Port = o.Port
+	cfg.Address = o.Address
+	cfg.MinResyncPeriod = o.MinResyncPeriod
+	cfg.ClientConnection = o.ClientConnection
+	cfg.ControllerStartInterval = o.ControllerStartInterval
+	cfg.LeaderElection = o.LeaderElection
+	cfg.Controllers = o.Controllers
+
+	return nil
+}
+
+// Validate checks validation of GenericOptions.
+func (o *GenericControllerManagerConfigurationOptions) Validate(allControllers []string, disabledByDefaultControllers []string) []error {
+	if o == nil {
+		return nil
+	}
+
+	errs := []error{}
+	errs = append(errs, o.Debugging.Validate()...)
+
+	allControllersSet := sets.NewString(allControllers...)
+	for _, controller := range o.Controllers {
+		if controller == "*" {
+			continue
+		}
+		controller = strings.TrimPrefix(controller, "-")
+		if !allControllersSet.Has(controller) {
+			errs = append(errs, fmt.Errorf("%q is not in the list of known controllers", controller))
+		}
+	}
+
+	return errs
+}